@world-engines/tmw 0.1.0-alpha.0

package/dist/compiler-stage-cache.d.ts

@@ -0,0 +1,42 @@
+import type { TmwDiagnostic } from "./diagnostics.js";
+export interface CompilerStageCacheIdentity {
+    readonly scenario_id: string;
+    readonly source_manifest_sha256: string;
+    readonly stage_id: string;
+    readonly stage_version: string;
+    readonly target_profile_sha256: string;
+    readonly section_sha256s: readonly Readonly<{
+        section_key: string;
+        sha256: string;
+    }>[];
+    readonly dependency_sha256s: readonly Readonly<{
+        stage_id: string;
+        sha256: string;
+    }>[];
+}
+export type CompilerStageContentCacheIdentity = Omit<CompilerStageCacheIdentity, "source_manifest_sha256">;
+export interface CompilerStageCacheEntry {
+    readonly cache_key: string;
+    readonly bytes: Uint8Array;
+    readonly output_sha256: string;
+    readonly diagnostics: readonly TmwDiagnostic[];
+}
+export interface CompilerStageCache {
+    read(cacheKey: string): Promise<CompilerStageCacheEntry | null>;
+    writeOnce(entry: CompilerStageCacheEntry): Promise<"stored" | "already_present">;
+    delete(cacheKey: string): Promise<void>;
+}
+export declare function compilerStageCacheKey(identity: CompilerStageCacheIdentity): Promise<string>;
+/**
+ * Reusable stage-output identity. The complete receipt still records
+ * `compilerStageCacheKey`, which binds the captured manifest; storage lookup
+ * omits that aggregate digest so an unchanged section can survive an
+ * unrelated-section edit.
+ */
+export declare function compilerStageContentCacheKey(identity: CompilerStageContentCacheIdentity): Promise<string>;
+export declare class InMemoryCompilerStageCache implements CompilerStageCache {
+    #private;
+    read(cacheKey: string): Promise<CompilerStageCacheEntry | null>;
+    writeOnce(entry: CompilerStageCacheEntry): Promise<"stored" | "already_present">;
+    delete(cacheKey: string): Promise<void>;
+}

package/dist/compiler-stage-cache.js

@@ -0,0 +1,100 @@
+import { canonicalTmwBytes, isSha256Hex, tmwSha256Hex } from "./runtime-contract.js";
+function compareAscii(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export async function compilerStageCacheKey(identity) {
+    if (identity.scenario_id.length === 0
+        || identity.scenario_id !== identity.scenario_id.trim().normalize("NFC")
+        || !isSha256Hex(identity.source_manifest_sha256)
+        || !isSha256Hex(identity.target_profile_sha256)
+        || identity.section_sha256s.some((section) => !isSha256Hex(section.sha256))
+        || identity.dependency_sha256s.some((stage) => !isSha256Hex(stage.sha256)))
+        throw new Error("compiler_stage_cache_identity_invalid");
+    return tmwSha256Hex(canonicalTmwBytes({
+        scenario_id: identity.scenario_id,
+        source_manifest_sha256: identity.source_manifest_sha256,
+        stage_id: identity.stage_id,
+        stage_version: identity.stage_version,
+        target_profile_sha256: identity.target_profile_sha256,
+        section_sha256s: [...identity.section_sha256s]
+            .sort((left, right) => compareAscii(left.section_key, right.section_key)),
+        dependency_sha256s: [...identity.dependency_sha256s]
+            .sort((left, right) => compareAscii(left.stage_id, right.stage_id)),
+    }));
+}
+/**
+ * Reusable stage-output identity. The complete receipt still records
+ * `compilerStageCacheKey`, which binds the captured manifest; storage lookup
+ * omits that aggregate digest so an unchanged section can survive an
+ * unrelated-section edit.
+ */
+export async function compilerStageContentCacheKey(identity) {
+    if (identity.scenario_id.length === 0
+        || identity.scenario_id !== identity.scenario_id.trim().normalize("NFC")
+        || !isSha256Hex(identity.target_profile_sha256)
+        || identity.section_sha256s.some((section) => !isSha256Hex(section.sha256))
+        || identity.dependency_sha256s.some((stage) => !isSha256Hex(stage.sha256)))
+        throw new Error("compiler_stage_content_cache_identity_invalid");
+    return tmwSha256Hex(canonicalTmwBytes({
+        scenario_id: identity.scenario_id,
+        stage_id: identity.stage_id,
+        stage_version: identity.stage_version,
+        target_profile_sha256: identity.target_profile_sha256,
+        section_sha256s: [...identity.section_sha256s]
+            .sort((left, right) => compareAscii(left.section_key, right.section_key)),
+        dependency_sha256s: [...identity.dependency_sha256s]
+            .sort((left, right) => compareAscii(left.stage_id, right.stage_id)),
+    }));
+}
+function cloneDiagnostic(diagnostic) {
+    return Object.freeze({
+        ...diagnostic,
+        related_stable_ids: Object.freeze([...diagnostic.related_stable_ids]),
+    });
+}
+function cloneEntry(entry) {
+    return Object.freeze({
+        cache_key: entry.cache_key,
+        bytes: entry.bytes.slice(),
+        output_sha256: entry.output_sha256,
+        diagnostics: Object.freeze(entry.diagnostics.map(cloneDiagnostic)),
+    });
+}
+function bytesEqual(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return difference === 0;
+}
+export class InMemoryCompilerStageCache {
+    #entries = new Map();
+    async read(cacheKey) {
+        const entry = this.#entries.get(cacheKey);
+        return entry === undefined ? null : cloneEntry(entry);
+    }
+    async writeOnce(entry) {
+        if (!isSha256Hex(entry.cache_key)
+            || !isSha256Hex(entry.output_sha256)
+            || entry.diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+            throw new Error("compiler_stage_cache_entry_invalid");
+        const observedHash = await tmwSha256Hex(entry.bytes);
+        if (observedHash !== entry.output_sha256) {
+            throw new Error("compiler_stage_cache_entry_hash_mismatch");
+        }
+        const existing = this.#entries.get(entry.cache_key);
+        if (existing !== undefined) {
+            if (existing.output_sha256 !== entry.output_sha256
+                || !bytesEqual(existing.bytes, entry.bytes))
+                throw new Error("compiler_stage_cache_write_conflict");
+            return "already_present";
+        }
+        this.#entries.set(entry.cache_key, cloneEntry(entry));
+        return "stored";
+    }
+    async delete(cacheKey) {
+        this.#entries.delete(cacheKey);
+    }
+}

package/dist/compiler-stage-registry.d.ts

@@ -0,0 +1,48 @@
+import type { CompileTargetProfile } from "./compile-target-profile.js";
+import type { TmwDiagnostic } from "./diagnostics.js";
+export interface NeutralCompilerSection {
+    readonly section_key: string;
+    readonly media_type: string;
+    readonly canonical_encoding: string;
+    readonly byte_length: number;
+    readonly sha256: string;
+    readonly payload_bytes: Uint8Array;
+}
+export interface CompilerStageDependencyOutput {
+    readonly stage_id: string;
+    readonly stage_version: string;
+    readonly bytes: Uint8Array;
+    readonly sha256: string;
+}
+export interface CompilerStageExecutionInput {
+    readonly scenario_id: string;
+    readonly target_profile: CompileTargetProfile;
+    readonly target_profile_sha256: string;
+    readonly sections: readonly NeutralCompilerSection[];
+    readonly dependency_outputs: readonly CompilerStageDependencyOutput[];
+}
+export type CompilerStageExecutionResult = {
+    readonly ok: true;
+    readonly bytes: Uint8Array;
+    readonly diagnostics: readonly TmwDiagnostic[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly TmwDiagnostic[];
+};
+export interface CompilerStageDescriptor {
+    readonly stage_id: string;
+    readonly stage_version: string;
+    readonly section_keys: readonly string[];
+    readonly depends_on: readonly string[];
+}
+export interface CompilerStage {
+    readonly descriptor: CompilerStageDescriptor;
+    execute(input: CompilerStageExecutionInput): Promise<CompilerStageExecutionResult>;
+}
+export interface CompilerStageRegistry {
+    readonly stages: readonly CompilerStage[];
+}
+export declare function buildCompilerStageRegistry(stages: readonly CompilerStage[]): CompilerStageRegistry;
+export declare function compilerStageById(registry: CompilerStageRegistry, stageId: string): CompilerStage | undefined;
+export declare function assertRegistryMatchesTargetProfile(registry: CompilerStageRegistry, profile: CompileTargetProfile): void;
+export declare function createPassThroughCompilerStage(descriptor: CompilerStageDescriptor): CompilerStage;

package/dist/compiler-stage-registry.js

@@ -0,0 +1,126 @@
+const IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/u;
+const SECTION_KEY_PATTERN = /^[a-z][a-z0-9_.-]{0,127}$/u;
+function requireIdentifier(value, code) {
+    if (!IDENTIFIER_PATTERN.test(value) || value !== value.normalize("NFC"))
+        throw new Error(code);
+}
+function requireUnique(values, code) {
+    if (new Set(values).size !== values.length)
+        throw new Error(code);
+}
+function normalizeStage(stage) {
+    const descriptor = stage.descriptor;
+    requireIdentifier(descriptor.stage_id, `compiler_stage_id_invalid:${descriptor.stage_id}`);
+    requireIdentifier(descriptor.stage_version, `compiler_stage_version_invalid:${descriptor.stage_id}`);
+    if (descriptor.section_keys.length === 0) {
+        throw new Error(`compiler_stage_sections_required:${descriptor.stage_id}`);
+    }
+    for (const key of descriptor.section_keys) {
+        if (!SECTION_KEY_PATTERN.test(key) || key !== key.normalize("NFC")) {
+            throw new Error(`compiler_stage_section_key_invalid:${descriptor.stage_id}`);
+        }
+    }
+    for (const dependency of descriptor.depends_on) {
+        requireIdentifier(dependency, `compiler_stage_dependency_invalid:${descriptor.stage_id}`);
+    }
+    requireUnique(descriptor.section_keys, `compiler_stage_section_key_duplicate:${descriptor.stage_id}`);
+    requireUnique(descriptor.depends_on, `compiler_stage_dependency_duplicate:${descriptor.stage_id}`);
+    if (descriptor.depends_on.includes(descriptor.stage_id)) {
+        throw new Error(`compiler_stage_self_dependency:${descriptor.stage_id}`);
+    }
+    return Object.freeze({
+        descriptor: Object.freeze({
+            stage_id: descriptor.stage_id,
+            stage_version: descriptor.stage_version,
+            section_keys: Object.freeze([...descriptor.section_keys].sort()),
+            depends_on: Object.freeze([...descriptor.depends_on].sort()),
+        }),
+        execute: stage.execute.bind(stage),
+    });
+}
+export function buildCompilerStageRegistry(stages) {
+    if (stages.length === 0)
+        throw new Error("compiler_stage_registry_empty");
+    const normalized = stages.map(normalizeStage);
+    requireUnique(normalized.map((stage) => stage.descriptor.stage_id), "compiler_stage_id_duplicate");
+    const byId = new Map(normalized.map((stage) => [stage.descriptor.stage_id, stage]));
+    for (const stage of normalized) {
+        for (const dependency of stage.descriptor.depends_on) {
+            if (!byId.has(dependency)) {
+                throw new Error(`compiler_stage_dependency_missing:${stage.descriptor.stage_id}:${dependency}`);
+            }
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const ordered = [];
+    const visit = (stageId) => {
+        if (visiting.has(stageId))
+            throw new Error(`compiler_stage_dependency_cycle:${stageId}`);
+        if (visited.has(stageId))
+            return;
+        visiting.add(stageId);
+        const stage = byId.get(stageId);
+        if (stage === undefined)
+            throw new Error(`compiler_stage_missing:${stageId}`);
+        for (const dependency of stage.descriptor.depends_on)
+            visit(dependency);
+        visiting.delete(stageId);
+        visited.add(stageId);
+        ordered.push(stage);
+    };
+    for (const stageId of [...byId.keys()].sort())
+        visit(stageId);
+    return Object.freeze({ stages: Object.freeze(ordered) });
+}
+export function compilerStageById(registry, stageId) {
+    return registry.stages.find((stage) => stage.descriptor.stage_id === stageId);
+}
+export function assertRegistryMatchesTargetProfile(registry, profile) {
+    const profileVersions = new Map(profile.stage_versions.map((stage) => [stage.stage_id, stage.stage_version]));
+    if (profileVersions.size !== registry.stages.length) {
+        throw new Error("compile_target_stage_set_mismatch");
+    }
+    for (const stage of registry.stages) {
+        if (profileVersions.get(stage.descriptor.stage_id) !== stage.descriptor.stage_version) {
+            throw new Error(`compile_target_stage_version_mismatch:${stage.descriptor.stage_id}`);
+        }
+    }
+}
+export function createPassThroughCompilerStage(descriptor) {
+    if (descriptor.section_keys.length !== 1 || descriptor.depends_on.length !== 0) {
+        throw new Error("pass_through_stage_descriptor_invalid");
+    }
+    const sectionKey = descriptor.section_keys[0];
+    if (sectionKey === undefined)
+        throw new Error("pass_through_stage_descriptor_invalid");
+    const stableDescriptor = Object.freeze({
+        stage_id: descriptor.stage_id,
+        stage_version: descriptor.stage_version,
+        section_keys: Object.freeze([sectionKey]),
+        depends_on: Object.freeze([]),
+    });
+    return {
+        descriptor: stableDescriptor,
+        async execute(input) {
+            const section = input.sections.find((candidate) => candidate.section_key === sectionKey);
+            if (section === undefined) {
+                return {
+                    ok: false,
+                    diagnostics: Object.freeze([{
+                            severity: "error",
+                            code: "compiler_stage_section_missing",
+                            path: `$/sections/${sectionKey}`,
+                            message: "compiler stage input section is missing",
+                            related_stable_ids: Object.freeze([]),
+                        }]),
+                };
+            }
+            return Object.freeze({
+                ok: true,
+                bytes: section.payload_bytes.slice(),
+                diagnostics: Object.freeze([]),
+            });
+        },
+    };
+}

package/dist/compiler.d.ts

@@ -0,0 +1,7 @@
+import type { CanonicalTmwCapabilityRegistryV3 } from "./capability-registry.js";
+import type { CompileTmw3Result } from "./compiled-plan.js";
+import { type TriggerDocumentV3 } from "./trigger-document-v3.js";
+import { type TmwRuntimeCapabilityTarget } from "./runtime-domain-capabilities.js";
+export declare function compileTmw3(value: TriggerDocumentV3 | unknown, registry: CanonicalTmwCapabilityRegistryV3, options?: Readonly<{
+    runtime_target?: TmwRuntimeCapabilityTarget;
+}>): Promise<CompileTmw3Result>;

package/dist/compiler.js

@@ -0,0 +1,68 @@
+import { canonicalTmwBytes, canonicalTmwJson, tmwSha256Hex, TMW_COMPILED_PLAN_VERSION, TMW_RUNTIME_GENERATION } from "./runtime-contract.js";
+import { allTriggerNodesV3 } from "./trigger-document-v3.js";
+import { compareTmwEffectiveTime } from "./time-domains.js";
+import { validateTmw3 } from "./validator.js";
+import { tmwDiagnostic } from "./diagnostics.js";
+import { tmwRuntimeProducesClockDomain } from "./runtime-domain-capabilities.js";
+function nodeKind(node) {
+    return node.kind;
+}
+export async function compileTmw3(value, registry, options = {}) {
+    const validated = await validateTmw3(value, registry);
+    if (!validated.ok)
+        return validated;
+    const document = validated.value;
+    const runtimeTarget = options.runtime_target ?? "production";
+    const unsupportedDomains = allTriggerNodesV3(document)
+        .filter((node) => !tmwRuntimeProducesClockDomain(runtimeTarget, node.effective_time.domain))
+        .map((node) => tmwDiagnostic("clock_domain_producer_unavailable", `$/nodes/${node.stable_id}/effective_time/domain`, `runtime target ${runtimeTarget} has no producer for clock domain ${node.effective_time.domain}`, [node.stable_id]));
+    if (unsupportedDomains.length > 0)
+        return Object.freeze({ ok: false, diagnostics: Object.freeze(unsupportedDomains) });
+    const executableNodes = allTriggerNodesV3(document).filter((node) => node.enabled !== false);
+    const executableIds = new Set(executableNodes.map((node) => node.stable_id));
+    const executableEdges = document.edges.filter((edge) => executableIds.has(edge.from_stable_id) && executableIds.has(edge.to_stable_id));
+    const dependencies = new Map();
+    for (const node of executableNodes)
+        dependencies.set(node.stable_id, []);
+    for (const edge of executableEdges)
+        dependencies.get(edge.to_stable_id)?.push(edge.from_stable_id);
+    const nodes = executableNodes.map((node) => {
+        const base = {
+            stable_id: node.stable_id,
+            kind: nodeKind(node),
+            effective_time: node.effective_time,
+            dependencies: Object.freeze([...(dependencies.get(node.stable_id) ?? [])].sort()),
+            canonical_payload: JSON.parse(canonicalTmwJson(node)),
+        };
+        return node.kind === "effect"
+            ? Object.freeze({
+                ...base,
+                kind: "effect",
+                execution_policy: node.execution_policy,
+                rewrite_policy: node.rewrite_policy,
+                priority: node.priority,
+                idempotency_key: node.idempotency_key,
+            })
+            : Object.freeze({ ...base, kind: node.kind });
+    }).sort((left, right) => compareTmwEffectiveTime(left.effective_time, right.effective_time)
+        || left.stable_id.localeCompare(right.stable_id));
+    const edges = [...executableEdges].sort((left, right) => left.from_stable_id.localeCompare(right.from_stable_id)
+        || left.to_stable_id.localeCompare(right.to_stable_id));
+    const documentSha256 = await tmwSha256Hex(canonicalTmwBytes(document));
+    const core = Object.freeze({
+        plan_version: TMW_COMPILED_PLAN_VERSION,
+        runtime_generation: TMW_RUNTIME_GENERATION,
+        runtime_contract_hash: document.runtime_contract_hash,
+        registry_version: document.registry_version,
+        document_sha256: documentSha256,
+        nodes: Object.freeze(nodes),
+        edges: Object.freeze(edges),
+        ...(document.value_graph === undefined ? {} : { value_graph: Object.freeze({ ...document.value_graph, edges: Object.freeze(document.value_graph.edges.filter((edge) => executableIds.has(edge.to_node) || document.value_graph.nodes.some((node) => node.stable_id === edge.to_node))) }) }),
+    });
+    const planSha256 = await tmwSha256Hex(canonicalTmwBytes(core));
+    return Object.freeze({
+        ok: true,
+        plan: Object.freeze({ ...core, plan_sha256: planSha256 }),
+        diagnostics: validated.diagnostics,
+    });
+}

package/dist/condition-graph.d.ts

@@ -0,0 +1,46 @@
+import { type TmwJsonValue } from "./runtime-trace.js";
+export type ConditionTruth = "true" | "false" | "unknown";
+export interface ConditionLeaf {
+    readonly nodeId: string;
+    readonly kind: "leaf";
+    readonly predicateKey: string;
+}
+export interface ConditionAll {
+    readonly nodeId: string;
+    readonly kind: "all";
+    readonly children: ReadonlyArray<string>;
+}
+export interface ConditionAny {
+    readonly nodeId: string;
+    readonly kind: "any";
+    readonly children: ReadonlyArray<string>;
+}
+export interface ConditionNot {
+    readonly nodeId: string;
+    readonly kind: "not";
+    readonly child: string;
+}
+export type ConditionNode = ConditionLeaf | ConditionAll | ConditionAny | ConditionNot;
+export interface ConditionGraph {
+    readonly rootNodeId: string;
+    readonly nodes: ReadonlyArray<ConditionNode>;
+}
+export interface EvaluationSnapshot {
+    readonly snapshotHash: string;
+    readonly values: Readonly<Record<string, ConditionTruth>>;
+    readonly evidenceRefs: Readonly<Record<string, ReadonlyArray<string>>>;
+    readonly frozenFacts: TmwJsonValue;
+}
+export interface ConditionNodeEvaluation {
+    readonly nodeId: string;
+    readonly truth: ConditionTruth;
+}
+export interface ConditionEvaluationResult {
+    readonly rootNodeId: string;
+    readonly truth: ConditionTruth;
+    readonly snapshotHash: string;
+    readonly nodeResults: ReadonlyArray<ConditionNodeEvaluation>;
+    readonly unknownPredicateKeys: ReadonlyArray<string>;
+    readonly evidenceRefs: ReadonlyArray<string>;
+}
+export declare function evaluateConditionGraph(graph: ConditionGraph, snapshotInput: EvaluationSnapshot): ConditionEvaluationResult;

package/dist/condition-graph.js

@@ -0,0 +1,135 @@
+import { canonicalTmwJsonValue, requireTmwIdentifier, requireTmwSha256, } from "./runtime-trace.js";
+function combineAll(values) {
+    if (values.includes("false"))
+        return "false";
+    return values.includes("unknown") ? "unknown" : "true";
+}
+function combineAny(values) {
+    if (values.includes("true"))
+        return "true";
+    return values.includes("unknown") ? "unknown" : "false";
+}
+function invert(value) {
+    return value === "true" ? "false" : value === "false" ? "true" : "unknown";
+}
+function canonicalNode(node) {
+    const nodeId = requireTmwIdentifier(node.nodeId, "condition_node_id");
+    switch (node.kind) {
+        case "leaf": return Object.freeze({
+            nodeId,
+            kind: "leaf",
+            predicateKey: requireTmwIdentifier(node.predicateKey, "condition_predicate_key"),
+        });
+        case "not": return Object.freeze({
+            nodeId,
+            kind: "not",
+            child: requireTmwIdentifier(node.child, "condition_child"),
+        });
+        case "all":
+        case "any": {
+            if (node.children.length === 0)
+                throw new Error("tmw_condition_children_empty");
+            const children = Object.freeze(node.children.map((child) => requireTmwIdentifier(child, "condition_child")));
+            if (new Set(children).size !== children.length)
+                throw new Error("tmw_condition_child_duplicate");
+            return Object.freeze({ nodeId, kind: node.kind, children });
+        }
+    }
+}
+export function evaluateConditionGraph(graph, snapshotInput) {
+    const snapshot = Object.freeze({
+        snapshotHash: requireTmwSha256(snapshotInput.snapshotHash, "condition_snapshot_hash"),
+        values: snapshotInput.values,
+        evidenceRefs: snapshotInput.evidenceRefs,
+        frozenFacts: canonicalTmwJsonValue(snapshotInput.frozenFacts, "condition_frozen_facts"),
+    });
+    const nodes = new Map();
+    for (const input of graph.nodes) {
+        const node = canonicalNode(input);
+        if (nodes.has(node.nodeId))
+            throw new Error("tmw_condition_node_duplicate");
+        nodes.set(node.nodeId, node);
+    }
+    const rootNodeId = requireTmwIdentifier(graph.rootNodeId, "condition_root_node_id");
+    if (!nodes.has(rootNodeId))
+        throw new Error("tmw_condition_root_missing");
+    const validating = new Set();
+    const validated = new Set();
+    const validateNode = (nodeId, depth = 0) => {
+        if (depth >= 32)
+            throw new Error("tmw_condition_depth_exceeded");
+        if (validated.has(nodeId))
+            return;
+        if (validating.has(nodeId))
+            throw new Error("tmw_condition_cycle");
+        const node = nodes.get(nodeId);
+        if (node === undefined)
+            throw new Error("tmw_condition_reference_missing");
+        validating.add(nodeId);
+        if (node.kind === "not")
+            validateNode(node.child, depth + 1);
+        else if (node.kind === "all" || node.kind === "any") {
+            for (const child of node.children)
+                validateNode(child, depth + 1);
+        }
+        validating.delete(nodeId);
+        validated.add(nodeId);
+    };
+    for (const nodeId of [...nodes.keys()].sort())
+        validateNode(nodeId);
+    const visiting = new Set();
+    const evaluated = new Map();
+    const unknownKeys = new Set();
+    const evidence = new Set();
+    const visit = (nodeId, depth = 0) => {
+        if (depth >= 32)
+            throw new Error("tmw_condition_depth_exceeded");
+        const previous = evaluated.get(nodeId);
+        if (previous !== undefined)
+            return previous;
+        if (visiting.has(nodeId))
+            throw new Error("tmw_condition_cycle");
+        const node = nodes.get(nodeId);
+        if (node === undefined)
+            throw new Error("tmw_condition_reference_missing");
+        visiting.add(nodeId);
+        let truth;
+        switch (node.kind) {
+            case "leaf": {
+                truth = snapshot.values[node.predicateKey] ?? "unknown";
+                if (truth !== "true" && truth !== "false" && truth !== "unknown") {
+                    throw new Error("tmw_condition_truth_invalid");
+                }
+                if (truth === "unknown")
+                    unknownKeys.add(node.predicateKey);
+                for (const ref of snapshot.evidenceRefs[node.predicateKey] ?? []) {
+                    evidence.add(requireTmwIdentifier(ref, "condition_evidence_ref"));
+                }
+                break;
+            }
+            case "not":
+                truth = invert(visit(node.child, depth + 1));
+                break;
+            case "all":
+                truth = combineAll(node.children.map((child) => visit(child, depth + 1)));
+                break;
+            case "any":
+                truth = combineAny(node.children.map((child) => visit(child, depth + 1)));
+                break;
+        }
+        visiting.delete(nodeId);
+        evaluated.set(nodeId, truth);
+        return truth;
+    };
+    const truth = visit(rootNodeId);
+    return Object.freeze({
+        rootNodeId,
+        truth,
+        snapshotHash: snapshot.snapshotHash,
+        nodeResults: Object.freeze([...evaluated.entries()]
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([nodeId, nodeTruth]) => Object.freeze({ nodeId, truth: nodeTruth }))),
+        unknownPredicateKeys: Object.freeze([...unknownKeys].sort()),
+        evidenceRefs: Object.freeze([...evidence].sort()),
+    });
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,20 @@
+export type TmwDiagnosticSeverity = "error" | "warning";
+export interface TmwDiagnostic {
+    readonly severity: TmwDiagnosticSeverity;
+    readonly code: string;
+    readonly path: string;
+    readonly message: string;
+    readonly related_stable_ids: readonly string[];
+}
+export type TmwResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+    readonly diagnostics: readonly TmwDiagnostic[];
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly TmwDiagnostic[];
+};
+export declare function tmwDiagnostic(code: string, path: string, message: string, relatedStableIds?: readonly string[], severity?: TmwDiagnosticSeverity): TmwDiagnostic;
+export declare function orderTmwDiagnostics(diagnostics: readonly TmwDiagnostic[]): readonly TmwDiagnostic[];
+export declare function tmwFailure<T>(diagnostics: readonly TmwDiagnostic[]): TmwResult<T>;
+export declare function tmwSuccess<T>(value: T, diagnostics?: readonly TmwDiagnostic[]): TmwResult<T>;

package/dist/diagnostics.js

@@ -0,0 +1,20 @@
+export function tmwDiagnostic(code, path, message, relatedStableIds = [], severity = "error") {
+    return Object.freeze({
+        severity,
+        code,
+        path,
+        message,
+        related_stable_ids: Object.freeze([...relatedStableIds].sort()),
+    });
+}
+export function orderTmwDiagnostics(diagnostics) {
+    return Object.freeze([...diagnostics].sort((left, right) => left.path.localeCompare(right.path)
+        || left.code.localeCompare(right.code)
+        || left.message.localeCompare(right.message)));
+}
+export function tmwFailure(diagnostics) {
+    return Object.freeze({ ok: false, diagnostics: orderTmwDiagnostics(diagnostics) });
+}
+export function tmwSuccess(value, diagnostics = []) {
+    return Object.freeze({ ok: true, value, diagnostics: orderTmwDiagnostics(diagnostics) });
+}

package/dist/durable-intent.d.ts

@@ -0,0 +1,29 @@
+import { TMW_RUNTIME_GENERATION } from "./runtime-contract.js";
+import { type TmwJsonValue } from "./runtime-trace.js";
+export type DurableIntentState = "active" | "blocked" | "applying" | "satisfied" | "cancelled" | "superseded" | "invalidated" | "failed";
+export interface DurableIntentV3 {
+    readonly intentId: string;
+    readonly epoch: number;
+    readonly runtimeGeneration: typeof TMW_RUNTIME_GENERATION;
+    readonly runtimeContractHash: string;
+    readonly artifactDigest: string;
+    readonly sourceRevision: string;
+    readonly timelineRevision: string;
+    readonly turnId: string;
+    readonly operationId: string;
+    readonly capabilityId: string;
+    readonly idempotencyKey: string;
+    readonly conflictKey: string;
+    readonly priority: number;
+    readonly state: DurableIntentState;
+    readonly selectorSnapshotHash: string;
+    readonly payload: TmwJsonValue;
+    readonly lastReceiptDigest: string | null;
+    readonly reasonCode: string | null;
+}
+export declare function canonicalDurableIntent(input: DurableIntentV3): DurableIntentV3;
+export declare function transitionDurableIntent(currentInput: DurableIntentV3, next: Readonly<{
+    state: DurableIntentState;
+    lastReceiptDigest: string | null;
+    reasonCode: string | null;
+}>): DurableIntentV3;