@openprose/reactor 0.1.0-rc.1

package/dist/adapters/storage-fs/index.d.ts

@@ -0,0 +1,14 @@
+import { type ReactorRuntimeRegistrySnapshotV0, type ReactorStorageRuntimeAdapterV0 } from "../types";
+export interface FileSystemStorageAdapterInputV0 {
+    readonly directory: string;
+    readonly registry_file?: string;
+    readonly receipts_file?: string;
+    readonly initial_registry?: ReactorRuntimeRegistrySnapshotV0;
+}
+export interface FileSystemStorageAdapterV0 extends ReactorStorageRuntimeAdapterV0 {
+    readonly directory: string;
+    readonly registryPath: string;
+    readonly receiptsPath: string;
+}
+export declare function createFileSystemStorageAdapterV0(input: FileSystemStorageAdapterInputV0): FileSystemStorageAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/storage-fs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/storage-fs/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAIL,KAAK,gCAAgC,EACrC,KAAK,8BAA8B,EACpC,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,gCAAgC,CAAC;CAC9D;AAED,MAAM,WAAW,0BAA2B,SAAQ,8BAA8B;IAChF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,+BAA+B,GACrC,0BAA0B,CAoC5B"}

package/dist/adapters/storage-fs/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemStorageAdapterV0 = createFileSystemStorageAdapterV0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const receipt_1 = require("../../receipt");
+const json_1 = require("../json");
+const types_1 = require("../types");
+function createFileSystemStorageAdapterV0(input) {
+    if (input.directory.length === 0) {
+        throw new Error("filesystem storage directory must be non-empty");
+    }
+    const registryPath = (0, node_path_1.join)(input.directory, input.registry_file ?? "registry.json");
+    const receiptsPath = (0, node_path_1.join)(input.directory, input.receipts_file ?? "receipts.json");
+    (0, node_fs_1.mkdirSync)(input.directory, { recursive: true });
+    initializeFile(registryPath, input.initial_registry ?? types_1.EMPTY_RUNTIME_REGISTRY_V0);
+    initializeFile(receiptsPath, []);
+    return {
+        directory: input.directory,
+        registryPath,
+        receiptsPath,
+        appendReceipt(receipt) {
+            (0, receipt_1.assertReceiptV0)(receipt);
+            const receipts = readReceiptLog(receiptsPath);
+            writeJsonFile(receiptsPath, [...receipts, cloneReceipt(receipt)]);
+        },
+        listReceipts() {
+            return readReceiptLog(receiptsPath);
+        },
+        readRegistry() {
+            const value = readJsonFile(registryPath);
+            (0, types_1.assertRuntimeRegistrySnapshotV0)(value);
+            return (0, types_1.cloneRuntimeRegistrySnapshotV0)(value);
+        },
+        writeRegistry(registry) {
+            writeJsonFile(registryPath, (0, types_1.cloneRuntimeRegistrySnapshotV0)(registry));
+        },
+    };
+}
+function initializeFile(path, value) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        writeJsonFile(path, value);
+    }
+}
+function readReceiptLog(path) {
+    const value = readJsonFile(path);
+    if (!Array.isArray(value)) {
+        throw new Error("filesystem receipts file must contain an array");
+    }
+    return value.map((receipt) => cloneReceipt(receipt));
+}
+function cloneReceipt(receipt) {
+    (0, receipt_1.assertReceiptV0)(receipt);
+    const clone = (0, json_1.cloneAdapterJsonValueV0)(receipt);
+    (0, receipt_1.assertReceiptV0)(clone);
+    return clone;
+}
+function readJsonFile(path) {
+    return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+}
+function writeJsonFile(path, value) {
+    const tempPath = `${path}.tmp-${process.pid}`;
+    (0, node_fs_1.writeFileSync)(tempPath, `${(0, json_1.renderAdapterJsonV0)(value)}\n`, "utf8");
+    (0, node_fs_1.renameSync)(tempPath, path);
+}

package/dist/adapters/storage-memory/index.d.ts

@@ -0,0 +1,11 @@
+import { type ReceiptV0 } from "../../receipt";
+import { type ReactorRuntimeRegistrySnapshotV0, type ReactorStorageRuntimeAdapterV0 } from "../types";
+export interface MemoryStorageAdapterInputV0 {
+    readonly registry?: ReactorRuntimeRegistrySnapshotV0;
+    readonly receipts?: readonly ReceiptV0[];
+}
+export interface MemoryStorageAdapterV0 extends ReactorStorageRuntimeAdapterV0 {
+    readonly clear: () => void;
+}
+export declare function createMemoryStorageAdapterV0(input?: MemoryStorageAdapterInputV0): MemoryStorageAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/storage-memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/storage-memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAGL,KAAK,gCAAgC,EACrC,KAAK,8BAA8B,EACpC,MAAM,UAAU,CAAC;AAGlB,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,gCAAgC,CAAC;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,sBAAuB,SAAQ,8BAA8B;IAC5E,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,GAAE,2BAAgC,GACtC,sBAAsB,CAwBxB"}

package/dist/adapters/storage-memory/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryStorageAdapterV0 = createMemoryStorageAdapterV0;
+const receipt_1 = require("../../receipt");
+const types_1 = require("../types");
+const json_1 = require("../json");
+function createMemoryStorageAdapterV0(input = {}) {
+    let registry = (0, types_1.cloneRuntimeRegistrySnapshotV0)(input.registry ?? types_1.EMPTY_RUNTIME_REGISTRY_V0);
+    let receipts = (input.receipts ?? []).map((receipt) => cloneReceipt(receipt));
+    return {
+        appendReceipt(receipt) {
+            receipts = [...receipts, cloneReceipt(receipt)];
+        },
+        listReceipts() {
+            return receipts.map((receipt) => cloneReceipt(receipt));
+        },
+        readRegistry() {
+            return (0, types_1.cloneRuntimeRegistrySnapshotV0)(registry);
+        },
+        writeRegistry(nextRegistry) {
+            registry = (0, types_1.cloneRuntimeRegistrySnapshotV0)(nextRegistry);
+        },
+        clear() {
+            registry = (0, types_1.cloneRuntimeRegistrySnapshotV0)(types_1.EMPTY_RUNTIME_REGISTRY_V0);
+            receipts = [];
+        },
+    };
+}
+function cloneReceipt(receipt) {
+    (0, receipt_1.assertReceiptV0)(receipt);
+    const clone = (0, json_1.cloneAdapterJsonValueV0)(receipt);
+    (0, receipt_1.assertReceiptV0)(clone);
+    return clone;
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,22 @@
+import type { ReactorModelGatewayAdapterV0, ReactorModelGatewayRequestV0, ReactorModelGatewayResponseV0, ReactorModelGatewayUsageV0, ReactorRegistrySnapshotV0, ReactorStorageAdapterV0 } from "../sdk";
+export interface ReactorRuntimeRegistrySnapshotV0 extends ReactorRegistrySnapshotV0 {
+    readonly [key: string]: unknown;
+    readonly compiled_evidence_plan?: unknown;
+    readonly forecast_schedule?: unknown;
+}
+export interface ReactorStorageRuntimeAdapterV0 extends ReactorStorageAdapterV0 {
+    readonly readRegistry: () => ReactorRuntimeRegistrySnapshotV0;
+    readonly writeRegistry: (registry: ReactorRuntimeRegistrySnapshotV0) => void;
+}
+export interface ReactorModelGatewayResponseWithUsageV0 extends ReactorModelGatewayResponseV0 {
+    readonly usage: ReactorModelGatewayUsageV0;
+}
+export interface ReactorModelGatewayRuntimeAdapterV0 extends ReactorModelGatewayAdapterV0 {
+    readonly invoke: (request: ReactorModelGatewayRequestV0) => ReactorModelGatewayResponseWithUsageV0;
+}
+export declare const EMPTY_RUNTIME_REGISTRY_V0: ReactorRuntimeRegistrySnapshotV0;
+export declare function cloneRuntimeRegistrySnapshotV0(registry: ReactorRuntimeRegistrySnapshotV0): ReactorRuntimeRegistrySnapshotV0;
+export declare function cloneModelGatewayUsageV0(usage: ReactorModelGatewayUsageV0): ReactorModelGatewayUsageV0;
+export declare function assertRuntimeRegistrySnapshotV0(value: unknown): asserts value is ReactorRuntimeRegistrySnapshotV0;
+export declare function assertModelGatewayUsageV0(value: unknown): asserts value is ReactorModelGatewayUsageV0;
+//# sourceMappingURL=types.d.ts.map

package/dist/adapters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/adapters/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,4BAA4B,EAC5B,4BAA4B,EAC5B,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,QAAQ,CAAC;AAKhB,MAAM,WAAW,gCACf,SAAQ,yBAAyB;IACjC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED,MAAM,WAAW,8BACf,SAAQ,uBAAuB;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,gCAAgC,CAAC;IAC9D,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,gCAAgC,KAAK,IAAI,CAAC;CAC9E;AAED,MAAM,WAAW,sCACf,SAAQ,6BAA6B;IACrC,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;CAC5C;AAED,MAAM,WAAW,mCACf,SAAQ,4BAA4B;IACpC,QAAQ,CAAC,MAAM,EAAE,CACf,OAAO,EAAE,4BAA4B,KAClC,sCAAsC,CAAC;CAC7C;AAED,eAAO,MAAM,yBAAyB,EAAE,gCAGvC,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,gCAAgC,GACzC,gCAAgC,CAIlC;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,0BAA0B,GAChC,0BAA0B,CAI5B;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,gCAAgC,CAgCnD;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,0BAA0B,CA8B7C"}

package/dist/adapters/types.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY_RUNTIME_REGISTRY_V0 = void 0;
+exports.cloneRuntimeRegistrySnapshotV0 = cloneRuntimeRegistrySnapshotV0;
+exports.cloneModelGatewayUsageV0 = cloneModelGatewayUsageV0;
+exports.assertRuntimeRegistrySnapshotV0 = assertRuntimeRegistrySnapshotV0;
+exports.assertModelGatewayUsageV0 = assertModelGatewayUsageV0;
+const json_1 = require("./json");
+const CONTENT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+exports.EMPTY_RUNTIME_REGISTRY_V0 = {
+    policy_artifact_namespace: "policy.uninitialized",
+    policy_artifact_revision: "0",
+};
+function cloneRuntimeRegistrySnapshotV0(registry) {
+    const clone = (0, json_1.cloneAdapterJsonValueV0)(registry);
+    assertRuntimeRegistrySnapshotV0(clone);
+    return clone;
+}
+function cloneModelGatewayUsageV0(usage) {
+    const clone = (0, json_1.cloneAdapterJsonValueV0)(usage);
+    assertModelGatewayUsageV0(clone);
+    return clone;
+}
+function assertRuntimeRegistrySnapshotV0(value) {
+    if (!isRecord(value)) {
+        throw new TypeError("registry snapshot must be an object");
+    }
+    const namespace = value["policy_artifact_namespace"];
+    if (typeof namespace !== "string" || namespace.length === 0) {
+        throw new TypeError("registry.policy_artifact_namespace must be a non-empty string");
+    }
+    const revision = value["policy_artifact_revision"];
+    if (typeof revision !== "string" || revision.length === 0) {
+        throw new TypeError("registry.policy_artifact_revision must be a non-empty string");
+    }
+    assertOptionalContentHash(value, "contract_revision");
+    assertOptionalContentHash(value, "policy_artifact_content_hash");
+    for (const key of [
+        "policy_artifact_id",
+        "policy_artifact_identity",
+        "policy_artifact_bytes",
+    ]) {
+        const item = value[key];
+        if (item !== undefined && typeof item !== "string") {
+            throw new TypeError(`registry.${key} must be a string when present`);
+        }
+    }
+}
+function assertModelGatewayUsageV0(value) {
+    if (!isRecord(value)) {
+        throw new TypeError("model gateway usage must be an object");
+    }
+    for (const key of ["provider", "model"]) {
+        const item = value[key];
+        if (typeof item !== "string" || item.length === 0) {
+            throw new TypeError(`usage.${key} must be a non-empty string`);
+        }
+    }
+    const tokens = value["tokens"];
+    if (!isRecord(tokens)) {
+        throw new TypeError("usage.tokens must be an object");
+    }
+    assertNonNegativeSafeInteger(tokens, "fresh");
+    assertNonNegativeSafeInteger(tokens, "reused");
+    const providerNorm = value["provider_norm"];
+    if (providerNorm !== undefined) {
+        if (!isRecord(providerNorm)) {
+            throw new TypeError("usage.provider_norm must be an object when present");
+        }
+        const schema = providerNorm["schema"];
+        if (typeof schema !== "string" || schema.length === 0) {
+            throw new TypeError("usage.provider_norm.schema must be non-empty");
+        }
+    }
+}
+function assertOptionalContentHash(record, key) {
+    const value = record[key];
+    if (value !== undefined && !isContentHash(value)) {
+        throw new TypeError(`registry.${key} must be a sha256 content address`);
+    }
+}
+function assertNonNegativeSafeInteger(record, key) {
+    const value = record[key];
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError(`usage.tokens.${key} must be a non-negative safe integer`);
+    }
+}
+function isContentHash(value) {
+    return typeof value === "string" && CONTENT_HASH_PATTERN.test(value);
+}
+function isRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/composition/index.d.ts

@@ -0,0 +1,79 @@
+import { type MemoLookupResultV0, type PolicyArtifactMemoNamespaceV0 } from "../memo";
+import { type PolicyTransitiveFreshnessFunctionV0 } from "../policy";
+import { type ConsumedFreshnessEvaluationV0, type ConsumedReceiptPinV0, type ContentHashV0, type ReceiptFreshnessV0, type ReceiptEventCauseV0, type ReceiptRecheckKindV0, type ReceiptV0 } from "../receipt";
+export interface UpstreamReceiptDependencyPinInputV0 {
+    readonly upstream_receipt: unknown;
+    readonly acceptable_signer_set: readonly string[];
+}
+export interface UpstreamReceiptDependencyPinVerificationInputV0 {
+    readonly upstream_receipt: unknown;
+    readonly expected_dependency_pin: unknown;
+}
+export interface VerifiedUpstreamReceiptDependencyPinV0 {
+    readonly receipt: ReceiptV0;
+    readonly content_hash: ContentHashV0;
+    readonly dependency_pin: ConsumedReceiptPinV0;
+    readonly signer_posture: string;
+}
+export type TransitiveFreshnessOutcomeV0 = "fresh" | "stale-blocked";
+export interface TransitiveFreshnessConsumedReceiptInputV0 {
+    readonly upstream_receipt: unknown;
+    readonly dependency_pin: unknown;
+    readonly refetched_from_receipt?: unknown;
+    readonly refetched_from_dependency_pin?: unknown;
+}
+export interface TransitiveFreshnessEvaluationInputV0 {
+    readonly as_of: string;
+    readonly transitive_freshness_policy_ref: string;
+    readonly transitive_freshness_function?: PolicyTransitiveFreshnessFunctionV0;
+    readonly consumed_receipts: readonly TransitiveFreshnessConsumedReceiptInputV0[];
+}
+export interface TransitiveFreshnessEvaluationResultV0 {
+    readonly outcome: TransitiveFreshnessOutcomeV0;
+    readonly as_of: string;
+    readonly transitive_freshness_policy_ref: string;
+    readonly consumed_freshness_evaluated: readonly ConsumedFreshnessEvaluationV0[];
+    readonly stale_receipt_hashes: readonly ContentHashV0[];
+}
+export interface ComposedReceiptFreshnessInputV0 extends TransitiveFreshnessEvaluationInputV0 {
+    readonly next_forecast_recheck: string;
+}
+export interface DownstreamComposedMemoKeyInputV0 {
+    readonly contract_revision: ContentHashV0;
+    readonly evidence_receipts: readonly ContentHashV0[];
+    readonly dependency_receipts: readonly ConsumedReceiptPinV0[];
+}
+export interface CompositionMemoStoreV0 {
+    readonly lookup: (namespace: PolicyArtifactMemoNamespaceV0, memoKey: ContentHashV0) => MemoLookupResultV0;
+}
+export interface CompositionPropagationPlanInputV0 extends DownstreamComposedMemoKeyInputV0 {
+    readonly memo_namespace: PolicyArtifactMemoNamespaceV0;
+    readonly memo_store: CompositionMemoStoreV0;
+    readonly as_of: string;
+    readonly next_forecast_recheck: string;
+    readonly event_cause?: ReceiptEventCauseV0;
+    readonly recheck_kind?: ReceiptRecheckKindV0;
+}
+export type CompositionPropagationPlanV0 = {
+    readonly outcome: "rejudge-required";
+    readonly memo_key: ContentHashV0;
+    readonly memo_lookup: Extract<MemoLookupResultV0, {
+        outcome: "miss";
+    }>;
+    readonly dependency_receipts: readonly ConsumedReceiptPinV0[];
+} | {
+    readonly outcome: "stop-memo-hit";
+    readonly memo_key: ContentHashV0;
+    readonly memo_lookup: Extract<MemoLookupResultV0, {
+        outcome: "hit";
+    }>;
+    readonly memo_hit_receipt: ReceiptV0;
+    readonly dependency_receipts: readonly ConsumedReceiptPinV0[];
+};
+export declare function dependencyReceiptPinFromVerifiedReceiptV0(input: UpstreamReceiptDependencyPinInputV0): ConsumedReceiptPinV0;
+export declare function verifyUpstreamReceiptDependencyPinV0(input: UpstreamReceiptDependencyPinVerificationInputV0): VerifiedUpstreamReceiptDependencyPinV0;
+export declare function evaluateTransitiveFreshnessV0(input: TransitiveFreshnessEvaluationInputV0): TransitiveFreshnessEvaluationResultV0;
+export declare function createComposedReceiptFreshnessV0(input: ComposedReceiptFreshnessInputV0): ReceiptFreshnessV0;
+export declare function computeDownstreamComposedMemoKeyV0(input: DownstreamComposedMemoKeyInputV0): ContentHashV0;
+export declare function planCompositionPropagationV0(input: CompositionPropagationPlanInputV0): CompositionPropagationPlanV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/composition/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composition/index.ts"],"names":[],"mappings":"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"}

package/dist/composition/index.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyReceiptPinFromVerifiedReceiptV0 = dependencyReceiptPinFromVerifiedReceiptV0;
+exports.verifyUpstreamReceiptDependencyPinV0 = verifyUpstreamReceiptDependencyPinV0;
+exports.evaluateTransitiveFreshnessV0 = evaluateTransitiveFreshnessV0;
+exports.createComposedReceiptFreshnessV0 = createComposedReceiptFreshnessV0;
+exports.computeDownstreamComposedMemoKeyV0 = computeDownstreamComposedMemoKeyV0;
+exports.planCompositionPropagationV0 = planCompositionPropagationV0;
+const memo_1 = require("../memo");
+const policy_1 = require("../policy");
+const receipt_1 = require("../receipt");
+function dependencyReceiptPinFromVerifiedReceiptV0(input) {
+    const verification = (0, receipt_1.verifyReceiptV0)(input.upstream_receipt);
+    if (!verification.ok) {
+        throw new Error("upstream receipt must verify before composition");
+    }
+    const upstreamReceipt = input.upstream_receipt;
+    const acceptableSignerSet = normalizeAcceptableSignerSetV0(input.acceptable_signer_set, "acceptable_signer_set");
+    const signerPosture = signerPostureForVerifiedReceiptV0(upstreamReceipt);
+    if (!acceptableSignerSet.includes(signerPosture)) {
+        throw new Error("upstream receipt signer posture is not allowed by dependency pin");
+    }
+    return {
+        upstream_content_hash: verification.content_hash,
+        contract_revision: upstreamReceipt.core.contract_revision,
+        acceptable_signer_set: acceptableSignerSet,
+    };
+}
+function verifyUpstreamReceiptDependencyPinV0(input) {
+    const verification = (0, receipt_1.verifyReceiptV0)(input.upstream_receipt);
+    if (!verification.ok) {
+        throw new Error("upstream receipt must verify before dependency pin check");
+    }
+    const upstreamReceipt = input.upstream_receipt;
+    const dependencyPin = normalizeDependencyReceiptPinV0(input.expected_dependency_pin, "expected_dependency_pin");
+    if (verification.content_hash !== dependencyPin.upstream_content_hash) {
+        throw new Error("upstream receipt content hash must match dependency pin");
+    }
+    if (upstreamReceipt.core.contract_revision !== dependencyPin.contract_revision) {
+        throw new Error("upstream receipt contract revision must match dependency pin");
+    }
+    const signerPosture = signerPostureForVerifiedReceiptV0(upstreamReceipt);
+    if (!dependencyPin.acceptable_signer_set.includes(signerPosture)) {
+        throw new Error("upstream receipt signer posture is not allowed by dependency pin");
+    }
+    return {
+        receipt: upstreamReceipt,
+        content_hash: verification.content_hash,
+        dependency_pin: dependencyPin,
+        signer_posture: signerPosture,
+    };
+}
+function evaluateTransitiveFreshnessV0(input) {
+    const asOfMs = parseReplayableInstantMsV0(input.as_of, "as_of");
+    assertNonEmptyStringV0(input.transitive_freshness_policy_ref, "transitive_freshness_policy_ref");
+    const transitiveFreshnessFunction = (0, policy_1.normalizePolicyTransitiveFreshnessFunctionV0)(input.transitive_freshness_function);
+    if (!Array.isArray(input.consumed_receipts)) {
+        throw new Error("consumed_receipts must be an array");
+    }
+    const staleReceiptHashes = [];
+    const consumedFreshnessEvaluated = input.consumed_receipts.map((entry, index) => {
+        if (!isRecord(entry)) {
+            throw new Error(`consumed_receipts[${index}] must be an object`);
+        }
+        const verified = verifyUpstreamReceiptDependencyPinV0({
+            upstream_receipt: entry.upstream_receipt,
+            expected_dependency_pin: entry.dependency_pin,
+        });
+        const refetchedFrom = readRefetchedFromReceiptV0(entry, index, asOfMs);
+        const nextForecastRecheck = verified.receipt.freshness.next_forecast_recheck;
+        const nextForecastRecheckMs = parseReplayableInstantMsV0(nextForecastRecheck, `consumed_receipts[${index}].upstream_receipt.freshness.next_forecast_recheck`);
+        const isStale = nextForecastRecheckMs <= asOfMs ||
+            isStaleByAuthoredTransitiveFreshnessFunctionV0(transitiveFreshnessFunction, nextForecastRecheckMs, asOfMs);
+        if (isStale) {
+            staleReceiptHashes.push(verified.content_hash);
+        }
+        return {
+            receipt_hash: verified.content_hash,
+            next_forecast_recheck: nextForecastRecheck,
+            staleness_outcome: isStale
+                ? "stale-blocked"
+                : refetchedFrom === undefined
+                    ? "fresh"
+                    : "stale-refetched",
+        };
+    });
+    return {
+        outcome: staleReceiptHashes.length === 0 ? "fresh" : "stale-blocked",
+        as_of: input.as_of,
+        transitive_freshness_policy_ref: input.transitive_freshness_policy_ref,
+        consumed_freshness_evaluated: consumedFreshnessEvaluated,
+        stale_receipt_hashes: staleReceiptHashes,
+    };
+}
+function isStaleByAuthoredTransitiveFreshnessFunctionV0(fn, nextForecastRecheckMs, asOfMs) {
+    switch (fn.kind) {
+        case "kernel-default":
+            return false;
+        case "minimum-remaining-freshness-ms":
+            return nextForecastRecheckMs <= asOfMs + fn.minimum_remaining_ms;
+    }
+}
+function readRefetchedFromReceiptV0(entry, index, asOfMs) {
+    const refetchedReceipt = entry["refetched_from_receipt"];
+    const refetchedPin = entry["refetched_from_dependency_pin"];
+    if (refetchedReceipt === undefined && refetchedPin === undefined) {
+        return undefined;
+    }
+    if (refetchedReceipt === undefined || refetchedPin === undefined) {
+        throw new Error(`consumed_receipts[${index}] refetch evidence requires both receipt and dependency pin`);
+    }
+    const verified = verifyUpstreamReceiptDependencyPinV0({
+        upstream_receipt: refetchedReceipt,
+        expected_dependency_pin: refetchedPin,
+    });
+    const previousNextForecastRecheckMs = parseReplayableInstantMsV0(verified.receipt.freshness.next_forecast_recheck, `consumed_receipts[${index}].refetched_from_receipt.freshness.next_forecast_recheck`);
+    if (previousNextForecastRecheckMs > asOfMs) {
+        throw new Error(`consumed_receipts[${index}].refetched_from_receipt must be stale at as_of`);
+    }
+    return verified;
+}
+function createComposedReceiptFreshnessV0(input) {
+    const asOfMs = parseReplayableInstantMsV0(input.as_of, "as_of");
+    const nextForecastRecheckMs = parseReplayableInstantMsV0(input.next_forecast_recheck, "next_forecast_recheck");
+    if (nextForecastRecheckMs < asOfMs) {
+        throw new Error("next_forecast_recheck must not be before as_of");
+    }
+    const evaluation = evaluateTransitiveFreshnessV0(input);
+    return {
+        as_of: input.as_of,
+        next_forecast_recheck: input.next_forecast_recheck,
+        transitive_freshness_policy_ref: input.transitive_freshness_policy_ref,
+        consumed_freshness_evaluated: evaluation.consumed_freshness_evaluated,
+    };
+}
+function computeDownstreamComposedMemoKeyV0(input) {
+    const dependencyReceipts = assertNoDuplicateDependencyPinsV0(input.dependency_receipts);
+    return (0, memo_1.computeMemoKeyV0)({
+        contract_revision: input.contract_revision,
+        evidence_receipts: input.evidence_receipts,
+        dependency_receipts: dependencyReceipts,
+    });
+}
+function planCompositionPropagationV0(input) {
+    const dependencyReceipts = assertNoDuplicateDependencyPinsV0(input.dependency_receipts);
+    const memoKey = computeDownstreamComposedMemoKeyV0({
+        contract_revision: input.contract_revision,
+        evidence_receipts: input.evidence_receipts,
+        dependency_receipts: dependencyReceipts,
+    });
+    const memoLookup = input.memo_store.lookup(input.memo_namespace, memoKey);
+    if (memoLookup.outcome === "miss") {
+        return {
+            outcome: "rejudge-required",
+            memo_key: memoKey,
+            memo_lookup: memoLookup,
+            dependency_receipts: dependencyReceipts,
+        };
+    }
+    assertMemoHitMatchesComposedInputV0(memoLookup, memoKey, dependencyReceipts);
+    return {
+        outcome: "stop-memo-hit",
+        memo_key: memoKey,
+        memo_lookup: memoLookup,
+        memo_hit_receipt: (0, memo_1.createMemoHitReceiptV0)({
+            source_receipt: memoLookup.entry.receipt,
+            as_of: input.as_of,
+            next_forecast_recheck: input.next_forecast_recheck,
+            ...(input.event_cause === undefined ? {} : { event_cause: input.event_cause }),
+            ...(input.recheck_kind === undefined ? {} : { recheck_kind: input.recheck_kind }),
+        }),
+        dependency_receipts: dependencyReceipts,
+    };
+}
+function assertMemoHitMatchesComposedInputV0(memoLookup, memoKey, dependencyReceipts) {
+    if (memoLookup.entry.memo_key !== memoKey) {
+        throw new Error("composition memo hit entry key must match composed memo key");
+    }
+    if (memoLookup.entry.receipt.core.memo_key !== memoKey) {
+        throw new Error("composition memo hit receipt key must match composed memo key");
+    }
+    if (canonicalizeDependencyPinsForComparisonV0(memoLookup.entry.receipt.composition.consumed_receipts) !== canonicalizeDependencyPinsForComparisonV0(dependencyReceipts)) {
+        throw new Error("composition memo hit receipt dependencies must match composed input");
+    }
+}
+function assertNoDuplicateDependencyPinsV0(dependencyReceipts) {
+    const seen = new Set();
+    for (const dependencyReceipt of dependencyReceipts) {
+        if (seen.has(dependencyReceipt.upstream_content_hash)) {
+            throw new Error(`duplicate dependency receipt pin ${dependencyReceipt.upstream_content_hash}`);
+        }
+        seen.add(dependencyReceipt.upstream_content_hash);
+    }
+    return dependencyReceipts;
+}
+function canonicalizeDependencyPinsForComparisonV0(dependencyReceipts) {
+    return (0, receipt_1.canonicalizeForReceiptV0)(dependencyReceipts
+        .map((dependencyReceipt, index) => ({
+        upstream_content_hash: dependencyReceipt.upstream_content_hash,
+        contract_revision: dependencyReceipt.contract_revision,
+        acceptable_signer_set: normalizeAcceptableSignerSetV0(dependencyReceipt.acceptable_signer_set, `dependency_receipts[${index}].acceptable_signer_set`),
+    }))
+        .sort((left, right) => left.upstream_content_hash.localeCompare(right.upstream_content_hash)));
+}
+function normalizeAcceptableSignerSetV0(acceptableSignerSet, path) {
+    if (!Array.isArray(acceptableSignerSet)) {
+        throw new Error(`${path} must be an array`);
+    }
+    if (acceptableSignerSet.length === 0) {
+        throw new Error(`${path} must not be empty`);
+    }
+    const seen = new Set();
+    for (const [index, signer] of acceptableSignerSet.entries()) {
+        if (typeof signer !== "string") {
+            throw new Error(`${path}[${index}] must be a non-empty string`);
+        }
+        if (signer.length === 0) {
+            throw new Error(`${path} contains an empty signer`);
+        }
+        if (seen.has(signer)) {
+            throw new Error(`${path} contains duplicate signer ${signer}`);
+        }
+        seen.add(signer);
+    }
+    return [...acceptableSignerSet].sort((left, right) => left.localeCompare(right));
+}
+function normalizeDependencyReceiptPinV0(value, path) {
+    if (!isRecord(value)) {
+        throw new Error(`${path} must be an object`);
+    }
+    assertExactPinKeysV0(value, path);
+    assertContentHashV0(value["upstream_content_hash"], `${path}.upstream_content_hash`);
+    assertContentHashV0(value["contract_revision"], `${path}.contract_revision`);
+    return {
+        upstream_content_hash: value["upstream_content_hash"],
+        contract_revision: value["contract_revision"],
+        acceptable_signer_set: normalizeAcceptableSignerSetV0(value["acceptable_signer_set"], `${path}.acceptable_signer_set`),
+    };
+}
+function signerPostureForVerifiedReceiptV0(receipt) {
+    if (receipt.sig.scheme === "none") {
+        return "none";
+    }
+    throw new Error("upstream receipt non-null signer posture is rejected in receipt v0.1; null signer is the only honest v0.1 dependency posture");
+}
+function assertExactPinKeysV0(value, path) {
+    const allowed = new Set([
+        "upstream_content_hash",
+        "contract_revision",
+        "acceptable_signer_set",
+    ]);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new Error(`${path}.${key} is not pinned in dependency receipt v0`);
+        }
+    }
+}
+function assertContentHashV0(value, path) {
+    if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value)) {
+        throw new Error(`${path} must be a sha256 content address`);
+    }
+}
+function assertNonEmptyStringV0(value, path) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${path} must be a non-empty string`);
+    }
+}
+function parseReplayableInstantMsV0(value, path) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value)) {
+        throw new Error(`${path} must be a replayable ISO instant`);
+    }
+    const parsed = Date.parse(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${path} must be a replayable ISO instant`);
+    }
+    return parsed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}