@deeeed/metamask-harness 0.38.1 → 0.40.0

package/dist/funding-execution-context.js

@@ -0,0 +1,1386 @@
+import { createHash } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import { chmod, lstat, mkdir, open, readFile, readdir, realpath } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { digestRecipeDocument } from "@farmslot/protocol";
+const SHA256 = /^[a-f0-9]{64}$/u;
+const INTEGER = /^(0|[1-9][0-9]{0,39})$/u;
+const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const NODE_ID = /^(?=.{1,256}$)[A-Za-z0-9][A-Za-z0-9._-]{0,63}(?:\/[A-Za-z0-9][A-Za-z0-9._-]{0,63})*$/u;
+const ORIGIN = /^chrome-extension:\/\/[a-p]{32}$/u;
+const MAX_DOCUMENT_BYTES = 256 * 1024;
+const FUNDING_BALANCE_READ_ONLY_ACTIONS = /* @__PURE__ */ new Set([
+  "call",
+  "end",
+  "metamask.perps.read_visible_state",
+  "metamask.wallet.import",
+  "ui.navigate",
+  "ui.wait_for"
+]);
+const CLAIM_DIFF_FIELDS = [
+  "runId",
+  "rootRecipeSha256",
+  "executionPlanSha256",
+  "fundingRequestSha256",
+  "fundingPreflightSha256",
+  "fundingReleaseProofSha256",
+  "fundingBalanceProofSha256",
+  "fundingRequirementsSha256",
+  "runtimeArtifactSha256",
+  "runtimeTreeSha256",
+  "artifactsIdentitySha256",
+  "cdpTargetId",
+  "operationCounts"
+];
+const trustedActionContexts = /* @__PURE__ */ new WeakSet();
+const fundingSources = /* @__PURE__ */ new WeakMap();
+const CURRENT_FUNDING_REGISTRY_SHA256 = "7e79ee2a5f7bdde0a5548208cb2eab55881575cc7d826ee5f7acdbf15d49609c";
+const FROZEN_G005_FUNDING_REGISTRY_SHA256 = "c2230bc02fa00d6902915d1cb81bcc08389ea7e399ee9618f26fb0d9fc00b291";
+const LIVE_PERPS_TINY_REGISTRY = {
+  "live-perps-tiny": {
+    perps: {
+      clients: /* @__PURE__ */ new Set(["extension", "mobile"]),
+      requirements: /* @__PURE__ */ new Map([
+        ["metric:perps-available-margin-usdc", { minBaseUnits: "30000000" }]
+      ]),
+      budgets: /* @__PURE__ */ new Map([
+        ["perps-market-order:usdc-base-units", { maxBaseUnits: "11000000", maxCount: 1 }],
+        ["perps-close-position:usdc-base-units", { maxBaseUnits: "11000000", maxCount: 1 }],
+        ["perps-limit-order:usdc-base-units", { maxBaseUnits: "10000000", maxCount: 1 }],
+        ["perps-cancel-order:usdc-base-units", { maxBaseUnits: "10000000", maxCount: 1 }],
+        ["perps-margin-adjust:usdc-base-units", { maxBaseUnits: "1000000", maxCount: 2 }],
+        ["perps-tpsl-update:usdc-base-units", { maxBaseUnits: "10000000", maxCount: 1 }]
+      ])
+    }
+  }
+};
+const TRUSTED_FUNDING_REGISTRIES = {
+  [CURRENT_FUNDING_REGISTRY_SHA256]: LIVE_PERPS_TINY_REGISTRY,
+  [FROZEN_G005_FUNDING_REGISTRY_SHA256]: LIVE_PERPS_TINY_REGISTRY
+};
+const OPERATION_ACTION = /* @__PURE__ */ new Map([
+  ["perps-market-order", "metamask.perps.place_order"],
+  ["perps-limit-order", "metamask.perps.place_order"],
+  ["perps-close-position", "metamask.perps.close_visible_position"],
+  ["perps-cancel-order", "metamask.perps.close_orders"],
+  ["perps-margin-adjust", "metamask.perps.edit_margin"],
+  ["perps-tpsl-update", "metamask.perps.update_position_tpsl"]
+]);
+async function loadTrustedMutationBase(options) {
+  const { fundingRequest, fundingPreflight, fundingReleaseProof, fundingBalanceProof } = options;
+  if (!fundingRequest && !fundingPreflight && !fundingReleaseProof && !fundingBalanceProof) return void 0;
+  if (!fundingRequest || !fundingPreflight || !fundingReleaseProof || !fundingBalanceProof) {
+    throw new Error(
+      "External-mutation funding requires --funding-request, --funding-preflight, --funding-release-proof, and --funding-balance-proof. Next: provide the exact preflight input chain."
+    );
+  }
+  if (![fundingRequest, fundingPreflight, fundingReleaseProof, fundingBalanceProof].every(path.isAbsolute)) {
+    throw new Error(
+      "External-mutation funding files must use absolute paths. Next: pass absolute --funding-request and --funding-preflight paths."
+    );
+  }
+  if (!path.isAbsolute(options.artifactsDir)) {
+    throw new Error("Runner artifactsDir must be absolute before funding context is created.");
+  }
+  if (!isRecord(options.rootRecipe)) {
+    throw new Error("External-mutation funding requires the loaded root recipe document.");
+  }
+  if (!options.projectRoot && !options.testIo?.currentReleaseRuntime) {
+    throw new Error("External-mutation funding requires the runner project root for current release-artifact validation.");
+  }
+  if (options.testIo?.currentReleaseRuntime && process.env.NODE_ENV !== "test") {
+    throw new Error("Current release runtime override is test-only.");
+  }
+  const documents = await readFundingDocuments(
+    fundingRequest,
+    fundingPreflight,
+    fundingReleaseProof,
+    fundingBalanceProof
+  );
+  const identity = await validateFundingDocuments(documents);
+  const currentReleaseRuntime = options.testIo?.currentReleaseRuntime ?? releaseRuntimeValidator(path.resolve(options.projectRoot));
+  const currentRelease = await currentReleaseRuntime(false, identity.cdpPort);
+  if (currentRelease.artifactSha256 !== identity.subjectDigest || currentRelease.treeSha256 !== identity.releaseTreeSha256) {
+    throw new Error("Runner-owned current release artifact does not match the funding release proof.");
+  }
+  const fundingRequirementsSha256 = sha256(canonical(identity.requirements));
+  const rootRecipeSha256 = normalizeRecipeDigest(digestRecipeDocument(options.rootRecipe));
+  const runId = sha256(JSON.stringify({
+    artifactsDir: options.artifactsDir,
+    requestSha256: documents.requestSha256,
+    preflightSha256: documents.preflightSha256,
+    releaseProofSha256: documents.releaseProofSha256,
+    balanceProofSha256: documents.balanceProofSha256,
+    rootRecipeSha256
+  }));
+  const trusted = deepFreeze({
+    runId,
+    rootRecipeSha256,
+    requestSha256: documents.requestSha256,
+    preflightSha256: documents.preflightSha256,
+    releaseProofSha256: documents.releaseProofSha256,
+    balanceProofSha256: documents.balanceProofSha256,
+    fundingRequirementsSha256,
+    runtimeArtifactSha256: currentRelease.artifactSha256,
+    runtimeTreeSha256: currentRelease.treeSha256,
+    ...identity
+  });
+  fundingSources.set(trusted, {
+    artifactsDir: options.artifactsDir,
+    currentReleaseRuntime
+  });
+  return trusted;
+}
+async function authorizeTrustedMutationPlan(base, plan, testIo = {}) {
+  const source = fundingSources.get(base);
+  if (!source) throw new Error("Funding plan authorization requires the original runner-verified context.");
+  const executionPlanSha256 = normalizeRecipeDigest(plan.digest);
+  const nodes = Array.isArray(plan.nodes) ? plan.nodes : [];
+  const actual = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node.capabilities.includes("external-mutation")) continue;
+    actual.set(node.action, (actual.get(node.action) ?? 0) + 1);
+  }
+  const expected = /* @__PURE__ */ new Map();
+  const operationsByAction = /* @__PURE__ */ new Map();
+  for (const operation of base.operations) {
+    const action = OPERATION_ACTION.get(operation.operation);
+    if (!action) throw new Error(`Funding operation ${operation.operation} has no external-mutation action binding.`);
+    expected.set(action, (expected.get(action) ?? 0) + operation.count);
+    const names = operationsByAction.get(action) ?? /* @__PURE__ */ new Set();
+    names.add(operation.operation);
+    operationsByAction.set(action, names);
+  }
+  if ([...operationsByAction.values()].some((operations) => operations.size !== 1)) {
+    throw new Error("Funding request has ambiguous operation types for one external-mutation action.");
+  }
+  const actions = /* @__PURE__ */ new Set([...actual.keys(), ...expected.keys()]);
+  for (const action of actions) {
+    if ((actual.get(action) ?? 0) !== (expected.get(action) ?? 0)) {
+      throw new Error(`Resolved plan external-mutation count for ${action} does not match the funding request.`);
+    }
+  }
+  if (actual.size === 0) throw new Error("Funding documents require a resolved external-mutation plan.");
+  const artifactsIdentitySha256 = await directoryIdentity(source.artifactsDir);
+  const operationCounts = [...expected.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([action, count]) => ({ action, count }));
+  const runId = sha256(canonical({
+    requestSha256: base.requestSha256,
+    preflightSha256: base.preflightSha256,
+    releaseProofSha256: base.releaseProofSha256,
+    balanceProofSha256: base.balanceProofSha256,
+    executionPlanSha256,
+    artifactsIdentitySha256
+  }));
+  const claim = {
+    schemaVersion: 1,
+    kind: "funding-execution-claim",
+    runId,
+    rootRecipeSha256: base.rootRecipeSha256,
+    executionPlanSha256,
+    fundingRequestSha256: base.requestSha256,
+    fundingPreflightSha256: base.preflightSha256,
+    fundingReleaseProofSha256: base.releaseProofSha256,
+    fundingBalanceProofSha256: base.balanceProofSha256,
+    fundingRequirementsSha256: base.fundingRequirementsSha256,
+    runtimeArtifactSha256: base.runtimeArtifactSha256,
+    runtimeTreeSha256: base.runtimeTreeSha256,
+    artifactsIdentitySha256,
+    cdpTargetId: base.cdpTargetId,
+    operationCounts
+  };
+  if (testIo.ledgerRoot && process.env.NODE_ENV !== "test") {
+    throw new Error("Funding execution ledger override is test-only.");
+  }
+  const executionClaimsRoot = await validatorLedgerRoot(testIo.ledgerRoot);
+  const executionLedgerRoot = path.join(path.dirname(executionClaimsRoot), "funding-execution-starts");
+  await ensurePrivateDirectory(path.dirname(executionLedgerRoot), executionLedgerRoot);
+  const currentExecutionClaimSha256 = sha256(canonical(claim));
+  const recoveryAlias = await publishExecutionClaim(
+    base,
+    claim,
+    source.artifactsDir,
+    plan,
+    executionClaimsRoot
+  );
+  const authorized = deepFreeze({
+    ...base,
+    runId: recoveryAlias?.runId ?? runId,
+    executionPlanSha256: recoveryAlias?.executionPlanSha256 ?? executionPlanSha256,
+    artifactsIdentitySha256,
+    ...recoveryAlias ? { recoveryPlanAlias: true } : {}
+  });
+  fundingSources.set(authorized, {
+    ...source,
+    executionLedgerRoot,
+    executionClaimSha256: recoveryAlias?.executionClaimSha256 ?? currentExecutionClaimSha256
+  });
+  return authorized;
+}
+async function trustedMutationForAction(base, recipe, selectedIdentitySha256) {
+  if (!selectedIdentitySha256 || !SHA256.test(selectedIdentitySha256)) {
+    throw new Error(
+      "External mutation requires a successful same-run metamask.wallet.import selected identity proof. Next: run metamask.wallet.import before the mutation node."
+    );
+  }
+  if (selectedIdentitySha256 !== base.selectedIdentitySha256) {
+    throw new Error("External mutation wallet identity does not match the independently validated funding evidence.");
+  }
+  const source = fundingSources.get(base);
+  if (!source) throw new Error("External mutation requires the original runner-verified funding context.");
+  if (!source.executionLedgerRoot || !source.executionClaimSha256) {
+    throw new Error("External mutation requires an authorized validator-owned execution ledger.");
+  }
+  const currentRelease = await source.currentReleaseRuntime(true, base.cdpPort);
+  if (currentRelease.artifactSha256 !== base.runtimeArtifactSha256 || currentRelease.treeSha256 !== base.runtimeTreeSha256) {
+    throw new Error("Runner-owned current release artifact changed before external mutation.");
+  }
+  const trusted = deepFreeze({
+    ...base,
+    recipeSha256: normalizeRecipeDigest(digestRecipeDocument(recipe)),
+    selectedIdentitySha256,
+    executionLedgerRoot: source.executionLedgerRoot,
+    executionClaimSha256: source.executionClaimSha256
+  });
+  trustedActionContexts.add(trusted);
+  return trusted;
+}
+function serializeTrustedMutationContext(value) {
+  if (!isRecord(value) || !trustedActionContexts.has(value)) {
+    throw new Error("Live adapter refused an untrusted mutation context.");
+  }
+  const trusted = value;
+  return {
+    runId: trusted.runId,
+    rootRecipeSha256: trusted.rootRecipeSha256,
+    ...trusted.executionPlanSha256 ? { executionPlanSha256: trusted.executionPlanSha256 } : {},
+    ...trusted.artifactsIdentitySha256 ? { artifactsIdentitySha256: trusted.artifactsIdentitySha256 } : {},
+    ...trusted.recoveryPlanAlias ? { recoveryPlanAlias: true } : {},
+    recipeSha256: trusted.recipeSha256,
+    executionLedgerRoot: trusted.executionLedgerRoot,
+    executionClaimSha256: trusted.executionClaimSha256,
+    requestSha256: trusted.requestSha256,
+    preflightSha256: trusted.preflightSha256,
+    releaseProofSha256: trusted.releaseProofSha256,
+    balanceProofSha256: trusted.balanceProofSha256,
+    fundingRequirementsSha256: trusted.fundingRequirementsSha256,
+    runtimeArtifactSha256: trusted.runtimeArtifactSha256,
+    runtimeTreeSha256: trusted.runtimeTreeSha256,
+    registrySha256: trusted.registrySha256,
+    profileId: trusted.profileId,
+    domain: trusted.domain,
+    client: trusted.client,
+    proofLane: trusted.proofLane,
+    targetId: trusted.targetId,
+    subjectDigest: trusted.subjectDigest,
+    selectedIdentitySha256: trusted.selectedIdentitySha256,
+    runtimeSessionId: trusted.runtimeSessionId,
+    cdpPort: trusted.cdpPort,
+    cdpTargetId: trusted.cdpTargetId,
+    extensionOrigin: trusted.extensionOrigin,
+    operations: trusted.operations.map((operation) => ({ ...operation })),
+    budgets: trusted.budgets.map((budget) => ({ ...budget })),
+    requirements: trusted.requirements.map((requirement) => ({ ...requirement }))
+  };
+}
+function selectedIdentityFromWalletImport(action, result, expected) {
+  if (action !== "metamask.wallet.import" || !isRecord(result)) return void 0;
+  const output = isRecord(result.output) ? result.output : void 0;
+  const method = output?.method;
+  const proofPath = method === "ui-import" ? "extension-visible-onboarding-import" : method === "ui-visible-session" ? "extension-visible-wallet-session" : "";
+  if (!output || output.action !== "metamask.wallet.import" || !proofPath || output.credentialSource !== "environment" || output.credentialSourceName !== "MM_RELEASE_SELECTED_WALLET_SRP" || output.proofPath !== proofPath || output.redacted !== true || output.selectedAddressMatched !== true || typeof output.selectedIdentitySha256 !== "string" || !SHA256.test(output.selectedIdentitySha256) || typeof output.runtimeSessionId !== "string" || !IDENTIFIER.test(output.runtimeSessionId) || !Number.isSafeInteger(output.cdpPort) || Number(output.cdpPort) < 1 || Number(output.cdpPort) > 65535 || typeof output.cdpTargetId !== "string" || !IDENTIFIER.test(output.cdpTargetId)) {
+    return void 0;
+  }
+  let origin;
+  try {
+    const target = new URL(String(output.targetUrl));
+    origin = `${target.protocol}//${target.hostname}`;
+  } catch {
+    return void 0;
+  }
+  if (!ORIGIN.test(origin) || expected && (output.selectedIdentitySha256 !== expected.selectedIdentitySha256 || output.runtimeSessionId !== expected.runtimeSessionId || output.cdpPort !== expected.cdpPort || output.cdpTargetId !== expected.cdpTargetId || origin !== expected.extensionOrigin)) {
+    return void 0;
+  }
+  return output.selectedIdentitySha256;
+}
+async function readFundingDocuments(requestPath, preflightPath, releaseProofPath, balanceProofPath) {
+  const [requestBytes, preflightBytes, releaseProofBytes, balanceProofBytes] = await Promise.all([
+    readRegularFile(requestPath, "--funding-request"),
+    readRegularFile(preflightPath, "--funding-preflight"),
+    readRegularFile(releaseProofPath, "--funding-release-proof"),
+    readRegularFile(balanceProofPath, "--funding-balance-proof")
+  ]);
+  return {
+    request: parseObject(requestBytes, "--funding-request"),
+    preflight: parseObject(preflightBytes, "--funding-preflight"),
+    releaseProof: parseObject(releaseProofBytes, "--funding-release-proof"),
+    balanceProof: parseObject(balanceProofBytes, "--funding-balance-proof"),
+    requestSha256: sha256(requestBytes),
+    preflightSha256: sha256(preflightBytes),
+    releaseProofSha256: sha256(releaseProofBytes),
+    balanceProofSha256: sha256(balanceProofBytes),
+    releaseProofPath: await realpath(releaseProofPath),
+    balanceProofPath: await realpath(balanceProofPath)
+  };
+}
+async function readRegularFile(file, option) {
+  const linkInfo = await lstat(file);
+  if (linkInfo.isSymbolicLink() || !linkInfo.isFile()) {
+    throw new Error(`${option} must name a regular non-symlink file.`);
+  }
+  const handle = await open(file, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || info.size <= 0 || info.size > MAX_DOCUMENT_BYTES) {
+      throw new Error(`${option} must be a nonempty regular file no larger than ${MAX_DOCUMENT_BYTES} bytes.`);
+    }
+    return await handle.readFile();
+  } finally {
+    await handle.close();
+  }
+}
+async function directoryIdentity(directory) {
+  const resolved = path.resolve(directory);
+  const info = await lstat(resolved);
+  if (!info.isDirectory() || info.isSymbolicLink() || await realpath(resolved) !== resolved) {
+    throw new Error("Runner artifactsDir must be a regular non-symlink directory before funding authorization.");
+  }
+  return sha256(canonical({ path: resolved, device: String(info.dev), inode: String(info.ino) }));
+}
+async function publishExecutionClaim(base, claim, artifactsDir, plan, directory) {
+  const releaseIdentityKey = sha256(canonical({
+    registrySha256: base.registrySha256,
+    profileId: base.profileId,
+    domain: base.domain,
+    client: base.client,
+    proofLane: base.proofLane,
+    targetId: base.targetId,
+    subjectDigest: base.subjectDigest
+  }));
+  const identityKey = sha256(canonical({
+    releaseIdentityKey,
+    requestSha256: base.requestSha256,
+    preflightSha256: base.preflightSha256
+  }));
+  const stateRoot = path.dirname(directory);
+  const claimPath = path.join(directory, `${identityKey}.json`);
+  const bytes = canonical(claim);
+  let currentClaimExists = true;
+  try {
+    await lstat(claimPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    currentClaimExists = false;
+  }
+  if (!currentClaimExists) {
+    const legacyRecovery = await recoverLegacyExecutionClaim(
+      path.join(directory, `${releaseIdentityKey}.json`),
+      bytes,
+      artifactsDir,
+      base,
+      plan
+    );
+    if (legacyRecovery) return legacyRecovery;
+  }
+  try {
+    const handle = await open(claimPath, "wx", 384);
+    try {
+      await handle.writeFile(bytes);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await syncDirectory(directory);
+    await syncDirectory(stateRoot);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const info = await lstat(claimPath);
+    if (!info.isFile() || info.isSymbolicLink()) throw new Error("Funding execution claim is unsafe.");
+    const existing = await readFile(claimPath, "utf8");
+    if (existing !== bytes) {
+      const comparison = compareExecutionClaims(existing, bytes);
+      if (comparison.differences.length === 2 && comparison.differences.includes("runId") && comparison.differences.includes("executionPlanSha256")) {
+        await requireSafeRecoveryReceiptChain(artifactsDir, comparison.existing, base, plan);
+        await syncDirectory(directory);
+        await syncDirectory(stateRoot);
+        return {
+          runId: comparison.existing.runId,
+          executionPlanSha256: comparison.existing.executionPlanSha256,
+          executionClaimSha256: sha256(existing)
+        };
+      }
+      throw new Error(executionClaimMismatch(comparison));
+    }
+    await syncDirectory(directory);
+    await syncDirectory(stateRoot);
+  }
+  return void 0;
+}
+async function recoverLegacyExecutionClaim(claimPath, currentBytes, artifactsDir, base, plan) {
+  let info;
+  try {
+    info = await lstat(claimPath);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  if (!info.isFile() || info.isSymbolicLink()) throw new Error("Funding execution claim is unsafe.");
+  const existingBytes = await readFile(claimPath, "utf8");
+  const comparison = compareExecutionClaims(existingBytes, currentBytes);
+  const sameFundingDocuments = comparison.existing.fundingRequestSha256 === comparison.current.fundingRequestSha256 && comparison.existing.fundingPreflightSha256 === comparison.current.fundingPreflightSha256 && comparison.existing.fundingReleaseProofSha256 === comparison.current.fundingReleaseProofSha256 && comparison.existing.fundingBalanceProofSha256 === comparison.current.fundingBalanceProofSha256;
+  if (!sameFundingDocuments) return void 0;
+  if (existingBytes !== currentBytes) throw new Error(executionClaimMismatch(comparison));
+  await requireSafeRecoveryReceiptChain(artifactsDir, comparison.existing, base, plan);
+  return {
+    runId: comparison.existing.runId,
+    executionPlanSha256: comparison.existing.executionPlanSha256,
+    executionClaimSha256: sha256(existingBytes)
+  };
+}
+function compareExecutionClaims(existingBytes, currentBytes) {
+  let existing;
+  let current;
+  try {
+    existing = parseExecutionClaimIdentity(existingBytes);
+    current = parseExecutionClaimIdentity(currentBytes);
+  } catch {
+    throw new Error("Funding execution claim is unsafe.");
+  }
+  const differences = CLAIM_DIFF_FIELDS.filter((field) => JSON.stringify(existing[field]) !== JSON.stringify(current[field]));
+  return { existing, current, differences };
+}
+function executionClaimMismatch(comparison) {
+  const differences = comparison.differences.map((field) => `${field} existing=${JSON.stringify(comparison.existing[field])} current=${JSON.stringify(comparison.current[field])}`);
+  const detail = differences.length > 0 ? ` Claim differences: ${differences.join("; ")}.` : "";
+  return `Funding request is already claimed by a different plan, artifacts directory, or execution.${detail}`;
+}
+function parseExecutionClaimIdentity(bytes) {
+  const value = JSON.parse(bytes);
+  if (!isRecord(value)) throw new Error("claim must be an object");
+  const expectedKeys = ["schemaVersion", "kind", ...CLAIM_DIFF_FIELDS].sort();
+  if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify(expectedKeys) || value.schemaVersion !== 1 || value.kind !== "funding-execution-claim") {
+    throw new Error("claim shape is invalid");
+  }
+  const identity = {};
+  for (const field of CLAIM_DIFF_FIELDS.slice(0, -2)) {
+    if (typeof value[field] !== "string" || !SHA256.test(value[field])) {
+      throw new Error(`claim ${field} is invalid`);
+    }
+    identity[field] = value[field];
+  }
+  if (typeof value.cdpTargetId !== "string" || !IDENTIFIER.test(value.cdpTargetId)) {
+    throw new Error("claim cdpTargetId is invalid");
+  }
+  identity.cdpTargetId = value.cdpTargetId;
+  if (!Array.isArray(value.operationCounts) || value.operationCounts.length < 1 || value.operationCounts.length > 32) {
+    throw new Error("claim operationCounts is invalid");
+  }
+  identity.operationCounts = value.operationCounts.map((entry) => {
+    if (!isRecord(entry) || typeof entry.action !== "string" || !IDENTIFIER.test(entry.action) || !Number.isInteger(entry.count) || Number(entry.count) < 1 || Number(entry.count) > 1e3) {
+      throw new Error("claim operationCounts entry is invalid");
+    }
+    return { action: entry.action, count: Number(entry.count) };
+  });
+  return identity;
+}
+async function requireSafeRecoveryReceiptChain(artifactsDir, claim, base, plan) {
+  const receiptDirectory = path.join(artifactsDir, "mutation-receipts");
+  let directoryInfo;
+  try {
+    directoryInfo = await lstat(receiptDirectory);
+  } catch {
+    throw new Error("Funding recovery requires a safe external mutation receipt chain.");
+  }
+  if (!directoryInfo.isDirectory() || directoryInfo.isSymbolicLink() || await realpath(receiptDirectory) !== receiptDirectory) {
+    throw new Error("Funding recovery receipt directory is unsafe.");
+  }
+  const externalNodes = plan.nodes.filter((node) => node.capabilities.includes("external-mutation"));
+  if (externalNodes.length < 1 || new Set(externalNodes.map((node) => node.nodeId)).size !== externalNodes.length) {
+    throw new Error("Funding recovery external mutation plan is unsafe.");
+  }
+  const entries = await readdir(receiptDirectory, { withFileTypes: true });
+  if (entries.length < 1 || entries.length > externalNodes.length || entries.some((entry) => !entry.isFile() || entry.isSymbolicLink() || !/^[a-f0-9]{64}\.json$/u.test(entry.name))) {
+    throw new Error("Funding recovery receipt chain contains unsafe or extra entries.");
+  }
+  const matches = [
+    ["runId", "runId"],
+    ["rootRecipeSha256", "rootRecipeSha256"],
+    ["executionPlanSha256", "executionPlanSha256"],
+    ["artifactsIdentitySha256", "artifactsIdentitySha256"],
+    ["fundingRequestSha256", "fundingRequestSha256"],
+    ["fundingPreflightSha256", "fundingPreflightSha256"],
+    ["fundingReleaseProofSha256", "fundingReleaseProofSha256"],
+    ["fundingBalanceProofSha256", "fundingBalanceProofSha256"],
+    ["fundingRequirementsSha256", "fundingRequirementsSha256"],
+    ["runtimeArtifactSha256", "runtimeArtifactSha256"],
+    ["runtimeTreeSha256", "runtimeTreeSha256"]
+  ];
+  const receiptByNode = /* @__PURE__ */ new Map();
+  let runtimeIdentity;
+  for (const entry of entries) {
+    const receiptPath = path.join(receiptDirectory, entry.name);
+    const receiptInfo = await lstat(receiptPath);
+    if (!receiptInfo.isFile() || receiptInfo.isSymbolicLink() || receiptInfo.size <= 0 || receiptInfo.size > MAX_DOCUMENT_BYTES) {
+      throw new Error("Funding recovery mutation receipt is unsafe.");
+    }
+    const handle = await open(receiptPath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    let bytes;
+    try {
+      const openedInfo = await handle.stat();
+      if (!openedInfo.isFile() || openedInfo.size !== receiptInfo.size) {
+        throw new Error("Funding recovery mutation receipt changed during inspection.");
+      }
+      bytes = await handle.readFile();
+    } finally {
+      await handle.close();
+    }
+    let receipt;
+    try {
+      receipt = parseObject(bytes, "Funding recovery mutation receipt");
+    } catch {
+      throw new Error("Funding recovery mutation receipt is unsafe.");
+    }
+    if (canonical(receipt) !== bytes.toString("utf8") || receipt.schemaVersion !== 1 || receipt.kind !== "external-mutation-receipt" || !isRecord(receipt.identity) || receipt.state !== "succeeded" && receipt.state !== "outcome-unknown") {
+      throw new Error("Funding recovery mutation receipt shape or state is unsafe.");
+    }
+    const identity = receipt.identity;
+    for (const [claimField, receiptField] of matches) {
+      if (typeof identity[receiptField] !== "string" || !SHA256.test(identity[receiptField]) || identity[receiptField] !== claim[claimField]) {
+        throw new Error(`Funding recovery receipt identity ${receiptField} does not match the existing claim.`);
+      }
+    }
+    const nodeId = String(identity.nodeId ?? "");
+    if (!NODE_ID.test(nodeId) || entry.name !== `${sha256(nodeId)}.json` || identity.executionId !== sha256(`${claim.runId}\0${nodeId}`)) {
+      throw new Error("Funding recovery receipt node digest is invalid.");
+    }
+    const node = externalNodes.find((candidate) => candidate.nodeId === nodeId);
+    const operation = base.operations.filter((candidate) => OPERATION_ACTION.get(candidate.operation) === identity.action && candidate.operation === identity.operation && candidate.amountBaseUnits === identity.amountBaseUnits);
+    if (!node || node.action !== identity.action || operation.length !== 1) {
+      throw new Error("Funding recovery receipt does not map uniquely to an authorized external node.");
+    }
+    const currentRuntimeIdentity = canonical({
+      selectedIdentitySha256: identity.selectedIdentitySha256,
+      cdpPort: identity.cdpPort,
+      runtimeSessionId: identity.runtimeSessionId,
+      cdpTargetId: identity.cdpTargetId,
+      extensionOrigin: identity.extensionOrigin
+    });
+    if (!SHA256.test(String(identity.selectedIdentitySha256 ?? "")) || !Number.isInteger(identity.cdpPort) || Number(identity.cdpPort) < 1 || Number(identity.cdpPort) > 65535 || !IDENTIFIER.test(String(identity.runtimeSessionId ?? "")) || !IDENTIFIER.test(String(identity.cdpTargetId ?? "")) || !ORIGIN.test(String(identity.extensionOrigin ?? "")) || identity.selectedIdentitySha256 !== base.selectedIdentitySha256 || identity.cdpPort !== base.cdpPort || identity.runtimeSessionId !== base.runtimeSessionId || identity.cdpTargetId !== base.cdpTargetId || identity.cdpTargetId !== claim.cdpTargetId || identity.extensionOrigin !== base.extensionOrigin || runtimeIdentity !== void 0 && runtimeIdentity !== currentRuntimeIdentity) {
+      throw new Error("Funding recovery receipt wallet or runtime identity drifted.");
+    }
+    runtimeIdentity = currentRuntimeIdentity;
+    if (receipt.state === "succeeded") {
+      if (!isRecord(receipt.observation) || typeof receipt.observationSha256 !== "string" || receipt.observationSha256 !== sha256(canonical(receipt.observation))) {
+        throw new Error("Funding recovery succeeded receipt observation digest is invalid.");
+      }
+    } else if ("observation" in receipt || "observationSha256" in receipt) {
+      throw new Error("Funding recovery outcome-unknown receipt contains a completed observation.");
+    }
+    if (receiptByNode.has(nodeId)) throw new Error("Funding recovery receipt chain has a duplicate node.");
+    receiptByNode.set(nodeId, receipt);
+  }
+  let sawOutcomeUnknown = false;
+  for (let index = 0; index < externalNodes.length; index += 1) {
+    const receipt = receiptByNode.get(externalNodes[index].nodeId);
+    if (!receipt) {
+      if (index !== receiptByNode.size) throw new Error("Funding recovery receipt chain has a gap or later receipt.");
+      break;
+    }
+    if (receipt.state === "outcome-unknown") {
+      if (sawOutcomeUnknown || index !== receiptByNode.size - 1) {
+        throw new Error("Funding recovery allows at most one outcome-unknown receipt at the next boundary.");
+      }
+      sawOutcomeUnknown = true;
+    } else if (sawOutcomeUnknown) {
+      throw new Error("Funding recovery succeeded receipt follows an outcome-unknown boundary.");
+    }
+  }
+}
+async function validatorLedgerRoot(testLedgerRoot) {
+  if (testLedgerRoot) {
+    const directory = path.resolve(testLedgerRoot);
+    await ensurePrivateDirectory(path.dirname(directory), directory);
+    return directory;
+  }
+  const home = await realpath(os.homedir());
+  const harnessRoot = path.join(home, ".mm-harness");
+  const stateRoot = path.join(harnessRoot, "state");
+  const ledgerRoot = path.join(stateRoot, "funding-execution-claims");
+  await ensurePrivateDirectory(home, harnessRoot);
+  await ensurePrivateDirectory(harnessRoot, stateRoot);
+  await ensurePrivateDirectory(stateRoot, ledgerRoot);
+  return ledgerRoot;
+}
+async function ensurePrivateDirectory(parent, directory) {
+  const resolvedParent = path.resolve(parent);
+  if (await realpath(resolvedParent) !== resolvedParent || path.dirname(path.resolve(directory)) !== resolvedParent) {
+    throw new Error("Funding execution ledger must remain inside its validator-owned state root.");
+  }
+  let created = false;
+  try {
+    await mkdir(directory, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink() || await realpath(directory) !== path.resolve(directory)) {
+    throw new Error("Funding execution ledger directory is unsafe.");
+  }
+  await chmod(directory, 448);
+  if (created) await syncDirectory(resolvedParent);
+}
+async function syncDirectory(directory) {
+  const handle = await open(directory, "r");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+function parseObject(bytes, option) {
+  try {
+    const value = JSON.parse(bytes.toString("utf8"));
+    if (!isRecord(value)) throw new Error("root must be an object");
+    return value;
+  } catch (error) {
+    throw new Error(`${option} is not a valid JSON object: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function validateFundingDocuments(documents) {
+  const request = documents.request;
+  const preflight = documents.preflight;
+  if (preflight.status !== "pass" || preflight.fundingReady !== true || preflight.mutationEligible !== true) {
+    throw new Error("Funding preflight is not eligible for external mutation.");
+  }
+  const mutation = requireRecord(preflight.mutation, "funding preflight mutation");
+  if (mutation.requested !== true || mutation.consent !== true) {
+    throw new Error("Funding preflight must bind a requested mutation with explicit consent.");
+  }
+  if (request.consent !== true) throw new Error("Funding request consent must be true.");
+  if (mutation.requestSha256 !== documents.requestSha256) {
+    throw new Error("Funding request bytes do not match funding preflight mutation.requestSha256.");
+  }
+  const requestOperations = parseOperations(request.operations, "funding request operations");
+  const preflightOperations = parseOperations(mutation.operations, "funding preflight operations");
+  if (JSON.stringify(requestOperations) !== JSON.stringify(preflightOperations)) {
+    throw new Error("Funding preflight operations do not exactly match the funding request.");
+  }
+  const budgets = parseBudgets(mutation.budgets);
+  for (const operation of requestOperations) {
+    const budget = budgets.find((candidate) => candidate.operation === operation.operation && candidate.unit === operation.unit);
+    if (!budget || BigInt(operation.amountBaseUnits) > BigInt(budget.maxBaseUnits) || operation.count > budget.maxCount) {
+      throw new Error(`Funding operation ${operation.operation} exceeds or lacks its preflight budget.`);
+    }
+  }
+  const identity = requireRecord(preflight.identity, "funding preflight identity");
+  const fields = ["registrySha256", "profileId", "domain", "client", "proofLane", "targetId", "subjectDigest"];
+  const values = {};
+  for (const field of fields) {
+    const requestValue = requireIdentifier(request[field], `funding request ${field}`, field.endsWith("Sha256") || field === "subjectDigest");
+    const preflightValue = requireIdentifier(identity[field], `funding preflight identity ${field}`, field.endsWith("Sha256") || field === "subjectDigest");
+    if (requestValue !== preflightValue) throw new Error(`Funding identity ${field} does not match the request.`);
+    values[field] = requestValue;
+  }
+  validateTrustedFundingRegistry(values, requestOperations, budgets);
+  const evidence = await validateFundingEvidenceChain(documents, values);
+  const preflightRequirements = parsePreflightRequirements(preflight.requirements);
+  if (JSON.stringify(preflightRequirements) !== JSON.stringify(evidence.requirements)) {
+    throw new Error("Funding preflight requirements do not match the independently validated balance evidence.");
+  }
+  return {
+    ...values,
+    ...evidence.runtime,
+    operations: requestOperations,
+    budgets,
+    requirements: evidence.requirements,
+    releaseTreeSha256: evidence.releaseTreeSha256
+  };
+}
+async function validateFundingEvidenceChain(documents, identity) {
+  const releaseProof = documents.releaseProof;
+  const releaseRoot = path.dirname(documents.releaseProofPath);
+  if (!documents.balanceProofPath.startsWith(`${releaseRoot}${path.sep}`)) {
+    throw new Error("Funding balance proof must be contained by the release-proof root.");
+  }
+  for (const field of ["client", "proofLane", "targetId", "subjectDigest"]) {
+    if (releaseProof[field] !== identity[field]) {
+      throw new Error(`Funding release proof ${field} does not match the request identity.`);
+    }
+  }
+  const policy = requireRecord(releaseProof.fundingPolicy, "funding release proof fundingPolicy");
+  if (policy.required !== true || policy.registrySha256 !== identity.registrySha256 || policy.profileId !== identity.profileId || policy.domain !== identity.domain) {
+    throw new Error("Funding release proof does not bind the runner-trusted funding policy.");
+  }
+  const artifact = requireRecord(releaseProof.artifact, "funding release proof artifact");
+  if (artifact.sha256 !== identity.subjectDigest || !SHA256.test(String(artifact.treeSha256 ?? ""))) {
+    throw new Error("Funding release proof artifact identity is invalid.");
+  }
+  const runtime = requireRecord(releaseProof.runtime, "funding release proof runtime");
+  const extensionRuntime = requireRecord(runtime.extension, "funding release proof Extension runtime");
+  if (identity.client !== "extension" || identity.proofLane !== "official-unmodified" || runtime.fixtures !== false || runtime.instrumentation !== false || extensionRuntime.cleanProfile !== true || extensionRuntime.runtimeTreeSha256 !== artifact.treeSha256) {
+    throw new Error("Funding release proof is not an unmodified clean Extension runtime.");
+  }
+  const onboarding = requireRecord(releaseProof.walletOnboarding, "funding release proof walletOnboarding");
+  const onboardingRuntime = requireRecord(onboarding.runtime, "funding release proof wallet runtime");
+  const onboardingTracePath = await containedRegularPath(releaseRoot, onboarding.evidence, "funding release onboarding evidence");
+  if (sha256(await readFile(onboardingTracePath)) !== onboarding.evidenceSha256) {
+    throw new Error("Funding release onboarding evidence digest is invalid.");
+  }
+  const onboardingRun = requireRecord(onboarding.run, "funding release onboarding run");
+  const onboardingArtifact = async (field) => {
+    const reference = requireRecord(onboardingRun[field], `funding release onboarding run ${field}`);
+    const artifactPath = await containedRegularPath(
+      releaseRoot,
+      reference.path,
+      `funding release onboarding run ${field}`
+    );
+    const bytes = await readFile(artifactPath);
+    if (reference.sha256 !== sha256(bytes)) {
+      throw new Error(`Funding release onboarding run ${field} digest is invalid.`);
+    }
+    return { document: parseObject(bytes, `funding release onboarding run ${field}`), artifactPath };
+  };
+  const onboardingRecipeArtifact = await onboardingArtifact("recipe");
+  const onboardingResolutionArtifact = await onboardingArtifact("recipeResolution");
+  const onboardingTraceArtifact = await onboardingArtifact("trace");
+  const onboardingSummaryArtifact = await onboardingArtifact("summary");
+  const onboardingManifestArtifact = await onboardingArtifact("artifactManifest");
+  const onboardingPaths = [
+    onboardingRecipeArtifact,
+    onboardingResolutionArtifact,
+    onboardingTraceArtifact,
+    onboardingSummaryArtifact,
+    onboardingManifestArtifact
+  ].map(({ artifactPath }) => artifactPath);
+  if (new Set(onboardingPaths).size !== onboardingPaths.length || onboardingTraceArtifact.artifactPath !== onboardingTracePath || onboardingRun.trace && requireRecord(onboardingRun.trace, "funding release onboarding run trace").sha256 !== onboarding.evidenceSha256) {
+    throw new Error("Funding release onboarding typed run does not bind its legacy trace evidence.");
+  }
+  const onboardingDirectory = path.dirname(onboardingRecipeArtifact.artifactPath);
+  for (const [artifactPath, name] of [
+    [onboardingRecipeArtifact.artifactPath, "recipe.json"],
+    [onboardingResolutionArtifact.artifactPath, "recipe-resolution.json"],
+    [onboardingTraceArtifact.artifactPath, "trace.json"],
+    [onboardingSummaryArtifact.artifactPath, "summary.json"],
+    [onboardingManifestArtifact.artifactPath, "artifact-manifest.json"]
+  ]) {
+    if (artifactPath !== path.join(onboardingDirectory, name)) {
+      throw new Error(`Funding release onboarding run does not bind emitted ${name}.`);
+    }
+  }
+  const onboardingRecipe = onboardingRecipeArtifact.document;
+  const onboardingResolution = onboardingResolutionArtifact.document;
+  const onboardingTrace = onboardingTraceArtifact.document;
+  const onboardingSummary = onboardingSummaryArtifact.document;
+  const onboardingManifest = onboardingManifestArtifact.document;
+  const onboardingTraceMetadata = requireRecord(onboardingTrace.metadata, "funding release onboarding trace metadata");
+  const onboardingRunner = requireRecord(onboardingTraceMetadata.runner, "funding release onboarding trace runner");
+  const onboardingManifestProvenance = requireRecord(onboardingManifest.provenance, "funding release onboarding artifact provenance");
+  if (JSON.stringify(onboardingRunner) !== JSON.stringify(onboardingSummary.runner) || JSON.stringify(onboardingRunner) !== JSON.stringify(onboardingManifestProvenance.runner)) {
+    throw new Error("Funding release onboarding runner provenance differs across typed artifacts.");
+  }
+  const onboardingResolutionRoot = requireRecord(onboardingResolution.root, "funding release onboarding resolution root");
+  if (onboardingResolutionRoot.digest !== `sha256:${normalizeRecipeDigest(digestRecipeDocument(onboardingRecipe))}` || typeof onboardingResolutionRoot.ref !== "string" || onboardingResolutionRoot.ref.length === 0 || JSON.stringify(Object.keys(onboardingResolutionRoot).sort()) !== JSON.stringify(["digest", "ref"]) || !Array.isArray(onboardingResolution.dependencies) || !Array.isArray(onboardingResolution.edges)) {
+    throw new Error("Funding release onboarding resolution does not bind its emitted recipe graph.");
+  }
+  const onboardingDependencies = /* @__PURE__ */ new Map();
+  for (const [index, value] of onboardingResolution.dependencies.entries()) {
+    const dependency = requireRecord(value, `funding release onboarding dependency[${index}]`);
+    if (dependency.ref === onboardingResolutionRoot.ref) {
+      throw new Error("Funding release onboarding dependency ref shadows the root ref.");
+    }
+    const ref = requireIdentifier(dependency.ref, `funding release onboarding dependency[${index}].ref`);
+    const digest = String(dependency.digest ?? "");
+    if (!digest.startsWith("sha256:") || !SHA256.test(digest.slice(7)) || onboardingDependencies.has(ref)) {
+      throw new Error("Funding release onboarding dependency identity is invalid.");
+    }
+    const artifactName = `resolved-recipes/${digest.slice(7)}.recipe.json`;
+    if (dependency.artifact !== artifactName) throw new Error("Funding release onboarding dependency artifact is invalid.");
+    const dependencyPath = await containedRegularPath(
+      releaseRoot,
+      path.relative(releaseRoot, path.resolve(onboardingDirectory, artifactName)),
+      `funding release onboarding dependency ${ref}`
+    );
+    const dependencyDocument = parseObject(await readFile(dependencyPath), `funding release onboarding dependency ${ref}`);
+    if (`sha256:${normalizeRecipeDigest(digestRecipeDocument(dependencyDocument))}` !== digest) {
+      throw new Error(`Funding release onboarding dependency digest is invalid: ${ref}.`);
+    }
+    onboardingDependencies.set(ref, dependencyDocument);
+  }
+  const onboardingArtifacts = Array.isArray(onboardingManifest.artifacts) ? onboardingManifest.artifacts : [];
+  for (const required of [
+    "recipe.json",
+    "recipe-resolution.json",
+    "trace.json",
+    "summary.json",
+    ...onboardingResolution.dependencies.map((value) => isRecord(value) ? value.artifact : void 0)
+  ]) {
+    if (typeof required !== "string" || !onboardingArtifacts.some((value) => isRecord(value) && value.path === required)) {
+      throw new Error(`Funding release onboarding artifact manifest does not bind ${String(required)}.`);
+    }
+  }
+  try {
+    validateResolvedTrace(onboardingRecipe, onboardingResolution, onboardingDependencies, onboardingTrace);
+  } catch (error) {
+    throw new Error(`Funding release onboarding trace is invalid: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!exactTerminalPass(onboardingRecipe, onboardingTrace, onboardingSummary, onboardingManifest)) {
+    throw new Error("Funding release onboarding trace is not exact terminal-pass.");
+  }
+  const onboardingWallet = successfulWalletOutput(
+    onboardingTrace,
+    "funding release onboarding evidence",
+    "ui-import",
+    "extension-visible-onboarding-import"
+  );
+  const onboardingOrigin = extensionOrigin(onboardingWallet.targetUrl, "funding release onboarding wallet");
+  if (onboardingWallet.runtimeSessionId !== onboardingRuntime.runtimeSessionId || onboardingWallet.cdpPort !== onboardingRuntime.cdpPort || onboardingWallet.cdpTargetId !== onboardingRuntime.cdpTargetId || extensionOrigin(onboardingRuntime.targetUrl, "funding release onboarding runtime") !== onboardingOrigin) {
+    throw new Error("Funding release onboarding runtime does not match its visible wallet trace.");
+  }
+  const balanceProof = documents.balanceProof;
+  for (const field of ["registrySha256", "profileId", "domain", "client", "proofLane", "targetId", "subjectDigest"]) {
+    if (balanceProof[field] !== identity[field]) {
+      throw new Error(`Funding balance proof ${field} does not match the request identity.`);
+    }
+  }
+  if (balanceProof.credentialMode !== "environment") {
+    throw new Error("Funding balance proof credential mode is invalid.");
+  }
+  const trustedRequirements = trustedFundingRequirements(identity);
+  if (!Array.isArray(balanceProof.observations) || balanceProof.observations.length !== trustedRequirements.size) {
+    throw new Error("Funding balance proof does not contain the exact trusted requirements.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const requirements = [];
+  let balanceRuntime;
+  for (const [index, value] of balanceProof.observations.entries()) {
+    const observation = requireRecord(value, `funding balance proof observations[${index}]`);
+    const kind = requireIdentifier(observation.kind, `funding balance proof observations[${index}].kind`);
+    const id = requireIdentifier(observation.id, `funding balance proof observations[${index}].id`);
+    const key = `${kind}:${id}`;
+    if (seen.has(key)) throw new Error("Funding balance proof contains a duplicate requirement.");
+    seen.add(key);
+    const trusted = trustedRequirements.get(key);
+    const actualBaseUnits = requireInteger(
+      observation.actualBaseUnits,
+      `funding balance proof observations[${index}].actualBaseUnits`
+    );
+    if (!trusted || BigInt(actualBaseUnits) < BigInt(trusted.minBaseUnits)) {
+      throw new Error(`Funding balance proof requirement ${key} is missing or below its trusted minimum.`);
+    }
+    const evidence = requireRecord(observation.evidence, `funding balance proof observations[${index}].evidence`);
+    for (const field of ["registrySha256", "profileId", "domain", "client", "proofLane", "targetId", "subjectDigest"]) {
+      if (evidence[field] !== identity[field]) throw new Error(`Funding balance evidence ${field} does not match.`);
+    }
+    const evidencePath = await containedRegularPath(
+      releaseRoot,
+      path.relative(releaseRoot, path.resolve(path.dirname(documents.balanceProofPath), String(evidence.path ?? ""))),
+      `funding balance proof observations[${index}].evidence`
+    );
+    const evidenceBytes = await readFile(evidencePath);
+    const evidenceSha256 = sha256(evidenceBytes);
+    if (evidence.sha256 !== evidenceSha256) throw new Error("Funding balance evidence digest is invalid.");
+    const evidenceDocument = parseObject(evidenceBytes, "funding balance evidence");
+    const containedEvidence = async (field) => {
+      const record = requireRecord(evidenceDocument[field], `funding balance evidence ${field}`);
+      const artifactPath = await containedRegularPath(
+        releaseRoot,
+        path.relative(releaseRoot, path.resolve(path.dirname(evidencePath), String(record.path ?? ""))),
+        `funding balance evidence ${field}`
+      );
+      const bytes = await readFile(artifactPath);
+      if (record.sha256 !== sha256(bytes)) throw new Error(`Funding balance evidence ${field} digest is invalid.`);
+      return {
+        document: parseObject(bytes, `funding balance evidence ${field}`),
+        artifactPath,
+        path: String(record.path),
+        sha256: String(record.sha256)
+      };
+    };
+    const recipeArtifact = await containedEvidence("recipe");
+    const resolutionArtifact = await containedEvidence("recipeResolution");
+    const traceArtifact = await containedEvidence("trace");
+    const summaryArtifact = await containedEvidence("summary");
+    const manifestArtifact = await containedEvidence("artifactManifest");
+    const recipe = recipeArtifact.document;
+    const resolution = resolutionArtifact.document;
+    const trace = traceArtifact.document;
+    const summary = summaryArtifact.document;
+    const artifactManifest = manifestArtifact.document;
+    const recipeDigest = `sha256:${normalizeRecipeDigest(digestRecipeDocument(recipe))}`;
+    const resolutionRoot = requireRecord(resolution.root, "funding balance evidence recipe resolution root");
+    if (resolutionRoot.digest !== recipeDigest || typeof resolutionRoot.ref !== "string" || resolutionRoot.ref.length === 0 || JSON.stringify(Object.keys(resolutionRoot).sort()) !== JSON.stringify(["digest", "ref"])) {
+      throw new Error("Funding balance evidence recipe resolution does not bind the emitted root recipe.");
+    }
+    if (!Array.isArray(resolution.dependencies) || !Array.isArray(resolution.edges)) {
+      throw new Error("Funding balance evidence recipe resolution graph is invalid.");
+    }
+    const resolvedRecipes = /* @__PURE__ */ new Map();
+    for (const [dependencyIndex, value2] of resolution.dependencies.entries()) {
+      const dependency = requireRecord(value2, `funding balance evidence dependency[${dependencyIndex}]`);
+      if (dependency.ref === resolutionRoot.ref) {
+        throw new Error("Funding balance evidence recipe dependency ref shadows the root ref.");
+      }
+      const ref = requireIdentifier(dependency.ref, `funding balance evidence dependency[${dependencyIndex}].ref`);
+      const digest = String(dependency.digest ?? "");
+      if (!digest.startsWith("sha256:") || !SHA256.test(digest.slice("sha256:".length)) || resolvedRecipes.has(ref)) {
+        throw new Error("Funding balance evidence recipe dependency identity is invalid.");
+      }
+      const expectedArtifact = `resolved-recipes/${digest.slice("sha256:".length)}.recipe.json`;
+      if (dependency.artifact !== expectedArtifact) {
+        throw new Error("Funding balance evidence recipe dependency artifact is invalid.");
+      }
+      const dependencyPath = await containedRegularPath(
+        releaseRoot,
+        path.relative(releaseRoot, path.resolve(path.dirname(recipeArtifact.artifactPath), expectedArtifact)),
+        `funding balance evidence dependency ${ref}`
+      );
+      const dependencyDocument = parseObject(await readFile(dependencyPath), `funding balance evidence dependency ${ref}`);
+      if (`sha256:${normalizeRecipeDigest(digestRecipeDocument(dependencyDocument))}` !== digest) {
+        throw new Error(`Funding balance evidence recipe dependency digest is invalid: ${ref}.`);
+      }
+      resolvedRecipes.set(ref, dependencyDocument);
+    }
+    const manifestArtifacts = Array.isArray(artifactManifest.artifacts) ? artifactManifest.artifacts : [];
+    for (const bound of [recipeArtifact, resolutionArtifact, traceArtifact, summaryArtifact]) {
+      const manifestPath = path.relative(path.dirname(manifestArtifact.artifactPath), bound.artifactPath).split(path.sep).join("/");
+      if (!manifestArtifacts.some((value2) => isRecord(value2) && value2.path === manifestPath)) {
+        throw new Error(`Funding balance artifact manifest does not bind ${manifestPath}.`);
+      }
+    }
+    for (const value2 of resolution.dependencies) {
+      const dependency = requireRecord(value2, "funding balance evidence dependency");
+      if (!manifestArtifacts.some((artifactValue) => isRecord(artifactValue) && artifactValue.path === dependency.artifact)) {
+        throw new Error(`Funding balance artifact manifest does not bind ${String(dependency.artifact)}.`);
+      }
+    }
+    const emittedNodes = validateResolvedTrace(recipe, resolution, resolvedRecipes, trace);
+    const wallet = successfulWalletOutput(
+      trace,
+      "funding balance evidence trace",
+      "ui-visible-session",
+      "extension-visible-wallet-session"
+    );
+    const runtimeSessionId = requireIdentifier(
+      evidenceDocument.runtimeSessionId,
+      "funding balance evidence runtimeSessionId"
+    );
+    if (evidenceDocument.selectedIdentitySha256 !== onboardingWallet.selectedIdentitySha256 || wallet.selectedIdentitySha256 !== onboardingWallet.selectedIdentitySha256 || wallet.runtimeSessionId !== runtimeSessionId || wallet.cdpPort !== onboardingWallet.cdpPort || extensionOrigin(wallet.targetUrl, "funding balance wallet") !== onboardingOrigin) {
+      throw new Error("Funding balance evidence wallet or runtime is not anchored to release onboarding.");
+    }
+    const currentRuntime = {
+      selectedIdentitySha256: String(wallet.selectedIdentitySha256),
+      runtimeSessionId,
+      cdpPort: Number(wallet.cdpPort),
+      cdpTargetId: String(wallet.cdpTargetId),
+      extensionOrigin: extensionOrigin(wallet.targetUrl, "funding balance wallet")
+    };
+    if (balanceRuntime && JSON.stringify(balanceRuntime) !== JSON.stringify(currentRuntime)) {
+      throw new Error("Funding balance evidence requirements do not share one wallet runtime identity.");
+    }
+    balanceRuntime = currentRuntime;
+    const visibleState = requireRecord(evidenceDocument.visibleState, "funding balance evidence visibleState");
+    if (visibleState.perpsAvailableMarginBaseUnits !== actualBaseUnits || visibleBalanceBaseUnits(trace, emittedNodes) !== actualBaseUnits) {
+      throw new Error("Funding balance actual value does not match its visible trace.");
+    }
+    if (!exactTerminalPass(recipe, trace, summary, artifactManifest)) {
+      throw new Error("Funding balance evidence trace is not exact terminal-pass.");
+    }
+    requirements.push({ kind, id, minBaseUnits: trusted.minBaseUnits, actualBaseUnits, evidenceSha256 });
+  }
+  if (!balanceRuntime) throw new Error("Funding balance proof has no runtime-bound requirement evidence.");
+  return {
+    requirements,
+    runtime: balanceRuntime,
+    releaseTreeSha256: String(artifact.treeSha256)
+  };
+}
+function releaseRuntimeValidator(projectRoot) {
+  return async (requireLive, cdpPort) => {
+    const { extensionRuntimeReusable } = await import("./commands/launch/extension.js");
+    const { releaseArtifactState, runtimeDistCheck } = await import("./adapters/extension/runtime-decision.js");
+    const artifact = releaseArtifactState(projectRoot);
+    if (artifact.status !== "valid" || runtimeDistCheck(projectRoot, artifact).status !== "fresh" || !artifact.sha256 || !artifact.treeSha256) {
+      throw new Error("Runner-owned current release artifact is invalid or stale.");
+    }
+    if (requireLive) {
+      const configuredPort = Number(process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT);
+      if (configuredPort !== cdpPort || !await extensionRuntimeReusable(projectRoot, artifact)) {
+        throw new Error("Runner-owned current release runtime does not own the funded CDP session.");
+      }
+    }
+    return { artifactSha256: artifact.sha256, treeSha256: artifact.treeSha256 };
+  };
+}
+function trustedFundingRequirements(identity) {
+  const registry = TRUSTED_FUNDING_REGISTRIES[identity.registrySha256];
+  const profile = registry?.[identity.profileId];
+  const domain = profile?.[identity.domain];
+  if (!domain) throw new Error("Funding requirements are absent from the runner-trusted registry.");
+  return domain.requirements;
+}
+async function containedRegularPath(root, relative, label) {
+  if (typeof relative !== "string" || !relative || path.isAbsolute(relative)) {
+    throw new Error(`${label} must be a contained relative path.`);
+  }
+  const resolved = path.resolve(root, relative);
+  if (!resolved.startsWith(`${root}${path.sep}`)) throw new Error(`${label} escapes the release root.`);
+  const info = await lstat(resolved);
+  if (!info.isFile() || info.isSymbolicLink() || await realpath(resolved) !== resolved || info.size <= 0 || info.size > MAX_DOCUMENT_BYTES) {
+    throw new Error(`${label} must be a regular bounded non-symlink file.`);
+  }
+  return resolved;
+}
+function successfulWalletOutput(trace, label, method, proofPath) {
+  const entries = Array.isArray(trace.entries) ? trace.entries : [];
+  const wallets = entries.filter((entry) => isRecord(entry) && entry.action === "metamask.wallet.import" && entry.ok === true && isRecord(entry.output));
+  if (wallets.length !== 1) throw new Error(`${label} must contain one successful visible wallet proof.`);
+  const output = wallets[0].output;
+  if (output.action !== "metamask.wallet.import" || output.method !== method || output.credentialSource !== "environment" || output.credentialSourceName !== "MM_RELEASE_SELECTED_WALLET_SRP" || output.proofPath !== proofPath || output.redacted !== true || output.selectedAddressMatched !== true || typeof output.selectedIdentitySha256 !== "string" || !SHA256.test(output.selectedIdentitySha256) || typeof output.runtimeSessionId !== "string" || !IDENTIFIER.test(output.runtimeSessionId) || !Number.isSafeInteger(output.cdpPort) || typeof output.cdpTargetId !== "string" || !IDENTIFIER.test(output.cdpTargetId)) {
+    throw new Error(`${label} visible wallet proof is invalid.`);
+  }
+  return output;
+}
+function extensionOrigin(value, label) {
+  try {
+    const parsed = new URL(String(value));
+    const origin = `${parsed.protocol}//${parsed.hostname}`;
+    if (!ORIGIN.test(origin)) throw new Error("invalid origin");
+    return origin;
+  } catch {
+    throw new Error(`${label} Extension origin is invalid.`);
+  }
+}
+function visibleBalanceBaseUnits(trace, emittedNodes) {
+  const entries = Array.isArray(trace.entries) ? trace.entries : [];
+  const matches = entries.filter((entry) => isRecord(entry) && entry.action === "metamask.perps.read_visible_state" && entry.ok === true && isRecord(entry.output) && entry.output.action === entry.action && entry.output.surface === "home" && entry.output.source === "visible-ui" && isRecord(entry.output.balance) && entry.output.balance.visible === true && isRecord(emittedNodes.get(String(entry.nodeId))) && emittedNodes.get(String(entry.nodeId))?.surface === "home");
+  const matchEntry = matches.at(-1);
+  if (!matchEntry) throw new Error("Funding balance evidence requires a visible Perps Home balance observation.");
+  const label = String(matchEntry.output.balance.label ?? "");
+  const match = /(?:^|\s)\$([0-9]+(?:\.[0-9]{1,2})?)(?:\s|$)/u.exec(label);
+  if (!match) throw new Error("Funding balance evidence visible amount is invalid.");
+  const [whole, fraction = ""] = match[1].split(".");
+  return `${BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, "0"))}`;
+}
+function workflowGraph(recipe, label) {
+  const workflow = requireRecord(recipe.workflow, `${label} workflow`);
+  const nodes = requireRecord(workflow.nodes, `${label} workflow nodes`);
+  const entry = requireIdentifier(workflow.entry, `${label} workflow entry`);
+  if (!isRecord(nodes[entry])) throw new Error(`${label} workflow entry is absent.`);
+  const reachable = /* @__PURE__ */ new Set();
+  const pending = [entry];
+  while (pending.length > 0) {
+    const nodeId = pending.pop();
+    if (reachable.has(nodeId)) continue;
+    reachable.add(nodeId);
+    const node = requireRecord(nodes[nodeId], `${label} node ${nodeId}`);
+    requireIdentifier(node.action, `${label} node ${nodeId} action`);
+    const cases = isRecord(node.cases) ? Object.values(node.cases) : [];
+    for (const successor of [node.next, node.default, ...cases]) {
+      if (successor === void 0) continue;
+      if (typeof successor !== "string" || !isRecord(nodes[successor])) {
+        throw new Error(`${label} node ${nodeId} has an invalid successor.`);
+      }
+      if (!reachable.has(successor)) pending.push(successor);
+    }
+  }
+  return { entry, nodes, reachable };
+}
+function validateResolvedTrace(rootRecipe, resolution, dependencies, trace) {
+  const resolutionRoot = requireRecord(resolution.root, "funding balance evidence resolution root");
+  const rootRef = String(resolutionRoot.ref ?? "");
+  if (!rootRef || !Array.isArray(resolution.edges)) {
+    throw new Error("Funding balance evidence recipe resolution graph is invalid.");
+  }
+  if (dependencies.has(rootRef)) {
+    throw new Error("Funding balance evidence recipe dependency ref shadows the root ref.");
+  }
+  const documents = new Map([[rootRef, rootRecipe], ...dependencies]);
+  const expectedEdges = /* @__PURE__ */ new Set();
+  for (const [source, document] of documents) {
+    const graph = workflowGraph(document, `funding balance evidence recipe ${source}`);
+    for (const nodeId of graph.reachable) {
+      const node = requireRecord(graph.nodes[nodeId], `funding balance evidence recipe node ${nodeId}`);
+      if (node.action !== "call") continue;
+      const ref = requireIdentifier(node.ref, `funding balance evidence call ${nodeId} ref`);
+      if (!dependencies.has(ref)) throw new Error(`Funding balance evidence recipe references unresolved dependency ${ref}.`);
+      expectedEdges.add(`${source}\0${ref}`);
+    }
+  }
+  const actualEdges = /* @__PURE__ */ new Set();
+  for (const value of resolution.edges) {
+    const edge = requireRecord(value, "funding balance evidence recipe resolution edge");
+    if (JSON.stringify(Object.keys(edge).sort()) !== JSON.stringify(["from", "to"])) {
+      throw new Error("Funding balance evidence recipe resolution edge fields are invalid.");
+    }
+    const from = String(edge.from ?? "");
+    const to = String(edge.to ?? "");
+    const key = `${from}\0${to}`;
+    if (!documents.has(from) || !dependencies.has(to) || actualEdges.has(key)) {
+      throw new Error("Funding balance evidence recipe resolution edge is invalid.");
+    }
+    actualEdges.add(key);
+  }
+  if (JSON.stringify([...actualEdges].sort()) !== JSON.stringify([...expectedEdges].sort())) {
+    throw new Error("Funding balance evidence recipe resolution edges do not match the emitted call graph.");
+  }
+  const reachedDocuments = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visitDocument = (ref) => {
+    if (visiting.has(ref)) throw new Error("Funding balance evidence recipe call graph contains a cycle.");
+    if (reachedDocuments.has(ref)) return;
+    visiting.add(ref);
+    reachedDocuments.add(ref);
+    for (const key of expectedEdges) {
+      const [from, to] = key.split("\0");
+      if (from === ref) visitDocument(to);
+    }
+    visiting.delete(ref);
+  };
+  visitDocument(rootRef);
+  if (reachedDocuments.size !== documents.size) {
+    throw new Error("Funding balance evidence recipe resolution contains unreachable dependencies.");
+  }
+  const expectedNodes = /* @__PURE__ */ new Map();
+  const transitions = /* @__PURE__ */ new Map();
+  const addTransition = (from, to) => {
+    const successors = transitions.get(from) ?? /* @__PURE__ */ new Set();
+    successors.add(to);
+    transitions.set(from, successors);
+  };
+  const expand = (ref, prefix, stack) => {
+    if (stack.includes(ref)) throw new Error("Funding balance evidence recipe call graph contains a cycle.");
+    const document = documents.get(ref);
+    if (!document) throw new Error(`Funding balance evidence recipe dependency is absent: ${ref}.`);
+    const graph = workflowGraph(document, `funding balance evidence recipe ${ref}`);
+    const nested = /* @__PURE__ */ new Map();
+    for (const nodeId of graph.reachable) {
+      const node = requireRecord(graph.nodes[nodeId], `funding balance evidence recipe node ${nodeId}`);
+      const traceNodeId = `${prefix}${nodeId}`;
+      if (!NODE_ID.test(traceNodeId) || expectedNodes.has(traceNodeId)) {
+        throw new Error("Funding balance evidence recipe expands invalid or duplicate trace node IDs.");
+      }
+      const action = String(node.action);
+      if (!FUNDING_BALANCE_READ_ONLY_ACTIONS.has(action)) {
+        throw new Error(`Funding balance evidence graph contains non-read-only action ${action}.`);
+      }
+      expectedNodes.set(traceNodeId, node);
+      if (node.action === "call") {
+        nested.set(nodeId, expand(String(node.ref), `${traceNodeId}/`, [...stack, ref]));
+      }
+    }
+    const entryFor = (nodeId) => nested.get(nodeId)?.entry ?? `${prefix}${nodeId}`;
+    const terminals = /* @__PURE__ */ new Set();
+    for (const nodeId of graph.reachable) {
+      const node = requireRecord(graph.nodes[nodeId], `funding balance evidence recipe node ${nodeId}`);
+      const traceNodeId = `${prefix}${nodeId}`;
+      const called = nested.get(nodeId);
+      if (called) for (const terminal2 of called.terminals) addTransition(terminal2, traceNodeId);
+      const cases = isRecord(node.cases) ? Object.values(node.cases) : [];
+      const successors = [node.next, node.default, ...cases].filter((value) => typeof value === "string");
+      if (successors.length === 0) {
+        if (node.action !== "end") throw new Error(`Funding balance evidence recipe node ${traceNodeId} has no terminal successor.`);
+        terminals.add(traceNodeId);
+      } else {
+        for (const successor of successors) addTransition(traceNodeId, entryFor(successor));
+      }
+    }
+    return { entry: entryFor(graph.entry), terminals };
+  };
+  const expanded = expand(rootRef, "", []);
+  const entries = Array.isArray(trace.entries) ? trace.entries : [];
+  if (entries.length === 0 || !isRecord(entries[0]) || entries[0].nodeId !== expanded.entry) {
+    throw new Error("Funding balance evidence trace does not start at the emitted root entry.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, value] of entries.entries()) {
+    const entry = requireRecord(value, `funding balance evidence trace entries[${index}]`);
+    const nodeId = String(entry.nodeId ?? "");
+    if (entry.ok !== true || seen.has(nodeId) || expectedNodes.get(nodeId)?.action !== entry.action) {
+      throw new Error("Funding balance evidence trace entries do not match unique successful emitted nodes and actions.");
+    }
+    seen.add(nodeId);
+    if (index > 0) {
+      const previous = requireRecord(entries[index - 1], `funding balance evidence trace entries[${index - 1}]`);
+      if (!transitions.get(String(previous.nodeId))?.has(nodeId)) {
+        throw new Error("Funding balance evidence trace execution order does not match the emitted recipe graph.");
+      }
+    }
+  }
+  const terminal = requireRecord(entries.at(-1), "funding balance evidence trace terminal");
+  const rootGraph = workflowGraph(rootRecipe, "funding balance evidence root recipe");
+  const rootNode = isRecord(rootGraph.nodes[String(terminal.nodeId)]) ? rootGraph.nodes[String(terminal.nodeId)] : void 0;
+  if (!expanded.terminals.has(String(terminal.nodeId)) || rootNode?.action !== "end" || rootNode.status !== "pass" || terminal.action !== "end" || terminal.status !== "pass") {
+    throw new Error("Funding balance evidence trace lacks an exact reachable root PASS terminal.");
+  }
+  return expectedNodes;
+}
+function reachableRootPassEnds(recipe) {
+  if (!isRecord(recipe.workflow)) return /* @__PURE__ */ new Set();
+  const nodes = isRecord(recipe.workflow.nodes) ? recipe.workflow.nodes : void 0;
+  const entry = recipe.workflow.entry;
+  if (!nodes || typeof entry !== "string" || !isRecord(nodes[entry])) return /* @__PURE__ */ new Set();
+  const reachable = /* @__PURE__ */ new Set();
+  const passEnds = /* @__PURE__ */ new Set();
+  const pending = [entry];
+  while (pending.length > 0) {
+    const nodeId = pending.pop();
+    if (reachable.has(nodeId)) continue;
+    reachable.add(nodeId);
+    const node = nodes[nodeId];
+    if (!isRecord(node)) continue;
+    if (node.action === "end" && node.status === "pass") passEnds.add(nodeId);
+    const cases = isRecord(node.cases) ? Object.values(node.cases) : [];
+    for (const successor of [node.next, node.default, ...cases]) {
+      if (typeof successor === "string" && isRecord(nodes[successor]) && !reachable.has(successor)) pending.push(successor);
+    }
+  }
+  return passEnds;
+}
+function exactTerminalPass(recipe, trace, summary, artifactManifest) {
+  if (!Array.isArray(trace.entries) || trace.entries.length === 0) return false;
+  const terminal = trace.entries.at(-1);
+  return isRecord(terminal) && terminal.action === "end" && terminal.ok === true && terminal.status === "pass" && typeof terminal.nodeId === "string" && IDENTIFIER.test(terminal.nodeId) && !terminal.nodeId.includes("/") && reachableRootPassEnds(recipe).has(terminal.nodeId) && summary.status === "pass" && summary.failed === 0 && summary.total === trace.entries.length && summary.passed === trace.entries.length && artifactManifest.runStatus === "pass";
+}
+function parsePreflightRequirements(value) {
+  if (!Array.isArray(value)) throw new Error("Funding preflight requirements must be an array.");
+  return value.map((entry, index) => {
+    const record = requireRecord(entry, `funding preflight requirements[${index}]`);
+    return {
+      kind: requireIdentifier(record.kind, `funding preflight requirements[${index}].kind`),
+      id: requireIdentifier(record.id, `funding preflight requirements[${index}].id`),
+      minBaseUnits: requireInteger(record.minBaseUnits, `funding preflight requirements[${index}].minBaseUnits`),
+      actualBaseUnits: requireInteger(record.actualBaseUnits, `funding preflight requirements[${index}].actualBaseUnits`),
+      evidenceSha256: requireIdentifier(
+        record.evidenceSha256,
+        `funding preflight requirements[${index}].evidenceSha256`,
+        true
+      )
+    };
+  });
+}
+function validateTrustedFundingRegistry(identity, operations, budgets) {
+  const registry = TRUSTED_FUNDING_REGISTRIES[identity.registrySha256];
+  const profile = registry?.[identity.profileId];
+  const domain = profile?.[identity.domain];
+  if (!domain || !domain.clients.has(identity.client)) {
+    throw new Error("Funding identity is not present in the runner-trusted funding registry.");
+  }
+  const suppliedBudgets = new Map(budgets.map((budget) => [
+    `${budget.operation}:${budget.unit}`,
+    budget
+  ]));
+  const requested = /* @__PURE__ */ new Map();
+  for (const operation of operations) {
+    const key = `${operation.operation}:${operation.unit}`;
+    const amountBaseUnits = BigInt(operation.amountBaseUnits);
+    const aggregate = requested.get(key) ?? {
+      operation: operation.operation,
+      count: 0,
+      amountBaseUnits: 0n,
+      maxAmountBaseUnits: 0n
+    };
+    aggregate.count += operation.count;
+    aggregate.amountBaseUnits += amountBaseUnits * BigInt(operation.count);
+    if (amountBaseUnits > aggregate.maxAmountBaseUnits) aggregate.maxAmountBaseUnits = amountBaseUnits;
+    requested.set(key, aggregate);
+  }
+  for (const [key, aggregate] of requested) {
+    const trusted = domain.budgets.get(key);
+    const supplied = suppliedBudgets.get(key);
+    if (!trusted || !supplied || BigInt(supplied.maxBaseUnits) > BigInt(trusted.maxBaseUnits) || supplied.maxCount > trusted.maxCount || aggregate.maxAmountBaseUnits > BigInt(trusted.maxBaseUnits) || aggregate.count > trusted.maxCount || aggregate.amountBaseUnits > BigInt(trusted.maxBaseUnits) * BigInt(trusted.maxCount)) {
+      throw new Error(`Funding operation ${aggregate.operation} is not bounded by the runner-trusted funding registry.`);
+    }
+  }
+}
+function parseOperations(value, label) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 32) {
+    throw new Error(`${label} must contain 1-32 entries.`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((entry, index) => {
+    const record = requireRecord(entry, `${label}[${index}]`);
+    const amountBaseUnits = requireInteger(record.amountBaseUnits, `${label}[${index}].amountBaseUnits`);
+    const count = requireCount(record.count, `${label}[${index}].count`);
+    const operation = requireIdentifier(record.operation, `${label}[${index}].operation`);
+    const unit = requireIdentifier(record.unit, `${label}[${index}].unit`);
+    const key = `${operation}:${unit}`;
+    if (seen.has(key)) throw new Error(`${label} contains a duplicate operation/unit key.`);
+    seen.add(key);
+    return {
+      operation,
+      unit,
+      amountBaseUnits,
+      count
+    };
+  });
+}
+function parseBudgets(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 64) {
+    throw new Error("Funding preflight budgets must contain 1-64 entries.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((entry, index) => {
+    const record = requireRecord(entry, `funding preflight budgets[${index}]`);
+    const operation = requireIdentifier(record.operation, `funding preflight budgets[${index}].operation`);
+    const unit = requireIdentifier(record.unit, `funding preflight budgets[${index}].unit`);
+    const key = `${operation}:${unit}`;
+    if (seen.has(key)) throw new Error("Funding preflight budgets contain a duplicate operation/unit key.");
+    seen.add(key);
+    return {
+      operation,
+      unit,
+      maxBaseUnits: requireInteger(record.maxBaseUnits, `funding preflight budgets[${index}].maxBaseUnits`),
+      maxCount: requireCount(record.maxCount, `funding preflight budgets[${index}].maxCount`)
+    };
+  });
+}
+function requireRecord(value, label) {
+  if (!isRecord(value)) throw new Error(`${label} must be an object.`);
+  return value;
+}
+function requireIdentifier(value, label, digest = false) {
+  if (typeof value !== "string" || !(digest ? SHA256 : IDENTIFIER).test(value)) {
+    throw new Error(`${label} is invalid.`);
+  }
+  return value;
+}
+function requireInteger(value, label) {
+  if (typeof value !== "string" || !INTEGER.test(value)) throw new Error(`${label} must be a bounded integer string.`);
+  return value;
+}
+function requireCount(value, label) {
+  if (!Number.isInteger(value) || Number(value) < 1 || Number(value) > 1e3) {
+    throw new Error(`${label} must be an integer from 1 through 1000.`);
+  }
+  return Number(value);
+}
+function normalizeRecipeDigest(value) {
+  const digest = value.startsWith("sha256:") ? value.slice("sha256:".length) : value;
+  if (!SHA256.test(digest)) throw new Error("Recipe digest is invalid.");
+  return digest;
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function canonical(value) {
+  return `${JSON.stringify(value)}
+`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+export {
+  authorizeTrustedMutationPlan,
+  loadTrustedMutationBase,
+  selectedIdentityFromWalletImport,
+  serializeTrustedMutationContext,
+  trustedMutationForAction
+};