@openprose/reactor-cradle 0.1.0-rc.1

package/dist/baselines/no-memo/index.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_MEMO_BASELINE_GENERATED_AT_V0 = exports.NO_MEMO_BASELINE_SOURCE_FIXTURE_V0 = exports.NO_MEMO_BASELINE_CASSETTE_PATH_V0 = exports.NO_MEMO_BASELINE_WORLD_PROFILE_V0 = exports.NO_MEMO_BASELINE_SCENARIO_ID_V0 = exports.NO_MEMO_BASELINE_VARIANT_V0 = exports.NO_MEMO_BASELINE_SUMMARY_VERSION_V0 = exports.NO_MEMO_BASELINE_SUMMARY_SCHEMA_V0 = void 0;
+exports.createNoMemoStaticBaselineFromReactorRunV0 = createNoMemoStaticBaselineFromReactorRunV0;
+exports.runNoMemoW7StaticBaselineV0 = runNoMemoW7StaticBaselineV0;
+const node_crypto_1 = require("node:crypto");
+exports.NO_MEMO_BASELINE_SUMMARY_SCHEMA_V0 = "openprose.reactor-cradle.baseline.no-memo-summary";
+exports.NO_MEMO_BASELINE_SUMMARY_VERSION_V0 = 0;
+exports.NO_MEMO_BASELINE_VARIANT_V0 = "reactor-no-memo";
+exports.NO_MEMO_BASELINE_SCENARIO_ID_V0 = "incident-briefing-static-zero";
+exports.NO_MEMO_BASELINE_WORLD_PROFILE_V0 = "static";
+exports.NO_MEMO_BASELINE_CASSETTE_PATH_V0 = "./c2-static-zero.model-cassette.json";
+exports.NO_MEMO_BASELINE_SOURCE_FIXTURE_V0 = "src/__tests__/fixtures/c2-static-zero.scenario";
+exports.NO_MEMO_BASELINE_GENERATED_AT_V0 = "2026-05-20T00:00:00.000Z";
+const OBSERVED_W7_STATIC_RECEIPT_PROFILES = Object.freeze([
+    {
+        as_of: "2026-05-18T12:00:00.000Z",
+        event_cause: "real-input",
+        source_provider: "cradle",
+        source_model: "deterministic-bootstrap",
+        source_tokens: tokensFromFreshReused(41, 0),
+    },
+    {
+        as_of: "2026-05-18T12:15:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "evidence-age",
+        source_provider: "memo",
+        source_model: "memo",
+        source_tokens: tokensFromFreshReused(0, 41),
+    },
+    {
+        as_of: "2026-05-18T18:00:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "plan-age",
+        source_provider: "cradle",
+        source_model: "deterministic-plan-audit",
+        source_tokens: tokensFromFreshReused(5, 0),
+    },
+    {
+        as_of: "2026-05-19T12:00:00.000Z",
+        event_cause: "forecast-recheck",
+        recheck_kind: "evidence-age",
+        source_provider: "memo",
+        source_model: "memo",
+        source_tokens: tokensFromFreshReused(0, 5),
+    },
+]);
+const BASELINE_NOTES = Object.freeze([
+    "Derived from the Reactor static-world receipt schedule for the same incident-briefing-static-zero scenario and cassette.",
+    "The ablation leaves the Reactor forecast/status schedule intact, but disables memo credit by charging every token-bearing receipt total as fresh judge work.",
+    "Memo-hit receipts are treated as memo misses: reused tokens become fresh tokens and model_invocation_count increments for that turn.",
+]);
+function createNoMemoStaticBaselineFromReactorRunV0(input) {
+    const run = input.reactor_run;
+    assertExpectedStaticRun(run);
+    return createNoMemoStaticSummary({
+        initial_instant: run.initial_instant,
+        final_instant: run.final_instant,
+        source_fixture: input.source_fixture ?? exports.NO_MEMO_BASELINE_SOURCE_FIXTURE_V0,
+        scenario_script_turn_count: run.trace.length,
+        turns: run.receipt_log.entries.map((receipt, index) => createNoMemoTurnFromReceipt(receipt, index)),
+    });
+}
+function runNoMemoW7StaticBaselineV0(input = {}) {
+    if (input.reactor_run !== undefined) {
+        return createNoMemoStaticBaselineFromReactorRunV0({
+            reactor_run: input.reactor_run,
+            ...(input.source_fixture === undefined
+                ? {}
+                : { source_fixture: input.source_fixture }),
+        });
+    }
+    return createNoMemoStaticSummary({
+        initial_instant: "2026-05-18T12:00:00.000Z",
+        final_instant: "2026-05-19T12:00:00.000Z",
+        source_fixture: input.source_fixture ?? exports.NO_MEMO_BASELINE_SOURCE_FIXTURE_V0,
+        scenario_script_turn_count: 5,
+        turns: OBSERVED_W7_STATIC_RECEIPT_PROFILES.map((profile, index) => createNoMemoTurnFromObservedProfile(profile, index)),
+    });
+}
+function createNoMemoStaticSummary(input) {
+    const tokens = sumTurnTokens(input.turns);
+    const payload = {
+        schema: exports.NO_MEMO_BASELINE_SUMMARY_SCHEMA_V0,
+        v: exports.NO_MEMO_BASELINE_SUMMARY_VERSION_V0,
+        summary_type: "runtime-derived-static-no-memo-replay",
+        generated_at: exports.NO_MEMO_BASELINE_GENERATED_AT_V0,
+        variant: exports.NO_MEMO_BASELINE_VARIANT_V0,
+        scenario: {
+            id: exports.NO_MEMO_BASELINE_SCENARIO_ID_V0,
+            profile: exports.NO_MEMO_BASELINE_WORLD_PROFILE_V0,
+            initial_instant: input.initial_instant,
+            final_instant: input.final_instant,
+            source_fixture: input.source_fixture,
+            cassette_path: exports.NO_MEMO_BASELINE_CASSETTE_PATH_V0,
+            scenario_script_turn_count: input.scenario_script_turn_count,
+        },
+        receipt_count: input.turns.length,
+        turn_count: input.turns.length,
+        memo_hit_equivalent_count: input.turns.filter((turn) => turn.runtime_equivalent === "memo-hit-equivalent").length,
+        model_invocation_count: sumModelInvocations(input.turns),
+        tokens,
+        ratio: tokenRatio(tokens),
+        assumptions: {
+            replay_mode: "same-runtime-receipt-log-with-memo-disabled-equivalent",
+            memo_hit_handling: "token-bearing-receipts-charge-total-as-fresh",
+            runtime_behavior_changed: false,
+            excluded_invocations: [
+                "scenario setup cassette model step at t=0 is not a Reactor receipt and is excluded from the baseline ratio",
+            ],
+        },
+        turns: Object.freeze([...input.turns]),
+        notes: BASELINE_NOTES,
+    };
+    return Object.freeze({
+        ...payload,
+        content_hash: contentHash(payload),
+    });
+}
+function createNoMemoTurnFromReceipt(receipt, index) {
+    const sourceTokens = tokensFromFreshReused(receipt.cost.tokens.fresh, receipt.cost.tokens.reused);
+    return createNoMemoTurn({
+        index,
+        as_of: receipt.core.as_of,
+        event_cause: receipt.core.event_cause,
+        ...(receipt.core.recheck_kind === undefined
+            ? {}
+            : { recheck_kind: receipt.core.recheck_kind }),
+        source_provider: receipt.cost.provider,
+        source_model: receipt.cost.model,
+        source_tokens: sourceTokens,
+        source_receipt_hash: receipt.content_hash,
+    });
+}
+function createNoMemoTurnFromObservedProfile(profile, index) {
+    return createNoMemoTurn({
+        index,
+        as_of: profile.as_of,
+        event_cause: profile.event_cause,
+        ...(profile.recheck_kind === undefined
+            ? {}
+            : { recheck_kind: profile.recheck_kind }),
+        source_provider: profile.source_provider,
+        source_model: profile.source_model,
+        source_tokens: profile.source_tokens,
+    });
+}
+function createNoMemoTurn(input) {
+    const tokens = tokensFromFreshReused(input.source_tokens.total, 0);
+    const runtimeEquivalent = input.source_provider === "memo"
+        ? "memo-hit-equivalent"
+        : "model-invocation-equivalent";
+    return Object.freeze({
+        index: input.index,
+        as_of: input.as_of,
+        event_cause: input.event_cause,
+        ...(input.recheck_kind === undefined
+            ? {}
+            : { recheck_kind: input.recheck_kind }),
+        runtime_equivalent: runtimeEquivalent,
+        no_memo_outcome: "fresh-judge",
+        model_invocation_count: tokens.total === 0 ? 0 : 1,
+        tokens,
+        source_tokens: input.source_tokens,
+        source_provider: input.source_provider,
+        source_model: input.source_model,
+        ...(input.source_receipt_hash === undefined
+            ? {}
+            : { source_receipt_hash: input.source_receipt_hash }),
+        deterministic_profile: input.source_model,
+        note: noMemoTurnNote(runtimeEquivalent, input.source_tokens),
+    });
+}
+function noMemoTurnNote(runtimeEquivalent, sourceTokens) {
+    if (runtimeEquivalent === "memo-hit-equivalent") {
+        return `Runtime memo-hit receipt is treated as a memo miss; ${sourceTokens.reused} reused token(s) become fresh judge work.`;
+    }
+    return "Runtime model invocation remains fresh judge work in the no-memo baseline.";
+}
+function assertExpectedStaticRun(run) {
+    if (run.scenario_id !== exports.NO_MEMO_BASELINE_SCENARIO_ID_V0) {
+        throw new Error(`no-memo static baseline requires scenario_id=${exports.NO_MEMO_BASELINE_SCENARIO_ID_V0}; received ${run.scenario_id}`);
+    }
+    if (run.world_profile !== exports.NO_MEMO_BASELINE_WORLD_PROFILE_V0) {
+        throw new Error(`no-memo static baseline requires world_profile=${exports.NO_MEMO_BASELINE_WORLD_PROFILE_V0}; received ${run.world_profile}`);
+    }
+    if (run.cassette_path !== exports.NO_MEMO_BASELINE_CASSETTE_PATH_V0) {
+        throw new Error(`no-memo static baseline requires cassette_path=${exports.NO_MEMO_BASELINE_CASSETTE_PATH_V0}; received ${run.cassette_path}`);
+    }
+}
+function sumTurnTokens(turns) {
+    const fresh = turns.reduce((sum, turn) => sum + turn.tokens.fresh, 0);
+    const reused = turns.reduce((sum, turn) => sum + turn.tokens.reused, 0);
+    return tokensFromFreshReused(fresh, reused);
+}
+function sumModelInvocations(turns) {
+    return turns.reduce((sum, turn) => sum + turn.model_invocation_count, 0);
+}
+function tokensFromFreshReused(fresh, reused) {
+    assertTokenCount(fresh, "fresh");
+    assertTokenCount(reused, "reused");
+    return Object.freeze({
+        fresh,
+        reused,
+        total: fresh + reused,
+    });
+}
+function assertTokenCount(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`no-memo baseline token count ${label} must be a non-negative integer`);
+    }
+}
+function tokenRatio(tokens) {
+    return Object.freeze({
+        fresh: tokens.fresh,
+        reused: tokens.reused,
+        label: `${tokens.fresh}:${tokens.reused}`,
+        reused_is_zero: tokens.reused === 0,
+    });
+}
+function contentHash(payload) {
+    const digest = (0, node_crypto_1.createHash)("sha256")
+        .update(JSON.stringify(payload))
+        .digest("hex");
+    return `sha256:${digest}`;
+}

package/dist/doubles/clock.d.ts

@@ -0,0 +1,9 @@
+import type { ReactorClockAdapterV0 } from "@openprose/reactor/sdk";
+export declare class VirtualClock implements ReactorClockAdapterV0 {
+    #private;
+    constructor(initialInstant: string);
+    now(): string;
+    advanceMs(ms: number): void;
+    set(instant: string): void;
+}
+//# sourceMappingURL=clock.d.ts.map

package/dist/doubles/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../src/doubles/clock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAKpE,qBAAa,YAAa,YAAW,qBAAqB;;gBAG5C,cAAc,EAAE,MAAM;IAIlC,GAAG,IAAI,MAAM;IAIb,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAkB3B,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAG3B"}

package/dist/doubles/clock.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualClock = void 0;
+const ISO_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+class VirtualClock {
+    #epochMs;
+    constructor(initialInstant) {
+        this.#epochMs = parseReplayableInstant(initialInstant, "initialInstant");
+    }
+    now() {
+        return new Date(this.#epochMs).toISOString();
+    }
+    advanceMs(ms) {
+        if (!Number.isSafeInteger(ms) || ms < 0) {
+            throw new RangeError("advanceMs requires a non-negative safe integer millisecond interval");
+        }
+        const nextEpochMs = this.#epochMs + ms;
+        if (!Number.isSafeInteger(nextEpochMs) ||
+            !Number.isFinite(new Date(nextEpochMs).getTime())) {
+            throw new RangeError("advanceMs would move the clock outside Date range");
+        }
+        this.#epochMs = nextEpochMs;
+    }
+    set(instant) {
+        this.#epochMs = parseReplayableInstant(instant, "instant");
+    }
+}
+exports.VirtualClock = VirtualClock;
+function parseReplayableInstant(instant, label) {
+    if (!ISO_INSTANT_PATTERN.test(instant)) {
+        throw new RangeError(`${label} must be an ISO-8601 UTC instant`);
+    }
+    const epochMs = Date.parse(instant);
+    if (!Number.isFinite(epochMs)) {
+        throw new RangeError(`${label} must be a valid ISO-8601 UTC instant`);
+    }
+    const canonical = new Date(epochMs).toISOString();
+    if (instant !== canonical && instant !== canonical.replace(".000Z", "Z")) {
+        throw new RangeError(`${label} must be a valid ISO-8601 UTC instant`);
+    }
+    return epochMs;
+}

package/dist/doubles/storage.d.ts

@@ -0,0 +1,24 @@
+import type { ReceiptV0 } from "@openprose/reactor/receipt";
+import type { ReactorRegistrySnapshotV0, ReactorStorageAdapterV0 } from "@openprose/reactor/sdk";
+export interface FileSystemReactorStorageOptionsV0 {
+    readonly rootDir: string;
+    readonly registry?: ReactorRegistrySnapshotV0;
+    readonly initialReceipts?: readonly ReceiptV0[];
+}
+export declare class InMemoryReactorStorage implements ReactorStorageAdapterV0 {
+    #private;
+    constructor(registry: ReactorRegistrySnapshotV0, initialReceipts?: readonly ReceiptV0[]);
+    appendReceipt(receipt: ReceiptV0): void;
+    listReceipts(): readonly ReceiptV0[];
+    readRegistry(): ReactorRegistrySnapshotV0;
+}
+export declare class FileSystemReactorStorage implements ReactorStorageAdapterV0 {
+    #private;
+    static readonly registryFileName = "registry.json";
+    static readonly receiptsFileName = "receipts.json";
+    constructor(input: FileSystemReactorStorageOptionsV0);
+    appendReceipt(receipt: ReceiptV0): void;
+    listReceipts(): readonly ReceiptV0[];
+    readRegistry(): ReactorRegistrySnapshotV0;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/doubles/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/doubles/storage.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EACV,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IAC9C,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;CACjD;AAED,qBAAa,sBAAuB,YAAW,uBAAuB;;gBAKlE,QAAQ,EAAE,yBAAyB,EACnC,eAAe,GAAE,SAAS,SAAS,EAAO;IAQ5C,aAAa,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IAIvC,YAAY,IAAI,SAAS,SAAS,EAAE;IAMpC,YAAY,IAAI,yBAAyB;CAG1C;AAED,qBAAa,wBAAyB,YAAW,uBAAuB;;IACtE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,mBAAmB;IACnD,MAAM,CAAC,QAAQ,CAAC,gBAAgB,mBAAmB;gBAKvC,KAAK,EAAE,iCAAiC;IAiCpD,aAAa,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IASvC,YAAY,IAAI,SAAS,SAAS,EAAE;IAIpC,YAAY,IAAI,yBAAyB;CAG1C"}

package/dist/doubles/storage.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemReactorStorage = exports.InMemoryReactorStorage = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+class InMemoryReactorStorage {
+    #receipts;
+    #registry;
+    constructor(registry, initialReceipts = []) {
+        this.#registry = cloneDeterministicJson(registry, "registry");
+        this.#receipts = initialReceipts.map((receipt) => cloneDeterministicJson(receipt, "receipt"));
+    }
+    appendReceipt(receipt) {
+        this.#receipts.push(cloneDeterministicJson(receipt, "receipt"));
+    }
+    listReceipts() {
+        return deepFreezeJson(this.#receipts.map((receipt) => cloneDeterministicJson(receipt, "receipt")));
+    }
+    readRegistry() {
+        return deepFreezeJson(cloneDeterministicJson(this.#registry, "registry"));
+    }
+}
+exports.InMemoryReactorStorage = InMemoryReactorStorage;
+class FileSystemReactorStorage {
+    static registryFileName = "registry.json";
+    static receiptsFileName = "receipts.json";
+    #registryPath;
+    #receiptsPath;
+    constructor(input) {
+        assertNonEmptyString(input.rootDir, "rootDir");
+        (0, node_fs_1.mkdirSync)(input.rootDir, { recursive: true });
+        this.#registryPath = (0, node_path_1.join)(input.rootDir, FileSystemReactorStorage.registryFileName);
+        this.#receiptsPath = (0, node_path_1.join)(input.rootDir, FileSystemReactorStorage.receiptsFileName);
+        if (input.registry !== undefined) {
+            writeJsonFile(this.#registryPath, input.registry, FileSystemReactorStorage.registryFileName);
+        }
+        const shouldInitializeReceipts = input.initialReceipts !== undefined ||
+            (input.registry !== undefined && !(0, node_fs_1.existsSync)(this.#receiptsPath));
+        if (shouldInitializeReceipts) {
+            writeJsonFile(this.#receiptsPath, input.initialReceipts ?? [], FileSystemReactorStorage.receiptsFileName);
+        }
+    }
+    appendReceipt(receipt) {
+        const receipts = readReceiptsFile(this.#receiptsPath);
+        writeJsonFile(this.#receiptsPath, [...receipts, cloneDeterministicJson(receipt, "receipt")], FileSystemReactorStorage.receiptsFileName);
+    }
+    listReceipts() {
+        return deepFreezeJson(readReceiptsFile(this.#receiptsPath));
+    }
+    readRegistry() {
+        return deepFreezeJson(readRegistryFile(this.#registryPath));
+    }
+}
+exports.FileSystemReactorStorage = FileSystemReactorStorage;
+function readRegistryFile(path) {
+    const registry = readJsonRecordFile(path, FileSystemReactorStorage.registryFileName);
+    assertStringField(registry, "policy_artifact_namespace", "registry.policy_artifact_namespace");
+    assertStringField(registry, "policy_artifact_revision", "registry.policy_artifact_revision");
+    return registry;
+}
+function readReceiptsFile(path) {
+    const receipts = readJsonArrayFile(path, FileSystemReactorStorage.receiptsFileName);
+    receipts.forEach((receipt, index) => {
+        if (!isPlainRecord(receipt)) {
+            throw new Error(`filesystem storage ${FileSystemReactorStorage.receiptsFileName} entry ${index} must be a JSON object`);
+        }
+        assertStringField(receipt, "content_hash", `receipts[${index}].content_hash`);
+    });
+    return receipts;
+}
+function readJsonRecordFile(path, label) {
+    const value = readJsonFile(path, label);
+    if (!isPlainRecord(value)) {
+        throw new Error(`filesystem storage ${label} must contain a JSON object`);
+    }
+    return value;
+}
+function readJsonArrayFile(path, label) {
+    const value = readJsonFile(path, label);
+    if (!Array.isArray(value)) {
+        throw new Error(`filesystem storage ${label} must contain a JSON array`);
+    }
+    return value;
+}
+function readJsonFile(path, label) {
+    let bytes;
+    try {
+        bytes = (0, node_fs_1.readFileSync)(path, "utf8");
+    }
+    catch (error) {
+        throw new Error(`filesystem storage ${label} read failed: ${errorMessage(error)}`);
+    }
+    try {
+        return JSON.parse(bytes);
+    }
+    catch (error) {
+        throw new Error(`filesystem storage ${label} must contain valid JSON: ${errorMessage(error)}`);
+    }
+}
+function writeJsonFile(path, value, label) {
+    try {
+        (0, node_fs_1.writeFileSync)(path, `${renderDeterministicJson(value)}\n`, "utf8");
+    }
+    catch (error) {
+        throw new Error(`filesystem storage ${label} write failed: ${errorMessage(error)}`);
+    }
+}
+function cloneDeterministicJson(value, label) {
+    try {
+        return JSON.parse(renderDeterministicJson(value));
+    }
+    catch (error) {
+        throw new Error(`${label} must be deterministic JSON: ${errorMessage(error)}`);
+    }
+}
+function deepFreezeJson(value) {
+    if (Array.isArray(value)) {
+        value.forEach((item) => deepFreezeJson(item));
+        return Object.freeze(value);
+    }
+    if (isPlainRecord(value)) {
+        Object.values(value).forEach((item) => deepFreezeJson(item));
+        return Object.freeze(value);
+    }
+    return value;
+}
+function renderDeterministicJson(value) {
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "number":
+        case "string": {
+            if (typeof value === "number" && !Number.isFinite(value)) {
+                throw new TypeError("Cannot render non-finite numbers");
+            }
+            const rendered = JSON.stringify(value);
+            if (rendered === undefined) {
+                throw new TypeError(`Cannot render ${typeof value}`);
+            }
+            return rendered;
+        }
+        case "object":
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => renderDeterministicJson(item)).join(",")}]`;
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("Cannot render non-plain objects");
+            }
+            return renderDeterministicJsonObject(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`Cannot render ${typeof value}`);
+    }
+    throw new TypeError("Cannot render unknown value");
+}
+function renderDeterministicJsonObject(value) {
+    const fields = [];
+    for (const key of Object.keys(value).sort()) {
+        const item = value[key];
+        if (item === undefined) {
+            throw new TypeError(`Cannot render undefined field ${key}`);
+        }
+        fields.push(`${JSON.stringify(key)}:${renderDeterministicJson(item)}`);
+    }
+    return `{${fields.join(",")}}`;
+}
+function assertStringField(value, key, label) {
+    const field = value[key];
+    if (typeof field !== "string" || field.length === 0) {
+        throw new Error(`filesystem storage ${label} must be a non-empty string`);
+    }
+}
+function assertNonEmptyString(value, label) {
+    if (value.trim().length === 0) {
+        throw new Error(`${label} must be non-empty`);
+    }
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : "unknown error";
+}