@fangorn-network/westmarch 2026.10.29 → 2026.11.4-dev

package/site/worker.js

@@ -13,25 +13,21 @@
 //                         show it inline. Source sites forbid framing and send no CORS, so the
 //                         page cannot fetch or frame them itself. Only hosts the app's own
 //                         records link to (each domain's `link_hosts`), only PDFs, cached a day.
-//   GET /paid/<item id>   with CONFIG.paid: 402 + the price (x402 v2); with a valid
-//                         PAYMENT-SIGNATURE header, the facilitator verifies and settles it, then
-//                         the record's KEY is returned
-//   POST /paid {ids}      many keys for one price, paid by one payment or several (vouchers).
-//                         Its 402 carries the Bazaar extension, so the facilitator lists it on
-//                         the first sale; /openapi.json and /.well-known/x402 name it for x402scan
+//   GET /paid/<publisher>/<repo>/<id>   with CONFIG.paid: an x402 v2 quote for one record its
+//                         publisher sells (scheme "fangorn", from the record's signed terms). With a
+//                         PAYMENT-SIGNATURE header, the facilitator (Barliman) verifies and settles it
 //   anything else         the static site (the stock page, the card)
 //
-// The paid records are not here. Each is already in the app's committed rows on IPFS,
-// encrypted (`paid_ct`, AES-256-GCM), with the sha256 of its plaintext beside it. This worker
-// sells only the key, HMAC-SHA256(PAID_SECRET, id): the buyer holds the ciphertext before
-// paying, so nobody pays for a record that does not exist, and decrypts and checks it after.
+// The app sells nothing of its own. A publisher seals a record's fields and signs its terms
+// (`fangorn commit --paid`); this worker only quotes them. After paying, the buyer proves it to
+// the relay and asks the record's key server for the key: nothing secret passes through here.
 //
 // Bindings: VIEW (R2), AI (Workers AI), ASSETS (the site), CONFIG (a JSON var: app, name,
-// description, fromBlock, schema, repos, paid, deployment), and optionally RPC_URL and IPFS_GATEWAY
-// (vars) and PAID_SECRET (a secret).
+// description, fromBlock, schema, repos, paid, facilitator, deployment), and optionally RPC_URL
+// and IPFS_GATEWAY (vars).
 
-import { Fangorn, FangornConfig, SupportedNetworks, repoExcluded } from "@fangorn-network/sdk";
-import { createPublicClient, http } from "viem";
+import { Fangorn, FangornConfig, SupportedNetworks } from "@fangorn-network/sdk";
+import { createPublicClient, http, parseAbi } from "viem";
 import { generatePrivateKey } from "viem/accounts";
 import { EMBED_MODEL, DOCUMENT, QUERY, matryoshka } from "../src/core/embed.js";
 import { configure, resetShard } from "../src/core/shard.js";
@@ -74,35 +70,28 @@ export async function takeLock(bucket, now = Date.now()) {
 const network = () => SupportedNetworks[CONFIG.network] ?? FangornConfig;
 
 function reader(env) {
-    // CONFIG.deployment: another deployment's addresses (and appRegistryFromBlock as a string),
+    // CONFIG.deployment: another deployment's addresses (and fromBlock as a string),
     // for a testnet fork or a local chain. Absent, the network's.
     const d = CONFIG.deployment ?? {};
-    const config = { ...network(), ...d, ...(d.appRegistryFromBlock ? { appRegistryFromBlock: BigInt(d.appRegistryFromBlock) } : {}),
+    const config = { ...network(), ...d, ...(d.fromBlock != null ? { fromBlock: BigInt(d.fromBlock) } : {}),
                      ...(env.RPC_URL ? { rpcUrl: env.RPC_URL } : {}) };
-    const fangorn = Fangorn.create({ privateKey: generatePrivateKey(), config, appId: CONFIG.app,
+    const fangorn = Fangorn.create({ privateKey: generatePrivateKey(), config,
         storage: { signedUrl: env.IPFS_GATEWAY ? { gateway: env.IPFS_GATEWAY } : {} } });
     return { fangorn, chain: createPublicClient({ chain: config.chain, transport: http(config.rpcUrl) }) };
 }
 
 /**
- * What the app presents now, kept across runs in R2: each run reads only the updates since
- * the last, then asks which repos the app presents: its members' (`presents`), less what it
- * excludes. Neither membership nor exclusions move a head, so they are read, not followed.
- * ponytail: reads every publisher's updates, and 4 contract reads per repo per run; follow
- * the app's members and ExclusionChanged events when an app holds enough repos to show it.
+ * Every repo at its latest head, kept across runs in R2: each run reads only the updates
+ * since the last. publishView narrows it to the repos the app lists.
  */
 export async function presented({ fangorn, chain }, state) {
     const to = await chain.getBlockNumber();
-    const from = state.block == null ? BigInt(CONFIG.fromBlock ?? network().appRegistryFromBlock) : BigInt(state.block) + 1n;
-    const app = fangorn.getAppId();
+    const from = state.block == null ? BigInt(CONFIG.fromBlock ?? network().fromBlock) : BigInt(state.block) + 1n;
     const registry = fangorn.getRegistry();
     if (from <= to) for (const e of await registry.log({}, from, to))
         state.repos[`${e.publisher.toLowerCase()}/${e.repo}`] = { owner: e.publisher, repo: e.repo, root: e.head };
     state.block = String(to);
-    const all = Object.values(state.repos);
-    const kept = await Promise.all(all.map(async (r) => await registry.presents(app, r.owner)
-        && !(await repoExcluded(registry, app, { publisher: r.owner, repo: r.repo }))));
-    return all.filter((_, i) => kept[i]);
+    return Object.values(state.repos);
 }
 
 export async function index(env, { log = console.log } = {}) {
@@ -112,12 +101,9 @@ export async function index(env, { log = console.log } = {}) {
     try {
         const state = (await (await env.VIEW.get(STATE))?.json()) ?? { block: null, repos: {} };
         const r = reader(env);
-        // Imported here: x402.js's self-check imports this module, and a cycle at load would deadlock it.
-        const { openRow } = await import("../src/agent/x402.js");
         const report = await publishView({
             fangorn: r.fangorn, app: CONFIG.app, schema: CONFIG.schema, repos: CONFIG.repos, store: r2Store(env.VIEW),
             presented: await presented(r, state), embedBatch: encode(env, DOCUMENT), embedder: await embedderOf(env), log,
-            ...(CONFIG.private ? { open: (p) => openRow(env.PAID_SECRET, p) } : {}),
         });
         await env.VIEW.put(STATE, JSON.stringify(state));
         log(`index: through block ${state.block}, ${Object.keys(report).length} domain(s) changed`);
@@ -167,7 +153,7 @@ async function tools(env, origin) {
     return mcp.tools;
 }
 
-export async function mcpCall(env, origin, msg, request = null) {
+export async function mcpCall(env, origin, msg) {
     const ok = (result) => ({ jsonrpc: "2.0", id: msg.id, result });
     switch (msg.method) {
         case "initialize": return ok({
@@ -177,21 +163,11 @@ export async function mcpCall(env, origin, msg, request = null) {
             instructions: `${CONFIG.description ?? ""} Call describe first, then search.`.trim(),
         });
         case "ping": return ok({});
-        case "tools/list": {
-            const t = await tools(env, origin), X = CONFIG.private;
-            const price = X && `${Number(X.call) / 10 ** (X.decimals ?? 6)} ${X.symbol ?? "USDC"}`;
-            return ok({ tools: (t ? t.tools : []).map((d) => !X || FREE_TOOLS.has(d.name) ? d
-                : { ...d, description: `${d.description} Paid: ${price} a call over x402, or a pass from POST ${origin}/pass.` }) });
-        }
+        case "tools/list": return ok({ tools: (await tools(env, origin))?.tools ?? [] });
         case "tools/call": {
-            const t = await tools(env, origin), name = msg.params?.name;
-            const run = async () => {
-                try { return await t.call(name, msg.params?.arguments ?? {}); }
-                catch (e) { return { isError: true, content: [{ type: "text", text: e?.message ?? String(e) }] }; }
-            };
-            const tool = t.tools.find((d) => d.name === name);
-            if (!CONFIG.private || !tool || FREE_TOOLS.has(name) || (request && await passOf(env, request))) return ok(await run());
-            return ok(await paidCall(origin, tool, msg.params?._meta?.["x402/payment"], run));
+            const t = await tools(env, origin);
+            try { return ok(await t.call(msg.params?.name, msg.params?.arguments ?? {})); }
+            catch (e) { return ok({ isError: true, content: [{ type: "text", text: e?.message ?? String(e) }] }); }
         }
         default: return { jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: `unknown method ${msg.method}` } };
     }
@@ -203,7 +179,7 @@ async function serveMcp(request, env, url) {
     try { msg = await request.json(); } catch { return json({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "not JSON" } }, 400); }
     if (Array.isArray(msg)) return json({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "one message per request" } }, 400);
     if (msg.id === undefined) return new Response(null, { status: 202, headers: CORS });   // a notification
-    return json(await mcpCall(env, url.origin, msg, request));
+    return json(await mcpCall(env, url.origin, msg));
 }
 
 const CORS = { "access-control-allow-origin": "*", "access-control-allow-headers": "PAYMENT-SIGNATURE, authorization, content-type",
@@ -233,240 +209,82 @@ async function doc(request, env, url) {
     return res;
 }
 
-/** A record's key: HMAC-SHA256(PAID_SECRET, id), hex. The same derivation as the sources that
- *  encrypt (and x402.js's paidKey). */
-async function keyFor(env, id) {
-    if (!env.PAID_SECRET) throw new Error("PAID_SECRET is not set (wrangler pages secret put PAID_SECRET)");
-    const k = await crypto.subtle.importKey("raw", new TextEncoder().encode(env.PAID_SECRET), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-    const mac = new Uint8Array(await crypto.subtle.sign("HMAC", k, new TextEncoder().encode(id)));
-    return [...mac].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-const keysFor = async (env, ids) => Object.fromEntries(await Promise.all(ids.map(async (id) => [id, await keyFor(env, id)])));
-
-// ── x402 v2 ───────────────────────────────────────────────────────────────────
-// Over HTTP the 402's PaymentRequired is in the PAYMENT-REQUIRED header (base64 JSON) and in the
-// body, the buyer pays in PAYMENT-SIGNATURE, the settlement comes back in PAYMENT-RESPONSE. Over
-// MCP (a private app's tools) the same objects ride in the tool result and `_meta`.
-// Only a payment's `payload` (the signed EIP-3009 authorization) is taken from the buyer: what
-// goes to the facilitator is rebuilt here around it, so `accepted`, `resource` and the Bazaar
-// extension are always this worker's, including on vouchers signed weeks ago.
-//
-// A sale is what one route sells: its terms `P` (CONFIG.paid or CONFIG.private: network, asset,
-// payTo, facilitator, the token's EIP-712 name and version), what a catalog says it is
-// (`resource`), and its Bazaar entry, if the facilitator should list it.
+// ── paid records ─────────────────────────────────────────────────────────────
+// x402 v2 over HTTP: the 402's PaymentRequired in the PAYMENT-REQUIRED header (base64 JSON) and the
+// body, the buyer's payment in PAYMENT-SIGNATURE, the settlement back in PAYMENT-RESPONSE. Only the
+// payment's `payload` is taken from the buyer: the requirement sent to the facilitator is ours.
 
-const MAX_BATCH = 1000, MAX_PAYMENTS = 10;
 const b64json = (o) => btoa(JSON.stringify(o));
-const requirement = (P, amount) => ({ scheme: "exact", network: P.network, amount: String(amount), asset: P.asset,
-    payTo: P.payTo, maxTimeoutSeconds: 120, extra: { name: P.name, version: P.version } });
-const resource = (url, description) => ({ url, mimeType: "application/json", serviceName: CONFIG.name, description });
-const lead = (P) => (P.description ? `${P.description}. ` : "");
-
-const SCHEMA = "https://json-schema.org/draft/2020-12/schema";
-const OUTPUT = { type: "object", required: ["type"], properties: { type: { type: "string" }, example: { type: "object" } } };
-/** A Bazaar entry for a POST route taking JSON. */
-const httpBazaar = (body, bodySchema, example) => ({
-    info: { input: { type: "http", method: "POST", bodyType: "json", body }, output: { type: "json", example } },
-    schema: { $schema: SCHEMA, type: "object", required: ["input"], properties: {
-        input: { type: "object", required: ["type", "method", "bodyType", "body"], additionalProperties: false, properties: {
-            type: { type: "string", const: "http" }, method: { type: "string", enum: ["POST"] }, bodyType: { type: "string", enum: ["json"] }, body: bodySchema } },
-        output: OUTPUT } },
-});
-/** A Bazaar entry for one MCP tool: listed by (the server's URL, its name). */
-const mcpBazaar = (tool) => ({
-    info: { input: { type: "mcp", toolName: tool.name, description: tool.description, inputSchema: tool.inputSchema, transport: "streamable-http" } },
-    schema: { $schema: SCHEMA, type: "object", required: ["input"], properties: {
-        input: { type: "object", required: ["type", "toolName", "inputSchema"], additionalProperties: false, properties: {
-            type: { type: "string", const: "mcp" }, toolName: { type: "string" }, description: { type: "string" },
-            transport: { type: "string", enum: ["streamable-http", "sse"] }, inputSchema: { type: "object" }, example: { type: "object" } } },
-        output: OUTPUT } },
-});
-
-// The keys to sealed records. Only POST /paid is listed: GET /paid/<id>'s URL differs per record,
-// and each would be listed apart.
-const KEYS_BAZAAR = httpBazaar({ ids: ["<record id>"] },
-    { type: "object", required: ["ids"], properties: { ids: { type: "array", items: { type: "string" }, minItems: 1, maxItems: MAX_BATCH } } },
-    { keys: { "<record id>": "<hex key>" }, missing: [], receipts: [], paid: [] });
-const keySale = (url, listed) => ({ P: CONFIG.paid, bazaar: listed ? KEYS_BAZAAR : null,
-    resource: resource(url.href, `${lead(CONFIG.paid)}Sells the keys to ${CONFIG.name}'s sealed records (AES-256-GCM, in its rows as `
-        + `paid_ct). Find records and their ids with the MCP server at ${url.origin}/mcp.`) });
-
-// A private app's pass, and its tools one call at a time.
-const PASS_BAZAAR = httpBazaar({}, { type: "object" }, { token: "<pass>", expires: 1900000000 });
-const days = (s) => Math.round(s / 86400);
-const passSale = (url) => ({ P: CONFIG.private, bazaar: PASS_BAZAAR,
-    resource: resource(url.href, `${lead(CONFIG.private)}A ${days(CONFIG.private.pass.seconds)}-day pass to ${CONFIG.name}: every tool of its MCP server `
-        + `at ${url.origin}/mcp and its view, with Authorization: Bearer <token>.`) });
-const callSale = (origin, tool) => ({ P: CONFIG.private, bazaar: mcpBazaar(tool),
-    resource: resource(`${origin}/mcp`, `${lead(CONFIG.private)}${CONFIG.name}'s ${tool.name} tool, one call. A pass (POST ${origin}/pass) covers every call.`) });
-
-const paymentRequired = (sale, amount, error) => ({ x402Version: 2, error, resource: sale.resource, accepts: [requirement(sale.P, amount)],
-    ...(sale.bazaar ? { extensions: { bazaar: sale.bazaar } } : {}) });
-
-/** 402 with the price of `amount`; `more` rides in the body only. */
-function quote(sale, amount, error, more = {}) {
-    const required = paymentRequired(sale, amount, error);
-    return json({ ...required, ...more }, 402, { "payment-required": b64json(required) });
-}
 
-/** The PaymentPayload the facilitator sees: the buyer's signed `payload`, the rest ours. */
-const payloadOf = (sale, p, amount) => ({ x402Version: 2, resource: sale.resource, accepted: requirement(sale.P, amount),
-    payload: p?.payload, ...(sale.bazaar ? { extensions: { bazaar: sale.bazaar } } : {}) });
-
-async function facilitator(P, path, paymentPayload) {
-    // A network failure is an answer too: thrown, it would turn a half-settled batch into a 500.
-    let r;
-    try {
-        r = await fetch(`${P.facilitator}/${path}`, {
-            method: "POST", headers: { "content-type": "application/json" },
-            body: JSON.stringify({ x402Version: 2, paymentPayload, paymentRequirements: paymentPayload.accepted }),
-        });
-    } catch (e) { return { error: `facilitator ${path}: ${e.message}` }; }
-    const text = await r.text();
-    try { return JSON.parse(text); } catch { return { error: `facilitator ${path}: HTTP ${r.status} ${text.slice(0, 200)}` }; }
+/**
+ * A record's quote: `{ requirement, body }`, or null when its publisher doesn't sell it.
+ * `read(publisher, repo, id)` → the record's payload, or null. `chain`: chainId, registry, usdc and
+ * its EIP-712 name and version. The facilitator's /supported names the referrer the buyer signs in.
+ */
+export async function quoteOf({ publisher, repo, id, read, chain, facilitator }) {
+    const payload = await read(publisher, repo, id);
+    const t = payload?.["@terms"];
+    if (!t?.terms || !t.signature) return null;
+    const fields = Object.fromEntries(Object.entries(payload).filter(([, v]) => v?.["@type"] === "handle" && v.gadget === "field-v1"));
+    const generation = Object.values(fields)[0]?.generation;
+    if (generation == null) return null;
+    const deposit = await read(publisher, repo, `@deposit/${generation}`);
+    if (!deposit) return null;
+    const network = `eip155:${chain.chainId}`;
+    const kind = (await (await fetch(`${facilitator}/supported`)).json()).kinds?.find((k) => k.scheme === "fangorn" && k.network === network);
+    if (!kind?.extra?.referrer) throw new Error(`${facilitator} does not settle scheme "fangorn" on ${network}`);
+    return {
+        requirement: { scheme: "fangorn", network, amount: String(t.terms.price), asset: chain.usdc, payTo: chain.registry, maxTimeoutSeconds: 300,
+                       extra: { terms: t.terms, signature: t.signature, referrer: kind.extra.referrer, name: chain.usdcName, version: chain.usdcVersion } },
+        body: { record: { publisher, repo, id }, fields, deposit, relay: facilitator },
+    };
 }
 
-const signatures = (request) => {
-    const header = request.headers.get("PAYMENT-SIGNATURE");
-    if (!header) return { error: "PAYMENT-SIGNATURE header is required" };
-    try { return { payments: [JSON.parse(atob(header))].flat() }; } catch { return { error: "PAYMENT-SIGNATURE is not base64 JSON" }; }
-};
-
-/** One payment for `amount`, verified and settled: `{settled, payer}`, or `{refused}`, the 402 to answer with. */
-async function payOnce(request, sale, amount) {
-    const { payments, error } = signatures(request);
-    if (error) return { refused: quote(sale, amount, error) };
-    if (payments.length !== 1) return { refused: quote(sale, amount, "one payment, not several") };
-    const payment = payloadOf(sale, payments[0], amount);
-    const verified = await facilitator(sale.P, "verify", payment);
-    if (!verified.isValid) return { refused: quote(sale, amount, verified.invalidReason ?? verified.error ?? "payment did not verify") };
-    const settled = await facilitator(sale.P, "settle", payment);
-    if (!settled.success) return { refused: quote(sale, amount, settled.errorReason ?? settled.error ?? "settlement failed") };
-    return { settled, payer: settled.payer ?? payment.payload?.authorization?.from };
+let chainInfo = null;
+/** The SettlementRegistry and its USDC (address, EIP-712 name and version), read once per isolate. */
+function chainOf(fangorn) {
+    return (chainInfo ??= (async () => {
+        const c = fangorn.getConfig(), registry = fangorn.getSettlementRegistry().getAddress();
+        const pub = createPublicClient({ transport: http(c.rpcUrl) });
+        const usdc = await pub.readContract({ address: registry, abi: parseAbi(["function usdc() view returns (address)"]), functionName: "usdc" });
+        const str = (fn, fallback) => pub.readContract({ address: usdc, abi: parseAbi([`function ${fn}() view returns (string)`]), functionName: fn }).catch(() => fallback);
+        return { chainId: c.chain.id, registry, usdc, usdcName: await str("name", "USDC"), usdcVersion: await str("version", "2") };
+    })().catch((e) => { chainInfo = null; throw e; }));
 }
 
 async function sell(request, env, url) {
-    const id = decodeURIComponent(url.pathname.slice("/paid/".length));
-    if (!id) return json({ error: "no id" }, 400);
-    const { settled, refused } = await payOnce(request, keySale(url, false), CONFIG.paid.price);
-    if (refused) return refused;
-    return json({ id, key: await keyFor(env, id) }, 200, { "payment-response": b64json(settled) });
-}
-
-// POST /paid {ids}: many keys, one price. 402 with the total; then PAYMENT-SIGNATURE may be one
-// payment or a JSON array of them (an agent's vouchers) that add up to it. The only subrequests
-// are the facilitator's (2 per payment, 50 on the free plan), hence MAX_PAYMENTS; keys cost nothing.
-async function sellBatch(request, env, url) {
-    const P = CONFIG.paid, sale = keySale(url, true);
-    const { payments, error } = signatures(request);
-    let ids;
-    try { ids = [...new Set((await request.json()).ids)].filter((x) => typeof x === "string"); } catch { ids = null; }
-    if (!ids?.length || ids.length > MAX_BATCH) {
-        // A probe (x402scan, a Bazaar crawler) posts no body: it gets the price of one record.
-        if (error) return quote(sale, P.price, `${error}; the body is {"ids": [...]}, ${P.price} per id`);
-        return json({ error: `body must be {"ids": [...]}, between 1 and ${MAX_BATCH} ids per purchase` }, 400);
-    }
-    const found = ids, missing = [];
-    const total = BigInt(P.price) * BigInt(found.length);
-    const refuse = (error, more = {}) => quote(sale, total, error, { found, missing, ...more });
-    if (error) return refuse(error);
-    if (payments.length > MAX_PAYMENTS) return refuse(`at most ${MAX_PAYMENTS} payments per purchase`);
-    const auths = payments.map((p) => p?.payload?.authorization ?? {});
-    if (new Set(auths.map((a) => a.nonce)).size !== auths.length) return refuse("a payment is repeated");
-    if (auths.some((a) => String(a.to).toLowerCase() !== P.payTo.toLowerCase())) return refuse("a payment is not to this app");
-    let sum = 0n;
-    try { for (const a of auths) sum += BigInt(a.value); } catch { return refuse("a payment has no amount"); }
-    if (sum !== total) return refuse(`payments add up to ${sum}, the price is ${total}`);
-    const signed = payments.map((p, i) => payloadOf(sale, p, auths[i].value));
-    for (const [i, p] of signed.entries()) {
-        const v = await facilitator(P, "verify", p);
-        if (!v.isValid) return refuse(`payment ${i + 1}: ${v.invalidReason ?? v.error ?? "did not verify"}`);
-    }
-    // Settle one by one. A spent voucher (or one the wallet can no longer cover) passes verify
-    // and fails here. If that happens after others settled, the buyer still gets what the
-    // settled money pays for, never more: a spent voucher riding along with a fresh one buys
-    // only what the fresh one pays for. `paid` and `rejected` name the vouchers (by nonce) so
-    // the buyer's stack can drop them either way.
-    const receipts = [];
-    let settled = 0n;
-    for (const [i, p] of signed.entries()) {
-        const s = await facilitator(P, "settle", p);
-        if (!s.success) {
-            const error = `payment ${i + 1}: ${s.errorReason ?? s.error ?? "settlement failed"}`;
-            if (!receipts.length) return refuse(error, { rejected: [auths[i].nonce] });
-            const n = Number(settled / BigInt(P.price));
-            return json({ keys: await keysFor(env, found.slice(0, n)), missing, undelivered: found.slice(n), receipts, error,
-                paid: auths.slice(0, i).map((a) => a.nonce), rejected: [auths[i].nonce] });
-        }
-        receipts.push(s);
-        settled += BigInt(auths[i].value);
-    }
-    return json({ keys: await keysFor(env, found), missing, receipts, paid: auths.map((a) => a.nonce) });
-}
-
-// ── a private app ─────────────────────────────────────────────────────────────
-// CONFIG.private: the rows are sealed on chain (x402.js's sealRow), opened by the cron with
-// PAID_SECRET, and the view is served only with access: a pass bought at POST /pass (one x402
-// payment, a token good for `pass.seconds`), or, on /mcp, one x402 payment per tool call. What a
-// stranger needs to decide whether to pay stays free: the card, the catalog (views, counts) and
-// the describe tool.
-// ponytail: a pass is a signed token, not a record: it cannot be revoked before it expires, and
-// changing PAID_SECRET voids every pass (and every key). A list of revoked payers in R2 if that matters.
-
-const FREE_VIEW = new Set(["cdn/catalog"]), FREE_TOOLS = new Set(["describe"]);
-const b64url = (bytes) => btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-const unb64url = (s) => Uint8Array.from(atob(s.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0));
-const passKey = (env) => crypto.subtle.importKey("raw", new TextEncoder().encode(`${env.PAID_SECRET}:pass`), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
-
-async function issuePass(env, payer, exp) {
-    const claims = b64url(new TextEncoder().encode(JSON.stringify({ app: CONFIG.app, sub: payer, exp })));
-    return `${claims}.${b64url(new Uint8Array(await crypto.subtle.sign("HMAC", await passKey(env), new TextEncoder().encode(claims))))}`;
-}
-
-/** The pass a request carries (Authorization: Bearer), if it is this app's and unexpired. */
-async function passOf(env, request) {
-    const m = /^Bearer ([\w-]+)\.([\w-]+)$/.exec(request.headers.get("authorization") ?? "");
-    if (!m || !env.PAID_SECRET) return null;
-    try {
-        if (!await crypto.subtle.verify("HMAC", await passKey(env), unb64url(m[2]), new TextEncoder().encode(m[1]))) return null;
-        const c = JSON.parse(new TextDecoder().decode(unb64url(m[1])));
-        return c.app === CONFIG.app && c.exp > Date.now() / 1000 ? c : null;
-    } catch { return null; }
-}
-
-// POST /pass: one payment, a pass. A probe posts nothing and gets the price.
-async function sellPass(request, env, url) {
-    const X = CONFIG.private;
-    const { settled, payer, refused } = await payOnce(request, passSale(url), X.pass.price);
-    if (refused) return refused;
-    const expires = Math.floor(Date.now() / 1000) + X.pass.seconds;
-    return json({ token: await issuePass(env, payer, expires), expires,
-        use: `Authorization: Bearer <token> on ${url.origin}/mcp and ${url.origin}/view/…` }, 200, { "payment-response": b64json(settled) });
-}
-
-/** A paid tool call over x402's MCP transport: verify, run, settle. A call that fails is not
- *  charged (its payment is never settled), and a settlement that fails returns no content. */
-async function paidCall(origin, tool, payment, run) {
-    const X = CONFIG.private, sale = callSale(origin, tool);
+    if (!CONFIG.facilitator) return json({ error: "this app names no facilitator (CONFIG.facilitator)" }, 503);
+    const [publisher, repo, ...rest] = url.pathname.slice("/paid/".length).split("/").map(decodeURIComponent);
+    const id = rest.join("/");
+    if (!/^0x[0-9a-fA-F]{40}$/.test(publisher ?? "") || !repo || !id) return json({ error: "GET /paid/<publisher>/<repo>/<record id>" }, 400);
+    const { fangorn } = reader(env);
+    const read = async (p, r, i) => (await fangorn.engine.readRecord(p, r, i).catch(() => null))?.payload ?? null;
+    let q;
+    try { q = await quoteOf({ publisher, repo, id, read, chain: await chainOf(fangorn), facilitator: CONFIG.facilitator }); }
+    catch (e) { return json({ error: e.message }, 502); }
+    if (!q) return json({ error: "not for sale" }, 404);
+
+    const resource = { url: url.href, mimeType: "application/json", serviceName: CONFIG.name, description: `${CONFIG.name}: ${id}` };
     const required = (error) => {
-        const pr = paymentRequired(sale, X.call, error);
-        return { isError: true, structuredContent: pr, content: [{ type: "text", text: JSON.stringify(pr) }] };
+        const r = { x402Version: 2, error, resource, accepts: [q.requirement] };
+        return json({ ...r, ...q.body }, 402, { "payment-required": b64json(r) });
     };
-    if (!payment) return required(`${tool.name} is paid: one x402 payment per call in _meta["x402/payment"], or a pass from POST ${origin}/pass`);
-    const p = payloadOf(sale, payment, X.call);
-    const verified = await facilitator(X, "verify", p);
+    const header = request.headers.get("PAYMENT-SIGNATURE");
+    if (!header) return required("payment required");
+    let payment;
+    try { payment = JSON.parse(atob(header)); } catch { return required("PAYMENT-SIGNATURE is not base64 JSON"); }
+    const paymentPayload = { x402Version: 2, resource, accepted: q.requirement, payload: payment?.payload };
+    const call = (path) => fetch(`${CONFIG.facilitator}/${path}`, { method: "POST", headers: { "content-type": "application/json" },
+        body: JSON.stringify({ x402Version: 2, paymentPayload, paymentRequirements: q.requirement }) })
+        .then((r) => r.json()).catch((e) => ({ error: `facilitator ${path}: ${e.message}` }));
+    const verified = await call("verify");
     if (!verified.isValid) return required(verified.invalidReason ?? verified.error ?? "payment did not verify");
-    const result = await run();
-    // view-tools answers a miss ("not in a loaded view") with {error} in the text, not isError.
-    let missed = false;
-    try { missed = !!JSON.parse(result.content?.[0]?.text ?? "{}").error; } catch { /* not JSON: an answer */ }
-    if (result.isError || missed) return result;
-    const settled = await facilitator(X, "settle", p);
+    const settled = await call("settle");
     if (!settled.success) return required(settled.errorReason ?? settled.error ?? "settlement failed");
-    return { ...result, _meta: { ...result._meta, "x402/payment-response": settled } };
+    return json({ ...q.body, settlement: settled }, 200, { "payment-response": b64json(settled) });
 }
 
-const BY_ORIGIN = new Set(["/.well-known/agent-card.json", "/openapi.json", "/.well-known/x402"]);
+const BY_ORIGIN = new Set(["/.well-known/agent-card.json"]);
 
 const worker = {
     async fetch(request, env) {
@@ -474,16 +292,9 @@ const worker = {
         const url = new URL(request.url);
         const p = url.pathname;
         if (request.method === "OPTIONS") return new Response(null, { status: 204, headers: CORS });
-        if (p.startsWith("/view/")) {
-            const path = p.slice("/view/".length);
-            if (CONFIG.private && !FREE_VIEW.has(path) && !await passOf(env, request))
-                return json({ error: `${CONFIG.name}'s data is private: send Authorization: Bearer <pass>, from POST ${url.origin}/pass (x402)` }, 401);
-            return viewFile(env, path);
-        }
-        if (p === "/pass" && request.method === "POST") return CONFIG.private ? sellPass(request, env, url) : json({ error: "nothing is sold here" }, 404);
+        if (p.startsWith("/view/")) return viewFile(env, p.slice("/view/".length));
         if (p === "/mcp") return serveMcp(request, env, url);
         if (p === "/doc") return doc(request, env, url);
-        if (p === "/paid" && request.method === "POST") return CONFIG.paid ? sellBatch(request, env, url) : json({ error: "nothing is sold here" }, 404);
         if (p.startsWith("/paid/")) return CONFIG.paid ? sell(request, env, url) : json({ error: "nothing is sold here" }, 404);
 
         let res = await env.ASSETS.fetch(request);
@@ -552,7 +363,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
             rec("c1", TAG, { sku: "a1", name: "Oak table", about: "a solid oak dining table", doc: "https://docs.example/oak.pdf" }),
             rec("c2", TAG, { sku: "b2", name: "Brass lamp", about: "a brass reading lamp" })] },
     };
-    const fangorn = localFangorn(chain, { appId: APP, owner: OWNER });
+    const fangorn = localFangorn(chain);
     await publishView({ fangorn, app: APP, schema: CONFIG.schema, store: r2Store(VIEW), embedBatch: encode(env, DOCUMENT), embedder: WORKER_EMBEDDER, log: () => {} });
     eq([calls[0].model, calls[0].text[0].startsWith(DOCUMENT)], [AI_MODEL, true], "documents go to the AI binding with the document prompt");
 
@@ -563,8 +374,11 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     for (const t of ["describe", "search", "get", "similar", "count", "browse"]) if (!names.includes(t)) throw new Error(`missing tool ${t}: ${names}`);
     const described = JSON.parse((await call("tools/call", { name: "describe", arguments: {} })).result.content[0].text);
     eq(described.views.map((v) => v.rows), [2], "describe reads the catalog from R2");
+    eq(described.views[0].repos.map((r) => [r.publisher, r.repo, r.rows]), [[PUB, "shop", 2]], "describe names each repo's publisher");
     const found = JSON.parse((await call("tools/call", { name: "search", arguments: { query: "reading lamp", limit: 1 } })).result.content[0].text);
-    eq([found.ranked_by, found.hits[0].title], ["meaning", "Brass lamp"], "search ranks by meaning, the query embedded by the same runtime");
+    eq([found.ranked_by, found.hits[0].title, found.hits[0].publisher], ["meaning", "Brass lamp", PUB], "search ranks by meaning, the query embedded by the same runtime; a hit names its publisher");
+    const theirs = JSON.parse((await call("tools/call", { name: "search", arguments: { query: "lamp", where: { owner: OWNER } } })).result.content[0].text);
+    eq(theirs.hits.length, 0, "search narrows to one publisher with where.owner");
     if (!calls.at(-1).text[0].startsWith(QUERY)) throw new Error("the query goes to the AI binding with the query prompt");
     eq((await (await worker.fetch(new Request("https://shop.test/mcp", { method: "POST", body: '{"jsonrpc":"2.0","method":"notifications/initialized"}' }), env)).status), 202, "a notification is accepted, not answered");
 
@@ -575,77 +389,40 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     eq((await worker.fetch(new Request("https://shop.test/doc?u=https://evil.example/x.pdf"), env)).status, 403, "/doc refuses a host no record links to");
     eq((await worker.fetch(new Request("https://shop.test/view/cdn/nope"), env)).status, 404, "a missing file is a 404");
 
-    // A private app: its rows sealed on chain, opened by the indexer, served only with a pass or a paid call.
-    const { sealRow, openRow } = await import("../src/agent/x402.js");
-    const SECRET = "s3cret";
-    chain[`${PUB}/vault`] = { records: [rec("v1", TAG, await sealRow(SECRET, { sku: "v1", name: "Velvet chair", about: "a green velvet armchair" }))] };
-    const sealedAgain = await sealRow(SECRET, { sku: "v1", name: "Velvet chair", about: "a green velvet armchair" });
-    eq(sealedAgain, chain[`${PUB}/vault`].records[0].payload, "an unchanged row seals to the same bytes (the same CID: not embedded again)");
-    if (JSON.stringify(sealedAgain).includes("Velvet")) throw new Error("a sealed row must not carry its plaintext");
-    await publishView({ fangorn, app: APP, schema: CONFIG.schema, store: r2Store(VIEW), embedBatch: encode(env, DOCUMENT), embedder: WORKER_EMBEDDER, log: () => {},
-        open: (p) => openRow(SECRET, p) });
-    env.PAID_SECRET = SECRET;
-    CONFIG = env.CONFIG = { ...env.CONFIG, private: { network: "eip155:84532", asset: `0x${"aa".repeat(20)}`, payTo: `0x${"5e".repeat(20)}`,
-        facilitator: "https://fac", name: "USDC", version: "2", pass: { price: "1000000", seconds: 86400 }, call: "10000" } };
-    const settles = [];
+    // A paid record's quote: its signed terms as the requirement, its handles and deposit beside it.
+    const H = (b) => `0x${b.repeat(32)}`;
+    const terms = { terms: { publisher: PUB, repo: H("22"), key: H("33"), price: "10000", shareBps: 500, generation: "0", deadline: "2000000000" }, signature: "0x12" };
+    const handle = { "@type": "handle", gadget: "field-v1", generation: "0", cid: "bafy" };
+    const records = { [`${PUB}/shop/a1`]: { name: "Oak", body: handle, "@terms": terms }, [`${PUB}/shop/@deposit/0`]: { "@type": "deposit", sealed: "0x99" },
+                      [`${PUB}/shop/free`]: { name: "Free" } };
+    const read = async (p, r, i) => records[`${p}/${r}/${i}`] ?? null;
+    const chainInfo = { chainId: 84532, registry: `0x${"e0".repeat(20)}`, usdc: `0x${"aa".repeat(20)}`, usdcName: "USDC", usdcVersion: "2" };
     const realFetch = globalThis.fetch;
-    globalThis.fetch = async (u, init) => {
-        const { paymentPayload: p } = JSON.parse(init.body);
-        if (u === "https://fac/verify") return new Response(JSON.stringify({ isValid: true, payer: p.payload.authorization.from }));
-        settles.push(p);
-        return new Response(JSON.stringify({ success: true, transaction: `0x${settles.length}`, network: "eip155:84532", payer: p.payload.authorization.from }));
-    };
+    globalThis.fetch = async (u) => (u === "https://fac/supported"
+        ? new Response(JSON.stringify({ kinds: [{ x402Version: 2, scheme: "fangorn", network: "eip155:84532", extra: { referrer: `0x${"fe".repeat(20)}` } }] }))
+        : realFetch(u));
     try {
-        const payment = { x402Version: 2, payload: { signature: "0x", authorization: { from: "0xbuyer", to: CONFIG.private.payTo, value: "1", nonce: "0x1" } } };
-        const shard = [...objs.keys()].find((k) => k.startsWith("view/cdn/domains/") && k.endsWith("/manifest")).slice("view/".length);
-        const get = (path, headers = {}) => worker.fetch(new Request(`https://shop.test/${path}`, { headers }), env);
-        eq([(await get("view/cdn/catalog")).status, (await get(`view/${shard}`)).status], [200, 401], "the catalog is free, the rest of the view is not");
-        const asMcp = async (params, headers = {}) => (await (await worker.fetch(new Request("https://shop.test/mcp", { method: "POST", headers,
-            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params }) }), env)).json()).result;
-        const search = { name: "search", arguments: { query: "velvet armchair", limit: 1 } };
-        const ask = await asMcp(search);
-        eq([ask.isError, ask.structuredContent.accepts[0].amount, ask.structuredContent.extensions.bazaar.info.input.toolName, JSON.parse(ask.content[0].text).x402Version],
-            [true, "10000", "search", 2], "a paid tool without payment answers with x402's PaymentRequired, listed as an MCP tool");
-        eq(JSON.parse((await asMcp({ name: "describe", arguments: {} })).content[0].text).views[0].rows, 3, "describe stays free, and counts the sealed row");
-        if (!(await call("tools/list")).result.tools.find((t) => t.name === "search").description.includes("Paid: 0.01 USDC")) throw new Error("tools/list names the price");
-
-        const quote402 = await worker.fetch(new Request("https://shop.test/pass", { method: "POST" }), env);
-        const pr = JSON.parse(atob(quote402.headers.get("payment-required")));
-        eq([quote402.status, pr.accepts[0].amount, pr.extensions.bazaar.info.input.method], [402, "1000000", "POST"], "a pass is quoted over x402, Bazaar entry and all");
-        const bought = await (await worker.fetch(new Request("https://shop.test/pass", { method: "POST", headers: { "PAYMENT-SIGNATURE": btoa(JSON.stringify(payment)) } }), env)).json();
-        const auth = { authorization: `Bearer ${bought.token}` };
-        eq([(await get(`view/${shard}`, auth)).status, settles.length], [200, 1], "a pass opens the view, paid once");
-        const withPass = JSON.parse((await asMcp(search, auth)).content[0].text);
-        eq([withPass.hits[0].title, settles.length], ["Velvet chair", 1], "a pass covers tool calls, and the sealed row was opened and embedded");
-        const forged = `${bought.token.split(".")[0]}.${"A".repeat(43)}`;
-        eq((await get(`view/${shard}`, { authorization: `Bearer ${forged}` })).status, 401, "a forged pass is refused");
-
-        const paidOnce = await asMcp({ ...search, _meta: { "x402/payment": payment } });
-        eq([JSON.parse(paidOnce.content[0].text).hits[0].title, paidOnce._meta["x402/payment-response"].transaction, settles.at(-1).resource.url],
-            ["Velvet chair", "0x2", "https://shop.test/mcp"], "one call, one payment, settled after it ran");
-        const failed = await asMcp({ name: "get", arguments: { id: "no-such-row" }, _meta: { "x402/payment": payment } });
-        eq([!!JSON.parse(failed.content[0].text).error, !!failed._meta, settles.length], [true, false, 2], "a call that misses is not charged");
+        const q = await quoteOf({ publisher: PUB, repo: "shop", id: "a1", read, chain: chainInfo, facilitator: "https://fac" });
+        eq([q.requirement.scheme, q.requirement.amount, q.requirement.payTo, q.requirement.extra.referrer, q.requirement.extra.terms.key],
+           ["fangorn", "10000", chainInfo.registry, `0x${"fe".repeat(20)}`, H("33")], "the requirement is the record's signed terms, paid to the registry, with the facilitator's referrer");
+        eq([Object.keys(q.body.fields), q.body.deposit.sealed, q.body.relay], [["body"], "0x99", "https://fac"], "the body carries the sealed fields' handles, the deposit and the relay");
+        eq(await quoteOf({ publisher: PUB, repo: "shop", id: "free", read, chain: chainInfo, facilitator: "https://fac" }), null, "a record with no terms is not for sale");
     } finally { globalThis.fetch = realFetch; }
-    CONFIG = env.CONFIG = { ...env.CONFIG, private: null };
+    eq((await worker.fetch(new Request(`https://shop.test/paid/${PUB}/shop/a1`), env)).status, 404, "an app without `paid` sells nothing");
 
-    // The incremental scan: only updates since the last run, membership and exclusions applied every run.
-    const STRANGER = "0x" + "9".repeat(40);
-    const logs = [{ publisher: PUB, repo: "shop", head: "0x01", t: 10n }, { publisher: OWNER, repo: "notes", head: "0x02", t: 12n },
-                  { publisher: STRANGER, repo: "spam", head: "0x04", t: 14n }];
+    // The incremental scan: only updates since the last run.
+    const logs = [{ publisher: PUB, repo: "shop", head: "0x01", t: 10n }, { publisher: OWNER, repo: "notes", head: "0x02", t: 12n }];
     const asked = [];
-    let excluded = null, block = 20n;
-    const r = { chain: { getBlockNumber: async () => block }, fangorn: { getAppId: () => APP, getRegistry: () => ({
+    let block = 20n;
+    const r = { chain: { getBlockNumber: async () => block }, fangorn: { getRegistry: () => ({
         log: async (_f, from, to) => { asked.push([from, to]); return logs.filter((l) => l.t >= from && l.t <= to); },
-        presents: async (_app, p) => p !== STRANGER,
-        exclusionCount: async (_app, x) => (excluded && x.publisher === excluded && !x.repo ? 1 : 0),
     }) } };
     CONFIG = { ...CONFIG, fromBlock: "5" };
     const state = { block: null, repos: {} };
-    eq((await presented(r, state)).map((t) => t.repo).sort(), ["notes", "shop"], "the first run scans from the app's fromBlock, and keeps members only");
+    eq((await presented(r, state)).map((t) => t.repo).sort(), ["notes", "shop"], "the first run scans from the app's fromBlock");
     logs.push({ publisher: PUB, repo: "shop", head: "0x03", t: 25n });
     block = 30n;
-    excluded = OWNER;
-    eq((await presented(r, state)).map((t) => [t.repo, t.root]), [["shop", "0x03"]], "the next reads only what is new, and drops what the app excludes");
+    eq((await presented(r, state)).map((t) => [t.repo, t.root]).sort(), [["notes", "0x02"], ["shop", "0x03"]], "the next reads only what is new");
     eq(asked.map((a) => a.map(String)), [["5", "20"], ["21", "30"]], "each run starts where the last ended");
-    console.log("worker.js self-check ok — the lens embeds through the AI binding, /mcp serves the view's tools from R2 with queries embedded by the same runtime, the view and /doc are served from R2, and the indexer scans only new updates and applies membership and exclusions every run");
+    console.log("worker.js self-check ok — the lens embeds through the AI binding, /mcp serves the view's tools from R2 with queries embedded by the same runtime, the view and /doc are served from R2, a paid record is quoted from its signed terms, and the indexer scans only new updates");
 }