@hazbase/simplicity 0.0.4 → 0.1.1

package/dist/domain/policies.js

@@ -0,0 +1,1605 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLICY_EVIDENCE_BUNDLE_SCHEMA_VERSION = exports.POLICY_VERIFICATION_REPORT_SCHEMA_VERSION = exports.POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION = void 0;
+exports.listPolicyTemplates = listPolicyTemplates;
+exports.describePolicyTemplate = describePolicyTemplate;
+exports.validatePolicyTemplateManifest = validatePolicyTemplateManifest;
+exports.loadPolicyTemplateManifest = loadPolicyTemplateManifest;
+exports.validatePolicyTemplateParams = validatePolicyTemplateParams;
+exports.summarizePolicyState = summarizePolicyState;
+exports.validatePolicyState = validatePolicyState;
+exports.summarizePolicyOutputDescriptor = summarizePolicyOutputDescriptor;
+exports.validatePolicyOutputDescriptor = validatePolicyOutputDescriptor;
+exports.summarizePolicyTransferDescriptor = summarizePolicyTransferDescriptor;
+exports.validatePolicyTransferDescriptor = validatePolicyTransferDescriptor;
+exports.compilePolicyStateContract = compilePolicyStateContract;
+exports.issue = issue;
+exports.verifyState = verifyState;
+exports.buildPolicyOutputDescriptor = buildPolicyOutputDescriptor;
+exports.prepareTransfer = prepareTransfer;
+exports.prepareDirectTransfer = prepareDirectTransfer;
+exports.verifyDirectTransfer = verifyDirectTransfer;
+exports.inspectDirectTransfer = inspectDirectTransfer;
+exports.executeDirectTransfer = executeDirectTransfer;
+exports.verifyTransfer = verifyTransfer;
+exports.inspectTransfer = inspectTransfer;
+exports.executeTransfer = executeTransfer;
+exports.exportEvidence = exportEvidence;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const summary_1 = require("../core/summary");
+const errors_1 = require("../core/errors");
+const outputBinding_1 = require("../core/outputBinding");
+function resolvePolicyDocsAsset(filename) {
+    const cwdCandidate = node_path_1.default.resolve(process.cwd(), "docs/definitions", filename);
+    if ((0, node_fs_1.existsSync)(cwdCandidate)) {
+        return cwdCandidate;
+    }
+    const bundledCandidate = node_path_1.default.resolve(__dirname, "../docs/definitions", filename);
+    if ((0, node_fs_1.existsSync)(bundledCandidate)) {
+        return bundledCandidate;
+    }
+    return cwdCandidate;
+}
+exports.POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION = "policy-template-manifest/v1";
+exports.POLICY_VERIFICATION_REPORT_SCHEMA_VERSION = "policy-verification-report/v1";
+exports.POLICY_EVIDENCE_BUNDLE_SCHEMA_VERSION = "policy-evidence-bundle/v1";
+const POLICY_TEMPLATE_MANIFESTS = {
+    "recursive-delay-required": {
+        templateId: "recursive-delay-required",
+        manifestVersion: exports.POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION,
+        title: "Recursive Delay (Required)",
+        description: "1tx recursive delay covenant that requires the next hop to remain policy-aware.",
+        stateSimfFilename: "recursive-delay-required.simf",
+        directStateSimfFilename: "recursive-delay-required.simf",
+        parameterSchema: { lockDistanceBlocks: "number" },
+        supportedBindingModes: ["script-bound", "descriptor-bound"],
+        supportsPlainExit: false,
+        defaultPropagationMode: "required",
+    },
+    "recursive-delay-optional": {
+        templateId: "recursive-delay-optional",
+        manifestVersion: exports.POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION,
+        title: "Recursive Delay (Optional)",
+        description: "1tx recursive delay covenant that can plain-exit or continue into the next policy-aware hop.",
+        stateSimfFilename: "recursive-delay-optional.simf",
+        directStateSimfFilename: "recursive-delay-required.simf",
+        parameterSchema: { lockDistanceBlocks: "number" },
+        supportedBindingModes: ["none", "script-bound", "descriptor-bound"],
+        supportsPlainExit: true,
+        defaultPropagationMode: "optional",
+    },
+};
+function resolveManifestKey(templateId, propagationMode) {
+    if (templateId in POLICY_TEMPLATE_MANIFESTS)
+        return templateId;
+    if (templateId === "recursive-delay") {
+        return propagationMode === "required" ? "recursive-delay-required" : "recursive-delay-optional";
+    }
+    throw new errors_1.ValidationError(`Unknown policy template: ${templateId}`, {
+        code: "POLICY_TEMPLATE_UNKNOWN",
+    });
+}
+function materializeBuiltInManifest(manifest) {
+    return {
+        templateId: manifest.templateId,
+        manifestVersion: manifest.manifestVersion,
+        title: manifest.title,
+        description: manifest.description,
+        stateSimfPath: resolvePolicyDocsAsset(manifest.stateSimfFilename),
+        ...(manifest.directStateSimfFilename
+            ? { directStateSimfPath: resolvePolicyDocsAsset(manifest.directStateSimfFilename) }
+            : {}),
+        parameterSchema: manifest.parameterSchema,
+        supportedBindingModes: manifest.supportedBindingModes,
+        supportsPlainExit: manifest.supportsPlainExit,
+        defaultPropagationMode: manifest.defaultPropagationMode,
+    };
+}
+function listPolicyTemplates() {
+    return Object.values(POLICY_TEMPLATE_MANIFESTS).map((manifest) => materializeBuiltInManifest(manifest));
+}
+function describePolicyTemplate(input) {
+    const manifest = POLICY_TEMPLATE_MANIFESTS[resolveManifestKey(input.templateId, input.propagationMode)];
+    return materializeBuiltInManifest(manifest);
+}
+function validatePolicyTemplateManifest(input) {
+    const value = input.manifestValue;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_REQUIRED",
+            reason: "Policy template manifest must be an object",
+        };
+    }
+    const manifest = value;
+    if (manifest.manifestVersion !== exports.POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_VERSION_UNSUPPORTED",
+            reason: `manifestVersion must be ${exports.POLICY_TEMPLATE_MANIFEST_SCHEMA_VERSION}`,
+        };
+    }
+    if (typeof manifest.templateId !== "string" || manifest.templateId.trim().length === 0) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_REQUIRED",
+            reason: "templateId must be a non-empty string",
+        };
+    }
+    if (typeof manifest.title !== "string" || manifest.title.trim().length === 0) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_REQUIRED",
+            reason: "title must be a non-empty string",
+        };
+    }
+    if (typeof manifest.description !== "string" || manifest.description.trim().length === 0) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_REQUIRED",
+            reason: "description must be a non-empty string",
+        };
+    }
+    if (typeof manifest.stateSimfPath !== "string" || manifest.stateSimfPath.trim().length === 0) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_REQUIRED",
+            reason: "stateSimfPath must be a non-empty string",
+        };
+    }
+    if (manifest.directStateSimfPath !== undefined
+        && (typeof manifest.directStateSimfPath !== "string" || manifest.directStateSimfPath.trim().length === 0)) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_INVALID",
+            reason: "directStateSimfPath must be a non-empty string when provided",
+        };
+    }
+    if (!manifest.parameterSchema || typeof manifest.parameterSchema !== "object" || Array.isArray(manifest.parameterSchema)) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_PARAMETER_SCHEMA_INVALID",
+            reason: "parameterSchema must be an object",
+        };
+    }
+    for (const [key, kind] of Object.entries(manifest.parameterSchema)) {
+        if (!["string", "number", "boolean"].includes(String(kind))) {
+            return {
+                ok: false,
+                reasonCode: "MANIFEST_PARAMETER_SCHEMA_INVALID",
+                reason: `parameterSchema.${key} must be string, number, or boolean`,
+            };
+        }
+    }
+    if (!Array.isArray(manifest.supportedBindingModes) || manifest.supportedBindingModes.length === 0) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_BINDING_MODE_INVALID",
+            reason: "supportedBindingModes must be a non-empty array",
+        };
+    }
+    for (const mode of manifest.supportedBindingModes) {
+        if (!["none", "script-bound", "descriptor-bound"].includes(String(mode))) {
+            return {
+                ok: false,
+                reasonCode: "MANIFEST_BINDING_MODE_INVALID",
+                reason: `Unsupported binding mode: ${String(mode)}`,
+            };
+        }
+    }
+    if (typeof manifest.supportsPlainExit !== "boolean") {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_FIELD_INVALID",
+            reason: "supportsPlainExit must be a boolean",
+        };
+    }
+    if (!["required", "optional", "none"].includes(String(manifest.defaultPropagationMode))) {
+        return {
+            ok: false,
+            reasonCode: "MANIFEST_PROPAGATION_MODE_INVALID",
+            reason: "defaultPropagationMode must be required, optional, or none",
+        };
+    }
+    return {
+        ok: true,
+        reasonCode: "OK",
+        manifest: {
+            templateId: manifest.templateId,
+            manifestVersion: manifest.manifestVersion,
+            title: manifest.title,
+            description: manifest.description,
+            stateSimfPath: manifest.stateSimfPath,
+            ...(manifest.directStateSimfPath ? { directStateSimfPath: manifest.directStateSimfPath } : {}),
+            parameterSchema: manifest.parameterSchema,
+            supportedBindingModes: manifest.supportedBindingModes,
+            supportsPlainExit: manifest.supportsPlainExit,
+            defaultPropagationMode: manifest.defaultPropagationMode,
+        },
+    };
+}
+async function loadPolicyTemplateManifest(input) {
+    if (input.manifestValue !== undefined) {
+        const validated = validatePolicyTemplateManifest({ manifestValue: input.manifestValue });
+        if (!validated.ok || !validated.manifest) {
+            throw new errors_1.ValidationError(validated.reason ?? "Policy template manifest is invalid", {
+                code: validated.reasonCode,
+            });
+        }
+        return validated.manifest;
+    }
+    if (input.manifestPath) {
+        const raw = await (0, promises_1.readFile)(input.manifestPath, "utf8");
+        const validated = validatePolicyTemplateManifest({ manifestValue: JSON.parse(raw) });
+        if (!validated.ok || !validated.manifest) {
+            throw new errors_1.ValidationError(validated.reason ?? "Policy template manifest is invalid", {
+                code: validated.reasonCode,
+            });
+        }
+        return validated.manifest;
+    }
+    if (!input.templateId) {
+        throw new errors_1.ValidationError("templateId or manifestPath/manifestValue is required", {
+            code: "POLICY_TEMPLATE_MANIFEST_REQUIRED",
+        });
+    }
+    return describePolicyTemplate({
+        templateId: input.templateId,
+        propagationMode: input.propagationMode,
+    });
+}
+function resolveValueOrPath(options) {
+    if (options.pathValue)
+        return { jsonPath: options.pathValue };
+    if (options.objectValue !== undefined)
+        return { value: options.objectValue };
+    return {};
+}
+function validatePropagationMode(mode) {
+    if (mode !== "required" && mode !== "optional" && mode !== "none") {
+        throw new errors_1.ValidationError("propagationMode must be required, optional, or none", {
+            code: "POLICY_PROPAGATION_MODE_INVALID",
+        });
+    }
+    return mode;
+}
+function validateReceiver(receiver) {
+    if (receiver.mode === "plain") {
+        if (!receiver.address || receiver.address.trim().length === 0) {
+            throw new errors_1.ValidationError("plain receiver requires a non-empty address", {
+                code: "POLICY_RECEIVER_ADDRESS_REQUIRED",
+            });
+        }
+        return receiver;
+    }
+    if (!receiver.recipientXonly || receiver.recipientXonly.trim().length === 0) {
+        throw new errors_1.ValidationError("policy receiver requires recipientXonly", {
+            code: "POLICY_RECEIVER_XONLY_REQUIRED",
+        });
+    }
+    return receiver;
+}
+function validatePolicyTemplateDocument(value, templateId) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { policyTemplateId: templateId };
+    }
+    const record = value;
+    const policyTemplateId = typeof record.policyTemplateId === "string" && record.policyTemplateId.trim().length > 0
+        ? record.policyTemplateId
+        : templateId;
+    return {
+        policyTemplateId,
+        ...(typeof record.description === "string" ? { description: record.description } : {}),
+        ...(record.metadata && typeof record.metadata === "object" && !Array.isArray(record.metadata)
+            ? { metadata: record.metadata }
+            : {}),
+    };
+}
+function summarizePolicyTemplateDocument(doc) {
+    const canonicalJson = (0, summary_1.stableStringify)(doc);
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function normalizeParams(params) {
+    return Object.fromEntries(Object.entries(params ?? {}).sort(([left], [right]) => left.localeCompare(right)));
+}
+function validatePolicyTemplateParams(input) {
+    const manifest = input.manifestValue
+        ? input.manifestValue
+        : describePolicyTemplate({
+            templateId: input.templateId ?? "recursive-delay",
+            propagationMode: input.propagationMode,
+        });
+    const params = normalizeParams(input.params);
+    for (const [key, value] of Object.entries(params)) {
+        const expected = manifest.parameterSchema[key];
+        if (!expected) {
+            throw new errors_1.ValidationError(`Unknown policy parameter: ${key}`, {
+                code: "POLICY_PARAM_UNKNOWN",
+            });
+        }
+        if (expected === "number" && !(typeof value === "number" && Number.isFinite(value))) {
+            throw new errors_1.ValidationError(`Policy parameter ${key} must be a number`, {
+                code: "POLICY_PARAM_TYPE_INVALID",
+            });
+        }
+        if (expected === "string" && typeof value !== "string") {
+            throw new errors_1.ValidationError(`Policy parameter ${key} must be a string`, {
+                code: "POLICY_PARAM_TYPE_INVALID",
+            });
+        }
+        if (expected === "boolean" && typeof value !== "boolean") {
+            throw new errors_1.ValidationError(`Policy parameter ${key} must be a boolean`, {
+                code: "POLICY_PARAM_TYPE_INVALID",
+            });
+        }
+    }
+    return params;
+}
+function summarizePolicyHash(input) {
+    const canonicalJson = (0, summary_1.stableStringify)({
+        policyTemplateId: input.template.policyTemplateId,
+        recipient: input.recipient,
+        params: normalizeParams(input.params),
+        propagationMode: input.propagationMode,
+    });
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function summarizePolicyState(state) {
+    const canonicalJson = (0, summary_1.stableStringify)({
+        policyTemplateId: state.policyTemplateId,
+        policyHash: state.policyHash,
+        recipient: state.recipient,
+        amountSat: state.amountSat,
+        assetId: state.assetId,
+        params: normalizeParams(state.params),
+        propagationMode: state.propagationMode,
+        previousStateHash: state.previousStateHash ?? null,
+        hop: state.hop,
+        status: state.status,
+    });
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function validatePolicyState(state) {
+    if (!state.policyTemplateId || state.policyTemplateId.trim().length === 0) {
+        throw new errors_1.ValidationError("policyTemplateId must be a non-empty string", { code: "POLICY_TEMPLATE_ID_REQUIRED" });
+    }
+    if (!/^[0-9a-f]{64}$/i.test(state.policyHash)) {
+        throw new errors_1.ValidationError("policyHash must be a 64-character hex string", { code: "POLICY_HASH_INVALID" });
+    }
+    if (!state.recipient || state.recipient.trim().length === 0) {
+        throw new errors_1.ValidationError("recipient must be a non-empty string", { code: "POLICY_RECIPIENT_REQUIRED" });
+    }
+    if (!Number.isInteger(state.amountSat) || state.amountSat <= 0) {
+        throw new errors_1.ValidationError("amountSat must be a positive integer", { code: "POLICY_AMOUNT_INVALID" });
+    }
+    if (!state.assetId || state.assetId.trim().length === 0) {
+        throw new errors_1.ValidationError("assetId must be a non-empty string", { code: "POLICY_ASSET_REQUIRED" });
+    }
+    validatePropagationMode(state.propagationMode);
+    if (!Number.isInteger(state.hop) || state.hop < 0) {
+        throw new errors_1.ValidationError("hop must be a non-negative integer", { code: "POLICY_HOP_INVALID" });
+    }
+    if (state.status !== "LOCKED" && state.status !== "SPENT") {
+        throw new errors_1.ValidationError("status must be LOCKED or SPENT", { code: "POLICY_STATUS_INVALID" });
+    }
+    return state;
+}
+function summarizePolicyOutputDescriptor(descriptor) {
+    const canonicalJson = (0, summary_1.stableStringify)({
+        assetId: descriptor.assetId,
+        feeIndex: descriptor.feeIndex,
+        maxFeeSat: descriptor.maxFeeSat,
+        nextAmountSat: descriptor.nextAmountSat,
+        nextContractAddress: descriptor.nextContractAddress,
+        nextOutputHash: descriptor.nextOutputHash ?? null,
+        nextOutputScriptHash: descriptor.nextOutputScriptHash ?? null,
+        nextOutputIndex: descriptor.nextOutputIndex,
+        requestedOutputBindingMode: descriptor.requestedOutputBindingMode ?? descriptor.outputBindingMode,
+        outputForm: descriptor.outputForm ?? (0, outputBinding_1.normalizeOutputForm)(),
+        rawOutput: (0, outputBinding_1.normalizeOutputRawFields)(descriptor.rawOutput) ?? null,
+        outputBindingMode: descriptor.outputBindingMode,
+    });
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function validatePolicyOutputDescriptor(descriptor) {
+    if (!descriptor.nextContractAddress || descriptor.nextContractAddress.trim().length === 0) {
+        throw new errors_1.ValidationError("nextContractAddress must be a non-empty string", {
+            code: "POLICY_NEXT_CONTRACT_REQUIRED",
+        });
+    }
+    if (!Number.isInteger(descriptor.nextAmountSat) || descriptor.nextAmountSat <= 0) {
+        throw new errors_1.ValidationError("nextAmountSat must be a positive integer", { code: "POLICY_NEXT_AMOUNT_INVALID" });
+    }
+    if (!descriptor.assetId || descriptor.assetId.trim().length === 0) {
+        throw new errors_1.ValidationError("assetId must be a non-empty string", { code: "POLICY_OUTPUT_ASSET_REQUIRED" });
+    }
+    if (!Number.isInteger(descriptor.feeIndex) || descriptor.feeIndex < 0) {
+        throw new errors_1.ValidationError("feeIndex must be a non-negative integer", { code: "POLICY_FEE_INDEX_INVALID" });
+    }
+    if (!Number.isInteger(descriptor.nextOutputIndex) || descriptor.nextOutputIndex < 0) {
+        throw new errors_1.ValidationError("nextOutputIndex must be a non-negative integer", { code: "POLICY_NEXT_OUTPUT_INDEX_INVALID" });
+    }
+    if (!Number.isInteger(descriptor.maxFeeSat) || descriptor.maxFeeSat < 0) {
+        throw new errors_1.ValidationError("maxFeeSat must be a non-negative integer", { code: "POLICY_MAX_FEE_INVALID" });
+    }
+    if (!["none", "script-bound", "descriptor-bound"].includes(descriptor.outputBindingMode)) {
+        throw new errors_1.ValidationError("outputBindingMode must be none, script-bound, or descriptor-bound", {
+            code: "POLICY_OUTPUT_BINDING_MODE_INVALID",
+        });
+    }
+    if (descriptor.requestedOutputBindingMode
+        && !["none", "script-bound", "descriptor-bound"].includes(descriptor.requestedOutputBindingMode)) {
+        throw new errors_1.ValidationError("requestedOutputBindingMode must be none, script-bound, or descriptor-bound", {
+            code: "POLICY_REQUESTED_OUTPUT_BINDING_MODE_INVALID",
+        });
+    }
+    if (descriptor.nextOutputScriptHash && !/^[0-9a-f]{64}$/i.test(descriptor.nextOutputScriptHash)) {
+        throw new errors_1.ValidationError("nextOutputScriptHash must be a 64-character hex string", {
+            code: "POLICY_NEXT_OUTPUT_SCRIPT_HASH_INVALID",
+        });
+    }
+    if (descriptor.nextOutputHash && !/^[0-9a-f]{64}$/i.test(descriptor.nextOutputHash)) {
+        throw new errors_1.ValidationError("nextOutputHash must be a 64-character hex string", {
+            code: "POLICY_NEXT_OUTPUT_HASH_INVALID",
+        });
+    }
+    descriptor.rawOutput = (0, outputBinding_1.normalizeOutputRawFields)(descriptor.rawOutput);
+    const outputForm = (0, outputBinding_1.normalizeOutputForm)(descriptor.outputForm);
+    descriptor.outputForm = outputForm;
+    descriptor.requestedOutputBindingMode = descriptor.requestedOutputBindingMode ?? descriptor.outputBindingMode;
+    return descriptor;
+}
+function summarizePolicyTransferDescriptor(descriptor) {
+    const canonicalJson = (0, summary_1.stableStringify)({
+        policyTemplateId: descriptor.policyTemplateId,
+        previousPolicyHash: descriptor.previousPolicyHash,
+        nextPolicyHash: descriptor.nextPolicyHash ?? null,
+        previousStateHash: descriptor.previousStateHash,
+        nextStateHash: descriptor.nextStateHash ?? null,
+        propagationMode: descriptor.propagationMode,
+        plainExitAddress: descriptor.plainExitAddress ?? null,
+        outputDescriptor: descriptor.outputDescriptor
+            ? JSON.parse(summarizePolicyOutputDescriptor(descriptor.outputDescriptor).canonicalJson)
+            : null,
+    });
+    return { canonicalJson, hash: (0, summary_1.sha256HexUtf8)(canonicalJson) };
+}
+function validatePolicyTransferDescriptor(descriptor) {
+    if (!descriptor.policyTemplateId || descriptor.policyTemplateId.trim().length === 0) {
+        throw new errors_1.ValidationError("policyTemplateId must be a non-empty string", {
+            code: "POLICY_TRANSFER_TEMPLATE_ID_REQUIRED",
+        });
+    }
+    if (!/^[0-9a-f]{64}$/i.test(descriptor.previousPolicyHash)) {
+        throw new errors_1.ValidationError("previousPolicyHash must be a 64-character hex string", {
+            code: "POLICY_TRANSFER_PREVIOUS_HASH_INVALID",
+        });
+    }
+    if (!/^[0-9a-f]{64}$/i.test(descriptor.previousStateHash)) {
+        throw new errors_1.ValidationError("previousStateHash must be a 64-character hex string", {
+            code: "POLICY_TRANSFER_PREVIOUS_STATE_HASH_INVALID",
+        });
+    }
+    if (descriptor.nextPolicyHash && !/^[0-9a-f]{64}$/i.test(descriptor.nextPolicyHash)) {
+        throw new errors_1.ValidationError("nextPolicyHash must be a 64-character hex string", {
+            code: "POLICY_TRANSFER_NEXT_HASH_INVALID",
+        });
+    }
+    if (descriptor.nextStateHash && !/^[0-9a-f]{64}$/i.test(descriptor.nextStateHash)) {
+        throw new errors_1.ValidationError("nextStateHash must be a 64-character hex string", {
+            code: "POLICY_TRANSFER_NEXT_STATE_HASH_INVALID",
+        });
+    }
+    validatePropagationMode(descriptor.propagationMode);
+    if (descriptor.outputDescriptor) {
+        validatePolicyOutputDescriptor(descriptor.outputDescriptor);
+    }
+    return descriptor;
+}
+function satToBtcAmount(sat) {
+    return Number((sat / 1e8).toFixed(8));
+}
+function resolvePolicySequence(state) {
+    const raw = state.params.lockDistanceBlocks;
+    if (typeof raw === "number" && Number.isInteger(raw) && raw >= 0) {
+        return raw;
+    }
+    return undefined;
+}
+function buildPolicyMachineWitness(prepared) {
+    return {
+        values: {
+            NEXT_POLICY_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.nextPolicyHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            NEXT_OUTPUT_DESCRIPTOR_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferSummary.hash}`,
+            },
+            EXPECTED_NEXT_OUTPUT_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.outputDescriptor?.nextOutputHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            EXPECTED_NEXT_OUTPUT_SCRIPT_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.outputDescriptor?.nextOutputScriptHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            OUTPUT_BINDING_MODE: {
+                type: "u8",
+                value: prepared.transferDescriptor.outputDescriptor?.outputBindingMode === "descriptor-bound"
+                    ? "0x01"
+                    : prepared.transferDescriptor.outputDescriptor?.outputBindingMode === "script-bound"
+                        ? "0x02"
+                        : "0x03",
+            },
+        },
+    };
+}
+function buildPolicyDirectWitness(prepared) {
+    return {
+        values: {
+            NEXT_POLICY_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.nextPolicyHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            NEXT_OUTPUT_DESCRIPTOR_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferSummary.hash}`,
+            },
+            EXPECTED_NEXT_OUTPUT_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.outputDescriptor?.nextOutputHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            EXPECTED_NEXT_OUTPUT_SCRIPT_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.outputDescriptor?.nextOutputScriptHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            OUTPUT_BINDING_MODE: {
+                type: "u8",
+                value: prepared.transferDescriptor.outputDescriptor?.outputBindingMode === "descriptor-bound"
+                    ? "0x01"
+                    : prepared.transferDescriptor.outputDescriptor?.outputBindingMode === "script-bound"
+                        ? "0x02"
+                        : "0x03",
+            },
+        },
+    };
+}
+function buildPolicyRecursiveWitness(prepared) {
+    return {
+        values: {
+            NEXT_POLICY_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.nextPolicyHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            NEXT_OUTPUT_DESCRIPTOR_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferSummary.hash}`,
+            },
+            EXPECTED_NEXT_OUTPUT_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.outputDescriptor?.nextOutputHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            EXPECTED_NEXT_OUTPUT_SCRIPT_HASH: {
+                type: "u256",
+                value: `0x${prepared.transferDescriptor.outputDescriptor?.nextOutputScriptHash ?? "0000000000000000000000000000000000000000000000000000000000000000"}`,
+            },
+            OUTPUT_BINDING_MODE: {
+                type: "u8",
+                value: prepared.transferDescriptor.outputDescriptor?.outputBindingMode === "descriptor-bound"
+                    ? "0x01"
+                    : prepared.transferDescriptor.outputDescriptor?.outputBindingMode === "script-bound"
+                        ? "0x02"
+                        : "0x03",
+            },
+        },
+    };
+}
+function camelToUpperSnake(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .toUpperCase();
+}
+function buildPolicyTemplateVars(input) {
+    const vars = {
+        SIGNER_XONLY: input.recipientXonly,
+        RECIPIENT_XONLY: input.recipientXonly,
+        POLICY_HASH: input.policyHash,
+    };
+    for (const [key, value] of Object.entries(input.params)) {
+        const templateKey = camelToUpperSnake(key);
+        vars[templateKey] = typeof value === "boolean" ? (value ? 1 : 0) : value;
+        if (key === "lockDistanceBlocks") {
+            vars.LOCK_DISTANCE = typeof value === "boolean" ? (value ? 1 : 0) : value;
+        }
+    }
+    if (input.propagationMode) {
+        vars.PROPAGATION_MODE_8 = input.propagationMode === "required" ? 1 : input.propagationMode === "optional" ? 2 : 3;
+        vars.ALLOW_PLAIN_EXIT_8 = input.propagationMode === "optional" || input.propagationMode === "none" ? 1 : 0;
+        vars.REQUIRE_RECURSIVE_NEXT_8 = input.propagationMode === "required" ? 1 : 0;
+        vars.REQUIRE_MACHINE_HOP_8 = input.propagationMode === "required" ? 1 : 0;
+    }
+    if (input.outputBindingMode) {
+        vars.OUTPUT_BINDING_MODE_8 =
+            input.outputBindingMode === "descriptor-bound"
+                ? 1
+                : input.outputBindingMode === "script-bound"
+                    ? 2
+                    : 3;
+    }
+    if (input.previousPolicyHash)
+        vars.PREVIOUS_POLICY_HASH = input.previousPolicyHash;
+    if (input.nextPolicyHash)
+        vars.NEXT_POLICY_HASH = input.nextPolicyHash;
+    if (input.nextOutputDescriptorHash)
+        vars.NEXT_OUTPUT_DESCRIPTOR_HASH = input.nextOutputDescriptorHash;
+    vars.EXPECTED_NEXT_OUTPUT_HASH_256 =
+        input.nextOutputHash ?? "0000000000000000000000000000000000000000000000000000000000000000";
+    vars.EXPECTED_NEXT_OUTPUT_SCRIPT_HASH_256 =
+        input.nextOutputScriptHash ?? "0000000000000000000000000000000000000000000000000000000000000000";
+    vars.ROUTER_MACHINE_SCRIPT_HASH_256 =
+        input.nextOutputScriptHash ?? "0000000000000000000000000000000000000000000000000000000000000000";
+    return vars;
+}
+async function resolveTemplateDocument(sdk, input, propagationMode) {
+    const manifest = await loadPolicyTemplateManifest({
+        templateId: input.templateId,
+        propagationMode,
+        manifestPath: input.manifestPath,
+        manifestValue: input.manifestValue,
+    });
+    const definitionSource = resolveValueOrPath({
+        pathValue: input.jsonPath,
+        objectValue: input.value,
+    });
+    const templateId = input.templateId ?? manifest.templateId;
+    const definition = await sdk.loadDefinition({
+        type: "policy-template",
+        id: templateId,
+        ...(definitionSource.jsonPath || definitionSource.value
+            ? definitionSource
+            : { value: { policyTemplateId: templateId } }),
+    });
+    const document = validatePolicyTemplateDocument(JSON.parse(definition.canonicalJson), templateId);
+    return {
+        document,
+        summary: summarizePolicyTemplateDocument(document),
+        manifest,
+        stateSimfPath: input.stateSimfPath ?? manifest.stateSimfPath,
+        directStateSimfPath: input.directStateSimfPath ?? manifest.directStateSimfPath ?? manifest.stateSimfPath,
+        transferMachineSimfPath: input.transferMachineSimfPath ?? resolvePolicyDocsAsset("recursive-policy-transfer-machine.simf"),
+    };
+}
+function createPolicyState(input) {
+    const policySummary = summarizePolicyHash({
+        template: input.template,
+        recipient: input.recipientXonly,
+        params: input.params,
+        propagationMode: input.propagationMode,
+    });
+    return validatePolicyState({
+        policyTemplateId: input.template.policyTemplateId,
+        policyHash: policySummary.hash,
+        recipient: input.recipientXonly,
+        amountSat: input.amountSat,
+        assetId: input.assetId,
+        params: normalizeParams(input.params),
+        propagationMode: input.propagationMode,
+        previousStateHash: input.previousStateHash ?? null,
+        hop: input.hop,
+        status: "LOCKED",
+    });
+}
+function resolvePolicyEnforcementMode(input) {
+    if (input.currentPropagationMode === "required") {
+        return "direct-hop";
+    }
+    if (input.currentPropagationMode === "optional" && input.nextReceiverMode === "policy") {
+        return "conditional-hop";
+    }
+    return "sdk-path";
+}
+function assertDirectArtifactCompatibility(artifact, template) {
+    const actual = artifact.source.simfPath ? node_path_1.default.basename(artifact.source.simfPath) : undefined;
+    const expected = node_path_1.default.basename(template.directStateSimfPath);
+    if (actual !== expected) {
+        throw new errors_1.ValidationError(`Current artifact is not using the direct-hop state contract (${expected})`, {
+            code: "POLICY_DIRECT_HOP_ARTIFACT_REQUIRED",
+        });
+    }
+}
+async function compilePolicyStateContractInternal(sdk, input) {
+    const template = await resolveTemplateDocument(sdk, input.template);
+    return sdk.compileFromFile({
+        simfPath: input.stateValue.propagationMode === "required"
+            ? template.directStateSimfPath
+            : template.stateSimfPath,
+        templateVars: buildPolicyTemplateVars({
+            recipientXonly: input.stateValue.recipient,
+            policyHash: input.stateValue.policyHash,
+            params: input.stateValue.params,
+            propagationMode: input.stateValue.propagationMode,
+            nextPolicyHash: input.nextPolicyHash,
+            nextOutputDescriptorHash: input.nextOutputDescriptorHash,
+            outputBindingMode: input.stateValue.propagationMode === "required" || input.stateValue.propagationMode === "optional"
+                ? "script-bound"
+                : undefined,
+            nextOutputScriptHash: input.stateValue.propagationMode === "required"
+                ? input.nextOutputScriptHash
+                : input.stateValue.propagationMode === "optional"
+                    ? input.nextOutputScriptHash
+                    : input.routerMachineScriptHash,
+        }),
+        definition: {
+            type: "policy-template",
+            id: template.document.policyTemplateId,
+            value: template.document,
+            anchorMode: "on-chain-constant-committed",
+        },
+        state: {
+            type: "policy-state",
+            id: `${input.stateValue.policyTemplateId}-${input.stateValue.hop}`,
+            value: input.stateValue,
+            anchorMode: "on-chain-constant-committed",
+        },
+        artifactPath: input.artifactPath,
+    });
+}
+async function compilePolicyRouterMachineInternal(sdk, input) {
+    const template = await resolveTemplateDocument(sdk, input.template);
+    return sdk.compileFromFile({
+        simfPath: template.transferMachineSimfPath,
+        templateVars: buildPolicyTemplateVars({
+            recipientXonly: input.currentState.recipient,
+            policyHash: input.currentState.policyHash,
+            params: input.currentState.params,
+            propagationMode: input.currentState.propagationMode,
+            outputBindingMode: "none",
+            previousPolicyHash: input.currentState.policyHash,
+            nextPolicyHash: input.currentState.policyHash,
+            nextOutputDescriptorHash: "0000000000000000000000000000000000000000000000000000000000000000",
+        }),
+        definition: {
+            type: "policy-template",
+            id: template.document.policyTemplateId,
+            value: template.document,
+            anchorMode: "on-chain-constant-committed",
+        },
+        state: {
+            type: "policy-state",
+            id: `${input.currentState.policyTemplateId}-${input.currentState.hop}`,
+            value: input.currentState,
+            anchorMode: "on-chain-constant-committed",
+        },
+        artifactPath: input.artifactPath,
+    });
+}
+async function getPolicyRouterMachineScriptHash(sdk, input) {
+    const router = await compilePolicyRouterMachineInternal(sdk, {
+        template: input.template,
+        currentState: input.currentState,
+    });
+    const scriptPubKeyHex = await (0, outputBinding_1.getScriptPubKeyHexViaRpc)(sdk, router.contractAddress);
+    return (0, outputBinding_1.hashHexBytes)(scriptPubKeyHex);
+}
+async function compilePolicyStateContract(sdk, input) {
+    const routerMachineScriptHash = input.stateValue.propagationMode !== "none"
+        ? await getPolicyRouterMachineScriptHash(sdk, {
+            template: input.template,
+            currentState: input.stateValue,
+        })
+        : undefined;
+    return compilePolicyStateContractInternal(sdk, {
+        ...input,
+        routerMachineScriptHash,
+    });
+}
+async function issue(sdk, input) {
+    const recipient = validateReceiver(input.recipient);
+    if (recipient.mode !== "policy") {
+        throw new errors_1.ValidationError("issue requires a policy receiver", { code: "POLICY_ISSUE_RECEIVER_MODE_INVALID" });
+    }
+    const propagationMode = validatePropagationMode(input.propagationMode ?? "required");
+    const template = await resolveTemplateDocument(sdk, input.template, propagationMode);
+    const params = validatePolicyTemplateParams({
+        templateId: template.manifest.templateId,
+        params: { ...(recipient.defaultParams ?? {}), ...(input.params ?? {}) },
+        propagationMode,
+    });
+    const stateValue = createPolicyState({
+        template: template.document,
+        recipientXonly: recipient.recipientXonly,
+        amountSat: input.amountSat,
+        assetId: input.assetId,
+        params,
+        propagationMode,
+        hop: 0,
+    });
+    const routerMachineScriptHash = propagationMode !== "none"
+        ? await getPolicyRouterMachineScriptHash(sdk, {
+            template: input.template,
+            currentState: stateValue,
+        })
+        : undefined;
+    const compiled = await compilePolicyStateContractInternal(sdk, {
+        template: input.template,
+        stateValue,
+        routerMachineScriptHash,
+        artifactPath: input.artifactPath,
+    });
+    return {
+        compiled,
+        state: stateValue,
+        policyTemplate: template.document,
+        policyHash: stateValue.policyHash,
+    };
+}
+async function verifyState(sdk, input) {
+    const artifact = input.artifact ?? (input.artifactPath ? (await sdk.loadArtifact(input.artifactPath)).artifact : undefined);
+    if (!artifact) {
+        throw new errors_1.ValidationError("artifactPath or artifact is required", { code: "POLICY_ARTIFACT_REQUIRED" });
+    }
+    const templateInput = input.template ?? { templateId: artifact.definition?.definitionId ?? "recursive-delay" };
+    const template = await resolveTemplateDocument(sdk, templateInput);
+    const definitionVerification = await sdk.verifyDefinitionAgainstArtifact({
+        artifact,
+        type: "policy-template",
+        id: template.document.policyTemplateId,
+        value: template.document,
+    });
+    const stateVerification = await sdk.verifyStateAgainstArtifact({
+        artifact,
+        type: "policy-state",
+        id: artifact.state?.stateId,
+        ...(input.statePath ? { jsonPath: input.statePath } : input.stateValue ? { value: input.stateValue } : {}),
+    });
+    const state = validatePolicyState(JSON.parse(stateVerification.state.canonicalJson));
+    const expectedPolicyHash = summarizePolicyHash({
+        template: template.document,
+        recipient: state.recipient,
+        params: state.params,
+        propagationMode: state.propagationMode,
+    }).hash;
+    const policyHashMatches = expectedPolicyHash === state.policyHash;
+    return {
+        ok: definitionVerification.ok && stateVerification.ok && policyHashMatches,
+        reason: policyHashMatches ? undefined : "Policy hash does not match template + params + recipient",
+        artifact,
+        template: definitionVerification,
+        state: stateVerification,
+        stateValue: state,
+        policyHashMatches,
+        report: {
+            schemaVersion: exports.POLICY_VERIFICATION_REPORT_SCHEMA_VERSION,
+            templateTrust: definitionVerification.trust,
+            stateTrust: stateVerification.trust,
+            propagationMode: state.propagationMode,
+            nextPolicyRequired: state.propagationMode === "required",
+            nextPolicyPresent: false,
+            plainExitAllowed: state.propagationMode !== "required",
+            enforcement: resolvePolicyEnforcementMode({
+                currentPropagationMode: state.propagationMode,
+                nextReceiverMode: state.propagationMode === "required" ? "policy" : undefined,
+            }),
+        },
+    };
+}
+async function buildPolicyOutputDescriptor(sdk, input) {
+    const nextScriptPubKeyHex = await (0, outputBinding_1.getScriptPubKeyHexViaRpc)(sdk, input.nextCompiledContractAddress);
+    const nextOutputScriptHash = (0, outputBinding_1.hashHexBytes)(nextScriptPubKeyHex);
+    const requestedBindingMode = input.outputBindingMode ?? "script-bound";
+    const outputForm = (0, outputBinding_1.normalizeOutputForm)(input.outputForm);
+    const rawOutput = (0, outputBinding_1.normalizeOutputRawFields)(input.rawOutput);
+    const rawOutputAnalysis = (0, outputBinding_1.analyzeOutputRawFields)(rawOutput);
+    const explicitAssetHex = requestedBindingMode !== "none" && (0, outputBinding_1.isExplicitV1OutputForm)(outputForm)
+        ? await (0, outputBinding_1.resolveExplicitAssetHex)(sdk, input.assetId)
+        : undefined;
+    const autoDerivedNextOutputHash = requestedBindingMode === "descriptor-bound" && !input.nextOutputHash
+        ? rawOutputAnalysis.valid && rawOutputAnalysis.normalized
+            ? (0, outputBinding_1.computeRawOutputV1Hash)(rawOutputAnalysis.normalized)
+            : explicitAssetHex
+                ? (0, outputBinding_1.computeExplicitV1OutputHash)({
+                    assetHex: explicitAssetHex,
+                    nextAmountSat: input.nextAmountSat,
+                    nextOutputScriptHash,
+                })
+                : undefined
+        : undefined;
+    const nextOutputHash = input.nextOutputHash ?? autoDerivedNextOutputHash;
+    const bindingResolution = (0, outputBinding_1.resolveOutputBindingDecision)({
+        requestedBindingMode,
+        nextOutputHash,
+        nextOutputScriptHash,
+        autoDerivedNextOutputHash: Boolean(autoDerivedNextOutputHash && !input.nextOutputHash),
+        explicitAssetSupported: Boolean(explicitAssetHex),
+        outputForm,
+        rawOutput,
+    });
+    const descriptor = validatePolicyOutputDescriptor({
+        nextContractAddress: input.nextCompiledContractAddress,
+        nextOutputHash: bindingResolution.outputBindingMode === "descriptor-bound" ? nextOutputHash : undefined,
+        nextOutputScriptHash: bindingResolution.outputBindingMode !== "none" ? nextOutputScriptHash : undefined,
+        nextAmountSat: input.nextAmountSat,
+        assetId: input.assetId,
+        requestedOutputBindingMode: requestedBindingMode,
+        outputForm,
+        rawOutput,
+        feeIndex: input.feeIndex ?? 1,
+        nextOutputIndex: input.nextOutputIndex ?? 0,
+        maxFeeSat: input.maxFeeSat ?? 100,
+        outputBindingMode: bindingResolution.outputBindingMode,
+    });
+    return {
+        descriptor,
+        summary: summarizePolicyOutputDescriptor(descriptor),
+        supportedForm: bindingResolution.supportedForm,
+        autoDerivedNextOutputHash: bindingResolution.autoDerived,
+        reasonCode: bindingResolution.reasonCode,
+        fallbackReason: bindingResolution.fallbackReason,
+        bindingInputs: {
+            assetId: descriptor.assetId,
+            assetForm: descriptor.outputForm?.assetForm ?? "explicit",
+            amountForm: descriptor.outputForm?.amountForm ?? "explicit",
+            nonceForm: descriptor.outputForm?.nonceForm ?? "null",
+            rangeProofForm: descriptor.outputForm?.rangeProofForm ?? "empty",
+            nextAmountSat: descriptor.nextAmountSat,
+            nextOutputIndex: descriptor.nextOutputIndex,
+            feeIndex: descriptor.feeIndex,
+            maxFeeSat: descriptor.maxFeeSat,
+            ...(rawOutputAnalysis.valid && rawOutputAnalysis.normalized
+                ? {
+                    rawOutputComponents: {
+                        scriptPubKey: rawOutputAnalysis.normalized.scriptComponentSource,
+                        rangeProof: rawOutputAnalysis.normalized.rangeProofComponentSource,
+                    },
+                }
+                : {}),
+        },
+    };
+}
+function buildPolicyOutputBindingReport(input) {
+    if (!input.descriptor)
+        return undefined;
+    return {
+        mode: input.descriptor.outputBindingMode,
+        supportedForm: input.supportedForm ?? "unsupported",
+        committed: true,
+        runtimeBound: input.descriptor.outputBindingMode !== "none",
+        sdkVerified: input.sdkVerified,
+        amountRuntimeBound: input.descriptor.outputBindingMode === "descriptor-bound",
+        nextOutputHashRuntimeBound: input.descriptor.outputBindingMode === "descriptor-bound",
+        nextOutputScriptRuntimeBound: input.descriptor.outputBindingMode === "script-bound",
+        reasonCode: input.reasonCode
+            ?? (input.descriptor.outputBindingMode === "descriptor-bound" ? "OK_MANUAL_HASH" : input.descriptor.outputBindingMode === "script-bound" ? "OK_SCRIPT_BOUND" : "OK_NONE"),
+        nextOutputHash: input.descriptor.nextOutputHash,
+        autoDerived: input.autoDerived,
+        fallbackReason: input.fallbackReason,
+        bindingInputs: input.bindingInputs
+            ?? {
+                assetId: input.descriptor.assetId,
+                assetForm: input.descriptor.outputForm?.assetForm ?? "explicit",
+                amountForm: input.descriptor.outputForm?.amountForm ?? "explicit",
+                nonceForm: input.descriptor.outputForm?.nonceForm ?? "null",
+                rangeProofForm: input.descriptor.outputForm?.rangeProofForm ?? "empty",
+                nextAmountSat: input.descriptor.nextAmountSat,
+                nextOutputIndex: input.descriptor.nextOutputIndex,
+                feeIndex: input.descriptor.feeIndex,
+                maxFeeSat: input.descriptor.maxFeeSat,
+            },
+    };
+}
+async function resolvePolicyOutputBindingVerificationContext(sdk, descriptor) {
+    if (!descriptor)
+        return {};
+    const rawOutput = (0, outputBinding_1.normalizeOutputRawFields)(descriptor.rawOutput);
+    const rawOutputAnalysis = (0, outputBinding_1.analyzeOutputRawFields)(rawOutput);
+    const bindingInputs = {
+        assetId: descriptor.assetId,
+        assetForm: descriptor.outputForm?.assetForm ?? "explicit",
+        amountForm: descriptor.outputForm?.amountForm ?? "explicit",
+        nonceForm: descriptor.outputForm?.nonceForm ?? "null",
+        rangeProofForm: descriptor.outputForm?.rangeProofForm ?? "empty",
+        nextAmountSat: descriptor.nextAmountSat,
+        nextOutputIndex: descriptor.nextOutputIndex,
+        feeIndex: descriptor.feeIndex,
+        maxFeeSat: descriptor.maxFeeSat,
+        ...(rawOutputAnalysis.valid && rawOutputAnalysis.normalized
+            ? {
+                rawOutputComponents: {
+                    scriptPubKey: rawOutputAnalysis.normalized.scriptComponentSource,
+                    rangeProof: rawOutputAnalysis.normalized.rangeProofComponentSource,
+                },
+            }
+            : {}),
+    };
+    const requestedBindingMode = descriptor.requestedOutputBindingMode ?? descriptor.outputBindingMode;
+    const outputForm = (0, outputBinding_1.normalizeOutputForm)(descriptor.outputForm);
+    const outputFormSupported = (0, outputBinding_1.isExplicitV1OutputForm)(outputForm);
+    const explicitAssetHex = !rawOutputAnalysis.valid && outputFormSupported
+        ? await (0, outputBinding_1.resolveExplicitAssetHex)(sdk, descriptor.assetId)
+        : undefined;
+    const decision = (0, outputBinding_1.resolveOutputBindingDecision)({
+        requestedBindingMode,
+        nextOutputHash: descriptor.nextOutputHash,
+        nextOutputScriptHash: descriptor.nextOutputScriptHash,
+        autoDerivedNextOutputHash: false,
+        explicitAssetSupported: Boolean(explicitAssetHex),
+        outputForm,
+        rawOutput,
+    });
+    if (descriptor.outputBindingMode === "none" || requestedBindingMode === "none") {
+        return {
+            supportedForm: decision.supportedForm,
+            reasonCode: "OK_NONE",
+            bindingInputs,
+        };
+    }
+    if (descriptor.outputBindingMode === "script-bound") {
+        return {
+            supportedForm: decision.supportedForm,
+            reasonCode: requestedBindingMode === "descriptor-bound" ? decision.reasonCode : "OK_SCRIPT_BOUND",
+            fallbackReason: requestedBindingMode === "descriptor-bound" ? decision.fallbackReason : undefined,
+            bindingInputs,
+        };
+    }
+    if (!descriptor.nextOutputHash) {
+        return {
+            supportedForm: decision.supportedForm,
+            reasonCode: decision.reasonCode,
+            fallbackReason: decision.fallbackReason ?? "descriptor-bound artifact is missing nextOutputHash",
+            bindingInputs,
+        };
+    }
+    if (rawOutputAnalysis.valid && rawOutputAnalysis.normalized) {
+        const derivedNextOutputHash = (0, outputBinding_1.computeRawOutputV1Hash)(rawOutputAnalysis.normalized);
+        const autoDerived = derivedNextOutputHash === descriptor.nextOutputHash;
+        return {
+            supportedForm: "raw-output-v1",
+            reasonCode: autoDerived ? "OK_RAW_OUTPUT" : "OK_MANUAL_HASH",
+            autoDerived,
+            bindingInputs,
+        };
+    }
+    if (!outputFormSupported) {
+        return {
+            supportedForm: decision.supportedForm,
+            reasonCode: "OK_MANUAL_HASH",
+            bindingInputs,
+        };
+    }
+    if (!explicitAssetHex || !descriptor.nextOutputScriptHash) {
+        return {
+            supportedForm: explicitAssetHex ? "explicit-v1" : "unsupported",
+            reasonCode: !explicitAssetHex ? "OK_MANUAL_HASH" : "FALLBACK_UNSUPPORTED_OUTPUT_FORM",
+            ...(explicitAssetHex
+                ? {
+                    fallbackReason: "descriptor-bound output hash could not be auto-verified because the descriptor is missing the explicit-v1 output shape inputs",
+                }
+                : {}),
+            bindingInputs,
+        };
+    }
+    const derivedNextOutputHash = (0, outputBinding_1.computeExplicitV1OutputHash)({
+        assetHex: explicitAssetHex,
+        nextAmountSat: descriptor.nextAmountSat,
+        nextOutputScriptHash: descriptor.nextOutputScriptHash,
+    });
+    const autoDerived = derivedNextOutputHash === descriptor.nextOutputHash;
+    return {
+        supportedForm: "explicit-v1",
+        reasonCode: autoDerived ? "OK_EXPLICIT" : "OK_MANUAL_HASH",
+        autoDerived,
+        bindingInputs,
+    };
+}
+async function prepareTransfer(sdk, input) {
+    const verifiedCurrent = await verifyState(sdk, {
+        artifactPath: input.currentArtifactPath,
+        artifact: input.currentArtifact,
+        template: input.template,
+        statePath: input.currentStatePath,
+        stateValue: input.currentStateValue,
+    });
+    if (!verifiedCurrent.ok) {
+        throw new errors_1.ValidationError(verifiedCurrent.reason ?? "Current policy state verification failed", {
+            code: "POLICY_CURRENT_STATE_INVALID",
+        });
+    }
+    const currentState = verifiedCurrent.stateValue;
+    const nextPropagationMode = validatePropagationMode(input.propagationMode ?? currentState.propagationMode);
+    const nextReceiver = validateReceiver(input.nextReceiver);
+    if (currentState.propagationMode === "required" && nextReceiver.mode === "plain") {
+        throw new errors_1.ValidationError("required propagation mode does not allow a plain-address exit", {
+            code: "POLICY_REQUIRED_PROPAGATION_PLAIN_EXIT_FORBIDDEN",
+        });
+    }
+    if (nextPropagationMode === "none" && nextReceiver.mode === "policy") {
+        throw new errors_1.ValidationError("propagationMode none does not create a next policy state", {
+            code: "POLICY_NONE_MODE_POLICY_RECEIVER_FORBIDDEN",
+        });
+    }
+    if (currentState.propagationMode === "required") {
+        return prepareDirectTransfer(sdk, input);
+    }
+    if (nextReceiver.mode === "plain") {
+        const descriptor = validatePolicyTransferDescriptor({
+            policyTemplateId: currentState.policyTemplateId,
+            previousPolicyHash: currentState.policyHash,
+            previousStateHash: summarizePolicyState(currentState).hash,
+            propagationMode: currentState.propagationMode,
+            plainExitAddress: nextReceiver.address,
+        });
+        const summary = summarizePolicyTransferDescriptor(descriptor);
+        return {
+            current: verifiedCurrent,
+            nextState: null,
+            nextCompiled: null,
+            machineArtifact: null,
+            transferDescriptor: descriptor,
+            transferSummary: summary,
+            verificationReport: {
+                ...verifiedCurrent.report,
+                nextPolicyPresent: false,
+                plainExitAllowed: true,
+                enforcement: resolvePolicyEnforcementMode({
+                    currentPropagationMode: currentState.propagationMode,
+                    nextReceiverMode: "plain",
+                }),
+            },
+        };
+    }
+    const template = await resolveTemplateDocument(sdk, input.template, nextPropagationMode);
+    const nextParams = validatePolicyTemplateParams({
+        templateId: template.manifest.templateId,
+        params: { ...(nextReceiver.defaultParams ?? {}), ...(input.nextParams ?? currentState.params) },
+        propagationMode: nextPropagationMode,
+    });
+    const nextState = createPolicyState({
+        template: template.document,
+        recipientXonly: nextReceiver.recipientXonly,
+        amountSat: input.nextAmountSat,
+        assetId: currentState.assetId,
+        params: nextParams,
+        propagationMode: nextPropagationMode,
+        previousStateHash: summarizePolicyState(currentState).hash,
+        hop: currentState.hop + 1,
+    });
+    const nextCompiled = await compilePolicyStateContractInternal(sdk, {
+        template: input.template,
+        stateValue: nextState,
+    });
+    const outputDescriptor = await buildPolicyOutputDescriptor(sdk, {
+        nextCompiledContractAddress: nextCompiled.contractAddress,
+        nextAmountSat: input.nextAmountSat,
+        assetId: nextState.assetId,
+        maxFeeSat: 100,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.nextOutputForm,
+        rawOutput: input.nextRawOutput,
+        outputBindingMode: input.outputBindingMode ?? "script-bound",
+    });
+    const previousStateSummary = summarizePolicyState(currentState);
+    const nextStateSummary = summarizePolicyState(nextState);
+    const transferDescriptor = validatePolicyTransferDescriptor({
+        policyTemplateId: currentState.policyTemplateId,
+        previousPolicyHash: currentState.policyHash,
+        nextPolicyHash: nextState.policyHash,
+        previousStateHash: previousStateSummary.hash,
+        nextStateHash: nextStateSummary.hash,
+        propagationMode: currentState.propagationMode,
+        outputDescriptor: outputDescriptor.descriptor,
+    });
+    const transferSummary = summarizePolicyTransferDescriptor(transferDescriptor);
+    if (input.nextArtifactPath) {
+        await nextCompiled.saveArtifact(input.nextArtifactPath);
+    }
+    return {
+        current: verifiedCurrent,
+        nextState,
+        nextCompiled,
+        machineArtifact: null,
+        transferDescriptor,
+        transferSummary,
+        verificationReport: {
+            ...verifiedCurrent.report,
+            nextPolicyPresent: true,
+            outputBinding: buildPolicyOutputBindingReport({
+                descriptor: outputDescriptor.descriptor,
+                sdkVerified: true,
+                supportedForm: outputDescriptor.supportedForm,
+                autoDerived: outputDescriptor.autoDerivedNextOutputHash,
+                reasonCode: outputDescriptor.reasonCode,
+                fallbackReason: outputDescriptor.fallbackReason,
+                bindingInputs: outputDescriptor.bindingInputs,
+            }),
+            enforcement: resolvePolicyEnforcementMode({
+                currentPropagationMode: currentState.propagationMode,
+                nextReceiverMode: "policy",
+            }),
+        },
+    };
+}
+async function prepareDirectTransfer(sdk, input) {
+    const verifiedCurrent = await verifyState(sdk, {
+        artifactPath: input.currentArtifactPath,
+        artifact: input.currentArtifact,
+        template: input.template,
+        statePath: input.currentStatePath,
+        stateValue: input.currentStateValue,
+    });
+    if (!verifiedCurrent.ok) {
+        throw new errors_1.ValidationError(verifiedCurrent.reason ?? "Current policy state verification failed", {
+            code: "POLICY_CURRENT_STATE_INVALID",
+        });
+    }
+    const currentState = verifiedCurrent.stateValue;
+    if (currentState.propagationMode !== "required") {
+        throw new errors_1.ValidationError("Direct transfer is only available for required propagation mode", {
+            code: "POLICY_DIRECT_HOP_REQUIRES_REQUIRED_MODE",
+        });
+    }
+    const template = await resolveTemplateDocument(sdk, input.template, currentState.propagationMode);
+    assertDirectArtifactCompatibility(verifiedCurrent.artifact, template);
+    const nextReceiver = validateReceiver(input.nextReceiver);
+    if (nextReceiver.mode !== "policy") {
+        throw new errors_1.ValidationError("Direct transfer requires a policy receiver", {
+            code: "POLICY_DIRECT_HOP_POLICY_RECEIVER_REQUIRED",
+        });
+    }
+    const nextPropagationMode = validatePropagationMode(input.propagationMode ?? currentState.propagationMode);
+    if (nextPropagationMode !== "required") {
+        throw new errors_1.ValidationError("Direct transfer currently requires the next hop to remain in required mode", {
+            code: "POLICY_DIRECT_HOP_NEXT_MODE_INVALID",
+        });
+    }
+    const nextParams = validatePolicyTemplateParams({
+        templateId: template.manifest.templateId,
+        params: { ...(nextReceiver.defaultParams ?? {}), ...(input.nextParams ?? currentState.params) },
+        propagationMode: nextPropagationMode,
+    });
+    const nextState = createPolicyState({
+        template: template.document,
+        recipientXonly: nextReceiver.recipientXonly,
+        amountSat: input.nextAmountSat,
+        assetId: currentState.assetId,
+        params: nextParams,
+        propagationMode: nextPropagationMode,
+        previousStateHash: summarizePolicyState(currentState).hash,
+        hop: currentState.hop + 1,
+    });
+    const nextCompiled = await compilePolicyStateContractInternal(sdk, {
+        template: input.template,
+        stateValue: nextState,
+    });
+    const outputDescriptor = await buildPolicyOutputDescriptor(sdk, {
+        nextCompiledContractAddress: nextCompiled.contractAddress,
+        nextAmountSat: input.nextAmountSat,
+        assetId: nextState.assetId,
+        maxFeeSat: 100,
+        nextOutputHash: input.nextOutputHash,
+        outputForm: input.nextOutputForm,
+        rawOutput: input.nextRawOutput,
+        outputBindingMode: input.outputBindingMode ?? "script-bound",
+    });
+    const previousStateSummary = summarizePolicyState(currentState);
+    const nextStateSummary = summarizePolicyState(nextState);
+    const transferDescriptor = validatePolicyTransferDescriptor({
+        policyTemplateId: currentState.policyTemplateId,
+        previousPolicyHash: currentState.policyHash,
+        nextPolicyHash: nextState.policyHash,
+        previousStateHash: previousStateSummary.hash,
+        nextStateHash: nextStateSummary.hash,
+        propagationMode: currentState.propagationMode,
+        outputDescriptor: outputDescriptor.descriptor,
+    });
+    const transferSummary = summarizePolicyTransferDescriptor(transferDescriptor);
+    if (input.nextArtifactPath) {
+        await nextCompiled.saveArtifact(input.nextArtifactPath);
+    }
+    return {
+        current: verifiedCurrent,
+        nextState,
+        nextCompiled,
+        machineArtifact: null,
+        transferDescriptor,
+        transferSummary,
+        verificationReport: {
+            ...verifiedCurrent.report,
+            nextPolicyPresent: true,
+            plainExitAllowed: false,
+            outputBinding: buildPolicyOutputBindingReport({
+                descriptor: outputDescriptor.descriptor,
+                sdkVerified: true,
+                supportedForm: outputDescriptor.supportedForm,
+                autoDerived: outputDescriptor.autoDerivedNextOutputHash,
+                reasonCode: outputDescriptor.reasonCode,
+                fallbackReason: outputDescriptor.fallbackReason,
+                bindingInputs: outputDescriptor.bindingInputs,
+            }),
+            enforcement: resolvePolicyEnforcementMode({
+                currentPropagationMode: currentState.propagationMode,
+                nextReceiverMode: "policy",
+            }),
+        },
+    };
+}
+async function verifyDirectTransfer(sdk, input) {
+    const prepared = await verifyState(sdk, {
+        artifactPath: input.currentArtifactPath,
+        artifact: input.currentArtifact,
+        template: input.template,
+        statePath: input.currentStatePath,
+        stateValue: input.currentStateValue,
+    });
+    const template = await resolveTemplateDocument(sdk, input.template);
+    assertDirectArtifactCompatibility(prepared.artifact, template);
+    const currentState = prepared.stateValue;
+    const transfer = input.transferDescriptorValue ? validatePolicyTransferDescriptor(input.transferDescriptorValue) : undefined;
+    const nextState = input.nextStateValue ? validatePolicyState(input.nextStateValue) : undefined;
+    const outputBindingContext = await resolvePolicyOutputBindingVerificationContext(sdk, transfer?.outputDescriptor);
+    const summary = transfer ? summarizePolicyTransferDescriptor(transfer) : undefined;
+    const nextStateSummary = nextState ? summarizePolicyState(nextState) : undefined;
+    const ok = currentState.propagationMode === "required" && (!transfer || (transfer.previousPolicyHash === currentState.policyHash
+        && transfer.previousStateHash === summarizePolicyState(currentState).hash
+        && Boolean(transfer.outputDescriptor?.nextOutputScriptHash)
+        && (!nextState || transfer.nextPolicyHash === nextState.policyHash)
+        && (!nextStateSummary || transfer.nextStateHash === nextStateSummary.hash)));
+    return {
+        ok,
+        reason: ok ? undefined : "Direct transfer descriptor does not match current/next policy state",
+        current: prepared,
+        transfer,
+        transferSummary: summary,
+        nextState,
+        verificationReport: {
+            ...prepared.report,
+            nextPolicyPresent: Boolean(nextState),
+            plainExitAllowed: false,
+            outputBinding: buildPolicyOutputBindingReport({
+                descriptor: transfer?.outputDescriptor,
+                sdkVerified: ok,
+                supportedForm: outputBindingContext.supportedForm,
+                reasonCode: outputBindingContext.reasonCode,
+                autoDerived: outputBindingContext.autoDerived,
+                fallbackReason: outputBindingContext.fallbackReason,
+                bindingInputs: outputBindingContext.bindingInputs,
+            }),
+            enforcement: resolvePolicyEnforcementMode({
+                currentPropagationMode: currentState.propagationMode,
+                nextReceiverMode: "policy",
+            }),
+        },
+    };
+}
+async function inspectDirectTransfer(sdk, input) {
+    const prepared = await prepareDirectTransfer(sdk, input);
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new errors_1.ValidationError("currentArtifactPath or currentArtifact is required", {
+            code: "POLICY_CURRENT_ARTIFACT_REQUIRED",
+        });
+    }
+    const currentContract = sdk.fromArtifact(currentArtifact);
+    const inspect = await currentContract.inspectCall({
+        wallet: input.wallet,
+        toAddress: prepared.nextCompiled.contractAddress,
+        signer: input.signer,
+        sendAmount: satToBtcAmount(input.nextAmountSat),
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        sequence: resolvePolicySequence(prepared.current.stateValue),
+        witness: buildPolicyDirectWitness(prepared),
+    });
+    return {
+        mode: "direct-hop",
+        prepared,
+        inspect,
+    };
+}
+async function executeDirectTransfer(sdk, input) {
+    const prepared = await prepareDirectTransfer(sdk, input);
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new errors_1.ValidationError("currentArtifactPath or currentArtifact is required", {
+            code: "POLICY_CURRENT_ARTIFACT_REQUIRED",
+        });
+    }
+    const currentContract = sdk.fromArtifact(currentArtifact);
+    const execution = await currentContract.execute({
+        wallet: input.wallet,
+        toAddress: prepared.nextCompiled.contractAddress,
+        signer: input.signer,
+        sendAmount: satToBtcAmount(input.nextAmountSat),
+        feeSat: input.feeSat,
+        broadcast: input.broadcast,
+        utxoPolicy: input.utxoPolicy,
+        sequence: resolvePolicySequence(prepared.current.stateValue),
+        witness: buildPolicyDirectWitness(prepared),
+    });
+    return {
+        mode: "direct-hop",
+        prepared,
+        execution,
+    };
+}
+async function verifyTransfer(sdk, input) {
+    const prepared = await verifyState(sdk, {
+        artifactPath: input.currentArtifactPath,
+        artifact: input.currentArtifact,
+        template: input.template,
+        statePath: input.currentStatePath,
+        stateValue: input.currentStateValue,
+    });
+    const currentState = prepared.stateValue;
+    const transfer = input.transferDescriptorValue ? validatePolicyTransferDescriptor(input.transferDescriptorValue) : undefined;
+    const nextState = input.nextStateValue ? validatePolicyState(input.nextStateValue) : undefined;
+    const outputBindingContext = await resolvePolicyOutputBindingVerificationContext(sdk, transfer?.outputDescriptor);
+    const summary = transfer ? summarizePolicyTransferDescriptor(transfer) : undefined;
+    const nextStateSummary = nextState ? summarizePolicyState(nextState) : undefined;
+    const ok = !transfer || (transfer.previousPolicyHash === currentState.policyHash
+        && transfer.previousStateHash === summarizePolicyState(currentState).hash
+        && (!nextState || transfer.nextPolicyHash === nextState.policyHash)
+        && (!nextStateSummary || transfer.nextStateHash === nextStateSummary.hash));
+    return {
+        ok,
+        reason: ok ? undefined : "Policy transfer descriptor does not match current/next policy state",
+        current: prepared,
+        transfer,
+        transferSummary: summary,
+        nextState,
+        verificationReport: {
+            ...prepared.report,
+            nextPolicyPresent: Boolean(nextState),
+            plainExitAllowed: currentState.propagationMode !== "required",
+            outputBinding: buildPolicyOutputBindingReport({
+                descriptor: transfer?.outputDescriptor,
+                sdkVerified: ok,
+                supportedForm: outputBindingContext.supportedForm,
+                reasonCode: outputBindingContext.reasonCode,
+                autoDerived: outputBindingContext.autoDerived,
+                fallbackReason: outputBindingContext.fallbackReason,
+                bindingInputs: outputBindingContext.bindingInputs,
+            }),
+            enforcement: resolvePolicyEnforcementMode({
+                currentPropagationMode: currentState.propagationMode,
+                nextReceiverMode: nextState ? "policy" : "plain",
+            }),
+        },
+    };
+}
+async function inspectTransfer(sdk, input) {
+    const prepared = await prepareTransfer(sdk, input);
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new errors_1.ValidationError("currentArtifactPath or currentArtifact is required", {
+            code: "POLICY_CURRENT_ARTIFACT_REQUIRED",
+        });
+    }
+    const currentContract = sdk.fromArtifact(currentArtifact);
+    if (!prepared.nextCompiled) {
+        const inspect = await currentContract.inspectCall({
+            wallet: input.wallet,
+            toAddress: input.nextReceiver.address,
+            signer: input.signer,
+            sendAmount: satToBtcAmount(input.nextAmountSat),
+            feeSat: input.feeSat,
+            utxoPolicy: input.utxoPolicy,
+            sequence: resolvePolicySequence(prepared.current.stateValue),
+            witness: buildPolicyRecursiveWitness(prepared),
+        });
+        return {
+            mode: "plain-exit",
+            prepared,
+            inspect,
+        };
+    }
+    const inspect = await currentContract.inspectCall({
+        wallet: input.wallet,
+        toAddress: prepared.nextCompiled.contractAddress,
+        signer: input.signer,
+        sendAmount: satToBtcAmount(input.nextAmountSat),
+        feeSat: input.feeSat,
+        utxoPolicy: input.utxoPolicy,
+        sequence: resolvePolicySequence(prepared.current.stateValue),
+        witness: buildPolicyRecursiveWitness(prepared),
+    });
+    return {
+        mode: prepared.verificationReport.enforcement,
+        prepared,
+        inspect,
+    };
+}
+async function executeTransfer(sdk, input) {
+    const prepared = await prepareTransfer(sdk, input);
+    const currentArtifact = input.currentArtifact
+        ?? (input.currentArtifactPath ? (await sdk.loadArtifact(input.currentArtifactPath)).artifact : undefined);
+    if (!currentArtifact) {
+        throw new errors_1.ValidationError("currentArtifactPath or currentArtifact is required", {
+            code: "POLICY_CURRENT_ARTIFACT_REQUIRED",
+        });
+    }
+    const currentContract = sdk.fromArtifact(currentArtifact);
+    if (!prepared.nextCompiled) {
+        const execution = await currentContract.execute({
+            wallet: input.wallet,
+            toAddress: input.nextReceiver.address,
+            signer: input.signer,
+            sendAmount: satToBtcAmount(input.nextAmountSat),
+            feeSat: input.feeSat,
+            broadcast: input.broadcast,
+            utxoPolicy: input.utxoPolicy,
+            sequence: resolvePolicySequence(prepared.current.stateValue),
+            witness: buildPolicyRecursiveWitness(prepared),
+        });
+        return {
+            mode: "plain-exit",
+            prepared,
+            execution,
+        };
+    }
+    const execution = await currentContract.execute({
+        wallet: input.wallet,
+        toAddress: prepared.nextCompiled.contractAddress,
+        signer: input.signer,
+        sendAmount: satToBtcAmount(input.nextAmountSat),
+        feeSat: input.feeSat,
+        broadcast: input.broadcast,
+        utxoPolicy: input.utxoPolicy,
+        sequence: resolvePolicySequence(prepared.current.stateValue),
+        witness: buildPolicyRecursiveWitness(prepared),
+    });
+    return {
+        mode: prepared.verificationReport.enforcement,
+        prepared,
+        execution,
+    };
+}
+async function exportEvidence(sdk, input) {
+    const verified = await verifyState(sdk, {
+        artifactPath: input.artifactPath,
+        artifact: input.artifact,
+        template: input.template,
+        statePath: input.statePath,
+        stateValue: input.stateValue,
+    });
+    const transferVerification = input.transferDescriptorValue
+        ? await verifyTransfer(sdk, {
+            template: input.template,
+            currentArtifact: verified.artifact,
+            currentStateValue: verified.stateValue,
+            transferDescriptorValue: input.transferDescriptorValue,
+        })
+        : undefined;
+    const template = await resolveTemplateDocument(sdk, input.template, verified.stateValue.propagationMode);
+    const stateSummary = summarizePolicyState(verified.stateValue);
+    const artifact = verified.artifact;
+    const renderedSourceHash = artifact.source.simfPath && (0, node_fs_1.existsSync)(artifact.source.simfPath)
+        ? (0, summary_1.sha256HexUtf8)(await (0, promises_1.readFile)(artifact.source.simfPath, "utf8"))
+        : undefined;
+    return {
+        schemaVersion: exports.POLICY_EVIDENCE_BUNDLE_SCHEMA_VERSION,
+        artifact,
+        template: template.summary,
+        state: stateSummary,
+        ...(input.transferDescriptorValue ? { transfer: summarizePolicyTransferDescriptor(input.transferDescriptorValue) } : {}),
+        report: transferVerification?.verificationReport ?? verified.report,
+        renderedSourceHash,
+        sourceVerificationMode: renderedSourceHash ? "source-reloaded" : "artifact-only",
+        compiled: {
+            program: artifact.compiled.program,
+            cmr: artifact.compiled.cmr,
+            contractAddress: artifact.compiled.contractAddress,
+        },
+    };
+}