reactor-effect-client 0.7.0 → 0.8.0

package/dist/orchestration/scheduler.js

@@ -1,2597 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Context from "effect/Context";
-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 Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as PubSub from "effect/PubSub";
-import * as Queue from "effect/Queue";
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import * as Scope from "effect/Scope";
-import * as Stream from "effect/Stream";
-import * as SubscriptionRef from "effect/SubscriptionRef";
-import { take as takeQueue } from "../_internal/queue.js";
-import { duration } from "../duration.js";
-import { parsedInput, ReactorError } from "../errors.js";
-import { monotonicMillis } from "./elapsed.js";
-import { requestSeconds as h3RequestSeconds } from "../h3/profile.js";
-import { captureRequest, PolicyFailure } from "./request.js";
-import { activeIds } from "./routing.js";
-import { fillerIndexFromKey, fillerKey, isReservedSchedulerKey, keyedRequest, keyFromProviderMetadata, } from "./scheduler-key.js";
-import { dueCues, estimatesFrom, plan, projectedStartMs, runwaySeconds, } from "./scheduler-policy.js";
-import { Engine } from "./types.js";
-/** Stable caller identity for a scheduled item. */
-export const ItemKey = Schema.NonEmptyString.pipe(Schema.brand("ItemKey"));
-const isFirstDecisive = (status) => status._tag === "Started" ||
-    status._tag === "Ended" ||
-    status._tag === "Dropped" ||
-    status._tag === "Failed" ||
-    status._tag === "Unobserved" ||
-    (status._tag === "Unknown" && status.terminal === true);
-export class KeyMismatch extends Schema.TaggedError()("KeyMismatch", {
-    key: ItemKey,
-}) {
-    static of(key) {
-        return new KeyMismatch({ key });
-    }
-}
-export class LaneBusy extends Schema.TaggedError()("LaneBusy", {
-    key: ItemKey,
-    lane: Schema.String,
-}) {
-    static of(key, lane) {
-        return new LaneBusy({ key, lane });
-    }
-}
-export class WouldMissDeadline extends Schema.TaggedError()("WouldMissDeadline", { key: ItemKey }) {
-    static of(key) {
-        return new WouldMissDeadline({ key });
-    }
-}
-const maxEarlyClipIds = 4096;
-const invalid = (message) => PolicyFailure.refuse("InvalidRequest", message, "submit");
-const ownedData = (input, fields, name) => {
-    if (input === null || typeof input !== "object" || Array.isArray(input))
-        return Result.fail(invalid(`${name} must be an object`));
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    if (Object.getOwnPropertySymbols(input).length > 0 ||
-        Object.keys(descriptors).some((field) => !fields.includes(field) || !("value" in descriptors[field])))
-        return Result.fail(invalid(`${name} has unsupported fields or accessors`));
-    return Result.succeed(Object.fromEntries(Object.entries(descriptors).map(([field, descriptor]) => [field, descriptor.value])));
-};
-/** A Duration tuple or object read from own data properties; no accessor runs. */
-const durationData = (input) => {
-    if (Array.isArray(input)) {
-        const descriptors = Object.getOwnPropertyDescriptors(input);
-        if (Object.getOwnPropertySymbols(input).length > 0 ||
-            Object.keys(descriptors).some((field) => !["0", "1", "length"].includes(field) || !("value" in descriptors[field])) ||
-            descriptors.length?.value !== 2 ||
-            descriptors["0"] === undefined ||
-            descriptors["1"] === undefined)
-            return Result.fail(invalid("Duration tuple has unsupported fields or accessors"));
-        const seconds = descriptors["0"].value;
-        const nanos = descriptors["1"].value;
-        return Result.succeed([seconds, nanos]);
-    }
-    const fields = ownedData(input, ["weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"], "Duration");
-    return Result.isFailure(fields) ? Result.fail(fields.failure) : Result.succeed(fields.success);
-};
-const captureDuration = (input) => Effect.gen(function* () {
-    if (input === null || typeof input !== "object" || Duration.isDuration(input))
-        return input;
-    return yield* Effect.fromResult(durationData(input));
-});
-/**
- * A Duration option read as caller data: a data property, own or inherited,
- * captured without running any accessor. Rejections throw for `parsedInput`.
- */
-const optionDuration = (options, field, name) => {
-    let descriptor;
-    for (let owner = options; descriptor === undefined && owner !== null; owner = Object.getPrototypeOf(owner))
-        descriptor = Object.getOwnPropertyDescriptor(owner, field);
-    if (descriptor === undefined)
-        return undefined;
-    const reject = () => ReactorError.fromCode("InvalidInput", `${name} must be a Duration of data properties`);
-    if (!("value" in descriptor))
-        throw reject();
-    const value = descriptor.value;
-    if (value === undefined)
-        return undefined;
-    if (value === null)
-        throw reject();
-    if (typeof value !== "object" || Duration.isDuration(value))
-        return value;
-    const captured = durationData(value);
-    if (Result.isFailure(captured))
-        throw reject();
-    return captured.success;
-};
-const requestDuration = (input, name, allowZero = false) => Effect.gen(function* () {
-    const captured = yield* captureDuration(input);
-    return yield* parsedInput(() => Duration.toMillis(duration(captured, name, { allowZero, allowNegative: name === "startBy" })), "submit").pipe(Effect.mapError((error) => invalid(error.message)));
-});
-/** A continuity choice, read as caller data, checked against the request it would continue. */
-const captureContinuity = (input, request) => Effect.gen(function* () {
-    if (input === undefined)
-        return undefined;
-    if (input !== "previous")
-        return yield* invalid('Continuity is "previous" or absent');
-    if ((request.audio?.length ?? 0) > 2)
-        return yield* invalid("A clip that continues takes at most two audio references");
-    return "previous";
-});
-/** Enough cues for a line's overlays and actions, and a bound on one clip's timers. */
-const maxCues = 32;
-/** A clip's cues, read as caller data. */
-const captureCues = (input) => Effect.gen(function* () {
-    if (input === undefined)
-        return [];
-    if (!Array.isArray(input))
-        return yield* invalid("Cues must be an array");
-    // Read as a plain object: a mapped array type would hide the descriptors.
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    const length = descriptors.length?.value;
-    if (typeof length !== "number" || length > maxCues)
-        return yield* invalid(`A clip takes at most ${maxCues} cues`);
-    const cues = [];
-    for (let index = 0; index < length; index++) {
-        const descriptor = descriptors[String(index)];
-        if (descriptor === undefined || !("value" in descriptor))
-            return yield* invalid("Cues must be data");
-        const cue = yield* Effect.fromResult(ownedData(descriptor.value, ["name", "at"], "Cue"));
-        const at = yield* Effect.fromResult(ownedData(cue.at, ["from", "offset"], "Cue time"));
-        if (typeof cue.name !== "string" || cue.name.length === 0)
-            return yield* invalid("A cue needs a nonempty name");
-        if (at.from !== "start" && at.from !== "end")
-            return yield* invalid("A cue is timed from the start or the end");
-        cues.push({
-            name: cue.name,
-            from: at.from,
-            offsetMs: yield* requestDuration(at.offset, "cue offset", true),
-        });
-    }
-    return cues;
-});
-/** Capture scheduling fields before reading the request's placement fields. */
-/** A caller's clip request, without the placement and source fields the scheduler owns. */
-const captureClip = (input) => Effect.gen(function* () {
-    const request = yield* captureRequest(input);
-    if (request.position !== undefined ||
-        request.before !== undefined ||
-        request.sameSessionAs !== undefined ||
-        request.continueFrom !== undefined ||
-        request.sequence !== undefined)
-        return yield* invalid("Scheduler owns placement and source selection");
-    return request;
-});
-/** A window's offsets from admission, read as caller data. */
-const captureWindow = (input) => Effect.gen(function* () {
-    const window = input === undefined
-        ? undefined
-        : yield* Effect.fromResult(ownedData(input, ["notBefore", "startBy", "firm"], "Scheduled window"));
-    const notBeforeOffsetMs = window?.notBefore === undefined
-        ? undefined
-        : yield* requestDuration(window.notBefore, "notBefore", true);
-    const startByOffsetMs = window?.startBy === undefined
-        ? undefined
-        : yield* requestDuration(window.startBy, "startBy", true);
-    if (window !== undefined &&
-        (typeof window.firm !== "boolean" ||
-            (notBeforeOffsetMs !== undefined &&
-                startByOffsetMs !== undefined &&
-                startByOffsetMs >= 0 &&
-                notBeforeOffsetMs > startByOffsetMs)))
-        return yield* invalid("Scheduled window is inconsistent");
-    return { notBeforeOffsetMs, startByOffsetMs, firm: window?.firm === true };
-});
-const captureItem = (input, lanes) => Effect.gen(function* () {
-    if (input === null || typeof input !== "object" || Array.isArray(input))
-        return yield* invalid("Scheduled item must be an object");
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    if (Object.getOwnPropertySymbols(input).length > 0 ||
-        Object.keys(descriptors).some((field) => !["key", "lane", "request", "window", "start", "cues", "continuity"].includes(field) ||
-            !("value" in descriptors[field])))
-        return yield* invalid("Scheduled item has unsupported fields or accessors");
-    const key = yield* Schema.decodeUnknownEffect(ItemKey)(descriptors.key?.value).pipe(Effect.mapError(() => invalid("Scheduled item key must be nonempty")));
-    if (isReservedSchedulerKey(key))
-        return yield* invalid("Scheduled item key is reserved");
-    const lane = descriptors.lane?.value;
-    if (typeof lane !== "string" || !lanes.has(lane))
-        return yield* invalid("Scheduled item lane is not configured");
-    const request = yield* captureClip(descriptors.request?.value);
-    const { notBeforeOffsetMs, startByOffsetMs, firm } = yield* captureWindow(descriptors.window?.value);
-    const cues = yield* captureCues(descriptors.cues?.value);
-    const continuity = yield* captureContinuity(descriptors.continuity?.value, request);
-    const rawStart = descriptors.start?.value;
-    const start = rawStart === undefined
-        ? undefined
-        : yield* Effect.fromResult(ownedData(rawStart, ["_tag", "time", "late"], "Scheduled start mode"));
-    let atWallMs;
-    let late = "nextBoundary";
-    const mode = start?._tag === "Asap" ? "asap" : start?._tag === "Manual" ? "manual" : undefined;
-    if ((start?._tag === "Follow" || mode !== undefined) &&
-        (start?.time !== undefined || start?.late !== undefined))
-        return yield* invalid(`${String(start?._tag)} cannot contain an anchor or lateness policy`);
-    if (start !== undefined && start._tag !== "Follow" && mode === undefined) {
-        if (start._tag !== "At" || !Number.isFinite(start.time))
-            return yield* invalid("Scheduled start mode is invalid");
-        atWallMs = start.time;
-        const policy = yield* Effect.fromResult(ownedData(start.late, ["_tag", "by"], "Scheduled lateness policy"));
-        if (policy._tag === "drop" && policy.by === undefined)
-            late = "drop";
-        else if (policy._tag === "skipIfLaterThan")
-            late = {
-                skipIfLaterThanMs: yield* requestDuration(policy.by, "skipIfLaterThan", true),
-            };
-        else if (policy._tag !== "nextBoundary" || policy.by !== undefined)
-            return yield* invalid("Scheduled lateness policy is invalid");
-    }
-    return {
-        key,
-        lane,
-        request,
-        notBeforeOffsetMs,
-        startByOffsetMs,
-        firm,
-        atWallMs,
-        late,
-        ...(mode === undefined ? {} : { mode }),
-        ...(cues.length === 0 ? {} : { cues }),
-        ...(continuity === undefined ? {} : { continuity }),
-        fingerprint: JSON.stringify({
-            lane,
-            request,
-            notBeforeOffsetMs,
-            startByOffsetMs,
-            firm,
-            atWallMs,
-            late,
-            mode,
-            ...(cues.length === 0 ? {} : { cues }),
-            ...(continuity === undefined ? {} : { continuity }),
-        }),
-    };
-});
-/** Enough parts for a spoken line of beats, and a bound on one submission's work. */
-const maxGroupParts = 64;
-const captureGroup = (input, lanes) => Effect.gen(function* () {
-    const group = yield* Effect.fromResult(ownedData(input, ["key", "lane", "parts", "window"], "Scheduled group"));
-    const key = yield* Schema.decodeUnknownEffect(ItemKey)(group.key).pipe(Effect.mapError(() => invalid("Scheduled group key must be nonempty")));
-    if (isReservedSchedulerKey(key))
-        return yield* invalid("Scheduled group key is reserved");
-    if (!Array.isArray(group.parts))
-        return yield* invalid("Scheduled group parts must be an array");
-    // Read as a plain object: a mapped array type would hide the descriptors.
-    const descriptors = Object.getOwnPropertyDescriptors(group.parts);
-    const length = descriptors.length?.value;
-    if (typeof length !== "number" || length < 1 || length > maxGroupParts)
-        return yield* invalid(`Scheduled group needs 1 to ${maxGroupParts} parts`);
-    const parts = [];
-    for (let index = 0; index < length; index++) {
-        const descriptor = descriptors[String(index)];
-        if (descriptor === undefined || !("value" in descriptor))
-            return yield* invalid("Scheduled group parts must be data");
-        const part = yield* Effect.fromResult(ownedData(descriptor.value, ["key", "request", "cues", "continuity"], "Scheduled group part"));
-        parts.push(yield* captureItem({
-            key: part.key,
-            lane: group.lane,
-            request: part.request,
-            ...(part.cues === undefined ? {} : { cues: part.cues }),
-            ...(part.continuity === undefined ? {} : { continuity: part.continuity }),
-            ...(index === 0 && group.window !== undefined ? { window: group.window } : {}),
-        }, lanes));
-    }
-    const [first, ...rest] = parts;
-    if (first === undefined || new Set([key, ...parts.map((part) => part.key)]).size !== length + 1)
-        return yield* invalid("Scheduled group and part keys must be distinct");
-    return {
-        key,
-        parts: [first, ...rest],
-        fingerprint: JSON.stringify(parts.map((part) => [part.key, part.fingerprint])),
-    };
-});
-const captureReplacement = (input) => Effect.gen(function* () {
-    const next = yield* Effect.fromResult(ownedData(input, ["key", "request", "cues", "continuity"], "Replacement"));
-    const key = yield* Schema.decodeUnknownEffect(ItemKey)(next.key).pipe(Effect.mapError(() => invalid("Replacement key must be nonempty")));
-    if (isReservedSchedulerKey(key))
-        return yield* invalid("Replacement key is reserved");
-    const request = yield* captureClip(next.request);
-    return {
-        key,
-        request,
-        cues: yield* captureCues(next.cues),
-        continuity: yield* captureContinuity(next.continuity, request),
-    };
-});
-const captureInsert = (input) => Effect.gen(function* () {
-    const spec = yield* Effect.fromResult(ownedData(input, ["key", "request", "before", "after", "window", "cues", "continuity"], "Insert"));
-    const key = yield* Schema.decodeUnknownEffect(ItemKey)(spec.key).pipe(Effect.mapError(() => invalid("Insert key must be nonempty")));
-    if (isReservedSchedulerKey(key))
-        return yield* invalid("Insert key is reserved");
-    if ((spec.before === undefined) === (spec.after === undefined))
-        return yield* invalid("Insert needs exactly one of before or after");
-    const side = spec.before === undefined ? "after" : "before";
-    const anchor = yield* Schema.decodeUnknownEffect(ItemKey)(spec.before ?? spec.after).pipe(Effect.mapError(() => invalid("Insert anchor must be a nonempty key")));
-    const request = yield* captureClip(spec.request);
-    const window = yield* captureWindow(spec.window);
-    const cues = yield* captureCues(spec.cues);
-    const continuity = yield* captureContinuity(spec.continuity, request);
-    return {
-        key,
-        request,
-        side,
-        anchor,
-        ...window,
-        cues,
-        continuity,
-        fingerprint: JSON.stringify({
-            [side]: anchor,
-            request,
-            ...window,
-            ...(cues.length === 0 ? {} : { cues }),
-            ...(continuity === undefined ? {} : { continuity }),
-        }),
-    };
-});
-/** A bound on one batch's work, generous for a spoken plan of several lines. */
-const maxEdits = 256;
-const editKey = (input, name) => Schema.decodeUnknownEffect(ItemKey)(input).pipe(Effect.mapError(() => invalid(`${name} must be a nonempty key`)));
-const captureEdits = (input, lanes) => Effect.gen(function* () {
-    if (!Array.isArray(input))
-        return yield* invalid("Edits must be an array");
-    // Read as a plain object: a mapped array type would hide the descriptors.
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    const length = descriptors.length?.value;
-    if (typeof length !== "number" || length < 1 || length > maxEdits)
-        return yield* invalid(`An edit batch needs 1 to ${maxEdits} edits`);
-    const edits = [];
-    for (let index = 0; index < length; index++) {
-        const descriptor = descriptors[String(index)];
-        if (descriptor === undefined || !("value" in descriptor))
-            return yield* invalid("Edits must be data");
-        const raw = descriptor.value;
-        const tag = raw !== null && typeof raw === "object"
-            ? Object.getOwnPropertyDescriptor(raw, "_tag")?.value
-            : undefined;
-        switch (tag) {
-            case "Submit": {
-                const edit = yield* Effect.fromResult(ownedData(raw, ["_tag", "item"], "Edit"));
-                edits.push({ _tag: "Submit", item: yield* captureItem(edit.item, lanes) });
-                break;
-            }
-            case "SubmitGroup": {
-                const edit = yield* Effect.fromResult(ownedData(raw, ["_tag", "group"], "Edit"));
-                edits.push({
-                    _tag: "SubmitGroup",
-                    group: yield* captureGroup(edit.group, lanes),
-                });
-                break;
-            }
-            case "Insert": {
-                const edit = yield* Effect.fromResult(ownedData(raw, ["_tag", "insert"], "Edit"));
-                edits.push({ _tag: "Insert", insert: yield* captureInsert(edit.insert) });
-                break;
-            }
-            case "Replace": {
-                const edit = yield* Effect.fromResult(ownedData(raw, ["_tag", "key", "next"], "Edit"));
-                edits.push({
-                    _tag: "Replace",
-                    key: yield* editKey(edit.key, "A replaced key"),
-                    next: yield* captureReplacement(edit.next),
-                });
-                break;
-            }
-            case "Withdraw": {
-                const edit = yield* Effect.fromResult(ownedData(raw, ["_tag", "key"], "Edit"));
-                edits.push({ _tag: "Withdraw", key: yield* editKey(edit.key, "A withdrawn key") });
-                break;
-            }
-            default:
-                return yield* invalid("An edit's _tag is not one the scheduler knows");
-        }
-    }
-    return edits;
-});
-export const lineup = (filler) => ({
-    lanes: [{ name: "line" }],
-    filler,
-});
-export class Scheduler extends Context.Service()("reactor-effect-client/Orchestration/Scheduler") {
-    static lineup = lineup;
-}
-export const makeScheduler = (options) => Effect.gen(function* () {
-    const engine = yield* Engine;
-    const clock = yield* Clock.Clock;
-    const lanes = yield* parsedInput(() => {
-        if (options.lanes.length === 0 ||
-            options.lanes.some((lane) => typeof lane.name !== "string" || lane.name.length === 0) ||
-            new Set(options.lanes.map((lane) => lane.name)).size !== options.lanes.length)
-            throw ReactorError.fromCode("InvalidInput", "Scheduler lanes must be unique and nonempty");
-        if (options.lanes.some((lane) => (lane.conflict !== undefined &&
-            !["queue", "replace", "skip"].includes(lane.conflict)) ||
-            (lane.cut !== undefined && typeof lane.cut !== "boolean")))
-            throw ReactorError.fromCode("InvalidInput", "A lane's conflict or cut is invalid");
-        return options.lanes.map((lane) => lane.name);
-    }, "makeScheduler");
-    const conflicts = new Map(options.lanes.map((lane) => [lane.name, lane.conflict ?? "queue"]));
-    const cutLanes = new Set(options.lanes.filter((lane) => lane.cut === true).map((lane) => lane.name));
-    const { floorSeconds, targetSeconds, maxBuildsInFlight, maxHistory, unknownRecoveryMs, fillLengths, } = yield* parsedInput(() => {
-        const floorSeconds = Duration.toMillis(duration(options.filler.runway.floor, "runway floor", { allowZero: true })) / 1000;
-        const targetSeconds = Duration.toMillis(duration(options.filler.runway.target, "runway target")) / 1000;
-        const maxBuildsInFlight = options.maxBuildsInFlight ?? 1;
-        const maxHistory = options.maxHistory ?? 4096;
-        const unknownRecoveryMs = Duration.toMillis(duration(optionDuration(options, "unknownRecoveryTimeout", "Unknown recovery timeout") ??
-            "60 seconds", "unknown recovery timeout", { maximum: "10 minutes" }));
-        if (floorSeconds > targetSeconds ||
-            !Number.isSafeInteger(maxBuildsInFlight) ||
-            maxBuildsInFlight < 1 ||
-            maxBuildsInFlight > 1024 ||
-            !Number.isSafeInteger(maxHistory) ||
-            maxHistory < 0 ||
-            maxHistory > 65_536)
-            throw ReactorError.fromCode("InvalidInput", "Scheduler runway or build cap is invalid");
-        const lengths = options.filler.lengths;
-        const fillLengths = {
-            min: lengths === undefined
-                ? h3RequestSeconds.min
-                : Duration.toMillis(duration(lengths.min, "filler minimum length")) / 1000,
-            max: lengths === undefined
-                ? h3RequestSeconds.max
-                : Duration.toMillis(duration(lengths.max, "filler maximum length")) / 1000,
-        };
-        if (fillLengths.min > fillLengths.max)
-            throw ReactorError.fromCode("InvalidInput", "Filler lengths are inconsistent");
-        return {
-            floorSeconds,
-            targetSeconds,
-            maxBuildsInFlight,
-            maxHistory,
-            unknownRecoveryMs,
-            fillLengths,
-        };
-    }, "makeScheduler");
-    const captureFiller = (index, runway, durationSeconds, targetSeconds) => Effect.gen(function* () {
-        const request = yield* captureRequest(options.filler.clip({
-            index,
-            runwaySeconds: runway,
-            durationSeconds,
-            ...(targetSeconds === undefined ? {} : { targetSeconds }),
-        }));
-        if (request.position !== undefined ||
-            request.before !== undefined ||
-            request.sameSessionAs !== undefined ||
-            request.continueFrom !== undefined ||
-            request.sequence !== undefined)
-            return yield* PolicyFailure.refuse("InvalidRequest", "Scheduler filler cannot choose placement or source");
-        return request;
-    });
-    let fillerIndex = 0;
-    let fillerRetryAtMs = 0;
-    const unknownFillers = new Map();
-    const maxUnknownFillers = 4096;
-    let upcomingFiller = yield* captureFiller(0, 0, fillLengths.min);
-    const actorScope = yield* Effect.scope;
-    const inbox = yield* Queue.unbounded();
-    const commandQueue = yield* Queue.unbounded();
-    const events = yield* PubSub.unbounded();
-    const cueEvents = yield* PubSub.unbounded();
-    yield* Effect.addFinalizer(() => Effect.gen(function* () {
-        yield* Queue.shutdown(commandQueue);
-        yield* Queue.shutdown(inbox);
-        yield* PubSub.shutdown(events);
-        yield* PubSub.shutdown(cueEvents);
-    }));
-    const stateRef = yield* SubscriptionRef.make({
-        accepting: true,
-        runwaySeconds: 0,
-        playing: null,
-        lanes: lanes.map((name) => ({ name, keys: [] })),
-        sessions: [],
-        starved: 0,
-        estimates: { build: undefined, length: 1 },
-    });
-    const initialized = yield* Deferred.make();
-    const stopped = yield* Deferred.make();
-    const settled = yield* Deferred.make();
-    const closedCall = Deferred.await(stopped).pipe(Effect.flatMap((cause) => PolicyFailure.refuse("SessionClosed", cause.message)));
-    const items = new Map();
-    const history = new Map();
-    /** Kept while any part is active or in history, for idempotency and withdrawal. */
-    const groups = new Map();
-    const owned = new Map();
-    // An event can overtake its enqueue reply. Keep only the evidence needed to
-    // decide that clip's fate until the one in-flight command returns its ID.
-    const earlyClipEvents = new Map();
-    const removedIds = new Set();
-    const filler = new Map();
-    const playingStartedMs = new Map();
-    let admission = 0;
-    let accepting = true;
-    let starved = 0;
-    let refillActive = false;
-    let ended;
-    let drainFailure;
-    const drainReplies = [];
-    const pendingWithdrawals = new Map();
-    /** Edit batches that have not taken effect yet. */
-    const batches = new Map();
-    let batchCount = 0;
-    const pendingBuilds = new Set();
-    // A Build whose enqueue has started and whose result the worker has not
-    // yet seen. The provider may still accept it after the scheduler ends.
-    let dispatching;
-    const pendingAtDeferrals = new Set();
-    const pendingItemRemovals = new Set();
-    const pendingFillerRemovals = new Set();
-    const removalRetryAtMs = new Map();
-    const removalUnknownAtSerial = new Map();
-    let commandCount = 0;
-    let snapshotAcquiredSerial = 0;
-    let lastProcessedSnapshotSerial = 0;
-    let draining = false;
-    let finishAccepted = false;
-    let autoplayPaused = false;
-    let drained = false;
-    let observationReady = false;
-    let blockedMove;
-    let blockedCut;
-    // Recent measured builds: build seconds per requested second, and actual over requested length.
-    const buildSamples = [];
-    const lengthSamples = [];
-    const maxSamples = 32;
-    let lastFillerSeconds;
-    /** Filler builds sent and not yet Ready, by filler index. */
-    const fillerDispatch = new Map();
-    const measure = (atMs, requested, actual) => {
-        if (!(requested > 0))
-            return;
-        buildSamples.push((monotonicMillis(clock) - atMs) / 1000 / requested);
-        lengthSamples.push(actual / requested);
-        if (buildSamples.length > maxSamples)
-            buildSamples.shift();
-        if (lengthSamples.length > maxSamples)
-            lengthSamples.shift();
-    };
-    /** An item's build is measured once, when its clip is first seen Ready. */
-    const measureItem = (item, actual) => {
-        if (item.dispatchedAtMs === undefined)
-            return;
-        measure(item.dispatchedAtMs, item.request.durationSeconds, actual);
-        delete item.dispatchedAtMs;
-    };
-    /** Fires the cues of a playing item that are due by `untilMs`, in the order they fall. */
-    const fireCues = (entry, untilMs) => {
-        if (entry.status._tag !== "Started" || entry.startedAtMonoMs === undefined)
-            return;
-        for (const due of dueCues(entry.cues, entry.firedCues, entry.startedAtMonoMs, entry.status.durationSeconds, untilMs)) {
-            entry.firedCues.add(due);
-            PubSub.publishUnsafe(cueEvents, {
-                key: entry.key,
-                name: entry.cues[due].name,
-                at: clock.currentTimeMillisUnsafe(),
-            });
-        }
-    };
-    const emit = (entry, status, terminal = false) => Effect.gen(function* () {
-        if (ended !== undefined && !terminal)
-            return;
-        if (JSON.stringify(entry.status) === JSON.stringify(status))
-            return;
-        // A clip that ends fires only the cues that fell within the airtime it had.
-        if (status._tag === "Ended" && entry.startedAtMonoMs !== undefined)
-            fireCues(entry, entry.startedAtMonoMs +
-                1000 *
-                    (status.termination === "finished" && entry.status._tag === "Started"
-                        ? Math.max(status.airedSeconds, entry.status.durationSeconds)
-                        : status.airedSeconds));
-        entry.status = status;
-        entry.phase =
-            status._tag === "Accepted" ||
-                status._tag === "Building" ||
-                status._tag === "Ready" ||
-                status._tag === "Started"
-                ? status._tag
-                : status._tag === "Unknown" && status.terminal !== true
-                    ? "Unknown"
-                    : "Terminal";
-        const replaced = entry.replaces === undefined ? undefined : items.get(entry.replaces);
-        if (entry.group !== undefined &&
-            entry.inserted !== true &&
-            (status._tag === "Failed" || status._tag === "Dropped") &&
-            !(status._tag === "Dropped" && status.reason === "replaced") &&
-            (replaced === undefined || replaced.phase === "Terminal")) {
-            const group = groups.get(entry.group.key);
-            if (group !== undefined)
-                group.brokenAt = Math.min(group.brokenAt ?? entry.group.index, entry.group.index);
-        }
-        // Publish in the step that records it (the PubSub is unbounded): a claim
-        // from another fiber cannot land between the two, so asRun never carries
-        // a settlement ahead of a recorded status, nor omits one.
-        PubSub.publishUnsafe(events, {
-            key: entry.key,
-            at: clock.currentTimeMillisUnsafe(),
-            status,
-        });
-        if (isFirstDecisive(status))
-            yield* Deferred.succeed(entry.firstDecisiveWaiter, status);
-        if (status._tag === "Started")
-            yield* Deferred.succeed(entry.startedWaiter, status);
-        if (status._tag === "Ended" ||
-            status._tag === "Dropped" ||
-            status._tag === "Failed" ||
-            status._tag === "Unobserved" ||
-            (status._tag === "Unknown" && status.terminal === true)) {
-            yield* Deferred.succeed(entry.startedWaiter, status);
-            yield* Deferred.succeed(entry.outcomeWaiter, status);
-        }
-    });
-    // The claim is synchronous; interruption masking alone would still allow
-    // two closers to publish conflicting results. Join only local bookkeeping,
-    // never the worker scope (a worker can itself own terminal settlement).
-    const terminate = (terminal) => Effect.suspend(() => {
-        if (ended !== undefined)
-            return Deferred.await(settled);
-        ended = terminal;
-        accepting = false;
-        // Wake the watchdog so an episode left armed by another owner cannot
-        // keep re-arming its timer.
-        Deferred.doneUnsafe(recoveryChanged, Exit.void);
-        return Effect.gen(function* () {
-            for (const item of items.values()) {
-                if (Exit.isFailure(terminal)) {
-                    yield* Deferred.failCause(item.startedWaiter, terminal.cause);
-                    yield* Deferred.failCause(item.outcomeWaiter, terminal.cause);
-                    yield* Deferred.failCause(item.firstDecisiveWaiter, terminal.cause);
-                    continue;
-                }
-                // emit records and publishes a status before completing its waits,
-                // and a claim can land in between: a completion can resume an
-                // observer that closes the owner, and another fiber can claim while
-                // the actor is preempted. Finish those waits from the record.
-                const recorded = item.status;
-                if (item.phase === "Started" || item.phase === "Terminal") {
-                    if (isFirstDecisive(recorded))
-                        yield* Deferred.succeed(item.firstDecisiveWaiter, recorded);
-                    yield* Deferred.succeed(item.startedWaiter, recorded);
-                }
-                if (item.phase === "Terminal")
-                    yield* Deferred.succeed(item.outcomeWaiter, recorded);
-                else
-                    yield* emit(item, item.phase === "Unknown" ||
-                        (item.clipId === undefined &&
-                            (item.unknownAtMs !== undefined || item.key === dispatching))
-                        ? { _tag: "Unknown", terminal: true }
-                        : { _tag: "Failed", reason: { _tag: "Scheduler", cause: terminal.value } }, true);
-            }
-            const closed = Exit.isSuccess(terminal)
-                ? Exit.fail(PolicyFailure.refuse("SessionClosed", terminal.value.message))
-                : Exit.failCause(terminal.cause);
-            for (const [key, pending] of pendingWithdrawals) {
-                // A drop recorded before the claim is the withdrawal's actual result.
-                const reply = Exit.isSuccess(terminal) && items.get(key)?.status._tag === "Dropped"
-                    ? Exit.succeed("withdrawn")
-                    : closed;
-                for (const waiter of pending.replies)
-                    yield* Deferred.done(waiter, reply);
-            }
-            pendingWithdrawals.clear();
-            for (const batch of batches.values()) {
-                for (const target of batch.targets.values())
-                    if (target.reply !== undefined)
-                        yield* Deferred.done(target.reply, closed);
-                yield* Deferred.done(batch.committed, closed);
-            }
-            batches.clear();
-            for (const reply of drainReplies.splice(0))
-                yield* Deferred.done(reply, closed);
-            yield* SubscriptionRef.update(stateRef, (state) => ({ ...state, accepting: false }));
-            yield* Deferred.done(initialized, Exit.isFailure(terminal)
-                ? Exit.failCause(terminal.cause)
-                : Exit.fail(ReactorError.fromCode("Closed", terminal.value.message)));
-            // Supervisors may close the owner immediately when this wakes them.
-            yield* Deferred.done(stopped, terminal);
-        }).pipe(Effect.onExit((exit) => Effect.gen(function* () {
-            // A bookkeeping defect must release joiners with that Cause, never
-            // leave an unfinished latch or report a partial settlement as success.
-            yield* Deferred.done(settled, exit);
-            if (Exit.isFailure(exit)) {
-                yield* Deferred.failCause(initialized, exit.cause);
-                yield* Deferred.failCause(stopped, exit.cause);
-            }
-        })));
-    }).pipe(Effect.uninterruptible);
-    const closeActor = (cause) => terminate(Exit.succeed(cause));
-    let recoveryState;
-    let capacityRecovery;
-    let recoveryDeadline;
-    let recoveryChanged = Deferred.makeUnsafe();
-    // Retain the original age while Closing hides the old source and acquisition
-    // is still pending. Only accepted evidence or a Ready replacement clears it.
-    const updateRecovery = (state = recoveryState, fresh) => {
-        if (ended !== undefined)
-            return;
-        recoveryState = state;
-        const preferred = state === undefined ? undefined : Option.getOrUndefined(state.preferredSessionId);
-        const ready = preferred !== undefined &&
-            state?.sessions.some((source) => source.sessionId === preferred && source.availability === "Ready") === true;
-        let earliest;
-        let drainDeadline;
-        const consider = (atMs, sessionId, cause, newlyObserved = false) => {
-            const deadlineMs = atMs + unknownRecoveryMs;
-            if (((!ready && newlyObserved) || sessionId === undefined || sessionId === preferred) &&
-                (earliest === undefined || deadlineMs < earliest.deadlineMs))
-                earliest = { deadlineMs, sessionId, cause };
-            if (draining && (drainDeadline === undefined || deadlineMs < drainDeadline.deadlineMs))
-                drainDeadline = { deadlineMs, sessionId, cause };
-        };
-        for (const entry of unknownFillers.values())
-            consider(entry.atMs, entry.sessionId, entry.cause);
-        for (const item of items.values())
-            if (item.phase !== "Terminal" &&
-                item.clipId === undefined &&
-                item.unknownAtMs !== undefined &&
-                item.unknownCause !== undefined)
-                consider(item.unknownAtMs, item.unknownSessionId, item.unknownCause);
-        if (fresh !== undefined)
-            consider(fresh.atMs, fresh.sessionId, fresh.cause, true);
-        if (ready &&
-            (earliest === undefined ||
-                (capacityRecovery?.sessionId !== undefined && capacityRecovery.sessionId !== preferred)))
-            capacityRecovery = undefined;
-        if (earliest !== undefined &&
-            (capacityRecovery === undefined || earliest.deadlineMs < capacityRecovery.deadlineMs))
-            capacityRecovery = earliest;
-        const next = drainDeadline !== undefined &&
-            (capacityRecovery === undefined || drainDeadline.deadlineMs < capacityRecovery.deadlineMs)
-            ? drainDeadline
-            : capacityRecovery;
-        if (next?.deadlineMs !== recoveryDeadline?.deadlineMs ||
-            next?.cause !== recoveryDeadline?.cause) {
-            recoveryDeadline = next;
-            Deferred.doneUnsafe(recoveryChanged, Exit.void);
-        }
-    };
-    const provedUnknown = (atMs) => {
-        if (atMs !== undefined && capacityRecovery?.deadlineMs === atMs + unknownRecoveryMs)
-            capacityRecovery = undefined;
-    };
-    const watchdog = Effect.gen(function* () {
-        for (;;) {
-            // A committed result and its queued actor evidence can arrive in one
-            // turn. Coalesce those revisions before allocating a replacement timer;
-            // the original monotonic deadline remains unchanged.
-            yield* Effect.yieldNow;
-            if (ended !== undefined)
-                return;
-            recoveryChanged = Deferred.makeUnsafe();
-            const episode = recoveryDeadline;
-            if (episode === undefined) {
-                yield* Deferred.await(recoveryChanged);
-                continue;
-            }
-            yield* Deferred.await(recoveryChanged).pipe(Effect.timeoutOrElse({
-                duration: Math.max(0, episode.deadlineMs - monotonicMillis(clock)),
-                orElse: () => Effect.void,
-            }));
-            // A canceled timer may already have resumed. Recheck the retained
-            // identity without awaiting the actor, Engine state, or its permits.
-            if (ended === undefined &&
-                recoveryDeadline === episode &&
-                monotonicMillis(clock) >= episode.deadlineMs) {
-                const causes = new Set([episode.cause]);
-                for (const item of items.values())
-                    if (item.unknownCause !== undefined)
-                        causes.add(item.unknownCause);
-                for (const entry of unknownFillers.values())
-                    causes.add(entry.cause);
-                yield* closeActor(ReactorError.fromCode("Timeout", "Scheduler unknown recovery deadline elapsed", {
-                    operation: "scheduler.unknownRecovery",
-                    detail: [...causes],
-                }));
-                return;
-            }
-        }
-    });
-    const prune = (state) => {
-        const active = new Set(activeIds(state));
-        if (state.availability === "Ready") {
-            for (const id of removedIds)
-                if (!active.has(id))
-                    removedIds.delete(id);
-            for (const id of removalRetryAtMs.keys())
-                if (!active.has(id))
-                    removalRetryAtMs.delete(id);
-            for (const id of removalUnknownAtSerial.keys())
-                if (!active.has(id))
-                    removalUnknownAtSerial.delete(id);
-        }
-        for (const [key, item] of items) {
-            if (item.phase !== "Terminal" ||
-                pendingBuilds.has(key) ||
-                pendingWithdrawals.has(key) ||
-                pendingAtDeferrals.has(key) ||
-                pendingItemRemovals.has(key) ||
-                [...batches.values()].some((batch) => batch.targets.has(key)) ||
-                // A replacement dropped before it was built still links its own replacement to
-                // the item in the place.
-                [...items.values()].some((other) => other.replaces === key && other.phase !== "Terminal") ||
-                (item.clipId !== undefined && active.has(item.clipId)))
-                continue;
-            if (item.clipId !== undefined) {
-                owned.delete(item.clipId);
-                playingStartedMs.delete(item.clipId);
-            }
-            history.set(key, { fingerprint: item.fingerprint, handle: item.handle });
-            items.delete(key);
-        }
-        while (history.size > maxHistory)
-            history.delete(history.keys().next().value);
-        for (const [key, group] of groups)
-            if (!group.parts.some((part) => items.has(part) || history.has(part)))
-                groups.delete(key);
-    };
-    // Capture membership and public rows in one pass. A fresh token reads every
-    // source on every observation, including in-place changes to Engine arrays;
-    // frozen empty rows can be shared by every published state without treating
-    // array identity as proof.
-    const noReady = Object.freeze([]);
-    const sourceRows = new Map();
-    const projectSources = (state) => {
-        const seen = Symbol();
-        const sessions = state.sessions.map(({ sessionId }) => {
-            let cached = sourceRows.get(sessionId);
-            if (cached === undefined) {
-                cached = { empty: Object.freeze({ sessionId, ready: noReady }), seen };
-                sourceRows.set(sessionId, cached);
-            }
-            else
-                cached.seen = seen;
-            if (state.ready.length === 0)
-                return cached.empty;
-            return {
-                sessionId,
-                ready: state.ready
-                    .filter((clip) => clip.sessionId === sessionId)
-                    .map((clip) => {
-                    const owner = owned.get(clip.clipId);
-                    return owner === undefined ? "other" : owner._tag === "Filler" ? "filler" : owner.key;
-                }),
-            };
-        });
-        // Bound cached rows by snapshot size without scanning unchanged overlap.
-        // Membership still requires this observation's token, even before pruning.
-        if (sourceRows.size > state.sessions.length)
-            for (const [id, cached] of sourceRows)
-                if (cached.seen !== seen)
-                    sourceRows.delete(id);
-        // Only the serialized actor uses this membership view, before its next projection.
-        return { sessions, has: (id) => sourceRows.get(id)?.seen === seen };
-    };
-    const publishState = (state, sessions = projectSources(state).sessions) => {
-        const playing = Option.getOrUndefined(state.playing);
-        const playingOwner = playing === undefined ? undefined : owned.get(playing.clipId);
-        const playingKey = playing === undefined
-            ? null
-            : playingOwner === undefined
-                ? "other"
-                : playingOwner._tag === "Filler"
-                    ? "filler"
-                    : playingOwner.key;
-        return SubscriptionRef.set(stateRef, {
-            accepting,
-            runwaySeconds: runwaySeconds(state, monotonicMillis(clock), playingStartedMs, owned, [
-                ...items.values(),
-            ]),
-            playing: playingKey,
-            lanes: lanes.map((name) => ({
-                name,
-                keys: [...items.values()]
-                    .filter((item) => item.lane === name && item.phase !== "Terminal")
-                    .map((item) => item.key),
-            })),
-            sessions,
-            starved,
-            estimates: estimatesFrom(buildSamples, lengthSamples),
-        });
-    };
-    /** When the filler build in flight was sent, and the next filler clip's requested length. */
-    const fillerView = () => ({
-        fillerDispatchedAtMs: fillerDispatch.size === 0
-            ? undefined
-            : Math.min(...[...fillerDispatch.values()].map((sent) => sent.atMs)),
-        fillerSeconds: upcomingFiller?.durationSeconds ?? lastFillerSeconds,
-    });
-    const activeRecords = (state) => [
-        ...state.queued,
-        ...state.ready,
-        ...Option.match(state.building, {
-            onNone: () => [],
-            onSome: (build) => [build.record],
-        }),
-        ...Option.match(state.playing, {
-            onNone: () => [],
-            onSome: (playing) => Option.match(playing.record, {
-                onNone: () => [],
-                onSome: (record) => [record],
-            }),
-        }),
-    ];
-    const knownRecord = (state, clipId) => activeRecords(state).find((record) => record.clipId === clipId);
-    const refreshAnchors = () => {
-        const nowMs = monotonicMillis(clock);
-        const wallMs = clock.currentTimeMillisUnsafe();
-        for (const item of items.values())
-            if (item.atWallMs !== undefined)
-                item.atMs = nowMs + item.atWallMs - wallMs;
-    };
-    const observed = (state, recoverMissing = false) => Effect.gen(function* () {
-        const active = new Set(activeIds(state));
-        if (recoverMissing) {
-            for (const [clipId, owner] of owned) {
-                if (owner._tag !== "Filler" || active.has(clipId))
-                    continue;
-                const tracked = filler.get(owner.index);
-                if (tracked?.clipId === clipId &&
-                    tracked?.acknowledgedAtSnapshotSerial !== undefined &&
-                    lastProcessedSnapshotSerial <= tracked.acknowledgedAtSnapshotSerial)
-                    continue;
-                const sessionId = owner.sessionId;
-                const source = state.sessions.find((entry) => entry.sessionId === sessionId);
-                if (sessionId === undefined
-                    ? state.availability !== "Ready"
-                    : source !== undefined && source.availability !== "Ready")
-                    continue;
-                owned.delete(clipId);
-                if (tracked?.clipId === clipId)
-                    filler.delete(owner.index);
-                playingStartedMs.delete(clipId);
-                pendingFillerRemovals.delete(clipId);
-            }
-        }
-        const keyed = new Map();
-        for (const record of activeRecords(state)) {
-            const key = keyFromProviderMetadata(record.provider.metadata);
-            if (key !== undefined && !removedIds.has(record.clipId))
-                keyed.set(key, record);
-            const index = fillerIndexFromKey(key);
-            if (index === undefined || removedIds.has(record.clipId))
-                continue;
-            const existing = owned.get(record.clipId);
-            if (existing?._tag === "Filler") {
-                if (existing.sessionId !== record.sessionId)
-                    owned.set(record.clipId, { ...existing, sessionId: record.sessionId });
-                const tracked = filler.get(index);
-                if (tracked?.clipId === record.clipId)
-                    tracked.sessionId = record.sessionId;
-                continue;
-            }
-            if (existing !== undefined)
-                continue;
-            owned.set(record.clipId, { _tag: "Filler", index, sessionId: record.sessionId });
-            filler.set(index, { index, clipId: record.clipId, sessionId: record.sessionId });
-            const priorIndex = fillerIndex;
-            fillerIndex = Math.max(fillerIndex, index + 1);
-            provedUnknown(unknownFillers.get(index)?.atMs);
-            unknownFillers.delete(index);
-            if (fillerIndex !== priorIndex)
-                upcomingFiller = undefined;
-        }
-        for (const item of items.values()) {
-            if (item.phase === "Terminal")
-                continue;
-            if (item.clipId === undefined) {
-                const resumed = keyed.get(item.key);
-                if (resumed !== undefined) {
-                    item.clipId = resumed.clipId;
-                    item.sessionId = resumed.sessionId;
-                    provedUnknown(item.unknownAtMs);
-                    item.unknownAtMs = undefined;
-                    item.unknownCause = undefined;
-                    item.unknownSessionId = undefined;
-                    owned.set(resumed.clipId, { _tag: "Item", key: item.key });
-                }
-            }
-            const clipId = item.clipId;
-            if (clipId === undefined)
-                continue;
-            const playing = Option.getOrUndefined(state.playing);
-            if (playing?.clipId === clipId) {
-                const record = Option.getOrUndefined(playing.record);
-                const at = Option.getOrUndefined(playing.startedAt);
-                const startedAtMonotonicMillis = playing.startedAtMonotonicMillis;
-                if (record !== undefined &&
-                    at !== undefined &&
-                    startedAtMonotonicMillis !== undefined &&
-                    item.phase !== "Started") {
-                    item.sessionId = record.sessionId;
-                    item.startedAtEpochMs = at;
-                    item.startedAtMonoMs = startedAtMonotonicMillis;
-                    playingStartedMs.set(clipId, startedAtMonotonicMillis);
-                    yield* emit(item, {
-                        _tag: "Started",
-                        at,
-                        sessionId: record.sessionId,
-                        durationSeconds: record.durationSeconds,
-                        ...((item.atMs ?? item.startByMs) === undefined ||
-                            startedAtMonotonicMillis <= (item.atMs ?? item.startByMs)
-                            ? {}
-                            : { lateByMillis: startedAtMonotonicMillis - (item.atMs ?? item.startByMs) }),
-                    });
-                }
-                else if (recoverMissing &&
-                    (record === undefined || at === undefined) &&
-                    item.phase !== "Started")
-                    yield* emit(item, { _tag: "Unobserved" });
-            }
-            else if (state.ready.some((record) => record.clipId === clipId)) {
-                const record = knownRecord(state, clipId);
-                measureItem(item, record.durationSeconds);
-                item.sessionId = record.sessionId;
-                if (item.phase !== "Started")
-                    yield* emit(item, { _tag: "Ready", sessionId: record.sessionId });
-            }
-            else if (state.queued.some((record) => record.clipId === clipId) ||
-                state.generationOrder.includes(clipId) ||
-                Option.getOrUndefined(state.building)?.record.clipId === clipId) {
-                item.sessionId = knownRecord(state, clipId)?.sessionId ?? item.sessionId;
-                if (item.phase === "Accepted" || item.phase === "Unknown")
-                    yield* emit(item, { _tag: "Building" });
-            }
-            else if (state.failed.includes(clipId))
-                yield* emit(item, {
-                    _tag: "Failed",
-                    reason: { _tag: "Clip", message: "The clip failed unobserved" },
-                });
-            else if (recoverMissing &&
-                item.sessionId !== undefined &&
-                (state.sessions.find((source) => source.sessionId === item.sessionId)?.availability ??
-                    "Ready") === "Ready" &&
-                !active.has(clipId) &&
-                (item.acknowledgedAtSnapshotSerial === undefined ||
-                    lastProcessedSnapshotSerial > item.acknowledgedAtSnapshotSerial))
-                yield* emit(item, { _tag: "Unobserved" });
-        }
-        updateRecovery(state);
-    });
-    const onEvent = (event) => Effect.gen(function* () {
-        if (event._tag === "Starved")
-            starved++;
-        if (event._tag === "SessionFailed") {
-            yield* closeActor(event.failure);
-            return;
-        }
-        if (!("clipId" in event))
-            return;
-        if (commandCount > 0 &&
-            (event._tag === "Started" || event._tag === "Ended" || event._tag === "Failed")) {
-            const prior = earlyClipEvents.get(event.clipId);
-            if (prior === undefined) {
-                if (earlyClipEvents.size >= maxEarlyClipIds) {
-                    // A lost pre-ack start cannot be recast as a definite failure.
-                    for (const key of pendingBuilds) {
-                        const item = items.get(key);
-                        if (item !== undefined && item.phase !== "Terminal" && item.phase !== "Started") {
-                            yield* emit(item, { _tag: "Unknown", terminal: true });
-                            item.phase = "Terminal";
-                        }
-                    }
-                    yield* closeActor(ReactorError.fromCode("Overflow", "Unattributed clip evidence exceeded its bound"));
-                    return;
-                }
-                earlyClipEvents.set(event.clipId, [event]);
-            }
-            else if (!prior.some((seen) => event._tag === "Started"
-                ? seen._tag === "Started"
-                : seen._tag === "Ended" || seen._tag === "Failed"))
-                prior.push(event);
-        }
-        const owner = owned.get(event.clipId);
-        if (owner === undefined)
-            return;
-        if (owner._tag === "Filler") {
-            const sent = fillerDispatch.get(owner.index);
-            if (event._tag === "Ready" && sent !== undefined)
-                measure(sent.atMs, sent.seconds, event.durationSeconds);
-            if (event._tag === "Ready" || event._tag === "Ended" || event._tag === "Failed")
-                fillerDispatch.delete(owner.index);
-            if (event._tag === "Started")
-                playingStartedMs.set(event.clipId, event.atMonotonicMillis ?? monotonicMillis(clock));
-            if (event._tag === "Ended" || event._tag === "Failed") {
-                owned.delete(event.clipId);
-                if (filler.get(owner.index)?.clipId === event.clipId)
-                    filler.delete(owner.index);
-                playingStartedMs.delete(event.clipId);
-            }
-            return;
-        }
-        const item = items.get(owner.key);
-        if (item === undefined || item.phase === "Terminal")
-            return;
-        switch (event._tag) {
-            case "Queued":
-            case "Building":
-                if (item.phase === "Accepted" || item.phase === "Unknown")
-                    yield* emit(item, { _tag: "Building" });
-                break;
-            case "Ready": {
-                measureItem(item, event.durationSeconds);
-                const record = knownRecord(yield* engine.state, event.clipId);
-                if (record !== undefined) {
-                    item.sessionId = record.sessionId;
-                    if (item.phase !== "Started")
-                        yield* emit(item, { _tag: "Ready", sessionId: record.sessionId });
-                }
-                break;
-            }
-            case "Started": {
-                if (item.phase === "Started")
-                    break;
-                const state = yield* engine.state;
-                const record = knownRecord(state, event.clipId);
-                const sessionId = record?.sessionId ?? item.sessionId;
-                if (sessionId === undefined)
-                    yield* emit(item, { _tag: "Unobserved" });
-                else {
-                    item.sessionId = sessionId;
-                    const playing = Option.getOrUndefined(state.playing);
-                    item.startedAtMonoMs =
-                        event.atMonotonicMillis ??
-                            (playing?.clipId === event.clipId
-                                ? (playing.startedAtMonotonicMillis ?? monotonicMillis(clock))
-                                : monotonicMillis(clock));
-                    item.startedAtEpochMs = event.at;
-                    playingStartedMs.set(event.clipId, item.startedAtMonoMs);
-                    yield* emit(item, {
-                        _tag: "Started",
-                        at: event.at,
-                        sessionId,
-                        durationSeconds: event.durationSeconds,
-                        ...((item.atMs ?? item.startByMs) === undefined ||
-                            item.startedAtMonoMs <= (item.atMs ?? item.startByMs)
-                            ? {}
-                            : { lateByMillis: item.startedAtMonoMs - (item.atMs ?? item.startByMs) }),
-                    });
-                }
-                break;
-            }
-            case "Ended":
-                yield* emit(item, item.startedAtMonoMs === undefined
-                    ? { _tag: "Unobserved" }
-                    : {
-                        _tag: "Ended",
-                        at: event.at ?? clock.currentTimeMillisUnsafe(),
-                        termination: event.termination,
-                        airedSeconds: Math.max(0, ((event.atMonotonicMillis ?? monotonicMillis(clock)) - item.startedAtMonoMs) /
-                            1000),
-                    });
-                playingStartedMs.delete(event.clipId);
-                break;
-            case "Failed": {
-                // A clip lost with a replaced session before it aired is rebuilt from the plan.
-                if (event.lost === true &&
-                    (item.phase === "Accepted" || item.phase === "Building" || item.phase === "Ready")) {
-                    const sessionId = event.sessionId ?? item.sessionId;
-                    // Its session may still list the clip until it closes; it is not adopted again.
-                    removedIds.add(event.clipId);
-                    owned.delete(event.clipId);
-                    playingStartedMs.delete(event.clipId);
-                    delete item.clipId;
-                    delete item.dispatchedAtMs;
-                    delete item.acknowledgedAtSnapshotSerial;
-                    item.sessionId = undefined;
-                    const pending = pendingWithdrawals.get(item.key);
-                    if (pending !== undefined) {
-                        yield* emit(item, { _tag: "Dropped", reason: pending.reason });
-                        yield* finishWithdrawal(item.key, Result.succeed("withdrawn"));
-                    }
-                    else
-                        yield* emit(item, sessionId === undefined
-                            ? { _tag: "Accepted" }
-                            : { _tag: "Accepted", carried: { sessionId } });
-                    break;
-                }
-                yield* emit(item, { _tag: "Failed", reason: { _tag: "Clip", message: event.reason } });
-                break;
-            }
-            default:
-                break;
-        }
-    });
-    const replayEarlyClipEvents = (clipId) => Effect.gen(function* () {
-        const saved = earlyClipEvents.get(clipId);
-        earlyClipEvents.delete(clipId);
-        if (saved === undefined)
-            return;
-        for (const event of saved)
-            yield* onEvent(event);
-    });
-    const executeCommand = (command) => {
-        switch (command._tag) {
-            case "Build":
-            case "BuildFiller":
-                return Effect.gen(function* () {
-                    if (command.sessionId === undefined ||
-                        Option.getOrUndefined((yield* engine.state).preferredSessionId) !== command.sessionId)
-                        return yield* PolicyFailure.refuse("RouteChanged", "The preferred source changed before dispatch");
-                    // Termination can be claimed while the route is read; its settlement
-                    // must not be followed by a new dispatch.
-                    if (ended !== undefined)
-                        return yield* PolicyFailure.refuse("SessionClosed", "The scheduler closed");
-                    if (command._tag === "Build")
-                        dispatching = command.key;
-                    return yield* engine.enqueueOnSource === undefined
-                        ? engine.enqueue(command.request)
-                        : engine.enqueueOnSource(command.request, command.sessionId);
-                });
-            case "RemoveItem":
-            case "RemoveFiller":
-            case "RemoveDuplicate":
-            case "DeferAt":
-                return engine.remove(command.clipId);
-            case "Order":
-                return engine.move(command.clipId, command.position, "playout");
-            case "PauseAutoplay":
-                return engine.setAutoplay(false);
-            case "Cut":
-                return engine.cut(command.clipId);
-        }
-    };
-    const commandWorker = Effect.gen(function* () {
-        for (;;) {
-            const command = yield* takeQueue(commandQueue);
-            if (ended !== undefined)
-                continue;
-            const result = yield* Effect.result(executeCommand(command));
-            dispatching = undefined;
-            // Capture uncertainty before actor delivery: drain may be awaiting a
-            // permit in stopRenewal while this committed command finishes.
-            if (ended === undefined &&
-                Result.isFailure(result) &&
-                result.failure.context.outcome === "unknown") {
-                let fresh;
-                const sessionId = engine.enqueueOnSource === undefined ||
-                    (command._tag !== "Build" && command._tag !== "BuildFiller")
-                    ? undefined
-                    : command.sessionId;
-                if (command._tag === "Build") {
-                    const item = items.get(command.key);
-                    if (item !== undefined && item.phase !== "Terminal" && item.clipId === undefined) {
-                        item.unknownAtMs ??= monotonicMillis(clock);
-                        item.unknownCause = result.failure;
-                        item.unknownSessionId = sessionId;
-                        fresh = { sessionId, atMs: item.unknownAtMs, cause: result.failure };
-                    }
-                }
-                else if (command._tag === "BuildFiller" &&
-                    !filler.has(command.index) &&
-                    !unknownFillers.has(command.index)) {
-                    fresh = { sessionId, atMs: monotonicMillis(clock), cause: result.failure };
-                    unknownFillers.set(command.index, { ...fresh, index: command.index });
-                }
-                updateRecovery(recoveryState, fresh);
-            }
-            yield* Queue.offer(inbox, { _tag: "CommandDone", command, result });
-        }
-    });
-    const sendCommand = (command) => Effect.gen(function* () {
-        if (ended !== undefined)
-            return;
-        if (command._tag === "Build") {
-            pendingBuilds.add(command.key);
-            const item = items.get(command.key);
-            if (item !== undefined)
-                item.dispatchedAtMs = monotonicMillis(clock);
-        }
-        if (command._tag === "BuildFiller") {
-            lastFillerSeconds = command.request.durationSeconds;
-            fillerDispatch.set(command.index, {
-                atMs: monotonicMillis(clock),
-                seconds: command.request.durationSeconds,
-            });
-            // In-flight filler is bounded like the samples it feeds.
-            for (const index of fillerDispatch.keys())
-                if (fillerDispatch.size > maxSamples)
-                    fillerDispatch.delete(index);
-        }
-        if (command._tag === "DeferAt")
-            pendingAtDeferrals.add(command.key);
-        commandCount++;
-        yield* Queue.offer(commandQueue, command);
-    });
-    const canRetryRemoval = (clipId) => monotonicMillis(clock) >= (removalRetryAtMs.get(clipId) ?? 0) &&
-        (removalUnknownAtSerial.get(clipId) === undefined ||
-            lastProcessedSnapshotSerial > removalUnknownAtSerial.get(clipId));
-    const finishWithdrawal = (key, result) => Effect.gen(function* () {
-        const pending = pendingWithdrawals.get(key);
-        pendingWithdrawals.delete(key);
-        if (pending === undefined)
-            return;
-        for (const reply of pending.replies)
-            if (Result.isSuccess(result))
-                yield* Deferred.succeed(reply, result.success);
-            else
-                yield* Deferred.fail(reply, result.failure);
-    });
-    const sendItemRemoval = (item, reason) => Effect.gen(function* () {
-        if (item.clipId === undefined ||
-            pendingItemRemovals.has(item.key) ||
-            !canRetryRemoval(item.clipId))
-            return;
-        pendingItemRemovals.add(item.key);
-        yield* sendCommand({ _tag: "RemoveItem", key: item.key, clipId: item.clipId, reason });
-    });
-    /** A withdrawal's answer for an item that has started or settled another way. */
-    const settledOutcome = (item) => item.phase === "Started" || item.status._tag === "Ended" || item.status._tag === "Unobserved"
-        ? "already-started"
-        : item.status._tag === "Dropped"
-            ? "withdrawn"
-            : "not-found";
-    const requestWithdrawal = (item, reason, reply) => Effect.gen(function* () {
-        if (item.phase === "Started" || item.phase === "Terminal") {
-            if (reply !== undefined)
-                yield* Deferred.succeed(reply, settledOutcome(item));
-            return;
-        }
-        const pending = pendingWithdrawals.get(item.key);
-        if (pending !== undefined) {
-            if (reply !== undefined)
-                pending.replies.push(reply);
-            return;
-        }
-        pendingWithdrawals.set(item.key, { reason, replies: reply === undefined ? [] : [reply] });
-        if (pendingAtDeferrals.has(item.key))
-            return;
-        if (item.clipId === undefined) {
-            if (item.phase === "Unknown" || pendingBuilds.has(item.key))
-                return;
-            yield* emit(item, { _tag: "Dropped", reason });
-            yield* finishWithdrawal(item.key, Result.succeed("withdrawn"));
-            return;
-        }
-        yield* sendItemRemoval(item, reason);
-    });
-    const applyPolicy = (action, state) => Effect.gen(function* () {
-        switch (action._tag) {
-            case "DeferAt":
-                if (canRetryRemoval(action.clipId))
-                    yield* sendCommand({ _tag: "DeferAt", key: action.key, clipId: action.clipId });
-                break;
-            case "Cut":
-                yield* sendCommand({ _tag: "Cut", clipId: action.clipId });
-                break;
-            case "Order": {
-                const signature = state.ready.map((record) => record.clipId).join(",") +
-                    ":" +
-                    action.clipId +
-                    ":" +
-                    action.position;
-                if (blockedMove !== signature)
-                    yield* sendCommand({
-                        _tag: "Order",
-                        clipId: action.clipId,
-                        position: action.position,
-                        signature,
-                    });
-                break;
-            }
-            case "Build": {
-                const item = items.get(action.key);
-                if (item?.phase !== "Accepted")
-                    break;
-                const prepared = yield* Effect.result(keyedRequest(item.request, item.key, action.continueFrom));
-                if (Result.isFailure(prepared)) {
-                    yield* emit(item, {
-                        _tag: "Failed",
-                        reason: { _tag: "Command", cause: prepared.failure },
-                    });
-                    break;
-                }
-                yield* sendCommand({
-                    _tag: "Build",
-                    key: item.key,
-                    request: prepared.success,
-                    sessionId: Option.getOrUndefined(state.preferredSessionId),
-                });
-                break;
-            }
-            case "BuildFiller": {
-                if (unknownFillers.size >= maxUnknownFillers) {
-                    yield* closeActor(ReactorError.fromCode("Overflow", "Scheduler uncertain filler ledger is full", {
-                        operation: "scheduler.unknownRecovery",
-                    }));
-                    break;
-                }
-                const captured = upcomingFiller === undefined
-                    ? yield* Effect.result(captureFiller(fillerIndex, runwaySeconds(state, monotonicMillis(clock), playingStartedMs, owned, [
-                        ...items.values(),
-                    ]), action.durationSeconds, action.targetSeconds))
-                    : Result.succeed(upcomingFiller);
-                if (Result.isFailure(captured)) {
-                    yield* closeActor(captured.failure);
-                    break;
-                }
-                upcomingFiller = captured.success;
-                const prepared = yield* Effect.result(keyedRequest(captured.success, fillerKey(fillerIndex)));
-                if (Result.isFailure(prepared)) {
-                    yield* closeActor(prepared.failure);
-                    break;
-                }
-                yield* sendCommand({
-                    _tag: "BuildFiller",
-                    index: fillerIndex,
-                    request: prepared.success,
-                    sessionId: Option.getOrUndefined(state.preferredSessionId),
-                });
-                break;
-            }
-        }
-    });
-    const resolveRetiredUnknown = (item) => Effect.gen(function* () {
-        if (item.phase !== "Unknown" || item.clipId !== undefined)
-            return;
-        item.unknownSessionId = undefined;
-        // A retired source cannot play this key again, but it may have played
-        // during a missed observation. Preserve Unknown instead of replaying it.
-        yield* emit(item, { _tag: "Unknown", terminal: true });
-        item.phase = "Terminal";
-        const pending = pendingWithdrawals.get(item.key);
-        if (pending !== undefined)
-            yield* finishWithdrawal(item.key, Result.fail(item.unknownCause ??
-                PolicyFailure.refuse("SessionRecovering", "The original source retired without an enqueue result")));
-    });
-    const handleCommandDone = (command, result) => Effect.gen(function* () {
-        commandCount--;
-        if (ended !== undefined) {
-            if (command._tag === "Build")
-                pendingBuilds.delete(command.key);
-            if (command._tag === "DeferAt")
-                pendingAtDeferrals.delete(command.key);
-            if (command._tag === "RemoveItem")
-                pendingItemRemovals.delete(command.key);
-            if (command._tag === "RemoveFiller")
-                pendingFillerRemovals.delete(command.clipId);
-            return;
-        }
-        switch (command._tag) {
-            case "Build": {
-                const item = items.get(command.key);
-                pendingBuilds.delete(command.key);
-                if (item === undefined)
-                    break;
-                if (Result.isSuccess(result)) {
-                    const clipId = result.success;
-                    if (item.clipId !== undefined && item.clipId !== clipId) {
-                        yield* sendCommand({ _tag: "RemoveDuplicate", clipId });
-                        break;
-                    }
-                    item.clipId = clipId;
-                    item.acknowledgedAtSnapshotSerial = snapshotAcquiredSerial;
-                    owned.set(clipId, { _tag: "Item", key: item.key });
-                    item.sessionId =
-                        knownRecord(yield* engine.state, clipId)?.sessionId ??
-                            (engine.enqueueOnSource === undefined ? undefined : command.sessionId);
-                    provedUnknown(item.unknownAtMs);
-                    item.unknownAtMs = undefined;
-                    item.unknownSessionId = undefined;
-                    item.unknownCause = undefined;
-                    yield* replayEarlyClipEvents(clipId);
-                    // Evidence that overtook the reply may already have carried the clip away
-                    // with a lost session; the item then waits to be rebuilt, not Building.
-                    const carried = item.clipId === undefined;
-                    const pending = pendingWithdrawals.get(item.key);
-                    if (carried) {
-                        // The carry settled any withdrawal that was waiting.
-                    }
-                    else if (pending !== undefined) {
-                        if (item.phase === "Started" || item.phase === "Terminal")
-                            yield* finishWithdrawal(item.key, Result.succeed(settledOutcome(item)));
-                        else
-                            yield* sendItemRemoval(item, pending.reason);
-                    }
-                    else if (item.phase === "Accepted" || item.phase === "Unknown")
-                        yield* emit(item, { _tag: "Building" });
-                    yield* observed(yield* engine.state);
-                }
-                else if (result.failure.context.outcome === "unknown") {
-                    // Its time to Ready spans the uncertainty, so it is never measured.
-                    delete item.dispatchedAtMs;
-                    if (item.clipId === undefined) {
-                        // A generic engine may re-route between the state read and dispatch.
-                        // Only an owner-fenced enqueue can attribute its unknown result.
-                        item.unknownSessionId =
-                            engine.enqueueOnSource === undefined ? undefined : command.sessionId;
-                        item.unknownCause = result.failure;
-                        yield* emit(item, { _tag: "Unknown" });
-                    }
-                }
-                else {
-                    const pending = pendingWithdrawals.get(item.key);
-                    if (pending !== undefined) {
-                        yield* emit(item, { _tag: "Dropped", reason: pending.reason });
-                        yield* finishWithdrawal(item.key, Result.succeed("withdrawn"));
-                    }
-                    else if (result.failure.context.outcome !== "not-submitted" ||
-                        !["QueueFull", "SessionRecovering", "RouteChanged"].includes(result.failure.reason._tag))
-                        yield* emit(item, {
-                            _tag: "Failed",
-                            reason: { _tag: "Command", cause: result.failure },
-                        });
-                    else
-                        item.retryAtMs = monotonicMillis(clock) + 1_000;
-                    delete item.dispatchedAtMs;
-                }
-                break;
-            }
-            case "BuildFiller": {
-                if (Result.isSuccess(result)) {
-                    const clipId = result.success;
-                    const actualSessionId = knownRecord(yield* engine.state, clipId)?.sessionId ??
-                        (engine.enqueueOnSource === undefined ? undefined : command.sessionId);
-                    owned.set(clipId, {
-                        _tag: "Filler",
-                        index: command.index,
-                        sessionId: actualSessionId,
-                    });
-                    filler.set(command.index, {
-                        index: command.index,
-                        clipId,
-                        sessionId: actualSessionId,
-                        acknowledgedAtSnapshotSerial: snapshotAcquiredSerial,
-                    });
-                    fillerIndex = Math.max(fillerIndex, command.index + 1);
-                    upcomingFiller = undefined;
-                    yield* replayEarlyClipEvents(clipId);
-                }
-                else if (result.failure.context.outcome === "unknown") {
-                    // The worker already retained this identity and its original age.
-                }
-                else {
-                    fillerDispatch.delete(command.index);
-                    fillerRetryAtMs = monotonicMillis(clock) + 1_000;
-                    if (result.failure.context.outcome === "replied") {
-                        fillerIndex = Math.max(fillerIndex, command.index + 1);
-                        upcomingFiller = undefined;
-                    }
-                }
-                yield* observed(yield* engine.state);
-                break;
-            }
-            case "RemoveItem": {
-                pendingItemRemovals.delete(command.key);
-                const item = items.get(command.key);
-                if (Result.isSuccess(result)) {
-                    removalRetryAtMs.delete(command.clipId);
-                    removalUnknownAtSerial.delete(command.clipId);
-                    removedIds.add(command.clipId);
-                    owned.delete(command.clipId);
-                    playingStartedMs.delete(command.clipId);
-                    if (item?.phase === "Started")
-                        yield* finishWithdrawal(command.key, Result.succeed("already-started"));
-                    else {
-                        if (item !== undefined && item.phase !== "Terminal")
-                            yield* emit(item, { _tag: "Dropped", reason: command.reason });
-                        yield* finishWithdrawal(command.key, Result.succeed("withdrawn"));
-                    }
-                }
-                else {
-                    removalRetryAtMs.set(command.clipId, monotonicMillis(clock) + 1_000);
-                    if (result.failure.context.outcome === "unknown")
-                        removalUnknownAtSerial.set(command.clipId, snapshotAcquiredSerial);
-                    if (item?.phase === "Started")
-                        yield* finishWithdrawal(command.key, Result.succeed("already-started"));
-                    // A refusal is not an outcome: the withdrawal stays pending and is retried.
-                    // An unknown removal may already have taken effect, so it ends the wait.
-                    else if (result.failure.context.outcome === "unknown")
-                        yield* finishWithdrawal(command.key, Result.fail(result.failure));
-                }
-                break;
-            }
-            case "RemoveFiller": {
-                pendingFillerRemovals.delete(command.clipId);
-                if (Result.isSuccess(result)) {
-                    removalRetryAtMs.delete(command.clipId);
-                    removalUnknownAtSerial.delete(command.clipId);
-                    removedIds.add(command.clipId);
-                    const owner = owned.get(command.clipId);
-                    if (owner?._tag === "Filler" && filler.get(owner.index)?.clipId === command.clipId)
-                        filler.delete(owner.index);
-                    owned.delete(command.clipId);
-                    playingStartedMs.delete(command.clipId);
-                }
-                else {
-                    removalRetryAtMs.set(command.clipId, monotonicMillis(clock) + 1_000);
-                    if (result.failure.context.outcome === "unknown")
-                        removalUnknownAtSerial.set(command.clipId, snapshotAcquiredSerial);
-                }
-                break;
-            }
-            case "RemoveDuplicate":
-                if (Result.isFailure(result))
-                    yield* closeActor(result.failure);
-                break;
-            case "DeferAt": {
-                pendingAtDeferrals.delete(command.key);
-                const item = items.get(command.key);
-                if (Result.isFailure(result)) {
-                    removalRetryAtMs.set(command.clipId, monotonicMillis(clock) + 1_000);
-                    if (result.failure.context.outcome === "unknown")
-                        removalUnknownAtSerial.set(command.clipId, snapshotAcquiredSerial);
-                    break;
-                }
-                removalRetryAtMs.delete(command.clipId);
-                removalUnknownAtSerial.delete(command.clipId);
-                owned.delete(command.clipId);
-                removedIds.add(command.clipId);
-                playingStartedMs.delete(command.clipId);
-                if (item === undefined || item.phase === "Started" || item.phase === "Terminal")
-                    break;
-                delete item.clipId;
-                item.sessionId = undefined;
-                const pending = pendingWithdrawals.get(command.key);
-                if (pending !== undefined) {
-                    yield* emit(item, { _tag: "Dropped", reason: pending.reason });
-                    yield* finishWithdrawal(command.key, Result.succeed("withdrawn"));
-                }
-                else
-                    yield* emit(item, { _tag: "Accepted" });
-                break;
-            }
-            case "Order":
-                blockedMove = Result.isFailure(result) ? command.signature : undefined;
-                break;
-            case "Cut":
-                if (Result.isFailure(result))
-                    blockedCut = command.clipId;
-                break;
-            case "PauseAutoplay":
-                if (Result.isFailure(result)) {
-                    drainFailure = result.failure;
-                    const replies = drainReplies.splice(0);
-                    for (const reply of replies)
-                        yield* Deferred.fail(reply, result.failure);
-                }
-                break;
-        }
-    });
-    const pendingBatches = () => [...batches.values()].map((batch) => ({
-        id: batch.id,
-        waitFor: batch.waitFor,
-        targets: [...batch.targets].map(([key, target]) => ({ key, reason: target.reason })),
-    }));
-    /** The reply a batch keeps for its withdrawal of `key`, taken once. */
-    const takeBatchReply = (key) => {
-        for (const batch of batches.values()) {
-            const target = batch.targets.get(key);
-            if (target === undefined)
-                continue;
-            batch.targets.delete(key);
-            return target.reply;
-        }
-        return undefined;
-    };
-    /** A batch takes effect: what it withdraws goes at once, and its replacements take over. */
-    const commitBatch = (id) => Effect.gen(function* () {
-        const batch = batches.get(id);
-        if (batch === undefined)
-            return;
-        batches.delete(id);
-        for (const [key, target] of batch.targets) {
-            const item = items.get(key);
-            if (item !== undefined)
-                yield* requestWithdrawal(item, target.reason, target.reply);
-            else if (target.reply !== undefined)
-                yield* Deferred.succeed(target.reply, "not-found");
-        }
-        yield* Deferred.succeed(batch.committed, undefined);
-    });
-    const reconcile = Effect.gen(function* () {
-        const state = yield* engine.state;
-        if (ended !== undefined)
-            return;
-        prune(state);
-        refreshAnchors();
-        const sources = projectSources(state);
-        if (!observationReady) {
-            yield* publishState(state, sources.sessions);
-            return;
-        }
-        const nowMs = monotonicMillis(clock);
-        for (const item of items.values())
-            if (item.phase === "Started")
-                fireCues(item, nowMs);
-        for (const uncertain of unknownFillers.values()) {
-            const sourceRetired = uncertain.sessionId !== undefined && !sources.has(uncertain.sessionId);
-            if (sourceRetired)
-                unknownFillers.delete(uncertain.index);
-            if (sourceRetired ||
-                (uncertain.sessionId !== undefined &&
-                    Option.getOrUndefined(state.preferredSessionId) !== uncertain.sessionId)) {
-                if (fillerIndex <= uncertain.index) {
-                    fillerIndex = uncertain.index + 1;
-                    upcomingFiller = undefined;
-                }
-            }
-        }
-        for (const [key, pending] of pendingWithdrawals) {
-            const item = items.get(key);
-            if (item === undefined)
-                continue;
-            if (item.phase === "Started")
-                yield* finishWithdrawal(key, Result.succeed("already-started"));
-            // A withdrawal still being retried when its item settles another way. Terminal
-            // Unknown keeps its uncertain result from the retirement or terminal settlement.
-            else if (item.phase === "Terminal" && item.status._tag !== "Unknown")
-                yield* finishWithdrawal(key, Result.succeed(settledOutcome(item)));
-            else if (item.clipId !== undefined)
-                yield* sendItemRemoval(item, pending.reason);
-        }
-        for (const item of items.values())
-            if (item.phase === "Unknown" &&
-                item.clipId === undefined &&
-                item.unknownSessionId !== undefined &&
-                !sources.has(item.unknownSessionId))
-                yield* resolveRetiredUnknown(item);
-        // After retirement, so a deadline no longer outlives the uncertainty that
-        // set it until the next message.
-        updateRecovery(state);
-        const preferred = Option.getOrUndefined(state.preferredSessionId);
-        let unknownFillerCount = 0;
-        for (const entry of unknownFillers.values())
-            if (entry.sessionId === undefined || entry.sessionId === preferred)
-                unknownFillerCount++;
-        const brokenGroups = new Map();
-        for (const [key, group] of groups)
-            if (group.brokenAt !== undefined)
-                brokenGroups.set(key, group.brokenAt);
-        const decide = () => plan({
-            engine: state,
-            items: [...items.values()],
-            owned,
-            lanes,
-            nowMs: monotonicMillis(clock),
-            playingStartedMs,
-            floorSeconds,
-            targetSeconds,
-            refillActive,
-            maxBuildsInFlight,
-            accepting,
-            drain: draining ? (finishAccepted ? "accepted" : "playing") : undefined,
-            fillerRetryAtMs,
-            unknownFillerCount,
-            blockedMove,
-            withdrawing: new Set(pendingWithdrawals.keys()),
-            dispatched: pendingBuilds,
-            brokenGroups,
-            batches: pendingBatches(),
-            estimates: estimatesFrom(buildSamples, lengthSamples),
-            ...fillerView(),
-            cutLanes,
-            fillLengths,
-            blockedCut,
-        });
-        let decision = decide();
-        // A commit changes what is withdrawn and what takes over, so the plan is read again.
-        if (decision.commit.length > 0) {
-            for (const id of decision.commit)
-                yield* commitBatch(id);
-            decision = decide();
-        }
-        refillActive = decision.refillActive;
-        for (const { key, reason } of decision.withdraw) {
-            const item = items.get(key);
-            if (item !== undefined)
-                yield* requestWithdrawal(item, reason, takeBatchReply(key));
-        }
-        for (const clipId of decision.withdrawFiller)
-            if (!pendingFillerRemovals.has(clipId) && canRetryRemoval(clipId)) {
-                pendingFillerRemovals.add(clipId);
-                yield* sendCommand({ _tag: "RemoveFiller", clipId });
-            }
-        yield* publishState(state, sources.sessions);
-        if ((!draining || finishAccepted) && commandCount === 0 && decision.action !== undefined)
-            yield* applyPolicy(decision.action, state);
-        if (draining &&
-            finishAccepted &&
-            !autoplayPaused &&
-            commandCount === 0 &&
-            [...items.values()].every((item) => item.phase === "Terminal")) {
-            autoplayPaused = true;
-            yield* sendCommand({ _tag: "PauseAutoplay" });
-        }
-        if (drainFailure === undefined &&
-            drainReplies.length > 0 &&
-            commandCount === 0 &&
-            [...items.values()].every((item) => item.phase === "Terminal") &&
-            pendingWithdrawals.size === 0 &&
-            unknownFillers.size === 0) {
-            const after = yield* engine.state;
-            if (Option.isNone(after.playing) && !activeIds(after).some((clipId) => owned.has(clipId))) {
-                drained = true;
-                // A truthful completed drain no longer needs a replacement to resume
-                // service, even when retirement left a capacity episode behind.
-                capacityRecovery = undefined;
-                updateRecovery(after);
-                const replies = drainReplies.splice(0);
-                for (const reply of replies)
-                    yield* Deferred.succeed(reply, undefined);
-            }
-        }
-    });
-    /** Registers a captured item, without yielding; its caller publishes the Accepted evidence. */
-    const accept = (captured, nowMs, startByMs, group, place) => {
-        const startedWaiter = Deferred.makeUnsafe();
-        const outcomeWaiter = Deferred.makeUnsafe();
-        const firstDecisiveWaiter = Deferred.makeUnsafe();
-        const item = {
-            key: captured.key,
-            lane: captured.lane,
-            request: captured.request,
-            fingerprint: captured.fingerprint,
-            admission: place === undefined ? ++admission : place.admission,
-            seconds: captured.request.durationSeconds,
-            phase: "Accepted",
-            status: { _tag: "Accepted" },
-            ...(place === undefined
-                ? captured.notBeforeOffsetMs === undefined
-                    ? {}
-                    : { notBeforeMs: nowMs + captured.notBeforeOffsetMs }
-                : place.notBeforeMs === undefined
-                    ? {}
-                    : { notBeforeMs: place.notBeforeMs }),
-            ...(place?.replaces === undefined
-                ? {}
-                : { replaces: place.replaces, generation: place.generation ?? 1 }),
-            ...(place?.inserted === true ? { inserted: true } : {}),
-            ...(startByMs === undefined ? {} : { startByMs }),
-            firm: captured.firm,
-            ...(captured.atWallMs === undefined
-                ? {}
-                : {
-                    atWallMs: captured.atWallMs,
-                    atMs: nowMs + captured.atWallMs - clock.currentTimeMillisUnsafe(),
-                }),
-            late: captured.late,
-            cues: captured.cues ?? [],
-            firedCues: new Set(),
-            ...(captured.continuity === undefined ? {} : { continuity: captured.continuity }),
-            ...(captured.mode === "asap" ? { asap: true } : {}),
-            ...(captured.mode === "manual" ? { held: true } : {}),
-            ...(group === undefined ? {} : { group }),
-            sessionId: undefined,
-            unknownSessionId: undefined,
-            unknownCause: undefined,
-            unknownAtMs: undefined,
-            handle: {
-                key: captured.key,
-                started: Deferred.await(startedWaiter),
-                outcome: Deferred.await(outcomeWaiter),
-                firstDecisive: Deferred.await(firstDecisiveWaiter),
-            },
-            startedWaiter,
-            outcomeWaiter,
-            firstDecisiveWaiter,
-        };
-        items.set(item.key, item);
-        return item;
-    };
-    /**
-     * One reply for withdrawals across a group's parts. A group key reports
-     * `withdrawn` if any part was; a part key reports that part's own outcome,
-     * while the parts after it are withdrawn too.
-     */
-    const settleWithdrawals = (replies, reply, wholeGroup) => Effect.gen(function* () {
-        const outcomes = [];
-        for (const pending of replies) {
-            const result = yield* Effect.result(Deferred.await(pending));
-            if (Result.isFailure(result)) {
-                yield* Deferred.fail(reply, result.failure);
-                return;
-            }
-            outcomes.push(result.success);
-        }
-        yield* Deferred.succeed(reply, wholeGroup && outcomes.includes("withdrawn") ? "withdrawn" : (outcomes[0] ?? "not-found"));
-    });
-    /**
-     * The place an insert takes beside its anchor, or why it cannot: the anchor's lane, an
-     * admission between the anchor and its neighbour in that lane, and a group place when
-     * the insert falls between two parts of a group.
-     */
-    const placeInsert = (insert) => {
-        const live = (entry) => entry !== undefined && entry.phase !== "Terminal" && entry.replacedBy === undefined;
-        const named = groups.get(insert.anchor);
-        let anchor;
-        if (named === undefined)
-            anchor = items.get(insert.anchor);
-        else {
-            const parts = named.parts
-                .map((key) => items.get(key))
-                .filter(live)
-                .sort((a, b) => a.group.index - b.group.index);
-            if (insert.side === "before" &&
-                (parts.some((part) => part.phase === "Started") || parts[0]?.group?.index !== 0))
-                return "The anchor group already started";
-            anchor = insert.side === "before" ? parts[0] : parts.at(-1);
-        }
-        if (!live(anchor))
-            return "Nothing queued under the anchor key";
-        if (anchor.phase === "Unknown")
-            return "The anchor's admission is uncertain";
-        if (anchor.held === true)
-            return "The anchor is held until it is released";
-        if (insert.side === "before" && anchor.phase === "Started")
-            return "The anchor already started";
-        const neighbours = [...items.values()]
-            .filter((entry) => entry.lane === anchor.lane && entry.phase !== "Terminal")
-            .map((entry) => entry.admission);
-        const bound = insert.side === "before"
-            ? Math.max(...neighbours.filter((value) => value < anchor.admission))
-            : Math.min(...neighbours.filter((value) => value > anchor.admission));
-        const admission = Number.isFinite(bound)
-            ? (anchor.admission + bound) / 2
-            : anchor.admission + (insert.side === "before" ? -0.5 : 0.5);
-        if (admission === anchor.admission || admission === bound)
-            return "No room is left to insert at that place";
-        let group;
-        if (anchor.group !== undefined) {
-            const indexes = (groups.get(anchor.group.key)?.parts ?? [])
-                .map((key) => items.get(key)?.group?.index)
-                .filter((value) => value !== undefined);
-            const index = anchor.group.index;
-            const neighbour = insert.side === "before"
-                ? Math.max(...indexes.filter((value) => value < index))
-                : Math.min(...indexes.filter((value) => value > index));
-            // Before the first part or after the last one, the insert stays outside the group.
-            // Once parts have aired and settled, the place before the first remaining part is
-            // still inside the group.
-            const between = insert.side === "before"
-                ? index > 0
-                    ? (Number.isFinite(neighbour) ? neighbour : index - 1) + index
-                    : undefined
-                : Number.isFinite(neighbour)
-                    ? index + neighbour
-                    : undefined;
-            if (between !== undefined) {
-                if (between / 2 === index || between / 2 === neighbour)
-                    return "No room is left to insert at that place";
-                group = { key: anchor.group.key, index: between / 2 };
-            }
-        }
-        const timing = {
-            ...(anchor.atWallMs === undefined ? {} : { atWallMs: anchor.atWallMs }),
-            late: anchor.late,
-            asap: anchor.asap === true,
-        };
-        return group === undefined
-            ? { lane: anchor.lane, admission, ...timing }
-            : { lane: anchor.lane, admission, group, ...timing };
-    };
-    /** The items a withdrawal of `key` names: a group's parts, a part and those after it, or one item. */
-    const withdrawalTargets = (key) => {
-        const item = items.get(key);
-        const named = groups.get(key);
-        const group = named ?? (item?.group === undefined ? undefined : groups.get(item.group.key));
-        if (group === undefined || (named === undefined && item?.inserted === true))
-            return item === undefined ? [] : [item];
-        const from = named === undefined ? item.group.index : 0;
-        const targets = group.parts
-            .map((part) => items.get(part))
-            .filter((part) => part?.group !== undefined && part.group.index >= from);
-        // A part key's reply is that part's own outcome, so it goes first.
-        if (named === undefined)
-            targets.sort((a, b) => Number(b === item) - Number(a === item));
-        return targets;
-    };
-    /**
-     * Checks and admits a call's edits in order, without yielding. A refused edit undoes the
-     * edits before it, so nothing of a refused batch is admitted or published.
-     */
-    const stageEdits = (edits, batched, state, nowMs) => {
-        const undo = [];
-        const added = [];
-        const waitFor = [];
-        const replaced = [];
-        const results = [];
-        const refuse = (error) => {
-            for (const step of undo.reverse())
-                step();
-            return Result.fail(error);
-        };
-        // Clips a batch withdraws or replaces do not count ahead of the clips it adds.
-        const excluding = new Set();
-        const named = [];
-        for (const edit of edits)
-            switch (edit._tag) {
-                case "Submit":
-                    named.push(edit.item.key);
-                    break;
-                case "SubmitGroup":
-                    named.push(edit.group.key, ...edit.group.parts.map((part) => part.key));
-                    break;
-                case "Insert":
-                    named.push(edit.insert.key);
-                    break;
-                case "Replace":
-                    named.push(edit.key, edit.next.key);
-                    excluding.add(edit.key);
-                    break;
-                case "Withdraw": {
-                    const targets = withdrawalTargets(edit.key);
-                    named.push(edit.key, ...targets.map((target) => target.key).filter((key) => key !== edit.key));
-                    for (const target of targets)
-                        excluding.add(target.key);
-                    break;
-                }
-            }
-        if (new Set(named).size !== named.length)
-            return refuse(invalid("An edit batch names each key once"));
-        for (const edit of edits)
-            if (edit._tag === "Insert" && excluding.has(edit.insert.anchor))
-                return refuse(invalid("An insert's anchor is withdrawn or replaced in the same batch"));
-        const view = (place) => projectedStartMs({
-            engine: state,
-            items: [...items.values()],
-            owned,
-            lanes,
-            playingStartedMs,
-            nowMs,
-            batches: pendingBatches(),
-            estimates: estimatesFrom(buildSamples, lengthSamples),
-            ...fillerView(),
-            withdrawing: new Set([...pendingWithdrawals.keys(), ...excluding]),
-        }, place);
-        /**
-         * A new submission's lane policy: a skip lane refuses it while the lane has an item
-         * waiting or playing; a replace lane supersedes the items still waiting there.
-         */
-        const conflict = (key, lane) => {
-            const others = [...items.values()].filter((entry) => entry.lane === lane &&
-                entry.phase !== "Terminal" &&
-                !excluding.has(entry.key) &&
-                !added.includes(entry));
-            switch (conflicts.get(lane)) {
-                case "skip":
-                    return others.length > 0 ? LaneBusy.of(key, lane) : undefined;
-                case "replace":
-                    for (const entry of others)
-                        if (entry.phase !== "Started" && !pendingWithdrawals.has(entry.key)) {
-                            replaced.push(entry.key);
-                            excluding.add(entry.key);
-                        }
-                    return undefined;
-                default:
-                    return undefined;
-            }
-        };
-        const admitted = (entry) => {
-            added.push(entry);
-            waitFor.push(entry.key);
-            undo.push(() => items.delete(entry.key));
-        };
-        /** An existing key: the same spec returns its handle, and the batch waits for it too. */
-        const repeated = (key, fingerprint) => {
-            const existing = items.get(key) ?? history.get(key);
-            if (existing === undefined && !groups.has(key))
-                return Result.succeed(undefined);
-            if (existing?.fingerprint !== fingerprint)
-                return Result.fail(KeyMismatch.of(key));
-            waitFor.push(key);
-            return Result.succeed(existing.handle);
-        };
-        for (const edit of edits) {
-            switch (edit._tag) {
-                case "Submit": {
-                    const { item } = edit;
-                    const known = repeated(item.key, item.fingerprint);
-                    if (Result.isFailure(known))
-                        return refuse(known.failure);
-                    if (known.success !== undefined) {
-                        results.push({ _tag: "Added", handle: known.success });
-                        break;
-                    }
-                    const busy = conflict(item.key, item.lane);
-                    if (busy !== undefined)
-                        return refuse(busy);
-                    const startByMs = item.startByOffsetMs === undefined ? undefined : nowMs + item.startByOffsetMs;
-                    if (startByMs !== undefined &&
-                        view({
-                            lane: item.lane,
-                            admission: Infinity,
-                            seconds: item.request.durationSeconds,
-                            startByMs,
-                            ...(item.mode === "asap" ? { asap: true } : {}),
-                            ...(item.mode === "manual" ? { held: true } : {}),
-                        }) > startByMs)
-                        return refuse(WouldMissDeadline.of(item.key));
-                    const entry = accept(item, nowMs, startByMs, undefined);
-                    admitted(entry);
-                    results.push({ _tag: "Added", handle: entry.handle });
-                    break;
-                }
-                case "SubmitGroup": {
-                    const { group } = edit;
-                    const known = groups.get(group.key);
-                    if (known !== undefined) {
-                        if (known.fingerprint !== group.fingerprint)
-                            return refuse(KeyMismatch.of(group.key));
-                        waitFor.push(...known.parts);
-                        results.push({ _tag: "AddedGroup", handle: known.handle });
-                        break;
-                    }
-                    const taken = [group.key, ...group.parts.map((part) => part.key)].find((key) => items.has(key) || history.has(key) || groups.has(key));
-                    if (taken !== undefined)
-                        return refuse(KeyMismatch.of(taken));
-                    const [first, ...rest] = group.parts;
-                    const busy = conflict(group.key, first.lane);
-                    if (busy !== undefined)
-                        return refuse(busy);
-                    const startByMs = first.startByOffsetMs === undefined ? undefined : nowMs + first.startByOffsetMs;
-                    if (startByMs !== undefined &&
-                        view({
-                            lane: first.lane,
-                            admission: Infinity,
-                            seconds: first.request.durationSeconds,
-                            startByMs,
-                        }) > startByMs)
-                        return refuse(WouldMissDeadline.of(group.key));
-                    const parts = [
-                        accept(first, nowMs, startByMs, { key: group.key, index: 0 }),
-                        ...rest.map((part, index) => accept(part, nowMs, undefined, { key: group.key, index: index + 1 })),
-                    ];
-                    for (const part of parts)
-                        admitted(part);
-                    const handle = {
-                        key: group.key,
-                        parts: [parts[0].handle, ...parts.slice(1).map((part) => part.handle)],
-                    };
-                    groups.set(group.key, {
-                        fingerprint: group.fingerprint,
-                        handle,
-                        parts: group.parts.map((part) => part.key),
-                        brokenAt: undefined,
-                    });
-                    undo.push(() => groups.delete(group.key));
-                    results.push({ _tag: "AddedGroup", handle });
-                    break;
-                }
-                case "Insert": {
-                    const { insert } = edit;
-                    const known = repeated(insert.key, insert.fingerprint);
-                    if (Result.isFailure(known))
-                        return refuse(known.failure);
-                    if (known.success !== undefined) {
-                        results.push({ _tag: "Added", handle: known.success });
-                        break;
-                    }
-                    const placed = placeInsert(insert);
-                    if (typeof placed === "string")
-                        return refuse(invalid(placed));
-                    const startByMs = insert.startByOffsetMs === undefined ? undefined : nowMs + insert.startByOffsetMs;
-                    if (startByMs !== undefined &&
-                        view({ ...placed, seconds: insert.request.durationSeconds, startByMs }) > startByMs)
-                        return refuse(WouldMissDeadline.of(insert.key));
-                    const entry = accept({
-                        key: insert.key,
-                        lane: placed.lane,
-                        request: insert.request,
-                        fingerprint: insert.fingerprint,
-                        notBeforeOffsetMs: insert.notBeforeOffsetMs,
-                        startByOffsetMs: insert.startByOffsetMs,
-                        firm: insert.firm,
-                        atWallMs: placed.atWallMs,
-                        late: placed.late,
-                        ...(placed.asap ? { mode: "asap" } : {}),
-                        cues: insert.cues,
-                        ...(insert.continuity === undefined ? {} : { continuity: insert.continuity }),
-                    }, nowMs, startByMs, placed.group, {
-                        admission: placed.admission,
-                        inserted: true,
-                        notBeforeMs: insert.notBeforeOffsetMs === undefined
-                            ? undefined
-                            : nowMs + insert.notBeforeOffsetMs,
-                    });
-                    admitted(entry);
-                    if (placed.group !== undefined) {
-                        const parts = groups.get(placed.group.key)?.parts;
-                        parts?.push(entry.key);
-                        undo.push(() => parts?.pop());
-                    }
-                    results.push({ _tag: "Added", handle: entry.handle });
-                    break;
-                }
-                case "Replace": {
-                    const { next } = edit;
-                    const fingerprint = JSON.stringify({
-                        replaces: edit.key,
-                        request: next.request,
-                        ...(next.cues.length === 0 ? {} : { cues: next.cues }),
-                        ...(next.continuity === undefined ? {} : { continuity: next.continuity }),
-                    });
-                    const known = repeated(next.key, fingerprint);
-                    if (Result.isFailure(known))
-                        return refuse(known.failure);
-                    if (known.success !== undefined) {
-                        results.push({ _tag: "Added", handle: known.success });
-                        break;
-                    }
-                    const old = items.get(edit.key);
-                    if (old === undefined ||
-                        old.replacedBy !== undefined ||
-                        (old.phase !== "Accepted" && old.phase !== "Building" && old.phase !== "Ready"))
-                        return refuse(invalid("Nothing queued to replace under that key"));
-                    const entry = accept({
-                        key: next.key,
-                        lane: old.lane,
-                        request: next.request,
-                        fingerprint,
-                        notBeforeOffsetMs: undefined,
-                        startByOffsetMs: undefined,
-                        firm: old.firm,
-                        atWallMs: old.atWallMs,
-                        late: old.late,
-                        ...(old.asap === true ? { mode: "asap" } : {}),
-                        ...(old.held === true ? { mode: "manual" } : {}),
-                        cues: next.cues,
-                        ...(next.continuity === undefined ? {} : { continuity: next.continuity }),
-                    }, nowMs, old.startByMs, old.group, {
-                        admission: old.admission,
-                        replaces: old.key,
-                        generation: (old.generation ?? 0) + 1,
-                        inserted: old.inserted === true,
-                        notBeforeMs: old.notBeforeMs,
-                    });
-                    admitted(entry);
-                    old.replacedBy = entry.key;
-                    undo.push(() => delete old.replacedBy);
-                    // A pending batch that waits for the replaced item waits for its replacement.
-                    for (const batch of batches.values())
-                        if (batch.waitFor.includes(old.key)) {
-                            batch.waitFor.push(entry.key);
-                            undo.push(() => batch.waitFor.pop());
-                        }
-                    if (old.group !== undefined) {
-                        const parts = groups.get(old.group.key)?.parts;
-                        parts?.push(entry.key);
-                        undo.push(() => parts?.pop());
-                    }
-                    results.push({ _tag: "Added", handle: entry.handle });
-                    break;
-                }
-                case "Withdraw":
-                    results.push({ _tag: "Withdrawal", key: edit.key });
-                    break;
-            }
-        }
-        return Result.succeed({ results, added, waitFor, replaced });
-    };
-    /**
-     * Makes a staged call's handle. A batch keeps what it withdraws as cover until it commits;
-     * a single call adds one item or group and takes effect at once.
-     */
-    const openBatch = (staged, batched) => {
-        // A single call adds one item or group and never withdraws; only a replace lane gives
-        // it something to supersede.
-        if (!batched && staged.replaced.length === 0)
-            return {
-                handle: {
-                    results: staged.results.filter((result) => result._tag !== "Withdrawal"),
-                    committed: Effect.void,
-                },
-                settle: [],
-            };
-        const settle = [];
-        const batch = {
-            id: ++batchCount,
-            waitFor: [...staged.waitFor],
-            targets: new Map(staged.replaced.map((key) => [key, { reason: "replaced", reply: undefined }])),
-            committed: Deferred.makeUnsafe(),
-        };
-        const results = staged.results.map((result) => {
-            if (result._tag !== "Withdrawal")
-                return result;
-            const replies = [];
-            for (const target of withdrawalTargets(result.key)) {
-                const reply = Deferred.makeUnsafe();
-                replies.push(reply);
-                batch.targets.set(target.key, { reason: "withdrawn", reply });
-            }
-            const outcome = Deferred.makeUnsafe();
-            settle.push(settleWithdrawals(replies, outcome, groups.has(result.key)));
-            return {
-                _tag: "Withdrawal",
-                outcome: Deferred.await(outcome).pipe(Effect.raceFirst(closedCall)),
-            };
-        });
-        // A pending batch whose new clip this one withdraws now also waits for this one's, so
-        // its own cover is not withdrawn before anything replaces it.
-        for (const other of batches.values())
-            if (other.waitFor.some((key) => batch.targets.has(key)))
-                other.waitFor.push(...batch.waitFor);
-        batches.set(batch.id, batch);
-        return {
-            handle: {
-                results: batched ? results : results.filter((result) => result._tag !== "Withdrawal"),
-                committed: batched ? Deferred.await(batch.committed) : Effect.void,
-            },
-            settle,
-        };
-    };
-    const actor = Effect.gen(function* () {
-        for (;;) {
-            const message = yield* takeQueue(inbox);
-            // Queued public calls observe the same terminal result through closedCall.
-            if (ended !== undefined && message._tag !== "CommandDone")
-                continue;
-            switch (message._tag) {
-                case "Edit": {
-                    if (!accepting) {
-                        yield* Deferred.fail(message.reply, invalid("Scheduler is draining or closed"));
-                        break;
-                    }
-                    const nowMs = monotonicMillis(clock);
-                    const state = yield* engine.state;
-                    if (ended !== undefined)
-                        continue;
-                    // No yield from the terminal check above through admission and its
-                    // publication below: a claim either precedes the items or settles them
-                    // after their Accepted evidence.
-                    const staged = stageEdits(message.edits, message.batched, state, nowMs);
-                    if (Result.isFailure(staged)) {
-                        yield* Deferred.fail(message.reply, staged.failure);
-                        break;
-                    }
-                    for (const entry of staged.success.added)
-                        PubSub.publishUnsafe(events, {
-                            key: entry.key,
-                            at: clock.currentTimeMillisUnsafe(),
-                            status: entry.status,
-                        });
-                    const opened = openBatch(staged.success, message.batched);
-                    for (const effect of opened.settle)
-                        yield* Effect.forkIn(effect, actorScope);
-                    yield* observed(state);
-                    // An edit returns its committed view; other messages publish once
-                    // through reconciliation after all their evidence is adopted.
-                    yield* publishState(state);
-                    yield* Deferred.succeed(message.reply, opened.handle);
-                    break;
-                }
-                case "Withdraw": {
-                    const targets = withdrawalTargets(message.key);
-                    if (targets.length <= 1 && !groups.has(message.key)) {
-                        if (targets[0] === undefined)
-                            yield* Deferred.succeed(message.reply, "not-found");
-                        else
-                            yield* requestWithdrawal(targets[0], "withdrawn", message.reply);
-                        break;
-                    }
-                    const replies = [];
-                    for (const part of targets) {
-                        const reply = Deferred.makeUnsafe();
-                        replies.push(reply);
-                        yield* requestWithdrawal(part, "withdrawn", reply);
-                    }
-                    yield* Effect.forkIn(settleWithdrawals(replies, message.reply, groups.has(message.key)), actorScope);
-                    break;
-                }
-                case "Release": {
-                    const item = items.get(message.key);
-                    if (item?.held !== true || item.phase === "Started" || item.phase === "Terminal") {
-                        yield* Deferred.fail(message.reply, invalid("Nothing is held under that key"));
-                        break;
-                    }
-                    item.held = false;
-                    item.asap = true;
-                    yield* Deferred.succeed(message.reply, undefined);
-                    break;
-                }
-                case "Drain": {
-                    if (drainFailure !== undefined) {
-                        yield* Deferred.fail(message.reply, drainFailure);
-                        break;
-                    }
-                    accepting = false;
-                    if (drained) {
-                        yield* Deferred.succeed(message.reply, undefined);
-                        break;
-                    }
-                    drainReplies.push(message.reply);
-                    if (!draining) {
-                        draining = true;
-                        finishAccepted = message.finish === "accepted";
-                        updateRecovery();
-                        // Renewal admission must stop even while an earlier enqueue is
-                        // awaiting its reply in the command worker.
-                        const stoppedRenewal = yield* Effect.result(engine.stopRenewal);
-                        if (ended !== undefined)
-                            break;
-                        if (Result.isFailure(stoppedRenewal)) {
-                            drainFailure = stoppedRenewal.failure;
-                            for (const reply of drainReplies.splice(0))
-                                yield* Deferred.fail(reply, stoppedRenewal.failure);
-                            break;
-                        }
-                        if (!finishAccepted) {
-                            autoplayPaused = true;
-                            yield* sendCommand({ _tag: "PauseAutoplay" });
-                        }
-                    }
-                    break;
-                }
-                case "Snapshot": {
-                    lastProcessedSnapshotSerial = message.acquiredSerial;
-                    observationReady = true;
-                    yield* observed(message.state, true);
-                    blockedMove = undefined;
-                    break;
-                }
-                case "Event":
-                    yield* onEvent(message.event);
-                    yield* observed(yield* engine.state);
-                    blockedMove = undefined;
-                    break;
-                case "Tick":
-                    break;
-                case "CommandDone":
-                    yield* handleCommandDone(message.command, message.result);
-                    if (commandCount === 0)
-                        earlyClipEvents.clear();
-                    break;
-                case "Closed":
-                    yield* closeActor(message.cause);
-                    yield* Deferred.fail(initialized, ReactorError.fromCode("Closed", message.cause.message));
-                    break;
-            }
-            if (ended === undefined)
-                yield* reconcile;
-            if (message._tag === "Snapshot")
-                yield* Deferred.succeed(initialized, undefined);
-        }
-    });
-    const observe = Effect.gen(function* () {
-        for (;;) {
-            const result = yield* Effect.result(Effect.scoped(Effect.gen(function* () {
-                // Claim the serial before acquiring the initial state. A snapshot
-                // begun before an enqueue result must not disprove its clip.
-                const acquiredSerial = ++snapshotAcquiredSerial;
-                const observation = yield* engine.observe({ capacity: 4096 });
-                yield* Queue.offer(inbox, {
-                    _tag: "Snapshot",
-                    state: observation.initial,
-                    acquiredSerial,
-                });
-                yield* Stream.runForEach(observation.events, (event) => Queue.offer(inbox, { _tag: "Event", event }));
-            })));
-            if (Result.isSuccess(result)) {
-                yield* Queue.offer(inbox, {
-                    _tag: "Closed",
-                    cause: ReactorError.fromCode("Closed", "The orchestration closed"),
-                });
-                return;
-            }
-            if (result.failure.reason._tag !== "Overflow") {
-                yield* Queue.offer(inbox, { _tag: "Closed", cause: result.failure });
-                return;
-            }
-        }
-    });
-    // Orderly scope teardown has already claimed and settled Closed before
-    // worker interruption; unexpected interruption retains its original Cause.
-    const supervise = (effect) => effect.pipe(Effect.onExit((exit) => Exit.isFailure(exit) && ended === undefined
-        ? terminate(Exit.failCause(exit.cause))
-        : Effect.void));
-    yield* Effect.forkScoped(supervise(watchdog));
-    yield* Effect.forkScoped(supervise(commandWorker));
-    yield* Effect.forkScoped(supervise(actor));
-    yield* Effect.forkScoped(supervise(observe));
-    yield* Effect.forkScoped(Effect.gen(function* () {
-        for (;;) {
-            yield* Effect.sleep("100 millis");
-            yield* Queue.offer(inbox, { _tag: "Tick" });
-        }
-    }));
-    yield* Queue.offer(inbox, { _tag: "Tick" });
-    yield* Effect.addFinalizer(() => closeActor(ReactorError.fromCode("Closed", "The scheduler closed")));
-    yield* Deferred.await(initialized);
-    const laneSet = new Set(lanes);
-    const send = (edits, batched) => Effect.gen(function* () {
-        const reply = yield* Deferred.make();
-        if (!(yield* Queue.offer(inbox, { _tag: "Edit", edits, batched, reply })))
-            return yield* closedCall;
-        return yield* Deferred.await(reply).pipe(Effect.raceFirst(closedCall));
-    });
-    /** The one result of a single call. */
-    const only = (handle) => handle.results[0];
-    const submit = (input) => Effect.gen(function* () {
-        if (yield* Deferred.isDone(stopped))
-            return yield* closedCall;
-        const item = yield* captureItem(input, laneSet);
-        yield* Effect.annotateCurrentSpan("reactor.scheduler.item.key", item.key);
-        const result = only(yield* send([{ _tag: "Submit", item }], false));
-        if (result?._tag !== "Added")
-            return yield* Effect.die("A submission returned no item");
-        return result.handle;
-    }).pipe(Effect.withSpan("Scheduler.submit", {}, { captureStackTrace: false }));
-    const submitGroup = (input) => Effect.gen(function* () {
-        if (yield* Deferred.isDone(stopped))
-            return yield* closedCall;
-        const group = yield* captureGroup(input, laneSet);
-        yield* Effect.annotateCurrentSpan("reactor.scheduler.group.key", group.key);
-        const result = only(yield* send([{ _tag: "SubmitGroup", group }], false));
-        if (result?._tag !== "AddedGroup")
-            return yield* Effect.die("A group returned no handle");
-        return result.handle;
-    }).pipe(Effect.withSpan("Scheduler.submitGroup", {}, { captureStackTrace: false }));
-    const replace = (key, input) => Effect.gen(function* () {
-        if (yield* Deferred.isDone(stopped))
-            return yield* closedCall;
-        const next = yield* captureReplacement(input);
-        const result = only(yield* send([{ _tag: "Replace", key, next }], false).pipe(
-        // A replacement keeps the replaced item's place and window, so neither a deadline
-        // nor its lane's policy is checked for it.
-        Effect.catchTag(["WouldMissDeadline", "LaneBusy"], (error) => Effect.die(error))));
-        if (result?._tag !== "Added")
-            return yield* Effect.die("A replacement returned no item");
-        return result.handle;
-    }).pipe(Effect.withSpan("Scheduler.replace", { attributes: { key } }, { captureStackTrace: false }));
-    const insert = (input) => Effect.gen(function* () {
-        if (yield* Deferred.isDone(stopped))
-            return yield* closedCall;
-        const captured = yield* captureInsert(input);
-        yield* Effect.annotateCurrentSpan("reactor.scheduler.item.key", captured.key);
-        const result = only(yield* send([{ _tag: "Insert", insert: captured }], false).pipe(
-        // An insert places itself, so its lane's policy does not apply.
-        Effect.catchTag("LaneBusy", (error) => Effect.die(error))));
-        if (result?._tag !== "Added")
-            return yield* Effect.die("An insert returned no item");
-        return result.handle;
-    }).pipe(Effect.withSpan("Scheduler.insert", {}, { captureStackTrace: false }));
-    const edit = (input) => Effect.gen(function* () {
-        if (yield* Deferred.isDone(stopped))
-            return yield* closedCall;
-        const edits = yield* captureEdits(input, laneSet);
-        yield* Effect.annotateCurrentSpan("reactor.scheduler.edits", edits.length);
-        return yield* send(edits, true);
-    }).pipe(Effect.withSpan("Scheduler.edit", {}, { captureStackTrace: false }));
-    const release = (key) => Effect.gen(function* () {
-        const reply = yield* Deferred.make();
-        if (!(yield* Queue.offer(inbox, { _tag: "Release", key, reply })))
-            return yield* closedCall;
-        return yield* Deferred.await(reply).pipe(Effect.raceFirst(closedCall));
-    }).pipe(Effect.withSpan("Scheduler.release", { attributes: { key } }, { captureStackTrace: false }));
-    const withdraw = (key) => Effect.gen(function* () {
-        const reply = yield* Deferred.make();
-        if (!(yield* Queue.offer(inbox, { _tag: "Withdraw", key, reply })))
-            return yield* closedCall;
-        return yield* Deferred.await(reply).pipe(Effect.raceFirst(closedCall));
-    }).pipe(Effect.withSpan("Scheduler.withdraw", { attributes: { key } }, {
-        captureStackTrace: false,
-    }));
-    const drain = (options = {}) => Effect.gen(function* () {
-        const reply = yield* Deferred.make();
-        const finish = options.finish ?? "playing";
-        if (finish !== "playing" && finish !== "accepted")
-            return yield* invalid("Drain finish must be playing or accepted");
-        if (!(yield* Queue.offer(inbox, { _tag: "Drain", finish, reply })))
-            return yield* closedCall;
-        yield* Deferred.await(reply).pipe(Effect.raceFirst(closedCall));
-    }).pipe(Effect.withSpan("Scheduler.drain", {}, { captureStackTrace: false }));
-    return {
-        submit,
-        submitGroup,
-        replace,
-        insert,
-        edit,
-        release,
-        withdraw,
-        drain,
-        failure: Deferred.await(stopped),
-        state: SubscriptionRef.get(stateRef),
-        asRun: Stream.fromPubSub(events),
-        cues: Stream.fromPubSub(cueEvents),
-    };
-}).pipe(Effect.provideServiceEffect(Scope.Scope, Effect.flatMap(Scope.Scope, (parent) => Scope.fork(parent, "sequential"))));
-export const layerScheduler = (options) => Layer.effect(Scheduler, makeScheduler(options));
-//# sourceMappingURL=scheduler.js.map