@world-engines/tmw 0.1.0-alpha.0

package/dist/runtime.js

@@ -0,0 +1,1887 @@
+import { TMW_RUNTIME_GENERATION, TMW_SEMANTIC_CONFIDENCE_THRESHOLD_MILLIONTHS, } from "./runtime-contract.js";
+import { compareTmwValuesV1, readTmwSceneValueV1, resolveTmwValueGraphInputsV1, resolveTmwEffectValueArgumentsV1, tmwValueContextFromSavV1 } from "./value-graph.js";
+import { emptyTmwGameplayStateV1, persistentTmwGameplayStateV1, prepareTmwGameplayEffectsV1 } from "./gameplay-state.js";
+import { EventFabric, } from "./event-fabric.js";
+import { planEffectFlow, } from "./effect-flow.js";
+import { evaluateConditionGraph, } from "./condition-graph.js";
+import { requireTmwIdentifier, requireTmwSafeInteger, requireTmwSha256 } from "./runtime-trace.js";
+import { canonicalRuntimeSavPayload, encodeRuntimeSavSection, runtimeSavPayloadDigest, } from "./runtime-sav.js";
+import { activateTmwCandidate, } from "./activation.js";
+import { isTmwEventBroadcastSuspension, isTmwEventDefinitionActive, isTmwEventLifecycleCapability, reduceTmwEventLifecycle } from "./event-lifecycle.js";
+import { canonicalTmwJson, canonicalTmwJsonValue, tmwSha256Hex } from "./runtime-trace.js";
+import { crossingPolicyAllows, observeTmwEffectiveTime, tmwEffectiveTimeIsDue, } from "./time-domains.js";
+import { canonicalSchedulerCoordinates, TmwScheduler, } from "./scheduler.js";
+import { assertTemporalRewriteBinding, } from "./temporal-rewrite.js";
+import { replayTemporalRewriteIsolated, } from "./isolated-replay.js";
+import { canonicalTmwPendingSceneClockCrossingV1, consumeCommittedTmwSceneNotesV1, projectTmwSceneWorldTimeV1, reduceTmwSceneEffectsV1, setTmwSceneWorldTimeV1, } from "./scene-state.js";
+/** effect 链先消费依赖，再读取本次执行已写入的局部变量；stable_id 只用于同级稳定排序。 */
+function dependencyOrderedRuntimeNodes(plan) {
+    const byId = new Map(plan.nodes.map((node) => [node.stable_id, node]));
+    if (byId.size !== plan.nodes.length)
+        throw new Error("tmw_runtime_compiled_plan_dependencies_invalid");
+    const expectedDependencies = new Map(plan.nodes.map((node) => [node.stable_id, []]));
+    for (const edge of plan.edges) {
+        const dependencies = expectedDependencies.get(edge.to_stable_id);
+        if (!byId.has(edge.from_stable_id) || dependencies === undefined) {
+            throw new Error("tmw_runtime_compiled_plan_dependencies_invalid");
+        }
+        dependencies.push(edge.from_stable_id);
+    }
+    for (const node of plan.nodes) {
+        if (!Array.isArray(node.dependencies)
+            || node.dependencies.some((dependency) => typeof dependency !== "string" || !byId.has(dependency))) {
+            throw new Error("tmw_runtime_compiled_plan_dependencies_invalid");
+        }
+        const actual = [...node.dependencies].sort();
+        const expected = [...expectedDependencies.get(node.stable_id)].sort();
+        if (actual.length !== expected.length || actual.some((dependency, index) => dependency !== expected[index])) {
+            throw new Error("tmw_runtime_compiled_plan_dependencies_invalid");
+        }
+    }
+    const ordered = [];
+    const visited = new Set();
+    const active = new Set();
+    const visit = (id) => {
+        if (visited.has(id))
+            return;
+        if (active.has(id))
+            throw new Error("tmw_runtime_effect_cycle");
+        const node = byId.get(id);
+        if (!node)
+            throw new Error("tmw_runtime_compiled_plan_dependencies_invalid");
+        active.add(id);
+        for (const dependency of node.dependencies)
+            visit(dependency);
+        active.delete(id);
+        visited.add(id);
+        ordered.push(node);
+    };
+    for (const node of plan.nodes)
+        visit(node.stable_id);
+    return Object.freeze(ordered);
+}
+function record(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`tmw_runtime_${label}_object_required`);
+    }
+    return value;
+}
+function eventField(payload, path) {
+    let current = payload;
+    for (const part of path) {
+        if (typeof current !== "object" || current === null || Array.isArray(current))
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function comparePrimitive(actual, comparison, expected) {
+    if (actual === undefined)
+        return null;
+    if (comparison === "eq" || comparison === "neq") {
+        const equal = canonicalTmwJson(actual) === canonicalTmwJson(expected);
+        return comparison === "eq" ? equal : !equal;
+    }
+    if (comparison === "contains") {
+        if (typeof actual === "string" && typeof expected === "string")
+            return actual.includes(expected);
+        if (Array.isArray(actual)) {
+            return actual.some((entry) => canonicalTmwJson(entry) === canonicalTmwJson(expected));
+        }
+        return null;
+    }
+    if (typeof actual !== "number" || typeof expected !== "number")
+        return null;
+    if (comparison === "gt")
+        return actual > expected;
+    if (comparison === "gte")
+        return actual >= expected;
+    if (comparison === "lt")
+        return actual < expected;
+    return actual <= expected;
+}
+export function buildTmwConditionExpressionSnapshotV3(expression, eventPayload, prefix, positiveSemanticLatches = new Set(), valueContext = {}, valueGraph) {
+    const nodes = [];
+    const values = Object.create(null);
+    const semanticPredicates = [];
+    let sequence = 0;
+    const visit = (value) => {
+        const nodeId = `${prefix}:${sequence++}`;
+        if (value.op === "literal") {
+            const predicateKey = `${nodeId}:literal`;
+            values[predicateKey] = value.value ? "true" : "false";
+            nodes.push(Object.freeze({ nodeId, kind: "leaf", predicateKey }));
+        }
+        else if (value.op === "value_input" || value.op === "scene_field") {
+            const predicateKey = `${nodeId}:${value.op}`;
+            const resolved = value.op === "value_input" ? resolveTmwValueGraphInputsV1(valueGraph, prefix, valueContext)[value.port] : readTmwSceneValueV1(valueContext.scene, value.field);
+            const truth = resolved === undefined ? undefined : value.op === "value_input" ? resolved.value_type === "boolean" ? resolved.value : undefined : compareTmwValuesV1(resolved.value, value.value, value.comparison);
+            values[predicateKey] = truth === undefined ? "unknown" : truth ? "true" : "false";
+            nodes.push(Object.freeze({ nodeId, kind: "leaf", predicateKey }));
+        }
+        else if (value.op === "event_field") {
+            const predicateKey = `${nodeId}:event-field:${value.path.join(".")}`;
+            const comparison = comparePrimitive(eventField(eventPayload, value.path), value.comparison, value.value);
+            values[predicateKey] = comparison === null ? "unknown" : comparison ? "true" : "false";
+            nodes.push(Object.freeze({ nodeId, kind: "leaf", predicateKey }));
+        }
+        else if (value.op === "selector_exists") {
+            const predicateKey = `${nodeId}:selector`;
+            values[predicateKey] = "unknown";
+            nodes.push(Object.freeze({ nodeId, kind: "leaf", predicateKey }));
+        }
+        else if (value.op === "nl_condition") {
+            const predicateKey = `${nodeId}:nl:${value.stable_id}`;
+            const latched = positiveSemanticLatches.has(predicateKey);
+            values[predicateKey] = latched ? "true" : "unknown";
+            if (!latched)
+                semanticPredicates.push(Object.freeze({ predicateKey, condition: value }));
+            nodes.push(Object.freeze({ nodeId, kind: "leaf", predicateKey }));
+        }
+        else if (value.op === "not") {
+            nodes.push(Object.freeze({ nodeId, kind: "not", child: visit(value.value) }));
+        }
+        else {
+            nodes.push(Object.freeze({
+                nodeId,
+                kind: value.op,
+                children: Object.freeze(value.values.map(visit)),
+            }));
+        }
+        return nodeId;
+    };
+    const rootNodeId = visit(expression);
+    return Object.freeze({
+        graph: Object.freeze({ rootNodeId, nodes: Object.freeze(nodes) }),
+        values: Object.freeze(values),
+        semanticPredicates: Object.freeze(semanticPredicates),
+    });
+}
+const CONDITION_STATE_SCHEMA_V2 = "tmw3.condition-state.v2";
+function positiveSemanticLatchesFromState(conditionState) {
+    if (typeof conditionState !== "object" || conditionState === null || Array.isArray(conditionState)) {
+        return new Map();
+    }
+    const state = conditionState;
+    if (state.schema !== CONDITION_STATE_SCHEMA_V2) {
+        return new Map();
+    }
+    if (Object.keys(state).sort().join("\0")
+        !== ["evaluations", "positiveSemanticLatches", "schema"].sort().join("\0")
+        || !Array.isArray(state.positiveSemanticLatches)) {
+        throw new Error("tmw_condition_state_v2_invalid");
+    }
+    const latches = new Map();
+    for (const value of state.positiveSemanticLatches) {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error("tmw_positive_semantic_latch_invalid");
+        }
+        const latch = value;
+        if (Object.keys(latch).sort().join("\0")
+            !== ["evidenceSetDigest", "predicateKey", "sourceOperationId", "verdictDigest"].sort().join("\0")
+            || typeof latch.predicateKey !== "string"
+            || typeof latch.verdictDigest !== "string"
+            || typeof latch.evidenceSetDigest !== "string"
+            || typeof latch.sourceOperationId !== "string"
+            || latches.has(latch.predicateKey)) {
+            throw new Error("tmw_positive_semantic_latch_invalid");
+        }
+        const predicateKey = requireTmwIdentifier(latch.predicateKey, "semantic_latch_predicate");
+        latches.set(predicateKey, Object.freeze({
+            predicateKey,
+            verdictDigest: requireTmwSha256(latch.verdictDigest, "semantic_latch_verdict"),
+            evidenceSetDigest: requireTmwSha256(latch.evidenceSetDigest, "semantic_latch_evidence"),
+            sourceOperationId: requireTmwIdentifier(latch.sourceOperationId, "semantic_latch_operation"),
+        }));
+    }
+    return latches;
+}
+function appendPositiveSemanticLatches(target, receipt, values) {
+    if (receipt === null)
+        return;
+    for (const verdict of receipt.verdicts ?? []) {
+        if (values[verdict.predicateKey] !== "true")
+            continue;
+        target.set(verdict.predicateKey, Object.freeze({
+            predicateKey: verdict.predicateKey,
+            verdictDigest: receipt.verdictDigest,
+            evidenceSetDigest: verdict.evidenceSetDigest,
+            sourceOperationId: verdict.sourceOperationId,
+        }));
+    }
+}
+function materializeConditionState(latches, evaluations) {
+    return canonicalTmwJsonValue({
+        schema: CONDITION_STATE_SCHEMA_V2,
+        positiveSemanticLatches: Object.freeze([...latches.values()]
+            .sort((left, right) => left.predicateKey.localeCompare(right.predicateKey))),
+        evaluations,
+    }, "runtime_condition_state");
+}
+export function resolveTmwSemanticPredicateValues(predicates, receipt) {
+    const expected = new Map(predicates.map((predicate) => [predicate.predicateKey, predicate]));
+    const values = Object.create(null);
+    const seen = new Set();
+    for (const verdict of receipt.verdicts ?? []) {
+        const predicate = expected.get(verdict.predicateKey);
+        if (predicate === undefined || seen.has(verdict.predicateKey)) {
+            throw new Error("tmw_semantic_predicate_binding_mismatch");
+        }
+        seen.add(verdict.predicateKey);
+        if (verdict.sourceOperationId !== predicate.evidenceIdentity.sourceOperationId
+            || verdict.evidenceSetDigest !== receipt.evidenceSetDigest) {
+            throw new Error("tmw_semantic_evidence_binding_mismatch");
+        }
+        if (!Number.isSafeInteger(verdict.confidenceMillionths)
+            || verdict.confidenceMillionths < 0
+            || verdict.confidenceMillionths > 1_000_000) {
+            throw new Error("tmw_semantic_confidence_invalid");
+        }
+        if (verdict.truth !== "true" && verdict.truth !== "false" && verdict.truth !== "unknown") {
+            throw new Error("tmw_semantic_truth_invalid");
+        }
+        values[verdict.predicateKey] = verdict.confidenceMillionths >= TMW_SEMANTIC_CONFIDENCE_THRESHOLD_MILLIONTHS
+            ? verdict.truth
+            : "unknown";
+    }
+    for (const predicate of predicates) {
+        if (!seen.has(predicate.predicateKey))
+            values[predicate.predicateKey] = "unknown";
+    }
+    return Object.freeze(values);
+}
+function eventSchedulerCoordinates(coordinates) {
+    return canonicalSchedulerCoordinates(Object.freeze({
+        logicalSeq: coordinates.logicalSeq,
+        worldTime: coordinates.worldTime,
+        presentation: coordinates.presentation,
+        realTime: coordinates.realTime === null
+            ? Object.freeze({})
+            : Object.freeze({ [coordinates.realTime.clock]: coordinates.realTime.value }),
+    }));
+}
+function canonicalEventCoordinates(coordinates) {
+    const canonical = eventSchedulerCoordinates(coordinates);
+    return Object.freeze({
+        logicalSeq: canonical.logicalSeq,
+        worldTime: canonical.worldTime,
+        presentation: canonical.presentation,
+        realTime: coordinates.realTime === null
+            ? null
+            : Object.freeze({
+                clock: coordinates.realTime.clock,
+                value: canonical.realTime[coordinates.realTime.clock],
+            }),
+    });
+}
+function schedulerObservedCoordinate(coordinates, effectiveTime) {
+    if (coordinates === null || coordinates === undefined)
+        return null;
+    if (effectiveTime.domain === "logical_seq")
+        return coordinates.logicalSeq;
+    if (effectiveTime.domain === "world_time")
+        return coordinates.worldTime;
+    if (effectiveTime.domain === "presentation_seq")
+        return coordinates.presentation?.eventSeq ?? null;
+    const clock = effectiveTime.real_time_clock;
+    return clock === null ? null : coordinates.realTime[clock] ?? null;
+}
+function observedCoordinate(coordinates, effectiveTime) {
+    if (effectiveTime.domain === "logical_seq")
+        return coordinates.logicalSeq;
+    if (effectiveTime.domain === "world_time")
+        return coordinates.worldTime;
+    if (effectiveTime.domain === "presentation_seq")
+        return coordinates.presentation?.eventSeq ?? null;
+    return coordinates.realTime?.clock === effectiveTime.real_time_clock
+        ? coordinates.realTime.value
+        : null;
+}
+function dueForEvent(event, node) {
+    const observed = observedCoordinate(event.coordinates, node.effective_time);
+    if (observed === null)
+        return false;
+    return tmwEffectiveTimeIsDue(node.effective_time, observed, event.crossingDirection);
+}
+function downstreamNodeIds(plan, roots) {
+    const reachable = new Set(roots);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const edge of plan.edges) {
+            if (!reachable.has(edge.from_stable_id) || reachable.has(edge.to_stable_id))
+                continue;
+            reachable.add(edge.to_stable_id);
+            changed = true;
+        }
+    }
+    return reachable;
+}
+function combineTruth(values) {
+    if (values.includes("false"))
+        return "false";
+    return values.includes("unknown") ? "unknown" : "true";
+}
+function eventLedger(base, snapshot, rewriteEvent, eventId, schedulerDueReceipts = Object.freeze([])) {
+    const existing = record(base.eventLedger, "event_ledger");
+    const events = Array.isArray(existing.events) ? existing.events : [];
+    const rewriteEvents = Array.isArray(existing.rewriteEvents) ? existing.rewriteEvents : [];
+    const temporalBlockedEventIds = Array.isArray(existing.temporalBlockedEventIds)
+        ? existing.temporalBlockedEventIds
+        : [];
+    const priorSchedulerDueReceipts = Array.isArray(existing.schedulerDueReceipts)
+        ? existing.schedulerDueReceipts
+        : [];
+    return canonicalTmwJsonValue({
+        ...existing,
+        events: [...events, ...snapshot.events],
+        rewriteEvents: rewriteEvent === null ? rewriteEvents : [...rewriteEvents, rewriteEvent],
+        temporalBlockedEventIds: rewriteEvent === null
+            ? [...temporalBlockedEventIds, eventId]
+            : temporalBlockedEventIds,
+        schedulerDueReceipts: [...priorSchedulerDueReceipts, ...schedulerDueReceipts],
+    }, "runtime_event_ledger");
+}
+function verifiedAuthorViewEvent(base, binding, event, pending) {
+    const projection = pending?.authorViewProjection;
+    if (projection === undefined)
+        return Object.freeze([]);
+    if (projection.saveId !== event.scope.saveId || projection.artifactDigest !== binding.artifactDigest) {
+        throw new Error("tmw_runtime_author_view_projection_binding_mismatch");
+    }
+    const causationId = record(event.payload, "event_payload").causationId;
+    if (causationId !== projection.sourceEventId)
+        throw new Error("tmw_runtime_author_view_projection_source_mismatch");
+    const ledger = record(base.eventLedger, "event_ledger");
+    if (!Array.isArray(ledger.events))
+        throw new Error("tmw_runtime_author_view_projection_source_missing");
+    const source = ledger.events.filter((candidate) => {
+        if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate))
+            return false;
+        const sourceEvent = candidate;
+        if (sourceEvent.eventId !== projection.sourceEventId
+            || sourceEvent.artifactDigest !== projection.artifactDigest
+            || sourceEvent.commitReceiptDigest !== projection.sourceCommitReceiptDigest)
+            return false;
+        const scope = sourceEvent.scope;
+        return typeof scope === "object" && scope !== null && !Array.isArray(scope)
+            && scope.saveId === projection.saveId;
+    });
+    if (source.length !== 1)
+        throw new Error("tmw_runtime_author_view_projection_source_missing");
+    return Object.freeze([Object.freeze({
+            eventId: event.eventId,
+            eventType: event.eventType,
+            viewVisiblePayload: projection.viewVisiblePayload,
+        })]);
+}
+function writerTurnLedger(base, entry) {
+    const existing = record(base.eventLedger, "event_ledger");
+    const entries = Array.isArray(existing.writerSceneCommits) ? existing.writerSceneCommits : [];
+    return canonicalTmwJsonValue({ ...existing, writerSceneCommits: [...entries, entry] }, "runtime_event_ledger");
+}
+function writerTurnRequestDigestImage(input) {
+    return canonicalTmwJsonValue({
+        operationId: requireTmwIdentifier(input.operationId, "writer_operation_id"),
+        turnId: requireTmwIdentifier(input.turnId, "writer_turn_id"),
+        worldlineId: requireTmwIdentifier(input.worldlineId, "writer_worldline_id"),
+        logicalSeq: requireTmwSafeInteger(input.logicalSeq, "writer_logical_seq", 0),
+        worldTime: input.worldTime,
+        writerReceiptDigest: requireTmwSha256(input.writerReceiptDigest, "writer_receipt_digest"),
+        noteConsumption: input.noteConsumption,
+        pendingClockCrossings: input.pendingClockCrossings,
+    }, "writer_turn_request");
+}
+function committedWriterTurnEntry(base, operationId) {
+    const ledger = record(base.eventLedger, "event_ledger");
+    if (!Array.isArray(ledger.writerSceneCommits))
+        return null;
+    const matches = ledger.writerSceneCommits.filter((value) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return false;
+        return value.operationId === operationId;
+    });
+    if (matches.length !== 1)
+        throw new Error("tmw_runtime_writer_commit_ledger_invalid");
+    return matches[0];
+}
+function rewriteSourceEvents(base) {
+    const ledger = record(base.eventLedger, "event_ledger");
+    if (Array.isArray(ledger.temporalBlockedEventIds)
+        && ledger.temporalBlockedEventIds.length > 0) {
+        throw new Error("tmw_rewrite_non_world_time_event_present");
+    }
+    const raw = ledger.rewriteEvents;
+    if (raw === undefined) {
+        const events = ledger.events;
+        if (Array.isArray(events) && events.length === 0)
+            return Object.freeze([]);
+        throw new Error("tmw_rewrite_source_metadata_missing");
+    }
+    if (!Array.isArray(raw))
+        throw new Error("tmw_rewrite_source_metadata_invalid");
+    return Object.freeze(raw);
+}
+function sourceEventLedgerDigestImage(events) {
+    return canonicalTmwJsonValue(events.map((event) => ({
+        eventId: event.eventId,
+        eventType: event.eventType,
+        effectiveWorldTime: event.effectiveWorldTime,
+        capabilityIds: event.capabilityIds,
+        payload: event.payload,
+        payloadHash: event.payloadHash,
+        replacementOf: event.replacementOf,
+        hardFact: event.hardFact,
+        externalIrreversible: event.externalIrreversible,
+    })), "rewrite_source_event_ledger");
+}
+function registryAdapter(registry) {
+    const byId = new Map(registry.capabilities.map((capability) => [capability.capability_id, capability]));
+    return Object.freeze({
+        resolve: (capabilityId) => {
+            const capability = byId.get(capabilityId);
+            if (capability === undefined)
+                return null;
+            return Object.freeze({
+                capabilityId: capability.capability_id,
+                profileIds: Object.freeze([registry.registry_version]),
+                executorKind: capability.policy === "presentation_only" ? "command" : "reconciler",
+                conflictKey: capability.capability_id,
+                mergePolicy: "reject",
+                allowsExternalSideEffect: capability.rewrite_safety === "external_irreversible",
+                selectorRequired: capability.selector_required,
+            });
+        },
+    });
+}
+function canonicalBinding(input) {
+    if (input.runtimeGeneration !== 3)
+        throw new Error("unsupported_runtime_generation");
+    return Object.freeze({
+        epoch: requireTmwSafeInteger(input.epoch, "runtime_epoch", 1),
+        runtimeGeneration: TMW_RUNTIME_GENERATION,
+        runtimeContractHash: requireTmwSha256(input.runtimeContractHash, "runtime_contract_hash"),
+        artifactDigest: requireTmwSha256(input.artifactDigest, "runtime_artifact_digest"),
+        sourceRevision: requireTmwIdentifier(input.sourceRevision, "runtime_source_revision"),
+        timelineRevision: requireTmwIdentifier(input.timelineRevision, "runtime_timeline_revision"),
+        leaseId: requireTmwIdentifier(input.leaseId, "runtime_lease_id"),
+    });
+}
+export function createTmwRuntimeHost(input) {
+    const binding = canonicalBinding(input.binding);
+    if (input.compiledPlan.plan_version !== 3 || input.compiledPlan.runtime_generation !== 3) {
+        throw new Error("unsupported_runtime_generation");
+    }
+    if (input.compiledPlan.runtime_contract_hash !== binding.runtimeContractHash) {
+        throw new Error("runtime_contract_hash_mismatch");
+    }
+    if (input.compiledPlan.registry_version !== input.capabilityRegistry.registry_version) {
+        throw new Error("tmw_runtime_registry_version_mismatch");
+    }
+    const orderedRuntimeNodes = dependencyOrderedRuntimeNodes(input.compiledPlan);
+    let fabric = new EventFabric({
+        epoch: binding.epoch,
+        runtimeContractHash: binding.runtimeContractHash,
+        artifactDigest: binding.artifactDigest,
+        timelineRevision: binding.timelineRevision,
+    });
+    const capabilities = registryAdapter(input.capabilityRegistry);
+    const compiledEventHardFact = (eventTypeInput) => {
+        const eventType = requireTmwIdentifier(eventTypeInput, "runtime_event_type");
+        const matches = input.compiledPlan.nodes.flatMap((node) => {
+            if (node.kind !== "event")
+                return [];
+            const payload = record(node.canonical_payload, "compiled_event");
+            return payload.event_type === eventType ? [payload] : [];
+        });
+        if (matches.length !== 1 || typeof matches[0].hard_fact !== "boolean") {
+            throw new Error("tmw_runtime_event_node_ambiguous");
+        }
+        return matches[0].hard_fact;
+    };
+    const hasExternalIrreversibleCapability = (capabilityIds) => capabilityIds.some((capabilityId) => {
+        const capability = input.capabilityRegistry.capabilities.find((candidate) => candidate.capability_id === capabilityId);
+        if (capability === undefined)
+            throw new Error("tmw_runtime_capability_missing");
+        return capability.rewrite_safety === "external_irreversible";
+    });
+    let disposed = false;
+    let restoredSav = null;
+    let eventAccepted = false;
+    let executionTail = Promise.resolve();
+    const assertActive = () => {
+        if (disposed)
+            throw new Error("tmw_runtime_disposed");
+    };
+    return Object.freeze({
+        binding,
+        compiledPlan: input.compiledPlan,
+        ingestCommittedEvent: async (event) => {
+            assertActive();
+            eventAccepted = true;
+            return await fabric.appendCommitted(event);
+        },
+        executeCommittedEvent: async (event, ports) => {
+            let releaseExecution;
+            const previousExecution = executionTail;
+            executionTail = new Promise((resolve) => {
+                releaseExecution = resolve;
+            });
+            await previousExecution;
+            try {
+                assertActive();
+                const base = restoredSav;
+                if (base === null)
+                    throw new Error("tmw_runtime_sav_state_missing");
+                const positiveSemanticLatches = new Map(positiveSemanticLatchesFromState(base.conditionState));
+                const positiveSemanticLatchKeys = new Set(positiveSemanticLatches.keys());
+                const operationId = `tmw3:event:${event.eventId}`;
+                if ((base.completedOperationIds ?? []).includes(operationId)) {
+                    throw new Error("tmw_runtime_operation_already_completed");
+                }
+                if (event.timelineRevision !== base.activeTimelineRevision) {
+                    throw new Error("tmw_event_timeline_revision_mismatch");
+                }
+                const pendingClockCrossing = base.pendingSceneClockCrossings.find((candidate) => candidate.eventId === event.eventId);
+                if (pendingClockCrossing !== undefined) {
+                    if (pendingClockCrossing.eventType !== event.eventType
+                        || pendingClockCrossing.logicalSeq !== event.coordinates.logicalSeq
+                        || pendingClockCrossing.worldTime !== event.coordinates.worldTime
+                        || pendingClockCrossing.crossingDirection !== event.crossingDirection
+                        || pendingClockCrossing.payloadHash !== event.payloadHash
+                        || pendingClockCrossing.commitReceiptDigest !== event.commitReceiptDigest
+                        || canonicalTmwJson(pendingClockCrossing.payload) !== canonicalTmwJson(event.payload)) {
+                        throw new Error("tmw_runtime_pending_scene_crossing_mismatch");
+                    }
+                }
+                const authorViewEvents = verifiedAuthorViewEvent(base, binding, event, pendingClockCrossing);
+                if (await ports.activation.readByOperation(operationId) !== null) {
+                    throw new Error("tmw_runtime_operation_already_activated");
+                }
+                eventAccepted = true;
+                const draftFabric = new EventFabric({
+                    epoch: binding.epoch,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    timelineRevision: base.activeTimelineRevision,
+                });
+                draftFabric.restoreLedgerHead(base.ledgerHead);
+                const eventReceipt = await draftFabric.appendCommitted(event);
+                const scheduler = new TmwScheduler(base.scheduler);
+                const schedulerReceipts = scheduler.advance(eventSchedulerCoordinates(event.coordinates), event.crossingDirection);
+                const dueSchedulerReceipts = Object.freeze(schedulerReceipts.filter((receipt) => receipt.status === "due"));
+                const consumedSuspensions = dueSchedulerReceipts.map((receipt) => {
+                    const suspension = scheduler.consumeDue(receipt.suspensionId);
+                    return Object.freeze({ receipt, suspension });
+                });
+                const dueSuspensions = new Map(consumedSuspensions.filter(({ suspension }) => !isTmwEventBroadcastSuspension(suspension)).map((entry) => [entry.suspension.resumeNodeId, entry]));
+                const eventRoots = new Set(input.compiledPlan.nodes.flatMap((node) => {
+                    if (node.kind !== "event" || !dueForEvent(event, node))
+                        return [];
+                    if (!isTmwEventDefinitionActive(node.stable_id, base.durableIntents))
+                        return [];
+                    const payload = record(node.canonical_payload, "compiled_event");
+                    return payload.event_type === event.eventType ? [node.stable_id] : [];
+                }));
+                if (event.hardFact !== compiledEventHardFact(event.eventType)) {
+                    throw new Error("tmw_runtime_event_hard_fact_mismatch");
+                }
+                const reachable = new Set(downstreamNodeIds(input.compiledPlan, eventRoots));
+                for (const resumeNodeId of dueSuspensions.keys())
+                    reachable.add(resumeNodeId);
+                const conditionResults = new Map();
+                const conditionValues = new Map();
+                const semanticPredicates = [];
+                const turnId = event.correlationId;
+                for (const node of input.compiledPlan.nodes) {
+                    if (!reachable.has(node.stable_id) || node.kind !== "condition" || !dueForEvent(event, node)) {
+                        continue;
+                    }
+                    const payload = record(node.canonical_payload, "compiled_condition");
+                    const expression = payload.expression;
+                    const expressionSnapshot = buildTmwConditionExpressionSnapshotV3(expression, record(event.payload, "event_payload"), node.stable_id, positiveSemanticLatchKeys, tmwValueContextFromSavV1(base), input.compiledPlan.value_graph);
+                    const result = evaluateConditionGraph(expressionSnapshot.graph, {
+                        snapshotHash: event.payloadHash,
+                        values: expressionSnapshot.values,
+                        evidenceRefs: Object.freeze(Object.fromEntries(Object.keys(expressionSnapshot.values).map((key) => [key, [event.eventId]]))),
+                        frozenFacts: event.payload,
+                    });
+                    conditionResults.set(node.stable_id, result);
+                    conditionValues.set(node.stable_id, expressionSnapshot.values);
+                    semanticPredicates.push(...expressionSnapshot.semanticPredicates.map((predicate) => Object.freeze({
+                        ...predicate,
+                        evidenceIdentity: Object.freeze({
+                            eventId: event.eventId,
+                            eventPayloadHash: event.payloadHash,
+                            sourceOperationId: operationId,
+                        }),
+                    })));
+                }
+                const semanticPredicateKeys = Object.freeze(semanticPredicates.map((item) => item.predicateKey).sort());
+                const semanticIntentId = `tmw3:semantic:${event.eventId}`;
+                let semanticReceipt = null;
+                let semanticValues = Object.freeze({});
+                if (semanticPredicates.length > 0) {
+                    try {
+                        semanticReceipt = await ports.semanticJudge.judge({
+                            event,
+                            turnId,
+                            operationId,
+                            intentId: semanticIntentId,
+                            idempotencyKey: operationId,
+                            predicates: Object.freeze(semanticPredicates),
+                            predicateKeys: semanticPredicateKeys,
+                        });
+                        semanticValues = resolveTmwSemanticPredicateValues(semanticPredicates, semanticReceipt);
+                        appendPositiveSemanticLatches(positiveSemanticLatches, semanticReceipt, semanticValues);
+                    }
+                    catch {
+                        semanticReceipt = null;
+                    }
+                    for (const [conditionId, values] of conditionValues) {
+                        const merged = Object.freeze({ ...values, ...semanticValues });
+                        const payload = record(input.compiledPlan.nodes.find((node) => node.stable_id === conditionId)
+                            .canonical_payload, "compiled_condition");
+                        const expressionSnapshot = buildTmwConditionExpressionSnapshotV3(payload.expression, record(event.payload, "event_payload"), conditionId, positiveSemanticLatchKeys, tmwValueContextFromSavV1(base), input.compiledPlan.value_graph);
+                        conditionResults.set(conditionId, evaluateConditionGraph(expressionSnapshot.graph, {
+                            snapshotHash: event.payloadHash,
+                            values: merged,
+                            evidenceRefs: Object.freeze(Object.fromEntries(Object.keys(merged).map((key) => [key, [event.eventId]]))),
+                            frozenFacts: event.payload,
+                        }));
+                    }
+                }
+                const worldEffectNodeIds = Object.freeze(input.compiledPlan.nodes.flatMap((node) => {
+                    if (!reachable.has(node.stable_id)
+                        || node.kind !== "effect"
+                        || (!dueSuspensions.has(node.stable_id) && !dueForEvent(event, node))) {
+                        return [];
+                    }
+                    const payload = record(node.canonical_payload, "compiled_effect");
+                    const capabilityId = String(payload.capability_id);
+                    return capabilityId.startsWith("world.") ? [node.stable_id] : [];
+                }).sort());
+                const preparedWorldMutation = worldEffectNodeIds.length > 0
+                    ? await ports.effectCommit.prepareWorldMutation({
+                        epoch: binding.epoch,
+                        runtimeContractHash: binding.runtimeContractHash,
+                        artifactDigest: binding.artifactDigest,
+                        event,
+                        turnId,
+                        operationId,
+                        worldEffectNodeIds,
+                    })
+                    : null;
+                const upstreamConditions = (nodeId) => {
+                    const seen = new Set();
+                    const pending = [nodeId];
+                    const found = [];
+                    while (pending.length > 0) {
+                        const current = pending.pop();
+                        for (const edge of input.compiledPlan.edges) {
+                            if (edge.to_stable_id !== current || seen.has(edge.from_stable_id))
+                                continue;
+                            seen.add(edge.from_stable_id);
+                            pending.push(edge.from_stable_id);
+                            const condition = conditionResults.get(edge.from_stable_id);
+                            if (condition !== undefined)
+                                found.push(condition);
+                        }
+                    }
+                    return found;
+                };
+                for (const node of input.compiledPlan.nodes) {
+                    if (!reachable.has(node.stable_id)
+                        || dueSuspensions.has(node.stable_id)
+                        || node.kind !== "effect"
+                        || dueForEvent(event, node))
+                        continue;
+                    const observed = observedCoordinate(event.coordinates, node.effective_time);
+                    if (observed === null
+                        || !crossingPolicyAllows(node.effective_time.crossing_policy, event.crossingDirection)) {
+                        continue;
+                    }
+                    const upstream = upstreamConditions(node.stable_id);
+                    const expectedConditionIds = new Set();
+                    const pendingAncestors = [node.stable_id];
+                    const seenAncestors = new Set();
+                    while (pendingAncestors.length > 0) {
+                        const current = pendingAncestors.pop();
+                        for (const edge of input.compiledPlan.edges) {
+                            if (edge.to_stable_id !== current || seenAncestors.has(edge.from_stable_id))
+                                continue;
+                            seenAncestors.add(edge.from_stable_id);
+                            pendingAncestors.push(edge.from_stable_id);
+                            if (input.compiledPlan.nodes.find((candidate) => candidate.stable_id === edge.from_stable_id)?.kind === "condition")
+                                expectedConditionIds.add(edge.from_stable_id);
+                        }
+                    }
+                    if ([...expectedConditionIds].some((id) => !conditionResults.has(id)))
+                        continue;
+                    const conditionTruth = combineTruth(upstream.map((condition) => condition.truth));
+                    if (conditionTruth !== "true")
+                        continue;
+                    scheduler.schedule(Object.freeze({
+                        suspensionId: `scheduled-effect:${event.eventId}:${node.stable_id}`,
+                        epoch: binding.epoch,
+                        runtimeGeneration: TMW_RUNTIME_GENERATION,
+                        runtimeContractHash: binding.runtimeContractHash,
+                        artifactDigest: binding.artifactDigest,
+                        sourceRevision: binding.sourceRevision,
+                        timelineRevision: base.activeTimelineRevision,
+                        scope: event.scope,
+                        effectiveTime: observeTmwEffectiveTime(node.effective_time, observed),
+                        resumeNodeId: node.stable_id,
+                        correlationId: event.correlationId,
+                        cancellationKey: null,
+                        createdSnapshotHash: event.payloadHash,
+                        durablePayload: canonicalTmwJsonValue({
+                            schema: "tmw3.scheduled-effect.v1",
+                            sourceEventId: event.eventId,
+                            conditionTruth,
+                        }, "runtime_scheduled_effect_payload"),
+                    }));
+                }
+                const effectPlans = [];
+                let plannedGameplay = base.gameplayState ?? emptyTmwGameplayStateV1();
+                for (const node of orderedRuntimeNodes) {
+                    if (!reachable.has(node.stable_id)
+                        || node.kind !== "effect"
+                        || (!dueSuspensions.has(node.stable_id) && !dueForEvent(event, node)))
+                        continue;
+                    const payload = record(node.canonical_payload, "compiled_effect");
+                    const scheduled = dueSuspensions.get(node.stable_id);
+                    const scheduledPayload = scheduled === undefined
+                        ? null
+                        : record(scheduled.suspension.durablePayload, "scheduled_effect_payload");
+                    if (scheduledPayload !== null
+                        && (scheduledPayload.schema !== "tmw3.scheduled-effect.v1"
+                            || scheduledPayload.conditionTruth !== "true")) {
+                        throw new Error("tmw_runtime_scheduled_effect_payload_invalid");
+                    }
+                    const conditions = upstreamConditions(node.stable_id);
+                    const valueInputsEnabled = scheduledPayload !== null || combineTruth(conditions.map((condition) => condition.truth)) === "true";
+                    const plan = planEffectFlow({
+                        epoch: binding.epoch,
+                        runtimeContractHash: binding.runtimeContractHash,
+                        artifactDigest: binding.artifactDigest,
+                        sourceRevision: binding.sourceRevision,
+                        timelineRevision: base.activeTimelineRevision,
+                        turnId,
+                        capabilityProfileId: input.capabilityRegistry.registry_version,
+                        mode: "normal",
+                        conditionTruth: scheduledPayload === null
+                            ? combineTruth(conditions.map((condition) => condition.truth))
+                            : "true",
+                        effects: Object.freeze([{
+                                effectId: node.stable_id,
+                                capabilityId: String(payload.capability_id),
+                                selector: (payload.selector ?? null),
+                                effectiveTime: node.effective_time,
+                                input: valueInputsEnabled ? resolveTmwEffectValueArgumentsV1(input.compiledPlan.value_graph, node.stable_id, record(payload.arguments, "runtime_effect_arguments"), tmwValueContextFromSavV1({ ...base, gameplayState: plannedGameplay }), String(payload.capability_id)) : canonicalTmwJsonValue(payload.arguments, "runtime_effect_arguments"),
+                                executionPolicy: node.execution_policy,
+                                rewritePolicy: node.rewrite_policy,
+                                priority: node.priority,
+                                idempotencyKey: node.idempotency_key,
+                            }]),
+                        maxEffects: 256,
+                    }, capabilities);
+                    if (plan.status === "ready") {
+                        const preparedGameplay = prepareTmwGameplayEffectsV1(plannedGameplay, plan.effects);
+                        plannedGameplay = preparedGameplay.state;
+                        effectPlans.push(Object.freeze({ ...plan, effects: preparedGameplay.effects }));
+                    }
+                    else
+                        effectPlans.push(plan);
+                }
+                const durableIntents = semanticPredicateKeys.length === 0
+                    ? []
+                    : [Object.freeze({
+                            intentId: semanticIntentId,
+                            epoch: binding.epoch,
+                            runtimeGeneration: TMW_RUNTIME_GENERATION,
+                            runtimeContractHash: binding.runtimeContractHash,
+                            artifactDigest: binding.artifactDigest,
+                            sourceRevision: binding.sourceRevision,
+                            timelineRevision: base.activeTimelineRevision,
+                            turnId,
+                            operationId,
+                            capabilityId: "semantic.request_verdict",
+                            idempotencyKey: operationId,
+                            conflictKey: semanticIntentId,
+                            priority: 0,
+                            state: semanticReceipt === null
+                                || Object.values(semanticValues).includes("unknown")
+                                ? "blocked"
+                                : "satisfied",
+                            selectorSnapshotHash: event.payloadHash,
+                            payload: Object.freeze({ predicateKeys: semanticPredicateKeys }),
+                            lastReceiptDigest: semanticReceipt?.verdictDigest ?? null,
+                            reasonCode: semanticReceipt === null ? "semantic_verdict_pending" : null,
+                        })];
+                const gameplay = { state: plannedGameplay, effects: effectPlans.flatMap((plan) => plan.status === "ready" ? plan.effects : []) };
+                const acceptedGameplayEffects = new Set(gameplay.effects);
+                const lifecycle = await reduceTmwEventLifecycle({
+                    plan: input.compiledPlan, event,
+                    effects: effectPlans.flatMap((plan) => plan.status === "ready" ? plan.effects : []),
+                    intents: [...base.durableIntents, ...durableIntents], scheduler,
+                    dueBroadcasts: consumedSuspensions.map((entry) => entry.suspension).filter(isTmwEventBroadcastSuspension),
+                    pending: base.pendingSceneClockCrossings,
+                }).catch(async (error) => {
+                    await ports.effectCommit.rollbackWorldMutation({ operationId, preparedWorldMutation, reason: "activation_failed" });
+                    throw error;
+                });
+                const effectReceipt = await ports.effectCommit.stage({
+                    event,
+                    turnId,
+                    operationId,
+                    preparedWorldMutation,
+                    plans: Object.freeze(effectPlans.map((plan) => Object.freeze({ ...plan,
+                        effects: Object.freeze(plan.effects.filter((effect) => acceptedGameplayEffects.has(effect) && !isTmwEventLifecycleCapability(effect.capabilityId))),
+                    }))),
+                    durableIntents: Object.freeze(durableIntents),
+                });
+                const terminalDigest = requireTmwSha256(effectReceipt.preActivationTerminalDigest, "runtime_effect_terminal_digest");
+                const presentationIntents = input.compiledPlan.nodes.flatMap((node, index) => {
+                    if (!reachable.has(node.stable_id) || node.kind !== "presentation" || !dueForEvent(event, node)) {
+                        return [];
+                    }
+                    const payload = record(node.canonical_payload, "compiled_presentation");
+                    return [Object.freeze({
+                            schema: "presentation-intent.v3",
+                            generation: TMW_RUNTIME_GENERATION,
+                            intent_id: `presentation:${node.stable_id}:${event.eventId}`,
+                            epoch: binding.epoch,
+                            artifact_digest: binding.artifactDigest,
+                            timeline_revision: base.activeTimelineRevision,
+                            activation_id: operationId,
+                            dedupe_key: `presentation:${node.stable_id}:${event.eventId}`,
+                            sequence: index,
+                            payload: payload.payload,
+                            metadata: Object.freeze({ sourceNodeId: node.stable_id }),
+                        })];
+                });
+                const readyEffects = effectPlans.flatMap((plan) => plan.status === "ready" ? plan.effects : []);
+                const sceneAtObservedTime = base.scene === null || event.coordinates.worldTime === null
+                    ? base.scene
+                    : setTmwSceneWorldTimeV1(base.scene, event.coordinates.worldTime);
+                const nextScene = reduceTmwSceneEffectsV1(sceneAtObservedTime, readyEffects, operationId);
+                const rewriteEvent = event.coordinates.worldTime === null
+                    ? null
+                    : Object.freeze({
+                        eventId: event.eventId,
+                        eventType: event.eventType,
+                        effectiveWorldTime: event.coordinates.worldTime,
+                        capabilityIds: Object.freeze([...new Set(readyEffects.map((effect) => effect.capabilityId))].sort()),
+                        payload: event.payload,
+                        payloadHash: event.payloadHash,
+                        replacementOf: event.replacementLineage,
+                        hardFact: event.hardFact,
+                        externalIrreversible: hasExternalIrreversibleCapability(readyEffects.map((effect) => effect.capabilityId)),
+                    });
+                const ledger = eventLedger(base, draftFabric.snapshot(), rewriteEvent, event.eventId, dueSchedulerReceipts);
+                const dueReceiptDigests = await Promise.all(dueSchedulerReceipts.map(async (receipt) => await tmwSha256Hex(canonicalTmwJson(receipt))));
+                const [narrativeDigest, presentationIntentSetDigest] = await Promise.all([
+                    tmwSha256Hex(canonicalTmwJson(base.narrative)),
+                    tmwSha256Hex(canonicalTmwJson([...base.presentationIntents, ...presentationIntents])),
+                ]);
+                const revisionId = `tmw3:revision:${await tmwSha256Hex(canonicalTmwJson({
+                    operationId,
+                    previous: base.activeTimelineRevision,
+                    ledgerHead: draftFabric.snapshot().ledgerHead,
+                    terminalDigest,
+                }))}`;
+                const nextDurableIntents = Object.freeze(lifecycle.intents.map((intent) => Object.freeze({ ...intent, timelineRevision: revisionId })));
+                const intentSetDigest = await tmwSha256Hex(canonicalTmwJson(nextDurableIntents));
+                const provisionalTimeline = Object.freeze({
+                    revisionId,
+                    parentRevisionId: base.activeTimelineRevision,
+                    revisionSequence: base.activeTimeline.revisionSequence + 1,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    worldlineId: event.scope.worldlineId,
+                    operationId,
+                    ledgerHead: draftFabric.snapshot().ledgerHead,
+                    narrativeDigest,
+                    savSectionDigest: "0".repeat(64),
+                    intentSetDigest,
+                    presentationIntentSetDigest,
+                    createdFrom: "turn",
+                    active: true,
+                });
+                const provisionalSav = Object.freeze({
+                    ...base,
+                    activeTimelineRevision: revisionId,
+                    activeTimeline: provisionalTimeline,
+                    turnId,
+                    preActivationTerminalDigest: terminalDigest,
+                    ledgerHead: draftFabric.snapshot().ledgerHead,
+                    eventLedger: ledger,
+                    scene: nextScene,
+                    gameplayState: persistentTmwGameplayStateV1(gameplay.state),
+                    pendingSceneClockCrossings: lifecycle.pending,
+                    scheduler: Object.freeze({
+                        cursor: scheduler.snapshot().cursor === null
+                            ? null
+                            : Object.freeze({
+                                ...scheduler.snapshot().cursor,
+                                worldTime: projectTmwSceneWorldTimeV1(nextScene),
+                            }),
+                        suspensions: Object.freeze(scheduler.snapshot().suspensions.map((suspension) => Object.freeze({ ...suspension, timelineRevision: revisionId }))),
+                    }),
+                    conditionState: materializeConditionState(positiveSemanticLatches, Object.fromEntries([...conditionResults].map(([id, result]) => [
+                        id,
+                        canonicalTmwJsonValue(result, "runtime_condition_evaluation"),
+                    ]))),
+                    durableIntents: nextDurableIntents,
+                    presentationIntents: Object.freeze([
+                        ...base.presentationIntents,
+                        ...presentationIntents.map((intent) => canonicalTmwJsonValue(JSON.parse(canonicalTmwJson(intent)), "runtime_presentation_intent")),
+                    ]),
+                    semanticVerdictRefs: Object.freeze([
+                        ...base.semanticVerdictRefs,
+                        ...(semanticReceipt === null ? [] : [semanticReceipt.verdictDigest]),
+                    ]),
+                    operationReceiptDigests: Object.freeze([...new Set([
+                            ...base.operationReceiptDigests,
+                            event.commitReceiptDigest,
+                            terminalDigest,
+                            ...(semanticReceipt === null ? [] : [semanticReceipt.providerReceiptDigest]),
+                            ...dueReceiptDigests,
+                        ])]),
+                    completedOperationIds: Object.freeze([
+                        ...(base.completedOperationIds ?? []),
+                        operationId,
+                    ]),
+                    worldMutationRecoveryOperations: Object.freeze([
+                        ...base.worldMutationRecoveryOperations,
+                        ...(effectReceipt.worldMutationRecoveryOperation === null
+                            ? []
+                            : [effectReceipt.worldMutationRecoveryOperation]),
+                    ]),
+                });
+                const savSectionDigest = await runtimeSavPayloadDigest(provisionalSav);
+                const savPayload = Object.freeze({
+                    ...provisionalSav,
+                    activeTimeline: Object.freeze({
+                        ...provisionalTimeline,
+                        savSectionDigest,
+                    }),
+                });
+                const savSection = await encodeRuntimeSavSection(savPayload);
+                const candidate = Object.freeze({
+                    operationId,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    expectedHead: Object.freeze({
+                        revisionId: base.activeTimeline.revisionId,
+                        revisionSequence: base.activeTimeline.revisionSequence,
+                        ledgerHead: base.ledgerHead,
+                    }),
+                    timeline: savPayload.activeTimeline,
+                    ledger,
+                    ledgerHead: savPayload.ledgerHead,
+                    narrative: savPayload.narrative,
+                    narrativeDigest,
+                    savSection,
+                    savSectionDigest,
+                    intents: savPayload.durableIntents,
+                    intentSetDigest,
+                    presentationIntents: savPayload.presentationIntents,
+                    presentationIntentSetDigest,
+                    preActivationTerminalDigest: terminalDigest,
+                });
+                let authorViewOutboxStaged = false;
+                const rollbackAuthorViewOutbox = async () => {
+                    if (!authorViewOutboxStaged || ports.verifiedAuthorViewOutbox === undefined)
+                        return;
+                    authorViewOutboxStaged = false;
+                    await ports.verifiedAuthorViewOutbox.rollback({ operationId });
+                };
+                if (authorViewEvents.length > 0 && ports.verifiedAuthorViewOutbox !== undefined) {
+                    // 仅把 verifiedAuthorViewEvent 的结果交给 outbox；不得将 event payload 或未验证 projection 旁路出去。
+                    authorViewOutboxStaged = true;
+                    try {
+                        await ports.verifiedAuthorViewOutbox.stage(Object.freeze({
+                            operationId,
+                            binding: Object.freeze({
+                                epoch: binding.epoch,
+                                artifactDigest: binding.artifactDigest,
+                                sourceRevision: binding.sourceRevision,
+                                timelineRevision: base.activeTimelineRevision,
+                                saveId: event.scope.saveId,
+                                worldlineId: event.scope.worldlineId,
+                            }),
+                            events: authorViewEvents,
+                        }));
+                    }
+                    catch (error) {
+                        await Promise.all([
+                            rollbackAuthorViewOutbox(),
+                            ports.effectCommit.rollbackWorldMutation({ operationId, preparedWorldMutation, reason: "activation_failed" }),
+                        ]);
+                        throw error;
+                    }
+                }
+                let activation;
+                try {
+                    activation = await activateTmwCandidate(candidate, ports.activation);
+                }
+                catch (error) {
+                    await Promise.all([
+                        rollbackAuthorViewOutbox(),
+                        ports.effectCommit.rollbackWorldMutation({ operationId, preparedWorldMutation, reason: "activation_failed" }),
+                    ]);
+                    throw error;
+                }
+                if (activation.status !== "committed" && activation.status !== "already_committed") {
+                    await Promise.all([
+                        rollbackAuthorViewOutbox(),
+                        ports.effectCommit.rollbackWorldMutation({ operationId, preparedWorldMutation, reason: "activation_conflict" }),
+                    ]);
+                    throw new Error("tmw_runtime_activation_conflict");
+                }
+                await ports.effectCommit.finalizeWorldMutation({
+                    operationId,
+                    preparedWorldMutation,
+                });
+                restoredSav = savPayload;
+                fabric = new EventFabric({
+                    epoch: binding.epoch,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    timelineRevision: revisionId,
+                });
+                fabric.restoreLedgerHead(savPayload.ledgerHead);
+                return Object.freeze({ eventReceipt, activation, candidate, authorViewEvents });
+            }
+            finally {
+                releaseExecution();
+            }
+        },
+        commitSuccessfulWriterTurn: async (writerInput, activationPort) => {
+            let releaseExecution;
+            const previousExecution = executionTail;
+            executionTail = new Promise((resolve) => { releaseExecution = resolve; });
+            await previousExecution;
+            try {
+                assertActive();
+                const base = restoredSav;
+                if (base === null)
+                    throw new Error("tmw_runtime_sav_state_missing");
+                const operationId = requireTmwIdentifier(writerInput.operationId, "writer_operation_id");
+                const writerReceiptDigest = requireTmwSha256(writerInput.writerReceiptDigest, "writer_receipt_digest");
+                const requestDigest = await tmwSha256Hex(canonicalTmwJson(writerTurnRequestDigestImage(writerInput)));
+                if ((base.completedOperationIds ?? []).includes(operationId)) {
+                    const committed = committedWriterTurnEntry(base, operationId);
+                    if (committed === null || committed.requestDigest !== requestDigest
+                        || committed.writerReceiptDigest !== writerReceiptDigest)
+                        throw new Error("tmw_runtime_writer_retry_request_mismatch");
+                    const existing = await activationPort.readByOperation(operationId);
+                    if (existing === null
+                        || (existing.status !== "committed" && existing.status !== "already_committed")) {
+                        throw new Error("tmw_runtime_writer_retry_activation_missing");
+                    }
+                    return Object.freeze({ status: "already_committed", activation: existing, candidate: null });
+                }
+                const turnId = requireTmwIdentifier(writerInput.turnId, "writer_turn_id");
+                const worldlineId = requireTmwIdentifier(writerInput.worldlineId, "writer_worldline_id");
+                let pendingSceneClockCrossings = Object.freeze(writerInput.pendingClockCrossings.map(canonicalTmwPendingSceneClockCrossingV1));
+                if (pendingSceneClockCrossings.some((entry) => entry.authorViewProjection !== undefined)) {
+                    throw new Error("tmw_runtime_writer_author_view_projection_forbidden");
+                }
+                const sceneAfterConsumption = base.scene === null || writerInput.noteConsumption === null
+                    ? base.scene
+                    : consumeCommittedTmwSceneNotesV1(base.scene, {
+                        ...writerInput.noteConsumption,
+                        writerReceiptDigest,
+                    }, writerReceiptDigest);
+                const scene = sceneAfterConsumption === null
+                    ? null
+                    : setTmwSceneWorldTimeV1(sceneAfterConsumption, writerInput.worldTime);
+                const baseCursor = base.scheduler.cursor ?? null;
+                const scheduler = Object.freeze({
+                    ...base.scheduler,
+                    cursor: canonicalSchedulerCoordinates(Object.freeze({
+                        logicalSeq: requireTmwSafeInteger(writerInput.logicalSeq, "writer_logical_seq", 0),
+                        worldTime: projectTmwSceneWorldTimeV1(scene),
+                        presentation: baseCursor?.presentation ?? null,
+                        realTime: baseCursor?.realTime ?? Object.freeze({}),
+                    })),
+                });
+                const writerScheduler = new TmwScheduler(base.scheduler);
+                const writerDue = writerScheduler.advance(scheduler.cursor, "forward");
+                const dueBroadcasts = writerDue.filter((receipt) => receipt.status === "due").flatMap((receipt) => {
+                    const suspension = writerScheduler.snapshot().suspensions.find((entry) => entry.suspensionId === receipt.suspensionId);
+                    return isTmwEventBroadcastSuspension(suspension) ? [writerScheduler.consumeDue(receipt.suspensionId)] : [];
+                });
+                const writerLifecycle = dueBroadcasts.length === 0
+                    ? { intents: base.durableIntents, pending: Object.freeze([...base.pendingSceneClockCrossings, ...pendingSceneClockCrossings]) }
+                    : await reduceTmwEventLifecycle({
+                        plan: input.compiledPlan,
+                        event: {
+                            ...binding, eventId: operationId, eventType: "tmw.writer.committed", hardFact: true,
+                            timelineRevision: base.activeTimelineRevision,
+                            coordinates: { logicalSeq: scheduler.cursor.logicalSeq, worldTime: writerInput.worldTime, presentation: null, realTime: null },
+                            effectiveTime: { domain: "logical_seq", due_value: scheduler.cursor.logicalSeq, effective_value: scheduler.cursor.logicalSeq, crossing_policy: "forward_only", real_time_clock: null, wall_clock_policy: null },
+                            crossingDirection: "forward", scope: dueBroadcasts[0].scope,
+                            correlationId: turnId, causationId: null, replacementLineage: [], payload: {}, payloadHash: writerReceiptDigest, commitReceiptDigest: writerReceiptDigest,
+                        }, effects: [], intents: base.durableIntents, scheduler: writerScheduler, dueBroadcasts,
+                        pending: [...base.pendingSceneClockCrossings, ...pendingSceneClockCrossings],
+                    });
+                pendingSceneClockCrossings = writerLifecycle.pending;
+                const [narrativeDigest, presentationIntentSetDigest] = await Promise.all([
+                    tmwSha256Hex(canonicalTmwJson(base.narrative)),
+                    tmwSha256Hex(canonicalTmwJson(base.presentationIntents)),
+                ]);
+                const revisionId = `tmw3:revision:${await tmwSha256Hex(canonicalTmwJson({ operationId, previous: base.activeTimelineRevision, writerReceiptDigest, scene }))}`;
+                const writerIntents = Object.freeze(writerLifecycle.intents.map((intent) => Object.freeze({ ...intent, timelineRevision: revisionId })));
+                const intentSetDigest = await tmwSha256Hex(canonicalTmwJson(writerIntents));
+                const provisionalTimeline = Object.freeze({
+                    ...base.activeTimeline,
+                    revisionId,
+                    parentRevisionId: base.activeTimelineRevision,
+                    revisionSequence: base.activeTimeline.revisionSequence + 1,
+                    operationId,
+                    worldlineId,
+                    narrativeDigest,
+                    intentSetDigest,
+                    presentationIntentSetDigest,
+                    savSectionDigest: "0".repeat(64),
+                    createdFrom: "turn",
+                });
+                const provisionalSav = Object.freeze({
+                    ...base,
+                    activeTimelineRevision: revisionId,
+                    activeTimeline: provisionalTimeline,
+                    turnId,
+                    preActivationTerminalDigest: writerReceiptDigest,
+                    scene,
+                    pendingSceneClockCrossings,
+                    eventLedger: writerTurnLedger(base, Object.freeze({
+                        schema: "tmw3.writer-scene-commit.v1",
+                        operationId,
+                        requestDigest,
+                        writerReceiptDigest,
+                    })),
+                    scheduler: Object.freeze({ ...scheduler, suspensions: Object.freeze(writerScheduler.snapshot().suspensions.map((suspension) => Object.freeze({ ...suspension, timelineRevision: revisionId }))) }),
+                    durableIntents: writerIntents,
+                    operationReceiptDigests: Object.freeze([...new Set([...base.operationReceiptDigests, writerReceiptDigest])]),
+                    completedOperationIds: Object.freeze([...(base.completedOperationIds ?? []), operationId]),
+                });
+                const savSectionDigest = await runtimeSavPayloadDigest(provisionalSav);
+                const savPayload = Object.freeze({
+                    ...provisionalSav,
+                    activeTimeline: Object.freeze({ ...provisionalTimeline, savSectionDigest }),
+                });
+                const candidate = Object.freeze({
+                    operationId,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    expectedHead: Object.freeze({ revisionId: base.activeTimeline.revisionId, revisionSequence: base.activeTimeline.revisionSequence, ledgerHead: base.ledgerHead }),
+                    timeline: savPayload.activeTimeline,
+                    ledger: savPayload.eventLedger,
+                    ledgerHead: savPayload.ledgerHead,
+                    narrative: savPayload.narrative,
+                    narrativeDigest,
+                    savSection: await encodeRuntimeSavSection(savPayload),
+                    savSectionDigest,
+                    intents: savPayload.durableIntents,
+                    intentSetDigest,
+                    presentationIntents: savPayload.presentationIntents,
+                    presentationIntentSetDigest,
+                    preActivationTerminalDigest: writerReceiptDigest,
+                });
+                const activation = await activateTmwCandidate(candidate, activationPort);
+                if (activation.status !== "committed" && activation.status !== "already_committed")
+                    throw new Error("tmw_runtime_activation_conflict");
+                restoredSav = savPayload;
+                fabric = new EventFabric({ epoch: binding.epoch, runtimeContractHash: binding.runtimeContractHash, artifactDigest: binding.artifactDigest, timelineRevision: revisionId });
+                fabric.restoreLedgerHead(savPayload.ledgerHead);
+                return Object.freeze({ status: activation.status === "already_committed" ? "already_committed" : "committed", activation, candidate });
+            }
+            finally {
+                releaseExecution();
+            }
+        },
+        rewriteTimeline: async (request, ports) => {
+            let releaseExecution;
+            const previousExecution = executionTail;
+            executionTail = new Promise((resolve) => {
+                releaseExecution = resolve;
+            });
+            await previousExecution;
+            try {
+                assertActive();
+                const base = restoredSav;
+                if (base === null)
+                    throw new Error("tmw_runtime_sav_state_missing");
+                if ((base.completedOperationIds ?? []).includes(request.operationId)) {
+                    throw new Error("tmw_runtime_operation_already_completed");
+                }
+                const rewritePositiveSemanticLatches = new Map(positiveSemanticLatchesFromState(base.conditionState));
+                const rewritePositiveSemanticLatchKeys = new Set(rewritePositiveSemanticLatches.keys());
+                const sourceEvents = rewriteSourceEvents(base);
+                const targetWorldTime = requireTmwSafeInteger(request.targetWorldTime, "rewrite_target_world_time");
+                const toWorldTime = Math.max(targetWorldTime, ...sourceEvents.map((event) => event.effectiveWorldTime));
+                const interval = Object.freeze({
+                    fromWorldTime: 0,
+                    toWorldTime,
+                    targetWorldTime,
+                });
+                const sourceEventLedgerDigest = await tmwSha256Hex(canonicalTmwJson(sourceEventLedgerDigestImage(sourceEvents)));
+                const draft = await ports.draft.generate({
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    scenarioId: requireTmwIdentifier(request.scenarioId, "rewrite_scenario_id"),
+                    sourceRevision: binding.sourceRevision,
+                    timelineRevision: base.activeTimelineRevision,
+                    eventLedgerDigest: sourceEventLedgerDigest,
+                    interval,
+                    turnId: request.turnId,
+                    operationId: request.operationId,
+                    idempotencyKey: request.operationId,
+                    boundedContext: canonicalTmwJsonValue({
+                        sourceEvents,
+                        sourceEventLedgerDigest,
+                        narrative: base.narrative,
+                        activeTimeline: base.activeTimeline,
+                    }, "rewrite_bounded_context"),
+                });
+                await assertTemporalRewriteBinding(draft, {
+                    epoch: binding.epoch,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    scenarioId: request.scenarioId,
+                    sourceRevision: binding.sourceRevision,
+                    timelineRevision: base.activeTimelineRevision,
+                    turnId: request.turnId,
+                    operationId: request.operationId,
+                    idempotencyKey: request.operationId,
+                    interval,
+                });
+                if (draft.conflictCodes.length !== 0)
+                    throw new Error("tmw_rewrite_conflict");
+                const allowedCapabilityIds = input.capabilityRegistry.capabilities
+                    .map((capability) => capability.capability_id);
+                const replay = await replayTemporalRewriteIsolated({
+                    draft,
+                    sourceEvents,
+                    sourceEventLedgerDigest,
+                    sourceRevisionSequence: base.activeTimeline.revisionSequence,
+                    worldlineId: base.activeTimeline.worldlineId,
+                    semanticVerdicts: Object.freeze([]),
+                    knownEvidenceRefs: Object.freeze(sourceEvents.map((event) => event.eventId)),
+                    allowedCapabilityIds: Object.freeze(allowedCapabilityIds),
+                    budget: Object.freeze({
+                        maxEvents: 4096,
+                        maxEffects: 4096,
+                        maxDepth: 64,
+                        deadlineEpochMs: requireTmwSafeInteger(request.deadlineEpochMs, "rewrite_deadline_epoch_ms", 1),
+                    }),
+                    nowEpochMs: Date.now(),
+                });
+                if (replay.status !== "passed"
+                    || replay.projection === null
+                    || replay.savCandidate === null
+                    || replay.successorInputs === null) {
+                    throw new Error(`tmw_rewrite_rejected:${replay.reasonCodes.join(",")}`);
+                }
+                const projectedIds = new Set(replay.projectedEvents.map((event) => event.eventId));
+                const sourceById = new Map(sourceEvents.map((event) => [event.eventId, event]));
+                const existingLedger = record(base.eventLedger, "event_ledger");
+                const committedEvents = Array.isArray(existingLedger.events)
+                    ? existingLedger.events.filter((event) => {
+                        if (typeof event !== "object" || event === null || Array.isArray(event))
+                            return false;
+                        const eventId = event.eventId;
+                        return typeof eventId === "string" && projectedIds.has(eventId);
+                    })
+                    : [];
+                const rewriteEvents = replay.projectedEvents.map((event) => {
+                    const source = sourceById.get(event.eventId);
+                    return Object.freeze({
+                        ...event,
+                        hardFact: source?.hardFact ?? compiledEventHardFact(event.eventType),
+                        externalIrreversible: source?.externalIrreversible
+                            ?? hasExternalIrreversibleCapability(event.capabilityIds),
+                    });
+                });
+                const ledger = canonicalTmwJsonValue({
+                    events: committedEvents,
+                    rewriteEvents,
+                    rewriteProjection: replay.projection,
+                }, "rewrite_runtime_event_ledger");
+                const rewriteEffectPlans = [];
+                let plannedRewriteGameplay = base.gameplayInitialState ?? emptyTmwGameplayStateV1();
+                const rewriteConditionState = Object.create(null);
+                const rewriteSemanticRefs = [];
+                const rewriteProviderReceiptDigests = [];
+                const pendingDurableIntents = [];
+                const pendingSuspensions = [];
+                const pendingPresentations = [];
+                const rewriteRuntimeEvents = rewriteEvents.map((event, index) => Object.freeze({
+                    eventId: event.eventId,
+                    eventType: event.eventType,
+                    hardFact: event.hardFact,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    timelineRevision: base.activeTimelineRevision,
+                    scope: Object.freeze({
+                        scenarioId: request.scenarioId,
+                        saveId: binding.leaseId,
+                        worldlineId: base.activeTimeline.worldlineId,
+                    }),
+                    coordinates: Object.freeze({
+                        logicalSeq: index,
+                        worldTime: event.effectiveWorldTime,
+                        presentation: null,
+                        realTime: null,
+                    }),
+                    effectiveTime: Object.freeze({
+                        domain: "world_time",
+                        due_value: event.effectiveWorldTime,
+                        effective_value: event.effectiveWorldTime,
+                        crossing_policy: "both_directions",
+                        real_time_clock: null,
+                        wall_clock_policy: null,
+                    }),
+                    crossingDirection: "backward",
+                    correlationId: request.turnId,
+                    causationId: request.operationId,
+                    replacementLineage: event.replacementOf,
+                    payloadHash: event.payloadHash,
+                    payload: event.payload,
+                    commitReceiptDigest: event.payloadHash,
+                }));
+                for (const event of rewriteRuntimeEvents) {
+                    plannedRewriteGameplay = persistentTmwGameplayStateV1(plannedRewriteGameplay);
+                    const eventRoots = new Set(input.compiledPlan.nodes.flatMap((node) => {
+                        if (node.kind !== "event" || !dueForEvent(event, node))
+                            return [];
+                        const payload = record(node.canonical_payload, "compiled_event");
+                        return payload.event_type === event.eventType ? [node.stable_id] : [];
+                    }));
+                    const reachable = downstreamNodeIds(input.compiledPlan, eventRoots);
+                    const conditionResults = new Map();
+                    const conditionValues = new Map();
+                    const semanticPredicates = [];
+                    const semanticOperationId = `${request.operationId}:${event.eventId}`;
+                    for (const node of input.compiledPlan.nodes) {
+                        if (!reachable.has(node.stable_id)
+                            || node.kind !== "condition"
+                            || !dueForEvent(event, node))
+                            continue;
+                        const payload = record(node.canonical_payload, "compiled_condition");
+                        const expressionSnapshot = buildTmwConditionExpressionSnapshotV3(payload.expression, record(event.payload, "event_payload"), node.stable_id, rewritePositiveSemanticLatchKeys, tmwValueContextFromSavV1(base), input.compiledPlan.value_graph);
+                        const result = evaluateConditionGraph(expressionSnapshot.graph, {
+                            snapshotHash: event.payloadHash,
+                            values: expressionSnapshot.values,
+                            evidenceRefs: Object.freeze(Object.fromEntries(Object.keys(expressionSnapshot.values).map((key) => [key, [event.eventId]]))),
+                            frozenFacts: event.payload,
+                        });
+                        conditionResults.set(node.stable_id, result);
+                        conditionValues.set(node.stable_id, expressionSnapshot.values);
+                        semanticPredicates.push(...expressionSnapshot.semanticPredicates.map((predicate) => Object.freeze({
+                            ...predicate,
+                            evidenceIdentity: Object.freeze({
+                                eventId: event.eventId,
+                                eventPayloadHash: event.payloadHash,
+                                sourceOperationId: semanticOperationId,
+                            }),
+                        })));
+                    }
+                    const semanticPredicateKeys = Object.freeze(semanticPredicates.map((item) => item.predicateKey).sort());
+                    let semanticReceipt = null;
+                    let semanticValues = Object.freeze({});
+                    if (semanticPredicates.length > 0) {
+                        try {
+                            semanticReceipt = await ports.semanticJudge.judge({
+                                event,
+                                turnId: request.turnId,
+                                operationId: semanticOperationId,
+                                intentId: `tmw3:rewrite-semantic:${event.eventId}`,
+                                idempotencyKey: semanticOperationId,
+                                predicates: Object.freeze(semanticPredicates),
+                                predicateKeys: semanticPredicateKeys,
+                            });
+                            semanticValues = resolveTmwSemanticPredicateValues(semanticPredicates, semanticReceipt);
+                            appendPositiveSemanticLatches(rewritePositiveSemanticLatches, semanticReceipt, semanticValues);
+                            for (const [predicateKey, truth] of Object.entries(semanticValues)) {
+                                if (truth === "true")
+                                    rewritePositiveSemanticLatchKeys.add(predicateKey);
+                            }
+                            rewriteSemanticRefs.push(semanticReceipt.verdictDigest);
+                            rewriteProviderReceiptDigests.push(semanticReceipt.providerReceiptDigest);
+                        }
+                        catch {
+                            semanticReceipt = null;
+                        }
+                        for (const [conditionId, values] of conditionValues) {
+                            const merged = Object.freeze({ ...values, ...semanticValues });
+                            const node = input.compiledPlan.nodes.find((candidate) => candidate.stable_id === conditionId);
+                            const payload = record(node.canonical_payload, "compiled_condition");
+                            const expressionSnapshot = buildTmwConditionExpressionSnapshotV3(payload.expression, record(event.payload, "event_payload"), conditionId, rewritePositiveSemanticLatchKeys, tmwValueContextFromSavV1(base), input.compiledPlan.value_graph);
+                            conditionResults.set(conditionId, evaluateConditionGraph(expressionSnapshot.graph, {
+                                snapshotHash: event.payloadHash,
+                                values: merged,
+                                evidenceRefs: Object.freeze(Object.fromEntries(Object.keys(merged).map((key) => [key, [event.eventId]]))),
+                                frozenFacts: event.payload,
+                            }));
+                        }
+                    }
+                    pendingDurableIntents.push(Object.freeze({
+                        event,
+                        predicateKeys: semanticPredicateKeys,
+                        receipt: semanticReceipt,
+                        semanticValues,
+                    }));
+                    const upstreamConditions = (nodeId) => {
+                        const seen = new Set();
+                        const pending = [nodeId];
+                        const found = [];
+                        while (pending.length > 0) {
+                            const current = pending.pop();
+                            for (const edge of input.compiledPlan.edges) {
+                                if (edge.to_stable_id !== current || seen.has(edge.from_stable_id))
+                                    continue;
+                                seen.add(edge.from_stable_id);
+                                pending.push(edge.from_stable_id);
+                                const condition = conditionResults.get(edge.from_stable_id);
+                                if (condition !== undefined)
+                                    found.push(condition);
+                            }
+                        }
+                        return found;
+                    };
+                    for (const [conditionId, result] of conditionResults) {
+                        rewriteConditionState[`${event.eventId}:${conditionId}`] =
+                            canonicalTmwJsonValue(result, "rewrite_condition_result");
+                    }
+                    for (const node of orderedRuntimeNodes) {
+                        if (!reachable.has(node.stable_id) || !dueForEvent(event, node))
+                            continue;
+                        if (node.kind === "effect") {
+                            const payload = record(node.canonical_payload, "compiled_effect");
+                            const conditionTruth = combineTruth(upstreamConditions(node.stable_id).map((condition) => condition.truth));
+                            const plan = planEffectFlow({
+                                epoch: binding.epoch,
+                                runtimeContractHash: binding.runtimeContractHash,
+                                artifactDigest: binding.artifactDigest,
+                                sourceRevision: binding.sourceRevision,
+                                timelineRevision: base.activeTimelineRevision,
+                                turnId: request.turnId,
+                                capabilityProfileId: input.capabilityRegistry.registry_version,
+                                mode: "rewrite",
+                                conditionTruth,
+                                effects: Object.freeze([{
+                                        effectId: `rewrite:${event.eventId}:${node.stable_id}`,
+                                        capabilityId: String(payload.capability_id),
+                                        selector: (payload.selector ?? null),
+                                        effectiveTime: node.effective_time,
+                                        input: conditionTruth === "true" ? resolveTmwEffectValueArgumentsV1(input.compiledPlan.value_graph, node.stable_id, record(payload.arguments, "rewrite_effect_arguments"), tmwValueContextFromSavV1({ ...base, gameplayState: plannedRewriteGameplay }), String(payload.capability_id)) : canonicalTmwJsonValue(payload.arguments, "rewrite_effect_arguments"),
+                                        executionPolicy: node.execution_policy,
+                                        rewritePolicy: node.rewrite_policy,
+                                        priority: node.priority,
+                                        idempotencyKey: `rewrite:${request.operationId}:${event.eventId}:${node.stable_id}`,
+                                    }]),
+                                maxEffects: 256,
+                            }, capabilities);
+                            if (plan.status === "ready") {
+                                const gameplay = prepareTmwGameplayEffectsV1(plannedRewriteGameplay, plan.effects);
+                                plannedRewriteGameplay = gameplay.state;
+                                rewriteEffectPlans.push(Object.freeze({ ...plan, effects: gameplay.effects }));
+                            }
+                            else
+                                rewriteEffectPlans.push(plan);
+                            if (plan.status === "suspended") {
+                                pendingSuspensions.push(Object.freeze({ event, node }));
+                            }
+                        }
+                        else if (node.kind === "presentation") {
+                            pendingPresentations.push(Object.freeze({
+                                event,
+                                node,
+                                sequence: pendingPresentations.length,
+                            }));
+                        }
+                    }
+                }
+                const targetTimelineRevision = replay.successorInputs.revisionId;
+                const durableIntents = pendingDurableIntents.flatMap(({ event, predicateKeys, receipt, semanticValues }) => predicateKeys.length === 0
+                    ? []
+                    : [Object.freeze({
+                            intentId: `tmw3:rewrite-semantic:${event.eventId}`,
+                            epoch: binding.epoch,
+                            runtimeGeneration: TMW_RUNTIME_GENERATION,
+                            runtimeContractHash: binding.runtimeContractHash,
+                            artifactDigest: binding.artifactDigest,
+                            sourceRevision: binding.sourceRevision,
+                            timelineRevision: targetTimelineRevision,
+                            turnId: request.turnId,
+                            operationId: `${request.operationId}:${event.eventId}`,
+                            capabilityId: "semantic.request_verdict",
+                            idempotencyKey: `${request.operationId}:${event.eventId}`,
+                            conflictKey: `tmw3:rewrite-semantic:${event.eventId}`,
+                            priority: 0,
+                            state: receipt === null
+                                || Object.values(semanticValues).includes("unknown")
+                                ? "blocked"
+                                : "satisfied",
+                            selectorSnapshotHash: event.payloadHash,
+                            payload: Object.freeze({ predicateKeys }),
+                            lastReceiptDigest: receipt?.verdictDigest ?? null,
+                            reasonCode: receipt === null ? "semantic_verdict_pending" : null,
+                        })]);
+                const presentationIntents = pendingPresentations.map(({ event, node, sequence }) => {
+                    const payload = record(node.canonical_payload, "compiled_presentation");
+                    return Object.freeze({
+                        schema: "presentation-intent.v3",
+                        generation: TMW_RUNTIME_GENERATION,
+                        intent_id: `rewrite:presentation:${node.stable_id}:${event.eventId}`,
+                        epoch: binding.epoch,
+                        artifact_digest: binding.artifactDigest,
+                        timeline_revision: targetTimelineRevision,
+                        activation_id: request.operationId,
+                        dedupe_key: `rewrite:presentation:${node.stable_id}:${event.eventId}`,
+                        sequence,
+                        payload: payload.payload,
+                        metadata: Object.freeze({
+                            sourceNodeId: node.stable_id,
+                            sourceEventId: event.eventId,
+                        }),
+                    });
+                });
+                const rewriteReadyEffects = rewriteEffectPlans.flatMap((plan) => plan.status === "ready" ? plan.effects : []);
+                const sceneAtRewriteTime = base.scene === null
+                    ? null
+                    : setTmwSceneWorldTimeV1(base.scene, targetWorldTime);
+                const rewrittenScene = reduceTmwSceneEffectsV1(sceneAtRewriteTime, rewriteReadyEffects, request.operationId);
+                const scheduler = Object.freeze({
+                    cursor: canonicalSchedulerCoordinates(Object.freeze({
+                        logicalSeq: replay.projectedEvents.length,
+                        worldTime: projectTmwSceneWorldTimeV1(rewrittenScene),
+                        presentation: null,
+                        realTime: Object.freeze({}),
+                    })),
+                    suspensions: Object.freeze(pendingSuspensions.map(({ event, node }) => Object.freeze({
+                        suspensionId: `rewrite:suspension:${event.eventId}:${node.stable_id}`,
+                        epoch: binding.epoch,
+                        runtimeGeneration: TMW_RUNTIME_GENERATION,
+                        runtimeContractHash: binding.runtimeContractHash,
+                        artifactDigest: binding.artifactDigest,
+                        sourceRevision: binding.sourceRevision,
+                        timelineRevision: targetTimelineRevision,
+                        scope: event.scope,
+                        effectiveTime: node.effective_time,
+                        resumeNodeId: node.stable_id,
+                        correlationId: request.turnId,
+                        cancellationKey: null,
+                        createdSnapshotHash: event.payloadHash,
+                        durablePayload: canonicalTmwJsonValue({
+                            eventId: event.eventId,
+                            operationId: request.operationId,
+                        }, "rewrite_scheduler_payload"),
+                    }))),
+                });
+                const aggregateRewriteEvent = Object.freeze({
+                    eventId: request.operationId,
+                    eventType: "tmw.temporal_rewrite",
+                    hardFact: false,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    timelineRevision: base.activeTimelineRevision,
+                    scope: Object.freeze({
+                        scenarioId: request.scenarioId,
+                        saveId: binding.leaseId,
+                        worldlineId: base.activeTimeline.worldlineId,
+                    }),
+                    coordinates: Object.freeze({
+                        logicalSeq: replay.projectedEvents.length,
+                        worldTime: targetWorldTime,
+                        presentation: null,
+                        realTime: null,
+                    }),
+                    effectiveTime: Object.freeze({
+                        domain: "world_time",
+                        due_value: targetWorldTime,
+                        effective_value: targetWorldTime,
+                        crossing_policy: "both_directions",
+                        real_time_clock: null,
+                        wall_clock_policy: null,
+                    }),
+                    crossingDirection: "backward",
+                    correlationId: request.turnId,
+                    causationId: null,
+                    replacementLineage: replay.affectedEventIds,
+                    payloadHash: replay.projection.ledgerDigest,
+                    payload: canonicalTmwJsonValue({
+                        draftDigest: draft.draftDigest,
+                        projectedEventSetDigest: replay.projectedEventSetDigest,
+                        successorInputDigest: replay.successorInputs.successorInputDigest,
+                    }, "rewrite_aggregate_event"),
+                    commitReceiptDigest: draft.draftDigest,
+                });
+                const rewriteGameplay = { state: plannedRewriteGameplay, effects: rewriteReadyEffects };
+                const acceptedRewriteGameplayEffects = new Set(rewriteGameplay.effects);
+                const worldEffectNodeIds = Object.freeze(rewriteEffectPlans.flatMap((plan) => plan.status === "ready"
+                    ? plan.effects
+                        .filter((effect) => effect.capabilityId.startsWith("world."))
+                        .map((effect) => effect.effectId)
+                    : []));
+                const preparedWorldMutation = worldEffectNodeIds.length === 0
+                    ? null
+                    : await ports.effectCommit.prepareWorldMutation({
+                        epoch: binding.epoch,
+                        runtimeContractHash: binding.runtimeContractHash,
+                        artifactDigest: binding.artifactDigest,
+                        event: aggregateRewriteEvent,
+                        turnId: request.turnId,
+                        operationId: request.operationId,
+                        worldEffectNodeIds,
+                    });
+                const effectReceipt = await ports.effectCommit.stage({
+                    event: aggregateRewriteEvent,
+                    turnId: request.turnId,
+                    operationId: request.operationId,
+                    preparedWorldMutation,
+                    plans: Object.freeze(rewriteEffectPlans.map((plan) => Object.freeze({ ...plan, effects: Object.freeze(plan.effects.filter((effect) => acceptedRewriteGameplayEffects.has(effect))) }))),
+                    durableIntents: Object.freeze(durableIntents),
+                });
+                const terminalDigest = requireTmwSha256(effectReceipt.preActivationTerminalDigest, "rewrite_effect_terminal_digest");
+                const [intentSetDigest, presentationIntentSetDigest] = await Promise.all([
+                    tmwSha256Hex(canonicalTmwJson(durableIntents)),
+                    tmwSha256Hex(canonicalTmwJson(presentationIntents)),
+                ]);
+                const provisionalTimeline = Object.freeze({
+                    revisionId: replay.successorInputs.revisionId,
+                    parentRevisionId: base.activeTimelineRevision,
+                    revisionSequence: replay.successorInputs.revisionSequence,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    worldlineId: replay.successorInputs.worldlineId,
+                    operationId: request.operationId,
+                    ledgerHead: replay.projection.ledgerDigest,
+                    narrativeDigest: draft.narrativeDigest,
+                    savSectionDigest: "0".repeat(64),
+                    intentSetDigest,
+                    presentationIntentSetDigest,
+                    createdFrom: "temporal_rewrite",
+                    active: true,
+                });
+                const provisionalSav = Object.freeze({
+                    ...base,
+                    activeTimelineRevision: provisionalTimeline.revisionId,
+                    activeTimeline: provisionalTimeline,
+                    turnId: request.turnId,
+                    preActivationTerminalDigest: terminalDigest,
+                    ledgerHead: replay.projection.ledgerDigest,
+                    eventLedger: ledger,
+                    narrative: draft.narrative,
+                    scene: rewrittenScene,
+                    gameplayState: persistentTmwGameplayStateV1(rewriteGameplay.state),
+                    scheduler,
+                    conditionState: materializeConditionState(rewritePositiveSemanticLatches, rewriteConditionState),
+                    durableIntents: Object.freeze(durableIntents),
+                    presentationIntents: Object.freeze(presentationIntents.map((intent) => canonicalTmwJsonValue(JSON.parse(canonicalTmwJson(intent)), "rewrite_presentation_intent"))),
+                    semanticVerdictRefs: Object.freeze([...new Set(rewriteSemanticRefs)]),
+                    candidateSetRevisions: base.candidateSetRevisions,
+                    operationReceiptDigests: Object.freeze([...new Set([
+                            ...base.operationReceiptDigests,
+                            draft.draftDigest,
+                            replay.projection.ledgerDigest,
+                            replay.savCandidate.candidateDigest,
+                            replay.successorInputs.successorInputDigest,
+                            terminalDigest,
+                            ...rewriteProviderReceiptDigests,
+                            ...replay.savCandidate.compensationReceiptDigests,
+                        ])]),
+                    completedOperationIds: Object.freeze([...new Set([
+                            ...(base.completedOperationIds ?? []),
+                            request.operationId,
+                        ])]),
+                    worldMutationRecoveryOperations: Object.freeze([
+                        ...base.worldMutationRecoveryOperations,
+                        ...(effectReceipt.worldMutationRecoveryOperation === null
+                            ? []
+                            : [effectReceipt.worldMutationRecoveryOperation]),
+                    ]),
+                });
+                const savSectionDigest = await runtimeSavPayloadDigest(provisionalSav);
+                const savPayload = Object.freeze({
+                    ...provisionalSav,
+                    activeTimeline: Object.freeze({
+                        ...provisionalTimeline,
+                        savSectionDigest,
+                    }),
+                });
+                const savSection = await encodeRuntimeSavSection(savPayload);
+                const candidate = Object.freeze({
+                    operationId: request.operationId,
+                    epoch: binding.epoch,
+                    runtimeGeneration: TMW_RUNTIME_GENERATION,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    sourceRevision: binding.sourceRevision,
+                    expectedHead: Object.freeze({
+                        revisionId: base.activeTimeline.revisionId,
+                        revisionSequence: base.activeTimeline.revisionSequence,
+                        ledgerHead: base.ledgerHead,
+                    }),
+                    timeline: savPayload.activeTimeline,
+                    ledger,
+                    ledgerHead: savPayload.ledgerHead,
+                    narrative: savPayload.narrative,
+                    narrativeDigest: draft.narrativeDigest,
+                    savSection,
+                    savSectionDigest,
+                    intents: savPayload.durableIntents,
+                    intentSetDigest,
+                    presentationIntents: savPayload.presentationIntents,
+                    presentationIntentSetDigest,
+                    preActivationTerminalDigest: terminalDigest,
+                });
+                let activation;
+                try {
+                    activation = await activateTmwCandidate(candidate, ports.activation);
+                }
+                catch (error) {
+                    await ports.effectCommit.rollbackWorldMutation({
+                        operationId: request.operationId,
+                        preparedWorldMutation,
+                        reason: "activation_failed",
+                    });
+                    throw error;
+                }
+                if (activation.status !== "committed" && activation.status !== "already_committed") {
+                    await ports.effectCommit.rollbackWorldMutation({
+                        operationId: request.operationId,
+                        preparedWorldMutation,
+                        reason: "activation_conflict",
+                    });
+                    throw new Error("tmw_rewrite_activation_conflict");
+                }
+                await ports.effectCommit.finalizeWorldMutation({
+                    operationId: request.operationId,
+                    preparedWorldMutation,
+                });
+                restoredSav = savPayload;
+                fabric = new EventFabric({
+                    epoch: binding.epoch,
+                    runtimeContractHash: binding.runtimeContractHash,
+                    artifactDigest: binding.artifactDigest,
+                    timelineRevision: savPayload.activeTimelineRevision,
+                });
+                fabric.restoreLedgerHead(savPayload.ledgerHead);
+                return Object.freeze({ draft, activation, candidate });
+            }
+            finally {
+                releaseExecution();
+            }
+        },
+        restore: (payload) => {
+            assertActive();
+            if (eventAccepted || restoredSav !== null)
+                throw new Error("tmw_runtime_restore_barrier_closed");
+            const canonical = canonicalRuntimeSavPayload(payload);
+            if (canonical.epoch !== binding.epoch)
+                throw new Error("stale_content_epoch");
+            if (canonical.runtimeContractHash !== binding.runtimeContractHash) {
+                throw new Error("runtime_contract_hash_mismatch");
+            }
+            if (canonical.artifactDigest !== binding.artifactDigest
+                || canonical.sourceRevision !== binding.sourceRevision
+                || canonical.activeTimelineRevision !== binding.timelineRevision) {
+                throw new Error("tmw_runtime_restore_binding_mismatch");
+            }
+            fabric.restoreLedgerHead(canonical.ledgerHead);
+            restoredSav = canonical;
+        },
+        restoredSav: () => restoredSav,
+        materializeSav: (savInput) => {
+            assertActive();
+            const base = restoredSav;
+            if (base === null)
+                throw new Error("tmw_runtime_sav_state_missing");
+            return Object.freeze({
+                ...base,
+                turnId: requireTmwIdentifier(savInput.turnId, "runtime_sav_turn_id"),
+                preActivationTerminalDigest: requireTmwSha256(savInput.preActivationTerminalDigest, "runtime_sav_pre_activation_terminal_digest"),
+                ledgerHead: fabric.snapshot().ledgerHead,
+            });
+        },
+        viewEventCommitContext: (eventTypeInput, observation) => {
+            assertActive();
+            const eventType = requireTmwIdentifier(eventTypeInput, "runtime_view_event_type");
+            const matches = input.compiledPlan.nodes.filter((node) => {
+                if (node.kind !== "event")
+                    return false;
+                return record(node.canonical_payload, "compiled_event").event_type === eventType;
+            });
+            if (matches.length !== 1)
+                throw new Error("tmw_runtime_event_node_ambiguous");
+            const node = matches[0];
+            if (observation.crossingDirection !== "forward"
+                && observation.crossingDirection !== "backward") {
+                throw new Error("tmw_runtime_clock_crossing_direction_invalid");
+            }
+            if (!crossingPolicyAllows(node.effective_time.crossing_policy, observation.crossingDirection)) {
+                throw new Error("tmw_runtime_clock_crossing_direction_forbidden");
+            }
+            const coordinates = canonicalEventCoordinates(observation.coordinates);
+            const observed = observedCoordinate(coordinates, node.effective_time);
+            if (observed === null)
+                throw new Error("tmw_runtime_observed_clock_missing");
+            const previous = schedulerObservedCoordinate(restoredSav?.scheduler.cursor, node.effective_time);
+            if (previous !== null
+                && ((observation.crossingDirection === "forward" && observed < previous)
+                    || (observation.crossingDirection === "backward" && observed > previous))) {
+                throw new Error("tmw_runtime_clock_crossing_direction_mismatch");
+            }
+            const effectiveTime = observeTmwEffectiveTime(node.effective_time, observed);
+            return Object.freeze({
+                timelineRevision: restoredSav?.activeTimelineRevision ?? binding.timelineRevision,
+                hardFact: compiledEventHardFact(eventType),
+                effectiveTime,
+                coordinates,
+                crossingDirection: observation.crossingDirection,
+            });
+        },
+        evaluate: (evaluation) => {
+            assertActive();
+            const condition = evaluateConditionGraph(evaluation.graph, evaluation.snapshot);
+            const effectPlan = planEffectFlow({
+                ...evaluation.effectFlow,
+                conditionTruth: condition.truth,
+            }, capabilities);
+            return Object.freeze({ condition, effectPlan });
+        },
+        snapshot: () => {
+            assertActive();
+            return fabric.snapshot();
+        },
+        dispose: () => {
+            disposed = true;
+        },
+    });
+}