#!/usr/bin/env node
// Real SDK Borsh instructions and Ed25519 transactions against an isolated
// loopback validator. No third-party JS dependencies, wallet or external RPC.
// Genesis config is an explicit test fixture, NOT canonical bootstrap proof.
import assert from "node:assert/strict";
import { createHash, createPrivateKey, createPublicKey, randomBytes, sign } from "node:crypto";
import { execFileSync, spawn } from "node:child_process";
import { readFileSync, writeFileSync, mkdtempSync, mkdirSync, readdirSync, rmSync, existsSync } from "node:fs";
import { tmpdir } from "node:os";
import { dirname, resolve, join } from "node:path";
import { fileURLToPath } from "node:url";
import { encodeNativeLocalInstruction, nativeLocalIdlSha256,
  nativeLocalInstructionNames, disabledSolanaDeployment } from "../../sdk/dist/solana/index.js";
import { canonicalManifest, canonicalManifestDigest } from "../../sdk/dist/manifest/index.js";

const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
const repo = resolve(root, "../..");
const endpoint = "http://127.0.0.1:18899";
const program = "Ae7kRyqQ6zr4oseGbyRxcY19nYswkRNQAHe2UZ2Dmkc7";
const system = "11111111111111111111111111111111";
const out = resolve(process.env.VAULTFIRE_NATIVE_V2_SBF_DIR ?? "");
assert(process.env.VAULTFIRE_NATIVE_V2_SBF_DIR, "fresh SBF directory required");
assert(process.env.VAULTFIRE_LOCAL_REHEARSAL_LOG_DIR, "new evidence directory required");
const logDir = resolve(process.env.VAULTFIRE_LOCAL_REHEARSAL_LOG_DIR);
assert(!existsSync(logDir) || readdirSync(logDir).length === 0, "never overwrite existing evidence");
const longTermAdmissionOnly = process.argv.includes("--long-term-admission-witness");
const compositionalWitness = process.argv.includes("--compositional-witness");
const livenessWitness = process.argv.includes("--liveness-witness") || compositionalWitness;
execFileSync("python3", [join(root, "scripts/native-v2-source-binding.py"), "check", out]);
const binding = JSON.parse(readFileSync(join(out, "native-v2-source-binding.json")));
const idlBytes = readFileSync(join(root, "idl/vaultfire_v3_successor.native-v2.json"));
assert.equal(nativeLocalIdlSha256, createHash("sha256").update(idlBytes).digest("hex"));
const idl = JSON.parse(idlBytes);
mkdirSync(logDir, { recursive: true });
const discoveredV2Instructions = [
  "create_flourishing_program_v2", "submit_flourishing_observation_v2",
  "advance_flourishing_period_v2", "finalize_flourishing_observation_v2",
  "claim_flourishing_reward_v2", "recover_flourishing_program_v2",
];
for (const name of discoveredV2Instructions) {
  assert(nativeLocalInstructionNames.includes(name), `SDK discovery missing ${name}`);
  assert(idl.instructions.some(ix => ix.name === name), `actual IDL missing ${name}`);
}
const accountV2 = idl.accounts.find(a => a.name.endsWith("::FlourishingProgramV2"));
assert(accountV2);
const accountTypeV2 = idl.types.find(a => a.name === accountV2.name);
assert(accountTypeV2.type.fields.some(field => field.name === "cap_used"));
assert(accountTypeV2.type.fields.some(field => field.name === "comparison_gap"));
const deploymentDiscovery = disabledSolanaDeployment();
assert.equal(deploymentDiscovery.enabled, false, "local journey never activates production deployment");
const discovery = {
  manifestId: canonicalManifest.manifestId, manifestSchemaVersion: canonicalManifest.schemaVersion,
  canonicalManifestDigest, actualIdlMetadata: idl.metadata,
  actualIdlSha256: nativeLocalIdlSha256, programId: program,
  newAccount: { name: accountV2.name, discriminatorHex: Buffer.from(accountV2.discriminator).toString("hex"),
    allocatedBytes: 520, dataBytes: 512, signedEconomicsVersion: "NoRedistribution.v2" },
  discoveredV2Instructions, productionDeployment: deploymentDiscovery,
  selectedEnvironment: "local-test-validator", signingAndSubmission: "local-genesis-fixture-only",
};
writeFileSync(join(logDir, "discovery.json"), JSON.stringify(discovery, null, 2) + "\n");
const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
function b58(bytes) {
  let n = BigInt(`0x${Buffer.from(bytes).toString("hex") || "0"}`), encoded = "";
  while (n > 0n) { encoded = alphabet[Number(n % 58n)] + encoded; n /= 58n; }
  let zeros = 0; while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
  return "1".repeat(zeros) + encoded;
}
function un58(text) {
  let n = 0n;
  for (const char of text) { const i = alphabet.indexOf(char); assert(i >= 0); n = n * 58n + BigInt(i); }
  let hex = n.toString(16); if (hex.length % 2) hex = `0${hex}`;
  let zeros = 0; while (text[zeros] === "1") zeros++;
  const result = Buffer.concat([Buffer.alloc(zeros), n ? Buffer.from(hex, "hex") : Buffer.alloc(0)]);
  assert.equal(result.length, 32); return result;
}
function keypair(seed = randomBytes(32)) {
  const privateKey = createPrivateKey({ key: Buffer.concat([Buffer.from("302e020100300506032b657004220420", "hex"), seed]), format: "der", type: "pkcs8" });
  const publicBytes = createPublicKey(privateKey).export({ format: "der", type: "spki" }).subarray(-32);
  return { publicKey: b58(publicBytes), privateKey, secret: [...seed, ...publicBytes] };
}
function short(n) {
  assert(Number.isSafeInteger(n) && n >= 0 && n <= 65_535);
  const bytes = []; do { const byte = n & 127; n >>>= 7; bytes.push(byte | (n ? 128 : 0)); } while (n);
  return Buffer.from(bytes);
}
function u64(n) { const bytes = Buffer.alloc(8); bytes.writeBigUInt64LE(BigInt(n)); return bytes; }
function discriminator(name) { return createHash("sha256").update(`global:${name}`).digest().subarray(0, 8); }
let rpcId = 0;
async function rpc(method, params = []) {
  const response = await fetch(endpoint, {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: ++rpcId, method, params }),
    signal: AbortSignal.timeout(15_000),
  });
  assert(response.ok, `local RPC HTTP ${response.status}`);
  const body = await response.json();
  if (body.error) throw new Error(`${method}: ${JSON.stringify(body.error)}`);
  return body.result;
}
const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
const payer = keypair(), human = keypair(), ai = keypair(), sponsor = keypair();
const [partyA, partyB] = [human, ai].sort((a, b) => Buffer.compare(un58(a.publicKey), un58(b.publicKey)));
const attestors = [keypair(), keypair(), keypair()].sort((a, b) => Buffer.compare(un58(a.publicKey), un58(b.publicKey)));
const signatures = [], rejected = [], transportRetries = [];
function pda(...seeds) {
  const answer = execFileSync("solana", ["find-program-derived-address", program, ...seeds, "--output", "json"], { encoding: "utf8" });
  return JSON.parse(answer).address;
}
const pub = value => `pubkey:${value}`;
const num = value => `hex:${u64(value).toString("hex")}`;
const vaultFor = resource => pda("string:vault", pub(resource));
const creditFor = (vault, recipient) => pda("string:credit", pub(vault), pub(recipient));
const config = pda("string:v3-config-v2");
function sdk(name, accounts, args = {}) {
  const ix = encodeNativeLocalInstruction({ environment: "local-sbf-harness", instruction: name, accounts, args });
  return {
    programId: ix.programId, data: Buffer.from(ix.dataHex.slice(2), "hex"),
    accounts: ix.accounts.map(a => ({ publicKey: a.publicKey, signer: a.isSigner, writable: a.isWritable })),
  };
}
async function send(label, ix, additional = [], expected = true) {
  const keys = new Map();
  const add = (publicKey, signer, writable) => {
    const old = keys.get(publicKey);
    if (old) { old.signer ||= signer; old.writable ||= writable; }
    else keys.set(publicKey, { publicKey, signer, writable });
  };
  add(payer.publicKey, true, true);
  for (const account of ix.accounts) add(account.publicKey, account.signer, account.writable);
  add(ix.programId, false, false);
  const rank = a => a.publicKey === payer.publicKey ? 0 : a.signer ? (a.writable ? 1 : 2) : a.writable ? 3 : 4;
  const ordered = [...keys.values()].sort((a, b) => rank(a) - rank(b));
  const signed = ordered.filter(a => a.signer);
  const index = key => { const n = ordered.findIndex(a => a.publicKey === key); assert(n >= 0 && n < 256); return n; };
  const blockhash = (await rpc("getLatestBlockhash", [{ commitment: "confirmed" }])).value.blockhash;
  const message = Buffer.concat([
    Buffer.from([signed.length, signed.filter(a => !a.writable).length, ordered.filter(a => !a.signer && !a.writable).length]),
    short(ordered.length), ...ordered.map(a => un58(a.publicKey)), un58(blockhash),
    short(1), Buffer.from([index(ix.programId)]), short(ix.accounts.length),
    Buffer.from(ix.accounts.map(a => index(a.publicKey))), short(ix.data.length), ix.data,
  ]);
  const available = new Map([payer, ...additional].map(key => [key.publicKey, key]));
  const sigs = signed.map(a => { const key = available.get(a.publicKey); assert(key, `missing signer for ${label}`); return sign(null, message, key.privateKey); });
  const wire = Buffer.concat([short(sigs.length), ...sigs, message]);
  assert(wire.length <= 1_232, `${label}: transaction exceeds wire size`);
  const signature = await rpc("sendTransaction", [wire.toString("base64"), { encoding: "base64", skipPreflight: true }]);
  if (compositionalWitness && label === "composition_signed_escrow_withdrawal") {
    // Explicit ACK-loss boundary: do not consume the first submission's status
    // or receipt. Retry the IDENTICAL signed packet, never rebuild/re-sign the
    // financial instruction with a new blockhash or nonce.
    const retrySignature = await rpc("sendTransaction", [
      wire.toString("base64"), { encoding: "base64", skipPreflight: true, maxRetries: 0 },
    ]);
    assert.equal(retrySignature, signature, "same packet must retain same transaction identity");
    transportRetries.push({
      label, interruptionModel: "client discards first submission acknowledgement before status/receipt",
      actualProcessCrash: false, originalSignature: signature, retrySignature,
      identicalSignedPacketSha256: createHash("sha256").update(wire).digest("hex"),
      rebuiltOrResigned: false, wireBytes: wire.length,
    });
  }
  let status;
  for (let i = 0; i < 100; i++) {
    status = (await rpc("getSignatureStatuses", [[signature]])).value[0];
    if (status && (status.err || ["confirmed", "finalized"].includes(status.confirmationStatus))) break;
    await delay(100);
  }
  assert(status && (status.err || ["confirmed", "finalized"].includes(status.confirmationStatus)), `${label}: confirmation timeout`);
  let transaction;
  for (let i = 0; i < 20; i++) {
    transaction = await rpc("getTransaction", [signature, { encoding: "json", commitment: "confirmed", maxSupportedTransactionVersion: 0 }]);
    if (transaction) break;
    await delay(100);
  }
  assert(transaction?.meta, `${label}: actual transaction metadata required`);
  assert.deepEqual(status.err, transaction.meta.err, `${label}: status and transaction disagree`);
  assert.equal(transaction.meta.err === null, expected,
    `${label}: ${JSON.stringify(transaction.meta.err)}\n${transaction.meta.logMessages.join("\n")}`);
  const retried = transportRetries.find(row => row.originalSignature === signature);
  if (retried) {
    const settledAgain = await rpc("getTransaction", [signature, {
      encoding: "json", commitment: "confirmed", maxSupportedTransactionVersion: 0,
    }]);
    assert.deepEqual(settledAgain.meta, transaction.meta, "retry resolves the same parsed receipt, not a second execution");
    retried.resolvedSlot = transaction.slot;
    retried.singleReceiptFeeLamports = transaction.meta.fee;
    retried.parsedReceiptIdentical = true;
  }
  (expected ? signatures : rejected).push({
    label, signature, error: status.err, slot: transaction.slot,
    computeUnitsConsumed: transaction.meta.computeUnitsConsumed,
    fee: transaction.meta.fee, logMessages: transaction.meta.logMessages,
    wireBytes: wire.length, staticAccounts: ordered.length, signerCount: signed.length,
  });
  console.log(JSON.stringify({ label, signature, success: status.err === null }));
}
async function account(key) {
  const result = await rpc("getAccountInfo", [key, { encoding: "base64", commitment: "confirmed" }]);
  assert(result.value, `missing local account ${key}`); return result.value;
}
function decode(name, value) {
  assert.equal(value.owner, program, "only current-program owned accounts may be decoded");
  const data = Buffer.from(value.data[0], "base64"), type = idl.types.find(t => t.name.split("::").at(-1) === name);
  const spec = idl.accounts.find(a => a.name === type.name);
  assert(data.subarray(0, 8).equals(Buffer.from(spec.discriminator)));
  let offset = 8;
  function read(t) {
    if (t === "bytes") {
      const count = read("u32");
      assert(count <= 10_000 && offset + count <= data.length);
      const bytes = data.subarray(offset, offset + count); offset += count;
      return `0x${bytes.toString("hex")}`;
    }
    if (t === "pubkey") { const key = b58(data.subarray(offset, offset + 32)); offset += 32; return key; }
    if (t === "bool") { const n = data[offset++]; assert(n < 2); return n === 1; }
    if (typeof t === "string" && /^[ui](8|16|32|64)$/.test(t)) {
      const bits = Number(t.slice(1)), bytes = bits / 8;
      assert(offset + bytes <= data.length);
      const n = bits === 64 ? (t[0] === "i" ? data.readBigInt64LE(offset) : data.readBigUInt64LE(offset))
        : t[0] === "i" ? data.readIntLE(offset, bytes) : data.readUIntLE(offset, bytes);
      offset += bytes; return n;
    }
    if (t.array) return Array.from({ length: t.array[1] }, () => read(t.array[0]));
    if (t.vec) { const count = read("u32"); assert(count < 10_000); return Array.from({ length: count }, () => read(t.vec)); }
    const definition = t.defined ? idl.types.find(d => d.name === t.defined.name).type : t;
    if (definition.kind === "enum") { const variant = definition.variants[read("u8")]; assert(variant && !variant.fields); return variant.name; }
    assert.equal(definition.kind, "struct");
    return Object.fromEntries(definition.fields.map(field => [field.name, read(field.type)]));
  }
  return read(type.type);
}
async function wallTime() {
  const clock = await account("SysvarC1ock11111111111111111111111111111111");
  return Number(Buffer.from(clock.data[0], "base64").readBigInt64LE(32));
}
async function waitUntil(at) {
  for (let i = 0; i < 600; i++) { if (await wallTime() >= at) return; await delay(100); }
  throw new Error("local clock deadline not reached");
}

const work = mkdtempSync(join(tmpdir(), "vaultfire-flourishing-local-"));
let validator;
const validatorLog = [];
const beganAt = new Date().toISOString();
try {
  const fixture = JSON.parse(execFileSync(join(process.env.CARGO_TARGET_DIR, "debug/examples/flourishing_local_fixture"), [payer.publicKey], {
    encoding: "utf8", env: { ...process.env, VAULTFIRE_LOCAL_FIXTURE: "disposable-genesis-only" },
  }));
  const statePath = join(work, "config.json");
  writeFileSync(statePath, JSON.stringify({
    pubkey: config, account: {
      lamports: 10_000_000, data: [Buffer.from(fixture).toString("base64"), "base64"],
      owner: program, executable: false, rentEpoch: 0, space: fixture.length,
    },
  }));
  validator = spawn("solana-test-validator", [
    "--reset", "--ledger", join(work, "ledger"), "--rpc-port", "18899",
    "--faucet-port", "18900", "--bind-address", "127.0.0.1", "--gossip-host", "127.0.0.1",
    "--dynamic-port-range", "19000-19100", "--mint", payer.publicKey,
    "--bpf-program", program, join(out, "vaultfire_v3_successor.so"),
    "--account", config, statePath, "--quiet",
  ], { stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, RAYON_NUM_THREADS: "2", SOLANA_RAYON_THREADS: "2" } });
  validator.stdout.on("data", bytes => validatorLog.push(bytes));
  validator.stderr.on("data", bytes => validatorLog.push(bytes));
  for (let i = 0; i < 90; i++) {
    assert(validator.exitCode === null, `local validator exited: ${Buffer.concat(validatorLog).toString()}`);
    try { await rpc("getVersion"); break; } catch { await delay(500); }
  }
  await rpc("getVersion");
  for (const recipient of [human, ai, sponsor]) {
    await send("fund_fixture_participant", {
      programId: system,
      accounts: [{ publicKey: payer.publicKey, signer: true, writable: true }, { publicKey: recipient.publicKey, signer: false, writable: true }],
      data: Buffer.concat([Buffer.from([2, 0, 0, 0]), u64(50_000_000)]),
    });
  }
  const now = await wallTime(), start = now + (compositionalWitness ? 30 : 15),
    end = now + (livenessWitness ? 120 : 50), hardStop = now + (livenessWitness ? 160 : 90);
  const positions = [];
  const compositionAccounts = [];
  if (compositionalWitness) {
    const identity = pda("string:identity", pub(human.publicKey));
    const consent = pda("string:consent", pub(human.publicKey), pub(ai.publicKey), num(601));
    const evidence = pda("string:evidence", pub(ai.publicKey), num(602));
    const task = pda("string:task", pub(human.publicKey), pub(ai.publicKey), num(603));
    const milestone = pda("string:milestone", pub(task), "hex:00");
    const escrowVault = vaultFor(milestone), escrowCredit = creditFor(escrowVault, ai.publicKey);
    const evidenceDigest = `0x${"a7".repeat(32)}`;
    await send("composition_register_identity", sdk("register_identity", {
      config, identity, subject: human.publicKey, system_program: system,
    }, { args: { erc8004_id: `0x${"a1".repeat(32)}`, metadata_digest: `0x${"a2".repeat(32)}`,
      metadata_uri: "0x697066733a2f2f6c6f63616c2d66697874757265" } }), [human]);
    await send("composition_grant_explicit_consent", sdk("grant_consent", {
      config, consent, subject: human.publicKey, system_program: system,
    }, { args: { grantee: ai.publicKey, scope_digest: `0x${"a3".repeat(32)}`,
      data_digest: `0x${"a4".repeat(32)}`, not_before: BigInt(now),
      expires_at: BigInt(now + 3600), nonce: 601n } }), [human]);
    await send("composition_record_signer_bound_evidence_receipt", sdk("record_evidence", {
      config, evidence, issuer: ai.publicKey, system_program: system,
    }, { args: { subject: human.publicKey, schema: `0x${"a5".repeat(32)}`,
      evidence_digest: evidenceDigest, source_digest: `0x${"a6".repeat(32)}`,
      observed_at: BigInt(now), expires_at: BigInt(now + 3600), nonce: 602n } }), [ai]);
    await send("composition_create_bilateral_escrow_task", sdk("create_task", {
      config, task, client: human.publicKey, provider: ai.publicKey, system_program: system,
    }, { args: { terms_digest: evidenceDigest, arbitrator: payer.publicKey,
      milestone_count: 1, final_deadline: BigInt(now + 100),
      dispute_grace_seconds: 3600n, nonce: 603n } }), [human, ai]);
    await send("composition_fund_isolated_escrow_milestone", sdk("fund_milestone", {
      config, task, milestone, vault: escrowVault, client: human.publicKey,
      provider: ai.publicKey, system_program: system,
    }, { args: { index: 0, amount: 500_000n, acceptance_digest: evidenceDigest,
      deadline: BigInt(now + 90) } }), [human, ai]);
    await send("composition_settle_bilateral_milestone", sdk("settle_milestone", {
      config, task, milestone, vault: escrowVault, credit: escrowCredit,
      client: human.publicKey, provider: ai.publicKey, system_program: system,
    }), [human, ai]);
    await send("composition_signed_escrow_withdrawal", sdk("withdraw_credit", {
      config, vault: escrowVault, credit: escrowCredit, recipient: ai.publicKey,
    }), [ai]);
    await send("composition_revoke_consent", sdk("revoke_consent", {
      consent, subject: human.publicKey,
    }), [human]);
    assert.equal(decode("IdentityRecord", await account(identity)).subject, human.publicKey);
    assert(decode("ConsentRecord", await account(consent)).revoked_at > 0n);
    const receipt = decode("EvidenceRecord", await account(evidence));
    assert.equal(receipt.subject, human.publicKey);
    assert.equal(receipt.issuer, ai.publicKey);
    assert.deepEqual(receipt.evidence_digest, Array(32).fill(0xa7));
    assert.equal(receipt.informational_only, true, "typed evidence is not cryptographic qualification");
    const pulled = decode("PullCredit", await account(escrowCredit));
    assert.equal(pulled.amount, 500_000n);
    assert.equal(pulled.withdrawn, 500_000n);
    compositionAccounts.push(identity, consent, evidence, task, milestone, escrowVault, escrowCredit);
  }
  for (const [i, family] of ["Partnership", "Accountability"].entries()) {
    const terms = `0x${(i ? "42" : "41").repeat(32)}`, scope = Buffer.alloc(32, 0x55);
    let registry = null;
    if (i) {
      registry = pda("string:objective-issuer", pub(payer.publicKey), `hex:${scope.toString("hex")}`);
      await send("configure_fixture_objective_source", {
        programId: program,
        accounts: [
          { publicKey: config, signer: false, writable: false },
          { publicKey: registry, signer: false, writable: true },
          { publicKey: payer.publicKey, signer: true, writable: true },
          { publicKey: system, signer: false, writable: false },
        ],
        data: Buffer.concat([discriminator("configure_objective_issuer"), un58(payer.publicKey), Buffer.alloc(32, 0x56), scope, Buffer.alloc(32, 0x57)]),
      });
    }
    const bond = pda("string:bond-v2", pub(partyA.publicKey), pub(partyB.publicKey), num(i + 1));
    const bondVault = vaultFor(bond), rewardProgram = pda("string:flourish-v2", pub(sponsor.publicKey), num(i + 1)), vault = vaultFor(rewardProgram);
    await send(`create_${family}`, sdk("create_bond_v2", {
      config, bond, vault: bondVault, registry, party_a: partyA.publicKey, party_b: partyB.publicKey, system_program: system,
    }, { args: {
      kind: family, beneficiary: partyB.publicKey, terms_digest: terms,
      objective_fact_digest: `0x${(i ? "58" : "00").repeat(32)}`, objective_registry: registry ?? system,
      principal_a: 1_000_000n, principal_b: 250_000n, remedy_reserve: i ? 250_000n : 0n,
      remedy_cap: i ? 200_000n : 0n, objective_rule: i ? "ExactFactDigestV1" : "None",
      source_policy_digest: `0x${(i ? "59" : "00").repeat(32)}`,
      funding_deadline: BigInt(now + 20), activation_deadline: BigInt(now + 25),
      maturity_deadline: BigInt(now + (i ? 85 : 55)), nonce: BigInt(i + 1),
    } }), [partyA, partyB]);
    for (const [party, amount] of [[partyA, 1_000_000n], [partyB, 250_000n]]) {
      await send(`fund_${family}`, sdk("fund_bond_v2", {
        config, bond, vault: bondVault, funder: party.publicKey, system_program: system,
      }, { amount }), [party]);
    }
    if (i) await send("fund_additional_remedy", sdk("fund_bond_remedy_v2", {
      config, bond, vault: bondVault, funder: partyA.publicKey, system_program: system,
    }, { amount: 250_000n }), [partyA]);
    await send(`activate_${family}`, sdk("activate_bond_v2", { config, bond, party_a: partyA.publicKey, party_b: partyB.publicKey }), [partyA, partyB]);
    const untouchedBond = await account(bond), untouchedVault = await account(bondVault);
    const create = sdk("create_flourishing_program_v2", {
      config, bond, flourishing_program: rewardProgram, vault,
      sponsor: sponsor.publicKey, party_a: partyA.publicKey, party_b: partyB.publicKey, system_program: system,
    }, { args: {
      terms_digest: terms, human: human.publicKey, ai: ai.publicKey,
      partnership_fund: i ? system : sponsor.publicKey,
      attestors: attestors.map(a => a.publicKey), reward_basis: 1_000_000n, cap: 8_000_000n,
      active_start: BigInt(start),
      active_end: BigInt(longTermAdmissionOnly ? start + 3_650 * 86_400 : end + (i ? 30 : 0)),
      wall_recovery_deadline: BigInt(longTermAdmissionOnly ? start + 3_650 * 86_400 + 30 : hardStop),
      period_seconds: livenessWitness ? 10n : 2n,
      correction_seconds: livenessWitness ? 5n : 15n,
      max_age_seconds: livenessWitness ? 6n : 30n, nonce: BigInt(i + 1),
    } });
    if (!i) {
      for (const [label, recipient] of [['human',human.publicKey],['ai',ai.publicKey]]) {
        const aliased = { ...create, data: Buffer.from(create.data) };
        // Anchor discriminator + exact terms + human + AI, then the fund key.
        un58(recipient).copy(aliased.data, 8 + 32 + 32 + 32);
        await send(`reject_fund_alias_${label}`, aliased, [sponsor,partyA,partyB], false);
      }
    }
    const missingConsent = { ...create, accounts: create.accounts.map(a => a.publicKey === partyB.publicKey ? { ...a, signer: false } : a) };
    await send(`missing_${family}_participant_consent`, missingConsent, [sponsor, partyA], false);
    await send(`create_${family}_sponsor_allocation`, create, [sponsor, partyA, partyB]);
    const claim = beneficiary => sdk("claim_flourishing_reward_v2", {
      config, flourishing_program: rewardProgram, vault, credit: creditFor(vault, beneficiary),
      beneficiary, caller: payer.publicKey, system_program: system,
    });
    await send(`no_unfinalized_${family}_reward`, claim(human.publicKey), [], false);
    positions.push({ family, rewardProgram, vault, bond, bondVault, untouchedBond, untouchedVault, terms, claim, i });
  }
  if (longTermAdmissionOnly) {
    const states = [];
    for (const p of positions) {
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.equal(state.active_end - state.active_start, 3_650n * 86_400n);
      assert(state.active_end > BigInt(now + 366 * 86_400));
      assert.deepEqual(await account(p.bond), p.untouchedBond);
      assert.deepEqual(await account(p.bondVault), p.untouchedVault);
      states.push({ family: p.family, activeStart: String(state.active_start),
        activeEnd: String(state.active_end), wallRecoveryDeadline: String(state.wall_recovery_deadline),
        cap: String(state.cap), bondMaturityEarlierThanRewardEnd: true });
    }
    writeFileSync(join(logDir, "result.json"), JSON.stringify({
      schema: "vaultfire.native-flourishing.longterm-admission.v2",
      evidenceClass: "real-local-validator-admission-with-seeded-active-config",
      sourceBinding: binding, idlSha256: nativeLocalIdlSha256,
      beganAt, endedAt: new Date().toISOString(), signatures, rejected, states,
      protectedPrincipalAndRemedyUntouched: true, externalRpcRequests: 0,
      canonicalBootstrapOrGovernanceAcceptance: false, publicDeployment: false,
      limitation: "Actual ten-year allocation admission only; no elapsed-ten-year lifecycle or independent acceptance inferred.",
    }, null, 2) + "\n");
    console.log("NATIVE_FLOURISHING_LONGTERM_ADMISSION_PASS");
  } else if (livenessWitness) {
    // Actual validator wall clock; no warp, Clock sysvar replacement, or
    // host-only quote computation supplies these program transitions.
    await waitUntil(start + 16);
    for (const p of positions) {
      await send(`skip_missing_${p.family}_period0`, sdk("advance_flourishing_period_v2",
        { config, flourishing_program: p.rewardProgram }, { expected_period: 0n }));
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.equal(state.next_period, 1n);
      assert.equal(state.comparison_gap, true);
      await send(`reject_cursor_replay_${p.family}`, sdk("advance_flourishing_period_v2",
        { config, flourishing_program: p.rewardProgram }, { expected_period: 0n }), [], false);
    }
    const observe = (p, period, score) => sdk("submit_flourishing_observation_v2", {
      config, flourishing_program: p.rewardProgram,
      attestor_a: attestors[0].publicKey, attestor_b: attestors[1].publicKey,
      human_approval: human.publicKey,
    }, { args: {
      terms_digest: p.terms, period, revision: 1, evidence_digest: `0x${"71".repeat(32)}`,
      scores: p.i ? Array(6).fill(score) : [10_000, 10_000, 10_000, 10_000, 0, 0],
      tasks_mastered: 0n, human_confirmations: p.i ? 0 : 2,
    } });
    await waitUntil(start + 20);
    for (const p of positions) {
      await send(`admit_fresh_${p.family}_period1`, observe(p, 1n, 10_000), [...attestors.slice(0, 2), human]);
    }
    await waitUntil(start + 27); // period-end20 + max-age6 is irrevocably past.
    for (const p of positions) {
      await send(`cannot_discard_pending_${p.family}`, sdk("advance_flourishing_period_v2",
        { config, flourishing_program: p.rewardProgram }, { expected_period: 1n }), [], false);
      await send(`settle_stale_admitted_${p.family}_period1`, sdk("finalize_flourishing_observation_v2",
        { config, flourishing_program: p.rewardProgram }));
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.equal(state.authorized, p.i ? 1_500_000n : 720_000n);
      assert.equal(state.cap_used, p.i ? 3_000_000n : 1_200_000n);
      assert.deepEqual(state.allowances, [state.authorized, 0n, 0n]);
      assert.equal(state.comparison_gap, false);
      if (p.i) assert.equal(state.previous_global_score, 10_000);
    }
    await waitUntil(start + 40);
    for (const p of positions) {
      await send(`skip_only_empty_${p.family}_period2`, sdk("advance_flourishing_period_v2",
        { config, flourishing_program: p.rewardProgram }, { expected_period: 2n }));
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.equal(state.next_period, 3n);
      if (p.i) assert.equal(state.previous_global_score, 10_000, "no laundering decline through a gap");
    }
    // The first bond matures at now+55 (=start+40). Its independent prefunded
    // reward allocation keeps operating after actual principal recovery.
    await waitUntil(start + 41);
    const first = positions[0];
    await send("recover_underlying_partnership_bond_principal", sdk("recover_bond_v2", {
      config, bond: first.bond, registry: null, attestation: null, vault: first.bondVault,
      credit_a: creditFor(first.bondVault, partyA.publicKey),
      credit_b: creditFor(first.bondVault, partyB.publicKey),
      caller: payer.publicKey, system_program: system,
    }));
    first.untouchedBond = await account(first.bond);
    first.untouchedVault = await account(first.bondVault);
    assert.equal(decode("BondRecordV2", first.untouchedBond).principals_refunded, true);
    for (const p of positions) {
      await send(`new_observation_after_gap_${p.family}_period3`, observe(p, 3n, 7_000), [...attestors.slice(0, 2), human]);
    }
    await waitUntil(start + 47);
    const states = [], accountResources = [];
    for (const key of compositionAccounts) {
      const value = await account(key), bytes = Buffer.from(value.data[0], "base64");
      accountResources.push({ address: key, owner: value.owner, allocatedBytes: bytes.length,
        lamports: value.lamports,
        rentExemptMinimumLamports: await rpc("getMinimumBalanceForRentExemption", [bytes.length]),
        dataSha256: createHash("sha256").update(bytes).digest("hex"), dataBase64: value.data[0] });
    }
    for (const p of positions) {
      await send(`settle_after_gap_${p.family}_period3`, sdk("finalize_flourishing_observation_v2",
        { config, flourishing_program: p.rewardProgram }));
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.equal(state.authorized, p.i ? 2_050_000n : 1_440_000n);
      assert.equal(state.cap_used, p.i ? 4_100_000n : 2_400_000n);
      assert.deepEqual(state.allowances, [state.authorized, 0n, 0n]);
      if (p.i) assert.equal(state.previous_global_score, 7_000);
      assert.deepEqual(await account(p.bond), p.untouchedBond);
      assert.deepEqual(await account(p.bondVault), p.untouchedVault);
      states.push({ family: p.family, periodCursor: String(state.next_period),
        earnedAuthorized: String(state.authorized), evaluatedCapUsed: String(state.cap_used),
        allowances: state.allowances.map(String), previousGlobalScore: state.previous_global_score });
      for (const key of [p.bond, p.bondVault, p.rewardProgram, p.vault]) {
        const value = await account(key), bytes = Buffer.from(value.data[0], "base64");
        accountResources.push({ address: key, owner: value.owner, allocatedBytes: bytes.length,
          lamports: value.lamports,
          rentExemptMinimumLamports: await rpc("getMinimumBalanceForRentExemption", [bytes.length]),
          dataSha256: createHash("sha256").update(bytes).digest("hex"), dataBase64: value.data[0] });
      }
    }
    // Complete the earned-rights lifecycle against this same current ELF.
    // Finalized allowance is a reserved obligation, not sponsor-owned expiry dust.
    const rewardExits = [];
    const sponsorRecovery = p => sdk("recover_flourishing_program_v2", {
      config, flourishing_program: p.rewardProgram, vault: p.vault,
      credit: creditFor(p.vault, sponsor.publicKey), sponsor: sponsor.publicKey,
      caller: payer.publicKey, system_program: system,
    });
    const firstEarned = decode("FlourishingProgramV2", await account(first.rewardProgram)).authorized;
    await send("issued_partnership_reward_after_principal_recovery", first.claim(human.publicKey));
    assert.equal(decode("PullCredit", await account(creditFor(first.vault, human.publicKey))).amount, firstEarned);
    await send("no_double_issue_of_earned_partnership_reward", first.claim(human.publicKey), [], false);
    await send("no_reward_for_unearned_ai_gap_share", first.claim(ai.publicKey), [], false);
    await send("no_early_sponsor_recovery_after_principal_exit", sponsorRecovery(first), [], false);
    await waitUntil(end + 1);
    await send("recover_only_unearned_partnership_sponsor_funding", sponsorRecovery(first));
    await send("no_repeated_partnership_sponsor_recovery", sponsorRecovery(first), [], false);
    await send("pause_after_first_funding_return", {
      programId: program,
      accounts: [{ publicKey: config, signer: false, writable: true },
        { publicKey: payer.publicKey, signer: true, writable: false }],
      data: Buffer.concat([discriminator("set_pause"), Buffer.from([1])]),
    });
    const principalWithdrawals = [];
    for (const [recipient, principal] of [[partyA, 1_000_000n], [partyB, 250_000n]]) {
      const before = BigInt((await account(recipient.publicKey)).lamports);
      await send("paused_protected_principal_pull_withdrawal", sdk("withdraw_credit", {
        config, vault: first.bondVault, credit: creditFor(first.bondVault, recipient.publicKey),
        recipient: recipient.publicKey,
      }), [recipient]);
      const received = BigInt((await account(recipient.publicKey)).lamports) - before;
      assert.equal(received, principal);
      principalWithdrawals.push({ recipient: recipient.publicKey, receivedLamports: String(received) });
    }
    first.untouchedVault = await account(first.bondVault);
    const second = positions[1];
    const unissuedBeforeReturn = decode("FlourishingProgramV2", await account(second.rewardProgram));
    assert.deepEqual(unissuedBeforeReturn.allowances, [2_050_000n, 0n, 0n]);
    await send("paused_sponsor_cannot_return_early", sponsorRecovery(second), [], false);
    await waitUntil(hardStop + 1);
    await send("paused_hard_stop_returns_only_unearned_accountability_funding", sponsorRecovery(second));
    const afterReturn = decode("FlourishingProgramV2", await account(second.rewardProgram));
    assert.deepEqual(afterReturn.allowances, unissuedBeforeReturn.allowances);
    assert.equal(afterReturn.authorized, unissuedBeforeReturn.authorized);
    await send("paused_post_expiry_unissued_accountability_reward_claim", second.claim(human.publicKey));
    await send("no_repeated_accountability_sponsor_recovery", sponsorRecovery(second), [], false);
    for (const p of positions) {
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.equal(state.sponsor_refunded, true);
      assert.equal(state.claimed, state.authorized);
      assert.deepEqual(state.allowances, [0n, 0n, 0n]);
      for (const recipient of [human, sponsor]) {
        const credit = decode("PullCredit", await account(creditFor(p.vault, recipient.publicKey)));
        const due = credit.amount - credit.withdrawn;
        const before = BigInt((await account(recipient.publicKey)).lamports);
        await send(`paused_final_${p.family}_reward_or_sponsor_withdrawal`, sdk("withdraw_credit", {
          config, vault: p.vault, credit: creditFor(p.vault, recipient.publicKey),
          recipient: recipient.publicKey,
        }), [recipient]);
        assert.equal(BigInt((await account(recipient.publicKey)).lamports) - before, due);
      }
      const vault = decode("IsolatedVault", await account(p.vault));
      assert.equal(vault.total_deposited, 8_000_000n);
      assert.equal(vault.total_credited, 8_000_000n);
      assert.equal(vault.total_withdrawn, 8_000_000n);
      assert.deepEqual(await account(p.bond), p.untouchedBond);
      assert.deepEqual(await account(p.bondVault), p.untouchedVault);
      rewardExits.push({ family: p.family, earnedClaimedLamports: String(state.claimed),
        unearnedSponsorReturnLamports: String(8_000_000n - state.authorized),
        capUsedLamports: String(state.cap_used), totalRewardFundingWithdrawnLamports: String(vault.total_withdrawn) });
    }
    assert.equal(decode("ProtocolConfigV2", await account(config)).total_liability_lamports, 1_500_000n);
    writeFileSync(join(logDir, "result.json"), JSON.stringify({
      schema: "vaultfire.native-flourishing.liveness.v2",
      evidenceClass: "real-local-validator-transactions-with-seeded-active-config",
      sourceBinding: binding, idlSha256: nativeLocalIdlSha256,
      beganAt, endedAt: new Date().toISOString(), discovery,
      signatures, rejected, states, accountResources, transportRetries,
      rewardExits, principalWithdrawals,
      earnedAllowanceSurvivesSponsorReturnAndPause: true,
      rewardFundingConservedAfterWithdrawal: true,
      underlyingPrincipalActuallyWithdrawnWhilePaused: true,
      remainingProtectedAccountabilityPrincipalAndRemedyLamports: "1500000",
      actualClockNoWarp: true, syntheticObservations: true,
      independentAllocationAfterUnderlyingPrincipalRecovery: true,
      grossBudgetNotRecycled: true, suppressedSharesNotRedirected: true,
      compositionalModules: compositionalWitness
        ? ["identity", "consent+revocation", "signer-bound-evidence-receipt", "bilateral-escrow+pull-credit",
          "both-bond-families", "both-flourishing-families", "principal-recovery-independent-allocation"]
        : ["both-bond-families", "both-flourishing-families"],
      compositionUsesSameProgramAndConfig: compositionalWitness,
      interruptionRecovery: compositionalWitness
        ? "actual identical signed packet re-submission after discarded first ACK; one signature/receipt; escrow withdrawn exactly500000; no actual process crash"
        : "cursor/pending replay failures preserve state before successful continuation",
      canonicalBootstrapOrGovernanceAcceptance: false, externalRpcRequests: 0, publicDeployment: false,
    }, null, 2) + "\n");
    console.log("NATIVE_FLOURISHING_V2_LIVENESS_LOCAL_VALIDATOR_PASS");
  } else {
    assert(await wallTime() < start, "setup missed signed start; never silently shift a tested deadline");
    await waitUntil(start + 2);
    for (const p of positions) {
      const submit = (revision, approvals, a = attestors[0].publicKey, b = attestors[1].publicKey) =>
        sdk("submit_flourishing_observation_v2", {
          config, flourishing_program: p.rewardProgram, attestor_a: a, attestor_b: b, human_approval: approvals,
        }, { args: {
          terms_digest: p.terms, period: 0n, revision, evidence_digest: `0x${"61".repeat(32)}`,
          scores: p.i ? Array(6).fill(revision === 1 ? 9_000 : 10_000) : [10_000, 10_000, 10_000, 10_000, 0, 0],
          tasks_mastered: p.i ? 0n : 12n, human_confirmations: p.i ? 0 : 2,
        } });
      await send(`duplicate_${p.family}_quorum_member`, submit(1, human.publicKey, attestors[0].publicKey, attestors[0].publicKey), [attestors[0], human], false);
      await send(`outsider_${p.family}_attestor`, submit(1, human.publicKey, attestors[0].publicKey, payer.publicKey), [attestors[0], human], false);
      // Bypass SDK validation deliberately to exercise the actual fresh ELF.
      const withoutHuman = revision => {
        const ix = submit(revision, human.publicKey);
        ix.accounts = ix.accounts.map(a => a.publicKey === human.publicKey
          ? { publicKey: program, signer: false, writable: false } : a);
        return ix;
      };
      await send(`quorum_only_${p.family}_report`, withoutHuman(1), attestors.slice(0, 2), false);
      await send(`substituted_${p.family}_human`, submit(1, payer.publicKey), attestors.slice(0, 2), false);
      await send(`submit_${p.family}_metrics`, submit(1, human.publicKey), [...attestors.slice(0, 2), human]);
      await send(`quorum_only_${p.family}_correction`, withoutHuman(2), attestors.slice(0, 2), false);
      const substitution = submit(2, human.publicKey);
      substitution.data = Buffer.from(substitution.data);
      substitution.data[8] ^= 1; // Terms, not a mere unavailable-signature fixture.
      await send(`substituted_${p.family}_terms`, substitution, [...attestors.slice(0, 2), human], false);
      await send(`correct_${p.family}_metrics`, submit(2, human.publicKey), [...attestors.slice(0, 2), human]);
      await send(`old_${p.family}_revision`, submit(1, human.publicKey), [...attestors.slice(0, 2), human], false);
      p.finalize = sdk("finalize_flourishing_observation_v2", { config, flourishing_program: p.rewardProgram });
      await send(`premature_${p.family}_finalization`, p.finalize, [], false);
    }
    await waitUntil(start + 18);
    const finalStates = [];
    for (const p of positions) {
      await send(`finalize_${p.family}`, p.finalize);
      await send(`replay_${p.family}_finalization`, p.finalize, [], false);
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      assert.deepEqual(state.allowances, p.i ? [1_500_000n, 1_500_000n, 0n] : [720_000n, 360_000n, 120_000n]);
      await send(`claim_${p.family}_human`, p.claim(human.publicKey));
      const humanCredit = decode("PullCredit", await account(creditFor(p.vault, human.publicKey)));
      assert.equal(humanCredit.amount, p.i ? 1_500_000n : 720_000n, "human credit excludes the separate partnership fund");
      if (!p.i) {
        await send("claim_distinct_partnership_fund", p.claim(sponsor.publicKey));
        const fundCredit = decode("PullCredit", await account(creditFor(p.vault, sponsor.publicKey)));
        assert.equal(fundCredit.amount, 120_000n);
      }
      assert.deepEqual(await account(p.bond), p.untouchedBond, "metrics must not mutate bond custody");
      assert.deepEqual(await account(p.bondVault), p.untouchedVault, "metrics must not debit principal/remedy vault");
      p.recover = sdk("recover_flourishing_program_v2", {
        config, flourishing_program: p.rewardProgram, vault: p.vault,
        credit: creditFor(p.vault, sponsor.publicKey), sponsor: sponsor.publicKey,
        caller: payer.publicKey, system_program: system,
      });
      await send(`early_${p.family}_sponsor_exit`, p.recover, [], false);
    }
    await waitUntil(end + 1);
    const first = positions[0];
    await send("partnership_unused_sponsor_return", first.recover);
    await send("earned_ai_claim_after_sponsor_return", first.claim(ai.publicKey));
    await send("replayed_sponsor_return", first.recover, [], false);
    // Pause the second allocation before its own hard stop. Unlike active time,
    // the hard wall deadline advances and permits return of only unearned funds.
    await send("emergency_pause", {
      programId: program,
      accounts: [{ publicKey: config, signer: false, writable: true }, { publicKey: payer.publicKey, signer: true, writable: false }],
      data: Buffer.concat([discriminator("set_pause"), Buffer.from([1])]),
    });
    const second = positions[1];
    await send("paused_already_earned_claim_remains_live", second.claim(ai.publicKey));
    await send("paused_before_hard_stop_sponsor_return_rejected", second.recover, [], false);
    await waitUntil(hardStop + 1);
    await send("paused_hard_deadline_sponsor_return", second.recover);
    for (const p of positions) {
      const state = decode("FlourishingProgramV2", await account(p.rewardProgram));
      const vault = decode("IsolatedVault", await account(p.vault));
      assert.equal(state.authorized, p.i ? 3_000_000n : 1_200_000n);
      assert.equal(state.sponsor_refunded, true);
      assert.equal(state.cap_used, state.authorized, "no suppressed share in this normal-positive journey");
      assert.equal(state.comparison_gap, false);
      assert.equal(vault.total_deposited, 8_000_000n);
      assert.equal(vault.total_credited, 8_000_000n);
      assert.equal(state.allowances[1], 0n, "earned AI funds moved to signed withdrawable credit");
      for (const recipient of [human, sponsor, ai]) {
        const before = BigInt((await account(recipient.publicKey)).lamports);
        const due = decode("PullCredit", await account(creditFor(p.vault, recipient.publicKey))).amount;
        await send(`withdraw_${p.family}_${recipient.publicKey.slice(0, 6)}`, sdk("withdraw_credit", {
          config, vault: p.vault, credit: creditFor(p.vault, recipient.publicKey), recipient: recipient.publicKey,
        }), [recipient]);
        assert.equal(BigInt((await account(recipient.publicKey)).lamports) - before, due);
      }
      assert.deepEqual(await account(p.bond), p.untouchedBond);
      assert.deepEqual(await account(p.bondVault), p.untouchedVault);
      const finalVault = decode("IsolatedVault", await account(p.vault));
      finalStates.push({
        family: p.family, program: p.rewardProgram,
        authorizedLamports: String(state.authorized), claimedLamports: String(state.claimed),
        sponsorReturnLamports: String(8_000_000n - state.authorized),
        allowancesLamports: state.allowances.map(String),
        vaultDepositedLamports: String(finalVault.total_deposited),
        vaultCreditedLamports: String(finalVault.total_credited),
        vaultWithdrawnLamports: String(finalVault.total_withdrawn),
        protectedBondAccountSha256: createHash("sha256").update(p.untouchedBond.data[0]).digest("hex"),
        protectedVaultAccountSha256: createHash("sha256").update(p.untouchedVault.data[0]).digest("hex"),
      });
    }
    assert.equal(decode("ProtocolConfigV2", await account(config)).total_liability_lamports, 2_750_000n);
    const accountResources = [];
    for (const key of [config, ...positions.flatMap(p => [p.bond, p.bondVault, p.rewardProgram, p.vault])]) {
      const value = await account(key), bytes = Buffer.from(value.data[0], "base64");
      accountResources.push({
        address: key, owner: value.owner, executable: value.executable,
        allocatedBytes: bytes.length, observedLamports: value.lamports,
        rentExemptMinimumLamports: await rpc("getMinimumBalanceForRentExemption", [bytes.length]),
        dataSha256: createHash("sha256").update(bytes).digest("hex"),
        dataBase64: value.data[0],
      });
    }
    writeFileSync(join(logDir, "account-snapshots.json"), JSON.stringify(accountResources, null, 2) + "\n");
    writeFileSync(join(logDir, "result.json"), JSON.stringify({
      schema: "vaultfire.native-flourishing.local-validator.v2",
      evidenceClass: "real-local-validator-transactions-with-seeded-active-config",
      canonicalBootstrapOrGovernanceAcceptance: false, externalRpcRequests: 0,
      sourceBinding: binding, idlSha256: nativeLocalIdlSha256,
      beganAt, endedAt: new Date().toISOString(), finalStates,
      accountResources,
      resourceLimits: { transactionWireBytes: 1232, heapHighWaterMeasured: false, stackHighWaterMeasured: false },
      observations: "synthetic public aggregates, not external-data truth",
      signatures, rejected, protectedPrincipalAndRemedyUntouched: true,
      earnedAllowanceSurvivesSponsorReturnAndPause: true,
      activationAuthorized: false, publicDeployment: false,
    }, null, 2) + "\n");
    console.log("NATIVE_FLOURISHING_LOCAL_VALIDATOR_PASS");
  }
} catch (error) {
  writeFileSync(join(logDir, "failure.json"), JSON.stringify({
    evidenceClass: "failed-local-validator-attempt-not-acceptance",
    error: String(error.stack ?? error), beganAt, endedAt: new Date().toISOString(),
    sourceBinding: binding, idlSha256: nativeLocalIdlSha256, signatures, rejected,
    externalRpcRequests: 0, publicDeployment: false,
  }, null, 2) + "\n");
  throw error;
} finally {
  if (validator) {
    validator.kill("SIGTERM");
    const stop = setTimeout(() => validator.kill("SIGKILL"), 5_000);
    await new Promise(resolve => { if (validator.exitCode !== null) resolve(); else validator.once("exit", resolve); });
    clearTimeout(stop);
  }
  writeFileSync(join(logDir, "validator.log"), Buffer.concat(validatorLog));
  // Disposable private keys and ledger are never delivered or retained.
  rmSync(work, { recursive: true, force: true });
}