@world-engines/tmw 0.1.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+export { AUTHOR_SCENARIO_SOURCE_V3_SCHEMA_VERSION, canonicalRuntimeContractV3Bytes, canonicalTmwBytes, canonicalTmwJson, isSha256Hex, runtimeContractHashV3, tmwSha256Hex, TMW_COMPILED_PLAN_VERSION, TMW_RUNTIME_CONTRACT_V3, TMW_RUNTIME_GENERATION, TRIGGER_DOCUMENT_V3_VERSION, } from "./runtime-contract.js";
+export type { TmwJsonPrimitive, TmwJsonValue, TmwRuntimeRejectionCode } from "./runtime-contract.js";
+export * from "./audio-presentation-projection.js";
+export { orderTmwDiagnostics, tmwDiagnostic, tmwFailure, tmwSuccess } from "./diagnostics.js";
+export type { TmwDiagnostic, TmwDiagnosticSeverity, TmwResult } from "./diagnostics.js";
+export { compareTmwEffectiveTime, isTmwEffectiveTime, TMW_TIME_DOMAINS } from "./time-domains.js";
+export type { ConditionEffectiveTime, EffectEffectiveTime, EventEffectiveTime, PresentationEffectiveTime, TmwEffectiveTime, TmwTimeDomain, } from "./time-domains.js";
+export { SELECTOR_AST_V3_OPS, selectorAstStableIdentity } from "./selector-ast.js";
+export type { SelectorAstV3, SelectorComparisonOperator } from "./selector-ast.js";
+export { capabilityRegistryIndex, getCanonicalTmwCapabilityRegistryV3, isCanonicalTmwCapabilityRegistryV3, TMW_CAPABILITY_REGISTRY_VERSION, } from "./capability-registry.js";
+export type { CapabilityCheckedEffectV3, CanonicalTmwCapabilityRegistryV3, TmwCapabilityPolicy, TmwCapabilityRegistryV3, TmwCapabilityV3, } from "./capability-registry.js";
+export { allTriggerNodesV3, parseTriggerDocumentV3 } from "./trigger-document-v3.js";
+export type { TmwConditionExpressionV3, TriggerConditionNodeV3, TriggerDocumentV3, TriggerEdgeV3, TriggerEffectNodeV3, TriggerEventNodeV3, TriggerNodeKindV3, TriggerNodeV3, TriggerPresentationNodeV3, } from "./trigger-document-v3.js";
+export { tmwBuilderCommandFromNode, tmwBuilderCommandSchema, tmwBuilderNodeFromCommand, tmwStableIdSchema, } from "./builder-node.js";
+export type { TmwBuilderCommand, TmwBuilderNodeCommand, TmwBuilderNodeInput, } from "./builder-node.js";
+export { validateTmw3 } from "./validator.js";
+export type { ValidateTmw3Options } from "./validator.js";
+export { compileTmw3 } from "./compiler.js";
+export { getTmwRuntimeDomainCapability, tmwRuntimeProducesClockDomain } from "./runtime-domain-capabilities.js";
+export type { TmwRuntimeCapabilityTarget, TmwRuntimeDomainCapability } from "./runtime-domain-capabilities.js";
+export type { CompileTmw3Result, CompiledPlanNodeV3, CompiledPlanV3, CompiledPlanV3Core } from "./compiled-plan.js";
+export { simulateTmw3 } from "./simulator.js";
+export type { SimulateTmw3Options, SimulateTmw3Outcome, TmwSimulationResult, TmwSimulationTraceEntry } from "./simulator.js";
+export type { AuthenticatedCreateNewSourceInput, AuthorScenarioSourceV3, AuthorSourceIdentityV3 } from "./author-scenario-source-v3.js";
+export { authorScenarioSourceV3Digest, canonicalAuthorScenarioSourceV3Bytes, createCanonicalEmptyAuthorScenarioSourceV3 } from "./source-canonical.js";
+export { decryptAuthorSourcePayloadV3, encryptAuthorSourcePayloadV3 } from "./source-crypto.js";
+export type { AuthorSourceCryptoPort, EncryptedAuthorSourcePayloadV3 } from "./source-crypto.js";
+export { buildEncryptedAuthorSourceRevisionV3, readbackAuthorSourceRevisionV3 } from "./source-revision.js";
+export type { AuthorSourceReadbackReceiptV3, EncryptedAuthorSourceRevisionV3 } from "./source-revision.js";
+export * from "./activation.js";
+export * from "./condition-graph.js";
+export * from "./durable-intent.js";
+export * from "./effect-flow.js";
+export * from "./event-fabric.js";
+export * from "./event-lifecycle.js";
+export * from "./evidence.js";
+export * from "./isolated-replay.js";
+export * from "./recall-query-envelope.js";
+export * from "./rewrite-compensation.js";
+export * from "./runtime.js";
+export * from "./runtime-sav.js";
+export * from "./runtime-trace.js";
+export * from "./spatial-impact-receipt.js";
+export * from "./scheduler.js";
+export * from "./scene-state.js";
+export * from "./scene-author-source.js";
+export * from "./semantic-verdict.js";
+export * from "./temporal-rewrite.js";
+export * from "./timeline-revision.js";
+export * from "./turn-commit.js";
+export * from "./builder.js";
+export * from "./builder-diagnostics.js";
+export * from "./builder-node.js";
+export * from "./music-candidate-set.js";
+export * from "./presentation-intent.js";
+export * from "./view-interaction-manifest-v3.js";
+export * from "./view-event-delivery.js";
+export * from "./compile-target-profile.js";
+export * from "./compiler-stage-cache.js";
+export * from "./compiler-stage-registry.js";
+export * from "./neutral-source-compiler.js";
+export * from "./compiler-compatibility-gate.js";
+export * from "./compiler-release-authority.js";
+export * from "./scene-author-source.js";
+export * from "./value-graph.js";
+export * from "./gameplay-state.js";

package/dist/index.js

@@ -0,0 +1,52 @@
+export { AUTHOR_SCENARIO_SOURCE_V3_SCHEMA_VERSION, canonicalRuntimeContractV3Bytes, canonicalTmwBytes, canonicalTmwJson, isSha256Hex, runtimeContractHashV3, tmwSha256Hex, TMW_COMPILED_PLAN_VERSION, TMW_RUNTIME_CONTRACT_V3, TMW_RUNTIME_GENERATION, TRIGGER_DOCUMENT_V3_VERSION, } from "./runtime-contract.js";
+export * from "./audio-presentation-projection.js";
+export { orderTmwDiagnostics, tmwDiagnostic, tmwFailure, tmwSuccess } from "./diagnostics.js";
+export { compareTmwEffectiveTime, isTmwEffectiveTime, TMW_TIME_DOMAINS } from "./time-domains.js";
+export { SELECTOR_AST_V3_OPS, selectorAstStableIdentity } from "./selector-ast.js";
+export { capabilityRegistryIndex, getCanonicalTmwCapabilityRegistryV3, isCanonicalTmwCapabilityRegistryV3, TMW_CAPABILITY_REGISTRY_VERSION, } from "./capability-registry.js";
+export { allTriggerNodesV3, parseTriggerDocumentV3 } from "./trigger-document-v3.js";
+export { tmwBuilderCommandFromNode, tmwBuilderCommandSchema, tmwBuilderNodeFromCommand, tmwStableIdSchema, } from "./builder-node.js";
+export { validateTmw3 } from "./validator.js";
+export { compileTmw3 } from "./compiler.js";
+export { getTmwRuntimeDomainCapability, tmwRuntimeProducesClockDomain } from "./runtime-domain-capabilities.js";
+export { simulateTmw3 } from "./simulator.js";
+export { authorScenarioSourceV3Digest, canonicalAuthorScenarioSourceV3Bytes, createCanonicalEmptyAuthorScenarioSourceV3 } from "./source-canonical.js";
+export { decryptAuthorSourcePayloadV3, encryptAuthorSourcePayloadV3 } from "./source-crypto.js";
+export { buildEncryptedAuthorSourceRevisionV3, readbackAuthorSourceRevisionV3 } from "./source-revision.js";
+export * from "./activation.js";
+export * from "./condition-graph.js";
+export * from "./durable-intent.js";
+export * from "./effect-flow.js";
+export * from "./event-fabric.js";
+export * from "./event-lifecycle.js";
+export * from "./evidence.js";
+export * from "./isolated-replay.js";
+export * from "./recall-query-envelope.js";
+export * from "./rewrite-compensation.js";
+export * from "./runtime.js";
+export * from "./runtime-sav.js";
+export * from "./runtime-trace.js";
+export * from "./spatial-impact-receipt.js";
+export * from "./scheduler.js";
+export * from "./scene-state.js";
+export * from "./scene-author-source.js";
+export * from "./semantic-verdict.js";
+export * from "./temporal-rewrite.js";
+export * from "./timeline-revision.js";
+export * from "./turn-commit.js";
+export * from "./builder.js";
+export * from "./builder-diagnostics.js";
+export * from "./builder-node.js";
+export * from "./music-candidate-set.js";
+export * from "./presentation-intent.js";
+export * from "./view-interaction-manifest-v3.js";
+export * from "./view-event-delivery.js";
+export * from "./compile-target-profile.js";
+export * from "./compiler-stage-cache.js";
+export * from "./compiler-stage-registry.js";
+export * from "./neutral-source-compiler.js";
+export * from "./compiler-compatibility-gate.js";
+export * from "./compiler-release-authority.js";
+export * from "./scene-author-source.js";
+export * from "./value-graph.js";
+export * from "./gameplay-state.js";

package/dist/isolated-replay.d.ts

@@ -0,0 +1,81 @@
+import { type TemporalRewriteDraftV3, type TemporalRewriteEventV3 } from "./temporal-rewrite.js";
+import { type RewriteCompensationReceiptV3 } from "./rewrite-compensation.js";
+export interface ReplaySourceEventV3 extends TemporalRewriteEventV3 {
+    readonly hardFact: boolean;
+    readonly externalIrreversible: boolean;
+}
+export interface IsolatedReplayBudget {
+    readonly maxEvents: number;
+    readonly maxEffects: number;
+    readonly maxDepth: number;
+    readonly deadlineEpochMs: number;
+}
+export interface TemporalRewriteSemanticVerdictV3 {
+    readonly predicateKey: string;
+    readonly truth: "true" | "false" | "unknown";
+}
+export interface TemporalRewriteProjectedLedgerV3 {
+    readonly schemaVersion: 3;
+    readonly sourceEventLedgerDigest: string;
+    readonly sourceTimelineRevision: string;
+    readonly targetTimelineRevision: string;
+    readonly targetWorldTime: number;
+    readonly retainedEventIds: ReadonlyArray<string>;
+    readonly droppedEventIds: ReadonlyArray<string>;
+    readonly affectedEventIds: ReadonlyArray<string>;
+    readonly events: ReadonlyArray<TemporalRewriteEventV3>;
+    readonly compensationReceipts: ReadonlyArray<RewriteCompensationReceiptV3>;
+    readonly compensationReceiptSetDigest: string;
+    readonly ledgerDigest: string;
+}
+export interface TemporalRewriteSavCandidateV3 {
+    readonly schemaVersion: 3;
+    readonly sourceTimelineRevision: string;
+    readonly targetTimelineRevision: string;
+    readonly targetWorldTime: number;
+    readonly projectedLedgerDigest: string;
+    readonly compensationReceipts: ReadonlyArray<RewriteCompensationReceiptV3>;
+    readonly compensationReceiptDigests: ReadonlyArray<string>;
+    readonly candidateDigest: string;
+}
+export interface TemporalRewriteSuccessorInputsV3 {
+    readonly revisionId: string;
+    readonly parentRevisionId: string;
+    readonly revisionSequence: number;
+    readonly worldlineId: string;
+    readonly operationId: string;
+    readonly createdFrom: "temporal_rewrite";
+    readonly targetWorldTime: number;
+    readonly ledgerHead: string;
+    readonly narrativeDigest: string;
+    readonly compensationReceiptSetDigest: string;
+    readonly savCandidateDigest: string;
+    readonly successorInputDigest: string;
+}
+export interface IsolatedReplayResultV3 {
+    readonly status: "passed" | "rejected";
+    readonly reasonCodes: ReadonlyArray<string>;
+    readonly sourceTimelineRevision: string;
+    readonly sourceEventLedgerDigest: string;
+    readonly projectedEvents: ReadonlyArray<TemporalRewriteEventV3>;
+    readonly projectedEventSetDigest: string;
+    readonly retainedHardFactIds: ReadonlyArray<string>;
+    readonly droppedEventIds: ReadonlyArray<string>;
+    readonly affectedEventIds: ReadonlyArray<string>;
+    readonly externalEffectsRequiringCompensation: ReadonlyArray<string>;
+    readonly projection: TemporalRewriteProjectedLedgerV3 | null;
+    readonly savCandidate: TemporalRewriteSavCandidateV3 | null;
+    readonly successorInputs: TemporalRewriteSuccessorInputsV3 | null;
+}
+export declare function replayTemporalRewriteIsolated(input: Readonly<{
+    draft: TemporalRewriteDraftV3;
+    sourceEvents: ReadonlyArray<ReplaySourceEventV3>;
+    sourceEventLedgerDigest: string;
+    sourceRevisionSequence: number;
+    worldlineId: string;
+    semanticVerdicts: ReadonlyArray<TemporalRewriteSemanticVerdictV3>;
+    knownEvidenceRefs: ReadonlyArray<string>;
+    allowedCapabilityIds: ReadonlyArray<string>;
+    budget: IsolatedReplayBudget;
+    nowEpochMs: number;
+}>): Promise<IsolatedReplayResultV3>;

package/dist/isolated-replay.js

@@ -0,0 +1,316 @@
+import { verifyTemporalRewriteDraft, verifyTemporalRewriteEvent, } from "./temporal-rewrite.js";
+import { createRewriteCompensationReceipts, } from "./rewrite-compensation.js";
+import { canonicalTmwJson, canonicalTmwJsonValue, requireTmwIdentifier, requireTmwSafeInteger, requireTmwSha256, tmwSha256Hex, } from "./runtime-trace.js";
+function compareEvents(left, right) {
+    return left.effectiveWorldTime - right.effectiveWorldTime
+        || (left.eventId < right.eventId ? -1 : left.eventId > right.eventId ? 1 : 0);
+}
+function exactOrderedIds(actual, expected) {
+    return actual.length === expected.length
+        && actual.every((value, index) => value === expected[index]);
+}
+async function canonicalSourceLedger(sourceEvents) {
+    const result = [];
+    for (const source of sourceEvents) {
+        if (typeof source.hardFact !== "boolean" || typeof source.externalIrreversible !== "boolean") {
+            throw new Error("tmw_rewrite_source_event_flags_invalid");
+        }
+        const event = await verifyTemporalRewriteEvent({
+            eventId: source.eventId,
+            eventType: source.eventType,
+            effectiveWorldTime: source.effectiveWorldTime,
+            capabilityIds: source.capabilityIds,
+            payload: source.payload,
+            payloadHash: source.payloadHash,
+            replacementOf: source.replacementOf,
+        });
+        result.push(Object.freeze({
+            ...event,
+            hardFact: source.hardFact,
+            externalIrreversible: source.externalIrreversible,
+        }));
+    }
+    const eventIds = result.map((event) => event.eventId);
+    if (new Set(eventIds).size !== eventIds.length) {
+        throw new Error("tmw_rewrite_source_event_id_duplicate");
+    }
+    const ordered = [...result].sort(compareEvents);
+    if (!exactOrderedIds(eventIds, ordered.map((event) => event.eventId))) {
+        throw new Error("tmw_rewrite_source_ledger_order_invalid");
+    }
+    return Object.freeze(result);
+}
+function eventLedgerDigestImage(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 projectedEventDigestImage(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,
+    })), "rewrite_projected_events");
+}
+function canonicalSemanticVerdicts(input) {
+    const verdicts = input.map((verdict) => {
+        if (verdict.truth !== "true" && verdict.truth !== "false" && verdict.truth !== "unknown") {
+            throw new Error("tmw_rewrite_semantic_truth_invalid");
+        }
+        return Object.freeze({
+            predicateKey: requireTmwIdentifier(verdict.predicateKey, "rewrite_semantic_predicate"),
+            truth: verdict.truth,
+        });
+    }).sort((left, right) => left.predicateKey < right.predicateKey
+        ? -1
+        : left.predicateKey > right.predicateKey
+            ? 1
+            : 0);
+    if (new Set(verdicts.map((verdict) => verdict.predicateKey)).size !== verdicts.length) {
+        throw new Error("tmw_rewrite_semantic_predicate_duplicate");
+    }
+    return Object.freeze(verdicts);
+}
+async function rejectedResult(input) {
+    return Object.freeze({
+        status: "rejected",
+        reasonCodes: Object.freeze([...input.reasons].sort()),
+        sourceTimelineRevision: input.draft.timelineRevision,
+        sourceEventLedgerDigest: input.sourceEventLedgerDigest,
+        projectedEvents: Object.freeze([]),
+        projectedEventSetDigest: await tmwSha256Hex(canonicalTmwJson([])),
+        retainedHardFactIds: Object.freeze([...input.retainedHardFactIds]),
+        droppedEventIds: Object.freeze([...input.droppedEventIds]),
+        affectedEventIds: Object.freeze([...input.affectedEventIds]),
+        externalEffectsRequiringCompensation: Object.freeze([
+            ...input.externalEffectsRequiringCompensation,
+        ]),
+        projection: null,
+        savCandidate: null,
+        successorInputs: null,
+    });
+}
+export async function replayTemporalRewriteIsolated(input) {
+    const draft = await verifyTemporalRewriteDraft(input.draft);
+    const sourceEvents = await canonicalSourceLedger(input.sourceEvents);
+    const claimedSourceLedgerDigest = requireTmwSha256(input.sourceEventLedgerDigest, "rewrite_source_event_ledger_digest");
+    const computedSourceLedgerDigest = await tmwSha256Hex(canonicalTmwJson(eventLedgerDigestImage(sourceEvents)));
+    const sourceRevisionSequence = requireTmwSafeInteger(input.sourceRevisionSequence, "rewrite_source_revision_sequence");
+    if (sourceRevisionSequence === Number.MAX_SAFE_INTEGER) {
+        throw new Error("tmw_rewrite_revision_sequence_exhausted");
+    }
+    const worldlineId = requireTmwIdentifier(input.worldlineId, "rewrite_worldline_id");
+    const semanticVerdicts = canonicalSemanticVerdicts(input.semanticVerdicts);
+    const budget = Object.freeze({
+        maxEvents: requireTmwSafeInteger(input.budget.maxEvents, "replay_max_events", 1),
+        maxEffects: requireTmwSafeInteger(input.budget.maxEffects, "replay_max_effects", 1),
+        maxDepth: requireTmwSafeInteger(input.budget.maxDepth, "replay_max_depth", 1),
+        deadlineEpochMs: requireTmwSafeInteger(input.budget.deadlineEpochMs, "replay_deadline_epoch_ms", 1),
+    });
+    const now = requireTmwSafeInteger(input.nowEpochMs, "replay_now_epoch_ms");
+    const reasons = new Set();
+    if (computedSourceLedgerDigest !== claimedSourceLedgerDigest) {
+        reasons.add("rewrite_source_ledger_digest_mismatch");
+    }
+    if (now >= budget.deadlineEpochMs)
+        reasons.add("rewrite_budget_deadline_exhausted");
+    if (sourceEvents.length + draft.events.length > budget.maxEvents) {
+        reasons.add("rewrite_event_budget_exhausted");
+    }
+    if (draft.events.some((event) => event.replacementOf.length > budget.maxDepth)) {
+        reasons.add("rewrite_depth_budget_exhausted");
+    }
+    if (sourceEvents.some((event) => event.effectiveWorldTime > draft.interval.toWorldTime)) {
+        reasons.add("rewrite_source_event_outside_interval");
+    }
+    const knownEvidenceRefs = input.knownEvidenceRefs.map((ref) => requireTmwIdentifier(ref, "replay_evidence_ref"));
+    if (new Set(knownEvidenceRefs).size !== knownEvidenceRefs.length) {
+        throw new Error("tmw_rewrite_known_evidence_ref_duplicate");
+    }
+    const evidence = new Set(knownEvidenceRefs);
+    if (draft.evidenceRefs.some((ref) => !evidence.has(ref))) {
+        reasons.add("rewrite_evidence_ref_missing");
+    }
+    if (semanticVerdicts.some((verdict) => verdict.truth === "unknown")) {
+        reasons.add("rewrite_semantic_unknown");
+    }
+    if (semanticVerdicts.some((verdict) => verdict.truth === "false")) {
+        reasons.add("rewrite_semantic_rejected");
+    }
+    const sourceById = new Map(sourceEvents.map((event) => [event.eventId, event]));
+    const draftIds = new Set(draft.events.map((event) => event.eventId));
+    if (draft.events.some((event) => sourceById.has(event.eventId))) {
+        reasons.add("rewrite_source_replacement_event_id_collision");
+    }
+    if (draft.replacedEventIds.some((eventId) => !sourceById.has(eventId))) {
+        reasons.add("rewrite_replaced_event_missing");
+    }
+    if (draft.replacedEventIds.some((eventId) => {
+        const event = sourceById.get(eventId);
+        return event !== undefined
+            && (event.effectiveWorldTime < draft.interval.fromWorldTime
+                || event.effectiveWorldTime > draft.interval.toWorldTime);
+    })) {
+        reasons.add("rewrite_replaced_event_outside_interval");
+    }
+    const replacementClaims = new Set(draft.events.flatMap((event) => event.replacementOf));
+    if (draft.replacedEventIds.some((eventId) => !replacementClaims.has(eventId))) {
+        reasons.add("rewrite_replacement_lineage_missing");
+    }
+    const replaced = new Set(draft.replacedEventIds);
+    const dropped = sourceEvents.filter((event) => event.effectiveWorldTime > draft.interval.targetWorldTime || replaced.has(event.eventId));
+    const droppedEventIds = dropped.map((event) => event.eventId).sort();
+    const affectedEventIds = Object.freeze([...droppedEventIds]);
+    const retained = sourceEvents.filter((event) => !droppedEventIds.includes(event.eventId));
+    const retainedHardFactIds = sourceEvents
+        .filter((event) => event.hardFact && !droppedEventIds.includes(event.eventId))
+        .map((event) => event.eventId)
+        .sort();
+    const droppedHardFacts = dropped.filter((event) => event.hardFact);
+    if (droppedHardFacts.some((event) => !replaced.has(event.eventId))) {
+        reasons.add("rewrite_hard_fact_drop_undeclared");
+    }
+    if (droppedHardFacts.some((event) => !replacementClaims.has(event.eventId))) {
+        reasons.add("rewrite_hard_fact_replacement_missing");
+    }
+    const irreversible = dropped
+        .filter((event) => event.externalIrreversible)
+        .map((event) => event.eventId)
+        .sort();
+    const proposalIds = draft.compensationProposals
+        .map((proposal) => proposal.externalEffectId)
+        .sort();
+    if (irreversible.some((eventId) => !proposalIds.includes(eventId))) {
+        reasons.add("rewrite_external_compensation_missing");
+    }
+    if (proposalIds.some((eventId) => !irreversible.includes(eventId))) {
+        reasons.add("rewrite_external_compensation_unbound");
+    }
+    const projectedEvents = [...retained, ...draft.events].sort(compareEvents);
+    if (new Set(projectedEvents.map((event) => event.eventId)).size !== projectedEvents.length
+        || draftIds.size !== draft.events.length) {
+        reasons.add("rewrite_projected_event_duplicate");
+    }
+    const allowedCapabilityIds = input.allowedCapabilityIds.map((id) => requireTmwIdentifier(id, "replay_capability_id"));
+    if (new Set(allowedCapabilityIds).size !== allowedCapabilityIds.length) {
+        throw new Error("tmw_rewrite_allowed_capability_duplicate");
+    }
+    const allowedCapabilities = new Set(allowedCapabilityIds);
+    if (projectedEvents.some((event) => event.capabilityIds.some((capabilityId) => !allowedCapabilities.has(capabilityId)))) {
+        reasons.add("rewrite_capability_forbidden");
+    }
+    const effectCount = projectedEvents.reduce((total, event) => total + event.capabilityIds.length, 0);
+    if (effectCount > budget.maxEffects)
+        reasons.add("rewrite_effect_budget_exhausted");
+    if (reasons.size !== 0) {
+        return await rejectedResult({
+            draft,
+            sourceEventLedgerDigest: computedSourceLedgerDigest,
+            reasons,
+            retainedHardFactIds,
+            droppedEventIds,
+            affectedEventIds,
+            externalEffectsRequiringCompensation: irreversible,
+        });
+    }
+    const projectedEventImage = projectedEventDigestImage(projectedEvents);
+    const projectedEventSetDigest = await tmwSha256Hex(canonicalTmwJson(projectedEventImage));
+    const successorSeedDigest = await tmwSha256Hex(canonicalTmwJson({
+        epoch: draft.epoch,
+        runtimeContractHash: draft.runtimeContractHash,
+        artifactDigest: draft.artifactDigest,
+        sourceRevision: draft.sourceRevision,
+        sourceTimelineRevision: draft.timelineRevision,
+        sourceRevisionSequence,
+        worldlineId,
+        operationId: draft.operationId,
+        draftDigest: draft.draftDigest,
+        sourceEventLedgerDigest: computedSourceLedgerDigest,
+        targetWorldTime: draft.interval.targetWorldTime,
+        projectedEventSetDigest,
+        compensationProposals: draft.compensationProposals,
+    }));
+    const targetTimelineRevision = requireTmwIdentifier(`tmw3-rewrite-${successorSeedDigest}`, "rewrite_target_timeline_revision");
+    const compensation = await createRewriteCompensationReceipts({
+        operationId: draft.operationId,
+        sourceTimelineRevision: draft.timelineRevision,
+        targetTimelineRevision,
+        proposals: draft.compensationProposals,
+    });
+    const projectionImage = canonicalTmwJsonValue({
+        schemaVersion: 3,
+        sourceEventLedgerDigest: computedSourceLedgerDigest,
+        sourceTimelineRevision: draft.timelineRevision,
+        targetTimelineRevision,
+        targetWorldTime: draft.interval.targetWorldTime,
+        retainedEventIds: retained.map((event) => event.eventId).sort(),
+        droppedEventIds,
+        affectedEventIds,
+        events: projectedEvents,
+        compensationReceipts: compensation.receipts,
+        compensationReceiptSetDigest: compensation.receiptSetDigest,
+    }, "rewrite_projection");
+    const ledgerDigest = await tmwSha256Hex(canonicalTmwJson(projectionImage));
+    const projection = Object.freeze({
+        ...projectionImage,
+        ledgerDigest,
+    });
+    const compensationReceiptDigests = Object.freeze(compensation.receipts.map((receipt) => receipt.receiptDigest));
+    const savCandidateImage = canonicalTmwJsonValue({
+        schemaVersion: 3,
+        sourceTimelineRevision: draft.timelineRevision,
+        targetTimelineRevision,
+        targetWorldTime: draft.interval.targetWorldTime,
+        projectedLedgerDigest: ledgerDigest,
+        compensationReceipts: compensation.receipts,
+        compensationReceiptDigests,
+    }, "rewrite_sav_candidate");
+    const savCandidate = Object.freeze({
+        ...savCandidateImage,
+        candidateDigest: await tmwSha256Hex(canonicalTmwJson(savCandidateImage)),
+    });
+    const successorImage = canonicalTmwJsonValue({
+        revisionId: targetTimelineRevision,
+        parentRevisionId: draft.timelineRevision,
+        revisionSequence: sourceRevisionSequence + 1,
+        worldlineId,
+        operationId: draft.operationId,
+        createdFrom: "temporal_rewrite",
+        targetWorldTime: draft.interval.targetWorldTime,
+        ledgerHead: ledgerDigest,
+        narrativeDigest: draft.narrativeDigest,
+        compensationReceiptSetDigest: compensation.receiptSetDigest,
+        savCandidateDigest: savCandidate.candidateDigest,
+    }, "rewrite_successor_inputs");
+    const successorInputs = Object.freeze({
+        ...successorImage,
+        successorInputDigest: await tmwSha256Hex(canonicalTmwJson(successorImage)),
+    });
+    return Object.freeze({
+        status: "passed",
+        reasonCodes: Object.freeze([]),
+        sourceTimelineRevision: draft.timelineRevision,
+        sourceEventLedgerDigest: computedSourceLedgerDigest,
+        projectedEvents: Object.freeze(projectedEvents),
+        projectedEventSetDigest,
+        retainedHardFactIds: Object.freeze(retainedHardFactIds),
+        droppedEventIds: Object.freeze(droppedEventIds),
+        affectedEventIds,
+        externalEffectsRequiringCompensation: Object.freeze(irreversible),
+        projection,
+        savCandidate,
+        successorInputs,
+    });
+}

package/dist/music-candidate-set.d.ts

@@ -0,0 +1,38 @@
+import { TMW_RUNTIME_GENERATION } from "./runtime-contract.js";
+export type MusicEligibilityPolicyV3 = "normal" | "override_only";
+export interface MusicCandidateV3 {
+    readonly resource_id: string;
+    readonly policy: MusicEligibilityPolicyV3;
+    readonly continuity_key?: string;
+}
+/** ArtifactV5 编译器消费的资源资格 source；运行时 binding/revision 不由作者输入。 */
+export interface MusicCandidateSourceV3 {
+    readonly schema: "music-candidate-source.v3";
+    readonly generation: typeof TMW_RUNTIME_GENERATION;
+    readonly candidates: ReadonlyArray<MusicCandidateV3>;
+}
+export interface MusicCandidateSetV3 {
+    readonly schema: "music-candidate-set.v3";
+    readonly generation: typeof TMW_RUNTIME_GENERATION;
+    readonly candidate_set_id: string;
+    readonly revision: number;
+    readonly eligibility_revision: number;
+    readonly epoch: number;
+    readonly artifact_digest: string;
+    readonly timeline_revision: string;
+    readonly candidates: ReadonlyArray<MusicCandidateV3>;
+}
+export interface MusicCandidateSetBindingV3 {
+    readonly candidate_set_id: string;
+    readonly revision: number;
+    readonly eligibility_revision: number;
+    readonly epoch: number;
+    readonly artifact_digest: string;
+    readonly timeline_revision: string;
+}
+export declare const parseMusicCandidateSourceV3: (value: unknown) => MusicCandidateSourceV3 | null;
+/** Materializes author-owned candidates under a committed host-owned revision. */
+export declare const materializeMusicCandidateSetV3: (sourceInput: unknown, binding: MusicCandidateSetBindingV3) => MusicCandidateSetV3 | null;
+export declare const musicCandidateSetError: (set: MusicCandidateSetV3) => string | null;
+export declare const containsMusicCandidate: (set: MusicCandidateSetV3, resourceId: string, allowOverride: boolean) => boolean;
+export declare const selectMusicCandidate: (set: MusicCandidateSetV3, preferredResourceId: string | null, allowOverride: boolean) => string | null;

package/dist/music-candidate-set.js

@@ -0,0 +1,102 @@
+import { TMW_RUNTIME_GENERATION } from "./runtime-contract.js";
+const SHA256_HEX = /^[a-f0-9]{64}$/;
+const STABLE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const MAX_CANDIDATES = 512;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const exactKeys = (value, keys) => Object.keys(value).sort().join("\0") === [...keys].sort().join("\0");
+const parseCandidate = (value) => {
+    if (!isRecord(value))
+        return null;
+    const keys = value.continuity_key === undefined
+        ? ["policy", "resource_id"]
+        : ["continuity_key", "policy", "resource_id"];
+    if (!exactKeys(value, keys))
+        return null;
+    if (typeof value.resource_id !== "string" || !STABLE_ID.test(value.resource_id))
+        return null;
+    if (value.policy !== "normal" && value.policy !== "override_only")
+        return null;
+    if (value.continuity_key !== undefined
+        && (typeof value.continuity_key !== "string" || !STABLE_ID.test(value.continuity_key)))
+        return null;
+    return value;
+};
+export const parseMusicCandidateSourceV3 = (value) => {
+    if (!isRecord(value) || !exactKeys(value, ["candidates", "generation", "schema"]))
+        return null;
+    if (value.schema !== "music-candidate-source.v3" || value.generation !== 3)
+        return null;
+    if (!Array.isArray(value.candidates) || value.candidates.length > MAX_CANDIDATES)
+        return null;
+    const candidates = value.candidates.map(parseCandidate);
+    if (!candidates.every((candidate) => candidate !== null))
+        return null;
+    const ids = new Set(candidates.map((candidate) => candidate.resource_id));
+    if (ids.size !== candidates.length)
+        return null;
+    return value;
+};
+/** Materializes author-owned candidates under a committed host-owned revision. */
+export const materializeMusicCandidateSetV3 = (sourceInput, binding) => {
+    const source = parseMusicCandidateSourceV3(sourceInput);
+    if (source === null)
+        return null;
+    const set = Object.freeze({
+        schema: "music-candidate-set.v3",
+        generation: TMW_RUNTIME_GENERATION,
+        candidate_set_id: binding.candidate_set_id,
+        revision: binding.revision,
+        eligibility_revision: binding.eligibility_revision,
+        epoch: binding.epoch,
+        artifact_digest: binding.artifact_digest,
+        timeline_revision: binding.timeline_revision,
+        candidates: Object.freeze(source.candidates.map((candidate) => Object.freeze({ ...candidate })))
+    });
+    return musicCandidateSetError(set) === null ? set : null;
+};
+export const musicCandidateSetError = (set) => {
+    if (set.schema !== "music-candidate-set.v3" || set.generation !== 3)
+        return "music_candidate_set_generation_invalid";
+    if (!STABLE_ID.test(set.candidate_set_id))
+        return "music_candidate_set_id_invalid";
+    if (!Number.isSafeInteger(set.revision) || set.revision <= 0)
+        return "music_candidate_set_revision_invalid";
+    if (!Number.isSafeInteger(set.eligibility_revision) || set.eligibility_revision <= 0) {
+        return "music_eligibility_revision_invalid";
+    }
+    if (!Number.isSafeInteger(set.epoch) || set.epoch <= 0)
+        return "content_epoch_required";
+    if (!SHA256_HEX.test(set.artifact_digest))
+        return "music_candidate_artifact_invalid";
+    if (!STABLE_ID.test(set.timeline_revision)) {
+        return "music_candidate_timeline_revision_invalid";
+    }
+    if (set.candidates.length > MAX_CANDIDATES)
+        return "music_candidate_set_limit_exceeded";
+    const ids = new Set();
+    for (const candidate of set.candidates) {
+        if (!STABLE_ID.test(candidate.resource_id) || ids.has(candidate.resource_id))
+            return "music_candidate_resource_invalid";
+        if (candidate.policy !== "normal" && candidate.policy !== "override_only")
+            return "music_candidate_policy_invalid";
+        if (candidate.continuity_key !== undefined && !STABLE_ID.test(candidate.continuity_key)) {
+            return "music_candidate_continuity_key_invalid";
+        }
+        ids.add(candidate.resource_id);
+    }
+    return null;
+};
+export const containsMusicCandidate = (set, resourceId, allowOverride) => {
+    if (musicCandidateSetError(set) !== null)
+        return false;
+    const candidate = set.candidates.find((item) => item.resource_id === resourceId);
+    return candidate !== undefined && (candidate.policy === "normal" || allowOverride);
+};
+export const selectMusicCandidate = (set, preferredResourceId, allowOverride) => {
+    if (musicCandidateSetError(set) !== null || set.candidates.length === 0)
+        return null;
+    if (preferredResourceId !== null) {
+        return containsMusicCandidate(set, preferredResourceId, allowOverride) ? preferredResourceId : null;
+    }
+    return set.candidates.find((candidate) => candidate.policy === "normal" || allowOverride)?.resource_id ?? null;
+};