@you-agent-factory/factory-emulator 0.0.0 → 0.0.1

package/dist/session.js

@@ -0,0 +1,1490 @@
+import { inspectFactoryEmulatorCompatibility } from "./compatibility.js";
+import { visitCountGuardsAllow, visitsAfterTransition, } from "./logical-move.js";
+import { safeParseFactoryEmulatorScenario } from "./scenario.js";
+import { compareFactorySchedulerCandidates, FACTORY_EMULATOR_SCHEDULER_CANDIDATE_LIMIT, selectFactorySchedulerCandidates, } from "./scheduler.js";
+import { DEFAULT_FACTORY_EMULATOR_LIMITS, FACTORY_EMULATOR_LIMIT_HARD_CAPS, FactoryEmulatorConfigurationError, FactoryEmulatorDurationError, FactoryEmulatorExecutionPausedError, FactoryEmulatorLifecycleError, FactoryEmulatorPendingCommandError, FactoryEmulatorSubmissionError, } from "./session-contracts.js";
+export * from "./session-contracts.js";
+const LIMIT_NAMES = Object.keys(DEFAULT_FACTORY_EMULATOR_LIMITS);
+const PRE_START_STATE = {
+    lifecycle: "pre-start",
+    virtualElapsedMs: 0,
+    counters: { commands: 0, events: 0, completedDispatches: 0 },
+};
+function isSubmissionArray(value) {
+    return Array.isArray(value);
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function canonicalJson(value) {
+    return JSON.stringify(value, (_key, nested) => {
+        if (nested === null ||
+            typeof nested !== "object" ||
+            Array.isArray(nested)) {
+            return nested;
+        }
+        return Object.fromEntries(Object.entries(nested).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0));
+    });
+}
+function canonicalClone(value) {
+    return JSON.parse(canonicalJson(value));
+}
+function resolveLimits(configured, diagnostics) {
+    const limits = { ...DEFAULT_FACTORY_EMULATOR_LIMITS, ...configured };
+    for (const name of LIMIT_NAMES) {
+        const value = limits[name];
+        const hardCap = FACTORY_EMULATOR_LIMIT_HARD_CAPS[name];
+        if (!Number.isSafeInteger(value) || value < 1 || value > hardCap) {
+            diagnostics.push({
+                code: "invalid_limit",
+                path: ["limits", name],
+                message: `${name} must be a positive safe integer no greater than ${hardCap}.`,
+            });
+        }
+    }
+    return Object.freeze(limits);
+}
+function validateConfiguration(options) {
+    const diagnostics = [];
+    const factory = options?.factory;
+    if (factory === null ||
+        typeof factory !== "object" ||
+        typeof factory.name !== "string" ||
+        factory.name.trim() === "") {
+        diagnostics.push({
+            code: "invalid_factory",
+            path: ["factory"],
+            message: "factory must be a Factory definition with a non-empty name.",
+        });
+    }
+    let scenario;
+    if (diagnostics.length === 0) {
+        const parsed = safeParseFactoryEmulatorScenario(options.scenario, factory);
+        if (parsed.success)
+            scenario = parsed.data;
+        else
+            diagnostics.push(...parsed.issues);
+    }
+    if (diagnostics.length === 0) {
+        const compatibility = inspectFactoryEmulatorCompatibility(factory);
+        if (!compatibility.supported) {
+            diagnostics.push(...compatibility.diagnostics.map((issue) => ({
+                code: "incompatible_factory",
+                path: ["factory", ...issue.path],
+                message: issue.message,
+            })));
+        }
+    }
+    if (options?.sink === null || typeof options?.sink?.write !== "function") {
+        diagnostics.push({
+            code: "invalid_sink",
+            path: ["sink"],
+            message: "sink must provide an asynchronous write(events) function.",
+        });
+    }
+    if (options?.yieldControl !== undefined &&
+        typeof options.yieldControl !== "function") {
+        diagnostics.push({
+            code: "invalid_yield_control",
+            path: ["yieldControl"],
+            message: "yieldControl must be a function when provided.",
+        });
+    }
+    const limits = resolveLimits(options?.limits, diagnostics);
+    if (diagnostics.length > 0 || scenario === undefined) {
+        throw new FactoryEmulatorConfigurationError(diagnostics);
+    }
+    return {
+        factory: canonicalClone(factory),
+        scenario: canonicalClone(scenario),
+        sink: options.sink,
+        limits,
+        yieldControl: options.yieldControl,
+    };
+}
+function deterministicHash(value) {
+    let hash = 0xcbf29ce484222325n;
+    for (const character of value) {
+        hash ^= BigInt(character.codePointAt(0) ?? 0);
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return hash.toString(16).padStart(16, "0");
+}
+function identity(kind, ...coordinates) {
+    return `emulator-${kind}-${deterministicHash(canonicalJson(coordinates))}`;
+}
+function sessionIdentity(factory, scenario) {
+    return identity("session", factory.id ?? factory.name, scenario);
+}
+function virtualTimeAt(scenario, elapsedMs) {
+    const timestamp = Date.parse(scenario.startAt) + elapsedMs;
+    const instant = new Date(timestamp);
+    if (!Number.isSafeInteger(elapsedMs) ||
+        !Number.isFinite(timestamp) ||
+        !Number.isFinite(instant.getTime())) {
+        throw new FactoryEmulatorDurationError(elapsedMs);
+    }
+    return instant.toISOString();
+}
+function eventContext(state, sequence, eventTime, context = {}) {
+    return {
+        sequence,
+        tick: state.counters.commands,
+        eventTime,
+        sessionId: state.sessionId,
+        sessionSequence: sequence,
+        orchestratorKind: "PETRI",
+        source: "emulator",
+        ...context,
+    };
+}
+function bootstrapEvents(factory, scenario, sessionId) {
+    const eventTime = scenario.startAt;
+    const context = (sequence) => ({
+        sequence,
+        tick: 0,
+        eventTime,
+        sessionId,
+        sessionSequence: sequence,
+        orchestratorKind: "PETRI",
+        source: "emulator",
+    });
+    return [
+        {
+            schemaVersion: "agent-factory.event.v1",
+            id: `${sessionId}/event/0/run-request`,
+            type: "RUN_REQUEST",
+            context: context(0),
+            payload: { recordedAt: eventTime, factory: clone(factory) },
+        },
+        {
+            schemaVersion: "agent-factory.event.v1",
+            id: `${sessionId}/event/1/initial-structure-request`,
+            type: "INITIAL_STRUCTURE_REQUEST",
+            context: context(1),
+            payload: { factory: clone(factory) },
+        },
+        {
+            schemaVersion: "agent-factory.event.v1",
+            id: `${sessionId}/event/2/session-started`,
+            type: "SESSION_STARTED",
+            context: context(2),
+            payload: { factoryId: factory.id ?? factory.name, startedAt: eventTime },
+        },
+    ];
+}
+function ruleMatches(rule, submissions, workstation) {
+    const selector = rule.selector;
+    return ((selector.workstation === undefined ||
+        selector.workstation === workstation.name) &&
+        (selector.worker === undefined || selector.worker === workstation.worker) &&
+        (selector.input === undefined ||
+            submissions.some((submission) => (selector.input?.workType === undefined ||
+                selector.input.workType === submission.workType) &&
+                (selector.input?.state === undefined ||
+                    selector.input.state === submission.state) &&
+                (selector.input?.name === undefined ||
+                    selector.input.name === submission.name))));
+}
+function executionFor(configuration, submissions, workstation, invocationIndex = 0) {
+    if (workstation.type === "LOGICAL_MOVE") {
+        return {
+            workstation,
+            outcome: { result: "accepted", durationMs: 0 },
+        };
+    }
+    const rule = configuration.scenario.rules.find((candidate) => ruleMatches(candidate, submissions, workstation));
+    if (rule === undefined) {
+        return configuration.scenario.unmatched.behavior === "outcome"
+            ? { workstation, outcome: configuration.scenario.unmatched.outcome }
+            : { workstation };
+    }
+    const outcome = rule.outcomes[invocationIndex] ??
+        (rule.exhaustion === "repeat-last" ? rule.outcomes.at(-1) : undefined);
+    return { rule, workstation, outcome };
+}
+function submissionForWork(work) {
+    return {
+        name: work.submissionId,
+        workType: work.workType,
+        state: work.state,
+        ...(work.input === undefined ? {} : { input: work.input }),
+        ...(work.parent === undefined ? {} : { parent: work.parent }),
+    };
+}
+function bindingIndexesFor(state, workstation, observeExpansion, visit) {
+    const inputs = workstation.inputs.map((input) => state.works.flatMap((work, index) => work.phase === "ready" &&
+        work.workType === input.workType &&
+        work.state === input.state
+        ? [index]
+        : []));
+    if (inputs.some((matches) => matches.length === 0))
+        return;
+    const append = (slot, selected) => {
+        if (slot === inputs.length) {
+            visit(selected);
+            return;
+        }
+        for (const index of inputs[slot] ?? []) {
+            if (!selected.includes(index)) {
+                observeExpansion();
+                append(slot + 1, [...selected, index]);
+            }
+        }
+    };
+    append(0, []);
+}
+function dependencyStatesFor(state) {
+    const current = new Map();
+    for (const work of state.works) {
+        if (work.phase !== "active")
+            current.set(work.workId, work.state);
+        else
+            current.delete(work.workId);
+    }
+    return current;
+}
+function dependenciesSatisfied(work, dependencyStates) {
+    return (work.relations?.every(({ targetWorkId, requiredState }) => dependencyStates.get(targetWorkId) === requiredState) ?? true);
+}
+function dependenciesAllow(works, indexes, dependencyStates, executableWork) {
+    if (works.every((work) => dependenciesSatisfied(work, dependencyStates))) {
+        return true;
+    }
+    for (const index of indexes)
+        executableWork.add(index);
+    return false;
+}
+function potentiallyBoundIndexes(state, workstation) {
+    return state.works.flatMap((work, index) => work.phase === "ready" &&
+        workstation.inputs.some((input) => input.workType === work.workType && input.state === work.state)
+        ? [index]
+        : []);
+}
+function schedulerCandidatesFor(configuration, state, cursors, assertBindingBudget) {
+    const candidates = [];
+    const executableWork = new Set();
+    const dependencyStates = dependencyStatesFor(state);
+    let observedExpansions = 0;
+    const retainBoundedCandidate = (candidate) => {
+        candidates.push(candidate);
+        candidates.sort(compareFactorySchedulerCandidates);
+        if (candidates.length > FACTORY_EMULATOR_SCHEDULER_CANDIDATE_LIMIT) {
+            candidates.pop();
+        }
+    };
+    for (const workstation of configuration.factory.workstations ?? []) {
+        const potentiallyBound = potentiallyBoundIndexes(state, workstation);
+        let foundBinding = false;
+        const seenBindings = new Set();
+        bindingIndexesFor(state, workstation, () => {
+            observedExpansions += 1;
+            assertBindingBudget(observedExpansions);
+        }, (indexes) => {
+            foundBinding = true;
+            const key = [...indexes]
+                .map((index) => state.works[index]?.tokenId ?? "")
+                .sort()
+                .join("\u0000");
+            if (seenBindings.has(key))
+                return;
+            seenBindings.add(key);
+            const works = indexes.flatMap((index) => {
+                const work = state.works[index];
+                return work === undefined ? [] : [work];
+            });
+            const primary = works[0];
+            if (primary === undefined || works.length !== workstation.inputs.length)
+                return;
+            if (!dependenciesAllow(works, indexes, dependencyStates, executableWork))
+                return;
+            if (workstation.type === "LOGICAL_MOVE" &&
+                !visitCountGuardsAllow(workstation.guards ?? [], primary.visits)) {
+                return;
+            }
+            const submissions = works.map(submissionForWork);
+            const initial = executionFor(configuration, submissions, workstation);
+            const lineage = [
+                ...new Set(works.map(({ rootWorkId }) => rootWorkId)),
+            ].sort();
+            const cursorKey = initial.rule === undefined
+                ? undefined
+                : `${initial.rule.id}:${canonicalJson(lineage)}`;
+            const invocation = cursorKey === undefined ? 0 : (cursors[cursorKey] ?? 0);
+            const execution = executionFor(configuration, submissions, workstation, invocation);
+            if (execution.outcome === undefined)
+                return;
+            for (const index of indexes)
+                executableWork.add(index);
+            retainBoundedCandidate({
+                transitionId: workstation.name,
+                workerId: workstation.worker,
+                workstationKind: workstation.type === "LOGICAL_MOVE" ? "logical" : "normal",
+                resources: (workstation.resources ?? []).map(({ name, capacity }) => ({
+                    name,
+                    capacity,
+                })),
+                tokens: works.map((work) => ({
+                    tokenId: work.tokenId,
+                    customerWork: true,
+                    processing: configuration.factory.workTypes
+                        ?.find(({ name }) => name === work.workType)
+                        ?.states.find(({ name }) => name === work.state)?.type ===
+                        "PROCESSING",
+                    queuedElapsedMs: work.queuedElapsedMs,
+                    ...(work.lastDispatchElapsedMs === undefined
+                        ? {}
+                        : { lastDispatchElapsedMs: work.lastDispatchElapsedMs }),
+                })),
+                value: {
+                    indexes,
+                    execution,
+                    invocation,
+                    ...(cursorKey === undefined ? {} : { cursorKey }),
+                },
+            });
+        });
+        if (!foundBinding) {
+            for (const index of potentiallyBound)
+                executableWork.add(index);
+        }
+    }
+    return { candidates, executableWork };
+}
+function availableResourcesFor(configuration, state) {
+    const allocated = state.works.reduce((claims, work) => {
+        if (work.phase !== "active" || work.dispatch === undefined)
+            return claims;
+        for (const resource of work.dispatch.resources) {
+            claims[resource.name] =
+                (claims[resource.name] ?? 0) + resource.capacity;
+        }
+        return claims;
+    }, {});
+    return Object.fromEntries((configuration.factory.resources ?? []).map((resource) => [
+        resource.name,
+        Math.max(0, resource.capacity - (allocated[resource.name] ?? 0)),
+    ]));
+}
+function eventResourcesFor(configuration, claims) {
+    const totals = new Map((configuration.factory.resources ?? []).map(({ name, capacity }) => [
+        name,
+        capacity,
+    ]));
+    return claims.map(({ name }) => ({ name, capacity: totals.get(name) ?? 0 }));
+}
+function defaultFailureRoutesFor(configuration, workstation) {
+    const routes = [];
+    const seen = new Set();
+    for (const input of workstation.inputs) {
+        const failedState = configuration.factory.workTypes
+            ?.find(({ name }) => name === input.workType)
+            ?.states.find(({ type }) => type === "FAILED")?.name;
+        if (failedState === undefined)
+            continue;
+        const key = `${input.workType}\u0000${failedState}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        routes.push({ workType: input.workType, state: failedState });
+    }
+    return routes;
+}
+function outcomeRoutesFor(configuration, workstation, result) {
+    if (result === "accepted")
+        return workstation.outputs ?? [];
+    if (result === "continued")
+        return workstation.onContinue ?? [];
+    if (result === "failed" && (workstation.onFailure?.length ?? 0) > 0) {
+        return workstation.onFailure ?? [];
+    }
+    if (result === "rejected" && (workstation.onRejection?.length ?? 0) > 0) {
+        return workstation.onRejection ?? [];
+    }
+    if (result === "rejected" && workstation.behavior === "REPEATER") {
+        return workstation.inputs;
+    }
+    return defaultFailureRoutesFor(configuration, workstation);
+}
+function routedWorksFor(configuration, state, dispatch, inputs) {
+    const workstation = configuration.factory.workstations?.find(({ name }) => name === dispatch.workstation);
+    const first = inputs[0];
+    if (workstation === undefined || first === undefined)
+        return [];
+    const routes = outcomeRoutesFor(configuration, workstation, dispatch.outcome.result);
+    const visits = visitsAfterTransition(inputs.map((input) => input.visits), workstation.name);
+    return routes.map((route, ordinal) => {
+        const matching = inputs.find(({ workType }) => workType === route.workType);
+        const lineageSource = matching ?? first;
+        const workId = matching?.workId ??
+            identity("work", state.sessionId, "route", dispatch.dispatchId, ordinal, route);
+        const targetStateType = configuration.factory.workTypes
+            ?.find(({ name }) => name === route.workType)
+            ?.states.find(({ name }) => name === route.state)?.type;
+        const preserveInput = workstation.workPropagation?.mode === "PRESERVE_INPUT" ||
+            dispatch.outcome.result === "failed" ||
+            (dispatch.outcome.result === "rejected" && targetStateType === "FAILED");
+        const input = preserveInput
+            ? lineageSource.input
+            : (dispatch.outcome.output ?? lineageSource.input);
+        return {
+            submissionId: `${first.submissionId}/${workstation.name}/${ordinal}`,
+            requestId: first.requestId,
+            traceId: lineageSource.traceId,
+            tokenId: identity("token", dispatch.dispatchId, ordinal, route),
+            workId,
+            rootWorkId: lineageSource.rootWorkId,
+            visits,
+            workType: route.workType,
+            state: route.state,
+            ...(input === undefined ? {} : { input }),
+            ...(matching !== undefined
+                ? matching.parent === undefined
+                    ? {}
+                    : { parent: matching.parent }
+                : { parent: first.workId }),
+            ...(matching?.relations === undefined
+                ? {}
+                : { relations: matching.relations }),
+            queuedElapsedMs: dispatch.dueElapsedMs,
+            lastDispatchElapsedMs: Math.min(lineageSource.lastDispatchElapsedMs ?? dispatch.dueElapsedMs, dispatch.dueElapsedMs),
+            phase: targetStateType === "TERMINAL" || targetStateType === "FAILED"
+                ? "completed"
+                : "ready",
+        };
+    });
+}
+function eventWorkFor(configuration, work) {
+    return {
+        name: work.submissionId,
+        workId: work.workId,
+        requestId: work.requestId,
+        workTypeName: work.workType,
+        state: {
+            name: work.state,
+            type: configuration.factory.workTypes
+                ?.find(({ name }) => name === work.workType)
+                ?.states.find(({ name }) => name === work.state)?.type ??
+                "PROCESSING",
+        },
+        currentChainingTraceId: work.traceId,
+        traceId: work.traceId,
+        ...(work.input === undefined ? {} : { payload: work.input }),
+    };
+}
+function stateTypeFor(configuration, work) {
+    return configuration.factory.workTypes
+        ?.find(({ name }) => name === work.workType)
+        ?.states.find(({ name }) => name === work.state)?.type;
+}
+function failedStateFor(configuration, workType) {
+    return configuration.factory.workTypes
+        ?.find(({ name }) => name === workType)
+        ?.states.find(({ type }) => type === "FAILED")?.name;
+}
+function cascadeDependencyFailures(configuration, state, eventTime, sequence) {
+    const works = [...state.works];
+    const currentIndexes = new Map();
+    for (const [index, work] of works.entries())
+        currentIndexes.set(work.workId, index);
+    const currentWorks = [...currentIndexes.values()].flatMap((index) => {
+        const work = works[index];
+        return work === undefined ? [] : [work];
+    });
+    const dependents = new Map();
+    for (const work of currentWorks) {
+        for (const relation of work.relations ?? []) {
+            const existing = dependents.get(relation.targetWorkId) ?? [];
+            existing.push(work);
+            dependents.set(relation.targetWorkId, existing);
+        }
+    }
+    const queue = currentWorks
+        .filter((work) => stateTypeFor(configuration, work) === "FAILED")
+        .map(({ workId }) => workId);
+    const cascaded = new Set();
+    const events = [];
+    for (let cursor = 0; cursor < queue.length; cursor += 1) {
+        const triggerWorkId = queue[cursor];
+        if (triggerWorkId === undefined)
+            continue;
+        for (const dependent of dependents.get(triggerWorkId) ?? []) {
+            if (cascaded.has(dependent.workId))
+                continue;
+            const index = currentIndexes.get(dependent.workId);
+            const current = index === undefined ? undefined : works[index];
+            if (index === undefined || current === undefined)
+                continue;
+            const currentType = stateTypeFor(configuration, current);
+            if (currentType === "TERMINAL" || currentType === "FAILED")
+                continue;
+            const failedState = failedStateFor(configuration, current.workType);
+            if (failedState === undefined)
+                continue;
+            cascaded.add(current.workId);
+            queue.push(current.workId);
+            works[index] = {
+                ...current,
+                state: failedState,
+                phase: "completed",
+                dispatch: undefined,
+            };
+            const eventSequence = sequence + events.length;
+            const reason = `cascading failure: dependency ${triggerWorkId} failed`;
+            events.push({
+                schemaVersion: "agent-factory.event.v1",
+                id: identity("event", state.sessionId, eventSequence, "WORK_STATE_CHANGE", current.workId),
+                type: "WORK_STATE_CHANGE",
+                context: eventContext(state, eventSequence, eventTime, {
+                    requestId: current.requestId,
+                    workIds: [current.workId],
+                }),
+                payload: {
+                    workId: current.workId,
+                    workTypeName: current.workType,
+                    fromState: current.state,
+                    toState: failedState,
+                    fromPlaceId: `${current.workType}:${current.state}`,
+                    toPlaceId: `${current.workType}:${failedState}`,
+                    source: "cascading-failure",
+                    triggerWorkId,
+                    reason,
+                },
+            });
+        }
+    }
+    return { events, works };
+}
+function workRequestEvent(configuration, state, sequence, requestId, works, relations) {
+    return {
+        schemaVersion: "agent-factory.event.v1",
+        id: identity("event", state.sessionId, sequence, "WORK_REQUEST"),
+        type: "WORK_REQUEST",
+        context: eventContext(state, sequence, state.virtualTime, {
+            requestId,
+            traceIds: works.map(({ traceId }) => traceId),
+            workIds: works.map(({ workId }) => workId),
+        }),
+        payload: {
+            type: "FACTORY_REQUEST_BATCH",
+            source: "emulator",
+            works: works.map((work) => ({
+                name: work.submissionId,
+                workId: work.workId,
+                requestId: work.requestId,
+                workTypeName: work.workType,
+                state: {
+                    name: work.state,
+                    type: configuration.factory.workTypes
+                        ?.find(({ name }) => name === work.workType)
+                        ?.states.find(({ name }) => name === work.state)?.type ??
+                        "INITIAL",
+                },
+                currentChainingTraceId: work.traceId,
+                traceId: work.traceId,
+                ...(work.input === undefined ? {} : { payload: work.input }),
+            })),
+            ...(relations.length === 0
+                ? {}
+                : { relations: relations.map((relation) => ({ ...relation })) }),
+        },
+    };
+}
+function relationshipChangeEvents(state, sequence, requestId, workByName, relations) {
+    return relations.map((relation, ordinal) => {
+        const source = workByName.get(relation.sourceWorkName);
+        const target = workByName.get(relation.targetWorkName);
+        if (source === undefined || target === undefined) {
+            throw new Error("Validated submission relationship endpoint is missing.");
+        }
+        const relationshipSequence = sequence + ordinal + 1;
+        return {
+            schemaVersion: "agent-factory.event.v1",
+            id: identity("event", state.sessionId, relationshipSequence, "RELATIONSHIP_CHANGE_REQUEST", requestId, ordinal),
+            type: "RELATIONSHIP_CHANGE_REQUEST",
+            context: eventContext(state, relationshipSequence, state.virtualTime, {
+                requestId,
+                traceIds: [source.traceId, target.traceId],
+                workIds: [source.workId, target.workId],
+            }),
+            payload: { relation },
+        };
+    });
+}
+function workRequestCalculation(configuration, state, submissionBatch, command) {
+    const requestId = identity("request", state.sessionId, command, state.counters.commands);
+    const works = submissionBatch.works.map((submission, ordinal) => {
+        const workId = identity("work", state.sessionId, command, state.counters.commands, ordinal, submission);
+        const traceId = identity("trace", workId, requestId);
+        return {
+            submissionId: submission.name,
+            requestId,
+            traceId,
+            tokenId: identity("token", workId, submission.workType, submission.state),
+            workId,
+            rootWorkId: workId,
+            visits: {},
+            workType: submission.workType,
+            state: submission.state,
+            ...(submission.input === undefined ? {} : { input: submission.input }),
+            ...(submission.parent === undefined ? {} : { parent: submission.parent }),
+            queuedElapsedMs: state.virtualElapsedMs,
+            phase: "ready",
+        };
+    });
+    const workByName = new Map(works.map((work) => [work.submissionId, work]));
+    const resolvedWorkId = (name) => {
+        const resolved = workByName.get(name);
+        if (resolved === undefined) {
+            throw new Error(`Validated submission target ${name} is missing.`);
+        }
+        return resolved.workId;
+    };
+    const normalizedWorks = works.map((work) => {
+        const relations = submissionBatch.relations
+            .filter(({ sourceWorkName }) => sourceWorkName === work.submissionId)
+            .map((relation) => ({
+            type: "DEPENDS_ON",
+            sourceWorkName: relation.sourceWorkName,
+            targetWorkName: relation.targetWorkName,
+            targetWorkId: resolvedWorkId(relation.targetWorkName),
+            requiredState: relation.requiredState ?? "complete",
+        }));
+        return relations.length === 0 ? work : { ...work, relations };
+    });
+    const normalizedRelations = submissionBatch.relations.map((relation) => ({
+        type: "DEPENDS_ON",
+        sourceWorkName: relation.sourceWorkName,
+        targetWorkName: relation.targetWorkName,
+        targetWorkId: resolvedWorkId(relation.targetWorkName),
+        requiredState: relation.requiredState ?? "complete",
+    }));
+    const sequence = state.counters.events;
+    const request = workRequestEvent(configuration, state, sequence, requestId, normalizedWorks, normalizedRelations);
+    const relationshipEvents = relationshipChangeEvents(state, sequence, requestId, workByName, normalizedRelations);
+    return {
+        works: normalizedWorks,
+        events: [request, ...relationshipEvents],
+    };
+}
+function logicalMoveCalculation(configuration, state, workstation, outcome, inputs, resources, logicalMoveId, sequence) {
+    const primary = inputs[0];
+    if (primary === undefined)
+        throw new Error("Logical move has no input Work.");
+    const routedWorks = routedWorksFor(configuration, state, {
+        dispatchId: logicalMoveId,
+        completionId: identity("completion", logicalMoveId),
+        transitionId: workstation.name,
+        workstation: workstation.name,
+        worker: "",
+        startedElapsedMs: state.virtualElapsedMs,
+        dueElapsedMs: state.virtualElapsedMs,
+        inputTokenIds: inputs.map(({ tokenId }) => tokenId),
+        resources,
+        outcome,
+    }, inputs);
+    return {
+        routedWorks,
+        event: {
+            schemaVersion: "agent-factory.event.v1",
+            id: identity("event", state.sessionId, sequence, "DISPATCH_RESPONSE", logicalMoveId),
+            type: "DISPATCH_RESPONSE",
+            context: eventContext(state, sequence, state.virtualTime, {
+                requestId: primary.requestId,
+                traceIds: inputs.map(({ traceId }) => traceId),
+                workIds: inputs.map(({ workId }) => workId),
+                currentChainingTraceId: primary.traceId,
+                previousChainingTraceIds: inputs.slice(1).map(({ traceId }) => traceId),
+            }),
+            payload: {
+                transitionId: workstation.name,
+                outcome: "ACCEPTED",
+                durationMillis: 0,
+                ...(routedWorks.length === 0
+                    ? {}
+                    : {
+                        outputWork: routedWorks.map((routed) => eventWorkFor(configuration, routed)),
+                    }),
+            },
+        },
+    };
+}
+function replaceInputPhases(replacements, state, indexes, phase) {
+    for (const index of indexes) {
+        const consumed = state.works[index];
+        if (consumed !== undefined)
+            replacements[index] = { ...consumed, phase };
+    }
+}
+function worksAtIndexes(works, indexes) {
+    return indexes.flatMap((index) => {
+        const work = works[index];
+        return work === undefined ? [] : [work];
+    });
+}
+function workerDispatchRequestEvent(state, inputs, transitionId, dispatchId, resources, sequence) {
+    const primary = inputs[0];
+    if (primary === undefined)
+        throw new Error("Worker dispatch has no input Work.");
+    return {
+        schemaVersion: "agent-factory.event.v1",
+        id: identity("event", state.sessionId, sequence, "DISPATCH_REQUEST", dispatchId),
+        type: "DISPATCH_REQUEST",
+        context: eventContext(state, sequence, state.virtualTime, {
+            dispatchId,
+            requestId: primary.requestId,
+            traceIds: inputs.map(({ traceId }) => traceId),
+            workIds: inputs.map(({ workId }) => workId),
+            currentChainingTraceId: primary.traceId,
+            previousChainingTraceIds: inputs.slice(1).map(({ traceId }) => traceId),
+        }),
+        payload: {
+            transitionId,
+            inputs: inputs.map(({ workId }) => ({ workId })),
+            ...(resources.length === 0 ? {} : { resources: [...resources] }),
+        },
+    };
+}
+function validateSubmissions(configuration, state, value) {
+    const batch = isSubmissionArray(value)
+        ? { works: value }
+        : "works" in value
+            ? value
+            : { works: [value] };
+    const scenarioSubmissions = isSubmissionArray(value) || !("works" in value) ? batch.works : batch;
+    const parsed = safeParseFactoryEmulatorScenario({ ...configuration.scenario, initialSubmissions: scenarioSubmissions }, configuration.factory);
+    const issues = parsed.success
+        ? []
+        : parsed.issues.map((issue) => ({
+            ...issue,
+            path: ["submissions", ...issue.path.slice(1)],
+        }));
+    const known = new Set(state.works.map(({ submissionId }) => submissionId));
+    batch.works.forEach((submission, index) => {
+        if (known.has(submission?.name)) {
+            issues.push({
+                category: "semantic",
+                code: "duplicate_identity",
+                path: ["submissions", index, "name"],
+                message: `Work identity ${submission.name} already exists in this session.`,
+            });
+        }
+    });
+    if (issues.length > 0)
+        throw new FactoryEmulatorSubmissionError(issues);
+    return clone({ works: batch.works, relations: batch.relations ?? [] });
+}
+function rejectionMessage(rejection) {
+    if (rejection instanceof Error)
+        return String(rejection.message);
+    try {
+        return String(rejection);
+    }
+    catch {
+        return "Sink rejected with an unprintable value.";
+    }
+}
+function budgetUsage(state, limits) {
+    return {
+        completedDispatches: {
+            used: state.counters.completedDispatches,
+            limit: limits.maxCompletedDispatches,
+        },
+        events: { used: state.counters.events, limit: limits.maxEvents },
+        virtualElapsedMs: {
+            used: state.virtualElapsedMs,
+            limit: limits.maxVirtualElapsedMs,
+        },
+    };
+}
+function unfinished(state) {
+    return state.works.some(({ phase }) => phase !== "completed");
+}
+/** Creates one validated, caller-owned deterministic Factory emulator session. */
+// biome-ignore lint/complexity/noExcessiveLinesPerFunction: Command closures intentionally share one explicit session state owner.
+export function createFactoryEmulatorSession(options) {
+    const configuration = validateConfiguration(options);
+    const sessionId = sessionIdentity(configuration.factory, configuration.scenario);
+    let committedState = clone(PRE_START_STATE);
+    let pendingTransaction;
+    let pendingAdvanceContext;
+    let commandInFlight;
+    let lastError;
+    const pauseExecution = (command, diagnostic) => {
+        lastError = {
+            code: "execution_paused",
+            operation: "execute",
+            command,
+            message: `Factory emulator execution paused: ${diagnostic.kind}.`,
+            diagnostic: clone(diagnostic),
+        };
+        throw new FactoryEmulatorExecutionPausedError(diagnostic);
+    };
+    const assertCandidateWithinBudgets = (command, candidate) => {
+        const checks = [
+            {
+                limit: "completedDispatches",
+                configured: configuration.limits.maxCompletedDispatches,
+                observed: candidate.counters.completedDispatches,
+            },
+            {
+                limit: "events",
+                configured: configuration.limits.maxEvents,
+                observed: candidate.counters.events,
+            },
+            {
+                limit: "virtualElapsedMs",
+                configured: configuration.limits.maxVirtualElapsedMs,
+                observed: candidate.virtualElapsedMs,
+            },
+        ];
+        const exceeded = checks.find(({ configured, observed }) => observed > configured);
+        if (exceeded !== undefined) {
+            pauseExecution(command, {
+                kind: "budget-exceeded",
+                ...exceeded,
+                virtualTime: candidate.virtualTime,
+                virtualElapsedMs: candidate.virtualElapsedMs,
+            });
+        }
+    };
+    const assertWorkBound = (command, observed) => {
+        if (observed <= configuration.limits.maxSynchronousWorkItems)
+            return;
+        const state = committedState;
+        pauseExecution(command, {
+            kind: "bounded-work-exceeded",
+            limit: "synchronousWorkItems",
+            configured: configuration.limits.maxSynchronousWorkItems,
+            observed,
+            virtualTime: state.lifecycle === "pre-start"
+                ? configuration.scenario.startAt
+                : state.virtualTime,
+            virtualElapsedMs: state.virtualElapsedMs,
+        });
+    };
+    const status = () => {
+        const common = {
+            virtualTime: committedState.lifecycle !== "pre-start"
+                ? committedState.virtualTime
+                : configuration.scenario.startAt,
+            virtualElapsedMs: committedState.virtualElapsedMs,
+            budgetUsage: budgetUsage(committedState, configuration.limits),
+        };
+        if (lastError !== undefined) {
+            return clone({
+                ...common,
+                phase: "error",
+                reason: lastError.operation === "execute"
+                    ? "Execution paused at a configured safety boundary."
+                    : lastError.operation === "close"
+                        ? "The event sink rejected the pending close."
+                        : "The event sink rejected the pending transaction.",
+                ...(pendingTransaction === undefined
+                    ? {}
+                    : {
+                        pendingTransaction: {
+                            command: pendingTransaction.command,
+                            phase: pendingTransaction.phase,
+                            eventCount: pendingTransaction.batch.length,
+                        },
+                    }),
+                error: lastError,
+            });
+        }
+        if (commandInFlight !== undefined) {
+            return clone({
+                ...common,
+                phase: "active",
+                reason: `${commandInFlight} is awaiting the event sink.`,
+                ...(pendingTransaction === undefined
+                    ? {}
+                    : {
+                        pendingTransaction: {
+                            command: pendingTransaction.command,
+                            phase: pendingTransaction.phase,
+                            eventCount: pendingTransaction.batch.length,
+                        },
+                    }),
+            });
+        }
+        if (committedState.lifecycle === "pre-start") {
+            return clone({
+                ...common,
+                phase: "idle",
+                reason: "The session is ready to start.",
+            });
+        }
+        if (committedState.lifecycle === "closed") {
+            return clone({
+                ...common,
+                phase: "closed",
+                reason: "The session is closed.",
+            });
+        }
+        if (committedState.works.some(({ phase }) => phase === "active")) {
+            return clone({ ...common, phase: "active", reason: "Work is active." });
+        }
+        if (committedState.works.some(({ phase }) => phase === "ready")) {
+            return clone({
+                ...common,
+                phase: "ready",
+                reason: committedState.counters.commands === 1
+                    ? "Initial Work is ready for a later execution command."
+                    : "Work is ready.",
+            });
+        }
+        if (committedState.works.some(({ phase }) => phase === "waiting")) {
+            return clone({
+                ...common,
+                phase: "waiting",
+                reason: "Work is waiting for a supported outcome.",
+            });
+        }
+        return clone({
+            ...common,
+            phase: "idle",
+            reason: "The open session has no unfinished Work.",
+        });
+    };
+    const assertCommand = (command, retryKey) => {
+        if (commandInFlight !== undefined) {
+            throw new FactoryEmulatorPendingCommandError(command, commandInFlight);
+        }
+        if (pendingTransaction !== undefined) {
+            if (command === pendingTransaction.command &&
+                retryKey === pendingTransaction.retryKey) {
+                return pendingTransaction;
+            }
+            throw new FactoryEmulatorPendingCommandError(command, pendingTransaction.command);
+        }
+        if ((command === "start" && committedState.lifecycle !== "pre-start") ||
+            (command !== "start" && committedState.lifecycle !== "started")) {
+            throw new FactoryEmulatorLifecycleError(command, committedState.lifecycle);
+        }
+        return undefined;
+    };
+    const acceptPendingTransaction = async () => {
+        const transaction = pendingTransaction;
+        if (transaction === undefined)
+            return;
+        try {
+            if (transaction.phase === "sink-write") {
+                await configuration.sink.write(clone(transaction.batch));
+                if (transaction.command === "close") {
+                    transaction.phase = "sink-close";
+                }
+            }
+            if (transaction.phase === "sink-close") {
+                await configuration.sink.close?.();
+            }
+            committedState = transaction.candidate;
+            pendingTransaction = undefined;
+            lastError = undefined;
+        }
+        catch (rejection) {
+            lastError =
+                transaction.phase === "sink-close"
+                    ? {
+                        code: "sink_close_rejected",
+                        operation: "close",
+                        command: transaction.command,
+                        message: rejectionMessage(rejection),
+                    }
+                    : {
+                        code: "sink_write_rejected",
+                        operation: "write",
+                        command: transaction.command,
+                        message: rejectionMessage(rejection),
+                    };
+            throw rejection;
+        }
+    };
+    const write = async (command, retryKey, batch, candidate) => {
+        assertCandidateWithinBudgets(command, candidate);
+        pendingTransaction = {
+            command,
+            retryKey,
+            batch: clone(batch),
+            candidate: clone(candidate),
+            phase: "sink-write",
+        };
+        await acceptPendingTransaction();
+    };
+    const start = async () => {
+        const retryKey = "start";
+        const retry = assertCommand("start", retryKey);
+        commandInFlight = "start";
+        try {
+            if (retry !== undefined) {
+                await acceptPendingTransaction();
+                const candidate = retry.candidate;
+                const batches = [
+                    retry.batch.slice(0, 3),
+                    ...(retry.batch.length > 3 ? [retry.batch.slice(3)] : []),
+                ];
+                return clone({ status: "started", batches, state: candidate });
+            }
+            lastError = undefined;
+            const bootstrap = bootstrapEvents(configuration.factory, configuration.scenario, sessionId);
+            let candidate = {
+                lifecycle: "started",
+                sessionId,
+                virtualTime: configuration.scenario.startAt,
+                virtualElapsedMs: 0,
+                works: [],
+                ruleCursors: {},
+                counters: {
+                    commands: 1,
+                    events: bootstrap.length,
+                    completedDispatches: 0,
+                },
+            };
+            const batches = [bootstrap];
+            const initialValue = configuration.scenario.initialSubmissions ?? [];
+            const initial = isSubmissionArray(initialValue)
+                ? { works: initialValue, relations: [] }
+                : {
+                    works: initialValue.works,
+                    relations: initialValue.relations ?? [],
+                };
+            assertWorkBound("start", initial.works.length);
+            let combined = bootstrap;
+            if (initial.works.length > 0) {
+                const calculation = workRequestCalculation(configuration, { ...candidate, counters: { ...candidate.counters, commands: 0 } }, initial, "start");
+                const cascade = cascadeDependencyFailures(configuration, { ...candidate, works: calculation.works }, candidate.virtualTime, candidate.counters.events + calculation.events.length);
+                const submissionBatch = [...calculation.events, ...cascade.events];
+                batches.push(submissionBatch);
+                combined = [...bootstrap, ...submissionBatch];
+                candidate = {
+                    ...candidate,
+                    works: cascade.works,
+                    counters: { ...candidate.counters, events: combined.length },
+                };
+            }
+            await write("start", retryKey, combined, candidate);
+            return clone({ status: "started", batches, state: candidate });
+        }
+        finally {
+            commandInFlight = undefined;
+        }
+    };
+    const submit = async (value) => {
+        const retryKey = canonicalJson(Array.isArray(value) ? value : [value]);
+        const retry = assertCommand("submit", retryKey);
+        if (retry !== undefined) {
+            commandInFlight = "submit";
+            try {
+                await acceptPendingTransaction();
+                return clone({
+                    status: "submitted",
+                    batch: retry.batch,
+                    state: retry.candidate,
+                });
+            }
+            finally {
+                commandInFlight = undefined;
+            }
+        }
+        const state = committedState;
+        assertWorkBound("submit", isSubmissionArray(value)
+            ? value.length
+            : "works" in value
+                ? value.works.length
+                : 1);
+        const submissions = validateSubmissions(configuration, state, value);
+        commandInFlight = "submit";
+        lastError = undefined;
+        try {
+            const calculation = workRequestCalculation(configuration, state, submissions, "submit");
+            const cascade = cascadeDependencyFailures(configuration, { ...state, works: [...state.works, ...calculation.works] }, state.virtualTime, state.counters.events + calculation.events.length);
+            const batch = [...calculation.events, ...cascade.events];
+            const candidate = {
+                ...state,
+                works: cascade.works,
+                counters: {
+                    ...state.counters,
+                    commands: state.counters.commands + 1,
+                    events: state.counters.events + batch.length,
+                },
+            };
+            await write("submit", retryKey, batch, candidate);
+            return clone({ status: "submitted", batch, state: candidate });
+        }
+        finally {
+            commandInFlight = undefined;
+        }
+    };
+    const cascadeLogicalMoveFailures = (state, replacements, events) => {
+        const cascade = cascadeDependencyFailures(configuration, { ...state, works: replacements }, virtualTimeAt(configuration.scenario, state.virtualElapsedMs), state.counters.events + events.length);
+        replacements.splice(0, replacements.length, ...cascade.works);
+        events.push(...cascade.events);
+    };
+    const dispatchCalculation = (command, state) => {
+        const replacements = [...state.works];
+        const cursors = { ...state.ruleCursors };
+        const events = [];
+        const { candidates, executableWork } = schedulerCandidatesFor(configuration, state, cursors, (observed) => assertWorkBound(command, observed));
+        for (const { value, resources } of selectFactorySchedulerCandidates(candidates, undefined, availableResourcesFor(configuration, state))) {
+            const { indexes, execution, invocation, cursorKey } = value;
+            const works = worksAtIndexes(replacements, indexes);
+            const work = works[0];
+            if (work === undefined ||
+                works.length !== indexes.length ||
+                works.some(({ phase }) => phase !== "ready") ||
+                execution.workstation === undefined ||
+                execution.outcome === undefined)
+                continue;
+            if (cursorKey !== undefined)
+                cursors[cursorKey] = invocation + 1;
+            const logicalMove = execution.workstation.type === "LOGICAL_MOVE";
+            const transitionId = execution.workstation.name;
+            const dispatchId = identity(logicalMove ? "logical-move" : "dispatch", works.map(({ tokenId }) => tokenId), transitionId, invocation);
+            const completionId = identity("completion", dispatchId);
+            const dueElapsedMs = state.virtualElapsedMs + execution.outcome.durationMs;
+            const eventResources = eventResourcesFor(configuration, resources);
+            virtualTimeAt(configuration.scenario, dueElapsedMs);
+            if (logicalMove) {
+                const calculation = logicalMoveCalculation(configuration, state, execution.workstation, execution.outcome, works, resources, dispatchId, state.counters.events + events.length);
+                replaceInputPhases(replacements, state, indexes, "completed");
+                replacements.push(...calculation.routedWorks);
+                events.push(calculation.event);
+                cascadeLogicalMoveFailures(state, replacements, events);
+                continue;
+            }
+            replaceInputPhases(replacements, state, indexes, "active");
+            const primaryIndex = indexes[0];
+            if (primaryIndex === undefined)
+                continue;
+            replacements[primaryIndex] = {
+                ...work,
+                phase: "active",
+                dispatch: {
+                    dispatchId,
+                    completionId,
+                    transitionId,
+                    workstation: execution.workstation.name,
+                    worker: execution.workstation.worker,
+                    startedElapsedMs: state.virtualElapsedMs,
+                    dueElapsedMs,
+                    inputTokenIds: works.map(({ tokenId }) => tokenId),
+                    resources,
+                    outcome: execution.outcome,
+                },
+            };
+            const sequence = state.counters.events + events.length;
+            events.push(workerDispatchRequestEvent(state, works, transitionId, dispatchId, eventResources, sequence));
+        }
+        for (const [index, work] of state.works.entries()) {
+            if (work.phase === "ready" &&
+                replacements[index]?.phase === "ready" &&
+                !executableWork.has(index)) {
+                replacements[index] = { ...work, phase: "waiting" };
+            }
+        }
+        return {
+            batch: events,
+            state: {
+                ...state,
+                works: replacements,
+                ruleCursors: cursors,
+                counters: {
+                    ...state.counters,
+                    events: state.counters.events + events.length,
+                },
+            },
+        };
+    };
+    const completionCalculation = (state, dueElapsedMs) => {
+        const replacements = [...state.works];
+        const events = [];
+        const eventTime = virtualTimeAt(configuration.scenario, dueElapsedMs);
+        for (const work of state.works) {
+            if (work.phase !== "active" ||
+                work.dispatch?.dueElapsedMs !== dueElapsedMs)
+                continue;
+            const { dispatch } = work;
+            const inputs = dispatch.inputTokenIds.flatMap((tokenId) => {
+                const input = state.works.find((candidate) => candidate.tokenId === tokenId);
+                return input === undefined ? [] : [input];
+            });
+            if (inputs.length !== dispatch.inputTokenIds.length)
+                continue;
+            const routedWorks = routedWorksFor(configuration, state, dispatch, inputs);
+            const sequence = state.counters.events + events.length;
+            const outcome = {
+                accepted: "ACCEPTED",
+                continued: "CONTINUE",
+                rejected: "REJECTED",
+                failed: "FAILED",
+            };
+            events.push({
+                schemaVersion: "agent-factory.event.v1",
+                id: identity("event", state.sessionId, sequence, "DISPATCH_RESPONSE", dispatch.dispatchId),
+                type: "DISPATCH_RESPONSE",
+                context: eventContext(state, sequence, eventTime, {
+                    dispatchId: dispatch.dispatchId,
+                    requestId: work.requestId,
+                    traceIds: inputs.map(({ traceId }) => traceId),
+                    workIds: inputs.map(({ workId }) => workId),
+                    currentChainingTraceId: work.traceId,
+                    previousChainingTraceIds: inputs
+                        .slice(1)
+                        .map(({ traceId }) => traceId),
+                }),
+                payload: {
+                    completionId: dispatch.completionId,
+                    transitionId: dispatch.transitionId,
+                    outcome: outcome[dispatch.outcome.result],
+                    durationMillis: dispatch.dueElapsedMs - dispatch.startedElapsedMs,
+                    ...(dispatch.outcome.output === undefined
+                        ? {}
+                        : { output: dispatch.outcome.output }),
+                    ...(dispatch.outcome.feedback === undefined
+                        ? {}
+                        : { feedback: dispatch.outcome.feedback }),
+                    ...(dispatch.outcome.error === undefined
+                        ? {}
+                        : { error: dispatch.outcome.error }),
+                    ...(routedWorks.length === 0
+                        ? {}
+                        : {
+                            outputWork: routedWorks.map((routed) => eventWorkFor(configuration, routed)),
+                        }),
+                },
+            });
+            for (const input of inputs) {
+                const inputIndex = state.works.findIndex(({ tokenId }) => tokenId === input.tokenId);
+                if (inputIndex >= 0)
+                    replacements[inputIndex] = { ...input, phase: "completed" };
+            }
+            replacements.push(...routedWorks);
+        }
+        const completedDispatches = events.length;
+        const cascade = cascadeDependencyFailures(configuration, { ...state, works: replacements }, eventTime, state.counters.events + events.length);
+        events.push(...cascade.events);
+        return {
+            batch: events,
+            state: {
+                ...state,
+                virtualElapsedMs: dueElapsedMs,
+                virtualTime: eventTime,
+                works: cascade.works,
+                counters: {
+                    ...state.counters,
+                    events: state.counters.events + events.length,
+                    completedDispatches: state.counters.completedDispatches + completedDispatches,
+                },
+            },
+        };
+    };
+    // biome-ignore lint/complexity/noExcessiveLinesPerFunction: Advancement keeps retry, budget, yield, and transaction state in one traceable command boundary.
+    const runAdvance = async (command, requestedDuration) => {
+        if (requestedDuration !== undefined &&
+            (!Number.isSafeInteger(requestedDuration) || requestedDuration < 0)) {
+            throw new FactoryEmulatorDurationError(requestedDuration);
+        }
+        const retryKey = canonicalJson([command, requestedDuration]);
+        const retry = assertCommand(command, retryKey);
+        const original = committedState;
+        const target = retry === undefined
+            ? requestedDuration === undefined
+                ? undefined
+                : original.virtualElapsedMs + requestedDuration
+            : pendingAdvanceContext?.target;
+        if (retry === undefined && target !== undefined) {
+            virtualTimeAt(configuration.scenario, target);
+        }
+        const context = retry === undefined
+            ? {
+                command,
+                retryKey,
+                fromVirtualTime: original.virtualTime,
+                ...(target === undefined ? {} : { target }),
+                wasUnfinished: unfinished(original),
+                batches: [],
+                zeroDurationBatches: 0,
+            }
+            : pendingAdvanceContext;
+        if (context === undefined) {
+            throw new Error("Pending advancement context is unavailable.");
+        }
+        pendingAdvanceContext = context;
+        commandInFlight = command;
+        let synchronousBatches = 0;
+        const acceptSchedulerBatch = async (calculation) => {
+            const beforeElapsedMs = committedState.virtualElapsedMs;
+            const nextZeroDurationBatches = calculation.state.virtualElapsedMs === beforeElapsedMs
+                ? context.zeroDurationBatches + 1
+                : 0;
+            if (nextZeroDurationBatches > configuration.limits.maxZeroDurationBatches) {
+                pauseExecution(command, {
+                    kind: "zero-duration-cycle",
+                    limit: "zeroDurationBatches",
+                    configured: configuration.limits.maxZeroDurationBatches,
+                    observed: nextZeroDurationBatches,
+                    virtualTime: committedState.virtualTime,
+                    virtualElapsedMs: beforeElapsedMs,
+                });
+            }
+            assertWorkBound(command, calculation.batch.length);
+            context.batches.push(calculation.batch);
+            await write(command, retryKey, calculation.batch, calculation.state);
+            context.zeroDurationBatches = nextZeroDurationBatches;
+            synchronousBatches += 1;
+            if (configuration.yieldControl !== undefined &&
+                synchronousBatches >= configuration.limits.maxSynchronousBatches) {
+                synchronousBatches = 0;
+                await configuration.yieldControl();
+            }
+        };
+        try {
+            if (retry !== undefined) {
+                const beforeElapsedMs = original.virtualElapsedMs;
+                await acceptPendingTransaction();
+                context.zeroDurationBatches =
+                    committedState.virtualElapsedMs === beforeElapsedMs
+                        ? context.zeroDurationBatches + 1
+                        : 0;
+                synchronousBatches = 1;
+                if (configuration.yieldControl !== undefined &&
+                    synchronousBatches >= configuration.limits.maxSynchronousBatches) {
+                    synchronousBatches = 0;
+                    await configuration.yieldControl();
+                }
+            }
+            else
+                lastError = undefined;
+            const continueAdvancing = !(retry !== undefined && command === "advanceToNext");
+            while (continueAdvancing) {
+                const state = committedState;
+                if (state.works.some(({ phase }) => phase === "ready")) {
+                    const calculation = dispatchCalculation(command, state);
+                    if (calculation.batch.length > 0) {
+                        await acceptSchedulerBatch(calculation);
+                        if (command === "advanceToNext")
+                            break;
+                        continue;
+                    }
+                    committedState = calculation.state;
+                }
+                const activeDeadlines = committedState.works.flatMap((work) => work.phase === "active" && work.dispatch !== undefined
+                    ? [work.dispatch.dueElapsedMs]
+                    : []);
+                if (activeDeadlines.length === 0)
+                    break;
+                const earliest = Math.min(...activeDeadlines);
+                if (target !== undefined && earliest > target)
+                    break;
+                const calculation = completionCalculation(committedState, earliest);
+                await acceptSchedulerBatch(calculation);
+                if (command === "advanceToNext")
+                    break;
+            }
+            let finalState = committedState;
+            if (target !== undefined &&
+                context.wasUnfinished &&
+                finalState.virtualElapsedMs < target) {
+                finalState = {
+                    ...finalState,
+                    virtualElapsedMs: target,
+                    virtualTime: virtualTimeAt(configuration.scenario, target),
+                };
+            }
+            const madeProgress = context.batches.length > 0 ||
+                finalState.virtualTime !== context.fromVirtualTime;
+            if (madeProgress) {
+                finalState = {
+                    ...finalState,
+                    counters: {
+                        ...finalState.counters,
+                        commands: finalState.counters.commands + 1,
+                    },
+                };
+                assertCandidateWithinBudgets(command, finalState);
+                committedState = finalState;
+            }
+            const receipt = clone({
+                status: madeProgress ? "advanced" : "idle",
+                command,
+                fromVirtualTime: context.fromVirtualTime,
+                virtualTime: finalState.virtualTime,
+                virtualElapsedMs: finalState.virtualElapsedMs,
+                batches: context.batches,
+                state: finalState,
+            });
+            pendingAdvanceContext = undefined;
+            return receipt;
+        }
+        finally {
+            commandInFlight = undefined;
+        }
+    };
+    const close = async () => {
+        const retryKey = "close";
+        const retry = assertCommand("close", retryKey);
+        commandInFlight = "close";
+        try {
+            if (retry !== undefined) {
+                await acceptPendingTransaction();
+                return clone({
+                    status: "closed",
+                    batch: retry.batch,
+                    state: retry.candidate,
+                });
+            }
+            lastError = undefined;
+            const state = committedState;
+            const sequence = state.counters.events;
+            const event = {
+                schemaVersion: "agent-factory.event.v1",
+                id: identity("event", state.sessionId, sequence, "SESSION_COMPLETED"),
+                type: "SESSION_COMPLETED",
+                context: eventContext(state, sequence, state.virtualTime),
+                payload: {
+                    finalStatus: "TERMINATED",
+                    completedAt: state.virtualTime,
+                    durationMillis: state.virtualElapsedMs,
+                },
+            };
+            const candidate = {
+                ...state,
+                lifecycle: "closed",
+                counters: {
+                    ...state.counters,
+                    commands: state.counters.commands + 1,
+                    events: state.counters.events + 1,
+                },
+            };
+            const batch = [event];
+            await write("close", retryKey, batch, candidate);
+            return clone({ status: "closed", batch, state: candidate });
+        }
+        finally {
+            commandInFlight = undefined;
+        }
+    };
+    const reset = () => {
+        if (commandInFlight !== undefined) {
+            throw new FactoryEmulatorPendingCommandError("reset", commandInFlight);
+        }
+        if (committedState.lifecycle === "closed") {
+            throw new FactoryEmulatorLifecycleError("reset", "closed");
+        }
+        pendingTransaction = undefined;
+        pendingAdvanceContext = undefined;
+        lastError = undefined;
+        committedState = clone(PRE_START_STATE);
+        return clone({ status: "reset", state: committedState });
+    };
+    return {
+        start,
+        submit,
+        advanceBy: (durationMs) => runAdvance("advanceBy", durationMs),
+        advanceToNext: () => runAdvance("advanceToNext"),
+        close,
+        reset,
+        state: () => clone(committedState),
+        status,
+    };
+}