@openprose/reactor 0.1.0-rc.1

package/dist/receipt/index.js

@@ -0,0 +1,646 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NULL_SIGNER_ADAPTER_NOT_CONFIGURED_REASON_V0 = exports.RECEIPT_HASH_ALGORITHM = exports.RECEIPT_VERSION = exports.RECEIPT_SCHEMA = void 0;
+exports.createNullSignerReceiptSignatureV0 = createNullSignerReceiptSignatureV0;
+exports.createReceiptV0 = createReceiptV0;
+exports.verifyReceiptV0 = verifyReceiptV0;
+exports.assertReceiptV0 = assertReceiptV0;
+exports.inspectReceiptProofV0 = inspectReceiptProofV0;
+exports.readTokenTruthV0 = readTokenTruthV0;
+exports.serializeReceiptV0 = serializeReceiptV0;
+exports.computeReceiptContentHashV0 = computeReceiptContentHashV0;
+exports.canonicalizeForReceiptV0 = canonicalizeForReceiptV0;
+exports.hashCanonicalReceiptV0 = hashCanonicalReceiptV0;
+const node_crypto_1 = require("node:crypto");
+exports.RECEIPT_SCHEMA = "openprose.receipt";
+exports.RECEIPT_VERSION = 0;
+exports.RECEIPT_HASH_ALGORITHM = "sha256";
+exports.NULL_SIGNER_ADAPTER_NOT_CONFIGURED_REASON_V0 = "no-signer-adapter-configured";
+function createNullSignerReceiptSignatureV0() {
+    return {
+        scheme: "none",
+        null_reason: exports.NULL_SIGNER_ADAPTER_NOT_CONFIGURED_REASON_V0,
+    };
+}
+const CONTENT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const ISO_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+const EVENT_CAUSES = new Set([
+    "real-input",
+    "forecast-recheck",
+    "escalation",
+]);
+const RECHECK_KINDS = new Set([
+    "evidence-age",
+    "plan-age",
+]);
+const ROLES = new Set([
+    "judge",
+    "fulfill",
+    "summarize",
+    "policy-compile",
+]);
+const VERDICT_STATUSES = new Set([
+    "up",
+    "drifting",
+    "down",
+    "blocked",
+]);
+const CALIBRATION_GRADES = new Set([
+    "authored",
+    "accrued",
+    "none",
+]);
+const INTERRUPT_CAUSES = new Set([
+    "needs-judgment",
+    "needs-input",
+    "contract-declared",
+]);
+const STALENESS_OUTCOMES = new Set([
+    "fresh",
+    "stale-refetched",
+    "stale-blocked",
+]);
+function createReceiptV0(input) {
+    const payload = {
+        schema: exports.RECEIPT_SCHEMA,
+        v: exports.RECEIPT_VERSION,
+        hash_algorithm: exports.RECEIPT_HASH_ALGORITHM,
+        core: input.core,
+        sig: input.sig,
+        verdict: input.verdict,
+        freshness: input.freshness,
+        composition: input.composition,
+        cost: input.cost,
+    };
+    const receipt = {
+        ...payload,
+        content_hash: computeReceiptContentHashV0(payload),
+    };
+    const verification = verifyReceiptV0(receipt);
+    if (!verification.ok) {
+        throw new Error(`Invalid receipt v0 input: ${verification.errors.join("; ")}`);
+    }
+    return receipt;
+}
+function verifyReceiptV0(value) {
+    const errors = [];
+    if (!isRecord(value)) {
+        return { ok: false, errors: ["receipt must be an object"] };
+    }
+    validateReceiptShape(value, errors);
+    let expectedContentHash;
+    try {
+        expectedContentHash = computeReceiptContentHashV0(value);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : "content hash failed");
+    }
+    const actualContentHash = value["content_hash"];
+    if (typeof actualContentHash !== "string") {
+        errors.push("content_hash must be a sha256 content address");
+    }
+    else if (!CONTENT_HASH_PATTERN.test(actualContentHash)) {
+        errors.push("content_hash must use sha256:<64 lowercase hex>");
+    }
+    else if (expectedContentHash !== undefined &&
+        actualContentHash !== expectedContentHash) {
+        errors.push("content_hash does not match canonical receipt payload");
+    }
+    if (errors.length > 0) {
+        const failure = { ok: false, errors };
+        return {
+            ...failure,
+            ...(expectedContentHash === undefined
+                ? {}
+                : { expected_content_hash: expectedContentHash }),
+            ...(typeof actualContentHash === "string"
+                ? { actual_content_hash: actualContentHash }
+                : {}),
+        };
+    }
+    return {
+        ok: true,
+        content_hash: actualContentHash,
+    };
+}
+function assertReceiptV0(value) {
+    const verification = verifyReceiptV0(value);
+    if (!verification.ok) {
+        throw new Error(`Invalid receipt v0: ${verification.errors.join("; ")}`);
+    }
+}
+function inspectReceiptProofV0(value) {
+    const verification = verifyReceiptV0(value);
+    const receipt = isRecord(value) ? value : undefined;
+    const core = readRecord(receipt, "core");
+    return {
+        ok: verification.ok,
+        errors: verification.ok ? [] : verification.errors,
+        schema: readString(receipt, "schema"),
+        v: readNumber(receipt, "v"),
+        content_hash: verification.ok ? verification.content_hash : null,
+        contract_revision: readContentHash(core, "contract_revision"),
+        responsibility_id: readString(core, "responsibility_id"),
+        role: readString(core, "role"),
+        signer: inspectSigner(readRecord(receipt, "sig")),
+        freshness: inspectFreshness(readRecord(receipt, "freshness")),
+        composition: inspectComposition(readRecord(receipt, "composition")),
+        token_truth: inspectTokenTruth(readRecord(receipt, "cost")),
+    };
+}
+function readTokenTruthV0(receipt) {
+    return {
+        responsibility_id: receipt.cost.responsibility_id,
+        run_id: receipt.cost.run_id,
+        provider: receipt.cost.provider,
+        model: receipt.cost.model,
+        role: receipt.cost.role,
+        tags: receipt.cost.tags,
+        as_of: receipt.cost.as_of,
+        fresh: receipt.cost.tokens.fresh,
+        reused: receipt.cost.tokens.reused,
+        surprise_cause: receipt.cost.surprise_cause,
+    };
+}
+function serializeReceiptV0(receipt) {
+    assertReceiptV0(receipt);
+    return canonicalizeForReceiptV0(receipt);
+}
+function computeReceiptContentHashV0(value) {
+    const payload = withoutContentHash(value);
+    return hashCanonicalReceiptV0(canonicalizeForReceiptV0(payload));
+}
+function canonicalizeForReceiptV0(value) {
+    return renderCanonical(value);
+}
+function hashCanonicalReceiptV0(canonical) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(canonical).digest("hex")}`;
+}
+function inspectSigner(sig) {
+    const scheme = readString(sig, "scheme");
+    if (scheme === null || scheme.length === 0) {
+        return null;
+    }
+    if (scheme === "none") {
+        return { kind: "null", scheme };
+    }
+    return { kind: "signed", scheme };
+}
+function inspectFreshness(freshness) {
+    const consumed = freshness?.["consumed_freshness_evaluated"];
+    return {
+        as_of: readString(freshness, "as_of"),
+        next_forecast_recheck: readString(freshness, "next_forecast_recheck"),
+        transitive_freshness_policy_ref: readString(freshness, "transitive_freshness_policy_ref"),
+        consumed_freshness_evaluated_count: Array.isArray(consumed)
+            ? consumed.length
+            : 0,
+    };
+}
+function inspectComposition(composition) {
+    const consumed = composition?.["consumed_receipts"];
+    const consumedReceipts = Array.isArray(consumed) ? consumed : [];
+    return {
+        consumed_receipt_count: consumedReceipts.length,
+        consumed_receipts: consumedReceipts
+            .filter(isRecord)
+            .map((pin) => ({
+            upstream_content_hash: readContentHash(pin, "upstream_content_hash"),
+            contract_revision: readContentHash(pin, "contract_revision"),
+            acceptable_signer_set: readStringArray(pin, "acceptable_signer_set"),
+        })),
+        cycle_checked: readBoolean(composition, "cycle_checked"),
+    };
+}
+function inspectTokenTruth(cost) {
+    const tokens = readRecord(cost, "tokens");
+    return {
+        fresh: readNumber(tokens, "fresh"),
+        reused: readNumber(tokens, "reused"),
+        provider: readString(cost, "provider"),
+        model: readString(cost, "model"),
+        role: readString(cost, "role"),
+        surprise_cause: readString(cost, "surprise_cause"),
+    };
+}
+function readRecord(record, key) {
+    const value = record?.[key];
+    return isRecord(value) ? value : undefined;
+}
+function readString(record, key) {
+    const value = record?.[key];
+    return typeof value === "string" ? value : null;
+}
+function readNumber(record, key) {
+    const value = record?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readBoolean(record, key) {
+    const value = record?.[key];
+    return typeof value === "boolean" ? value : null;
+}
+function readStringArray(record, key) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function readContentHash(record, key) {
+    const value = readString(record, key);
+    return value !== null && CONTENT_HASH_PATTERN.test(value)
+        ? value
+        : null;
+}
+function withoutContentHash(value) {
+    const { content_hash: _contentHash, ...payload } = value;
+    return payload;
+}
+function validateReceiptShape(receipt, errors) {
+    validateExactKeys(receipt, "receipt", [
+        "schema",
+        "v",
+        "hash_algorithm",
+        "content_hash",
+        "core",
+        "sig",
+        "verdict",
+        "freshness",
+        "composition",
+        "cost",
+    ], errors);
+    expectLiteral(receipt, "schema", exports.RECEIPT_SCHEMA, "receipt", errors);
+    expectLiteral(receipt, "v", exports.RECEIPT_VERSION, "receipt", errors);
+    expectLiteral(receipt, "hash_algorithm", exports.RECEIPT_HASH_ALGORITHM, "receipt", errors);
+    const core = expectRecord(receipt, "core", "receipt", errors);
+    if (core !== undefined) {
+        validateCore(core, errors);
+    }
+    const sig = expectRecord(receipt, "sig", "receipt", errors);
+    if (sig !== undefined) {
+        validateSignature(sig, errors);
+    }
+    const verdict = expectRecord(receipt, "verdict", "receipt", errors);
+    if (verdict !== undefined) {
+        validateVerdict(verdict, errors);
+    }
+    const freshness = expectRecord(receipt, "freshness", "receipt", errors);
+    if (freshness !== undefined) {
+        validateFreshness(freshness, errors);
+    }
+    const composition = expectRecord(receipt, "composition", "receipt", errors);
+    if (composition !== undefined) {
+        validateComposition(composition, errors);
+    }
+    const cost = expectRecord(receipt, "cost", "receipt", errors);
+    if (cost !== undefined) {
+        validateCost(cost, errors);
+    }
+    if (core !== undefined && freshness !== undefined) {
+        expectSameString("freshness.as_of", freshness["as_of"], "core.as_of", core["as_of"], errors);
+    }
+    if (freshness !== undefined && composition !== undefined) {
+        validateComposedFreshness(composition, freshness, errors);
+    }
+    if (core !== undefined && cost !== undefined) {
+        expectSameString("cost.responsibility_id", cost["responsibility_id"], "core.responsibility_id", core["responsibility_id"], errors);
+        expectSameString("cost.role", cost["role"], "core.role", core["role"], errors);
+        expectSameString("cost.as_of", cost["as_of"], "core.as_of", core["as_of"], errors);
+        expectSameString("cost.surprise_cause", cost["surprise_cause"], "core.event_cause", core["event_cause"], errors);
+    }
+}
+function validateCore(core, errors) {
+    validateExactKeys(core, "core", [
+        "responsibility_id",
+        "contract_revision",
+        "event_cause",
+        "recheck_kind",
+        "memo_key",
+        "evidence_input_ids",
+        "as_of",
+        "role",
+    ], errors);
+    expectNonEmptyString(core, "responsibility_id", "core", errors);
+    expectContentHash(core, "contract_revision", "core", errors);
+    expectEnum(core, "event_cause", "core", EVENT_CAUSES, errors);
+    expectNonEmptyString(core, "memo_key", "core", errors);
+    expectContentHashArray(core, "evidence_input_ids", "core", errors);
+    expectIsoInstant(core, "as_of", "core", errors);
+    expectEnum(core, "role", "core", ROLES, errors);
+    const eventCause = core["event_cause"];
+    const recheckKind = core["recheck_kind"];
+    if (eventCause === "forecast-recheck") {
+        expectEnum(core, "recheck_kind", "core", RECHECK_KINDS, errors);
+    }
+    else if (recheckKind !== undefined) {
+        errors.push("core.recheck_kind is only valid for forecast-recheck");
+    }
+}
+function validateSignature(sig, errors) {
+    const scheme = sig["scheme"];
+    if (scheme === "none") {
+        validateExactKeys(sig, "sig", ["scheme", "null_reason"], errors);
+        expectNonEmptyString(sig, "null_reason", "sig", errors);
+        return;
+    }
+    validateExactKeys(sig, "sig", ["scheme", "signer_id", "signature", "signed_payload_hash"], errors);
+    expectNonEmptyString(sig, "scheme", "sig", errors);
+    expectNonEmptyString(sig, "signer_id", "sig", errors);
+    expectNonEmptyString(sig, "signature", "sig", errors);
+    expectContentHash(sig, "signed_payload_hash", "sig", errors);
+    errors.push("non-null signatures are not supported in receipt v0.1; null signer is the only honest v0.1 state");
+}
+function validateVerdict(verdict, errors) {
+    validateExactKeys(verdict, "verdict", ["status", "confidence", "blocked"], errors);
+    expectEnum(verdict, "status", "verdict", VERDICT_STATUSES, errors);
+    const confidence = expectRecord(verdict, "confidence", "verdict", errors);
+    if (confidence !== undefined) {
+        validateExactKeys(confidence, "verdict.confidence", ["value", "derivation_method", "calibration_grade", "label_source"], errors);
+        expectUnitInterval(confidence, "value", "verdict.confidence", errors);
+        expectNonEmptyString(confidence, "derivation_method", "verdict.confidence", errors);
+        expectEnum(confidence, "calibration_grade", "verdict.confidence", CALIBRATION_GRADES, errors);
+        expectNonEmptyString(confidence, "label_source", "verdict.confidence", errors);
+    }
+    const blocked = verdict["blocked"];
+    if (verdict["status"] === "blocked") {
+        const blockedRecord = expectRecord(verdict, "blocked", "verdict", errors);
+        if (blockedRecord !== undefined) {
+            validateBlocked(blockedRecord, errors);
+        }
+    }
+    else if (blocked !== undefined) {
+        errors.push("verdict.blocked is only valid when status is blocked");
+    }
+}
+function validateBlocked(blocked, errors) {
+    validateExactKeys(blocked, "verdict.blocked", ["reason", "fix_target", "interrupt_cause"], errors);
+    expectNonEmptyString(blocked, "reason", "verdict.blocked", errors);
+    expectNonEmptyString(blocked, "fix_target", "verdict.blocked", errors);
+    expectEnum(blocked, "interrupt_cause", "verdict.blocked", INTERRUPT_CAUSES, errors);
+}
+function validateFreshness(freshness, errors) {
+    validateExactKeys(freshness, "freshness", [
+        "as_of",
+        "next_forecast_recheck",
+        "transitive_freshness_policy_ref",
+        "consumed_freshness_evaluated",
+    ], errors);
+    expectIsoInstant(freshness, "as_of", "freshness", errors);
+    expectIsoInstant(freshness, "next_forecast_recheck", "freshness", errors);
+    if (freshness["transitive_freshness_policy_ref"] !== undefined) {
+        expectNonEmptyString(freshness, "transitive_freshness_policy_ref", "freshness", errors);
+    }
+    const consumed = freshness["consumed_freshness_evaluated"];
+    if (consumed !== undefined) {
+        if (!Array.isArray(consumed)) {
+            errors.push("freshness.consumed_freshness_evaluated must be an array");
+        }
+        else {
+            for (const [index, item] of consumed.entries()) {
+                const path = `freshness.consumed_freshness_evaluated[${index}]`;
+                if (!isRecord(item)) {
+                    errors.push(`${path} must be an object`);
+                    continue;
+                }
+                validateExactKeys(item, path, ["receipt_hash", "next_forecast_recheck", "staleness_outcome"], errors);
+                expectContentHash(item, "receipt_hash", path, errors);
+                expectIsoInstant(item, "next_forecast_recheck", path, errors);
+                expectEnum(item, "staleness_outcome", path, STALENESS_OUTCOMES, errors);
+            }
+        }
+    }
+}
+function validateComposition(composition, errors) {
+    validateExactKeys(composition, "composition", ["consumed_receipts", "cycle_checked"], errors);
+    expectBoolean(composition, "cycle_checked", "composition", errors);
+    const consumed = composition["consumed_receipts"];
+    if (!Array.isArray(consumed)) {
+        errors.push("composition.consumed_receipts must be an array");
+        return;
+    }
+    const seenHashes = new Set();
+    for (const [index, item] of consumed.entries()) {
+        const path = `composition.consumed_receipts[${index}]`;
+        if (!isRecord(item)) {
+            errors.push(`${path} must be an object`);
+            continue;
+        }
+        validateExactKeys(item, path, ["upstream_content_hash", "contract_revision", "acceptable_signer_set"], errors);
+        expectContentHash(item, "upstream_content_hash", path, errors);
+        expectContentHash(item, "contract_revision", path, errors);
+        expectStringArray(item, "acceptable_signer_set", path, errors);
+        if (Array.isArray(item["acceptable_signer_set"]) &&
+            item["acceptable_signer_set"].length === 0) {
+            errors.push(`${path}.acceptable_signer_set must not be empty`);
+        }
+        const hash = item["upstream_content_hash"];
+        if (typeof hash === "string") {
+            if (seenHashes.has(hash)) {
+                errors.push(`${path}.upstream_content_hash duplicates a consumed receipt`);
+            }
+            seenHashes.add(hash);
+        }
+    }
+}
+function validateComposedFreshness(composition, freshness, errors) {
+    const consumed = composition["consumed_receipts"];
+    if (!Array.isArray(consumed) || consumed.length === 0) {
+        return;
+    }
+    if (typeof freshness["transitive_freshness_policy_ref"] !== "string") {
+        errors.push("freshness.transitive_freshness_policy_ref is required when receipts are consumed");
+    }
+    const evaluated = freshness["consumed_freshness_evaluated"];
+    if (!Array.isArray(evaluated)) {
+        errors.push("freshness.consumed_freshness_evaluated is required when receipts are consumed");
+        return;
+    }
+    if (evaluated.length !== consumed.length) {
+        errors.push("freshness.consumed_freshness_evaluated must cover every consumed receipt");
+    }
+    const consumedHashes = new Set();
+    for (const item of consumed) {
+        if (isRecord(item) && typeof item["upstream_content_hash"] === "string") {
+            consumedHashes.add(item["upstream_content_hash"]);
+        }
+    }
+    for (const [index, item] of evaluated.entries()) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        const receiptHash = item["receipt_hash"];
+        if (typeof receiptHash === "string" && !consumedHashes.has(receiptHash)) {
+            errors.push(`freshness.consumed_freshness_evaluated[${index}].receipt_hash must match a consumed receipt`);
+        }
+    }
+}
+function validateCost(cost, errors) {
+    validateExactKeys(cost, "cost", [
+        "provider",
+        "model",
+        "role",
+        "tags",
+        "responsibility_id",
+        "run_id",
+        "as_of",
+        "tokens",
+        "surprise_cause",
+        "provider_norm",
+    ], errors);
+    expectNonEmptyString(cost, "provider", "cost", errors);
+    expectNonEmptyString(cost, "model", "cost", errors);
+    expectEnum(cost, "role", "cost", ROLES, errors);
+    expectStringArray(cost, "tags", "cost", errors);
+    expectNonEmptyString(cost, "responsibility_id", "cost", errors);
+    expectNonEmptyString(cost, "run_id", "cost", errors);
+    expectIsoInstant(cost, "as_of", "cost", errors);
+    expectEnum(cost, "surprise_cause", "cost", EVENT_CAUSES, errors);
+    const tokens = expectRecord(cost, "tokens", "cost", errors);
+    if (tokens !== undefined) {
+        validateExactKeys(tokens, "cost.tokens", ["fresh", "reused"], errors);
+        expectNonNegativeInteger(tokens, "fresh", "cost.tokens", errors);
+        expectNonNegativeInteger(tokens, "reused", "cost.tokens", errors);
+    }
+    const providerNorm = cost["provider_norm"];
+    if (providerNorm !== undefined) {
+        if (!isRecord(providerNorm)) {
+            errors.push("cost.provider_norm must be an object when present");
+        }
+        else {
+            expectNonEmptyString(providerNorm, "schema", "cost.provider_norm", errors);
+        }
+    }
+}
+function validateExactKeys(record, path, allowedKeys, errors) {
+    const allowed = new Set(allowedKeys);
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key)) {
+            errors.push(`${path}.${key} is not pinned in receipt v0`);
+        }
+    }
+}
+function expectLiteral(record, key, value, path, errors) {
+    if (record[key] !== value) {
+        errors.push(`${path}.${key} must be ${JSON.stringify(value)}`);
+    }
+}
+function expectRecord(record, key, path, errors) {
+    const value = record[key];
+    if (!isRecord(value)) {
+        errors.push(`${path}.${key} must be an object`);
+        return undefined;
+    }
+    return value;
+}
+function expectNonEmptyString(record, key, path, errors) {
+    const value = record[key];
+    if (typeof value !== "string" || value.length === 0) {
+        errors.push(`${path}.${key} must be a non-empty string`);
+    }
+}
+function expectContentHash(record, key, path, errors) {
+    const value = record[key];
+    if (typeof value !== "string" || !CONTENT_HASH_PATTERN.test(value)) {
+        errors.push(`${path}.${key} must use sha256:<64 lowercase hex>`);
+    }
+}
+function expectStringArray(record, key, path, errors) {
+    const value = record[key];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        errors.push(`${path}.${key} must be an array of strings`);
+    }
+}
+function expectContentHashArray(record, key, path, errors) {
+    const value = record[key];
+    if (!Array.isArray(value)) {
+        errors.push(`${path}.${key} must be an array of sha256 content addresses`);
+        return;
+    }
+    for (const [index, item] of value.entries()) {
+        if (typeof item !== "string" || !CONTENT_HASH_PATTERN.test(item)) {
+            errors.push(`${path}.${key}[${index}] must use sha256:<64 lowercase hex>`);
+        }
+    }
+}
+function expectBoolean(record, key, path, errors) {
+    if (typeof record[key] !== "boolean") {
+        errors.push(`${path}.${key} must be a boolean`);
+    }
+}
+function expectEnum(record, key, path, allowed, errors) {
+    const value = record[key];
+    if (typeof value !== "string" || !allowed.has(value)) {
+        errors.push(`${path}.${key} must be one of ${Array.from(allowed).join(", ")}`);
+    }
+}
+function expectIsoInstant(record, key, path, errors) {
+    const value = record[key];
+    if (typeof value !== "string" || !ISO_INSTANT_PATTERN.test(value)) {
+        errors.push(`${path}.${key} must be a replayable ISO instant`);
+    }
+}
+function expectUnitInterval(record, key, path, errors) {
+    const value = record[key];
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+        errors.push(`${path}.${key} must be a finite number between 0 and 1`);
+    }
+}
+function expectNonNegativeInteger(record, key, path, errors) {
+    const value = record[key];
+    if (!Number.isSafeInteger(value) || value < 0) {
+        errors.push(`${path}.${key} must be a non-negative safe integer`);
+    }
+}
+function expectSameString(leftPath, left, rightPath, right, errors) {
+    if (typeof left === "string" && typeof right === "string" && left !== right) {
+        errors.push(`${leftPath} must match ${rightPath}`);
+    }
+}
+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;
+}
+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 (!isRecord(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(",")}}`;
+}