2026-06-01 21:27:57 +01:00
using System.Net.WebSockets ;
2026-06-02 00:47:25 +01:00
using System.Diagnostics ;
2026-06-01 21:27:57 +01:00
using System.Text ;
using System.Text.Json ;
using Mimir.Runtime.Synchronization ;
var options = MimirWellOptions . Parse ( args ) ;
var runtimeConfig = MimirRuntimeConfiguration . Load ( ) ;
using var hub = new MimirSynchronizationHub ( runtimeConfig . Settings ) ;
var sourceErrors = new List < object > ( ) ;
foreach ( var factory in runtimeConfig . SourceFactories )
{
try
{
var source = factory . Create ( ) ;
if ( source = = null )
{
sourceErrors . Add ( new { factory . Descriptor . SourceId , status = "not-created" } ) ;
continue ;
}
hub . AddSource ( source ) ;
}
catch ( Exception ex )
{
sourceErrors . Add ( new
{
factory . Descriptor . SourceId ,
status = "create-error" ,
errorType = ex . GetType ( ) . Name ,
ex . Message ,
} ) ;
}
}
using var stopping = new CancellationTokenSource ( ) ;
if ( options . Seconds > 0 )
{
stopping . CancelAfter ( TimeSpan . FromSeconds ( options . Seconds ) ) ;
}
Console . CancelKeyPress + = ( _ , eventArgs ) = >
{
eventArgs . Cancel = true ;
stopping . Cancel ( ) ;
} ;
await using var publisher = new MimirWellPublisher ( options . PublishUrl ) ;
await publisher . ConnectAsync ( stopping . Token ) . ConfigureAwait ( false ) ;
var sequence = 0L ;
2026-06-02 00:07:21 +01:00
var captureSequence = 0L ;
2026-06-01 21:27:57 +01:00
var startedAt = DateTimeOffset . UtcNow ;
var nextPublish = DateTimeOffset . MinValue ;
2026-06-02 00:07:21 +01:00
var nextCapture = DateTimeOffset . MinValue ;
2026-06-01 21:27:57 +01:00
var nextSync = DateTimeOffset . MinValue ;
2026-06-01 23:52:17 +01:00
var nextVisualCalibration = DateTimeOffset . MinValue ;
2026-06-02 00:47:25 +01:00
var frameDegradedCount = 0L ;
var nextFrameDegradedLog = DateTimeOffset . MinValue ;
var streamTelemetry = new MimirWellStreamTelemetry ( ) ;
2026-06-01 21:27:57 +01:00
var presentation = new MimirPresentationControlState ( ) ;
2026-06-01 23:52:17 +01:00
var exposureController = new MimirCameraExposureController ( new MimirCameraExposureControlOptions (
options . VisualCalibrationEnabled ,
options . VisualExpectedLedCount ,
options . VisualMinimumLuma ,
options . VisualSettingSeconds ,
options . VisualResweepSeconds ) ) ;
2026-06-01 21:27:57 +01:00
Console . Error . WriteLine ( $"Mimir Well publishing to {options.PublishUrl}" ) ;
Console . Error . WriteLine ( $"Mimir Well sources={runtimeConfig.SourceFactories.Count} buffers={hub.Buffers.Buffers.Count}" ) ;
while ( ! stopping . IsCancellationRequested )
{
2026-06-02 00:47:25 +01:00
var pollStopwatch = Stopwatch . StartNew ( ) ;
var consumedSamples = hub . PollSources ( options . MaxSamplesPerSource ) ;
pollStopwatch . Stop ( ) ;
streamTelemetry . ObservePoll ( consumedSamples , pollStopwatch . Elapsed ) ;
2026-06-01 21:27:57 +01:00
var now = DateTimeOffset . UtcNow ;
if ( now > = nextSync )
{
if ( ! string . IsNullOrWhiteSpace ( runtimeConfig . Settings . Audio . ReferenceSourceId ) )
{
hub . AnalyzeAudioSynchronizationStep (
runtimeConfig . Settings . Audio . ReferenceSourceId ,
runtimeConfig . Settings . Audio . Mode ,
options . SyncCandidatesPerStep ) ;
hub . AnalyzeComplexContourSynchronizationStep (
runtimeConfig . Settings . Audio . ReferenceSourceId ,
( now - startedAt ) . TotalSeconds ,
options . SyncCandidatesPerStep ) ;
}
hub . UpdateBioacousticProbeSchedule ( NowNs ( ) ) ;
nextSync = now + TimeSpan . FromMilliseconds ( options . SyncIntervalMs ) ;
}
2026-06-01 23:52:17 +01:00
if ( now > = nextVisualCalibration )
{
exposureController . Update ( now , hub . Buffers . Buffers , hub . CameraExposureGainActuators ) ;
nextVisualCalibration = now + TimeSpan . FromMilliseconds ( options . VisualCalibrationIntervalMs ) ;
}
2026-06-01 21:27:57 +01:00
if ( now > = nextPublish )
{
presentation . SyncFromBuffers ( hub . Buffers . Buffers ) ;
2026-06-02 00:47:25 +01:00
var frameResult = BuildFrameOrEmpty ( hub , TimeSpan . FromMilliseconds ( options . PresentationDelayMs ) ) ;
if ( ! string . IsNullOrWhiteSpace ( frameResult . DegradedReason ) )
{
frameDegradedCount + + ;
if ( now > = nextFrameDegradedLog )
{
Console . Error . WriteLine (
$"mimir-well synchronized-frame degraded count={frameDegradedCount} reason={frameResult.DegradedReason}" ) ;
nextFrameDegradedLog = now + TimeSpan . FromSeconds ( 5 ) ;
}
}
var frame = frameResult . Frame ;
2026-06-01 21:27:57 +01:00
var snapshot = MimirWellSnapshot . Build (
options ,
runtimeConfig ,
hub ,
presentation ,
2026-06-02 00:47:25 +01:00
frameResult ,
2026-06-01 23:52:17 +01:00
exposureController . Statuses ,
2026-06-01 21:27:57 +01:00
sourceErrors ,
2026-06-02 00:47:25 +01:00
streamTelemetry . Snapshot ( now , subscribersAreExternal : true ) ,
2026-06-01 21:27:57 +01:00
+ + sequence ,
startedAt ) ;
2026-06-02 00:47:25 +01:00
streamTelemetry . ObservePublish (
await publisher . PublishAsync ( snapshot , "mimir.well_snapshot.v1" , stopping . Token ) . ConfigureAwait ( false ) ) ;
2026-06-02 00:07:21 +01:00
if ( options . CapturePagesEnabled & & now > = nextCapture )
{
var capturePage = MimirWellCapturePage . Build (
options ,
presentation ,
2026-06-02 00:47:25 +01:00
frameResult ,
2026-06-02 00:25:19 +01:00
hub . Buffers . Buffers ,
2026-06-02 00:07:21 +01:00
+ + captureSequence ,
startedAt ) ;
2026-06-02 00:47:25 +01:00
streamTelemetry . ObservePublish (
await publisher . PublishAsync ( capturePage , "mimir.well_capture_page.v1" , stopping . Token ) . ConfigureAwait ( false ) ) ;
2026-06-02 00:07:21 +01:00
nextCapture = now + TimeSpan . FromMilliseconds ( options . CaptureIntervalMs ) ;
}
2026-06-01 21:27:57 +01:00
if ( sequence % Math . Max ( 1 , options . MeterEvery ) = = 0 )
{
Console . Error . WriteLine (
$"mimir-well sequence={sequence} ingested={hub.IngestedSamples} ready={frame.Slices.Count(slice => slice.Status == MimirSynchronizedSliceStatus.Ready)}/{frame.Slices.Count}" ) ;
}
nextPublish = now + TimeSpan . FromMilliseconds ( options . PublishIntervalMs ) ;
}
try
{
await Task . Delay ( Math . Max ( 1 , options . PollMs ) , stopping . Token ) . ConfigureAwait ( false ) ;
}
catch ( OperationCanceledException )
{
break ;
}
}
Console . Error . WriteLine ( $"Mimir Well complete sequence={sequence} ingested={hub.IngestedSamples}" ) ;
static long NowNs ( ) = > DateTimeOffset . UtcNow . ToUnixTimeMilliseconds ( ) * 1_000_000L ;
2026-06-02 00:47:25 +01:00
static MimirWellFrameBuildResult BuildFrameOrEmpty ( MimirSynchronizationHub hub , TimeSpan presentationDelay )
2026-06-01 21:27:57 +01:00
{
try
{
2026-06-02 00:47:25 +01:00
return new MimirWellFrameBuildResult (
hub . BuildSynchronizedBufferFrame ( presentationDelay ) ,
"" ,
"" ) ;
2026-06-01 21:27:57 +01:00
}
catch ( ArgumentException ex )
{
2026-06-02 00:47:25 +01:00
return new MimirWellFrameBuildResult (
new MimirSynchronizedBufferFrame ( 0 , 0 , 0 , presentationDelay , [ ] ) ,
ex . GetType ( ) . Name ,
ex . Message ) ;
2026-06-01 21:27:57 +01:00
}
catch ( OverflowException ex )
{
2026-06-02 00:47:25 +01:00
return new MimirWellFrameBuildResult (
new MimirSynchronizedBufferFrame ( 0 , 0 , 0 , presentationDelay , [ ] ) ,
ex . GetType ( ) . Name ,
ex . Message ) ;
}
}
internal sealed record MimirWellFrameBuildResult (
MimirSynchronizedBufferFrame Frame ,
string DegradedKind ,
string DegradedReason ) ;
internal sealed record MimirWellPublishReceipt (
string Document ,
int ByteLength ,
double SerializeMilliseconds ,
double SendMilliseconds ,
double TotalMilliseconds ) ;
internal sealed class MimirWellStreamTelemetry
{
private long pollIterations ;
private long consumedSamples ;
private long zeroPollIterations ;
private double maxPollMilliseconds ;
private double totalPollMilliseconds ;
private long publishedDocuments ;
private long publishedBytes ;
private double maxPublishMilliseconds ;
private double totalPublishMilliseconds ;
private string lastPublishedDocument = "" ;
private int lastPublishedBytes ;
private double lastPublishMilliseconds ;
public void ObservePoll ( int consumed , TimeSpan elapsed )
{
pollIterations + + ;
consumedSamples + = Math . Max ( 0 , consumed ) ;
if ( consumed < = 0 )
{
zeroPollIterations + + ;
}
var milliseconds = elapsed . TotalMilliseconds ;
totalPollMilliseconds + = milliseconds ;
maxPollMilliseconds = Math . Max ( maxPollMilliseconds , milliseconds ) ;
}
public void ObservePublish ( MimirWellPublishReceipt receipt )
{
publishedDocuments + + ;
publishedBytes + = receipt . ByteLength ;
totalPublishMilliseconds + = receipt . TotalMilliseconds ;
maxPublishMilliseconds = Math . Max ( maxPublishMilliseconds , receipt . TotalMilliseconds ) ;
lastPublishedDocument = receipt . Document ;
lastPublishedBytes = receipt . ByteLength ;
lastPublishMilliseconds = receipt . TotalMilliseconds ;
2026-06-01 21:27:57 +01:00
}
2026-06-02 00:47:25 +01:00
public object Snapshot ( DateTimeOffset now , bool subscribersAreExternal ) = > new
{
document = "mimir.well_stream_pressure.v1" ,
status = "transitional-websocket-json" ,
authority = "Mimir.Well observes producer pressure; CultMesh streaming organ should own durable body lanes." ,
wallClockUtc = now . ToString ( "O" ) ,
poll = new
{
iterations = pollIterations ,
consumedSamples ,
zeroPollIterations ,
averageMilliseconds = pollIterations = = 0 ? 0.0 : totalPollMilliseconds / pollIterations ,
maxMilliseconds = maxPollMilliseconds ,
} ,
publish = new
{
documents = publishedDocuments ,
bytes = publishedBytes ,
averageMilliseconds = publishedDocuments = = 0 ? 0.0 : totalPublishMilliseconds / publishedDocuments ,
maxMilliseconds = maxPublishMilliseconds ,
lastDocument = lastPublishedDocument ,
lastBytes = lastPublishedBytes ,
lastMilliseconds = lastPublishMilliseconds ,
subscribersAreExternal ,
} ,
nextOrgan = new
{
controlLane = "CultMesh typed state and compact stream cursors" ,
bodyLane = "CultCache page/shard append stream with refs, hashes, and backpressure" ,
realtimeLane = "loss-aware latest-state observation stream for dashboards" ,
} ,
} ;
2026-06-01 21:27:57 +01:00
}
internal sealed record MimirWellOptions (
Uri PublishUrl ,
string NodeId ,
double Seconds ,
int PollMs ,
int PublishIntervalMs ,
int SyncIntervalMs ,
int PresentationDelayMs ,
int MaxSamplesPerSource ,
int SyncCandidatesPerStep ,
2026-06-01 23:52:17 +01:00
bool VisualCalibrationEnabled ,
int VisualCalibrationIntervalMs ,
int VisualExpectedLedCount ,
double VisualMinimumLuma ,
double VisualSettingSeconds ,
double VisualResweepSeconds ,
2026-06-02 00:07:21 +01:00
bool CapturePagesEnabled ,
int CaptureIntervalMs ,
int CaptureMaxBodyBytes ,
bool CaptureInlineBodies ,
2026-06-01 21:27:57 +01:00
int MeterEvery )
{
public static MimirWellOptions Parse ( string [ ] args ) = > new (
new Uri ( ParseString ( args , "--publish-url" , "ws://127.0.0.1:8796/eve/periwinkle" ) ) ,
ParseString ( args , "--node-id" , Environment . MachineName . ToLowerInvariant ( ) ) ,
ParseDouble ( args , "--seconds" , 0.0 ) ,
ParseInt ( args , "--poll-ms" , 5 ) ,
ParseInt ( args , "--publish-ms" , 250 ) ,
ParseInt ( args , "--sync-ms" , 250 ) ,
ParseInt ( args , "--presentation-delay-ms" , 2500 ) ,
ParseInt ( args , "--max-samples-per-source" , 4 ) ,
ParseInt ( args , "--sync-candidates" , 1 ) ,
2026-06-01 23:52:17 +01:00
ParseBool ( args , "--visual-calibration" , true ) ,
ParseInt ( args , "--visual-calibration-ms" , 250 ) ,
ParseInt ( args , "--visual-expected-leds" , 38 ) ,
ParseDouble ( args , "--visual-minimum-luma" , 0.55 ) ,
ParseDouble ( args , "--visual-setting-seconds" , 0.75 ) ,
ParseDouble ( args , "--visual-resweep-seconds" , 12.0 ) ,
2026-06-02 00:07:21 +01:00
ParseBool ( args , "--capture-pages" , true ) ,
ParseInt ( args , "--capture-ms" , 250 ) ,
ParseInt ( args , "--capture-max-body-bytes" , 4 * 1024 * 1024 ) ,
ParseBool ( args , "--capture-inline-bodies" , true ) ,
2026-06-01 21:27:57 +01:00
ParseInt ( args , "--meter-every" , 20 ) ) ;
private static string ParseString ( IReadOnlyList < string > args , string name , string fallback )
{
for ( var index = 0 ; index < args . Count - 1 ; index + + )
{
if ( string . Equals ( args [ index ] , name , StringComparison . OrdinalIgnoreCase ) )
{
return args [ index + 1 ] ;
}
}
return fallback ;
}
private static int ParseInt ( IReadOnlyList < string > args , string name , int fallback ) = >
int . TryParse ( ParseString ( args , name , "" ) , out var value ) ? value : fallback ;
private static double ParseDouble ( IReadOnlyList < string > args , string name , double fallback ) = >
double . TryParse ( ParseString ( args , name , "" ) , out var value ) ? value : fallback ;
2026-06-01 23:52:17 +01:00
private static bool ParseBool ( IReadOnlyList < string > args , string name , bool fallback )
{
for ( var index = 0 ; index < args . Count ; index + + )
{
if ( ! string . Equals ( args [ index ] , name , StringComparison . OrdinalIgnoreCase ) )
{
continue ;
}
if ( index = = args . Count - 1 | |
args [ index + 1 ] . StartsWith ( "--" , StringComparison . Ordinal ) )
{
return true ;
}
return bool . TryParse ( args [ index + 1 ] , out var value ) ? value : fallback ;
}
return fallback ;
}
2026-06-01 21:27:57 +01:00
}
internal sealed class MimirWellPublisher ( Uri url ) : IAsyncDisposable
{
private readonly ClientWebSocket socket = new ( ) ;
public async Task ConnectAsync ( CancellationToken stopping )
{
await socket . ConnectAsync ( url , stopping ) . ConfigureAwait ( false ) ;
}
2026-06-02 00:47:25 +01:00
public async Task < MimirWellPublishReceipt > PublishAsync (
object document ,
string documentName ,
CancellationToken stopping )
2026-06-01 21:27:57 +01:00
{
2026-06-02 00:47:25 +01:00
var stopwatch = Stopwatch . StartNew ( ) ;
2026-06-01 21:27:57 +01:00
var json = JsonSerializer . Serialize ( document ) ;
var bytes = Encoding . UTF8 . GetBytes ( json ) ;
2026-06-02 00:47:25 +01:00
var serializeMilliseconds = stopwatch . Elapsed . TotalMilliseconds ;
stopwatch . Restart ( ) ;
2026-06-01 21:27:57 +01:00
await socket . SendAsync ( bytes , WebSocketMessageType . Text , endOfMessage : true , stopping ) . ConfigureAwait ( false ) ;
2026-06-02 00:47:25 +01:00
stopwatch . Stop ( ) ;
return new MimirWellPublishReceipt (
documentName ,
bytes . Length ,
serializeMilliseconds ,
stopwatch . Elapsed . TotalMilliseconds ,
serializeMilliseconds + stopwatch . Elapsed . TotalMilliseconds ) ;
2026-06-01 21:27:57 +01:00
}
public async ValueTask DisposeAsync ( )
{
if ( socket . State = = WebSocketState . Open )
{
using var cts = new CancellationTokenSource ( TimeSpan . FromSeconds ( 1 ) ) ;
try
{
await socket . CloseAsync ( WebSocketCloseStatus . NormalClosure , "well-complete" , cts . Token ) . ConfigureAwait ( false ) ;
}
catch
{
}
}
socket . Dispose ( ) ;
}
}
2026-06-02 00:07:21 +01:00
internal static class MimirWellCapturePage
{
public static object Build (
MimirWellOptions options ,
MimirPresentationControlState presentation ,
2026-06-02 00:47:25 +01:00
MimirWellFrameBuildResult frameResult ,
2026-06-02 00:25:19 +01:00
IEnumerable < MimirRollingStreamBuffer > buffers ,
2026-06-02 00:07:21 +01:00
long captureSequence ,
2026-06-02 00:47:25 +01:00
DateTimeOffset startedAt )
2026-06-02 00:07:21 +01:00
{
2026-06-02 00:47:25 +01:00
var frame = frameResult . Frame ;
return new
{
2026-06-02 00:07:21 +01:00
type = "cultmesh-observation" ,
document = "mimir.well_capture_page.v1" ,
sourceId = "mimir-well" ,
nodeId = options . NodeId ,
captureSequence ,
wallClockUtc = DateTimeOffset . UtcNow . ToString ( "O" ) ,
elapsedSeconds = ( DateTimeOffset . UtcNow - startedAt ) . TotalSeconds ,
frame = new
{
frame . PresentationTimeNs ,
frame . WindowStartNs ,
frame . WindowEndNs ,
PresentationDelayMs = frame . PresentationDelay . TotalMilliseconds ,
frame . IsComplete ,
2026-06-02 00:47:25 +01:00
degradedKind = frameResult . DegradedKind ,
degradedReason = frameResult . DegradedReason ,
2026-06-02 00:07:21 +01:00
} ,
storage = new
{
bodyTransport = options . CaptureInlineBodies ? "inline-base64" : "metadata-only" ,
maxInlineBodyBytes = options . CaptureMaxBodyBytes ,
intendedSink = "mimir-recorder-paged-cultcache" ,
} ,
configuredComposite = new
{
video = presentation . VideoFeeds . Select ( feed = > new
{
feed . SourceId ,
feed . DisplayName ,
feed . Enabled ,
feed . Solo ,
feed . Opacity ,
feed . Layer ,
} ) . ToArray ( ) ,
audio = presentation . AudioFeeds . Select ( feed = > new
{
feed . SourceId ,
feed . DisplayName ,
feed . Muted ,
feed . Solo ,
feed . Gain ,
} ) . ToArray ( ) ,
postprocess = presentation . Postprocess ,
renderedProgramBody = new
{
status = "not-published-yet" ,
reason = "Fensalir/OBS program-output capture is a separate producer; this page records the configured composite contract and synchronized source bodies." ,
} ,
} ,
2026-06-02 00:25:19 +01:00
samples = CaptureSamples ( options , captureSequence , frame , buffers )
2026-06-02 00:07:21 +01:00
. ToArray ( ) ,
} ;
2026-06-02 00:47:25 +01:00
}
2026-06-02 00:07:21 +01:00
2026-06-02 00:25:19 +01:00
private static IEnumerable < object > CaptureSamples (
MimirWellOptions options ,
long captureSequence ,
MimirSynchronizedBufferFrame frame ,
IEnumerable < MimirRollingStreamBuffer > buffers )
{
var sliceSamples = frame . Slices
. Where ( slice = > slice . Sample . HasValue )
. Select ( slice = > CaptureSample ( options , captureSequence , slice ) )
. ToArray ( ) ;
if ( sliceSamples . Length > 0 )
{
return sliceSamples ;
}
return buffers
. Where ( buffer = > buffer . Latest . HasValue )
. Select ( buffer = > CaptureLatestFallbackSample ( options , captureSequence , buffer ) ) ;
}
2026-06-02 00:07:21 +01:00
private static object CaptureSample (
MimirWellOptions options ,
long captureSequence ,
MimirSynchronizedStreamSlice slice )
{
var sample = slice . Sample ! . Value ;
var bodyId = $"{options.NodeId}:{captureSequence}:{sample.SourceId}:{sample.Sequence}" ;
return new
{
bodyId ,
slice = new
{
slice . SourceId ,
Kind = slice . Kind . ToString ( ) ,
Origin = slice . Origin . ToString ( ) ,
Status = slice . Status . ToString ( ) ,
slice . SourceTimestampNs ,
slice . CanonicalStartNs ,
slice . CanonicalEndNs ,
slice . PresentationTimeNs ,
slice . TimingOffsetNs ,
slice . DistanceFromPresentationNs ,
slice . TimingConfidence ,
slice . TimingEvidenceKind ,
} ,
sample = SampleMetadata ( sample ) ,
body = CaptureBody ( options , sample ) ,
} ;
}
2026-06-02 00:25:19 +01:00
private static object CaptureLatestFallbackSample (
MimirWellOptions options ,
long captureSequence ,
MimirRollingStreamBuffer buffer )
{
var sample = buffer . Latest ! . Value ;
var bodyId = $"{options.NodeId}:{captureSequence}:{sample.SourceId}:{sample.Sequence}:latest" ;
return new
{
bodyId ,
slice = new
{
sample . SourceId ,
Kind = sample . Kind . ToString ( ) ,
Origin = sample . Origin . ToString ( ) ,
Status = "LatestUnalignedFallback" ,
SourceTimestampNs = sample . TimestampNs ,
CanonicalStartNs = sample . TimestampNs ,
CanonicalEndNs = sample . TimestampNs ,
PresentationTimeNs = 0L ,
TimingOffsetNs = 0L ,
DistanceFromPresentationNs = 0L ,
TimingConfidence = 0.0 ,
TimingEvidenceKind = "unsynchronized-fallback" ,
} ,
sample = SampleMetadata ( sample ) ,
body = CaptureBody ( options , sample ) ,
} ;
}
2026-06-02 00:07:21 +01:00
private static object SampleMetadata ( MimirStreamSample sample ) = > new
{
sample . SourceId ,
Kind = sample . Kind . ToString ( ) ,
Origin = sample . Origin . ToString ( ) ,
sample . TimestampNs ,
sample . ArrivalNs ,
sample . Sequence ,
sample . PayloadHandle ,
sample . ByteLength ,
video = sample . VideoFrame is null ? null : new
{
sample . VideoFrame . Width ,
sample . VideoFrame . Height ,
PixelFormat = sample . VideoFrame . PixelFormat . ToString ( ) ,
sample . VideoFrame . StrideBytes ,
sample . VideoFrame . DeviceTimestampNs ,
sample . VideoFrame . NativeHandle ,
sample . VideoFrame . NativeHandleKind ,
sample . VideoFrame . ResourceKey ,
sample . VideoFrame . ProducerFenceHandle ,
sample . VideoFrame . ProducerFenceValue ,
sample . VideoFrame . UnavoidableCopyCount ,
} ,
audio = sample . AudioBlock is null ? null : new
{
sample . AudioBlock . SampleRate ,
sample . AudioBlock . Channels ,
SampleFormat = sample . AudioBlock . SampleFormat . ToString ( ) ,
sample . AudioBlock . FrameCount ,
sample . AudioBlock . DeviceTimestampNs ,
sample . AudioBlock . NativeHandle ,
sample . AudioBlock . NativeHandleKind ,
} ,
} ;
private static object CaptureBody ( MimirWellOptions options , MimirStreamSample sample )
{
if ( ! options . CaptureInlineBodies )
{
return new { status = "not-inline" , sample . ByteLength } ;
}
if ( sample . Data . IsEmpty | | sample . ByteLength < = 0 )
{
return new { status = "empty" , sample . ByteLength } ;
}
if ( sample . ByteLength > options . CaptureMaxBodyBytes )
{
return new { status = "too-large" , sample . ByteLength } ;
}
return new
{
status = "inline" ,
encoding = "base64" ,
byteLength = sample . ByteLength ,
data = Convert . ToBase64String ( sample . Data . Span ) ,
} ;
}
}
2026-06-02 00:47:25 +01:00
internal static class MimirWellClockDiagnostics
{
public static object Build (
IEnumerable < MimirRollingStreamBuffer > buffers ,
string referenceSourceId ,
MimirWellFrameBuildResult frameResult )
{
var activeBuffers = buffers
. Where ( static buffer = > buffer . Latest . HasValue )
. ToArray ( ) ;
var referenceBuffer = activeBuffers . FirstOrDefault ( buffer = >
string . Equals ( buffer . Descriptor . SourceId , referenceSourceId , StringComparison . Ordinal ) ) ;
var referenceEdgeNs = referenceBuffer ? . Latest ? . TimestampNs ? ? 0L ;
var referenceClockDomain = referenceBuffer ? . Descriptor . EffectiveClockDomainId ? ? "" ;
var domains = activeBuffers
. GroupBy ( static buffer = > buffer . Descriptor . EffectiveClockDomainId , StringComparer . Ordinal )
. Select ( group = > BuildDomain ( group . Key , group . ToArray ( ) , referenceClockDomain , referenceEdgeNs ) )
. OrderBy ( domain = > domain . ClockDomainId , StringComparer . Ordinal )
. ToArray ( ) ;
return new
{
status = frameResult . Frame . Slices . Count > 0 ? "frame-built" : "degraded" ,
frameResult . DegradedKind ,
frameResult . DegradedReason ,
referenceSourceId ,
referenceClockDomain ,
referenceEdgeNs ,
domainCount = domains . Length ,
activeSourceCount = activeBuffers . Length ,
domains ,
} ;
}
private static ClockDomainDiagnostics BuildDomain (
string clockDomainId ,
IReadOnlyList < MimirRollingStreamBuffer > buffers ,
string referenceClockDomain ,
long referenceEdgeNs )
{
var latestEdges = buffers
. Select ( buffer = > buffer . Latest ? . TimestampNs ? ? 0L )
. Where ( static value = > value > 0 )
. ToArray ( ) ;
var windowStarts = buffers
. Select ( static buffer = > buffer . OldestSampleTimestampNs > 0 ? buffer . OldestSampleTimestampNs : buffer . WindowStartNs )
. Where ( static value = > value > 0 )
. ToArray ( ) ;
var minLatest = latestEdges . Length = = 0 ? 0L : latestEdges . Min ( ) ;
var maxLatest = latestEdges . Length = = 0 ? 0L : latestEdges . Max ( ) ;
var maxWindowStart = windowStarts . Length = = 0 ? 0L : windowStarts . Max ( ) ;
var minWindowEnd = minLatest ;
var overlapNs = minWindowEnd > 0 & & maxWindowStart > 0
? minWindowEnd - maxWindowStart
: 0L ;
var domainEdgeNs = maxLatest ;
var provisionalOffsetToReferenceNs = referenceEdgeNs > 0 & & domainEdgeNs > 0
? referenceEdgeNs - domainEdgeNs
: 0L ;
return new ClockDomainDiagnostics (
clockDomainId ,
buffers . Count ,
buffers
. OrderBy ( static buffer = > buffer . Descriptor . SourceId , StringComparer . Ordinal )
. Select ( buffer = > new
{
buffer . Descriptor . SourceId ,
Kind = buffer . Descriptor . Kind . ToString ( ) ,
Origin = buffer . Descriptor . Origin . ToString ( ) ,
buffer . Count ,
buffer . WindowStartNs ,
buffer . OldestSampleTimestampNs ,
EdgeNs = buffer . Latest ? . TimestampNs ? ? 0L ,
ByteLength = buffer . Latest ? . ByteLength ? ? 0 ,
} )
. ToArray ( ) ,
maxWindowStart ,
minLatest ,
maxLatest ,
overlapNs ,
overlapNs > = 0 ,
string . Equals ( clockDomainId , referenceClockDomain , StringComparison . Ordinal ) ,
provisionalOffsetToReferenceNs ,
provisionalOffsetToReferenceNs / 1_000_000.0 ) ;
}
private sealed record ClockDomainDiagnostics (
string ClockDomainId ,
int SourceCount ,
object [ ] Sources ,
long MaxWindowStartNs ,
long MinLatestEdgeNs ,
long MaxLatestEdgeNs ,
long OverlapNs ,
bool HasLocalOverlap ,
bool IsReferenceDomain ,
long ProvisionalOffsetToReferenceNs ,
double ProvisionalOffsetToReferenceMs ) ;
}
2026-06-01 21:27:57 +01:00
internal static class MimirWellSnapshot
{
public static object Build (
MimirWellOptions options ,
MimirRuntimeConfiguration runtimeConfig ,
MimirSynchronizationHub hub ,
MimirPresentationControlState presentation ,
2026-06-02 00:47:25 +01:00
MimirWellFrameBuildResult frameResult ,
2026-06-01 23:52:17 +01:00
IReadOnlyList < MimirCameraExposureControlStatus > visualCalibration ,
2026-06-01 21:27:57 +01:00
IReadOnlyList < object > sourceErrors ,
2026-06-02 00:47:25 +01:00
object streamPressure ,
2026-06-01 21:27:57 +01:00
long sequence ,
2026-06-02 00:47:25 +01:00
DateTimeOffset startedAt )
2026-06-01 21:27:57 +01:00
{
2026-06-02 00:47:25 +01:00
var frame = frameResult . Frame ;
return new
{
2026-06-01 21:27:57 +01:00
type = "cultmesh-observation" ,
document = "mimir.well_snapshot.v1" ,
sourceId = "mimir-well" ,
nodeId = options . NodeId ,
sequence ,
wallClockUtc = DateTimeOffset . UtcNow . ToString ( "O" ) ,
elapsedSeconds = ( DateTimeOffset . UtcNow - startedAt ) . TotalSeconds ,
ingestedSamples = hub . IngestedSamples ,
configuredSources = runtimeConfig . SourceFactories . Count ,
liveSources = hub . SourceCount ,
sourceErrors ,
buffers = hub . Buffers . Buffers . Select ( BufferSnapshot ) . ToArray ( ) ,
synchronizedFrame = new
{
frame . PresentationTimeNs ,
frame . WindowStartNs ,
frame . WindowEndNs ,
PresentationDelayMs = frame . PresentationDelay . TotalMilliseconds ,
frame . IsComplete ,
2026-06-02 00:47:25 +01:00
degradedKind = frameResult . DegradedKind ,
degradedReason = frameResult . DegradedReason ,
2026-06-01 21:27:57 +01:00
slices = frame . Slices . Select ( SliceSnapshot ) . ToArray ( ) ,
} ,
2026-06-02 00:47:25 +01:00
clockDomains = MimirWellClockDiagnostics . Build (
hub . Buffers . Buffers ,
runtimeConfig . Settings . Audio . ReferenceSourceId ,
frameResult ) ,
streamPressure ,
2026-06-01 21:27:57 +01:00
audioSync = new
{
referenceSourceId = runtimeConfig . Settings . Audio . ReferenceSourceId ,
mode = runtimeConfig . Settings . Audio . Mode . ToString ( ) ,
complexContour = hub . ComplexContourRuntimeEnabled ,
states = hub . AudioSynchronizationStates . Select ( state = > new
{
state . SourceId ,
state . ReferenceSourceId ,
state . SampleRate ,
state . SmoothedDelaySamples ,
state . SamplingRateOffsetPpm ,
state . Confidence ,
evidenceKind = "audio-sync" ,
} ) . ToArray ( ) ,
reports = hub . AudioSynchronizationReports . Select ( report = > new
{
report . SourceId ,
report . ReferenceSourceId ,
report . EvidenceKind ,
report . FractionalDelaySamples ,
report . Confidence ,
matchedEvents = report . TimelineMatchedEvents ,
report . ComparedSamples ,
report . AnalysisTimestampNs ,
} ) . ToArray ( ) ,
probe = hub . LastBioacousticProbeSchedule is null
? null
: new
{
hub . LastBioacousticProbeSchedule . TimestampNs ,
hub . LastBioacousticProbeSchedule . ShouldEmit ,
hub . LastBioacousticProbeSchedule . ScheduledIntervalSeconds ,
hub . LastBioacousticProbeSchedule . AggregateSyncConfidence ,
hub . LastBioacousticProbeSchedule . AggregateFrequencyResponseConfidence ,
reason = hub . LastBioacousticProbeSchedule . Reason . ToString ( ) ,
2026-06-01 23:52:17 +01:00
} ,
} ,
visualCalibration = new
{
enabled = options . VisualCalibrationEnabled ,
expectedLedCount = options . VisualExpectedLedCount ,
minimumLuma = options . VisualMinimumLuma ,
settingSeconds = options . VisualSettingSeconds ,
resweepSeconds = options . VisualResweepSeconds ,
cameras = visualCalibration . Select ( camera = > new
{
camera . SourceId ,
camera . ControlKind ,
camera . SupportsExposureGain ,
camera . State ,
camera . CurrentSettingId ,
camera . CurrentExposure ,
camera . CurrentGain ,
camera . BestSettingId ,
camera . BestExposure ,
camera . BestGain ,
camera . BestScore ,
camera . BestDetectedLedCount ,
camera . BestUsableForCalibration ,
camera . FramesScored ,
camera . LastApplySucceeded ,
camera . Reason ,
} ) . ToArray ( ) ,
2026-06-01 21:27:57 +01:00
} ,
composite = new
{
video = presentation . VideoFeeds . Select ( feed = > new
{
feed . SourceId ,
feed . DisplayName ,
feed . Enabled ,
feed . Solo ,
feed . Opacity ,
feed . Layer ,
} ) . ToArray ( ) ,
audio = presentation . AudioFeeds . Select ( feed = > new
{
feed . SourceId ,
feed . DisplayName ,
feed . Muted ,
feed . Solo ,
feed . Gain ,
} ) . ToArray ( ) ,
postprocess = presentation . Postprocess ,
} ,
publication = new
{
MimirObsPublicationConfigurations . NativeProgram . Id ,
MimirObsPublicationConfigurations . NativeProgram . VideoKind ,
MimirObsPublicationConfigurations . NativeProgram . VideoSourceName ,
MimirObsPublicationConfigurations . NativeProgram . AudioKind ,
MimirObsPublicationConfigurations . NativeProgram . TargetPresentationDelaySeconds ,
stems = MimirObsPublicationConfigurations . NativeProgram . AudioStems . Select ( stem = > new
{
stem . Id ,
stem . DisplayName ,
stem . ChannelCount ,
stem . UserMixable ,
stem . CarriesTimingWitness ,
stem . Notes ,
} ) . ToArray ( ) ,
} ,
} ;
2026-06-02 00:47:25 +01:00
}
2026-06-01 21:27:57 +01:00
private static object BufferSnapshot ( MimirRollingStreamBuffer buffer ) = > new
{
buffer . Descriptor . SourceId ,
Kind = buffer . Descriptor . Kind . ToString ( ) ,
Origin = buffer . Descriptor . Origin . ToString ( ) ,
buffer . Descriptor . Label ,
buffer . Descriptor . EffectiveClockDomainId ,
buffer . Count ,
buffer . EdgeNs ,
2026-06-02 00:47:25 +01:00
buffer . OldestSampleTimestampNs ,
2026-06-01 21:27:57 +01:00
buffer . WindowStartNs ,
hasLatest = buffer . Latest . HasValue ,
latest = buffer . Latest . HasValue ? SampleSnapshot ( buffer . Latest . Value ) : null ,
} ;
private static object SliceSnapshot ( MimirSynchronizedStreamSlice slice ) = > new
{
slice . SourceId ,
Kind = slice . Kind . ToString ( ) ,
Origin = slice . Origin . ToString ( ) ,
Status = slice . Status . ToString ( ) ,
slice . SourceTimestampNs ,
slice . CanonicalStartNs ,
slice . CanonicalEndNs ,
slice . PresentationTimeNs ,
slice . TimingOffsetNs ,
slice . DistanceFromPresentationNs ,
slice . TimingConfidence ,
slice . TimingEvidenceKind ,
sample = slice . Sample . HasValue ? SampleSnapshot ( slice . Sample . Value ) : null ,
} ;
private static object SampleSnapshot ( MimirStreamSample sample ) = > new
{
sample . SourceId ,
Kind = sample . Kind . ToString ( ) ,
Origin = sample . Origin . ToString ( ) ,
sample . TimestampNs ,
sample . ArrivalNs ,
sample . Sequence ,
sample . PayloadHandle ,
sample . ByteLength ,
video = sample . VideoFrame is null ? null : new
{
sample . VideoFrame . Width ,
sample . VideoFrame . Height ,
PixelFormat = sample . VideoFrame . PixelFormat . ToString ( ) ,
sample . VideoFrame . StrideBytes ,
sample . VideoFrame . DeviceTimestampNs ,
sample . VideoFrame . NativeHandle ,
sample . VideoFrame . NativeHandleKind ,
sample . VideoFrame . ResourceKey ,
sample . VideoFrame . ProducerFenceHandle ,
sample . VideoFrame . ProducerFenceValue ,
sample . VideoFrame . UnavoidableCopyCount ,
} ,
audio = sample . AudioBlock is null ? null : new
{
sample . AudioBlock . SampleRate ,
sample . AudioBlock . Channels ,
SampleFormat = sample . AudioBlock . SampleFormat . ToString ( ) ,
sample . AudioBlock . FrameCount ,
sample . AudioBlock . DeviceTimestampNs ,
sample . AudioBlock . NativeHandle ,
sample . AudioBlock . NativeHandleKind ,
} ,
} ;
}