@fangorn-network/westmarch 0.0.19-dev → 0.1.0

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

@@ -1 +0,0 @@
-import{t as e}from"./createLucideIcon-IPW50ckY.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,271 +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 10M-block windows, 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.
-//
-// ponytail: windows grow with the chain (1 + 8 at block 316M, ~0.2s). Index
-// the logs somewhere if that ever gets slow.
-
-import { parseAbi, parseAbiItem } from "viem";
-import { APP_EXTENSION } from "./apps.js";
-import { survey, comparable } from "./directory.js";
-import { rankDomains, zFloor, lexScore } from "../core/rank.js";
-
-export const CHAIN = {
-    chainId: 421614,
-    appRegistry: "0x11d228c4774af3d9cae3b4b6874a12576a1a83ec",
-    identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
-    // Each registry's first event (2026-10-05): nothing to read before it.
-    // Scanning from 0 instead was 32 windows per registry, ~5s of a 7.7s load.
-    appRegistryFrom: 311_639_205n,
-    identityFrom: 241_557_787n,
-    scan: (agentId) => `https://8004scan.io/agents/arbitrum-sepolia/${agentId}`,
-};
-
-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) };
-    }
-}
-
-// The public Arbitrum Sepolia RPC refuses an address+event getLogs spanning more
-// than 10M blocks (from 2026-10; one call from 0 worked before).
-const LOG_WINDOW = 10_000_000n;
-
-async function getLogsSince(client, start, filter) {
-    const head = await client.getBlockNumber();
-    const windows = [];
-    for (let from = start; from <= head; from += LOG_WINDOW) {
-        const to = from + LOG_WINDOW - 1n < head ? from + LOG_WINDOW - 1n : head;
-        windows.push(client.getLogs({ ...filter, fromBlock: from, toBlock: to }));
-    }
-    return (await Promise.all(windows)).flat();   // in window order: oldest first still holds
-}
-
-/**
- * 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.
- */
-export async function readDirectory(client, { chain = CHAIN, onUpdate = () => {} } = {}) {
-    const [bindLogs, regLogs] = await Promise.all([
-        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }),
-        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }),
-    ]);
-    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 });
-    }
-}

package/src/market/terms.js

@@ -1,200 +0,0 @@
-// Who gets paid, and how much, when something sells.
-//
-// An app owner registers terms; publishers join under them; a buyer pays once.
-// This file is the arithmetic in the middle, and it is the only revenue
-// mechanism in the whole architecture — discovery cannot be charged for (the
-// query never leaves the client and the index holds 4 KB per corpus), so a take
-// at settlement is the business model or there isn't one.
-//
-// Two layers, because they are set by different people at different times:
-//
-//   app terms   the owner's cut, fixed when the app is registered and hashed so
-//               a publisher can prove what they agreed to
-//   lineage     what a publisher owes UPSTREAM, declared per resource when they
-//               publish. Paid out of the publisher's share, never the app's:
-//               a derivative's author pays their sources, and the app's cut does
-//               not shrink because someone built on someone else.
-//
-// That second layer is the point. An agent buys three corpora, synthesises a
-// fourth, publishes it with lineage naming the three, and every later sale of
-// the derivative pays back up the chain. Knowledge in, concept out, concept
-// becomes knowledge someone else builds on — with the money following the
-// citations instead of stopping at the last hop.
-//
-// ponytail: BigInt base units, one level of lineage, no recursion. A derivative
-// OF a derivative declares its own immediate sources and each hop settles on its
-// own sale — walking the tree at settlement time would mean fetching a stranger's
-// terms mid-payment, and a payment that depends on someone else's server being
-// up is a payment that fails.
-
-const BPS = 10000n;
-const ADDR = /^0x[0-9a-fA-F]{40}$/;
-
-const addr = (a) => {
-    const s = String(a ?? "").toLowerCase();
-    if (!ADDR.test(s)) throw new Error(`not an address: ${a}`);
-    return s;
-};
-const bps = (n, what) => {
-    const v = BigInt(n ?? 0);
-    if (v < 0n || v > BPS) throw new Error(`${what} must be 0..10000 bps, got ${n}`);
-    return v;
-};
-
-/**
- * An app's terms, canonical.
- *
- * Canonical because the hash is the thing a publisher agrees to and a buyer can
- * check: same terms must produce the same bytes on any machine, in any key
- * order, forever. So: fixed field order, lowercase addresses, decimal strings
- * for numbers (JSON has no integers), and nothing else in the object.
- */
-export function appTerms({ appId, owner, appBps = 0, currency = "USDC", chainId = 421614 }) {
-    if (!appId) throw new Error("terms need an appId");
-    return {
-        v: 1,
-        appId: String(appId),
-        owner: addr(owner),
-        appBps: String(bps(appBps, "appBps")),
-        currency: String(currency),
-        chainId: Number(chainId),
-    };
-}
-
-/** Canonical bytes → sha-256. Async because that is the only hash both node and
- *  a browser have without a dependency. */
-export async function termsHash(t) {
-    const canon = JSON.stringify(appTerms(t));
-    const d = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canon));
-    return `0x${[...new Uint8Array(d)].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
-
-/** What a publisher owes upstream for one resource. Deduped by payee — the same
- *  source cited twice is one debt, not two, and merging is the only reading that
- *  cannot be gamed by repeating an entry. */
-export function lineage(entries = []) {
-    const by = new Map();
-    for (const e of entries) {
-        const to = addr(e.to);
-        by.set(to, { to, bps: (by.get(to)?.bps ?? 0n) + bps(e.bps, "lineage bps"), note: e.note ?? by.get(to)?.note ?? "" });
-    }
-    const out = [...by.values()];
-    const total = out.reduce((s, e) => s + e.bps, 0n);
-    if (total > BPS) throw new Error(`lineage owes ${total} bps of the publisher's share — more than all of it`);
-    return out.map((e) => ({ to: e.to, bps: String(e.bps), ...(e.note ? { note: e.note } : {}) }));
-}
-
-/**
- * One payment → the payouts it becomes.
- *
- * Integer base units end to end, and the dust is given to the publisher rather
- * than rounded away: the payouts MUST sum to exactly what the buyer paid, or
- * settlement is inventing or destroying money. Every share rounds down; the
- * publisher absorbs the difference, which is at most one base unit per payee.
- */
-export function splitPayment(amount, { terms, publisher, lineage: up = [] } = {}) {
-    const total = BigInt(amount);
-    if (total < 0n) throw new Error("amount must not be negative");
-    const t = appTerms(terms);
-    const pub = addr(publisher);
-
-    const payouts = [];
-    const appCut = (total * BigInt(t.appBps)) / BPS;
-    if (appCut > 0n) payouts.push({ to: t.owner, amount: appCut, why: `app ${t.appId} (${t.appBps} bps)` });
-
-    // Everything the app did not take is the publisher's, and upstream is paid
-    // out of that — so a publisher who cites nobody keeps it all, and one who
-    // builds on three sources pays them from their own half.
-    const publisherPool = total - appCut;
-    let owed = 0n;
-    for (const e of lineage(up)) {
-        const cut = (publisherPool * BigInt(e.bps)) / BPS;
-        if (cut === 0n) continue;
-        owed += cut;
-        payouts.push({ to: e.to, amount: cut, why: `upstream ${e.note || e.to.slice(0, 10)} (${e.bps} bps of the publisher's share)` });
-    }
-
-    const keeps = publisherPool - owed;
-    payouts.push({ to: pub, amount: keeps, why: "publisher" });
-
-    // Merge payees — an app owner who is also the publisher gets one payout, not
-    // two, and a downstream reconciliation that sees the same address twice has
-    // no way to tell a split from a double-pay.
-    const by = new Map();
-    for (const p of payouts) {
-        const at = by.get(p.to);
-        by.set(p.to, at ? { ...at, amount: at.amount + p.amount, why: `${at.why} + ${p.why}` } : p);
-    }
-    const merged = [...by.values()];
-    const sum = merged.reduce((s, p) => s + p.amount, 0n);
-    if (sum !== total) throw new Error(`payouts sum to ${sum}, buyer paid ${total}`);
-    return merged;
-}
-
-/** Human-readable, for a receipt or a quote. 6-decimal base units — every asset
- *  this settles on is 6-decimal, and a bare "50000" on a buy button is not a
- *  price anyone reads. */
-export const label = (base, currency = "USDC") => `${(Number(base) / 1e6).toFixed(2)} ${currency}`;
-
-// ── self-check: `node src/market/terms.js` ────────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/terms.js")) {
-    const A = "0x" + "a".repeat(40);   // app owner
-    const P = "0x" + "b".repeat(40);   // publisher
-    const S1 = "0x" + "c".repeat(40);  // a source
-    const S2 = "0x" + "d".repeat(40);  // another
-    const T = { appId: "fangorn.tv", owner: A, appBps: 1000 };
-    const at = (ps, to) => ps.find((p) => p.to === to)?.amount ?? 0n;
-
-    // The plain case: 10% to the app, the rest to whoever published it.
-    let ps = splitPayment(1_000_000n, { terms: T, publisher: P });
-    if (at(ps, A) !== 100_000n || at(ps, P) !== 900_000n) throw new Error(`plain split wrong: ${JSON.stringify(ps, (k, v) => typeof v === "bigint" ? String(v) : v)}`);
-
-    // A derivative: two sources, 20% and 5% OF THE PUBLISHER'S SHARE. The app's
-    // cut must not move — that is the whole reason lineage comes out of the
-    // publisher's half.
-    ps = splitPayment(1_000_000n, { terms: T, publisher: P, lineage: [{ to: S1, bps: 2000 }, { to: S2, bps: 500 }] });
-    if (at(ps, A) !== 100_000n) throw new Error("the app's cut must not shrink because the publisher cited someone");
-    if (at(ps, S1) !== 180_000n || at(ps, S2) !== 45_000n) throw new Error(`upstream is a share of 900000: ${at(ps, S1)}/${at(ps, S2)}`);
-    if (at(ps, P) !== 675_000n) throw new Error(`publisher keeps the rest: ${at(ps, P)}`);
-
-    // Money is neither created nor destroyed, at any amount.
-    for (const amt of [0n, 1n, 3n, 7n, 999n, 1_000_001n, 123_456_789n]) {
-        const out = splitPayment(amt, { terms: T, publisher: P, lineage: [{ to: S1, bps: 3333 }, { to: S2, bps: 3333 }] });
-        const sum = out.reduce((s, p) => s + p.amount, 0n);
-        if (sum !== amt) throw new Error(`${amt} split into ${sum}`);
-        if (out.some((p) => p.amount < 0n)) throw new Error(`negative payout at ${amt}`);
-    }
-
-    // Dust goes to the publisher, never to rounding.
-    ps = splitPayment(7n, { terms: { ...T, appBps: 3333 }, publisher: P });
-    if (at(ps, A) !== 2n || at(ps, P) !== 5n) throw new Error(`dust must land on the publisher: ${JSON.stringify(ps.map((p) => [p.to.slice(0, 4), String(p.amount)]))}`);
-
-    // One payee, one payout: an app owner who publishes under their own app.
-    ps = splitPayment(1_000_000n, { terms: T, publisher: A });
-    if (ps.length !== 1 || at(ps, A) !== 1_000_000n) throw new Error("the same address must be paid once, not twice");
-
-    // Citing the same source twice is one debt.
-    ps = splitPayment(1_000_000n, { terms: T, publisher: P, lineage: [{ to: S1, bps: 1000 }, { to: S1, bps: 1000 }] });
-    if (at(ps, S1) !== 180_000n) throw new Error(`a repeated citation must merge, not double-pay: ${at(ps, S1)}`);
-
-    // Terms are refused, not silently clamped.
-    for (const bad of [{ ...T, appBps: 10001 }, { ...T, appBps: -1 }, { ...T, owner: "0xnope" }, { appId: "", owner: A }]) {
-        let threw = false;
-        try { splitPayment(1n, { terms: bad, publisher: P }); } catch { threw = true; }
-        if (!threw) throw new Error(`bad terms must throw: ${JSON.stringify(bad)}`);
-    }
-    let threw = false;
-    try { lineage([{ to: S1, bps: 6000 }, { to: S2, bps: 6000 }]); } catch { threw = true; }
-    if (!threw) throw new Error("a publisher cannot owe more than they have");
-
-    // The hash is what a publisher agreed to: stable across key order, and it
-    // moves the moment a single term does.
-    const h1 = await termsHash(T);
-    const h2 = await termsHash({ owner: A, appBps: 1000, appId: "fangorn.tv" });
-    if (h1 !== h2) throw new Error("key order must not change the hash");
-    if (h1 === await termsHash({ ...T, appBps: 1001 })) throw new Error("a changed cut must change the hash");
-    if (!/^0x[0-9a-f]{64}$/.test(h1)) throw new Error(`hash shape: ${h1}`);
-
-    console.log("terms.js self-check ok — app cut fixed, lineage paid from the publisher's share, payouts always sum to what was paid, "
-        + "dust to the publisher, repeated payees merged, bad terms refused, terms hash canonical");
-}