@unrulysystems/native-motion-core 0.1.0-alpha.0

package/dist/external-animation-ledger.cjs

@@ -0,0 +1,1250 @@
+"use strict";
+// Private, host-free external-animation and target-batch ledger seam (REQ-VALUE-015). The state
+// shapes are serializable and deterministic so the eventual driver implementation and CORE tests
+// share one lifecycle vocabulary. `advance` applies one event immutably and returns the ordered
+// effects the host must perform; malformed, conflicting, or out-of-sequence input fails closed
+// with `ExternalAnimationLedgerInvariantError` and leaves the retained state untouched.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalAnimationLedgerInvariantError = exports.EXTERNAL_ANIMATION_LEDGER_INVARIANT = exports.ExternalAnimationLedgerUnimplementedError = exports.EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED = void 0;
+exports.initialExternalAnimationLedgerState = initialExternalAnimationLedgerState;
+exports.createExternalAnimationLedger = createExternalAnimationLedger;
+exports.EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED = 'NATIVE_MOTION_CORE_EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED';
+class ExternalAnimationLedgerUnimplementedError extends Error {
+    code = exports.EXTERNAL_ANIMATION_LEDGER_UNIMPLEMENTED;
+    operation;
+    constructor(operation) {
+        super(`native-motion-core: external-animation ledger operation '${operation}' is unimplemented ` +
+            '(REQ-VALUE-015)');
+        this.name = 'ExternalAnimationLedgerUnimplementedError';
+        this.operation = operation;
+    }
+}
+exports.ExternalAnimationLedgerUnimplementedError = ExternalAnimationLedgerUnimplementedError;
+exports.EXTERNAL_ANIMATION_LEDGER_INVARIANT = 'NATIVE_MOTION_CORE_EXTERNAL_ANIMATION_LEDGER_INVARIANT';
+/** Typed fail-closed refusal for malformed, conflicting, or out-of-sequence ledger input. */
+class ExternalAnimationLedgerInvariantError extends Error {
+    code = exports.EXTERNAL_ANIMATION_LEDGER_INVARIANT;
+    invariant;
+    constructor(invariant) {
+        super(`native-motion-core: external-animation ledger invariant '${invariant}' was violated ` +
+            '(REQ-VALUE-015)');
+        this.name = 'ExternalAnimationLedgerInvariantError';
+        this.invariant = invariant;
+    }
+}
+exports.ExternalAnimationLedgerInvariantError = ExternalAnimationLedgerInvariantError;
+function initialExternalAnimationLedgerState() {
+    return {
+        identityAuthorities: [],
+        targetBatchAuthority: {
+            targetBatchActivities: [],
+            nextAggregateReactionSequence: 1,
+        },
+    };
+}
+function executionCountsAsActive(_execution) {
+    return true;
+}
+function completionIsArmed(execution) {
+    switch (execution.kind) {
+        case 'completion-armed-running':
+        case 'completion-armed-physical-resolved':
+        case 'completion-dispatching':
+        case 'awaiting-completion-authoritative-acknowledgement':
+            return true;
+        case 'running-unarmed':
+        case 'awaiting-cancellation-authoritative-acknowledgement':
+            return false;
+        default: {
+            const exhaustive = execution;
+            return exhaustive;
+        }
+    }
+}
+function targetBatchActivityIsOpen(activity) {
+    return activity.kind !== 'released';
+}
+function observeExternalAnimationIdentityAuthority(state) {
+    let externalActiveAnimationCount = 0;
+    let completionArmedExecutionCount = 0;
+    let awaitingAuthoritativeAcknowledgementCount = 0;
+    for (const execution of state.executions) {
+        if (executionCountsAsActive(execution))
+            externalActiveAnimationCount += 1;
+        if (completionIsArmed(execution))
+            completionArmedExecutionCount += 1;
+        if (execution.kind === 'awaiting-completion-authoritative-acknowledgement' ||
+            execution.kind === 'awaiting-cancellation-authoritative-acknowledgement') {
+            awaitingAuthoritativeAcknowledgementCount += 1;
+        }
+    }
+    return {
+        identityId: state.identityId,
+        publicControlSlotExecutionId: state.publicControlSlot.kind === 'empty' ? null : state.publicControlSlot.executionId,
+        retainedPhysicalExecutionCount: state.executions.length,
+        externalActiveAnimationCount,
+        completionArmedExecutionCount,
+        awaitingAuthoritativeAcknowledgementCount,
+        pendingFrameActivityCount: state.pendingFrameActivities.length,
+        identityTargetBatchDependencyEventOutboxCount: state.identityTargetBatchDependencyEventOutbox.length,
+        identityTargetBatchDependencyEventAcknowledgementWatermark: state.identityTargetBatchDependencyEventAcknowledgementWatermark,
+        authoritativeAcknowledgementWatermark: state.authoritativeAcknowledgementWatermark,
+    };
+}
+function observeExternalAnimationLedger(graph, state) {
+    const identityObservations = [];
+    let retainedPhysicalExecutionCount = 0;
+    let externalActiveAnimationCount = 0;
+    let completionArmedExecutionCount = 0;
+    let awaitingAuthoritativeAcknowledgementCount = 0;
+    let pendingFrameActivityCount = 0;
+    let identityTargetBatchDependencyEventOutboxCount = 0;
+    for (const identityAuthority of state.identityAuthorities) {
+        const observation = observeExternalAnimationIdentityAuthority(identityAuthority);
+        identityObservations.push(observation);
+        retainedPhysicalExecutionCount += observation.retainedPhysicalExecutionCount;
+        externalActiveAnimationCount += observation.externalActiveAnimationCount;
+        completionArmedExecutionCount += observation.completionArmedExecutionCount;
+        awaitingAuthoritativeAcknowledgementCount +=
+            observation.awaitingAuthoritativeAcknowledgementCount;
+        pendingFrameActivityCount += observation.pendingFrameActivityCount;
+        identityTargetBatchDependencyEventOutboxCount +=
+            observation.identityTargetBatchDependencyEventOutboxCount;
+    }
+    let openTargetBatchActivityCount = 0;
+    for (const activity of state.targetBatchAuthority.targetBatchActivities) {
+        if (targetBatchActivityIsOpen(activity))
+            openTargetBatchActivityCount += 1;
+    }
+    const combinedActiveAnimationCount = graph.activeAnimationCount() + externalActiveAnimationCount;
+    const isSettled = graph.isSettled() &&
+        externalActiveAnimationCount === 0 &&
+        identityTargetBatchDependencyEventOutboxCount === 0 &&
+        openTargetBatchActivityCount === 0 &&
+        pendingFrameActivityCount === 0;
+    return {
+        identityObservations,
+        retainedPhysicalExecutionCount,
+        externalActiveAnimationCount,
+        completionArmedExecutionCount,
+        awaitingAuthoritativeAcknowledgementCount,
+        openTargetBatchActivityCount,
+        pendingFrameActivityCount,
+        identityTargetBatchDependencyEventOutboxCount,
+        combinedActiveAnimationCount,
+        isSettled,
+    };
+}
+function observeIdentityOrThrow(state, identityId) {
+    for (const identityAuthority of state.identityAuthorities) {
+        if (identityAuthority.identityId === identityId) {
+            return observeExternalAnimationIdentityAuthority(identityAuthority);
+        }
+    }
+    throw new ExternalAnimationLedgerInvariantError('identity-not-retained');
+}
+function stepWithEffects(state, effects = []) {
+    return { state, effects };
+}
+function requireIdentityAuthority(state, identityId) {
+    for (let index = 0; index < state.identityAuthorities.length; index += 1) {
+        const authority = state.identityAuthorities[index];
+        if (authority !== undefined && authority.identityId === identityId) {
+            return { index, authority };
+        }
+    }
+    throw new ExternalAnimationLedgerInvariantError('identity-not-retained');
+}
+function replaceIdentityAuthority(state, index, authority) {
+    const identityAuthorities = [...state.identityAuthorities];
+    identityAuthorities[index] = authority;
+    return { ...state, identityAuthorities };
+}
+function requireExecution(authority, executionId) {
+    for (const execution of authority.executions) {
+        if (execution.executionId === executionId)
+            return execution;
+    }
+    throw new ExternalAnimationLedgerInvariantError('execution-not-retained');
+}
+function replaceExecution(authority, replacement) {
+    return {
+        ...authority,
+        executions: authority.executions.map((execution) => execution.executionId === replacement.executionId ? replacement : execution),
+    };
+}
+function requireTargetBatchActivity(state, batchId) {
+    const activities = state.targetBatchAuthority.targetBatchActivities;
+    for (let index = 0; index < activities.length; index += 1) {
+        const activity = activities[index];
+        if (activity !== undefined && activity.batchId === batchId)
+            return { index, activity };
+    }
+    throw new ExternalAnimationLedgerInvariantError('target-batch-not-retained');
+}
+function requireTargetBatchDependency(activity, dependencyId) {
+    for (let index = 0; index < activity.dependencies.length; index += 1) {
+        const dependency = activity.dependencies[index];
+        if (dependency !== undefined && dependency.dependencyId === dependencyId) {
+            return { index, dependency };
+        }
+    }
+    throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+}
+function replaceTargetBatchActivity(state, index, activity) {
+    const targetBatchActivities = [...state.targetBatchAuthority.targetBatchActivities];
+    targetBatchActivities[index] = activity;
+    return {
+        ...state,
+        targetBatchAuthority: { ...state.targetBatchAuthority, targetBatchActivities },
+    };
+}
+function replaceTargetBatchDependency(dependencies, index, replacement) {
+    const next = [...dependencies];
+    next[index] = replacement;
+    return next;
+}
+function dependencySourceEquals(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === 'public-identity' && right.kind === 'public-identity') {
+        return left.identityId === right.identityId && left.executionId === right.executionId;
+    }
+    if (left.kind === 'private-control' && right.kind === 'private-control') {
+        return left.controlId === right.controlId;
+    }
+    return false;
+}
+function targetBatchDependencyEventEquals(left, right) {
+    return (left.kind === right.kind &&
+        left.batchId === right.batchId &&
+        left.dependencyId === right.dependencyId &&
+        left.valueCompletionSequence === right.valueCompletionSequence &&
+        left.eventSequence === right.eventSequence &&
+        dependencySourceEquals(left.source, right.source));
+}
+function requireDependencyProvenance(dependency, event) {
+    if (!dependencySourceEquals(dependency.source, event.source)) {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-source-mismatch');
+    }
+    if (dependency.valueCompletionSequence !== event.valueCompletionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-value-completion-sequence-mismatch');
+    }
+}
+/** Exact replay of an event the dependency already recorded; anything else at a stale sequence conflicts. */
+function dependencyEventIsRecordedReplay(dependency, event) {
+    switch (event.kind) {
+        case 'raw-resolved':
+            return ((dependency.kind === 'waiting-value-acknowledgement' ||
+                dependency.kind === 'acknowledged') &&
+                dependency.rawResolvedEventSequence === event.eventSequence);
+        case 'value-acknowledged':
+            return (dependency.kind === 'acknowledged' &&
+                dependency.valueAcknowledgedEventSequence === event.eventSequence);
+        case 'permanently-unresolved':
+            return (dependency.kind === 'permanently-unresolved' &&
+                dependency.eventSequence === event.eventSequence);
+    }
+}
+/** One exact carrier acquisition against its identity-local sequence namespace. */
+function acquirePendingFrameActivity(state, identityId, carrierSequence) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, identityId);
+    for (const activity of authority.pendingFrameActivities) {
+        if (activity.carrierSequence === carrierSequence) {
+            throw new ExternalAnimationLedgerInvariantError('pending-frame-activity-already-retained');
+        }
+    }
+    for (const activity of authority.releasedPendingFrameActivities) {
+        if (activity.carrierSequence === carrierSequence) {
+            throw new ExternalAnimationLedgerInvariantError('pending-frame-activity-sequence-out-of-order');
+        }
+    }
+    const nextAuthority = {
+        ...authority,
+        pendingFrameActivities: [...authority.pendingFrameActivities, { carrierSequence }],
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), [
+        { kind: 'acquire-pending-frame-activity', identityId, carrierSequence },
+    ]);
+}
+function advanceRegisterExternalAnimationIdentity(state, event) {
+    for (const authority of state.identityAuthorities) {
+        if (authority.identityId === event.identityId) {
+            throw new ExternalAnimationLedgerInvariantError('identity-id-already-retained');
+        }
+    }
+    const authority = {
+        identityId: event.identityId,
+        publicControlSlot: { kind: 'empty' },
+        executions: [],
+        identityTargetBatchDependencyEventOutbox: [],
+        identityTargetBatchDependencyEventAcknowledgementWatermark: 0,
+        nextIdentityTargetBatchDependencyEventSequence: 1,
+        pendingFrameActivities: [],
+        releasedPendingFrameActivities: [],
+        authoritativeAcknowledgementWatermark: 0,
+        nextExecutionCreationSequence: 1,
+    };
+    return stepWithEffects({
+        ...state,
+        identityAuthorities: [...state.identityAuthorities, authority],
+    });
+}
+function identityAuthorityIsQuiescent(state, authority) {
+    if (authority.publicControlSlot.kind !== 'empty')
+        return false;
+    if (authority.executions.length > 0)
+        return false;
+    if (authority.identityTargetBatchDependencyEventOutbox.length > 0)
+        return false;
+    if (authority.pendingFrameActivities.length > 0)
+        return false;
+    for (const activity of state.targetBatchAuthority.targetBatchActivities) {
+        if (activity.kind === 'released')
+            continue;
+        for (const dependency of activity.dependencies) {
+            if (dependency.source.kind === 'public-identity' &&
+                dependency.source.identityId === authority.identityId) {
+                return false;
+            }
+        }
+        if ('authoredCarriers' in activity) {
+            for (const carrier of activity.authoredCarriers) {
+                if (carrier.identityId === authority.identityId)
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+function advanceRetireExternalAnimationIdentity(state, event) {
+    const { authority } = requireIdentityAuthority(state, event.identityId);
+    if (!identityAuthorityIsQuiescent(state, authority)) {
+        throw new ExternalAnimationLedgerInvariantError('identity-authority-not-quiescent');
+    }
+    return stepWithEffects({
+        ...state,
+        identityAuthorities: state.identityAuthorities.filter((candidate) => candidate.identityId !== event.identityId),
+    });
+}
+function advanceInstallOrdinaryExecution(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    for (const execution of authority.executions) {
+        if (execution.executionId === event.executionId) {
+            throw new ExternalAnimationLedgerInvariantError('execution-id-already-retained');
+        }
+    }
+    if (event.creationSequence !== authority.nextExecutionCreationSequence) {
+        throw new ExternalAnimationLedgerInvariantError('execution-creation-sequence-mismatch');
+    }
+    const execution = {
+        kind: 'running-unarmed',
+        executionId: event.executionId,
+        controlId: event.controlId,
+        creationSequence: event.creationSequence,
+        directOperationEpoch: event.directOperationEpoch,
+        capturedTargetBatchDependencies: [],
+    };
+    const nextAuthority = {
+        ...authority,
+        publicControlSlot: {
+            kind: 'installed',
+            controlId: event.controlId,
+            executionId: event.executionId,
+        },
+        executions: [...authority.executions, execution],
+        nextExecutionCreationSequence: event.creationSequence + 1,
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority));
+}
+function advanceReplacePublicControlSlot(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.controlId !== event.controlId) {
+        throw new ExternalAnimationLedgerInvariantError('public-control-slot-reference-mismatch');
+    }
+    const nextAuthority = {
+        ...authority,
+        publicControlSlot: {
+            kind: 'installed',
+            controlId: event.controlId,
+            executionId: event.executionId,
+        },
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority));
+}
+function advanceCaptureExecutionTargetBatchDependency(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    for (const dependency of execution.capturedTargetBatchDependencies) {
+        if (dependency.batchId === event.batchId && dependency.dependencyId === event.dependencyId) {
+            throw new ExternalAnimationLedgerInvariantError('execution-target-batch-dependency-already-captured');
+        }
+    }
+    const nextExecution = {
+        ...execution,
+        capturedTargetBatchDependencies: [
+            ...execution.capturedTargetBatchDependencies,
+            {
+                batchId: event.batchId,
+                dependencyId: event.dependencyId,
+                valueCompletionSequence: event.valueCompletionSequence,
+            },
+        ],
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, replaceExecution(authority, nextExecution)));
+}
+function advanceArmCompletionBeforeFinalChange(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.kind !== 'running-unarmed') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    const nextExecution = {
+        kind: 'completion-armed-running',
+        executionId: execution.executionId,
+        controlId: execution.controlId,
+        creationSequence: execution.creationSequence,
+        directOperationEpoch: execution.directOperationEpoch,
+        capturedTargetBatchDependencies: execution.capturedTargetBatchDependencies,
+        completionSequence: event.completionSequence,
+        lifecycleEventSequence: event.lifecycleEventSequence,
+        cancellationCountAfterArm: 0,
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, replaceExecution(authority, nextExecution)));
+}
+function advanceCancelInstalledControl(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const slot = authority.publicControlSlot;
+    if (slot.kind !== 'installed') {
+        throw new ExternalAnimationLedgerInvariantError('public-control-slot-reference-mismatch');
+    }
+    const execution = authority.executions.find((candidate) => candidate.executionId === slot.executionId);
+    if (execution === undefined || execution.controlId !== slot.controlId) {
+        throw new ExternalAnimationLedgerInvariantError('public-control-slot-reference-mismatch');
+    }
+    const effects = [];
+    if (execution.kind === 'completion-armed-physical-resolved' ||
+        execution.kind === 'completion-dispatching') {
+        // A stop racing an already-armed completion cannot unresolve the physical control: the cancel
+        // is recorded against the armed execution and the token-blind continuation still completes.
+        effects.push({
+            kind: 'emit-animation-cancel-listeners',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+        });
+        effects.push({
+            kind: 'drain-reentrant-listener-commands',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+        });
+        effects.push({
+            kind: 'clear-public-control-slot-token-blind',
+            identityId: event.identityId,
+            causedByExecutionId: execution.executionId,
+        });
+        const nextExecution = {
+            ...execution,
+            cancellationCountAfterArm: execution.cancellationCountAfterArm + 1,
+        };
+        const nextAuthority = {
+            ...replaceExecution(authority, nextExecution),
+            publicControlSlot: { kind: 'empty' },
+        };
+        return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), effects);
+    }
+    if (execution.kind !== 'running-unarmed' && execution.kind !== 'completion-armed-running') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    effects.push({
+        kind: 'stop-physical-execution',
+        identityId: event.identityId,
+        executionId: execution.executionId,
+    });
+    effects.push({
+        kind: 'emit-animation-cancel-listeners',
+        identityId: event.identityId,
+        executionId: execution.executionId,
+    });
+    effects.push({
+        kind: 'drain-reentrant-listener-commands',
+        identityId: event.identityId,
+        executionId: execution.executionId,
+    });
+    effects.push({
+        kind: 'clear-public-control-slot-token-blind',
+        identityId: event.identityId,
+        causedByExecutionId: execution.executionId,
+    });
+    // A cancelled control never settles, so every captured dependency is permanently unresolved.
+    const outbox = [...authority.identityTargetBatchDependencyEventOutbox];
+    let nextEventSequence = authority.nextIdentityTargetBatchDependencyEventSequence;
+    for (const dependency of execution.capturedTargetBatchDependencies) {
+        const dependencyEvent = {
+            kind: 'permanently-unresolved',
+            batchId: dependency.batchId,
+            dependencyId: dependency.dependencyId,
+            source: {
+                kind: 'public-identity',
+                identityId: event.identityId,
+                executionId: execution.executionId,
+            },
+            valueCompletionSequence: dependency.valueCompletionSequence,
+            eventSequence: nextEventSequence,
+        };
+        nextEventSequence += 1;
+        outbox.push({ event: dependencyEvent });
+        effects.push({
+            kind: 'emit-target-batch-dependency-event',
+            identityId: event.identityId,
+            event: dependencyEvent,
+        });
+    }
+    const nextExecution = {
+        kind: 'awaiting-cancellation-authoritative-acknowledgement',
+        executionId: execution.executionId,
+        controlId: execution.controlId,
+        creationSequence: execution.creationSequence,
+        directOperationEpoch: execution.directOperationEpoch,
+        capturedTargetBatchDependencies: execution.capturedTargetBatchDependencies,
+        cancellationSequence: event.cancellationSequence,
+        rawControlPromise: 'permanently-pending',
+        publicControlSlotCleared: true,
+        authoritativeCancellationAcknowledged: false,
+    };
+    const nextAuthority = {
+        ...replaceExecution(authority, nextExecution),
+        publicControlSlot: { kind: 'empty' },
+        identityTargetBatchDependencyEventOutbox: outbox,
+        nextIdentityTargetBatchDependencyEventSequence: nextEventSequence,
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), effects);
+}
+/** The cancellation entry is retained until the authoritative ack and every caused outbox event. */
+function cancellationGateIsOpen(authority) {
+    return authority.identityTargetBatchDependencyEventOutbox.length === 0;
+}
+function advanceAcknowledgeCancellation(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.kind !== 'awaiting-cancellation-authoritative-acknowledgement') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    if (execution.cancellationSequence !== event.cancellationSequence) {
+        throw new ExternalAnimationLedgerInvariantError('cancellation-sequence-mismatch');
+    }
+    if (event.authoritativeAcknowledgementSequence <= authority.authoritativeAcknowledgementWatermark) {
+        throw new ExternalAnimationLedgerInvariantError('authoritative-acknowledgement-out-of-order');
+    }
+    const effects = [
+        {
+            kind: 'acknowledge-authoritative-cancellation',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+            acknowledgementSequence: event.authoritativeAcknowledgementSequence,
+        },
+    ];
+    let nextAuthority = {
+        ...authority,
+        authoritativeAcknowledgementWatermark: event.authoritativeAcknowledgementSequence,
+    };
+    if (cancellationGateIsOpen(nextAuthority)) {
+        nextAuthority = {
+            ...nextAuthority,
+            executions: nextAuthority.executions.filter((candidate) => candidate.executionId !== execution.executionId),
+        };
+        effects.push({
+            kind: 'release-external-animation-entry',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+        });
+    }
+    else {
+        nextAuthority = replaceExecution(nextAuthority, {
+            ...execution,
+            authoritativeCancellationAcknowledged: true,
+        });
+    }
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), effects);
+}
+function advanceResolveArmedPhysicalExecution(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.kind !== 'completion-armed-running') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    if (execution.completionSequence !== event.completionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('completion-sequence-mismatch');
+    }
+    const nextExecution = {
+        ...execution,
+        kind: 'completion-armed-physical-resolved',
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, replaceExecution(authority, nextExecution)));
+}
+function advanceDrainArmedCompletion(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.kind !== 'completion-armed-running' &&
+        execution.kind !== 'completion-armed-physical-resolved') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    if (execution.completionSequence !== event.completionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('completion-sequence-mismatch');
+    }
+    const nextExecution = {
+        ...execution,
+        kind: 'completion-dispatching',
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, replaceExecution(authority, nextExecution)), [
+        {
+            kind: 'emit-animation-complete-listeners',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+            completionSequence: execution.completionSequence,
+        },
+    ]);
+}
+function advanceFinishCompletionDispatch(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.kind !== 'completion-dispatching') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    if (execution.completionSequence !== event.completionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('completion-sequence-mismatch');
+    }
+    const nextExecution = {
+        kind: 'awaiting-completion-authoritative-acknowledgement',
+        executionId: execution.executionId,
+        controlId: execution.controlId,
+        creationSequence: execution.creationSequence,
+        directOperationEpoch: execution.directOperationEpoch,
+        capturedTargetBatchDependencies: execution.capturedTargetBatchDependencies,
+        completionSequence: execution.completionSequence,
+        lifecycleEventSequence: execution.lifecycleEventSequence,
+        publicStartPromiseResolved: true,
+    };
+    const nextAuthority = {
+        ...replaceExecution(authority, nextExecution),
+        publicControlSlot: { kind: 'empty' },
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), [
+        {
+            kind: 'drain-reentrant-listener-commands',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+        },
+        {
+            kind: 'clear-public-control-slot-token-blind',
+            identityId: event.identityId,
+            causedByExecutionId: execution.executionId,
+        },
+        {
+            kind: 'resolve-public-start-promise',
+            identityId: event.identityId,
+            executionId: execution.executionId,
+            completionSequence: execution.completionSequence,
+        },
+    ]);
+}
+function advanceAcknowledgeCompletion(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const execution = requireExecution(authority, event.executionId);
+    if (execution.kind !== 'awaiting-completion-authoritative-acknowledgement') {
+        throw new ExternalAnimationLedgerInvariantError('execution-state-mismatch');
+    }
+    if (execution.completionSequence !== event.completionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('completion-sequence-mismatch');
+    }
+    if (event.authoritativeAcknowledgementSequence <= authority.authoritativeAcknowledgementWatermark) {
+        throw new ExternalAnimationLedgerInvariantError('authoritative-acknowledgement-out-of-order');
+    }
+    const captured = execution.capturedTargetBatchDependencies;
+    const acknowledgements = event.targetBatchDependencyAcknowledgements;
+    if (acknowledgements.length !== captured.length) {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-reference-mismatch');
+    }
+    const effects = [];
+    const outbox = [...authority.identityTargetBatchDependencyEventOutbox];
+    let nextEventSequence = authority.nextIdentityTargetBatchDependencyEventSequence;
+    for (let index = 0; index < captured.length; index += 1) {
+        const reference = captured[index];
+        const acknowledgement = acknowledgements[index];
+        if (reference === undefined || acknowledgement === undefined) {
+            throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-reference-mismatch');
+        }
+        if (acknowledgement.batchId !== reference.batchId ||
+            acknowledgement.dependencyId !== reference.dependencyId ||
+            acknowledgement.valueCompletionSequence !== reference.valueCompletionSequence) {
+            throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-reference-mismatch');
+        }
+        if (acknowledgement.valueAcknowledgedEventSequence !== nextEventSequence) {
+            throw new ExternalAnimationLedgerInvariantError('identity-target-batch-dependency-event-acknowledgement-out-of-order');
+        }
+        const dependencyEvent = {
+            kind: 'value-acknowledged',
+            batchId: reference.batchId,
+            dependencyId: reference.dependencyId,
+            source: {
+                kind: 'public-identity',
+                identityId: event.identityId,
+                executionId: execution.executionId,
+            },
+            valueCompletionSequence: reference.valueCompletionSequence,
+            eventSequence: nextEventSequence,
+        };
+        nextEventSequence += 1;
+        outbox.push({ event: dependencyEvent });
+        effects.push({
+            kind: 'emit-target-batch-dependency-event',
+            identityId: event.identityId,
+            event: dependencyEvent,
+        });
+    }
+    effects.push({
+        kind: 'acknowledge-authoritative-completion',
+        identityId: event.identityId,
+        executionId: execution.executionId,
+        acknowledgementSequence: event.authoritativeAcknowledgementSequence,
+    });
+    effects.push({
+        kind: 'release-external-animation-entry',
+        identityId: event.identityId,
+        executionId: execution.executionId,
+    });
+    const nextAuthority = {
+        ...authority,
+        executions: authority.executions.filter((candidate) => candidate.executionId !== execution.executionId),
+        identityTargetBatchDependencyEventOutbox: outbox,
+        nextIdentityTargetBatchDependencyEventSequence: nextEventSequence,
+        authoritativeAcknowledgementWatermark: event.authoritativeAcknowledgementSequence,
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), effects);
+}
+function advanceOpenTargetBatchActivity(state, event) {
+    for (const activity of state.targetBatchAuthority.targetBatchActivities) {
+        if (activity.batchId === event.batchId) {
+            throw new ExternalAnimationLedgerInvariantError('target-batch-id-already-retained');
+        }
+    }
+    const activity = {
+        kind: 'capturing',
+        batchId: event.batchId,
+        dependencies: [],
+        aggregateReactionSequence: null,
+    };
+    return stepWithEffects({
+        ...state,
+        targetBatchAuthority: {
+            ...state.targetBatchAuthority,
+            targetBatchActivities: [...state.targetBatchAuthority.targetBatchActivities, activity],
+        },
+    });
+}
+function advanceAppendTargetBatchDependency(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.batchId);
+    if (activity.kind !== 'capturing') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+    }
+    for (const dependency of activity.dependencies) {
+        if (dependency.dependencyId === event.dependencyId) {
+            throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-id-already-retained');
+        }
+    }
+    const dependency = {
+        kind: 'waiting-raw',
+        dependencyId: event.dependencyId,
+        source: event.source,
+        valueCompletionSequence: event.valueCompletionSequence,
+        eventAckWatermark: 0,
+    };
+    const nextActivity = {
+        ...activity,
+        dependencies: [...activity.dependencies, dependency],
+    };
+    return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+}
+function advanceSealTargetBatchActivity(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.batchId);
+    if (activity.kind !== 'capturing') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-reaction-state-mismatch');
+    }
+    if (event.aggregateReactionSequence !== state.targetBatchAuthority.nextAggregateReactionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('aggregate-reaction-sequence-mismatch');
+    }
+    const targetBatchAuthority = {
+        ...state.targetBatchAuthority,
+        nextAggregateReactionSequence: event.aggregateReactionSequence + 1,
+    };
+    let nextState = { ...state, targetBatchAuthority };
+    const effects = [];
+    if (activity.dependencies.length === 0) {
+        // A zero-dependency seal is already resolved: every authored carrier is retained at seal,
+        // before the aggregate reaction registers.
+        for (const carrier of event.authoredCarriers) {
+            const acquisition = acquirePendingFrameActivity(nextState, carrier.identityId, carrier.carrierSequence);
+            nextState = acquisition.state;
+            effects.push(...acquisition.effects);
+        }
+    }
+    const sealedActivity = activity.dependencies.length === 0
+        ? {
+            kind: 'sealed-empty',
+            batchId: activity.batchId,
+            aggregateReactionSequence: event.aggregateReactionSequence,
+            dependencies: [],
+            authoredCarriers: event.authoredCarriers,
+            nextCarrierRetentionIndex: event.authoredCarriers.length,
+        }
+        : {
+            kind: 'waiting-dependencies',
+            batchId: activity.batchId,
+            aggregateReactionSequence: event.aggregateReactionSequence,
+            dependencies: activity.dependencies,
+            authoredCarriers: event.authoredCarriers,
+        };
+    nextState = replaceTargetBatchActivity(nextState, activityIndex, sealedActivity);
+    effects.push({
+        kind: 'register-target-batch-aggregate-reaction',
+        batchId: event.batchId,
+        aggregateReactionSequence: event.aggregateReactionSequence,
+    });
+    return stepWithEffects(nextState, effects);
+}
+function advanceReportTargetBatchDependencyEvent(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.event.batchId);
+    if (activity.kind !== 'waiting-dependencies' && activity.kind !== 'permanently-unrunnable') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+    }
+    const { index: dependencyIndex, dependency } = requireTargetBatchDependency(activity, event.event.dependencyId);
+    requireDependencyProvenance(dependency, event.event);
+    const watermark = dependency.kind === 'permanently-unresolved'
+        ? dependency.eventSequence
+        : dependency.eventAckWatermark;
+    if (event.event.eventSequence <= watermark) {
+        if (dependencyEventIsRecordedReplay(dependency, event.event))
+            return stepWithEffects(state);
+        throw new ExternalAnimationLedgerInvariantError('target-batch-event-sequence-replay-conflict');
+    }
+    switch (event.event.kind) {
+        case 'raw-resolved': {
+            if (dependency.kind !== 'waiting-raw') {
+                throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+            }
+            const nextDependency = {
+                kind: 'waiting-value-acknowledgement',
+                dependencyId: dependency.dependencyId,
+                source: dependency.source,
+                valueCompletionSequence: dependency.valueCompletionSequence,
+                rawResolvedEventSequence: event.event.eventSequence,
+                eventAckWatermark: dependency.eventAckWatermark,
+            };
+            const nextActivity = {
+                ...activity,
+                dependencies: replaceTargetBatchDependency(activity.dependencies, dependencyIndex, nextDependency),
+            };
+            return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+        }
+        case 'value-acknowledged': {
+            if (dependency.kind !== 'waiting-value-acknowledgement') {
+                throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+            }
+            const nextDependency = {
+                kind: 'acknowledged',
+                dependencyId: dependency.dependencyId,
+                source: dependency.source,
+                valueCompletionSequence: dependency.valueCompletionSequence,
+                rawResolvedEventSequence: dependency.rawResolvedEventSequence,
+                valueAcknowledgedEventSequence: event.event.eventSequence,
+                eventAckWatermark: dependency.eventAckWatermark,
+            };
+            const dependencies = replaceTargetBatchDependency(activity.dependencies, dependencyIndex, nextDependency);
+            const everyDependencyAcknowledged = dependencies.every((candidate) => candidate.kind === 'acknowledged');
+            const nextActivity = activity.kind === 'waiting-dependencies' && everyDependencyAcknowledged
+                ? {
+                    kind: 'ready-awaiting-carrier-retention',
+                    batchId: activity.batchId,
+                    aggregateReactionSequence: activity.aggregateReactionSequence,
+                    dependencies,
+                    authoredCarriers: activity.authoredCarriers,
+                    nextCarrierRetentionIndex: 0,
+                }
+                : { ...activity, dependencies };
+            return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+        }
+        case 'permanently-unresolved': {
+            if (dependency.kind !== 'waiting-raw' &&
+                dependency.kind !== 'waiting-value-acknowledgement') {
+                throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+            }
+            const nextDependency = {
+                kind: 'permanently-unresolved',
+                dependencyId: dependency.dependencyId,
+                source: dependency.source,
+                valueCompletionSequence: dependency.valueCompletionSequence,
+                eventSequence: event.event.eventSequence,
+                eventAcknowledged: false,
+            };
+            const dependencies = replaceTargetBatchDependency(activity.dependencies, dependencyIndex, nextDependency);
+            const everyOtherDependencyTerminal = dependencies.every((candidate, candidateIndex) => candidateIndex === dependencyIndex ||
+                candidate.kind === 'acknowledged' ||
+                candidate.kind === 'permanently-unresolved');
+            const nextActivity = {
+                kind: 'permanently-unrunnable',
+                batchId: activity.batchId,
+                aggregateReactionSequence: activity.aggregateReactionSequence,
+                dependencies,
+                authoredCarriers: activity.authoredCarriers,
+                everyOtherDependencyTerminal,
+                unacknowledgedEventCount: (activity.kind === 'permanently-unrunnable' ? activity.unacknowledgedEventCount : 0) + 1,
+            };
+            return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+        }
+    }
+}
+function advanceAcknowledgeTargetBatchDependencyEvent(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.event.batchId);
+    if (activity.kind === 'capturing' ||
+        activity.kind === 'released' ||
+        activity.kind === 'sealed-empty') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+    }
+    const { index: dependencyIndex, dependency } = requireTargetBatchDependency(activity, event.event.dependencyId);
+    requireDependencyProvenance(dependency, event.event);
+    let recordedEventSequence;
+    if (event.event.kind === 'raw-resolved' &&
+        (dependency.kind === 'waiting-value-acknowledgement' || dependency.kind === 'acknowledged')) {
+        recordedEventSequence = dependency.rawResolvedEventSequence;
+    }
+    else if (event.event.kind === 'value-acknowledged' && dependency.kind === 'acknowledged') {
+        recordedEventSequence = dependency.valueAcknowledgedEventSequence;
+    }
+    else if (event.event.kind === 'permanently-unresolved' &&
+        dependency.kind === 'permanently-unresolved') {
+        recordedEventSequence = dependency.eventSequence;
+    }
+    else {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+    }
+    if (event.event.eventSequence !== recordedEventSequence) {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-event-sequence-replay-conflict');
+    }
+    if (dependency.kind === 'permanently-unresolved') {
+        if (dependency.eventAcknowledged)
+            return stepWithEffects(state);
+        if (activity.kind !== 'permanently-unrunnable') {
+            throw new ExternalAnimationLedgerInvariantError('target-batch-dependency-state-mismatch');
+        }
+        const unacknowledgedEventCount = activity.unacknowledgedEventCount - 1;
+        const dependencies = replaceTargetBatchDependency(activity.dependencies, dependencyIndex, {
+            ...dependency,
+            eventAcknowledged: true,
+        });
+        if (unacknowledgedEventCount === 0 && activity.everyOtherDependencyTerminal) {
+            const released = {
+                kind: 'released',
+                batchId: activity.batchId,
+                terminal: 'permanently-unrunnable',
+            };
+            return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, released), [
+                {
+                    kind: 'release-target-batch-activity',
+                    batchId: activity.batchId,
+                    terminal: 'permanently-unrunnable',
+                },
+            ]);
+        }
+        const nextActivity = {
+            ...activity,
+            dependencies,
+            unacknowledgedEventCount,
+        };
+        return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+    }
+    if (event.event.eventSequence <= dependency.eventAckWatermark)
+        return stepWithEffects(state);
+    const nextDependency = {
+        ...dependency,
+        eventAckWatermark: event.event.eventSequence,
+    };
+    const nextActivity = {
+        ...activity,
+        dependencies: replaceTargetBatchDependency(activity.dependencies, dependencyIndex, nextDependency),
+    };
+    return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+}
+function advanceAcknowledgeIdentityTargetBatchDependencyEvent(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const head = authority.identityTargetBatchDependencyEventOutbox[0];
+    if (head === undefined) {
+        throw new ExternalAnimationLedgerInvariantError('identity-target-batch-dependency-event-not-retained');
+    }
+    if (!targetBatchDependencyEventEquals(head.event, event.event)) {
+        if (event.event.eventSequence <=
+            authority.identityTargetBatchDependencyEventAcknowledgementWatermark) {
+            throw new ExternalAnimationLedgerInvariantError('identity-target-batch-dependency-event-acknowledgement-out-of-order');
+        }
+        throw new ExternalAnimationLedgerInvariantError('identity-target-batch-dependency-event-not-retained');
+    }
+    const effects = [];
+    let nextAuthority = {
+        ...authority,
+        identityTargetBatchDependencyEventOutbox: authority.identityTargetBatchDependencyEventOutbox.slice(1),
+        identityTargetBatchDependencyEventAcknowledgementWatermark: event.event.eventSequence,
+    };
+    if (cancellationGateIsOpen(nextAuthority)) {
+        const retainedExecutions = [];
+        for (const execution of nextAuthority.executions) {
+            if (execution.kind === 'awaiting-cancellation-authoritative-acknowledgement' &&
+                execution.authoritativeCancellationAcknowledged) {
+                effects.push({
+                    kind: 'release-external-animation-entry',
+                    identityId: event.identityId,
+                    executionId: execution.executionId,
+                });
+            }
+            else {
+                retainedExecutions.push(execution);
+            }
+        }
+        if (retainedExecutions.length !== nextAuthority.executions.length) {
+            nextAuthority = { ...nextAuthority, executions: retainedExecutions };
+        }
+    }
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), effects);
+}
+function advanceTransferNextAuthoredCarrierRetention(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.batchId);
+    if (activity.kind !== 'ready-awaiting-carrier-retention') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-reaction-state-mismatch');
+    }
+    const carrier = activity.authoredCarriers[activity.nextCarrierRetentionIndex];
+    if (carrier === undefined ||
+        event.carrierIndex !== activity.nextCarrierRetentionIndex ||
+        carrier.identityId !== event.identityId ||
+        carrier.carrierSequence !== event.carrierSequence) {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-carrier-order-mismatch');
+    }
+    const acquisition = acquirePendingFrameActivity(state, event.identityId, event.carrierSequence);
+    const nextCarrierRetentionIndex = activity.nextCarrierRetentionIndex + 1;
+    const nextActivity = nextCarrierRetentionIndex === activity.authoredCarriers.length
+        ? {
+            kind: 'ready-awaiting-delivery',
+            batchId: activity.batchId,
+            aggregateReactionSequence: activity.aggregateReactionSequence,
+            dependencies: activity.dependencies,
+            authoredCarriers: activity.authoredCarriers,
+        }
+        : { ...activity, nextCarrierRetentionIndex };
+    return stepWithEffects(replaceTargetBatchActivity(acquisition.state, activityIndex, nextActivity), acquisition.effects);
+}
+/** Delivery once the aggregate reaction runs: the live owner observes element completion. */
+function deliverTargetBatchAggregate(state, activityIndex, batchId, ownerGenerationLive) {
+    const released = {
+        kind: 'released',
+        batchId,
+        terminal: 'delivered',
+    };
+    const effects = [];
+    if (ownerGenerationLive) {
+        effects.push({ kind: 'emit-target-owner-element-completion', batchId });
+    }
+    effects.push({ kind: 'release-target-batch-activity', batchId, terminal: 'delivered' });
+    return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, released), effects);
+}
+function advanceReactToTargetBatchAggregate(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.batchId);
+    if (activity.kind === 'ready-awaiting-carrier-retention') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-carrier-retention-incomplete');
+    }
+    if (activity.kind !== 'ready-awaiting-delivery' && activity.kind !== 'sealed-empty') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-reaction-state-mismatch');
+    }
+    if (activity.aggregateReactionSequence !== event.aggregateReactionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('aggregate-reaction-sequence-mismatch');
+    }
+    if (event.orchestrationPending) {
+        const nextActivity = {
+            kind: 'waiting-orchestration',
+            batchId: activity.batchId,
+            aggregateReactionSequence: activity.aggregateReactionSequence,
+            dependencies: activity.dependencies,
+            authoredCarriers: activity.authoredCarriers,
+        };
+        return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, nextActivity));
+    }
+    return deliverTargetBatchAggregate(state, activityIndex, event.batchId, event.ownerGenerationLive);
+}
+function advanceCompleteTargetBatchOrchestration(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.batchId);
+    if (activity.kind !== 'waiting-orchestration') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-reaction-state-mismatch');
+    }
+    if (activity.aggregateReactionSequence !== event.aggregateReactionSequence) {
+        throw new ExternalAnimationLedgerInvariantError('aggregate-reaction-sequence-mismatch');
+    }
+    return deliverTargetBatchAggregate(state, activityIndex, event.batchId, event.ownerGenerationLive);
+}
+function advanceReleaseTargetBatchActivity(state, event) {
+    const { index: activityIndex, activity } = requireTargetBatchActivity(state, event.batchId);
+    if (activity.kind !== 'ready-awaiting-delivery') {
+        throw new ExternalAnimationLedgerInvariantError('target-batch-release-before-terminal');
+    }
+    const released = {
+        kind: 'released',
+        batchId: activity.batchId,
+        terminal: event.terminal,
+    };
+    return stepWithEffects(replaceTargetBatchActivity(state, activityIndex, released), [
+        { kind: 'release-target-batch-activity', batchId: activity.batchId, terminal: event.terminal },
+    ]);
+}
+function advanceAcquirePendingFrameActivity(state, event) {
+    return acquirePendingFrameActivity(state, event.identityId, event.carrierSequence);
+}
+function advanceReleasePendingFrameActivity(state, event) {
+    const { index: authorityIndex, authority } = requireIdentityAuthority(state, event.identityId);
+    const head = authority.pendingFrameActivities[0];
+    if (head === undefined) {
+        throw new ExternalAnimationLedgerInvariantError('pending-frame-activity-not-retained');
+    }
+    if (head.carrierSequence !== event.carrierSequence) {
+        for (const activity of authority.pendingFrameActivities) {
+            if (activity.carrierSequence === event.carrierSequence) {
+                throw new ExternalAnimationLedgerInvariantError('pending-frame-activity-release-order-mismatch');
+            }
+        }
+        throw new ExternalAnimationLedgerInvariantError('pending-frame-activity-not-retained');
+    }
+    const nextAuthority = {
+        ...authority,
+        pendingFrameActivities: authority.pendingFrameActivities.slice(1),
+        releasedPendingFrameActivities: [
+            ...authority.releasedPendingFrameActivities,
+            { carrierSequence: event.carrierSequence },
+        ],
+    };
+    return stepWithEffects(replaceIdentityAuthority(state, authorityIndex, nextAuthority), [
+        {
+            kind: 'release-pending-frame-activity',
+            identityId: event.identityId,
+            carrierSequence: event.carrierSequence,
+        },
+    ]);
+}
+function advanceExternalAnimationLedger(state, event) {
+    switch (event.kind) {
+        case 'register-external-animation-identity':
+            return advanceRegisterExternalAnimationIdentity(state, event);
+        case 'retire-external-animation-identity':
+            return advanceRetireExternalAnimationIdentity(state, event);
+        case 'install-ordinary-execution':
+            return advanceInstallOrdinaryExecution(state, event);
+        case 'replace-public-control-slot':
+            return advanceReplacePublicControlSlot(state, event);
+        case 'capture-execution-target-batch-dependency':
+            return advanceCaptureExecutionTargetBatchDependency(state, event);
+        case 'arm-completion-before-final-change':
+            return advanceArmCompletionBeforeFinalChange(state, event);
+        case 'cancel-installed-control':
+            return advanceCancelInstalledControl(state, event);
+        case 'acknowledge-cancellation':
+            return advanceAcknowledgeCancellation(state, event);
+        case 'resolve-armed-physical-execution':
+            return advanceResolveArmedPhysicalExecution(state, event);
+        case 'drain-armed-completion':
+            return advanceDrainArmedCompletion(state, event);
+        case 'finish-completion-dispatch':
+            return advanceFinishCompletionDispatch(state, event);
+        case 'acknowledge-completion':
+            return advanceAcknowledgeCompletion(state, event);
+        case 'open-target-batch-activity':
+            return advanceOpenTargetBatchActivity(state, event);
+        case 'append-target-batch-dependency':
+            return advanceAppendTargetBatchDependency(state, event);
+        case 'seal-target-batch-activity':
+            return advanceSealTargetBatchActivity(state, event);
+        case 'report-target-batch-dependency-event':
+            return advanceReportTargetBatchDependencyEvent(state, event);
+        case 'acknowledge-target-batch-dependency-event':
+            return advanceAcknowledgeTargetBatchDependencyEvent(state, event);
+        case 'acknowledge-identity-target-batch-dependency-event':
+            return advanceAcknowledgeIdentityTargetBatchDependencyEvent(state, event);
+        case 'transfer-next-authored-carrier-retention':
+            return advanceTransferNextAuthoredCarrierRetention(state, event);
+        case 'react-to-target-batch-aggregate':
+            return advanceReactToTargetBatchAggregate(state, event);
+        case 'complete-target-batch-orchestration':
+            return advanceCompleteTargetBatchOrchestration(state, event);
+        case 'release-target-batch-activity':
+            return advanceReleaseTargetBatchActivity(state, event);
+        case 'acquire-pending-frame-activity':
+            return advanceAcquirePendingFrameActivity(state, event);
+        case 'release-pending-frame-activity':
+            return advanceReleasePendingFrameActivity(state, event);
+        default: {
+            // An untyped/JS caller can reach this with a kind outside the union: fail closed with the
+            // typed invariant (never return the event as a step — that would corrupt retained state).
+            throw new ExternalAnimationLedgerInvariantError('ledger-event-kind-unrecognized');
+        }
+    }
+}
+class ExternalAnimationLedgerImpl {
+    #graph;
+    #state;
+    /** Graph settle handles mirroring retained pending-frame carriers (REQ-SETTLE-001). */
+    #pendingFrameActivityHandles = new Map();
+    constructor(graph, state) {
+        this.#graph = graph;
+        this.#state = state;
+        this.#reconcilePendingFrameActivities();
+    }
+    observe() {
+        return observeExternalAnimationLedger(this.#graph, this.#state);
+    }
+    observeState() {
+        return this.#state;
+    }
+    observeIdentity(identityId) {
+        return observeIdentityOrThrow(this.#state, identityId);
+    }
+    advance(event) {
+        const step = advanceExternalAnimationLedger(this.#state, event);
+        this.#state = step.state;
+        this.#reconcilePendingFrameActivities();
+        return {
+            state: step.state,
+            observation: observeExternalAnimationLedger(this.#graph, step.state),
+            orderedEffects: step.effects,
+        };
+    }
+    /** Every retained carrier holds one open graph activity; released carriers release theirs. */
+    #reconcilePendingFrameActivities() {
+        for (const authority of this.#state.identityAuthorities) {
+            let handles = this.#pendingFrameActivityHandles.get(authority.identityId);
+            for (const activity of authority.pendingFrameActivities) {
+                if (handles?.has(activity.carrierSequence))
+                    continue;
+                if (handles === undefined) {
+                    handles = new Map();
+                    this.#pendingFrameActivityHandles.set(authority.identityId, handles);
+                }
+                handles.set(activity.carrierSequence, this.#graph.registerActivity());
+            }
+        }
+        for (const [identityId, handles] of this.#pendingFrameActivityHandles) {
+            const authority = this.#state.identityAuthorities.find((candidate) => candidate.identityId === identityId);
+            for (const [carrierSequence, handle] of handles) {
+                const retained = authority?.pendingFrameActivities.some((activity) => activity.carrierSequence === carrierSequence);
+                if (retained !== true) {
+                    handle.release();
+                    handles.delete(carrierSequence);
+                }
+            }
+        }
+    }
+}
+function createExternalAnimationLedger(options) {
+    return new ExternalAnimationLedgerImpl(options.graph, options.initialState ?? initialExternalAnimationLedgerState());
+}