@openprose/reactor-cradle 0.1.0-rc.1

package/dist/eval/index.js

@@ -0,0 +1,596 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCradleEvalProjectionMarkdownReportV0 = exports.projectCradleEvalResultArtifactV0 = exports.createCradleEvalProjectionV0 = exports.renderCradleEvalMarkdownReportV0 = exports.buildCradleEvalResultArtifactV0 = exports.createCradleEvalResultArtifactV0 = exports.createCradleEvalResultV0 = exports.EVAL_RESULT_VERSION_V0 = exports.EVAL_RESULT_SCHEMA_V0 = exports.CRADLE_EVAL_PROJECTION_VERSION_V0 = exports.CRADLE_EVAL_PROJECTION_SCHEMA_V0 = exports.CRADLE_EVAL_RESULT_VERSION_V0 = exports.CRADLE_EVAL_RESULT_SCHEMA_V0 = void 0;
+exports.buildCradleEvalResultV0 = buildCradleEvalResultV0;
+exports.renderCradleEvalReportMarkdownV0 = renderCradleEvalReportMarkdownV0;
+exports.projectCradleEvalResultV0 = projectCradleEvalResultV0;
+exports.renderCradleEvalProjectionReportMarkdownV0 = renderCradleEvalProjectionReportMarkdownV0;
+const node_crypto_1 = require("node:crypto");
+exports.CRADLE_EVAL_RESULT_SCHEMA_V0 = "openprose.reactor-cradle.eval-result";
+exports.CRADLE_EVAL_RESULT_VERSION_V0 = 0;
+exports.CRADLE_EVAL_PROJECTION_SCHEMA_V0 = "openprose.reactor-cradle.eval-projection";
+exports.CRADLE_EVAL_PROJECTION_VERSION_V0 = 0;
+exports.EVAL_RESULT_SCHEMA_V0 = exports.CRADLE_EVAL_RESULT_SCHEMA_V0;
+exports.EVAL_RESULT_VERSION_V0 = exports.CRADLE_EVAL_RESULT_VERSION_V0;
+const ISO_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+const CONTENT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const REDACTED_TEXT = "[redacted-secret]";
+const REDACTED_EMAIL_TEXT = "[redacted-email]";
+const REDACTED_URL_TEXT = "[redacted-url]";
+const REDACTED_PRIVATE_TEXT = "[redacted-private-text]";
+const REDACTED_RUNTIME_TEXT = "[redacted-runtime-id]";
+const REDACTED_RATIONALE_TEXT = "[redacted-rationale]";
+const REDACTED_REPLAY_TEXT = "[redacted-replay-bytes]";
+const SENSITIVE_ASSIGNMENT_VALUE_PATTERN = "\"[^\"]*\"|'[^']*'|\\{[^}\\n\\r]*\\}|\\[[^\\]\\n\\r]*\\]|[^\\s,;|]+";
+const TEXT_REDACTION_PATTERNS = Object.freeze([
+    {
+        pattern: new RegExp(`\\b${["sk", "or"].join("-")}-[A-Za-z0-9._-]+`, "g"),
+        replacement: REDACTED_TEXT,
+    },
+    {
+        pattern: new RegExp(`\\b${["Bear", "er"].join("")} [A-Za-z0-9._-]+`, "g"),
+        replacement: REDACTED_TEXT,
+    },
+    {
+        pattern: new RegExp(`\\b${["api", "Key"].join("")}\\s*[:=]\\s*[A-Za-z0-9._-]+`, "gi"),
+        replacement: REDACTED_TEXT,
+    },
+    {
+        pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi,
+        replacement: REDACTED_EMAIL_TEXT,
+    },
+    {
+        pattern: /\bhttps?:\/\/[^\s<>)\]}"']+/gi,
+        replacement: REDACTED_URL_TEXT,
+    },
+    {
+        pattern: new RegExp(`\\b(?:customer|tenant|account|user)[_-]?(?:payload|data|record|id|email)\\b\\s*[:=]\\s*(?:${SENSITIVE_ASSIGNMENT_VALUE_PATTERN})`, "gi"),
+        replacement: REDACTED_PRIVATE_TEXT,
+    },
+    {
+        pattern: new RegExp(`\\b(?:raw\\s+)?judge[_ -]?rationale\\b\\s*[:=]\\s*(?:${SENSITIVE_ASSIGNMENT_VALUE_PATTERN})`, "gi"),
+        replacement: REDACTED_RATIONALE_TEXT,
+    },
+    {
+        pattern: new RegExp(`\\braw[_ -]?replay[_ -]?bytes\\b\\s*[:=]\\s*(?:${SENSITIVE_ASSIGNMENT_VALUE_PATTERN})`, "gi"),
+        replacement: REDACTED_REPLAY_TEXT,
+    },
+    {
+        pattern: new RegExp(`\\b(?:memo[_ -]?key|run[_ -]?id|tags?|provider[_ -]?norm(?:alized)?(?:[_ -]?payload)?)\\b\\s*[:=]\\s*(?:${SENSITIVE_ASSIGNMENT_VALUE_PATTERN})`, "gi"),
+        replacement: REDACTED_RUNTIME_TEXT,
+    },
+]);
+function buildCradleEvalResultV0(input) {
+    assertNonEmptyString(input.suite_id, "suite_id");
+    assertIsoInstant(input.generated_at, "generated_at");
+    assertIsoInstant(input.as_of, "as_of");
+    assertModelMatrix(input.model_matrix);
+    if (input.cases.length === 0) {
+        throw new Error("cases must include at least one eval case");
+    }
+    const cases = Object.freeze(input.cases.map(normalizeCase));
+    const replayParitySummaryHashes = uniqueSortedHashes(cases.flatMap((item) => item.replay === undefined ? [] : [item.replay.summary_hash]));
+    const evidenceHashes = uniqueSortedHashes(cases.flatMap((item) => item.evidence_hashes));
+    const metrics = computeMetrics(cases, evidenceHashes.length);
+    const overallStatus = cases.some((item) => item.status === "fail") ? "fail" : "pass";
+    const payload = {
+        schema: exports.CRADLE_EVAL_RESULT_SCHEMA_V0,
+        v: exports.CRADLE_EVAL_RESULT_VERSION_V0,
+        generated_at: input.generated_at,
+        as_of: input.as_of,
+        suite_id: sanitizeText(input.suite_id),
+        overall_status: overallStatus,
+        metrics,
+        model_matrix: {
+            status: "not-run",
+            reason: sanitizeText(input.model_matrix.reason),
+        },
+        cases,
+        replay_parity_summary_hashes: replayParitySummaryHashes,
+        evidence_hashes: evidenceHashes,
+    };
+    return Object.freeze({
+        ...payload,
+        content_hash: hashCanonicalValue(payload),
+    });
+}
+exports.createCradleEvalResultV0 = buildCradleEvalResultV0;
+exports.createCradleEvalResultArtifactV0 = buildCradleEvalResultV0;
+exports.buildCradleEvalResultArtifactV0 = buildCradleEvalResultV0;
+function renderCradleEvalReportMarkdownV0(result) {
+    const caseRows = result.cases.map((item) => {
+        const assertionSummary = `${item.assertions.pass_count}/${item.assertions.results.length} pass`;
+        const replaySummary = item.replay === undefined
+            ? "not run"
+            : `${item.replay.kind} ${item.replay.status} ${item.replay.summary_hash}`;
+        return [
+            item.case_id,
+            item.scenario_id,
+            item.status,
+            assertionSummary,
+            replaySummary,
+            item.evidence_hashes.join("<br>"),
+        ]
+            .map(markdownTableCell)
+            .join(" | ");
+    });
+    const evidenceHashLines = result.evidence_hashes.length === 0
+        ? ["- none"]
+        : result.evidence_hashes.map((hash) => `- \`${hash}\``);
+    const replayHashLines = result.replay_parity_summary_hashes.length === 0
+        ? ["- none"]
+        : result.replay_parity_summary_hashes.map((hash) => `- \`${hash}\``);
+    return [
+        "# Cradle Eval Report",
+        "",
+        `Artifact hash: \`${result.content_hash}\``,
+        `Suite: \`${markdownInline(result.suite_id)}\``,
+        `Generated at: \`${result.generated_at}\``,
+        `As of: \`${result.as_of}\``,
+        "",
+        "## Pass/Fail Summary",
+        `- Overall: ${result.overall_status}`,
+        `- Cases: ${result.metrics.case_pass_count}/${result.metrics.case_count} pass, ${result.metrics.case_fail_count} fail`,
+        `- Assertions: ${result.metrics.assertion_pass_count}/${result.metrics.assertion_count} pass, ${result.metrics.assertion_fail_count} fail`,
+        `- Replay/parity: ${result.metrics.replay_parity_pass_count}/${result.metrics.replay_parity_summary_count} pass, ${result.metrics.replay_parity_fail_count} fail, ${result.metrics.replay_parity_future_rows} future rows`,
+        "",
+        "## Case Table",
+        "| Case | Scenario | Status | Assertions | Replay/parity | Evidence hashes |",
+        "| --- | --- | --- | --- | --- | --- |",
+        ...caseRows.map((row) => `| ${row} |`),
+        "",
+        "## Deferred Live Matrix",
+        `Live model matrix is ${result.model_matrix.status}: ${sanitizeText(result.model_matrix.reason)}`,
+        "",
+        "## Replay/Parity Summary Hashes",
+        ...replayHashLines,
+        "",
+        "## Evidence Hashes",
+        ...evidenceHashLines,
+        "",
+    ].join("\n");
+}
+exports.renderCradleEvalMarkdownReportV0 = renderCradleEvalReportMarkdownV0;
+function projectCradleEvalResultV0(result, tier) {
+    assertProjectionTier(tier);
+    assertContentHash(result.content_hash, "result.content_hash");
+    const payload = {
+        schema: exports.CRADLE_EVAL_PROJECTION_SCHEMA_V0,
+        v: exports.CRADLE_EVAL_PROJECTION_VERSION_V0,
+        tier,
+        source_content_hash: result.content_hash,
+        generated_at: result.generated_at,
+        as_of: result.as_of,
+        suite_id: sanitizeText(result.suite_id),
+        overall_status: normalizeStatus(result.overall_status, "overall_status"),
+        metrics: result.metrics,
+        model_matrix: {
+            status: "not-run",
+            reason: sanitizeText(result.model_matrix.reason),
+        },
+        cases: Object.freeze(result.cases.map(projectCase)),
+        replay_parity_summary_hashes: uniqueSortedHashes(result.replay_parity_summary_hashes),
+        evidence_hashes: uniqueSortedHashes(result.evidence_hashes),
+    };
+    return Object.freeze({
+        ...payload,
+        content_hash: hashCanonicalValue(payload),
+    });
+}
+exports.createCradleEvalProjectionV0 = projectCradleEvalResultV0;
+exports.projectCradleEvalResultArtifactV0 = projectCradleEvalResultV0;
+function renderCradleEvalProjectionReportMarkdownV0(projection) {
+    const caseRows = projection.cases.map((item) => {
+        const assertionSummary = `${item.assertions.pass_count}/${item.assertions.results.length} pass`;
+        const replaySummary = item.replay === undefined
+            ? "not run"
+            : `${item.replay.kind} ${item.replay.status} ${item.replay.summary_hash}`;
+        return [
+            item.case_id,
+            item.scenario_id,
+            item.status,
+            assertionSummary,
+            replaySummary,
+            item.evidence_hashes.join("<br>"),
+        ]
+            .map(markdownTableCell)
+            .join(" | ");
+    });
+    const evidenceHashLines = projection.evidence_hashes.length === 0
+        ? ["- none"]
+        : projection.evidence_hashes.map((hash) => `- \`${hash}\``);
+    const replayHashLines = projection.replay_parity_summary_hashes.length === 0
+        ? ["- none"]
+        : projection.replay_parity_summary_hashes.map((hash) => `- \`${hash}\``);
+    return [
+        "# Cradle Eval Projection",
+        "",
+        `Projection hash: \`${projection.content_hash}\``,
+        `Source artifact hash: \`${projection.source_content_hash}\``,
+        `Tier: \`${projection.tier}\``,
+        `Suite: \`${markdownInline(projection.suite_id)}\``,
+        `Generated at: \`${projection.generated_at}\``,
+        `As of: \`${projection.as_of}\``,
+        "",
+        "## Pass/Fail Summary",
+        `- Overall: ${projection.overall_status}`,
+        `- Cases: ${projection.metrics.case_pass_count}/${projection.metrics.case_count} pass, ${projection.metrics.case_fail_count} fail`,
+        `- Assertions: ${projection.metrics.assertion_pass_count}/${projection.metrics.assertion_count} pass, ${projection.metrics.assertion_fail_count} fail`,
+        `- Replay/parity: ${projection.metrics.replay_parity_pass_count}/${projection.metrics.replay_parity_summary_count} pass, ${projection.metrics.replay_parity_fail_count} fail, ${projection.metrics.replay_parity_future_rows} future rows`,
+        "",
+        "## Case Table",
+        "| Case | Scenario | Status | Assertions | Replay/parity | Evidence hashes |",
+        "| --- | --- | --- | --- | --- | --- |",
+        ...caseRows.map((row) => `| ${row} |`),
+        "",
+        "## Deferred Live Matrix",
+        `Live model matrix is ${projection.model_matrix.status}: ${sanitizeText(projection.model_matrix.reason)}`,
+        "",
+        "## Replay/Parity Summary Hashes",
+        ...replayHashLines,
+        "",
+        "## Evidence Hashes",
+        ...evidenceHashLines,
+        "",
+    ].join("\n");
+}
+exports.renderCradleEvalProjectionMarkdownReportV0 = renderCradleEvalProjectionReportMarkdownV0;
+function normalizeCase(input) {
+    assertNonEmptyString(input.case_id, "case_id");
+    const assertions = normalizeAssertionSuite(input.assertions);
+    const replay = input.replay === undefined ? undefined : summarizeReplayInput(input.replay);
+    const caseEvidenceHashes = uniqueSortedHashes([
+        ...assertions.results.map((item) => item.result_hash),
+        ...(replay === undefined ? [] : [replay.summary_hash]),
+        ...(input.evidence_hashes ?? []),
+    ]);
+    const status = assertions.status === "fail" || replay?.status === "fail" ? "fail" : "pass";
+    return Object.freeze({
+        case_id: sanitizeText(input.case_id),
+        scenario_id: sanitizeText(input.scenario_id ?? input.case_id),
+        status,
+        assertions,
+        ...(replay === undefined ? {} : { replay }),
+        evidence_hashes: caseEvidenceHashes,
+    });
+}
+function normalizeAssertionSuite(input) {
+    const sourceResults = isAssertionResultArray(input)
+        ? input
+        : input.results;
+    if (sourceResults.length === 0) {
+        throw new Error("assertions must include at least one result");
+    }
+    const results = sourceResults.map(normalizeAssertionResult);
+    const failCount = results.filter((item) => item.status === "fail").length;
+    const passCount = results.length - failCount;
+    return Object.freeze({
+        status: failCount === 0 ? "pass" : "fail",
+        pass_count: passCount,
+        fail_count: failCount,
+        results: Object.freeze(results),
+    });
+}
+function normalizeAssertionResult(input) {
+    const evidence = input.evidence.map(normalizeAssertionEvidence);
+    const payload = {
+        family: sanitizeText(input.family),
+        relationship: sanitizeText(input.relationship),
+        status: normalizeStatus(input.status, "assertion status"),
+        summary: sanitizeText(input.summary),
+        evidence,
+    };
+    return Object.freeze({
+        ...payload,
+        result_hash: hashCanonicalValue(payload),
+    });
+}
+function normalizeAssertionEvidence(input) {
+    const observedHash = input.observed === undefined
+        ? undefined
+        : hashRedactedObservedValue(input.observed);
+    return Object.freeze({
+        path: sanitizeText(input.path),
+        message: sanitizeText(input.message),
+        ...(observedHash === undefined ? {} : { observed_hash: observedHash }),
+    });
+}
+function summarizeReplayInput(input) {
+    if (input.relationship === "replay-byte-identical") {
+        return summarizeReplayByteIdentical(input);
+    }
+    return summarizeReplayParityMatrix(input);
+}
+function summarizeReplayByteIdentical(input) {
+    const payload = {
+        kind: "replay-byte-identical",
+        ...summarizeReplayByteIdenticalWithoutKind(input),
+    };
+    return Object.freeze({
+        ...payload,
+        summary_hash: hashCanonicalValue(payload),
+    });
+}
+function summarizeReplayByteIdenticalWithoutKind(input) {
+    const payload = {
+        status: input.ok ? "pass" : "fail",
+        expected_hash: input.expected_hash,
+        actual_hash: input.actual_hash,
+        evidence_path: sanitizeText(input.evidence_path),
+        ...("byte_length" in input ? { byte_length: input.byte_length } : {}),
+        ...("reason" in input ? { reason: sanitizeText(input.reason) } : {}),
+    };
+    return Object.freeze(payload);
+}
+function projectCase(input) {
+    return Object.freeze({
+        case_id: sanitizeText(input.case_id),
+        scenario_id: sanitizeText(input.scenario_id),
+        status: normalizeStatus(input.status, "case status"),
+        assertions: projectAssertionSuite(input.assertions),
+        ...(input.replay === undefined ? {} : { replay: projectReplay(input.replay) }),
+        evidence_hashes: uniqueSortedHashes(input.evidence_hashes),
+    });
+}
+function projectAssertionSuite(input) {
+    return Object.freeze({
+        status: normalizeStatus(input.status, "assertion suite status"),
+        pass_count: input.pass_count,
+        fail_count: input.fail_count,
+        results: Object.freeze(input.results.map(projectAssertionResult)),
+    });
+}
+function projectAssertionResult(input) {
+    return Object.freeze({
+        family: sanitizeText(input.family),
+        relationship: sanitizeText(input.relationship),
+        status: normalizeStatus(input.status, "assertion status"),
+        summary: sanitizeText(input.summary),
+        result_hash: input.result_hash,
+        evidence_count: input.evidence.length,
+        observed_hashes: uniqueSortedHashes(input.evidence.flatMap((item) => item.observed_hash === undefined ? [] : [item.observed_hash])),
+    });
+}
+function projectReplay(input) {
+    if (input.kind === "replay-byte-identical") {
+        return projectReplayByteIdentical(input);
+    }
+    return projectReplayParityMatrix(input);
+}
+function projectReplayByteIdentical(input) {
+    return Object.freeze({
+        kind: "replay-byte-identical",
+        ...projectReplayByteIdenticalWithoutKind(input),
+        summary_hash: input.summary_hash,
+    });
+}
+function projectReplayByteIdenticalWithoutKind(input) {
+    return Object.freeze({
+        status: normalizeStatus(input.status, "replay status"),
+        expected_hash: input.expected_hash,
+        actual_hash: input.actual_hash,
+        ...("byte_length" in input ? { byte_length: input.byte_length } : {}),
+        ...("reason" in input ? { reason: sanitizeText(input.reason) } : {}),
+    });
+}
+function projectReplayParityMatrix(input) {
+    return Object.freeze({
+        kind: "cross-adapter-parity",
+        status: normalizeStatus(input.status, "replay parity status"),
+        ready_rows_run: input.ready_rows_run,
+        future_rows: input.future_rows,
+        rows: Object.freeze(input.rows.map(projectReplayParityRow)),
+        summary_hash: input.summary_hash,
+    });
+}
+function projectReplayParityRow(input) {
+    return Object.freeze({
+        adapter_name: sanitizeText(input.adapter_name),
+        storage_adapter: sanitizeText(input.storage_adapter),
+        status: sanitizeText(input.status),
+        ...("reason" in input ? { reason: sanitizeText(input.reason) } : {}),
+        ...("check" in input && input.check !== undefined
+            ? { check: projectReplayByteIdenticalWithoutKind(input.check) }
+            : {}),
+    });
+}
+function summarizeReplayParityMatrix(input) {
+    const status = input.ok ? "pass" : "fail";
+    const payload = {
+        kind: "cross-adapter-parity",
+        status,
+        ready_rows_run: input.ready_rows_run,
+        future_rows: input.future_rows,
+        rows: Object.freeze(input.rows.map(summarizeReplayParityRow)),
+    };
+    return Object.freeze({
+        ...payload,
+        summary_hash: hashCanonicalValue(payload),
+    });
+}
+function summarizeReplayParityRow(input) {
+    return Object.freeze({
+        adapter_name: sanitizeText(input.adapter_name),
+        storage_adapter: sanitizeText(input.storage_adapter),
+        status: sanitizeText(input.status),
+        ...("reason" in input ? { reason: sanitizeText(input.reason) } : {}),
+        ...("check" in input && input.check !== undefined
+            ? { check: summarizeReplayByteIdenticalWithoutKind(input.check) }
+            : {}),
+    });
+}
+function computeMetrics(cases, evidenceHashCount) {
+    const assertionResults = cases.flatMap((item) => item.assertions.results);
+    const replaySummaries = cases.flatMap((item) => item.replay === undefined ? [] : [item.replay]);
+    const replayParitySummaries = replaySummaries.filter((item) => item.kind === "cross-adapter-parity");
+    return Object.freeze({
+        case_count: cases.length,
+        case_pass_count: cases.filter((item) => item.status === "pass").length,
+        case_fail_count: cases.filter((item) => item.status === "fail").length,
+        assertion_count: assertionResults.length,
+        assertion_pass_count: assertionResults.filter((item) => item.status === "pass").length,
+        assertion_fail_count: assertionResults.filter((item) => item.status === "fail").length,
+        replay_parity_summary_count: replaySummaries.length,
+        replay_parity_pass_count: replaySummaries.filter((item) => item.status === "pass").length,
+        replay_parity_fail_count: replaySummaries.filter((item) => item.status === "fail").length,
+        replay_parity_ready_rows_run: replayParitySummaries.reduce((sum, item) => sum + item.ready_rows_run, 0),
+        replay_parity_future_rows: replayParitySummaries.reduce((sum, item) => sum + item.future_rows, 0),
+        evidence_hash_count: evidenceHashCount,
+    });
+}
+function hashRedactedObservedValue(value) {
+    try {
+        return hashCanonicalValue(redactJsonValue(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+function hashCanonicalValue(value) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(renderCanonical(value)).digest("hex")}`;
+}
+function redactJsonValue(value) {
+    if (value === null) {
+        return null;
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "number":
+            return value;
+        case "string":
+            return sanitizeText(value);
+        case "object":
+            if (Array.isArray(value)) {
+                return value.map(redactJsonValue);
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("observed value is not canonical JSON");
+            }
+            return redactJsonObject(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`observed value cannot be ${typeof value}`);
+    }
+}
+function redactJsonObject(value) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+        const item = value[key];
+        if (item === undefined) {
+            continue;
+        }
+        result[redactedObjectKey(result, sanitizeText(key))] = redactJsonValue(item);
+    }
+    return result;
+}
+function sanitizeText(value) {
+    return TEXT_REDACTION_PATTERNS.reduce((current, item) => current.replace(item.pattern, item.replacement), value);
+}
+function redactedObjectKey(result, key) {
+    if (!(key in result)) {
+        return key;
+    }
+    let index = 2;
+    let candidate = `${key}#${index}`;
+    while (candidate in result) {
+        index += 1;
+        candidate = `${key}#${index}`;
+    }
+    return candidate;
+}
+function normalizeStatus(status, label) {
+    if (status === "pass" || status === "fail") {
+        return status;
+    }
+    throw new Error(`${label} must be pass or fail`);
+}
+function uniqueSortedHashes(values) {
+    const seen = new Set();
+    for (const value of values) {
+        assertContentHash(value, "evidence hash");
+        seen.add(value);
+    }
+    return Object.freeze(Array.from(seen).sort());
+}
+function assertModelMatrix(value) {
+    if (value.status !== "not-run") {
+        throw new Error("model_matrix.status must be not-run");
+    }
+    assertNonEmptyString(value.reason, "model_matrix.reason");
+}
+function assertProjectionTier(value) {
+    if (value !== "owner" && value !== "subscriber" && value !== "public") {
+        throw new Error("projection tier must be owner, subscriber, or public");
+    }
+}
+function assertNonEmptyString(value, label) {
+    if (value.length === 0) {
+        throw new Error(`${label} must be non-empty`);
+    }
+}
+function assertIsoInstant(value, label) {
+    if (!ISO_INSTANT_PATTERN.test(value)) {
+        throw new Error(`${label} must be an ISO instant string`);
+    }
+}
+function assertContentHash(value, label) {
+    if (!CONTENT_HASH_PATTERN.test(value)) {
+        throw new Error(`${label} must be a sha256 content hash`);
+    }
+}
+function isAssertionResultArray(value) {
+    return Array.isArray(value);
+}
+function markdownTableCell(value) {
+    return sanitizeText(value).replace(/\|/g, "\\|").replace(/\n/g, "<br>");
+}
+function markdownInline(value) {
+    return sanitizeText(value).replace(/`/g, "\\`");
+}
+function renderCanonical(value) {
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "boolean":
+            return value ? "true" : "false";
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new TypeError("Cannot canonicalize non-finite numbers");
+            }
+            return JSON.stringify(value);
+        case "string":
+            return JSON.stringify(value);
+        case "object":
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => renderCanonical(item)).join(",")}]`;
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("Cannot canonicalize non-plain objects");
+            }
+            return renderCanonicalObject(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`Cannot canonicalize ${typeof value}`);
+    }
+    throw new TypeError("Cannot canonicalize unknown value");
+}
+function renderCanonicalObject(value) {
+    const fields = [];
+    for (const key of Object.keys(value).sort()) {
+        const item = value[key];
+        if (item === undefined) {
+            throw new TypeError(`Cannot canonicalize undefined field ${key}`);
+        }
+        fields.push(`${JSON.stringify(key)}:${renderCanonical(item)}`);
+    }
+    return `{${fields.join(",")}}`;
+}
+function isPlainRecord(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./assert";
+export * from "./baselines/cost-thesis";
+export * from "./baselines/no-memo";
+export * from "./baselines/naive-loop";
+export * from "./doubles/clock";
+export * from "./doubles/storage";
+export * from "./eval";
+export * from "./policy-author";
+export * from "./policy-drift";
+export * from "./policy-replay";
+export * from "./provider-parity";
+export * from "./recompile";
+export * from "./release-parity";
+export * from "./release-candidate";
+export * from "./rollback";
+export * from "./replay/model-gateway";
+export * from "./replay/parity";
+export * from "./scenario/parser";
+export * from "./scenario/runner";
+export * from "./scenario/time";
+export * from "./scenario/types";
+export * from "./spikes";
+export * from "./world";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assert"), exports);
+__exportStar(require("./baselines/cost-thesis"), exports);
+__exportStar(require("./baselines/no-memo"), exports);
+__exportStar(require("./baselines/naive-loop"), exports);
+__exportStar(require("./doubles/clock"), exports);
+__exportStar(require("./doubles/storage"), exports);
+__exportStar(require("./eval"), exports);
+__exportStar(require("./policy-author"), exports);
+__exportStar(require("./policy-drift"), exports);
+__exportStar(require("./policy-replay"), exports);
+__exportStar(require("./provider-parity"), exports);
+__exportStar(require("./recompile"), exports);
+__exportStar(require("./release-parity"), exports);
+__exportStar(require("./release-candidate"), exports);
+__exportStar(require("./rollback"), exports);
+__exportStar(require("./replay/model-gateway"), exports);
+__exportStar(require("./replay/parity"), exports);
+__exportStar(require("./scenario/parser"), exports);
+__exportStar(require("./scenario/runner"), exports);
+__exportStar(require("./scenario/time"), exports);
+__exportStar(require("./scenario/types"), exports);
+__exportStar(require("./spikes"), exports);
+__exportStar(require("./world"), exports);