reactor-effect-client 0.2.0 → 0.3.0

package/dist/orchestration/renewal.js

@@ -3,25 +3,31 @@ import * as Clock from "effect/Clock";
 import * as Context from "effect/Context";
 import * as Crypto from "effect/Crypto";
 import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
 import * as Scope from "effect/Scope";
 import * as Semaphore from "effect/Semaphore";
-import { ReactorError, errorOf } from "../errors.js";
+import * as Stream from "effect/Stream";
+import { duration } from "../duration.js";
+import { AcquisitionFailure, CommandFailure, ReactorError, errorOf, parsed, positiveLimit, } from "../errors.js";
 import { Observations } from "../observation.js";
+import { noAcquisition } from "../session/_internal/acquire.js";
 import * as Sequence from "../Sequence.js";
 import * as Submission from "../Submission.js";
-import { CommandFailure } from "../session/commands.js";
-import { AcquisitionFailure } from "../session/index.js";
 import * as MediaBuffer from "./media-buffer.js";
 import * as SourceSlot from "./source-slot.js";
 import { canHandoff, decideRenewal } from "./renewal-state.js";
 import { PolicyFailure, captureRequest } from "./request.js";
 import { emptyState, isIdle } from "./queries.js";
 import { activeIds, generation, resolve } from "./routing.js";
+import { handleContext } from "./types.js";
+const engineOnly = (event) => event._tag === "Engine" ? Result.succeed(event.event) : Result.fail(event);
+const renewalsOnly = (event) => event._tag === "Renewal" ? Result.succeed(event.event) : Result.fail(event);
 /**
  * Explicit application policy for renewal, sequence affinity and continuous
  * recovering media. A physical source still owns each connection generation.
@@ -37,24 +43,22 @@ export const make = (options) => Effect.gen(function* () {
     const commands = yield* Semaphore.make(1);
     const closeGate = yield* Semaphore.make(1);
     const affinity = yield* Sequence.makeAffinity().pipe(Effect.mapError((cause) => errorOf(cause, "InvalidInput")));
-    const events = new Observations();
-    const buffer = yield* MediaBuffer.make;
+    // One ordered stream: engine events, renewals and media transitions.
+    const observations = new Observations();
+    const buffer = yield* MediaBuffer.make(yield* parsed(() => ({
+        videoFrames: positiveLimit(options.maxQueuedVideoFrames ?? MediaBuffer.defaultLimits.videoFrames, "orchestration maxQueuedVideoFrames"),
+        audioSamples: positiveLimit(options.maxQueuedAudioSamples ?? MediaBuffer.defaultLimits.audioSamples, "orchestration maxQueuedAudioSamples"),
+    })));
     const fatal = yield* Deferred.make();
     const slots = new Map();
     const cleanups = [];
     const seenCleanups = new Set();
     const maxSessions = options.maxSessions ?? 64;
-    const reconnectTimeout = options.reconnectTimeoutMs ?? 10_000;
-    const leadSeconds = options.leadSeconds ?? 30;
-    if (!Number.isSafeInteger(maxSessions) ||
-        maxSessions < 1 ||
-        maxSessions > 4096 ||
-        !Number.isFinite(reconnectTimeout) ||
-        reconnectTimeout <= 0 ||
-        !Number.isFinite(leadSeconds) ||
-        leadSeconds < 0) {
-        return yield* Effect.fail(new ReactorError("InvalidInput", "Invalid orchestration bounds"));
+    if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > 4096) {
+        return yield* ReactorError.fromCode("InvalidInput", "Invalid orchestration bounds");
     }
+    const reconnectTimeout = Duration.toMillis(yield* parsed(() => duration(options.reconnectTimeout ?? "10 seconds", "orchestration reconnectTimeout")));
+    const leadSeconds = Duration.toSeconds(yield* parsed(() => duration(options.lead ?? "30 seconds", "orchestration lead", { allowZero: true })));
     let current;
     let replacement = { _tag: "Absent" };
     let opened = 0;
@@ -66,26 +70,35 @@ export const make = (options) => Effect.gen(function* () {
     let mediaState = { _tag: "Closed" };
     let terminalFailure;
     let submissionSequence = 0n;
-    const observe = (event) => options.onRenewal?.(event) ?? Effect.void;
-    const log = (message) => Effect.sync(() => options.log?.(message));
-    const emit = (event) => events.emit(event, 256);
+    const announce = (event) => Effect.sync(() => observations.emit({ _tag: "Renewal", event }, 256));
+    const log = (message) => Effect.logDebug(message).pipe(Effect.annotateLogs({ module: "reactor.orchestration" }));
+    const emit = (event) => observations.emit({ _tag: "Engine", event }, 256);
+    const setMedia = (state) => {
+        mediaState = state;
+        observations.emit({ _tag: "Media", state }, 256);
+    };
+    const onRenewal = options.onRenewal;
+    // Subscribed before the first source opens, so the reader sees its Opened.
+    const renewalReader = onRenewal === undefined
+        ? undefined
+        : yield* observations.subscribe({ capacity: 4096 }).pipe(Effect.flatMap((stream) => stream.pipe(Stream.filterMap(renewalsOnly), Stream.runForEach((event) => Effect.suspend(() => onRenewal(event)).pipe(Effect.catchCause((cause) => Effect.logWarning("onRenewal failed", cause).pipe(Effect.annotateLogs({ module: "reactor.orchestration" }))))), Effect.catchCause((cause) => Effect.logWarning("onRenewal reader stopped", cause).pipe(Effect.annotateLogs({ module: "reactor.orchestration" }))), Effect.forkIn(scope))));
     const fail = (cause) => Effect.suspend(() => {
         if (terminalFailure !== undefined)
             return Effect.void;
         terminalFailure = cause;
         // Publish the failed state and queues before waking a failure waiter.
-        mediaState = { _tag: "Failed", cause };
+        setMedia({ _tag: "Failed", cause });
         emit({ _tag: "SessionFailed", failure: cause });
         buffer.fail(cause);
         Deferred.doneUnsafe(fatal, Effect.succeed(cause));
-        return observe({ _tag: "Failed", reason: cause.message });
+        return announce({ _tag: "Failed", reason: cause.message });
     });
     // Every asynchronous activation uses this final fence. Closed/failed state
     // cannot be replaced by a reconnect or autoplay operation that finished late.
     const publishReady = (slot) => {
         if (closing || slot.closed || slot !== current || terminalFailure !== undefined)
             return false;
-        mediaState = { _tag: "Ready", sessionId: slot.source.id, generation: slot.media.generation };
+        setMedia({ _tag: "Ready", sessionId: slot.source.id, generation: slot.media.generation });
         return true;
     };
     const recordCleanup = (cleanup) => {
@@ -97,6 +110,19 @@ export const make = (options) => Effect.gen(function* () {
     const openSequences = (slot) => affinity.snapshots.pipe(Effect.map((entries) => entries.some((entry) => entry.owner === slot.source.id && entry.status === "open")));
     const expired = (slot) => slot.expired();
     const recoveryBudget = (slot) => slot.recoveryBudget();
+    // The logical output's loss: every former owner's loss while it fed the
+    // output, plus the current owner's since it became the owner. A prepared
+    // replacement's loss before it fed the output is not the output's.
+    let outputLoss = SourceSlot.noLoss;
+    let ownerBaseline = SourceSlot.noLoss;
+    const ownerLoss = (slot) => Effect.result(slot.pressure.pipe(Effect.timeout(recoveryBudget(slot)))).pipe(Effect.map(SourceSlot.lossOf));
+    const activateOwner = (slot) => ownerLoss(slot).pipe(Effect.map((loss) => {
+        ownerBaseline = loss;
+    }));
+    const retireOwner = (slot) => ownerLoss(slot).pipe(Effect.map((loss) => {
+        outputLoss = SourceSlot.addLoss(outputLoss, SourceSlot.subtractLoss(loss, ownerBaseline));
+        ownerBaseline = SourceSlot.noLoss;
+    }));
     const retired = (slot) => slot.retired(buffer.forwarded);
     const closeSlot = (slot) => slot.close;
     const replace = (slot, cause) => Effect.gen(function* () {
@@ -112,8 +138,10 @@ export const make = (options) => Effect.gen(function* () {
                 reason: `Session lost: ${cause.message}`,
                 sessionId: slot.source.id,
             });
+        if (slot === current)
+            yield* retireOwner(slot);
         yield* closeSlot(slot);
-        yield* observe({
+        yield* announce({
             _tag: "Replaced",
             reason: cause.message,
             lostClips: lost.length,
@@ -133,17 +161,18 @@ export const make = (options) => Effect.gen(function* () {
             return;
         }
         current = selected;
+        yield* activateOwner(selected);
         yield* current.source.setAutoplay(autoplay);
         if (!publishReady(current))
             return;
         yield* log("Replaced lost session; local queue resumes on the new connection");
-    }).pipe(Effect.catch((failure) => fail(errorOf(failure, "Disconnected"))));
+    }).pipe(Effect.withSpan("reactor.orchestration.renewal.replace", { attributes: { "reactor.session.id": slot.source.id } }, { captureStackTrace: false }), Effect.catch(fail));
     const recover = (slot, cause) => Effect.gen(function* () {
         if (slot.closed || closing || terminalFailure !== undefined)
             return;
         if (slot === current)
-            mediaState = { _tag: "Recovering", sessionId: slot.source.id, cause };
-        yield* observe({ _tag: "Recovering", sessionId: slot.source.id, reason: cause.message });
+            setMedia({ _tag: "Recovering", sessionId: slot.source.id, cause });
+        yield* announce({ _tag: "Recovering", sessionId: slot.source.id, reason: cause.message });
         yield* slot.joinCommitted(recoveryBudget(slot));
         if (slot.closed || closing || terminalFailure !== undefined)
             return;
@@ -155,7 +184,7 @@ export const make = (options) => Effect.gen(function* () {
         // Read the retiring receiver before reconnect makes its counters unavailable.
         const previousPressure = yield* Effect.result(slot.media.pressure.pipe(Effect.timeout(recoveryBudget(slot))));
         if (expired(slot)) {
-            yield* replace(slot, new ReactorError("TerminalSession", "Source expired during recovery", {
+            yield* replace(slot, ReactorError.fromCode("TerminalSession", "Source expired during recovery", {
                 operation: "renewal",
             }));
             return;
@@ -165,7 +194,7 @@ export const make = (options) => Effect.gen(function* () {
             return;
         const connected = yield* Effect.result(slot.source.reconnect.pipe(Effect.timeoutOrElse({
             duration: recoveryBudget(slot),
-            orElse: () => Effect.fail(new ReactorError("Disconnected", "Explicit source reconnect timed out")),
+            orElse: () => Effect.fail(ReactorError.fromCode("Disconnected", "Explicit source reconnect timed out")),
         })));
         if (slot.closed || closing || terminalFailure !== undefined)
             return;
@@ -203,18 +232,18 @@ export const make = (options) => Effect.gen(function* () {
         }
         if (slot === current && !publishReady(slot))
             return;
-        yield* observe({
+        yield* announce({
             _tag: "Reconnected",
             sessionId: slot.source.id,
             generation: slot.media.generation,
         });
-    });
+    }).pipe(Effect.withSpan("reactor.orchestration.renewal.recover", { attributes: { "reactor.session.id": slot.source.id } }, { captureStackTrace: false }));
     const scheduleRecovery = (slot, cause, mode) => Effect.gen(function* () {
         if (slot.closed || closing || terminalFailure !== undefined)
             return;
         if (!slot.beginRecovery(mode))
             return;
-        yield* recover(slot, cause).pipe(commands.withPermit, Effect.forkIn(scope));
+        yield* recover(slot, cause).pipe(commands.withPermits(1), Effect.forkIn(scope));
     });
     const startMedia = (slot) => slot.startMedia({
         video: (frame) => Effect.suspend(() => {
@@ -234,7 +263,7 @@ export const make = (options) => Effect.gen(function* () {
     });
     const acquire = Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
         if (opened >= maxSessions)
-            return yield* Effect.fail(new ReactorError("Overflow", "Orchestration session and cleanup-history bound reached"));
+            return yield* ReactorError.fromCode("Overflow", "Orchestration session and cleanup-history bound reached");
         const owned = yield* Scope.make();
         let acquired;
         let acquiredSource;
@@ -243,22 +272,23 @@ export const make = (options) => Effect.gen(function* () {
             // Dependency provision order cannot move resources to the caller's owner.
             const value = yield* options.open.pipe(Effect.provideContext(Context.add(context, Scope.Scope, owned)), Effect.timeoutOrElse({
                 duration: "30 seconds",
-                orElse: () => Effect.fail(new ReactorError("InvalidState", "Source acquisition timed out")),
-            }), Effect.mapError((cause) => errorOf(cause, "InvalidState")));
+                orElse: () => Effect.fail(ReactorError.fromCode("InvalidState", "Source acquisition timed out")),
+            }));
             acquiredSource = value.source;
-            if (!(value.maxSeconds > 0) ||
-                (value.maxSeconds !== Infinity && !Number.isFinite(value.maxSeconds))) {
-                return yield* Effect.fail(new ReactorError("InvalidInput", "Source lifetime must be positive or infinite"));
-            }
+            const lifetime = yield* parsed(() => duration(value.lifetime, "source lifetime", { allowInfinite: true }));
+            // A lead as long as the lifetime would prepare a replacement at once,
+            // after every open, bounded only by maxSessions.
+            if (Duration.isFinite(lifetime) && leadSeconds >= Duration.toSeconds(lifetime))
+                return yield* ReactorError.fromCode("InvalidInput", "renewal lead must be shorter than the source lifetime", { operation: "renewal", outcome: "not-submitted" });
             if (slots.has(value.source.id))
-                return yield* Effect.fail(new ReactorError("InvalidInput", "Orchestration sources must have distinct session identities"));
+                return yield* ReactorError.fromCode("InvalidInput", "Orchestration sources must have distinct session identities");
             const media = yield* value.source.media;
             const slot = yield* SourceSlot.make({
                 source: value.source,
                 scope: owned,
                 media,
                 openedAt: clock.currentTimeMillisUnsafe(),
-                maxSeconds: value.maxSeconds,
+                maxSeconds: Duration.toSeconds(lifetime),
                 cleanupBudgetMs: reconnectTimeout,
                 recordCleanup,
                 retireSequences: affinity.retire(value.source.id).pipe(Effect.asVoid),
@@ -275,10 +305,10 @@ export const make = (options) => Effect.gen(function* () {
                 return Effect.void;
             }), (cause) => scheduleRecovery(slot, cause, "replace"));
             yield* startMedia(slot);
-            yield* observe({
+            yield* announce({
                 _tag: "Opened",
                 sessionId: slot.source.id,
-                maxSeconds: slot.maxSeconds,
+                lifetime: Duration.seconds(slot.maxSeconds),
             });
             return slot;
         })).pipe(Effect.onExit((exit) => Exit.isSuccess(exit)
@@ -292,12 +322,12 @@ export const make = (options) => Effect.gen(function* () {
                     yield* Scope.close(owned, exit);
                     if (Exit.isFailure(exit)) {
                         const failure = Cause.findErrorOption(exit.cause);
-                        if (Option.isSome(failure) && failure.value instanceof AcquisitionFailure)
+                        if (Option.isSome(failure) && AcquisitionFailure.is(failure.value))
                             recordCleanup({ lease: failure.value.cleanup, policy: [] });
                     }
                 }
             })));
-    }));
+    })).pipe(Effect.tap((slot) => Effect.annotateCurrentSpan("reactor.session.id", slot.source.id)), Effect.withSpan("reactor.orchestration.renewal.open", {}, { captureStackTrace: false }));
     const close = closeGate.withPermit(Effect.uninterruptible(Effect.gen(function* () {
         if (finalReport !== undefined)
             return finalReport;
@@ -306,29 +336,37 @@ export const make = (options) => Effect.gen(function* () {
             yield* Fiber.interrupt(replacement.fiber);
         yield* Effect.forEach([...slots.values()], closeSlot, { discard: true });
         buffer.end();
-        events.end();
-        mediaState = { _tag: "Closed" };
+        setMedia({ _tag: "Closed" });
+        observations.end();
+        // The reader delivers what was announced before close, within a bound.
+        if (renewalReader !== undefined)
+            yield* Fiber.await(renewalReader).pipe(Effect.interruptible, Effect.timeout("1 second"), Effect.ignore);
         finalReport = Object.freeze({ sessions: Object.freeze([...cleanups]) });
         return finalReport;
     })));
     yield* Effect.addFinalizer(() => close);
     current = yield* acquire.pipe(Effect.tap((slot) => slot.source.setAutoplay(true)), Effect.catch((cause) => close.pipe(Effect.flatMap((report) => {
+        // An AcquisitionFailure from `open` already carries the lease it
+        // recorded, by reference; any later failure takes the recorded lease.
         const lease = report.sessions[0]?.lease;
-        return Effect.fail(lease === undefined ? cause : new AcquisitionFailure(cause, lease));
+        return Effect.fail(AcquisitionFailure.is(cause) || (lease === undefined && ReactorError.is(cause))
+            ? cause
+            : AcquisitionFailure.from(cause, lease ?? noAcquisition));
     }))));
-    mediaState = {
+    // The first owner's loss from its start is the output's: no baseline.
+    setMedia({
         _tag: "Ready",
         sessionId: current.source.id,
         generation: current.media.generation,
-    };
+    });
     const guard = (operation, effect) => Effect.gen(function* () {
         if (closing)
-            return yield* Effect.fail(new PolicyFailure("session_closed", "Orchestration is closed", operation));
+            return yield* PolicyFailure.refuse("SessionClosed", "Orchestration is closed", operation);
         if (yield* Deferred.isDone(fatal))
-            return yield* Effect.fail(new CommandFailure(yield* Deferred.await(fatal), {
+            return yield* CommandFailure.from(yield* Deferred.await(fatal), {
                 operation,
                 outcome: "not-submitted",
-            }));
+            });
         return yield* effect;
     });
     const route = (request) => Effect.gen(function* () {
@@ -345,10 +383,10 @@ export const make = (options) => Effect.gen(function* () {
             ? next
             : current;
         if (preferred === undefined)
-            return yield* Effect.fail(new PolicyFailure("session_recovering", "No source is ready"));
+            return yield* PolicyFailure.refuse("SessionRecovering", "No source is ready");
         return yield* resolve(request, values, preferred.source.id, binding);
     });
-    const sequenceError = (error) => new PolicyFailure(`sequence_${error.reason}`, `Sequence ${error.sequenceId}: ${error.reason}`);
+    const sequenceError = (error) => PolicyFailure.sequence(error.sequenceId, error.code);
     const prepare = (input) => Effect.gen(function* () {
         const request = yield* captureRequest(input);
         const id = `${namespace}:${++submissionSequence}`;
@@ -360,30 +398,26 @@ export const make = (options) => Effect.gen(function* () {
                 // A committed submission remains a readable outcome after the handle
                 // closes. Only selecting or committing fresh work needs a live owner.
                 yield* guard("enqueue", Effect.void);
-                const decision = yield* route(request).pipe(commands.withPermit);
+                const decision = yield* route(request).pipe(commands.withPermits(1));
                 const target = slots.get(decision.owner);
                 if (target === undefined)
-                    return yield* Effect.fail(new PolicyFailure("session_retired", "Selected source was retired"));
+                    return yield* PolicyFailure.refuse("SessionRetired", "Selected source was retired");
                 const sequence = request.sequence;
                 active = yield* target.source.prepareRouted({ request, position: decision.position }, {
                     commit: (submissionId) => commands.withPermit(guard("enqueue", Effect.gen(function* () {
                         const checked = yield* route(request);
                         if (checked.owner !== decision.owner ||
                             checked.position !== decision.position) {
-                            return yield* Effect.fail(new PolicyFailure("route_changed", "Request ownership or insertion position changed during preparation"));
+                            return yield* PolicyFailure.refuse("RouteChanged", "Request ownership or insertion position changed during preparation");
                         }
                         if (active === undefined)
                             return yield* Effect.die(new Error("Source committed before returning its inert submission"));
                         yield* target.register(active, Effect.gen(function* () {
                             if (sequence !== undefined) {
-                                yield* affinity
-                                    .bind(sequence.id, target.source.id)
-                                    .pipe(Effect.mapError(sequenceError));
-                                yield* affinity
-                                    .begin(sequence.id, sequence.memberId ?? submissionId)
-                                    .pipe(Effect.mapError(sequenceError));
+                                yield* affinity.bind(sequence.id, target.source.id);
+                                yield* affinity.begin(sequence.id, sequence.memberId ?? submissionId);
                             }
-                        }));
+                        }).pipe(Effect.mapError(sequenceError)));
                     }))),
                     result: (submissionId, result) => Effect.gen(function* () {
                         target.recordResult(result);
@@ -397,7 +431,7 @@ export const make = (options) => Effect.gen(function* () {
                             yield* account.pipe(Effect.catch((cause) => Effect.gen(function* () {
                                 target.markIndeterminate();
                                 yield* affinity.retire(target.source.id);
-                                yield* fail(new ReactorError("InvalidState", "Committed sequence accounting failed", { detail: cause }));
+                                yield* fail(ReactorError.fromCode("InvalidState", "Committed sequence accounting failed", { detail: cause }));
                             })));
                         }
                         target.finishAccounting();
@@ -458,16 +492,20 @@ export const make = (options) => Effect.gen(function* () {
         const matches = yield* Effect.forEach([...slots.values()].filter((slot) => !slot.closed), (slot) => slot.source.state.pipe(Effect.map((state) => ({ slot, state }))));
         const found = matches.filter(({ state }) => activeIds(state).includes(id));
         if (found.length !== 1)
-            return yield* Effect.fail(new PolicyFailure(found.length === 0 ? "not_found" : "owner_conflict", "Clip has no unique active owning session", operation));
+            return yield* PolicyFailure.refuse(found.length === 0 ? "NotFound" : "OwnerConflict", "Clip has no unique active owning session", operation);
         if (found[0].slot.recovering)
-            return yield* Effect.fail(new PolicyFailure("session_recovering", "Owning session is recovering", operation));
+            return yield* PolicyFailure.refuse("SessionRecovering", "Owning session is recovering", operation);
         return found[0];
     });
     const engine = {
         prepare,
         enqueue: (request) => prepare(request).pipe(Effect.flatMap((submission) => submission.submit)),
         state,
-        events: events.stream(),
+        events: Stream.filterMap(observations.stream(), engineOnly),
+        observe: (options) => observations.observeWith(state, options).pipe(Effect.map(({ initial, events }) => ({
+            initial,
+            events: Stream.filterMap(events, engineOnly),
+        }))),
         failure: Deferred.await(fatal),
         setAutoplay: (enabled) => commands.withPermit(guard("set_autoplay", Effect.gen(function* () {
             autoplay = enabled;
@@ -485,11 +523,11 @@ export const make = (options) => Effect.gen(function* () {
         remove: (id) => commands.withPermit(guard("pop", owner(id, "pop").pipe(Effect.flatMap(({ slot }) => slot.source.remove(id))))),
         move: (id, position, queue) => commands.withPermit(guard("move", Effect.gen(function* () {
             if (!Number.isSafeInteger(position) || position < 0)
-                return yield* Effect.fail(new PolicyFailure("invalid_request", "Move position must be a nonnegative integer", "move"));
+                return yield* PolicyFailure.refuse("InvalidRequest", "Move position must be a nonnegative integer", "move");
             const selected = yield* owner(id, "move");
             const own = queue === "generation" ? generation(selected.state) : selected.state.ready;
             if (!own.some((clip) => clip.clipId === id))
-                return yield* Effect.fail(new PolicyFailure("queue_changed", "Clip is no longer in the selected application queue", "move"));
+                return yield* PolicyFailure.refuse("QueueChanged", "Clip is no longer in the selected application queue", "move");
             let preceding = 0;
             for (const slot of slots.values()) {
                 if (slot === selected.slot)
@@ -503,7 +541,7 @@ export const make = (options) => Effect.gen(function* () {
         }))),
         setCanvas: (canvas) => commands.withPermit(guard("set_canvas", Effect.gen(function* () {
             if (!isIdle(yield* state))
-                return yield* Effect.fail(new PolicyFailure("busy", "Canvas can only change while every source is idle", "set_canvas"));
+                return yield* PolicyFailure.refuse("Busy", "Canvas can only change while every source is idle", "set_canvas");
             for (const slot of slots.values())
                 if (!slot.closed)
                     yield* slot.source.setCanvas(canvas);
@@ -525,18 +563,18 @@ export const make = (options) => Effect.gen(function* () {
                     replacement = { _tag: "Ready", slot: result.value };
                     openFailures = 0;
                     yield* log("Prepared the next session for renewal");
-                    yield* observe({ _tag: "Prepared" });
+                    yield* announce({ _tag: "Prepared" });
                 }
                 else {
                     openFailures++;
                     retryAt = clock.currentTimeMillisUnsafe() + 5000;
-                    yield* observe({
+                    yield* announce({
                         _tag: "SetupFailed",
                         reason: "Could not prepare the next source",
                         consecutive: openFailures,
                     });
                     if (openFailures >= 3)
-                        return yield* fail(new ReactorError("Disconnected", "Repeated source renewal acquisition failed"));
+                        return yield* fail(ReactorError.fromCode("Disconnected", "Repeated source renewal acquisition failed"));
                 }
             }
         }
@@ -552,7 +590,7 @@ export const make = (options) => Effect.gen(function* () {
             case "Retain":
                 return;
             case "Expire":
-                yield* replace(current, new ReactorError("TerminalSession", "Source lifetime limit reached", {
+                yield* replace(current, ReactorError.fromCode("TerminalSession", "Source lifetime limit reached", {
                     operation: "renewal",
                 }));
                 return;
@@ -582,31 +620,47 @@ export const make = (options) => Effect.gen(function* () {
         }))
             return;
         const old = current;
-        current = next;
-        replacement = { _tag: "Absent" };
-        yield* current.source.setAutoplay(autoplay);
-        const activated = publishReady(current);
-        yield* closeSlot(old);
-        if (!activated)
-            return;
-        yield* observe({ _tag: "Switched", ...tail });
-        yield* log("Switched prepared sessions at a sequence boundary");
+        // The switch is traced; the tick that found it is not.
+        yield* Effect.gen(function* () {
+            yield* retireOwner(old);
+            current = next;
+            yield* activateOwner(next);
+            replacement = { _tag: "Absent" };
+            yield* next.source.setAutoplay(autoplay);
+            const activated = publishReady(next);
+            yield* closeSlot(old);
+            if (!activated)
+                return;
+            yield* announce({ _tag: "Switched", ...tail });
+            yield* log("Switched prepared sessions at a sequence boundary");
+        }).pipe(Effect.withSpan("reactor.orchestration.renewal.switch", {
+            attributes: {
+                "reactor.session.id": next.source.id,
+                "reactor.session.previous_id": old.source.id,
+            },
+        }, { captureStackTrace: false }));
     }))
-        .pipe(Effect.catch((cause) => fail(errorOf(cause, "Disconnected"))));
+        .pipe(Effect.catch(fail));
     yield* Effect.forever(Effect.sleep(100).pipe(Effect.andThen(tick))).pipe(Effect.forkIn(scope));
     const pressure = Effect.suspend(() => {
         if (current === undefined)
-            return Effect.fail(new ReactorError("InvalidState", "No active media source"));
+            return Effect.fail(ReactorError.fromCode("InvalidState", "No active media source"));
         const owner = current;
-        return owner.pressure.pipe(Effect.map((source) => {
+        return owner.pressure.pipe(Effect.flatMap((source) => {
             const queued = buffer.pressure();
-            return {
+            const loss = SourceSlot.addLoss(outputLoss, SourceSlot.subtractLoss(SourceSlot.lossOf(Result.succeed(source)), ownerBaseline));
+            if (loss.video === null || loss.audio === null || loss.readers === null)
+                return Effect.fail(ReactorError.fromCode("InvalidState", "A former media owner's loss totals are unknown"));
+            return Effect.succeed({
                 ...source,
                 closed: closing,
                 queuedVideo: source.queuedVideo + queued.queuedVideo,
                 queuedAudio: source.queuedAudio + queued.queuedAudio,
                 queuedBytes: source.queuedBytes + queued.queuedBytes,
-            };
+                droppedVideo: loss.video,
+                droppedAudio: loss.audio,
+                readerOverflows: loss.readers,
+            });
         }));
     });
     return {
@@ -618,6 +672,7 @@ export const make = (options) => Effect.gen(function* () {
             videoFramesPerSecond: current.media.videoFramesPerSecond,
         },
         mediaState: Effect.sync(() => mediaState),
+        observe: (options) => observations.observeWith(Effect.map(state, (engine) => ({ engine, media: mediaState })), options),
         sessionId: Effect.sync(() => current === undefined || current.closed ? Option.none() : Option.some(current.source.id)),
         close,
         cleanup: Effect.sync(() => finalReport === undefined ? Option.none() : Option.some(finalReport)),
@@ -630,4 +685,10 @@ export const make = (options) => Effect.gen(function* () {
         },
     };
 });
+/**
+ * The handle's `Engine`, `Media` and `Handle` services from one orchestration,
+ * so the three can never come from two paid session chains. Each build of the
+ * layer opens its own chain: bind it to a `const` and provide that one value.
+ */
+export const layer = (options) => Layer.effectContext(Effect.map(make(options), handleContext));
 //# sourceMappingURL=renewal.js.map