@fangorn-network/westmarch 2026.10.29 → 2026.11.4-dev

package/site/dist/assets/x-gjDrY2rk.js

@@ -1 +0,0 @@
-import{t as e}from"./createLucideIcon-BsERoFTA.js";var t=e(`x`,[[`path`,{d:`M18 6 6 18`,key:`1bl5f8`}],[`path`,{d:`m6 6 12 12`,key:`d8bk6v`}]]);export{t};

package/src/discover/explore.js

@@ -1,291 +0,0 @@
-// The Fangorn explorer: every verified app, what it is about, and what the
-// ERC-8004 registries say about it — read live, with no bake of its own.
-//
-// Everything here is already published by someone else:
-//   AppRegistry `AppAgentChanged`   which apps exist and where their cards are
-//   each card                       name, tools, views; checked against the chain
-//   each view's catalog             rows, domains, and coverage centroids (what it is about)
-//   ERC-8004 identity `Registered`  the agent minted for the app
-//   ERC-8004 reputation             feedback count and average per agent
-//
-// Both registries are scanned from their first event in windows as wide as the
-// chain's RPC allows (`chainOf`), in parallel, so the page and the MCP tool read
-// the same chain the same way, and a new app shows up on the next read.
-//
-// `client` is a viem PublicClient (getLogs, readContract): passed in, so this
-// runs in a tab and in node, and the self-check needs no chain.
-//
-// Windows grow with the chain. Pass `store` (apps.js cachedLogs) and only the
-// blocks since the last read are scanned; the page passes none.
-
-import { parseAbi, parseAbiItem } from "viem";
-// The config module alone (viem only), not the SDK's root: this runs in a tab too.
-import { BaseSepoliaConfig } from "@fangorn-network/sdk/lib/config.js";
-import { APP_EXTENSION, cachedLogs } from "./apps.js";
-import { survey, comparable } from "./directory.js";
-import { rankDomains, zFloor, lexScore } from "../core/rank.js";
-
-// The ERC-8004 registries per chain id, where `fangorn app agent` mints (agent0-sdk's
-// defaults, and the CLI's override for Arbitrum Sepolia, which agent0-sdk lacks).
-const ERC8004 = {
-    421614: { identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e", reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
-              // The identity registry's first event (2026-10-05). Its public RPC takes 10M-block windows.
-              identityFrom: 241_557_787n, window: 10_000_000n, scan: "arbitrum-sepolia" },
-    // ponytail: identity read from the AppRegistry's deployment, since an app's agent is minted after it.
-    // An agent minted before then and rebound with --skip-register is missed; scan earlier if that happens.
-    84532: { identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e", reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
-             scan: "base-sepolia" },
-};
-
-/** What explore reads on one of the SDK's networks (`SupportedNetworks.baseSepolia`, …). */
-export function chainOf(net = BaseSepoliaConfig) {
-    const e = ERC8004[net.caip2];
-    if (!e) throw new Error(`explore: no ERC-8004 registries known for chain ${net.caip2}`);
-    return {
-        chainId: net.caip2, appRegistry: net.appRegistryContractAddress, identity: e.identity, reputation: e.reputation,
-        // Nothing to read before the registry's deployment; from 0 a scan is mostly empty windows.
-        appRegistryFrom: net.appRegistryFromBlock, identityFrom: e.identityFrom ?? net.appRegistryFromBlock,
-        window: e.window ?? net.logWindow ?? 1000n,
-        scan: (agentId) => `https://8004scan.io/agents/${e.scan}/${agentId}`,
-    };
-}
-
-export const CHAIN = chainOf();
-
-const APP_AGENT_CHANGED = parseAbiItem("event AppAgentChanged(bytes32 indexed app_id, string agent_uri)");
-const REGISTERED = parseAbiItem("event Registered(uint256 indexed agentId, string agentURI, address indexed owner)");
-const APPS = parseAbi(["function getAppOwner(bytes32) view returns (address)"]);
-const REP = parseAbi([
-    "function getClients(uint256) view returns (address[])",
-    "function getSummary(uint256, address[], string, string) view returns (uint64, int128, uint8)",
-]);
-
-/** A link someone else wrote, shown to a reader: https or nothing. */
-const https = (u) => { try { const x = new URL(String(u)); return x.protocol === "https:" ? x.href : null; } catch { return null; } };
-const slug = (name) => String(name).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "").slice(0, 24) || "app";
-
-/** A card is listed only if it names this chain's AppRegistry and the app that
- *  bound it — the checks `discoverApp` makes. The binding itself is the log we
- *  read it from: we scanned to `latest`, so the last write per app is current. */
-export function verifyCard(card, appId, chain = CHAIN) {
-    const p = card?.capabilities?.extensions?.find((e) => e.uri === APP_EXTENSION)?.params;
-    if (!p) return "no fangorn app extension";
-    if (String(p.appId).toLowerCase() !== appId.toLowerCase()) return "card names another app";
-    if (p.chainId !== chain.chainId || String(p.appRegistry).toLowerCase() !== chain.appRegistry.toLowerCase()) return "card is for another registry";
-    if (!/^\d+$/.test(String(p.fromBlock))) return "bad fromBlock";
-    return null;
-}
-
-/**
- * The agent an app registered. `fangorn app agent` mints it and then binds the
- * card, from the owner's wallet, so it is the owner's latest `Registered` at or
- * before the binding.
- *
- * ponytail: paired by owner and block, not by reading the registration file
- * (IPFS gateways are too slow and flaky for a page load). An owner that
- * rebinds with --skip-register after minting another app's agent gets that
- * agent; fetch tokenURI and match its A2A endpoint if that starts happening.
- */
-export function pairAgent(registered, owner, bindBlock) {
-    let best = null;
-    for (const r of registered) {
-        if (r.owner.toLowerCase() !== owner.toLowerCase() || r.block > bindBlock) continue;
-        if (!best || r.block > best.block || (r.block === best.block && r.agentId > best.agentId)) best = r;
-    }
-    return best?.agentId ?? null;
-}
-
-/** Retried: dropping a verified app over a blip hides it from everyone who
- *  loads the page in that second. Seen 2026-09-28: headless Chrome in WSL got
- *  intermittent net::ERR_SSL_PROTOCOL_ERROR from one pages.dev host (curl never
- *  did); three tries do not always get past that one. */
-async function json(url, timeoutMs = 8000, tries = 3) {
-    try {
-        const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        return await res.json();
-    } catch (e) {
-        if (tries <= 1) throw e;
-        await new Promise((ok) => setTimeout(ok, 600 * (4 - tries)));   // 600ms, then 1.2s
-        return json(url, timeoutMs, tries - 1);
-    }
-}
-
-async function reputation(client, agentId, chain) {
-    try {
-        const clients = await client.readContract({ address: chain.reputation, abi: REP, functionName: "getClients", args: [agentId] });
-        if (!clients.length) return { feedback: 0, average: null };
-        const [count, value, decimals] = await client.readContract({ address: chain.reputation, abi: REP, functionName: "getSummary", args: [agentId, clients, "", ""] });
-        return { feedback: Number(count), average: Number(value) / 10 ** decimals, clients: clients.length };
-    } catch (e) {
-        return { error: e?.shortMessage ?? e?.message ?? String(e) };
-    }
-}
-
-// `window`: the most blocks one getLogs may span on the client's RPC (chainOf says, per chain).
-async function getLogsSince(client, start, filter, window, store) {
-    const head = await client.getBlockNumber();
-    const read = async (start, head) => {
-        const windows = [];
-        for (let from = start; from <= head; from += window) {
-            const to = from + window - 1n < head ? from + window - 1n : head;
-            windows.push(client.getLogs({ ...filter, fromBlock: from, toBlock: to }));
-        }
-        // In window order: oldest first still holds. Only what readDirectory reads, so a store stays small.
-        return (await Promise.all(windows)).flat().map(({ args, blockNumber }) => ({ args, blockNumber }));
-    };
-    return store ? cachedLogs(store, `${filter.address}:${filter.event.name}:${start}`, start, head, read) : read(start, head);
-}
-
-/**
- * Every verified app, with its 8004 agent, reputation, and catalog.
- * Unverified apps are dropped, not listed; `dropped` says why, for debugging.
- *
- * `onUpdate({ apps, pending })`, if given, is called once the bindings are read
- * and again as each app lands or drops, so a page can show apps as they arrive.
- * `pending` counts the bound apps not yet settled.
- * `store`, if given, keeps the logs read (apps.js cachedLogs), so the next read
- * scans only the blocks since.
- */
-export async function readDirectory(client, { chain = CHAIN, onUpdate = () => {}, store } = {}) {
-    const [bindLogs, regLogs] = await Promise.all([
-        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }, chain.window ?? 1000n, store),
-        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }, chain.window ?? 1000n, store),
-    ]);
-    const registered = regLogs.map((l) => ({ agentId: l.args.agentId, owner: l.args.owner, block: l.blockNumber }));
-    const latest = new Map();   // logs come oldest first: the last write wins
-    for (const l of bindLogs) latest.set(l.args.app_id, { uri: l.args.agent_uri, block: l.blockNumber });
-    const bound = [...latest].filter(([, { uri }]) => uri);   // an empty uri is unbound on purpose
-
-    // One pipeline per app, so the quick ones need not wait on Quorum's 1.7 MB
-    // catalog. Only a card failure drops an app; an owner or catalog that fails
-    // leaves it listed with less to say about it.
-    const apps = [], dropped = [];
-    let pending = bound.length;
-    const settle = () => { pending--; apps.sort((a, b) => a.name.localeCompare(b.name)); onUpdate({ apps: [...apps], pending }); };
-    onUpdate({ apps: [], pending });
-    await Promise.all(bound.map(async ([appId, { uri, block }]) => {
-        let card;
-        try {
-            if (!/^https:\/\//.test(uri)) throw new Error("card is not https");
-            card = await json(uri);
-            const why = verifyCard(card, appId, chain);
-            if (why) throw new Error(why);
-        } catch (e) { dropped.push({ card: uri, why: e?.message ?? String(e) }); return settle(); }
-
-        const p = card.capabilities.extensions.find((e) => e.uri === APP_EXTENSION).params;
-        const [[owner, agentId, rep], { corpora, unreachable }] = await Promise.all([
-            client.readContract({ address: chain.appRegistry, abi: APPS, functionName: "getAppOwner", args: [appId] }).catch(() => null)
-                .then(async (owner) => {
-                    const agentId = owner && pairAgent(registered, owner, block);
-                    return [owner, agentId, agentId == null ? null : await reputation(client, agentId, chain)];
-                }),
-            survey((p.views ?? []).filter((v) => /^https:\/\//.test(v))),
-        ]);
-        const name = typeof card.name === "string" && card.name.trim() ? card.name.trim() : `App ${appId.slice(0, 10)}`;
-        apps.push({
-            app: slug(name), name, description: typeof card.description === "string" ? card.description : "",
-            site: https(card.url), card: uri, appId, owner,
-            boundAt: Number(block), fromBlock: Number(p.fromBlock),
-            tools: (card.skills ?? []).map((s) => s.id),
-            agent: agentId == null ? null : { id: Number(agentId), scan: chain.scan(agentId) },
-            reputation: rep,
-            // null, not 0, when no catalog answered: "0 records" would claim it was counted.
-            rows: corpora.length ? corpora.reduce((n, c) => n + (c.rows || 0), 0) : null,
-            unreachable: unreachable.length,
-            domains: corpora.map((c) => ({ name: c.domain, description: c.description, rows: c.rows, coverage: c.coverage, model: c.model })),
-        });
-        settle();
-    }));
-    return { apps, dropped };
-}
-
-/** A calibration knob, not a law: nomic-embed-text-v1.5 at 256d, 5 apps
- *  (2026-09-28). Every on-topic top app scored >= 0.545 ("a cozy game" ->
- *  Sidequest), every off-topic top <= 0.52 ("bitcoin" -> Audius). Re-measure
- *  with the explorer's check when the model or the network changes much. */
-export const MIN_AFFINITY = 0.53;
-
-// ponytail: a short English list, enough for questions put to a directory.
-const FILLER = new Set("the and for are was were has have had not but with from that this these those what which where when who whom whose why how can could would should will shall may might must about into onto over under than then there their them they you your our any all some more most much many app apps find show tell learn know want need good best reputable".split(" "));
-
-/**
- * Rank a directory against a question. An app scores as its best domain's
- * coverage affinity (what its data is about, not what its blurb says). With no
- * `qv` (no embedder yet), name and description are matched by words.
- *
- * `relevant`: mean + 1σ of this query's scores, and at least MIN_AFFINITY.
- * Unlike findCorpora the top app is NOT always relevant: "which app has stock
- * prices" must be able to answer "none", or the explorer vouches for a
- * government-records app on a finance question.
- */
-export function rankApps(apps, query, { qv = null, model = null } = {}) {
-    const q = String(query ?? "").trim().toLowerCase();
-    if (!q) return apps.map((a) => ({ ...a, score: null, relevant: null, ranked_by: null }));
-    // Filler dropped, or "where can I learn about X" matches every blurb with "about" in it.
-    const content = q.split(/[^\p{L}\p{N}]+/u).filter((w) => w.length > 2 && !FILLER.has(w)).join(" ");
-    const words = (a) => (content ? lexScore({ text: `${a.name} ${a.description} ${a.domains.map((d) => d.description ?? "").join(" ")}` }, content) : 0);
-    let scored;
-    if (qv) {
-        scored = apps.map((a) => {
-            const doms = rankDomains(a.domains.filter((d) => comparable(d, model)), qv);
-            const best = doms.find((d) => d.affinity != null);
-            // No coverage (its catalog did not answer, or predates coverage):
-            // its own blurb, by words, rather than silently ranking it last.
-            if (!best) return { ...a, score: null, matched: null, ranked_by: "words", wordHit: words(a) > 0 };
-            return { ...a, score: best.affinity, matched: best.name, ranked_by: "meaning" };
-        });
-    } else {
-        scored = apps.map((a) => ({ ...a, score: words(a), ranked_by: "words" }));
-    }
-    scored.sort((a, b) => (b.score ?? -Infinity) - (a.score ?? -Infinity));
-    const s = scored.filter((a) => a.ranked_by === "meaning").map((a) => a.score);
-    const floor = qv ? Math.max(zFloor(s), MIN_AFFINITY) : 1e-9;
-    return scored.map(({ wordHit, ...a }) => ({ ...a, relevant: wordHit ?? (a.score != null && a.score >= floor) }));
-}
-
-/** What a caller sees: the ranking minus the centroids. Quorum alone has 29
- *  domains, so an app reports how many, and which one matched. */
-export const brief = ({ domains, ...a }) => ({ ...a, domains: domains.length });
-
-// ── self-check: `node src/discover/explore.js` ──────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/explore.js")) {
-    const j = (x) => JSON.stringify(x, (_, v) => (typeof v === "bigint" ? `${v}n` : v));
-    const eq = (a, b, m) => { if (j(a) !== j(b)) throw new Error(`${m}: ${j(a)} != ${j(b)}`); };
-    const O = "0x00000000000000000000000000000000000000aa", P = "0x00000000000000000000000000000000000000bb";
-    const reg = [
-        { agentId: 1n, owner: O, block: 10n }, { agentId: 2n, owner: P, block: 11n },
-        { agentId: 3n, owner: O, block: 20n }, { agentId: 4n, owner: O, block: 99n },
-    ];
-    eq(pairAgent(reg, O, 21n), 3n, "owner's latest agent at or before the binding");
-    eq(pairAgent(reg, P.toUpperCase().replace("0X", "0x"), 50n), 2n, "owner compared case-insensitively");
-    eq(pairAgent(reg, O, 5n), null, "no agent before the binding");
-
-    const A = "0x" + "a".repeat(64);
-    const card = (params) => ({ capabilities: { extensions: [{ uri: APP_EXTENSION, params }] } });
-    const good = { appId: A, chainId: CHAIN.chainId, appRegistry: CHAIN.appRegistry.toUpperCase().replace("0X", "0x"), fromBlock: "7" };
-    eq(verifyCard(card(good), A), null, "a good card verifies");
-    eq(verifyCard(card({ ...good, appId: "0x" + "b".repeat(64) }), A), "card names another app", "wrong app");
-    eq(verifyCard(card({ ...good, chainId: 1 }), A), "card is for another registry", "wrong chain");
-    eq(verifyCard({}, A), "no fangorn app extension", "no extension");
-
-    const cov = (v) => ({ vectors: [v] });
-    const apps = [
-        { name: "Tunes", description: "music tracks", domains: [{ name: "tracks", coverage: cov([1, 0, 0]) }] },
-        { name: "Sky", description: "weather alerts", domains: [{ name: "alerts", coverage: cov([0, 1, 0]) }, { name: "old", coverage: null }] },
-        { name: "Law", description: "meetings", domains: [{ name: "minutes", coverage: cov([0, 0, 1]) }] },
-        { name: "Empty", description: "", domains: [] },
-    ];
-    const r = rankApps(apps, "rain", { qv: [0.1, 1, 0] });
-    eq(r.map((a) => a.name), ["Sky", "Tunes", "Law", "Empty"], "ranked by best domain affinity, unscored last");
-    eq([r[0].relevant, r[0].matched, r[3].relevant], [true, "alerts", false], "top is relevant, unscored is not");
-    const blind = rankApps([{ ...apps[1], domains: [] }, apps[0], apps[2]], "weather alerts", { qv: [0.1, 1, 0] });
-    eq(blind.map((a) => [a.name, a.relevant, a.ranked_by]).at(-1), ["Sky", true, "words"], "an app with no coverage still matches on its own words");
-    eq(rankApps([{ ...apps[1], description: "all about the sky", domains: [] }], "where can I learn about music", { qv: [1, 0, 0] })[0].relevant, false, "filler words never match");
-    eq(rankApps(apps, "stock prices", { qv: [-1, -1, -1] }).filter((a) => a.relevant).length, 0, "a question no app covers matches none");
-    eq(rankApps(apps, "music").map((a) => [a.name, a.relevant]).slice(0, 2), [["Tunes", true], ["Sky", false]], "word fallback");
-    eq(rankApps(apps, "").map((a) => a.score), [null, null, null, null], "no query: listed, not ranked");
-    eq([https("javascript:alert(1)"), https("http://x.test"), https("https://x.test/a")], [null, null, "https://x.test/a"], "only https links reach a reader");
-    eq(brief({ name: "x", domains: [{ name: "d", coverage: 1 }] }), { name: "x", domains: 1 }, "brief drops centroids");
-    console.log("explore.js self-check ok — cards verified, agents paired by owner and block, apps ranked by coverage or words");
-}

package/src/market/settle.js

@@ -1,165 +0,0 @@
-// Encrypting a file into the access worker, from Node.
-//
-// This is the publisher's byte path, and it is the half of publishing that no
-// relay can do for you: the DEK is generated here, sealed to the worker's public
-// key here, and the plaintext never leaves the machine that owns it. A relay
-// that offered to do this step would be a relay that had your file.
-//
-// The browser has its own copy of this walk (an app's own encrypt.js, over
-// File.slice instead of fs.read). They must agree byte for byte — they share
-// `pack`, `aadFor` and `chunkKey` from envelope.js precisely so that the only
-// thing that differs between them is how bytes are read off a disk.
-import { open } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { seal } from "@fangorn-network/sdk";
-import { bytesToHex } from "viem";
-import {
-    CHUNK_SIZE, NONCE_LEN, aadFor, chunkKey, deleteResource,
-    getWorkerPubkey, pack, putChunk, unpack,
-} from "../publish/envelope.js";
-
-export { CHUNK_SIZE, aadFor, chunkKey, deleteResource, getWorkerPubkey };
-
-/**
- * Envelope-encrypt the file at `file` chunk by chunk and upload each
- * {ciphertext, sealed DEK} to the access worker's R2. Reads one chunk at a time,
- * so peak memory is ~2x chunkSize no matter how big the file is.
- *
- * @returns { plaintextHash, chunks, size, chunkSize } — the hash to commit
- *          on-chain, the chunk count the buyer reassembles, and the plaintext
- *          byte geometry a streaming player needs to map a Range request onto a
- *          chunk (chunk i starts at i * chunkSize).
- */
-export async function encryptAndUpload({ file, resourceId, workerUrl, uploadToken, chunkSize = CHUNK_SIZE, onProgress }) {
-    const dek = crypto.getRandomValues(new Uint8Array(32));
-    const aesKey = await crypto.subtle.importKey("raw", dek, "AES-GCM", false, ["encrypt"]);
-    const sealedDek = bytesToHex(seal(dek, await getWorkerPubkey(workerUrl), resourceId));
-
-    const fh = await open(file, "r");
-    try {
-        const { size } = await fh.stat();
-        const chunks = Math.max(1, Math.ceil(size / chunkSize));
-        const hash = createHash("sha256");
-        const buf = Buffer.allocUnsafe(Math.min(size, chunkSize) || 1);
-
-        for (let i = 0; i < chunks; i++) {
-            const { bytesRead } = await fh.read(buf, 0, buf.length, i * chunkSize);
-            const plain = buf.subarray(0, bytesRead);
-            hash.update(plain);
-
-            const nonce = crypto.getRandomValues(new Uint8Array(NONCE_LEN));
-            const aesCt = new Uint8Array(
-                await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce, additionalData: aadFor(i) }, aesKey, await pack(plain)),
-            );
-            const body = new Uint8Array(NONCE_LEN + aesCt.length);
-            body.set(nonce, 0);
-            body.set(aesCt, NONCE_LEN);
-
-            await putChunk({ workerUrl, uploadToken, key: chunkKey(resourceId, i), body, sealedDek });
-            onProgress?.(i + 1, chunks);
-        }
-        return { plaintextHash: `0x${hash.digest("hex")}`, chunks, size, chunkSize };
-    } finally {
-        await fh.close();
-    }
-}
-
-// ── self-check: `node src/market/settle.js` — no network, no worker ─────────────
-//
-// It decrypts with bare AES-GCM rather than importing a buyer, because what is
-// under test here is the ENCRYPTOR: chunk addressing, the AAD index binding, the
-// ragged tail, and that pack/unpack round trip. An app's full publisher→buyer
-// round trip belongs in that app, against its own buyer.
-if (import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/settle.js")) {
-    const { writeFileSync, rmSync } = await import("node:fs");
-    const { unseal } = await import("@fangorn-network/sdk");
-    const { x25519 } = await import("@noble/curves/ed25519");
-    const { hexToBytes, keccak256 } = await import("viem");
-
-    const CHUNK = 1000;
-    const tmp = `/tmp/westmarch-settle-${process.pid}.bin`;
-    const workerSecret = crypto.getRandomValues(new Uint8Array(32));
-    const workerPubkey = x25519.getPublicKey(workerSecret);
-    const r2 = new Map();
-    let sealedSeen = null;
-    const realFetch = globalThis.fetch;
-    globalThis.fetch = async (url, init = {}) => {
-        const u = String(url);
-        if (u.endsWith("/pubkey")) return { ok: true, json: async () => ({ pubkey: bytesToHex(workerPubkey) }) };
-        if (u.includes("/upload/")) {
-            const key = u.split("/upload/")[1];
-            if (init.method === "DELETE") return r2.delete(key), { ok: true };
-            sealedSeen = init.headers["X-Sealed-Dek"];
-            r2.set(key, new Uint8Array(init.body));
-            return { ok: true };
-        }
-        return { ok: false, status: 404 };
-    };
-
-    const rid = keccak256(new Uint8Array([1]));
-    /** Decrypt one stored chunk the way any buyer must. */
-    const read = async (i) => {
-        const dek = unseal(hexToBytes(sealedSeen), workerSecret, rid);
-        const key = await crypto.subtle.importKey("raw", dek, "AES-GCM", false, ["decrypt"]);
-        const body = r2.get(chunkKey(rid, i));
-        return unpack(new Uint8Array(await crypto.subtle.decrypt(
-            { name: "AES-GCM", iv: body.subarray(0, NONCE_LEN), additionalData: aadFor(i) },
-            key, body.subarray(NONCE_LEN),
-        )));
-    };
-    const same = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
-
-    try {
-        // Random bytes: 2.5 chunks → a ragged tail, and gzip must LOSE, so these
-        // exercise pack()'s store-raw branch.
-        const bytes = crypto.getRandomValues(new Uint8Array(2500));
-        writeFileSync(tmp, bytes);
-        const out = await encryptAndUpload({ file: tmp, resourceId: rid, workerUrl: "http://stub", chunkSize: CHUNK });
-        if (out.chunks !== 3) throw new Error(`chunk count: got ${out.chunks}, want 3`);
-        if (out.plaintextHash !== `0x${createHash("sha256").update(bytes).digest("hex")}`) throw new Error("streamed hash != whole-file sha256");
-        if (!r2.has(rid)) throw new Error("chunk 0 must land on the resourceId — that is where /access looks");
-        if (r2.size !== 3) throw new Error(`chunk keys collide: ${r2.size} objects for 3 chunks`);
-        // nonce(12) + flag(1) + ct(500) + tag(16)
-        if (r2.get(chunkKey(rid, 2)).length !== 12 + 1 + 500 + 16) throw new Error("ragged last chunk is the wrong size");
-
-        const back = new Uint8Array([...await read(0), ...await read(1), ...await read(2)]);
-        if (!same(back, bytes)) throw new Error("round trip corrupted the file");
-
-        // AAD binds each chunk to its index: a chunk decrypted at the wrong index
-        // must FAIL, not silently hand back scrambled bytes.
-        let swallowed = false;
-        try {
-            const dek = unseal(hexToBytes(sealedSeen), workerSecret, rid);
-            const key = await crypto.subtle.importKey("raw", dek, "AES-GCM", false, ["decrypt"]);
-            const body = r2.get(chunkKey(rid, 0));
-            await crypto.subtle.decrypt({ name: "AES-GCM", iv: body.subarray(0, NONCE_LEN), additionalData: aadFor(1) }, key, body.subarray(NONCE_LEN));
-            swallowed = true;
-        } catch { /* expected */ }
-        if (swallowed) throw new Error("a chunk decrypted under the wrong index — AAD binding is broken");
-
-        // Compressible payload: pack()'s other branch. Stored bytes must come in
-        // well under the plaintext and still round trip.
-        r2.clear();
-        const text = new Uint8Array(3000).fill(65);
-        writeFileSync(tmp, text);
-        const packed = await encryptAndUpload({ file: tmp, resourceId: rid, workerUrl: "http://stub", chunkSize: CHUNK });
-        const stored = [...r2.values()].reduce((n, b) => n + b.length, 0);
-        if (stored > text.length / 2) throw new Error(`compressible payload barely shrank: ${stored} of ${text.length}`);
-        const gzBack = new Uint8Array([...await read(0), ...await read(1), ...await read(2)]);
-        if (!same(gzBack, text)) throw new Error("gzip round trip corrupted the file");
-
-        // Delete frees every chunk, and a worker that refuses RAISES rather than
-        // reporting freed space the operator is still billed for.
-        if (await deleteResource({ workerUrl: "http://stub", uploadToken: "t", resourceId: rid, chunks: packed.chunks }) !== packed.chunks) throw new Error("deleteResource miscounted");
-        if (r2.size !== 0) throw new Error(`delete left ${r2.size} chunk(s) behind`);
-        globalThis.fetch = async () => ({ ok: false, status: 401, statusText: "Unauthorized" });
-        let quiet = false;
-        try { await deleteResource({ workerUrl: "http://stub", resourceId: rid, chunks: 2 }); quiet = true; } catch { /* expected */ }
-        if (quiet) throw new Error("a refused delete was swallowed — the ledger would free bytes still in R2");
-
-        console.log(`settle.js self-check ok — round trip, hash, ragged tail, AAD index binding, gzip ${stored}/${text.length} bytes, delete`);
-    } finally {
-        globalThis.fetch = realFetch;
-        rmSync(tmp, { force: true });
-    }
-}