import assert from "node:assert/strict";
import { createHash } from "node:crypto";
import { readdirSync, readFileSync } from "node:fs";
import { test } from "node:test";

import { did, load, now } from "../../../atlibs/rust/src/harness.mjs";
import { runModule } from "../../../atlibs/javascript/src/run-module/index.js";
import { loadComposition, rfpPolicyRoutes, runCompose } from "../../../atlibs/javascript/src/compose/index.js";
import { World } from "../../crates/policy/vectors.mjs";
import { T, KEY, HAT7, HAT9, ENDPOINT, EP7, ref, signature, POLICY, host, hex, ENDPOINT9, EP9, offering, isOffering, report, serverRef, uriOf, market } from "./fake-market.mjs";

const { module, run, handle } = await load(new URL("../../target/wasm32-unknown-unknown/release/requester.wasm", import.meta.url));
const ENTRIES = ["bind_key", "associate", "offerings", "request", "bids", "receipt", "guest", "accept", "release", "signal", "shell", "contract", "watch"];
const spec = JSON.parse(readFileSync(new URL("./module.json", import.meta.url), "utf8"));
// The market-dance tests run the requester with no hooks and the policy NSID in its calls: the host's
// call answers it (allow). The policy itself is tested with compositions and the default, below; an
// unrouted hook's null is a deny (fail closed).
const noPolicy = { module, calls: [...spec.calls, POLICY] };


// handle(), with calls: each call as the module planned it (nsid, params, input, proxy, service).
async function drive(entry, input, respond) {
	const calls = [];
	const ran = await handle(entry, input, {
		respond: ({ nsid, params, input, proxy, service, endpoints }) => {
			const call = JSON.parse(JSON.stringify({ nsid, params, input, proxy, service, endpoints }));
			calls.push(call);
			return respond(call);
		},
	});
	return { ...ran, calls };
}
// The handler's output for the start event alone: validation errors, the first calls.
const start = (entry, input) => run(entry, { did, now, state: null, event: { type: "start" }, ...input });

function base58btc(bytes) {
	const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
	let value = BigInt(`0x${Buffer.from(bytes).toString("hex") || "0"}`);
	let out = "";
	while (value > 0n) {
		out = alphabet[Number(value % 58n)] + out;
		value /= 58n;
	}
	for (const byte of bytes) {
		if (byte !== 0) break;
		out = `1${out}`;
	}
	return out;
}

test("module has no imports and exports the ABI", async () => {
	assert.equal(WebAssembly.Module.imports(module).length, 0);
	const names = WebAssembly.Module.exports(module).map((e) => e.name);
	for (const name of ["memory", "alloc", ...ENTRIES]) assert.ok(names.includes(name), name);
});

// Every input the sources read (arg("k"), given("k"), number("k", ..)) is a declared field, typed;
// the read-only actions say so. did and now come from the host, progress is a host callback.
test("module.json declares every input the code reads, typed, and marks the read-only actions", () => {
	const src = new URL("./src/", import.meta.url);
	const code = readdirSync(src).map((f) => readFileSync(new URL(f, src), "utf8")).join("\n");
	const read = new Set([...code.matchAll(/\b(?:arg|given|number)\("([A-Za-z_]+)"/g)].map((m) => m[1]));
	const declared = new Set(spec.actions.flatMap((a) => a.fields.map((f) => f.key)));
	assert.deepEqual([...read].filter((k) => !declared.has(k) && !["did", "now", "progress"].includes(k)), []);
	assert.deepEqual(spec.actions.map((a) => a.entry).sort(), [...ENTRIES].sort());
	for (const f of spec.actions.flatMap((a) => a.fields)) assert.ok(["string", "integer", "number", "boolean", "object", "array"].includes(f.type), f.key);
	assert.deepEqual(spec.actions.filter((a) => a.readOnly).map((a) => a.entry).sort(), ["bids", "guest", "offerings", "receipt", "watch"]);
});

test("bind_key writes the badgeBlueKeys record at the rkey verifiers derive", async () => {
	const { calls, respond } = host();
	const ran = await drive("bind_key", {}, respond);
	const rkey = base58btc(createHash("sha256").update(`${did}:${KEY}`).digest().subarray(0, 24)).slice(0, 32);
	assert.deepEqual(calls[0], { nsid: "com.fedfork.exec.attest", input: { repository: did } });
	assert.deepEqual(calls[1].input, {
		repo: did,
		collection: `${T}.badgeBlueKeys`,
		rkey,
		record: { $type: `${T}.badgeBlueKeys`, keyId: KEY, name: "socialweb.computer requester attestation", challenge: did, service: "market_requester", createdAt: now },
	});
	assert.equal(ran.result.key, KEY);
	assert.equal(ran.result.record.uri, `at://${did}/${T}.badgeBlueKeys/${rkey}`);
	assert.match((await drive("bind_key", {}, () => ({ ok: true, output: { key: "zQ3" } }))).error, /did:key/);
});

test("associate confirms through the peer's service, then records the association", async () => {
	const { calls, respond } = host((call) => (call.nsid.endsWith("associateConfirm") ? { ok: true, output: { ok: true, requesterDid: HAT9 } } : undefined));
	const ran = await drive("associate", { peer: HAT9, role: "bidder" }, respond);
	assert.deepEqual(calls[0], { nsid: `${T}.requester.associateConfirm`, proxy: `${HAT9}#bidder_associate`, input: {} });
	assert.deepEqual(calls[1].input.record, { $type: `${T}.badgeBlueKeys`, keyId: HAT9, name: `bidder-${HAT9.slice(-8)}`, challenge: did, service: "bidder_associate", createdAt: now });
	assert.equal(ran.result.peer, HAT9);
	assert.match(start("associate", { peer: HAT9, role: "admin" }).error, /role/);
	assert.match(start("associate", { peer: "did:plc:x#y" }).error, /peer must be a DID/);
	assert.match((await drive("associate", { peer: HAT9 }, () => ({ ok: false, error: "associateConfirm failed with 401" }))).error, /401/);
});

test("offerings reads each bidder's offering (getRecord at self) through its PDS and keeps its compute endpoints", async () => {
	const offering = (endpoints, appliesTo = [`${T}.compute.vm`], extra = {}) => ({ ok: true, output: { value: { endpoints, appliesTo, ...extra } } });
	const ran = await drive("offerings", { bidders: `${HAT7}, ${HAT9}` }, (call) => (call.params.repo === HAT7 ? offering(EP7) : { ok: false, error: "getRecord failed with 400" }));
	assert.deepEqual(ran.calls[0], { nsid: "com.atproto.repo.getRecord", service: HAT7, params: { repo: HAT7, collection: `${T}.market.offering`, rkey: "self" } });
	assert.deepEqual(ran.result, { offerings: [{ did: HAT7, endpoints: EP7 }], errors: [{ bidder: HAT9, error: "getRecord failed with 400" }] });
	for (const [response, why] of [[offering([]), "no endpoints"], [offering(EP7, undefined, { withdrawnAt: now }), "withdrawn"], [offering(EP7, ["other"]), "no compute"]]) {
		assert.deepEqual((await drive("offerings", { bidders: HAT7 }, () => response)).result.offerings, [], why);
	}
});

test("request creates the vm, a signed rfp, and submits it to each bidder", async () => {
	const { calls, respond } = host((call) => (call.nsid.endsWith("submitRfp") ? (call.service ? { ok: true, output: { ok: true } } : { ok: false, error: "submitRfp failed with 401" }) : undefined));
	const policy = ref("computer.socialweb.temp.policy.ghalite", "p");
	const ran = await drive("request", { role: "ci", user_data: "#cloud-config\n", bidders: [`${ENDPOINT}/`, HAT9], policies: [policy], cpus: 2 }, respond);
	assert.deepEqual(ran.calls.map((c) => c.nsid.split(".").pop()), ["createRecord", "attest", "createRecord", "submitRfp", "submitRfp"]);
	assert.deepEqual(calls[0].input.record, { $type: `${T}.compute.vm`, kind: "vm", role: "ci", disk: "50G", user_data: "#cloud-config\n", cpus: 2, createdAt: now });
	const rfp = { $type: `${T}.market.rfp`, domain: "compute", payload: ref(`${T}.compute.vm`, "r1"), createdAt: now, policies: [policy] };
	assert.deepEqual(calls[1], { nsid: "com.fedfork.exec.attest", input: { repository: did, record: rfp } });
	assert.deepEqual(calls[2].input, { repo: did, collection: `${T}.market.rfp`, record: { ...rfp, signatures: [signature] } });
	const input = { rfpUri: `at://${did}/${T}.market.rfp/r2`, rfpCid: "bafyr2" };
	assert.deepEqual(calls.slice(3), [
		{ nsid: `${T}.market.submitRfp`, service: ENDPOINT, input },
		{ nsid: `${T}.market.submitRfp`, proxy: `${HAT9}#pdr_temp_market`, input },
	]);
	assert.deepEqual(ran.result.submitted, [
		{ bidder: { service: ENDPOINT }, ok: true, output: { ok: true } },
		{ bidder: { proxy: `${HAT9}#pdr_temp_market` }, ok: false, error: "submitRfp failed with 401" },
	]);
	assert.equal(ran.result.rfp.uri, input.rfpUri);
	// a bidder as offerings returns it: its DID and endpoints; the host picks the transport and mints aud did#pdr_temp_market
	const peer = await drive("request", { user_data: "x", bidders: [{ did: HAT7, endpoints: EP7 }] }, host((call) => (call.nsid.endsWith("submitRfp") ? { ok: true, output: { ok: true } } : undefined)).respond);
	assert.deepEqual(peer.calls.at(-1), { nsid: `${T}.market.submitRfp`, service: `${HAT7}#pdr_temp_market`, endpoints: EP7, input: { rfpUri: `at://${did}/${T}.market.rfp/r2`, rfpCid: "bafyr2" } });
	assert.match(start("request", { did, now, user_data: "x", bidders: [{ did: HAT7, endpoints: [] }] }).error, /endpoints/);
});

test("request without bidders stops after the rfp; bad input fails before any call", async () => {
	const ran = await drive("request", { user_data: "x" }, host().respond);
	assert.deepEqual(ran.result.submitted, []);
	assert.equal((await drive("request", { user_data: "x", disk: "10G" }, host().respond)).calls[0].input.record.disk, "10G");
	// the kind is always said, and sizes are what a bidder parses ("4G"): a number is GiB
	const sized = (await drive("request", { user_data: "x", mem: 4, disk: 20, kind: "deno" }, host().respond)).calls[0].input.record;
	assert.deepEqual([sized.kind, sized.mem, sized.disk], ["deno", "4G", "20G"]);
	// expires_at: when the bidder ends the VM (compute.vm expiresAt), a datetime
	assert.equal((await drive("request", { user_data: "x", expires_at: "2026-11-10T22:00:00Z" }, host().respond)).calls[0].input.record.expiresAt, "2026-11-10T22:00:00Z");
	assert.equal((await drive("request", { user_data: "x" }, host().respond)).calls[0].input.record.expiresAt, undefined);
	for (const bad of ["tomorrow", "2026-11-10 22:00:00Z", "2026-11-10T22:00:00", 5]) assert.match(start("request", { did, now, user_data: "x", expires_at: bad }).error, /expires_at must be an RFC 3339 datetime/, String(bad));
	assert.equal(ran.calls.length, 3);
	const base = { did, now, user_data: "x" };
	assert.match(start("request", { ...base, user_data: " " }).error, /user_data/);
	assert.match(start("request", { ...base, bidders: ["http://insecure"] }).error, /bidders/);
	assert.match(start("request", { ...base, bidders: ["https://a/b"] }).error, /https origin/);
	assert.match(start("request", { ...base, bidders: Array(11).fill(HAT7) }).error, /at most 10/);
	assert.match(start("request", { ...base, policies: [{ uri: "x" }] }).error, /strong ref/);
	assert.match(start("request", { ...base, mem: "4 GiB" }).error, /mem must be a size/);
	assert.match(start("request", { ...base, disk: -1 }).error, /disk must be a size/);
	assert.match(start("request", { ...base, cpus: "2" }).error, /cpus must be an integer/);
	assert.match(start("request", { ...base, kind: "container" }).error, /kind must be vm or deno/);
});

test("request refuses an attestation that changed the record", async () => {
	const tampered = host((call) => (call.nsid === "com.fedfork.exec.attest" ? { ok: true, output: { record: { ...call.input.record, domain: "other", signatures: [signature] } } } : undefined));
	assert.match((await drive("request", { user_data: "x" }, tampered.respond)).error, /signatures added/);
	const unsigned = host((call) => (call.nsid === "com.fedfork.exec.attest" ? { ok: true, output: { record: call.input.record } } : undefined));
	assert.match((await drive("request", { user_data: "x" }, unsigned.respond)).error, /signatures added/);
});

test("bids reads each bidder's bid at the key it gives this rfp, or exact bid URIs, picks the first free one", async () => {
	const rfp = { uri: `at://${did}/${T}.market.rfp/r2`, cid: "bafyr2" };
	const key = (bidder) => `bid-${createHash("sha256").update(`${bidder}\0${rfp.uri}#${rfp.cid}`).digest("hex").slice(0, 20)}`;
	const bid = (bidder, rkey, on, payload) => ({ uri: `at://${bidder}/${T}.market.bid/${rkey}`, cid: `bafy${rkey}`, value: { rfp: { uri: on }, payload, submitAccept: ENDPOINT } });
	const free = bid(HAT7, key(HAT7), rfp.uri, { $type: "com.atproto.repo.strongRef", uri: `at://${HAT7}/${T}.market.bids.free/x`, cid: "c" });
	const ran = await drive("bids", { rfp, bidders: [HAT7, HAT9] }, (call) => (call.params.repo === HAT7 ? { ok: true, output: free } : { ok: false, error: "down" }));
	assert.deepEqual(ran.calls.map((c) => [c.nsid, c.service, c.params.rkey]), [["com.atproto.repo.getRecord", HAT7, key(HAT7)], ["com.atproto.repo.getRecord", HAT9, key(HAT9)]]);
	assert.deepEqual(ran.result.bids.map((b) => [b.uri.split("/").pop(), b.free]), [[key(HAT7), true]]);
	assert.equal(ran.result.winner.submitAccept, ENDPOINT);
	assert.deepEqual(ran.result.errors, [{ bidder: HAT9, error: "down" }]);
	const cheapest = await drive("bids", { rfp, bidders: [HAT7, HAT9] }, (call) => ({ ok: true, output: bid(call.params.repo, "b", rfp.uri, { cost: call.params.repo === HAT7 ? 9 : 3 }) }));
	assert.equal(cheapest.result.winner.bidder, HAT9);
	const stale = await drive("bids", { rfp, bidders: [HAT7] }, () => ({ ok: true, output: bid(HAT7, "o", `at://${did}/${T}.market.rfp/old`, { cost: 1 }) }));
	assert.deepEqual(stale.result.bids, [], "a bid on another rfp is not one");
	assert.match(start("bids", { rfp }).error, /bidders or bids is required/);
	assert.match(start("bids", { rfp: rfp.uri, bidders: [HAT7] }).error, /strong ref/);
	assert.match(start("bids", { rfp, bids: [`at://${HAT7}/other.nsid/x`] }).error, /market.bid at:\/\/ URIs/);
	const exact = await drive("bids", { rfp, bids: [free.uri] }, () => ({ ok: true, output: free }));
	assert.deepEqual(exact.calls, [{ nsid: "com.atproto.repo.getRecord", service: HAT7, params: { repo: HAT7, collection: `${T}.market.bid`, rkey: key(HAT7) } }]);
	assert.equal(exact.result.winner.uri, free.uri);
});

test("accept signs the accept, submits it, and returns the receipt", async () => {
	const rfp = ref(`${T}.market.rfp`, "r2");
	const bid = { uri: `at://${HAT7}/${T}.market.bid/b`, cid: "bafyb" };
	const receipt = { id: "rc", uri: `at://${HAT7}/${T}.market.receipt/rc`, cid: "bafyrc", submitEvent: `${HAT7}#pdr_temp_compute_event` };
	const { calls, respond } = host((call) => (call.nsid.endsWith("submitAccept") ? { ok: true, output: receipt } : undefined));
	const ran = await drive("accept", { rfp: JSON.stringify(rfp), bid, submitAccept: ENDPOINT }, respond);
	const accept = { $type: `${T}.market.accept`, rfp, bid: { $type: "com.atproto.repo.strongRef", ...bid }, createdAt: now };
	assert.deepEqual(calls[0].input.record, accept);
	assert.deepEqual(calls[1].input.record, { ...accept, signatures: [signature] });
	assert.deepEqual(calls[2], { nsid: `${T}.market.submitAccept`, service: ENDPOINT, input: { acceptUri: `at://${did}/${T}.market.accept/r1`, acceptCid: "bafyr1" } });
	assert.deepEqual(ran.result.receipt, { uri: receipt.uri, cid: receipt.cid, submitEvent: receipt.submitEvent });
	const failed = await drive("accept", { rfp, bid, submitAccept: ENDPOINT }, host((call) => (call.nsid.endsWith("submitAccept") ? { ok: false, error: "503" } : undefined)).respond);
	assert.deepEqual([failed.result.receipt, failed.result.error, failed.result.accept.uri.split("/").pop()], [null, "503", "r1"]);
	const plain = await drive("accept", { rfp, bid }, host().respond);
	assert.deepEqual(plain.calls.map((c) => c.nsid), [POLICY, "com.fedfork.exec.attest", "com.atproto.repo.createRecord"]);
	assert.deepEqual(plain.calls[0].input, { mode: "full", perspective: "requester", selfDid: did, rootRequesterDid: did, subjectDid: HAT7, counterpartyDid: HAT7, rfp: { uri: rfp.uri, cid: rfp.cid }, bid });
	const denied = await drive("accept", { rfp, bid }, host((call) => (call.nsid === POLICY ? { ok: true, output: { allow: false, violations: [{ msg: "not vouched", policyId: "requester-tangled-vouch" }] } } : undefined)).respond);
	assert.equal(denied.error, `bid ${bid.uri} denied by policy (full): not vouched`);
	assert.equal(denied.calls.length, 1, "nothing is signed for a denied bid");
	const later = await drive("accept", { rfp, bid, submitAccept: ENDPOINT }, host((call) => (call.nsid.endsWith("submitAccept") ? { ok: true, output: { ok: true, id: "accept-1" } } : undefined)).respond);
	assert.deepEqual([later.result.receipt, later.result.submitted], [null, { ok: true, id: "accept-1" }]);
});

test("receipt reads the winner's receipt at the key it gives the accept", async () => {
	const accept = { uri: `at://${did}/${T}.market.accept/r1`, cid: "bafyr1" };
	const rkey = `receipt-${hex(`${accept.uri}\n${accept.cid}`)}`;
	const ran = await drive("receipt", { bidder: HAT7, accept }, () => ({ ok: true, output: { uri: `at://${HAT7}/${T}.market.receipt/${rkey}`, cid: "c1", value: { accept, submitEvent: ENDPOINT } } }));
	assert.deepEqual(ran.calls, [{ nsid: "com.atproto.repo.getRecord", service: HAT7, params: { repo: HAT7, collection: `${T}.market.receipt`, rkey } }]);
	assert.deepEqual(ran.result.receipt, { uri: `at://${HAT7}/${T}.market.receipt/${rkey}`, cid: "c1", submitEvent: ENDPOINT });
	assert.equal((await drive("receipt", { bidder: HAT7, accept }, () => ({ ok: false, error: "RecordNotFound" }))).result.receipt, null);
});

test("receipt and guest read public records: signed out they need no did", async () => {
	const accept = { uri: `at://${did}/${T}.market.accept/r1`, cid: "bafyr1" };
	const receipt = await drive("receipt", { did: undefined, bidder: HAT7, accept }, () => ({ ok: false, error: "RecordNotFound" }));
	assert.equal(receipt.error, undefined);
	assert.equal(receipt.result.receipt, null);
	const guest = await drive("guest", { did: undefined, bidder: HAT7, receipt: `at://${HAT7}/${T}.market.receipt/rc` }, () => ({ ok: false, error: "RecordNotFound" }));
	assert.equal(guest.error, undefined);
	assert.ok(guest.calls.length > 0 && guest.calls.every((c) => c.nsid === "com.atproto.repo.getRecord"), "it read the bidder's reports");
	assert.match((await drive("receipt", { did: "nope", bidder: HAT7, accept }, () => ({}))).error, /did must start with did:/);
});

// A guest's own events: the n-th of a stream (nsid, tag, kind) at
// guest-payload-<hex(sha256("guest:<nsid>:<tag>:<kind>:<n>:<receipt>"))[0..32]> (kcp bidder syncs.go guestEventSyncKey).
test("guest reads each tag's event streams n = 0, 1, ... until one is missing", async () => {
	const receipt = `at://${HAT9}/${T}.market.receipt/receipt-r`;
	const stream = (collection, tag, kind, n) => report(HAT9, collection, "guest", `guest:${T}.compute.events.${collection}:${tag}:${kind}:${n}:${receipt}`);
	const values = {
		[stream("guest.signalWebRTC", "ssh", "answer", 0)]: { kind: "answer", tag: "ssh", ciphertext: "a0" },
		[stream("guest.signalWebRTC", "ssh", "answer", 1)]: { kind: "answer", tag: "ssh", ciphertext: "a1" },
		[stream("guest.publicKey", "shell", "age-x25519", 0)]: { kind: "age-x25519", tag: "shell", key: "age1x" },
		[report(HAT9, "vm.registerIdentity", `${T}.compute.events.vm.registerIdentity`.toLowerCase().replace(/[^a-z0-9]/g, ""), `${T}.compute.events.vm.registerIdentity:${receipt}`)]: { computeIdentity: { nodeId: "node1" } },
	};
	const ran = await drive("guest", { bidder: HAT9, receipt }, (call) => (values[uriOf(call)] ? { ok: true, output: { value: values[uriOf(call)] } } : { ok: false, error: "RecordNotFound" }));
	assert.ok(ran.calls.every((c) => c.nsid === "com.atproto.repo.getRecord" && c.service === HAT9));
	// 6 reports and 4 streams, then the 2 streams that found one, then the ssh answers' third
	assert.equal(ran.calls.length, 6 + 4 + 2 + 1);
	assert.deepEqual(ran.result.signals.map((v) => v.ciphertext), ["a0", "a1"]);
	assert.equal(ran.result.nodeId, "node1");
	assert.equal(ran.result.events.filter((e) => e.kind === "guest.publicKey").length, 1);
	assert.match(start("guest", { bidder: HAT9 }).error, /receipt/);
});

// The bidder keys reports by receipt: <prefix>-payload-<hex(sha256(key))[0..32]> (socialweb-computer-kcp
// internal/market/bidder recordKeys/reportSyncKey), checked against live hat-7 / hat-9 records.
test("guest reads the receipt-derived report records directly", async () => {
	const sum = (key) => createHash("sha256").update(key).digest("hex").slice(0, 32);
	const live = "at://did:plc:5svqtrhheairglgiiyvutzik/com.publicdomainrelay.temp.market.receipt/receipt-951ea91d7eea013374d69b5dac492735";
	assert.equal(`hostkeys-payload-${sum(`hostKeys:${live}`)}`, "hostkeys-payload-1a1d499967b7dd5b568bb029b04a7d9c");
	const receipt = `at://${HAT9}/${T}.market.receipt/receipt-r`;
	const at = (collection, rkey) => `at://${HAT9}/${T}.compute.events.${collection}/${rkey}`;
	const keys = [{ type: "ssh-ed25519", publicKey: "ssh-ed25519 AAAA", fingerprint: "SHA256:x" }];
	const reports = {
		[at("vm.onNetwork", `onnetwork-payload-${sum(`onNetwork:${receipt}`)}`)]: { address: "iroh://endpointaabm6" },
		[at("vm.onNetwork", `onnetwork-payload-${sum(`onNetwork:ssh:${receipt}`)}`)]: { address: "sha-256 29:D7", kind: "webrtc", tag: "ssh" },
		[at("vm.hostKeys", `hostkeys-payload-${sum(`hostKeys:${receipt}`)}`)]: { keys },
		[at("vm.terminated", `termination-payload-${sum(`terminated:${receipt}`)}`)]: { reason: "deleted_on_request" },
	};
	const respond = (call) => {
		const value = reports[`at://${call.params.repo}/${call.params.collection}/${call.params.rkey}`];
		return value ? { ok: true, output: { value } } : { ok: false, error: "RecordNotFound" };
	};
	const ran = await drive("guest", { bidder: HAT9, receipt }, respond);
	assert.ok(ran.calls.every((c) => c.nsid === "com.atproto.repo.getRecord" && c.service === HAT9));
	assert.equal(ran.calls.length, 6 + 4, "6 reports, and the first of each tag's 2 streams");
	const { events, ...result } = ran.result;
	assert.deepEqual(result, { receipt, iroh: "iroh://endpointaabm6", webrtc: [{ fingerprint: "sha-256 29:D7", tag: "ssh" }], nodeId: null, hostKeys: keys, signals: [], terminated: true });
	assert.equal(events.length, 4);
	const shell = await drive("shell", { receipt: { uri: receipt, cid: "c" }, via: "iroh", command: "hostname" }, (call) =>
		call.nsid === "com.fedfork.exec.iroh.connect" ? { ok: true, output: { output: "fc\n", exitCode: 0 } } : respond(call));
	assert.equal(shell.calls.length, 5);
	assert.deepEqual(shell.calls.slice(4), [{ nsid: "com.fedfork.exec.iroh.connect", input: { ticket: "iroh://endpointaabm6", hostKeys: keys, command: "hostname" } }]);
	assert.match(start("guest", { bidder: HAT9, receipt, tags: ["a b"] }).error, /tag/);
});

test("release signs vm.delete and the event, then submits the signed event", async () => {
	const receipt = { uri: `at://${HAT7}/${T}.market.receipt/rc`, cid: "bafyrc" };
	// The bidder's receipt names no accept here: the search notes it and the release goes ahead.
	const { calls, respond } = host((call) => {
		if (call.nsid.endsWith("submitEvent")) return { ok: true, output: { ok: true } };
		if (call.nsid === "com.atproto.repo.getRecord") return { ok: true, output: { value: call.params.collection.endsWith("receipt") ? { accept: { uri: "at://did:plc:other/x/y" } } : {} } };
		if (call.nsid === "com.atproto.repo.listRecords") return { ok: true, output: { records: [] } };
		if (call.nsid === "com.atproto.repo.deleteRecord") return { ok: true, output: {} };
	});
	const ran = await drive("release", { receipt, submitEvent: `${HAT7}#pdr_temp_compute_event`, poll_ms: 1 }, respond);
	const creates = calls.filter((c) => c.nsid === "com.atproto.repo.createRecord");
	assert.deepEqual(creates[0].input.record, { $type: `${T}.compute.events.vm.delete`, reason: "session_ended", createdAt: now, signatures: [signature] });
	const event = { $type: `${T}.market.event`, receipt: { $type: "com.atproto.repo.strongRef", ...receipt }, payload: ref(`${T}.compute.events.vm.delete`, "r1"), createdAt: now };
	assert.deepEqual(creates[1].input.record, { ...event, signatures: [signature] });
	assert.deepEqual(ran.calls.find((c) => c.nsid.endsWith("submitEvent")), {
		nsid: `${T}.market.submitEvent`,
		proxy: `${HAT7}#pdr_temp_compute_event`,
		input: { uri: `at://${did}/${T}.market.event/r2`, cid: "bafyr2", record: { ...event, signatures: [signature] } },
	});
	assert.equal(ran.result.release.terminated, true);
	assert.match(ran.result.errors.join("\n"), /accept "at:\/\/did:plc:other\/x\/y" is not in your repo/);
	assert.equal(ran.result.release.event.uri, `at://${did}/${T}.market.event/r2`);
});

test("signal sends a sealed offer or an age key as signed guest.* payloads under a market.event", async () => {
	const receipt = { uri: `at://${HAT9}/${T}.market.receipt/rc`, cid: "bafyrc" };
	const offer = "-----BEGIN AGE ENCRYPTED FILE-----\nYWdl\n-----END AGE ENCRYPTED FILE-----\n";
	// The n-th signal of (receipt, tag, kind) at signal-payload-/signal-event-<hex of its key>: n is
	// the first index whose payload is missing (here one earlier offer, n = 1).
	const key = (kind, n) => `signal:${T}.compute.events.guest.signalWebRTC:shell:${kind}:${n}:${receipt.uri}`;
	const first = `signal-payload-${hex(key("offer", 0))}`;
	const { calls, respond } = host((call) => (call.nsid === "com.atproto.repo.getRecord" ? (call.params.rkey === first ? { ok: true, output: { value: {} } } : { ok: false, error: "RecordNotFound" }) : undefined));
	const ran = await drive("signal", { receipt, tag: "shell", offer }, respond);
	assert.deepEqual(calls.slice(0, 2).map((c) => [c.nsid, c.params?.repo, c.params?.rkey]), [["com.atproto.repo.getRecord", did, first], ["com.atproto.repo.getRecord", did, `signal-payload-${hex(key("offer", 1))}`]]);
	assert.deepEqual(calls[3], { nsid: "com.atproto.repo.createRecord", input: { repo: did, collection: `${T}.compute.events.guest.signalWebRTC`, rkey: `signal-payload-${hex(key("offer", 1))}`,
		record: { $type: `${T}.compute.events.guest.signalWebRTC`, kind: "offer", tag: "shell", ciphertext: offer, createdAt: now, signatures: [signature] } } });
	assert.deepEqual(calls[4].input.record.payload, ref(`${T}.compute.events.guest.signalWebRTC`, `signal-payload-${hex(key("offer", 1))}`));
	assert.deepEqual([calls[5].input.collection, calls[5].input.rkey], [`${T}.market.event`, `signal-event-${hex(`event:${key("offer", 1)}`)}`]);
	assert.equal(ran.result.submitted, false);
	const age = host();
	await drive("signal", { receipt, tag: "shell", key: "age1abc" }, age.respond);
	assert.deepEqual(age.calls[2].input.record, { $type: `${T}.compute.events.guest.publicKey`, kind: "age-x25519", tag: "shell", key: "age1abc", createdAt: now, signatures: [signature] });
	for (const bad of [{ tag: "shell" }, { tag: "shell", offer: "plain sdp" }, { tag: "shell", offer, key: "age1abc" }, { tag: "", key: "age1abc" }, { tag: "a b", key: "age1abc" }]) {
		assert.ok(start("signal", { receipt, ...bad }).error, JSON.stringify(bad));
	}
});

// shell plans a host pseudo-call (never a PDS call): webrtc directly, iroh after guest's reads.
test("shell plans webrtc.connect, or iroh.connect with the guest's ticket and pinned host keys", async () => {
	const receipt = { uri: `at://${HAT9}/${T}.market.receipt/rc`, cid: "bafyrc" };
	const strongRef = { $type: "com.atproto.repo.strongRef", ...receipt };
	const out = { tag: "ssh", fingerprint: "sha-256 AB", output: "ok\n" };
	const rtc = await drive("shell", { receipt: JSON.stringify(receipt), command: "echo ok" }, () => ({ ok: true, output: out }));
	assert.deepEqual(rtc.calls, [{ nsid: "com.fedfork.exec.webrtc.connect", input: { receipt: strongRef, tag: "ssh", command: "echo ok" } }]);
	assert.deepEqual(rtc.result, { via: "webrtc", result: out });
	// a secret for the command goes as stdin, beside it, never in it
	const rtcIn = await drive("shell", { receipt: JSON.stringify(receipt), command: "IFS= read -r t", stdin: "tok\n" }, () => ({ ok: true, output: out }));
	assert.deepEqual(rtcIn.calls[0].input, { receipt: strongRef, tag: "ssh", command: "IFS= read -r t", stdin: "tok\n" });
	assert.deepEqual(start("shell", { receipt, tag: "shell", via: "" }).calls[0].input, { receipt: strongRef, tag: "shell" });

	const keys = [{ type: "ssh-ed25519", publicKey: "AAAA", fingerprint: "SHA256:x" }];
	const values = {
		[report(HAT9, "vm.onNetwork", "onnetwork", `onNetwork:${receipt.uri}`)]: { address: "iroh://endpointaabm6" },
		[report(HAT9, "vm.hostKeys", "hostkeys", `hostKeys:${receipt.uri}`)]: { keys },
	};
	const repo = (call) => {
		if (call.nsid === "com.atproto.repo.getRecord") return values[uriOf(call)] ? { ok: true, output: { value: values[uriOf(call)] } } : { ok: false, error: "RecordNotFound" };
		return { ok: true, output: { output: "fc-1\n", exitCode: 0 } };
	};
	const iroh = await drive("shell", { receipt, via: "iroh", command: "hostname" }, repo);
	assert.deepEqual(iroh.calls.map((c) => c.nsid.split(".").pop()), ["getRecord", "getRecord", "getRecord", "getRecord", "connect"]);
	assert.deepEqual(iroh.calls.slice(4), [{ nsid: "com.fedfork.exec.iroh.connect", input: { ticket: "iroh://endpointaabm6", hostKeys: keys, command: "hostname" } }]);
	assert.deepEqual(iroh.result, { via: "iroh", result: { output: "fc-1\n", exitCode: 0 } });
	const irohIn = await drive("shell", { receipt, via: "iroh", command: "hostname", stdin: "tok\n" }, repo);
	assert.equal(irohIn.calls.at(-1).input.stdin, "tok\n");
	values[report(HAT9, "vm.hostKeys", "hostkeys", `hostKeys:${receipt.uri}`)] = { keys: [] };
	assert.match((await drive("shell", { receipt, via: "iroh", command: "x" }, repo)).error, /unpinned/);
	delete values[report(HAT9, "vm.onNetwork", "onnetwork", `onNetwork:${receipt.uri}`)];
	assert.match((await drive("shell", { receipt, via: "iroh", command: "x" }, repo)).error, /iroh ticket/);
	for (const bad of [{ receipt, via: "iroh" }, { receipt, via: "tcp" }, { receipt, tag: "a b" }, { receipt: "x" }, { receipt, command: 1 }, { receipt, command: "x", stdin: 1 }]) {
		assert.ok(start("shell", { ...bad }).error, JSON.stringify(bad));
	}
});

// The host side of `service`: runModule validates it and hands it to call().
test("runModule passes service (origin or DID) to call and rejects a bad or doubled route", async () => {
	// One call on start; the run's result is that call's result event.
	const step = (call) => ({ wasm: { run: async ({ input }) => (input.event.type === "start" ? { calls: [{ id: "c", ...call }] } : { result: input.event, done: true }) } });
	const submit = (call) => step({ nsid: `${T}.market.submitRfp`, input: {}, ...call });
	const route = ({ params, input, proxy, service }) => ({ params, input, proxy, service });
	const seen = [];
	await runModule(submit({ service: ENDPOINT }), { module }, "request", {}, async (nsid, request) => seen.push(route(request)));
	assert.deepEqual(seen, [{ params: undefined, input: {}, proxy: undefined, service: ENDPOINT }]);
	const refused = async (call) => (await runModule(submit(call), { module }, "request", {}, async () => ({}))).result.error;
	for (const service of ["http://a", "https://a/xrpc", "https://a?x", "file:///etc"]) assert.match(await refused({ service }), /https origin/, service);
	assert.match(await refused({ service: ENDPOINT, proxy: `${HAT7}#x` }), /not both/);
	assert.match(await refused({ service: HAT7 }), /is a read/);
	seen.length = 0;
	await runModule(step({ nsid: "com.atproto.repo.listRecords", service: HAT7, params: { repo: HAT7 } }), { module }, "bids", {}, async (nsid, request) => seen.push(route(request)));
	assert.deepEqual(seen, [{ params: { repo: HAT7 }, input: undefined, proxy: undefined, service: HAT7 }]);
});

// ---- contract and watch ---------------------------------------------------------------

// A hook default's module: this repo's modules/, or atlibs-iroh's (the sibling checkout, `cargo wasm` there).
const loadLib = async (key) => {
	const dir = key === "iroh-user-data" ? "../../../atlibs-iroh/" : "../../";
	return { ...JSON.parse(readFileSync(new URL(`${dir}modules/${key}/module.json`, import.meta.url), "utf8")), module: readFileSync(new URL(`${dir}target/wasm32-unknown-unknown/release/${key.replaceAll("-", "_")}.wasm`, import.meta.url)) };
};

// The harness's handle() has no managed_records ledger, so the rkey guard would refuse every
// cleanup delete; run it here with an in-memory ledger, as the server and emdash hosts keep one.
async function handleWithLedger(entry, input, respond, records = new Map()) {
	const managed_records = { get: async (k) => records.get(k) ?? null, put: async (k, v) => void records.set(k, v), delete: async (k) => void records.delete(k) };
	const ctx = { wasm: { run: async ({ entry, input }) => run(entry, { ...input, now }) }, storage: { managed_records } };
	const call = async (nsid, request) => {
		const answer = await respond({ nsid, ...request });
		if (answer?.ok === false) throw new Error(answer.error ?? "call failed");
		return answer?.output;
	};
	return runModule(ctx, noPolicy, entry, { did, ...input }, call);
}

test("contract: one run from rfp to release, reacting to the bid, receipt and reports as they land", async () => {
	const { calls, respond, keys } = market();
	const ran = await handleWithLedger("contract", { bidders: [HAT7, HAT9], user_data: "#cloud-config\n", via: "iroh", command: "hostname", stdin: "tok\n", poll_ms: 1 }, respond);
	assert.equal(ran.error, undefined);
	const r = ran.result;
	assert.equal(r.bid.uri, `at://${HAT7}/${T}.market.bid/bid-7`);
	assert.equal(r.bid.free, true);
	assert.match(r.receipt.uri, new RegExp(`^at://${HAT7}/${T}.market.receipt/receipt-[0-9a-f]{32}$`));
	assert.equal(r.guest.iroh, "iroh://endpointaabm6");
	assert.deepEqual(r.guest.hostKeys, keys);
	assert.deepEqual(r.shell.input, { ticket: "iroh://endpointaabm6", hostKeys: keys, command: "hostname", stdin: "tok\n" });
	assert.equal(r.release.terminated, true);
	assert.equal(r.deleted.length, 5);
	assert.ok(r.errors.some((e) => /503/.test(e)), "hat-9's refusal is reported, not fatal");
	const nsids = calls.map((c) => c.nsid);
	assert.equal(nsids.filter((n) => n === "com.atproto.repo.deleteRecord").length, 5);
	const collections = calls.filter((c) => c.nsid === "com.atproto.repo.createRecord").map((c) => c.input.collection.split(".").slice(-2).join("."));
	// this host's attestation key is bound first (nothing it signs verifies without), and stays bound
	assert.deepEqual(collections, ["temp.badgeBlueKeys", "compute.vm", "market.rfp", "market.accept", "vm.delete", "market.event"]);
	const rkey = base58btc(createHash("sha256").update(`${did}:${KEY}`).digest().subarray(0, 24)).slice(0, 32);
	const bound = calls.find((c) => c.input?.collection === `${T}.badgeBlueKeys`);
	assert.deepEqual([bound.input.rkey, bound.input.record.keyId], [rkey, KEY]);
	assert.ok(calls.some((c) => c.nsid === "com.atproto.repo.getRecord" && c.params.collection === `${T}.badgeBlueKeys` && c.params.rkey === rkey), "read before it is written");
	assert.ok(!calls.some((c) => c.nsid === "com.atproto.repo.deleteRecord" && c.input.collection === `${T}.badgeBlueKeys`));
	// a key already bound is not bound again
	const again = market({ bound: true });
	assert.equal((await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", via: "iroh", poll_ms: 1 }, again.respond)).error, undefined);
	assert.ok(!again.calls.some((c) => c.input?.collection === `${T}.badgeBlueKeys`));
	const peer = { service: `${HAT7}#pdr_temp_market`, endpoints: EP7 };
	for (const n of ["submitRfp", "submitAccept", "submitEvent"]) {
		const sent = calls.find((c) => c.nsid === `${T}.market.${n}` && c.service === peer.service);
		assert.deepEqual(sent && { service: sent.service, endpoints: sent.endpoints }, peer, `${n} goes to the winner's DID and offering endpoints`);
	}
	const signedCreates = calls.filter((c) => c.nsid === "com.atproto.repo.createRecord" && ![`${T}.compute.vm`, `${T}.badgeBlueKeys`].includes(c.input.collection));
	assert.ok(signedCreates.every((c) => c.input.record.signatures?.length === 1), "rfp, accept, vm.delete and event are signed");
});

test("contract over webrtc asks the host for webrtc.connect with the receipt and tag; release: false keeps the VM", async () => {
	const { respond } = market();
	const ran = await handle("contract", { bidders: [HAT7], user_data: "x", via: "webrtc", tag: "ssh", command: "id", poll_ms: 1, release: false }, { respond });
	assert.equal(ran.result.shell.input.tag, "ssh");
	assert.equal(ran.result.shell.input.receipt.uri, ran.result.receipt.uri);
	assert.equal(ran.result.release, null);
	assert.deepEqual(ran.result.deleted, []);
});

// The prod flake (2026-11-10 19:46Z, hat-9): the guest reported ssh and shell 8 ms apart and the
// bidder published only shell's vm.onNetwork. One DTLS certificate serves every tag, so any will do.
test("contract over webrtc goes on with another tag's fingerprint when its own tag's report is missing", async () => {
	const ran = await handle("contract", { bidders: [HAT7], user_data: "x", via: "webrtc", tag: "ssh", command: "id", poll_ms: 1, release: false }, { respond: market({ ssh: false }).respond });
	assert.deepEqual(ran.result.errors, []);
	assert.equal(ran.result.shell.input.tag, "ssh");
});

test("contract reports a failed shell in errors, not only in shell", async () => {
	const { respond } = market();
	const failing = (call) => call.nsid === "com.fedfork.exec.webrtc.connect" ? { ok: false, error: "no fingerprint for tag ssh" } : respond(call);
	const ran = await handle("contract", { bidders: [HAT7], user_data: "x", via: "webrtc", tag: "ssh", command: "id", poll_ms: 1, release: false }, { respond: failing });
	assert.match(ran.result.shell.error, /no fingerprint/);
	assert.ok(ran.result.errors.some((e) => /the shell failed: .*no fingerprint/.test(e)), JSON.stringify(ran.result.errors));
});

test("contract with release: false names the kept VM's MCP servers; release {receipt, records} cleans up fully", async () => {
	const ledger = new Map();
	const { calls, respond, keys } = market();
	const kept = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", via: "iroh", poll_ms: 1, release: false }, respond, ledger);
	assert.equal(kept.error, undefined);
	const r = kept.result;
	const short = r.receipt.uri.split("/").pop().slice("receipt-".length).slice(0, 8);
	assert.deepEqual(r.mcp.map((m) => m.name), [`vm-${short}`, `vm-${short}-iroh`]);
	assert.deepEqual(r.mcp.map((m) => serverRef(m.server.url)), [
		["webrtc:", { receipt: { uri: r.receipt.uri, cid: "bafyrc" }, bidder: HAT7 }, "/shell/mcp"],
		["iroh:", { ticket: "iroh://endpointaabm6", hostKeys: keys }, "/shell/mcp"],
	]);
	assert.deepEqual([r.release, r.deleted, r.records.map((u) => u.split("/")[3].split(".").pop())], [null, [], ["vm", "rfp", "accept"]]);

	calls.length = 0;
	const submits = (call) => (call.nsid.endsWith("submitEvent") ? (calls.push(call), { ok: true, output: { ok: true } }) : respond(call));
	// a composition's instance input (release: false, for its contract) reaches the release entry too: it still releases
	const released = await handleWithLedger("release", { receipt: r.receipt, records: r.records, submitEvent: ENDPOINT, poll_ms: 1, release: false }, submits, ledger);
	assert.equal(released.error, undefined);
	const out = released.result;
	assert.deepEqual(out.errors, []);
	assert.equal(out.release.terminated, true);
	assert.deepEqual(out.mcp, [], "a released VM has no MCP servers");
	assert.deepEqual(out.records, []);
	const kinds = (uris) => uris.map((u) => u.split("/")[3].split(".").slice(-2).join(".")).sort();
	assert.deepEqual(kinds(out.deleted), ["compute.vm", "market.accept", "market.event", "market.rfp", "vm.delete"]);
	const submit = calls.find((c) => c.nsid.endsWith("submitEvent"));
	assert.equal(submit.service, ENDPOINT);
	assert.equal(submit.input.uri, out.release.event.uri);
	assert.ok(calls.some((c) => c.nsid === "com.atproto.repo.getRecord" && c.params.repo === did && c.params.rkey.startsWith("signal-payload-")), "looked for signal records");
	assert.ok(!calls.some((c) => c.nsid === "com.atproto.repo.listRecords"), "never listRecords");

	// Bare release {receipt} (the agent lost records): the receipt -> accept -> rfp -> vm chain
	// finds them; a record the ledger does not hold is reported, not fatal.
	const ledger2 = new Map();
	const m2 = market();
	const kept2 = (await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", via: "iroh", poll_ms: 1, release: false }, m2.respond, ledger2)).result;
	const rpdr = (call) => {
		if (call.nsid.endsWith("submitEvent")) return { ok: true, output: { ok: true } };
		// The PDS's own records, as getRecord returns them (market() serves only the bidder's).
		const own = m2.calls.find((c) => c.nsid === "com.atproto.repo.createRecord" && call.nsid === "com.atproto.repo.getRecord" && call.params.repo === did && c.input.collection === call.params.collection);
		if (own) return { ok: true, output: { uri: uriOf(call), cid: "c", value: own.input.record } };
		return m2.respond(call);
	};
	ledger2.delete(kept2.records[1]);
	const bare = await handleWithLedger("release", { receipt: kept2.receipt, poll_ms: 1 }, rpdr, ledger2);
	assert.equal(bare.error, undefined);
	assert.equal(bare.result.release.terminated, true);
	assert.deepEqual(kinds(bare.result.deleted), ["compute.vm", "market.accept", "market.event", "vm.delete"]);
	assert.equal(bare.result.errors.length, 1);
	assert.match(bare.result.errors[0], new RegExp(`^delete ${kept2.records[1].replaceAll(".", "\\.")}: `), "the rfp the ledger lost is reported");
	assert.deepEqual(bare.result.records, [kept2.records[1]]);

	// Only what the guest reported: no shell tag, so iroh alone.
	const iroh = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", via: "iroh", poll_ms: 1, release: false }, market({ mcp: false }).respond);
	assert.deepEqual(iroh.result.mcp.map((m) => m.server.url.split("/")[0]), ["iroh:"]);
	const foreign = await handleWithLedger("release", { receipt: r.receipt, records: ["at://did:plc:other/x.y.z/r"] }, respond);
	assert.match(foreign.error, /in your repo/);
});

// The live-round bug: the guest posted onNetwork for a tag the requester did not ask for. The
// tags read are `tags` (default ssh, shell), user_data's tunnels.json tags, and `tag`.
test("contract reads the onNetwork reports of user_data's tunnels and the tags input", async () => {
	const tunnels = { tunnels: [{ tag: "box", unix: "/run/socialweb-guest-agent/shell.sock" }] };
	const user_data = "#cloud-config\n" + JSON.stringify({ write_files: [{ path: "/etc/socialweb-guest-agent/tunnels.json", content: JSON.stringify(tunnels) }] });
	const read = async (input, mcp) => {
		const ran = await handleWithLedger("contract", { bidders: [HAT7], via: "iroh", poll_ms: 1, release: false, ...input }, market({ mcp }).respond);
		assert.equal(ran.error, undefined);
		return ran.result.guest.webrtc.map((w) => w.tag);
	};
	assert.deepEqual((await read({ user_data: "x" }, "shell")), ["ssh", "shell"], "shell is read by default");
	assert.deepEqual((await read({ user_data }, "box")), ["ssh", "box"], "user_data's tunnel tags are read");
	assert.deepEqual((await read({ user_data: "x", tags: ["box"] }, "box")), ["box", "ssh"], "tags replaces the default; tag (ssh) is still read");
	assert.deepEqual((await read({ user_data: "x", tags: [] }, "shell")), ["ssh"], "neither asks for shell");
});

// As the page does: webrtc.connect's host runs `signal` (this module, this session, the same
// ledger) inside the shell call; contract finds that market.event + guest.signalWebRTC in the
// session's repo and deletes them with the rest (live gap).
test("contract over webrtc also deletes the signal records webrtc.connect's host wrote", async () => {
	const { calls, respond: base } = market();
	const records = new Map();
	const managed_records = { get: async (k) => records.get(k) ?? null, put: async (k, v) => void records.set(k, v), delete: async (k) => void records.delete(k) };
	const ctx = { wasm: { run: async ({ entry, input }) => run(entry, { ...input, now }) }, storage: { managed_records } };
	const mod = noPolicy;
	const repo = new Map();
	const call = async (nsid, request) => {
		if (nsid === "com.fedfork.exec.webrtc.connect") {
			const offer = "-----BEGIN AGE ENCRYPTED FILE-----\nYWdl\n-----END AGE ENCRYPTED FILE-----\n";
			for (let n = 0; n < 2; n++) {
				const signal = await runModule(ctx, mod, "signal", { did, receipt: request.input.receipt, tag: "ssh", offer }, call);
				assert.equal(signal.error, undefined);
			}
			return { tag: "ssh", fingerprint: "sha-256 29:D7", output: "uid=0(root)\n" };
		}
		assert.notEqual(nsid, "com.atproto.repo.listRecords");
		if (nsid === "com.atproto.repo.getRecord" && request.params.repo === did) {
			const value = repo.get(`at://${did}/${request.params.collection}/${request.params.rkey}`);
			if (value) return { value };
			if (request.params.rkey.startsWith("signal-")) throw new Error("RecordNotFound");
		}
		const answer = await base({ nsid, ...request });
		if (answer?.ok === false) throw new Error(answer.error ?? "call failed");
		if (nsid === "com.atproto.repo.createRecord") repo.set(answer.output.uri, request.input.record);
		return answer?.output;
	};
	const ran = await runModule(ctx, mod, "contract", { did, bidders: [HAT7], user_data: "x", via: "webrtc", tag: "ssh", command: "id", poll_ms: 1 }, call);
	assert.equal(ran.error, undefined);
	const r = ran.result;
	assert.deepEqual(r.errors, []);
	assert.equal(r.shell.output, "uid=0(root)\n");
	const deleted = r.deleted.map((u) => u.split("/").slice(-2, -1)[0].split(".").slice(-2).join("."));
	assert.deepEqual(deleted.sort(), ["compute.vm", "guest.signalWebRTC", "guest.signalWebRTC", "market.accept", "market.event", "market.event", "market.event", "market.rfp", "vm.delete"].sort());
	const removed = calls.filter((c) => c.nsid === "com.atproto.repo.deleteRecord");
	assert.equal(removed.length, 9);
});

test("contract cleanup counts only the deletes it asks for: a bad URI is noted, and none left finishes", async () => {
	const state = (created) => ({ phase: "releasing", created, release: { terminated: false }, deleted: [], errors: [], polls: {} });
	const term = { type: "result", id: "term", ok: true, output: { value: {} } };
	const none = await run("contract", { did, now, state: state(["bad"]), event: term });
	assert.equal(none.done, true);
	assert.deepEqual(none.result.errors, ['cannot delete "bad": not an at:// record URI']);
	const one = await run("contract", { did, now, state: state(["bad", `at://${did}/a.b.c/r`]), event: term });
	assert.deepEqual([one.calls.map((c) => c.id), one.state.deletes.length], [["rm:1"], 1]);
	const after = await run("contract", { did, now, state: one.state, event: { type: "result", id: "rm:1", ok: true, output: {} } });
	assert.equal(after.done, true);
});

test("contract whose winner accepts but mints no receipt cleans up vm, rfp and accept (release true or false)", async () => {
	for (const release of [true, false]) {
		const { calls, respond } = market({ receipts: false });
		const ran = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", poll_ms: 1, release }, respond);
		assert.equal(ran.error, undefined, `release ${release}`);
		assert.ok(ran.result.errors.includes("the winner minted no receipt"));
		assert.equal(ran.result.release, null, "nothing to release without a receipt");
		assert.equal(ran.result.deleted.length, 3, `release ${release}: vm, rfp and accept deleted`);
		const deleted = calls.filter((c) => c.nsid === "com.atproto.repo.deleteRecord").map((c) => c.input.collection.split(".").slice(-2).join("."));
		assert.deepEqual(deleted.sort(), ["compute.vm", "market.accept", "market.rfp"]);
	}
});

test("a bidder that refuses the vm.delete fails the release and keeps its records for another try", async () => {
	const { calls, respond } = market({ refuses: true });
	const ran = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", via: "iroh", poll_ms: 1 }, respond);
	assert.match(ran.error, /submitEvent failed with 400: the inbound event is not signed; the VM is not released, these records are kept: .*compute\.vm.*compute\.events\.vm\.delete.*market\.event/);
	assert.ok(!calls.some((c) => c.nsid === "com.atproto.repo.deleteRecord"), "nothing deleted");
});

test("contract whose VM never boots gives it back and deletes its records, even with release: false", async () => {
	const { calls, respond } = market({ boots: false });
	const ran = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", via: "iroh", poll_ms: 1, max_polls: 3, release: false }, respond);
	assert.equal(ran.error, undefined);
	assert.ok(ran.result.errors.some((e) => e.includes("did not report")), JSON.stringify(ran.result.errors));
	assert.equal(ran.result.release.terminated, true, "vm.delete sent, vm.terminated read");
	assert.deepEqual(ran.result.mcp, [], "no VM kept");
	assert.deepEqual(ran.result.records, []);
	const deleted = calls.filter((c) => c.nsid === "com.atproto.repo.deleteRecord").map((c) => c.input.collection.split(".").slice(-2).join("."));
	assert.deepEqual(deleted.sort(), ["compute.vm", "market.accept", "market.event", "market.rfp", "vm.delete"]);
});

test("contract with no compute offering cleans up the vm and rfp and reports why", async () => {
	const { calls, respond } = host((call) => {
		if (call.nsid === "com.atproto.repo.listRecords") return { ok: true, output: { records: [] } };
		if (call.nsid === "com.atproto.repo.deleteRecord") return { ok: true, output: {} };
	});
	const ran = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", poll_ms: 1 }, respond);
	assert.ok(ran.result.errors.includes("no bidder offers compute"));
	assert.equal(ran.result.deleted.length, 2);
	assert.equal(calls.filter((c) => c.nsid.endsWith("submitRfp")).length, 0);
	for (const bad of [{ user_data: "x" }, { bidders: [HAT7], user_data: " " }, { bidders: [HAT7], user_data: "x", via: "tcp" }, { bidders: [HAT7], user_data: "x", command: "id" }, { bidders: [HAT7], user_data: "x", via: "iroh", command: "id", stdin: 5 }]) {
		assert.ok((await handle("contract", bad, { respond })).error, JSON.stringify(bad));
	}
});

test("contract whose rfp attest or createRecord fails after the vm exists still deletes the vm", async () => {
	const isRfp = (call) => call.input?.record?.$type === `${T}.market.rfp`;
	for (const fails of [(call) => call.nsid === "com.fedfork.exec.attest" && isRfp(call), (call) => call.nsid === "com.atproto.repo.createRecord" && isRfp(call)]) {
		const { calls, respond } = host((call) => {
			if (fails(call)) return { ok: false, error: "rfp refused" };
			if (isOffering(call)) return { ok: true, output: offering(EP7) };
			if (call.nsid === "com.atproto.repo.deleteRecord") return { ok: true, output: {} };
		});
		const ran = await handleWithLedger("contract", { bidders: [HAT7], user_data: "x", poll_ms: 1 }, respond);
		assert.equal(ran.error, undefined);
		assert.ok(ran.result.errors.some((e) => /rfp refused/.test(e)), ran.result.errors.join("\n"));
		assert.equal(ran.result.rfp, null);
		assert.deepEqual(ran.result.deleted, [ran.result.vm.uri]);
		const deleted = calls.filter((c) => c.nsid === "com.atproto.repo.deleteRecord");
		assert.deepEqual(deleted.map((c) => c.input.collection), [`${T}.compute.vm`]);
		assert.equal(calls.filter((c) => c.nsid.endsWith("submitRfp")).length, 0);
	}
});

test("watch re-reads the derived reports until ready, and reads the answer stream until an answer comes", async () => {
	const receipt = `at://${HAT9}/${T}.market.receipt/receipt-r`;
	const answer0 = report(HAT9, "guest.signalWebRTC", "guest", `guest:${T}.compute.events.guest.signalWebRTC:shell:answer:0:${receipt}`);
	let reads = 0;
	const respond = (call) => {
		assert.notEqual(call.nsid, "com.atproto.repo.listRecords");
		const uri = uriOf(call);
		if (uri === answer0 && ++reads >= 2) return { ok: true, output: { value: { kind: "answer", tag: "shell", ciphertext: "age" } } };
		if (uri === report(HAT9, "vm.onNetwork", "onnetwork", `onNetwork:${receipt}`)) return { ok: true, output: { value: { address: "iroh://t" } } };
		if (uri === report(HAT9, "vm.hostKeys", "hostkeys", `hostKeys:${receipt}`)) return { ok: true, output: { value: { keys: ["k"] } } };
		return { ok: false, error: "RecordNotFound" };
	};
	const ready = await handle("watch", { bidder: HAT9, receipt, via: "iroh", poll_ms: 1 }, { respond });
	assert.deepEqual([ready.result.ready, ready.result.iroh, ready.result.hostKeys], [true, "iroh://t", ["k"]]);
	reads = 0;
	const answer = await handle("watch", { bidder: HAT9, receipt, until: "answer", tag: "shell", poll_ms: 1 }, { respond });
	assert.equal(answer.result.ready, true);
	assert.deepEqual(answer.result.signals, [{ kind: "answer", tag: "shell", ciphertext: "age" }]);
	const never = await handle("watch", { bidder: HAT9, receipt: `at://${HAT9}/${T}.market.receipt/none`, via: "iroh", poll_ms: 1, max_polls: 3 }, { respond });
	assert.equal(never.result.ready, false);
});

// Composition: policy-composition.json routes the requester's policy
// hook (com.publicdomainrelay.temp.market.evaluatePolicy, all-allow) to its policy modules; the policies'
// own reads (vouch records) go through their own call (callFor), the requester's through the fake market.
// edit(manifest) changes the composition; handlers are the caller's.
async function composeContract(input, { respond, world, edit = (m) => m, handlers }) {
	const manifest = edit(JSON.parse(readFileSync(new URL("./policy-composition.json", import.meta.url), "utf8")));
	const records = new Map();
	const managed_records = { get: async (k) => records.get(k) ?? null, put: async (k, v) => void records.set(k, v), delete: async (k) => void records.delete(k) };
	const instances = new Map();
	const ctx = {
		storage: { managed_records },
		wasm: {
			run: async ({ module, entry, input }) => {
				if (!instances.has(module)) instances.set(module, new WebAssembly.Instance(new WebAssembly.Module(module), {}).exports);
				const exports = instances.get(module);
				const data = new TextEncoder().encode(JSON.stringify(input));
				const ptr = exports.alloc(data.length);
				new Uint8Array(exports.memory.buffer, ptr, data.length).set(data);
				const packed = BigInt.asUintN(64, exports[entry](ptr, data.length));
				return JSON.parse(new TextDecoder().decode(new Uint8Array(exports.memory.buffer, Number(packed >> 32n), Number(packed & 0xffffffffn))));
			},
		},
	};
	const load = loadLib;
	const callOf = (answer) => async (nsid, request) => {
		const out = await answer({ nsid, ...request });
		if (out?.ok === false) throw new Error(out.error ?? "call failed");
		return out?.output;
	};
	const comp = await loadComposition(ctx, manifest, { load, provides: ["com.fedfork.exec.iroh.connect"] });
	return runCompose(ctx, comp, "requester", "contract", { did, ...input }, {
		callFor: (inst) => callOf(inst.name === "requester" ? respond : world.respond),
		handlers,
	});
}
const policyCalls = (ran) => ran.graph.filter((g) => g.nsid === POLICY);
const routes = (manifest, ...keep) => ({ ...manifest, edges: manifest.edges.filter((e) => keep.includes(e.to ?? e.handler)) });

test("composition: two policies, both must allow; hat-7 is denied in scope mode by the first, hat-9 passes both, scope then full", async () => {
	const { calls, respond } = market({ bidders: [HAT7, HAT9] });
	const world = new World();
	world.vouch(did, HAT9); // the requester vouches for hat-9 only
	const ran = await composeContract({ bidders: [HAT7, HAT9], user_data: "x", poll_ms: 1, release: false }, { respond, world });
	assert.equal(ran.error, undefined);
	assert.equal(ran.result.bid.bidder, HAT9);
	assert.ok(ran.result.errors.some((e) => e.includes(`at://${HAT7}/${T}.market.bid/bid-7 denied by policy (scope): `)), ran.result.errors.join("\n"));
	// hat-7: vouch denies, so payload is never asked; hat-9: both, in scope mode and again in full mode
	const count = (to) => policyCalls(ran).filter((g) => g.to === to && g.ok).length;
	assert.deepEqual([count("vouch"), count("payload")], [3, 2]);
	const accepts = calls.filter((c) => c.nsid === "com.atproto.repo.createRecord" && c.input.collection === `${T}.market.accept`);
	assert.deepEqual(accepts.map((c) => c.input.record.bid.uri), [`at://${HAT9}/${T}.market.bid/bid-9`]);
	assert.ok(world.reads.includes(`at://${did}/sh.tangled.graph.vouch/${HAT9}`), "the policy read the vouch itself");
});

test("composition: the second policy denies the winner in full mode: nothing is accepted", async () => {
	const world = new World();
	world.vouch(did, HAT9);
	// vouch, then a caller handler that allows the bidder (scope) but not the bid (full)
	const edit = (m) => ({ ...routes(m, "vouch"), handlers: [{ name: "judge" }], edges: [...routes(m, "vouch").edges, { from: "requester", nsid: POLICY, handler: "judge", reason: "the caller judges the bid" }] });
	const judge = async ({ mode }) => (mode === "scope" ? { allow: true, violations: [] } : { allow: false, violations: [{ msg: "over budget", policyId: "judge" }] });
	const ran = await composeContract({ bidders: [HAT9], user_data: "x", poll_ms: 1 }, { ...market({ bidders: [HAT9] }), world, edit, handlers: { judge } });
	assert.ok(ran.result.errors.includes("no acceptable bid"), ran.result.errors.join("\n"));
	assert.ok(ran.result.errors.includes(`bid at://${HAT9}/${T}.market.bid/bid-9 denied by policy (full): over budget`), ran.result.errors.join("\n"));
	assert.equal(ran.result.accept, null);
	assert.deepEqual(policyCalls(ran).map((g) => g.to ?? g.handler), ["vouch", "judge", "vouch", "judge"], "both routes, in edge order, scope then full");
});

test("composition: a caller handler as the policy sees scope mode, then full mode with the rfp and the bid", async () => {
	const seen = [];
	const approve = async (input) => (seen.push(input), { allow: input.mode === "scope" || input.bid.value.payload !== undefined, violations: [] });
	const edit = (m) => ({ ...routes(m), handlers: [{ name: "approve", description: "the caller decides" }], edges: [{ from: "requester", nsid: POLICY, handler: "approve", reason: "the caller approves each bid" }] });
	const ran = await composeContract({ bidders: [HAT7], user_data: "x", poll_ms: 1, release: false }, { ...market(), world: new World(), edit, handlers: { approve } });
	assert.equal(ran.result.bid.bidder, HAT7);
	assert.deepEqual(seen.map((i) => i.mode), ["scope", "full"]);
	const [scope, full] = seen;
	for (const i of seen) assert.deepEqual([i.perspective, i.selfDid, i.rootRequesterDid, i.subjectDid, i.counterpartyDid], ["requester", did, did, HAT7, HAT7]);
	assert.deepEqual(scope.rfp, { uri: ran.result.rfp.uri, cid: ran.result.rfp.cid });
	assert.equal(scope.bid, undefined);
	assert.deepEqual([full.bid.uri, full.bid.cid], [ran.result.bid.uri, ran.result.bid.cid]);
	const denied = await composeContract({ bidders: [HAT7], user_data: "x", poll_ms: 1 }, { ...market(), world: new World(), edit, handlers: { approve: async () => ({ allow: false, violations: [{ msg: "no", policyId: "caller" }] }) } });
	assert.ok(denied.result.errors.includes(`bid at://${HAT7}/${T}.market.bid/bid-7 denied by policy (scope): no`), denied.result.errors.join("\n"));
});

test("composition: unrouted, the requester's policy is its default, policy-requester-tangled-vouch", async () => {
	const world = new World();
	world.vouch(did, HAT9);
	const ran = await composeContract({ bidders: [HAT7, HAT9], user_data: "x", poll_ms: 1, release: false }, { ...market({ bidders: [HAT7, HAT9] }), world, edit: (m) => routes({ ...m, instances: m.instances.slice(0, 1) }) });
	assert.equal(ran.result.bid.bidder, HAT9);
	assert.ok(policyCalls(ran).every((g) => g.to === "requester-policy-requester-tangled-vouch"), JSON.stringify(policyCalls(ran)));
});

test("composition: swapping a module swaps the policy; RFP-attached policy records route by name", async () => {
	const world = new World();
	world.vouch(did, HAT9);
	const swap = (module) => (m) => routes({ ...m, instances: m.instances.map((i) => (i.name === "vouch" ? { ...i, module } : i)) }, "vouch");
	const onlyMe = await composeContract({ bidders: [HAT7, HAT9], user_data: "x", poll_ms: 1 }, { ...market({ bidders: [HAT7, HAT9] }), world, edit: swap("policy-requester-only-me") });
	assert.ok(onlyMe.result.errors.includes("no acceptable bid"), onlyMe.result.errors.join("\n"));
	assert.equal(onlyMe.result.errors.filter((e) => e.includes("denied by policy (scope): scope denied by requester-only-me")).length, 2, onlyMe.result.errors.join("\n"));
	assert.equal(onlyMe.result.accept, null);
	const open = await composeContract({ bidders: [HAT7], user_data: "x", poll_ms: 1, release: false }, { ...market(), world: new World(), edit: swap("policy-open") });
	assert.equal(open.result.bid.bidder, HAT7);
	// kcp: the RFP's computer.socialweb.temp.policy.ghalite record names the policy; "only-me" is requester-only-me.
	// They add to the requester's own routes (here vouch, as a loaded manifest routes its default), never replace them.
	const attached = (m) => rfpPolicyRoutes(routes({ ...m, instances: m.instances.slice(0, 2) }, "vouch"), "requester", [{ name: "only-me" }]);
	const file = () => JSON.parse(readFileSync(new URL("./policy-composition.json", import.meta.url), "utf8"));
	assert.throws(() => rfpPolicyRoutes(routes({ ...file(), instances: file().instances.slice(0, 1) }), "requester", [{ name: "open" }]), /evaluatePolicy is not routed: RFP policies add to its routes/);
	assert.deepEqual(attached(file()).instances.at(-1), { name: "requester-rfp-0", module: "policy-requester-only-me" });
	assert.deepEqual(attached(file()).edges.map((e) => e.to), ["vouch", "requester-rfp-0"], "the requester's own policy first, the RFP's after it");
	const named = await composeContract({ bidders: [HAT9], user_data: "x", poll_ms: 1 }, { ...market({ bidders: [HAT9] }), world, edit: attached });
	assert.ok(named.result.errors.includes("no acceptable bid"), named.result.errors.join("\n"));
	const own = { instances: [{ name: "requester", module: "requester" }, { name: "own", module: "policy-open" }], edges: [{ from: "requester", nsid: POLICY, to: "own", reason: "r" }] };
	assert.throws(() => rfpPolicyRoutes(own, "requester", [{ name: "my-own-workflow" }]), /no policy module for the RFP's policy "my-own-workflow"/);
	assert.throws(() => rfpPolicyRoutes(own, "requester", [null]), /no policy module for the RFP's policy null/);
});

test("no user_data: the userData hook's default, user-data, builds it (and iroh-user-data, for ssh)", async () => {
	const seen = [];
	const loaded = [];
	const load = async (key) => (loaded.push(key), loadLib(key));
	const ctx = { wasm: { run: async ({ module: bytes, entry, input }) => {
		const x = new WebAssembly.Instance(new WebAssembly.Module(bytes), {}).exports;
		const data = new TextEncoder().encode(JSON.stringify({ ...input, now }));
		const ptr = x.alloc(data.length);
		new Uint8Array(x.memory.buffer, ptr, data.length).set(data);
		const packed = BigInt.asUintN(64, x[entry](ptr, data.length));
		return JSON.parse(new TextDecoder().decode(new Uint8Array(x.memory.buffer, Number(packed >> 32n), Number(packed & 0xffffffffn))));
	} } };
	const { respond } = host();
	const call = async (nsid, request) => (seen.push({ nsid, ...request }), (await respond({ nsid, ...request })).output);
	const snapshot = (name) => readFileSync(new URL(`../user-data/snapshots/${name}.cloud-config`, import.meta.url), "utf8");
	const vmOf = () => seen.find((c) => c.input?.collection === `${T}.compute.vm`).input.record.user_data;
	const mod = { ...spec, module: readFileSync(new URL("../../target/wasm32-unknown-unknown/release/requester.wasm", import.meta.url)) };
	assert.equal((await runModule(ctx, mod, "request", { did }, call, { load, callFor: () => call })).error, undefined);
	assert.equal(vmOf(), snapshot("shell"));
	assert.deepEqual(loaded, ["user-data"]);
	seen.length = 0;
	const KEY = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIExample me@host";
	assert.equal((await runModule(ctx, mod, "request", { did, iroh: true, ssh_key: KEY }, call, { load, callFor: () => call })).error, undefined);
	assert.equal(vmOf(), snapshot("shell-iroh"));
	assert.deepEqual(loaded, ["user-data", "user-data", "iroh-user-data"]);
	// more tunnels: passed through to the hook, one more tunnels.json entry
	seen.length = 0;
	const tunnels = [{ tag: "atirc", port: 6680, transport: "webrtc" }];
	assert.equal((await runModule(ctx, mod, "request", { did, tunnels }, call, { load, callFor: () => call })).error, undefined);
	assert.equal(vmOf(), snapshot("shell-tunnels"));
	// a bad input fails the run before any record
	seen.length = 0;
	assert.match((await runModule(ctx, mod, "request", { did, iroh: true }, call, { load, callFor: () => call })).error, /ssh_key/);
	assert.deepEqual(seen, []);
	// unrouted, no default: user_data is required
	const bare = { ...mod, hooks: mod.hooks.filter((h) => h.nsid !== "computer.socialweb.vm.userData").concat([{ nsid: "computer.socialweb.vm.userData", reason: "r" }]) };
	assert.match((await runModule(ctx, bare, "request", { did }, call, { load })).error, /user_data is required/);
});

test("no composition: runModule runs the default policy itself, so a plain run never accepts an unvouched bidder", async () => {
	const world = new World();
	const ctx = {
		wasm: {
			run: async ({ module: bytes, entry, input }) => {
				const x = new WebAssembly.Instance(new WebAssembly.Module(bytes), {}).exports;
				const data = new TextEncoder().encode(JSON.stringify({ ...input, now }));
				const ptr = x.alloc(data.length);
				new Uint8Array(x.memory.buffer, ptr, data.length).set(data);
				const packed = BigInt.asUintN(64, x[entry](ptr, data.length));
				return JSON.parse(new TextDecoder().decode(new Uint8Array(x.memory.buffer, Number(packed >> 32n), Number(packed & 0xffffffffn))));
			},
		},
	};
	const key = "policy-requester-tangled-vouch";
	const loaded = [];
	const load = async (k) => (loaded.push(k), { ...JSON.parse(readFileSync(new URL(`../${k}/module.json`, import.meta.url), "utf8")), module: readFileSync(new URL(`../../target/wasm32-unknown-unknown/release/${k.replaceAll("-", "_")}.wasm`, import.meta.url)) });
	const { respond } = market();
	const call = async (nsid, request) => {
		const out = await (request.service?.startsWith("did:") && nsid === "com.atproto.repo.getRecord" ? world.respond : respond)({ nsid, ...request });
		if (out?.ok === false) throw new Error(out.error ?? "call failed");
		return out?.output;
	};
	const bytes = readFileSync(new URL("../../target/wasm32-unknown-unknown/release/requester.wasm", import.meta.url));
	const ran = await runModule(ctx, { ...spec, module: bytes }, "request", { did, bidders: [HAT7], user_data: "x" }, call, { load });
	assert.equal(ran.error, undefined, "a run with no bid to judge never loads the policy");
	assert.deepEqual(loaded, []);
	// the default runs on its own call (callFor), never the requester's
	const own = [];
	const callFor = (mod) => (own.push(mod.name), call);
	const accept = await runModule(ctx, { ...spec, module: bytes }, "accept", { did, rfp: ref(`${T}.market.rfp`, "r1"), bid: { uri: `at://${HAT7}/${T}.market.bid/b`, cid: "bafyb" } }, call, { load, callFor });
	assert.deepEqual(loaded, [key]);
	assert.deepEqual(own, [JSON.parse(readFileSync(new URL(`../${key}/module.json`, import.meta.url), "utf8")).name]);
	assert.match(accept.error, /denied by policy \(full\): /);
	assert.doesNotMatch(accept.error, /no call for/);
	// a record that lost its default (and its required): the unrouted hook's null is a deny, never an allow
	const unrouted = await runModule(ctx, { ...spec, module: bytes, hooks: [{ nsid: POLICY, reason: "r" }] }, "accept", { did, rfp: ref(`${T}.market.rfp`, "r1"), bid: { uri: `at://${HAT7}/${T}.market.bid/b`, cid: "bafyb" } }, call);
	assert.match(unrouted.error, /denied by policy \(full\): no verdict/);
});