reactor-effect-client 0.5.0 → 0.7.0

package/dist/orchestration/scheduler.js

@@ -10,15 +10,18 @@ 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 { plan, runwaySeconds } from "./scheduler-policy.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"));
@@ -35,6 +38,14 @@ export class KeyMismatch extends Schema.TaggedError()("KeyMismatch", {
         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 });
@@ -51,9 +62,8 @@ const ownedData = (input, fields, name) => {
         return Result.fail(invalid(`${name} has unsupported fields or accessors`));
     return Result.succeed(Object.fromEntries(Object.entries(descriptors).map(([field, descriptor]) => [field, descriptor.value])));
 };
-const captureDuration = (input) => Effect.gen(function* () {
-    if (input === null || typeof input !== "object" || Duration.isDuration(input))
-        return input;
+/** 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 ||
@@ -61,51 +71,107 @@ const captureDuration = (input) => Effect.gen(function* () {
             descriptors.length?.value !== 2 ||
             descriptors["0"] === undefined ||
             descriptors["1"] === undefined)
-            return yield* invalid("Duration tuple has unsupported fields or accessors");
-        return [descriptors["0"].value, descriptors["1"].value];
+            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]);
     }
-    return (yield* Effect.fromResult(ownedData(input, [
-        "weeks",
-        "days",
-        "hours",
-        "minutes",
-        "seconds",
-        "milliseconds",
-        "microseconds",
-        "nanoseconds",
-    ], "Duration")));
+    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)));
 });
-/** Capture scheduling fields before reading the request's placement fields. */
-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");
+/** 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);
-    if (Object.getOwnPropertySymbols(input).length > 0 ||
-        Object.keys(descriptors).some((field) => !["key", "lane", "request", "window", "start"].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 rawRequest = descriptors.request?.value;
-    const request = yield* captureRequest(rawRequest);
+    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");
-    const rawWindow = descriptors.window?.value;
-    const window = rawWindow === undefined
+    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(rawWindow, ["notBefore", "startBy", "firm"], "Scheduled window"));
+        : yield* Effect.fromResult(ownedData(input, ["notBefore", "startBy", "firm"], "Scheduled window"));
     const notBeforeOffsetMs = window?.notBefore === undefined
         ? undefined
         : yield* requestDuration(window.notBefore, "notBefore", true);
@@ -119,15 +185,37 @@ const captureItem = (input, lanes) => Effect.gen(function* () {
                 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";
-    if (start?._tag === "Follow" && (start.time !== undefined || start.late !== undefined))
-        return yield* invalid("Follow cannot contain an anchor or lateness policy");
-    if (start !== undefined && start._tag !== "Follow") {
+    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;
@@ -147,20 +235,166 @@ const captureItem = (input, lanes) => Effect.gen(function* () {
         request,
         notBeforeOffsetMs,
         startByOffsetMs,
-        firm: window?.firm === true,
+        firm,
         atWallMs,
         late,
+        ...(mode === undefined ? {} : { mode }),
+        ...(cues.length === 0 ? {} : { cues }),
+        ...(continuity === undefined ? {} : { continuity }),
         fingerprint: JSON.stringify({
             lane,
             request,
             notBeforeOffsetMs,
             startByOffsetMs,
-            firm: window?.firm === true,
+            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,
@@ -176,13 +410,21 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             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 { floorSeconds, targetSeconds, maxBuildsInFlight, maxHistory } = yield* parsedInput(() => {
+    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 ||
@@ -191,12 +433,31 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             maxHistory < 0 ||
             maxHistory > 65_536)
             throw ReactorError.fromCode("InvalidInput", "Scheduler runway or build cap is invalid");
-        return { floorSeconds, targetSeconds, maxBuildsInFlight, maxHistory };
+        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, targetSeconds) => Effect.gen(function* () {
+    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 ||
@@ -209,15 +470,19 @@ export const makeScheduler = (options) => Effect.gen(function* () {
     });
     let fillerIndex = 0;
     let fillerRetryAtMs = 0;
-    let unknownFiller;
-    let upcomingFiller = yield* captureFiller(0, 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,
@@ -226,12 +491,16 @@ export const makeScheduler = (options) => Effect.gen(function* () {
         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.
@@ -247,7 +516,13 @@ export const makeScheduler = (options) => Effect.gen(function* () {
     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();
@@ -262,9 +537,56 @@ export const makeScheduler = (options) => Effect.gen(function* () {
     let drained = false;
     let observationReady = false;
     let blockedMove;
-    const emit = (entry, status) => Effect.gen(function* () {
+    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" ||
@@ -275,7 +597,20 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 : status._tag === "Unknown" && status.terminal !== true
                     ? "Unknown"
                     : "Terminal";
-        yield* PubSub.publish(events, {
+        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,
@@ -293,31 +628,172 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             yield* Deferred.succeed(entry.outcomeWaiter, status);
         }
     });
-    const closeActor = (cause) => Effect.gen(function* () {
+    // 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;
-        ended = cause;
+            return Deferred.await(settled);
+        ended = terminal;
         accepting = false;
-        yield* Deferred.succeed(stopped, cause);
-        for (const item of items.values()) {
-            if (item.phase === "Terminal")
-                continue;
-            if (item.phase === "Unknown") {
-                yield* emit(item, { _tag: "Unknown", terminal: true });
-                item.phase = "Terminal";
+        // 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);
             }
-            else
-                yield* emit(item, { _tag: "Failed", reason: { _tag: "Scheduler", cause } });
+            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 closed = PolicyFailure.refuse("SessionClosed", cause.message);
-        for (const [key, pending] of pendingWithdrawals) {
-            for (const reply of pending.replies)
-                yield* Deferred.fail(reply, closed);
-            pendingWithdrawals.delete(key);
+    };
+    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;
+            }
         }
-        for (const reply of drainReplies.splice(0))
-            yield* Deferred.fail(reply, closed);
-        yield* SubscriptionRef.update(stateRef, (state) => ({ ...state, accepting: false }));
     });
     const prune = (state) => {
         const active = new Set(activeIds(state));
@@ -338,6 +814,10 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 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) {
@@ -349,8 +829,48 @@ export const makeScheduler = (options) => Effect.gen(function* () {
         }
         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) => {
+    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
@@ -372,18 +892,18 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     .filter((item) => item.lane === name && item.phase !== "Terminal")
                     .map((item) => item.key),
             })),
-            sessions: state.sessions.map(({ sessionId }) => ({
-                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;
-                }),
-            })),
+            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,
@@ -454,8 +974,8 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             filler.set(index, { index, clipId: record.clipId, sessionId: record.sessionId });
             const priorIndex = fillerIndex;
             fillerIndex = Math.max(fillerIndex, index + 1);
-            if (unknownFiller?.index === index)
-                unknownFiller = undefined;
+            provedUnknown(unknownFillers.get(index)?.atMs);
+            unknownFillers.delete(index);
             if (fillerIndex !== priorIndex)
                 upcomingFiller = undefined;
         }
@@ -467,6 +987,9 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 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 });
                 }
@@ -505,6 +1028,7 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             }
             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 });
@@ -530,7 +1054,7 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     lastProcessedSnapshotSerial > item.acknowledgedAtSnapshotSerial))
                 yield* emit(item, { _tag: "Unobserved" });
         }
-        yield* publishState(state);
+        updateRecovery(state);
     });
     const onEvent = (event) => Effect.gen(function* () {
         if (event._tag === "Starved")
@@ -568,6 +1092,11 @@ export const makeScheduler = (options) => Effect.gen(function* () {
         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") {
@@ -588,6 +1117,7 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     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;
@@ -639,9 +1169,33 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     });
                 playingStartedMs.delete(event.clipId);
                 break;
-            case "Failed":
+            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;
         }
@@ -662,6 +1216,12 @@ export const makeScheduler = (options) => 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);
@@ -675,18 +1235,67 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 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* Queue.take(commandQueue);
+            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 (command._tag === "Build")
+        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++;
@@ -714,10 +1323,16 @@ export const makeScheduler = (options) => Effect.gen(function* () {
         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, item.phase === "Started" ? "already-started" : "not-found");
+                yield* Deferred.succeed(reply, settledOutcome(item));
             return;
         }
         const pending = pendingWithdrawals.get(item.key);
@@ -740,22 +1355,12 @@ export const makeScheduler = (options) => Effect.gen(function* () {
     });
     const applyPolicy = (action, state) => Effect.gen(function* () {
         switch (action._tag) {
-            case "Withdraw": {
-                const item = items.get(action.key);
-                if (item !== undefined)
-                    yield* requestWithdrawal(item, action.reason);
-                break;
-            }
             case "DeferAt":
                 if (canRetryRemoval(action.clipId))
                     yield* sendCommand({ _tag: "DeferAt", key: action.key, clipId: action.clipId });
                 break;
-            case "WithdrawFiller":
-                for (const clipId of action.clipIds)
-                    if (!pendingFillerRemovals.has(clipId) && canRetryRemoval(clipId)) {
-                        pendingFillerRemovals.add(clipId);
-                        yield* sendCommand({ _tag: "RemoveFiller", clipId });
-                    }
+            case "Cut":
+                yield* sendCommand({ _tag: "Cut", clipId: action.clipId });
                 break;
             case "Order": {
                 const signature = state.ready.map((record) => record.clipId).join(",") +
@@ -776,7 +1381,7 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 const item = items.get(action.key);
                 if (item?.phase !== "Accepted")
                     break;
-                const prepared = yield* Effect.result(keyedRequest(item.request, item.key));
+                const prepared = yield* Effect.result(keyedRequest(item.request, item.key, action.continueFrom));
                 if (Result.isFailure(prepared)) {
                     yield* emit(item, {
                         _tag: "Failed",
@@ -793,10 +1398,16 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 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.targetSeconds))
+                    ]), action.durationSeconds, action.targetSeconds))
                     : Result.succeed(upcomingFiller);
                 if (Result.isFailure(captured)) {
                     yield* closeActor(captured.failure);
@@ -862,17 +1473,21 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     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 (pending !== undefined) {
-                        if (item.phase === "Started" ||
-                            item.status._tag === "Ended" ||
-                            item.status._tag === "Unobserved")
-                            yield* finishWithdrawal(item.key, Result.succeed("already-started"));
-                        else if (item.phase === "Terminal")
-                            yield* finishWithdrawal(item.key, Result.succeed("not-found"));
+                    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);
                     }
@@ -881,6 +1496,8 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     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.
@@ -904,6 +1521,7 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                         });
                     else
                         item.retryAtMs = monotonicMillis(clock) + 1_000;
+                    delete item.dispatchedAtMs;
                 }
                 break;
             }
@@ -928,13 +1546,10 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     yield* replayEarlyClipEvents(clipId);
                 }
                 else if (result.failure.context.outcome === "unknown") {
-                    if (!filler.has(command.index))
-                        unknownFiller = {
-                            index: command.index,
-                            sessionId: engine.enqueueOnSource === undefined ? undefined : command.sessionId,
-                        };
+                    // 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);
@@ -967,7 +1582,9 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                         removalUnknownAtSerial.set(command.clipId, snapshotAcquiredSerial);
                     if (item?.phase === "Started")
                         yield* finishWithdrawal(command.key, Result.succeed("already-started"));
-                    else
+                    // 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;
@@ -1025,6 +1642,10 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             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;
@@ -1035,90 +1656,63 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 break;
         }
     });
-    // An accepted drain still owes air to every line not yet Ready, and to a
-    // Ready line held for a future At anchor, which runway must reach. Filler
-    // is the only material that can cover either, so it keeps playing and
-    // refilling until nothing accepted can still leave the host frozen. An
-    // Unknown item does not count: without a fenced source it can stay open
-    // until the scheduler closes, and filler for it would never stop.
-    const fillerHeld = (nowMs) => draining &&
-        finishAccepted &&
-        [...items.values()].some((item) => item.phase === "Accepted" ||
-            item.phase === "Building" ||
-            (item.phase === "Ready" && item.atMs !== undefined && item.atMs > nowMs));
-    const drainPending = (state) => Effect.gen(function* () {
-        if (!draining)
-            return;
-        const playingId = Option.getOrUndefined(state.playing)?.clipId;
-        for (const item of items.values()) {
-            if (finishAccepted)
-                break;
-            if (item.phase === "Terminal" || item.phase === "Started")
-                continue;
-            if (item.clipId === playingId)
+    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;
-            yield* requestWithdrawal(item, "withdrawn");
+            batch.targets.delete(key);
+            return target.reply;
         }
-        if (fillerHeld(monotonicMillis(clock)))
+        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;
-        for (const entry of filler.values()) {
-            if (entry.clipId !== undefined &&
-                entry.clipId !== playingId &&
-                !pendingFillerRemovals.has(entry.clipId) &&
-                canRetryRemoval(entry.clipId)) {
-                pendingFillerRemovals.add(entry.clipId);
-                yield* sendCommand({ _tag: "RemoveFiller", clipId: entry.clipId });
-            }
+        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 projectedStartMs = (state, lane, nowMs) => {
-        const playing = Option.getOrUndefined(state.playing);
-        const playingRecord = playing === undefined ? undefined : Option.getOrUndefined(playing.record);
-        const started = playing === undefined ? undefined : playingStartedMs.get(playing.clipId);
-        const restMs = playingRecord === undefined || started === undefined
-            ? 0
-            : Math.max(0, playingRecord.durationSeconds * 1000 - (nowMs - started));
-        const laneRank = lanes.indexOf(lane);
-        const preferred = Option.getOrUndefined(state.preferredSessionId);
-        const aheadMs = state.ready.reduce((total, record) => {
-            if (record.sessionId !== preferred)
-                return total;
-            const owner = owned.get(record.clipId);
-            if (owner?._tag === "Filler")
-                return total;
-            if (owner?._tag === "Item") {
-                const prior = items.get(owner.key);
-                if (prior !== undefined && lanes.indexOf(prior.lane) > laneRank)
-                    return total;
-            }
-            return total + record.durationSeconds * 1000;
-        }, 0);
-        return nowMs + restMs + aheadMs;
-    };
     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);
+            yield* publishState(state, sources.sessions);
             return;
         }
-        if (unknownFiller !== undefined) {
-            const uncertain = unknownFiller;
-            const sourceRetired = uncertain.sessionId !== undefined &&
-                !state.sessions.some((session) => session.sessionId === uncertain.sessionId);
-            if (sourceRetired) {
-                unknownFiller = undefined;
-                fillerIndex = Math.max(fillerIndex, uncertain.index + 1);
-                upcomingFiller = undefined;
-            }
-            else if (uncertain.sessionId !== undefined &&
-                Option.getOrUndefined(state.preferredSessionId) !== uncertain.sessionId &&
-                fillerIndex <= uncertain.index) {
-                // A replacement may build independently, with a distinct key. The
-                // uncertain old request can still be adopted if it later appears.
-                fillerIndex = uncertain.index + 1;
-                upcomingFiller = undefined;
+        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) {
@@ -1127,6 +1721,10 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                 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);
         }
@@ -1134,11 +1732,21 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             if (item.phase === "Unknown" &&
                 item.clipId === undefined &&
                 item.unknownSessionId !== undefined &&
-                !state.sessions.some((session) => session.sessionId === item.unknownSessionId))
+                !sources.has(item.unknownSessionId))
                 yield* resolveRetiredUnknown(item);
-        if (draining)
-            yield* drainPending(state);
-        const decision = plan({
+        // 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,
@@ -1149,15 +1757,40 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             targetSeconds,
             refillActive,
             maxBuildsInFlight,
-            accepting: accepting || (draining && finishAccepted),
-            fillerEnabled: !draining || fillerHeld(monotonicMillis(clock)),
+            accepting,
+            drain: draining ? (finishAccepted ? "accepted" : "playing") : undefined,
             fillerRetryAtMs,
-            fillerUnknown: unknownFiller !== undefined,
-            fillerUnknownSessionId: unknownFiller?.sessionId,
+            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;
-        yield* publishState(state);
+        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 &&
@@ -1173,105 +1806,585 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             commandCount === 0 &&
             [...items.values()].every((item) => item.phase === "Terminal") &&
             pendingWithdrawals.size === 0 &&
-            unknownFiller === undefined) {
+            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* Queue.take(inbox);
-            if (ended !== undefined && message._tag !== "CommandDone") {
-                if (message._tag === "Submit")
-                    yield* Deferred.fail(message.reply, PolicyFailure.refuse("SessionClosed", ended.message));
-                else if (message._tag === "Withdraw")
-                    yield* Deferred.fail(message.reply, PolicyFailure.refuse("SessionClosed", ended.message));
-                else if (message._tag === "Drain")
-                    yield* Deferred.fail(message.reply, PolicyFailure.refuse("SessionClosed", ended.message));
+            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 "Submit": {
+                case "Edit": {
                     if (!accepting) {
                         yield* Deferred.fail(message.reply, invalid("Scheduler is draining or closed"));
                         break;
                     }
-                    const existing = items.get(message.item.key) ?? history.get(message.item.key);
-                    if (existing !== undefined) {
-                        if (existing.fingerprint === message.item.fingerprint)
-                            yield* Deferred.succeed(message.reply, existing.handle);
-                        else
-                            yield* Deferred.fail(message.reply, KeyMismatch.of(message.item.key));
-                        break;
-                    }
                     const nowMs = monotonicMillis(clock);
                     const state = yield* engine.state;
-                    const startByMs = message.item.startByOffsetMs === undefined
-                        ? undefined
-                        : nowMs + message.item.startByOffsetMs;
-                    const projectedMs = projectedStartMs(state, message.item.lane, nowMs);
-                    if (startByMs !== undefined && projectedMs > startByMs) {
-                        yield* Deferred.fail(message.reply, WouldMissDeadline.of(message.item.key));
+                    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;
                     }
-                    const startedWaiter = yield* Deferred.make();
-                    const outcomeWaiter = yield* Deferred.make();
-                    const firstDecisiveWaiter = yield* Deferred.make();
-                    const handle = {
-                        key: message.item.key,
-                        started: Deferred.await(startedWaiter),
-                        outcome: Deferred.await(outcomeWaiter),
-                        firstDecisive: Deferred.await(firstDecisiveWaiter),
-                    };
-                    const item = {
-                        key: message.item.key,
-                        lane: message.item.lane,
-                        request: message.item.request,
-                        fingerprint: message.item.fingerprint,
-                        admission: ++admission,
-                        phase: "Accepted",
-                        status: { _tag: "Accepted" },
-                        ...(message.item.notBeforeOffsetMs === undefined
-                            ? {}
-                            : { notBeforeMs: nowMs + message.item.notBeforeOffsetMs }),
-                        ...(startByMs === undefined ? {} : { startByMs }),
-                        firm: message.item.firm,
-                        ...(message.item.atWallMs === undefined
-                            ? {}
-                            : {
-                                atWallMs: message.item.atWallMs,
-                                atMs: nowMs + message.item.atWallMs - clock.currentTimeMillisUnsafe(),
-                            }),
-                        late: message.item.late,
-                        sessionId: undefined,
-                        unknownSessionId: undefined,
-                        unknownCause: undefined,
-                        handle,
-                        startedWaiter,
-                        outcomeWaiter,
-                        firstDecisiveWaiter,
-                    };
-                    items.set(item.key, item);
-                    yield* PubSub.publish(events, {
-                        key: item.key,
-                        at: clock.currentTimeMillisUnsafe(),
-                        status: item.status,
-                    });
+                    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);
-                    yield* Deferred.succeed(message.reply, handle);
+                    // 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 === undefined)
-                        yield* Deferred.succeed(message.reply, "not-found");
-                    else
-                        yield* requestWithdrawal(item, "withdrawn", message.reply);
+                    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": {
@@ -1288,9 +2401,12 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                     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))
@@ -1302,7 +2418,6 @@ export const makeScheduler = (options) => Effect.gen(function* () {
                             yield* sendCommand({ _tag: "PauseAutoplay" });
                         }
                     }
-                    yield* drainPending(yield* engine.state);
                     break;
                 }
                 case "Snapshot": {
@@ -1362,22 +2477,12 @@ export const makeScheduler = (options) => Effect.gen(function* () {
             }
         }
     });
-    // A defect remains a defect, but it must wake waiters just as a typed
-    // terminal failure does. Scope interruption uses the finalizer below.
+    // 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
-        ? Effect.gen(function* () {
-            accepting = false;
-            yield* Deferred.failCause(stopped, exit.cause);
-            yield* Deferred.failCause(initialized, exit.cause);
-            for (const item of items.values()) {
-                yield* Deferred.failCause(item.startedWaiter, exit.cause);
-                yield* Deferred.failCause(item.outcomeWaiter, exit.cause);
-                yield* Deferred.failCause(item.firstDecisiveWaiter, exit.cause);
-            }
-            yield* Queue.shutdown(inbox);
-            yield* Queue.shutdown(commandQueue);
-        })
+        ? 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));
@@ -1390,16 +2495,72 @@ export const makeScheduler = (options) => Effect.gen(function* () {
     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, new Set(lanes));
+        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: "Submit", item, reply })))
+        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.submit", {}, { captureStackTrace: false }));
+    }).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 })))
@@ -1419,12 +2580,18 @@ export const makeScheduler = (options) => Effect.gen(function* () {
     }).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