@fangorn-network/westmarch 2026.10.29 → 2026.11.4-dev

package/src/core/roles.js

@@ -5,7 +5,7 @@
 // on the next — which is exactly what happened the first time the probe was
 // pointed at a second bundle.
 //
-// The answer is already baked. A quickbeam domain manifest carries `role_map`
+// The answer is already baked. A view's domain manifest carries `role_map`
 // (which field is the title, the subtitle, the tags, the prose to search, the
 // measures, the location, the link) and `presentation` (an icon, an accent and a
 // singular/plural name per entity type, plus per-type external URL templates).
@@ -158,7 +158,7 @@ export function rolesFrom(manifests = [], sample = []) {
 /**
  * Which collection a row belongs to.
  *
- * `entityType` is quickbeam's own convention — both bundles here carry it, and
+ * `entityType` is the view's own convention — every row carries it, and
  * the manifest's `entity_types` counts are keyed by it — so this is the one
  * field name the format actually fixes. `kind` is the older spelling and is
  * still on-chain in sond3r's vertices, hence the fallback.
@@ -249,7 +249,7 @@ export const isLocked = (field, roles) =>
 /** Is this row part of the corpus's free sample — the deterministic slice a
  *  paywalled bake hands over whole so a buyer can read before paying?
  *
- *  The bake picks it by hashing the row's own id (quickbeam `paywall.in_sample`),
+ *  The bake picks it by hashing the row's own id (`inSample`),
  *  which is what stops a seller putting its best rows in the shop window. That
  *  only holds if someone CHECKS, and the check is this function: anyone can
  *  recompute which rows should be free and see whether the shard agrees. */
@@ -460,9 +460,9 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     if (gatesOf(rolesFrom([places])).length) throw new Error("an ungated view must report no gates");
     if (isLocked("text", rolesFrom([places]))) throw new Error("nothing is locked in an ungated view");
 
-    // The free sample, recomputed. Must agree with quickbeam's paywall.in_sample
-    // byte for byte or the check that keeps a seller honest checks nothing —
-    // these ids and their verdicts are pinned against that implementation.
+    // The free sample, recomputed. Must agree with the bake's sample byte for byte or
+    // the check that keeps a seller honest checks nothing — these ids and their
+    // verdicts are pinned.
     for (const [id, yes] of [["row-47", true], ["row-169", true], ["row-0", false], ["row-3", false], ["row-19", false]]) {
         if (await inSample(id, 0.01) !== yes) throw new Error(`inSample must match the bake: ${id}`);
     }

package/src/core/shard.js

@@ -1,4 +1,4 @@
-// Reading a quickbeam VIEW's Semantic CDN shards, in the consumer's own process.
+// Reading a VIEW's Semantic CDN shards (view.js's layout), in the consumer's own process.
 //
 // One view → one manifest per watched (owner, namespace) domain → N gzipped
 // NDJSON shards, downloaded once, kept in memory, ranked locally — no index
@@ -139,7 +139,7 @@ export function setDomains(only) {
 const wanted = (name) => !_only || _only.some((e) =>
     name === e || name.split("/").pop() === e || name.startsWith(e));
 
-const NO_VIEW = "no quickbeam view configured — pass a view base, or wire one with configure({ resolveView })";
+const NO_VIEW = "no view configured — pass a view base, or wire one with configure({ resolveView })";
 
 /** Fetch + parse a view's shards. Cached PER VIEW; concurrent callers share one
  *  fetch. Keyed by the resolved base, so two apps on screen in one session can't
@@ -347,7 +347,7 @@ async function load(view, onRows) {
     // A view with nothing baked yet is the normal state of a brand-new one, not an
     // error. Say which it is, or "search finds nothing" is indistinguishable from
     // a URL pointing at the wrong view.
-    if (!domains.length) console.warn(`shard: quickbeam view ${cdn} has no baked domains yet — nothing to read until the watcher bakes one.`);
+    if (!domains.length) console.warn(`shard: view ${cdn} has no baked domains yet — nothing to read until its indexer bakes one.`);
 
     const byId = new Map();
     const dead = new Set();
@@ -666,7 +666,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     }
 
     // ── the bake's packed vector (`v`), the form shipped today ──
-    // Pinned against pack_vec in quickbeam/vectors.py: [0,1,-1] -> "AH+B". A
+    // Pinned: [0,1,-1] -> "AH+B" (packVec in embed.js writes it). A
     // drift here is not a crash, it is cosine ranking on noise.
     {
         await serveView({ d0: [[{ track_id: "p1", owner: "0xa", v: "AH+B", fields: { entityType: "file", name: "packed.md", path: "packed.md" } },

package/src/discover/apps.js

@@ -1,20 +1,15 @@
-// The index of apps — read off the chain.
+// The index of apps, read off the chain.
 //
-// An app owner binds its agent card with `setAppAgentUri`, and the AppRegistry
-// emits `AppAgentChanged(appId, uri)`. The log IS the directory: no registry
-// namespace to bake, no relay to ask, nobody's server in the loop. Scan the
-// logs, keep each app's latest uri, and hand every uri to `discoverApp`, which
-// fetches the card and checks it names that app and is still the one bound on
-// chain. The card then says where the data is (`views`) and where it starts
-// (`fromBlock`).
+// An app is a publisher's repo whose `@card` record points at an agent card that points back.
+// So the directory is `repos()` (one scan of the update log), each repo's `@card` (one read
+// per repo, cached by head), and `discoverCard` on each card found, which checks the binding.
+// No registry, no relay, nobody's server in the loop.
 //
-// `fangorn` is an SDK client, passed in rather than imported, so this module
-// stays usable where the SDK is not installed, and testable without a chain.
-// Reads only: a reader can create one with a throwaway key.
+// `fangorn` is an SDK client, passed in rather than imported, so this module stays usable
+// where the SDK is not installed, and testable without a chain.
 //
-// ponytail: one flat list, no ranking. Every card is one fetch, all in
-// parallel. Past a few hundred apps, rank by the cards' own coverage instead of
-// fetching them all.
+// ponytail: one flat list, no ranking, every card fetched. Past a few hundred apps, rank by
+// the cards' own coverage instead.
 
 /**
  * A pointer someone else wrote, and following it is the one place a reader
@@ -29,9 +24,9 @@ function safeView(url) {
     } catch { return null; }
 }
 
-/** The SDK's FANGORN_APP_EXTENSION. Copied so this file needs no SDK;
+/** The SDK's FANGORN_REPO_EXTENSION. Copied so this file needs no SDK;
  *  src/agent/agent-card.js's self-check fails if the two drift. */
-export const APP_EXTENSION = "https://fangorn.network/a2a/app/v1";
+export const APP_EXTENSION = "https://fangorn.network/a2a/repo/v1";
 
 /** The app's agent skill, `{url, sha256}`, when its card names one well-formed; else null. */
 export const skillOf = (ext) => {
@@ -47,16 +42,19 @@ export const pluginOf = (ext) => {
     return p && PLUGIN_MARKETPLACE.test(p.marketplace ?? "") && PLUGIN_NAME.test(p.name ?? "") ? { marketplace: p.marketplace, name: p.name } : null;
 };
 
-/** A verified card → an app entry. `views` is westmarch's param; the SDK does not read it. */
-export function toApp({ card, appId, fromBlock, repos }, cardUrl) {
-    const ext = card.capabilities.extensions.find((e) => e.uri === APP_EXTENSION);
-    const views = (Array.isArray(ext?.params?.views) ? ext.params.views : []).map(safeView).filter(Boolean);
-    const p = ext?.params?.paid;
-    const paid = p && /^https?:\/\//.test(p.url ?? "") && p.url.includes("{id}") && /^\d+$/.test(String(p.price)) ? p : null;
+/** A verified card (`discoverCard`'s result) → an app entry. `views` etc. are westmarch's params; the SDK ignores them. */
+export function toApp({ card, publisher, repo }, cardUrl) {
+    const p = card.capabilities.extensions.find((e) => e.uri === APP_EXTENSION)?.params ?? {};
+    const views = (Array.isArray(p.views) ? p.views : []).map(safeView).filter(Boolean);
+    const paid = p.paid && /^https?:\/\//.test(p.paid.url ?? "") && p.paid.url.includes("{id}") ? { url: p.paid.url } : null;
     return {
-        appId, card: cardUrl, fromBlock, repos, views, paid, skill: skillOf(ext), plugin: pluginOf(ext),
-        mcp: safeView(ext?.params?.mcp),
-        name: card.name ?? appId,
+        id: `${publisher}:${repo}`, publisher, repo, card: cardUrl,
+        fromBlock: /^\d+$/.test(String(p.fromBlock)) ? BigInt(p.fromBlock) : null,
+        repos: Array.isArray(p.repos) ? p.repos.filter((r) => typeof r === "string") : [],
+        views, paid, skill: skillOf({ params: p }), plugin: pluginOf({ params: p }),
+        mcp: safeView(p.mcp),
+        tools: (card.skills ?? []).map((k) => k.id),
+        name: card.name ?? repo,
         desc: card.description ?? "",
         url: safeView(card.url),
     };
@@ -80,29 +78,23 @@ export async function cachedLogs(store, key, start, head, read) {
 }
 
 /**
- * Every app with a bound, verifiable card. The ones that fail are reported
- * with the reason, not dropped: a card that is down and a card that lies look
- * the same from outside, and an agent should see both.
- *
- * An app that cleared its uri (bound to "") is skipped. It is not an error.
- *
- * With a `store` (see cachedLogs) and `toBlock`, the logs read before are not
- * read again; the cards are still all verified.
+ * Every app with a bound, verifiable card. The ones that fail are reported with the reason,
+ * not dropped: a card that is down and a card that lies look the same from outside, and an
+ * agent should see both. `store` ({ get, set }) caches each repo's card URL by head.
  */
-export async function listApps(fangorn, { fromBlock, toBlock, store } = {}) {
-    if (fromBlock == null) throw new Error("listApps: pass fromBlock, a block at or before the AppRegistry's deployment — from 0 is one RPC call per 1000 blocks of chain history");
-    const read = (from, to) => fangorn.getAppRegistry().getAppAgentLogs({ fromBlock: from, toBlock: to });
-    const logs = store && toBlock != null
-        ? await cachedLogs(store, `AppAgentChanged:${fromBlock}`, BigInt(fromBlock), BigInt(toBlock), read)
-        : await read(BigInt(fromBlock), toBlock);
-    // Oldest first, so the last write wins. discoverApp re-reads the binding,
-    // so a stale uri here is caught there, not trusted.
-    const latest = new Map(logs.map((l) => [l.appId, l.agentUri]));
+export async function listApps(fangorn, { fromBlock, store } = {}) {
+    const repos = await fangorn.repos(fromBlock == null ? {} : { fromBlock: BigInt(fromBlock) });
     const apps = [], rejected = [];
-    await Promise.all([...latest].map(async ([appId, uri]) => {
-        if (!uri) return;
-        try { apps.push(toApp(await fangorn.discoverApp(uri), uri)); }
-        catch (e) { rejected.push({ appId, card: uri, why: e?.message ?? String(e) }); }
+    await Promise.all(repos.map(async ({ owner, repo, root }) => {
+        const key = `card:${owner.toLowerCase()}/${repo}@${root}`;
+        let url = store?.get(key);
+        if (url === undefined) {
+            try { url = (await fangorn.cardOf(owner, repo)) ?? null; } catch { return; }   // unreadable now: not cached, tried next time
+            store?.set(key, url);
+        }
+        if (!url) return;
+        try { apps.push(toApp(await fangorn.discoverCard(url), url)); }
+        catch (e) { rejected.push({ publisher: owner, repo, card: url, why: e?.message ?? String(e) }); }
     }));
     apps.sort((a, b) => a.name.localeCompare(b.name));
     return { apps, rejected };
@@ -112,52 +104,46 @@ export async function listApps(fangorn, { fromBlock, toBlock, store } = {}) {
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/apps.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 A = "0x" + "a".repeat(64), B = "0x" + "b".repeat(64), C = "0x" + "c".repeat(64);
-    const card = (appId, name, views) => ({ name, description: `${name}!`, url: "https://x.test/", capabilities: { extensions: [
-        { uri: "https://other/ext", params: { appId, views: ["https://evil.test/"] } },
-        { uri: "https://fangorn.network/a2a/app/v1", params: { appId, views } },
+    const P = "0x" + "11".repeat(20), Q = "0x" + "22".repeat(20);
+    const card = (publisher, repo, name, views) => ({ name, description: `${name}!`, url: "https://x.test/", capabilities: { extensions: [
+        { uri: "https://other/ext", params: { views: ["https://evil.test/"] } },
+        { uri: APP_EXTENSION, params: { publisher, repo, fromBlock: "7", repos: ["n"], views } },
     ] } });
     const cards = {
-        "https://a.test/card": card(A, "Beta", ["https://a.test/q/v1/stream", "javascript:alert(1)"]),
-        "https://a.test/old": card(A, "Old", []),
-        "https://b.test/card": card(B, "Alpha", []),
+        "https://a.test/card": card(P, "beta", "Beta", ["https://a.test/q/v1/stream", "javascript:alert(1)"]),
+        "https://b.test/card": card(Q, "alpha", "Alpha", []),
     };
-    let askedFrom;
+    const bound = { [`${P}/beta`]: "https://a.test/card", [`${Q}/alpha`]: "https://b.test/card", [`${Q}/liar`]: "https://liar.test/card" };
+    let cardReads = 0;
     const fangorn = {
-        getAppRegistry: () => ({ getAppAgentLogs: ({ fromBlock }) => (askedFrom = fromBlock, Promise.resolve([
-            { appId: A, agentUri: "https://a.test/old" },
-            { appId: B, agentUri: "https://b.test/card" },
-            { appId: A, agentUri: "https://a.test/card" },   // A rebound: last wins
-            { appId: C, agentUri: "https://c.test/card" },
-            { appId: C, agentUri: "" },                      // C unbound
-            { appId: "0x" + "d".repeat(64), agentUri: "https://liar.test/card" },
-        ])) }),
-        discoverApp: async (uri) => {
-            if (uri === "https://liar.test/card") throw new Error("not bound to app");
-            const c = cards[uri];
-            return { card: c, appId: c.capabilities.extensions[1].params.appId, fromBlock: 7n, repos: ["n"] };
+        repos: async () => [{ owner: P, repo: "beta", root: "0x1" }, { owner: Q, repo: "alpha", root: "0x2" },
+                            { owner: Q, repo: "plain", root: "0x3" }, { owner: Q, repo: "liar", root: "0x4" }],
+        cardOf: async (o, r) => (cardReads++, bound[`${o}/${r}`]),
+        discoverCard: async (url) => {
+            if (url === "https://liar.test/card") throw new Error("not bound");
+            const c = cards[url], p = c.capabilities.extensions[1].params;
+            return { card: c, publisher: p.publisher, repo: p.repo };
         },
     };
-    const { apps, rejected } = await listApps(fangorn, { fromBlock: 42 });
-    eq(askedFrom, 42n, "fromBlock forwarded as bigint");
-    eq(apps.map((a) => a.name), ["Alpha", "Beta"], "one entry per app, latest card, sorted, unbound skipped");
+    const m = new Map(), store = { get: (k) => m.get(k), set: (k, v) => m.set(k, v) };
+    const { apps, rejected } = await listApps(fangorn, { store });
+    eq(apps.map((a) => a.name), ["Alpha", "Beta"], "one entry per carded repo, sorted, repos with no card skipped");
     const beta = apps[1];
     eq(beta.views, ["https://a.test/q/v1"], "views from the fangorn extension only, trimmed, non-http dropped");
-    eq([beta.appId, beta.card, beta.url, beta.fromBlock, beta.desc], [A, "https://a.test/card", "https://x.test", 7n, "Beta!"], "entry fields");
-    eq(rejected.map((r) => r.why), ["not bound to app"], "a card that fails verification is reported");
-    await listApps(fangorn).then(() => { throw new Error("missing fromBlock must throw"); }, () => {});
+    eq([beta.id, beta.card, beta.url, beta.fromBlock, beta.repos, beta.desc], [`${P}:beta`, "https://a.test/card", "https://x.test", 7n, ["n"], "Beta!"], "entry fields");
+    eq(rejected.map((r) => r.why), ["not bound"], "a card that fails verification is reported");
+    eq(cardReads, 4, "one @card read per repo");
+    await listApps(fangorn, { store });
+    eq(cardReads, 4, "an unchanged head is not read again");
 
-    const m = new Map(), store = { get: (k) => m.get(k), set: (k, v) => m.set(k, v) }, asked = [];
+    const asked = [];
     const chain = [{ blockNumber: 10n, n: 1 }, { blockNumber: 150n, n: 2 }, { blockNumber: 190n, n: 3 }];
     const read = async (from, to) => (asked.push([from, to]), chain.filter((l) => l.blockNumber >= from && l.blockNumber <= to));
-    eq((await cachedLogs(store, "k", 5n, 200n, read)).map((l) => l.n), [1, 2, 3], "first call reads it all");
-    eq(m.get("k").to, 136n, "stores only what is settled");
-    eq(m.get("k").logs.map((l) => l.n), [1], "the unsettled tail is not stored");
-    eq((await cachedLogs(store, "k", 5n, 210n, read)).map((l) => l.n), [1, 2, 3], "second call: same logs, no duplicates");
+    const lm = new Map(), ls = { get: (k) => lm.get(k), set: (k, v) => lm.set(k, v) };
+    eq((await cachedLogs(ls, "k", 5n, 200n, read)).map((l) => l.n), [1, 2, 3], "first call reads it all");
+    eq(lm.get("k").to, 136n, "stores only what is settled");
+    eq((await cachedLogs(ls, "k", 5n, 210n, read)).map((l) => l.n), [1, 2, 3], "second call: same logs, no duplicates");
     eq(asked, [[5n, 200n], [137n, 210n]], "second call reads only from the settled point");
-    asked.length = 0;
-    await cachedLogs(store, "k", 5n, 146n, read);
-    eq(asked, [], "head at the stored point: no read");
 
-    console.log("apps.js self-check ok — latest card per app, unbound skipped, failures reported, views gated to http(s)");
+    console.log("apps.js self-check ok — an app is a repo whose card verifies, cards read once per head, failures reported, views gated to http(s)");
 }

package/src/discover/directory.js

@@ -62,7 +62,7 @@ export async function survey(sources = [], { timeoutMs = 8000 } = {}) {
             for (const d of cat.domains ?? []) {
                 corpora.push({
                     view,
-                    publisher: typeof src === "string" ? null : (src.name ?? src.appId ?? null),
+                    publisher: typeof src === "string" ? null : (src.name ?? src.id ?? null),
                     owner: typeof src === "string" ? null : (src.owner ?? null),
                     domain: d.name,
                     description: d.description || "",
@@ -164,7 +164,7 @@ export async function findCorpora(query, { sources = [], embed, model, limit = 1
  *  modules to run a survey. Rejected cards come back beside the sources. */
 export async function sourcesFromChain(fangorn, opts) {
     const { apps, rejected } = await listApps(fangorn, opts);
-    return { sources: apps.flatMap((a) => a.views.map((view) => ({ view, name: a.name, appId: a.appId }))), rejected };
+    return { sources: apps.flatMap((a) => a.views.map((view) => ({ view, name: a.name, id: a.id }))), rejected };
 }
 
 // ── self-check: `node src/discover/directory.js` ─────────────────────────────────

package/src/market/reactions.js

@@ -16,7 +16,7 @@
 // ------------------------------------------------------
 // A reaction's vector is the vector of the row reacted to, which the reader
 // already downloaded in order to react to it. So a reaction corpus needs no
-// model, no GPU, no bake, no quickbeam — the vectors are copied, not computed.
+// model, no GPU, no bake — the vectors are copied, not computed.
 // The only thing that has to be fitted locally is `coverage`, which is eight
 // centroids and is the function below. A consumer becoming a publisher is
 // therefore not a tier you upgrade into; it is this file and a price.
@@ -51,7 +51,24 @@
 // hat, and a reader with nine reactions is exactly who most needs this to hold.
 
 import { EMBED_MODEL, packVec } from "../core/embed.js";
-import { lineage } from "./terms.js";
+
+const ADDR = /^0x[0-9a-fA-F]{40}$/;
+/** What a publisher owes upstream for one resource, in bps of its share. Deduped by payee:
+ *  the same source cited twice is one debt, not two, which can't be gamed by repeating an entry. */
+function lineage(entries = []) {
+    const by = new Map();
+    for (const e of entries) {
+        const to = String(e.to ?? "").toLowerCase();
+        if (!ADDR.test(to)) throw new Error(`not an address: ${e.to}`);
+        const b = BigInt(e.bps ?? 0);
+        if (b < 0n || b > 10000n) throw new Error(`lineage bps must be 0..10000, got ${e.bps}`);
+        by.set(to, { to, bps: (by.get(to)?.bps ?? 0n) + b, note: e.note ?? by.get(to)?.note ?? "" });
+    }
+    const out = [...by.values()];
+    const total = out.reduce((s, e) => s + e.bps, 0n);
+    if (total > 10000n) 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 } : {}) }));
+}
 
 // 32, not 8: on Kingsfoil the top 3 of 23 views held 92% of the true top 10 with 32
 // centroids and 86% with 8, and 8 missed whole topics (ALS → neurology).
@@ -68,7 +85,7 @@ const dot = (a, b) => { let s = 0, n = Math.min(a.length, b.length); for (let i
  * Spherical k-means over the corpus's own vectors — the routing summary that
  * lets a buyer rank this corpus WITHOUT downloading it.
  *
- * Mirrors quickbeam's `cdn._coverage`: fit at full width, truncate to `dim`
+ * The view's coverage: fit at full width, truncate to `dim`
  * leading components (Matryoshka), then RENORMALIZE, because a truncated unit
  * vector is not unit and the client compares against a truncated query it
  * renormalizes too. Get that order wrong and routing degrades silently.
@@ -238,7 +255,6 @@ export function reactionCorpus(events = [], {
 
 // ── self-check: `node src/market/reactions.js` ────────────────────────────────
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/reactions.js")) {
-    const { splitPayment } = await import("./terms.js");
     const A = (n) => `0x${String(n).repeat(40).slice(0, 40)}`;
     const vec = (a, b) => { const v = new Float32Array(256); v[0] = a; v[1] = b; return v; };
 
@@ -321,16 +337,6 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     if (bps["archive-films"] !== 1500 || bps.games !== 500) throw new Error(`upstream must follow contribution: ${JSON.stringify(bps)}`);
     if (up.reduce((s, e) => s + Number(e.bps), 0) !== 2000) throw new Error("the declared upstream total must be exact, not a basis point short");
 
-    // …and it reconciles against a real sale. This is the claim: the corpora that
-    // produced the attention are paid when the attention sells.
-    const TERMS = { appId: "fangorn.tv", owner: A(9), appBps: 1000 };
-    const pay = splitPayment(300000n, { terms: TERMS, publisher: A(3), lineage: up });
-    const got = Object.fromEntries(pay.map((p) => [p.to, p.amount]));
-    if (got[A(9)] !== 30000n) throw new Error("the app's cut comes off the top and never moves");
-    if (got[A(1)] !== 40500n || got[A(2)] !== 13500n) throw new Error(`upstream is paid from the publisher's share: ${JSON.stringify(got, (k, v) => typeof v === "bigint" ? String(v) : v)}`);
-    if (got[A(3)] !== 216000n) throw new Error("the reader keeps the rest");
-    if (pay.reduce((s, p) => s + p.amount, 0n) !== 300000n) throw new Error("money is neither invented nor destroyed");
-
     // A reader who cites a corpus nobody registered simply owes it nothing.
     const orphan = reactionCorpus(EV, { publisher: A(3), sources: { games: A(2) } });
     if (orphan.lineage.length !== 1 || Number(orphan.lineage[0].bps) !== 2000) throw new Error("an unregistered corpus cannot be paid, and its share does not vanish");
@@ -341,5 +347,5 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
 
     console.log("reactions.js self-check ok — reactions become a corpus with no model, coverage is deterministic and renormalized after truncation, "
         + "the free index ranks on centroids alone, publishes no per-row vector to join against and no paid string anywhere including its own keys, "
-        + "time is coarse, upstream follows contribution exactly and reconciles against a real sale");
+        + "time is coarse, upstream follows contribution exactly");
 }

package/src/publish/devnet.js

@@ -4,23 +4,56 @@
 // scripts/e2e-worker.mjs run an app against, with nothing leaving the machine.
 //
 // Needs forge and anvil, and the contracts' source (FANGORN_CONTRACTS_DIR, default
-// ../contracts/solidity next to westmarch).
+// ../contracts next to westmarch). USDC and Semaphore are the contracts' mocks: payments
+// aren't checked and any proof is accepted.
+//
+// The services a deployment runs are here too, each its own Worker under `wrangler dev`, wired
+// to this chain: `keyServer()` and `relay()` from the webworker checkout (FANGORN_WEBWORKER_DIR,
+// default ../webworker), and `worker()` for any other, such as an app's.
 
 import { spawn, spawnSync } from "node:child_process";
 import { createServer } from "node:http";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createTestClient, encodeFunctionData, getAddress, http, parseEther, publicActions, walletActions } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { APP_REGISTRY_ABI, DATA_REGISTRY_ABI, Fangorn, FangornConfig } from "@fangorn-network/sdk";
+import { bytesToHex } from "viem";
+import { DATA_REGISTRY_ABI, SETTLEMENT_REGISTRY_ABI, Fangorn, FangornConfig } from "@fangorn-network/sdk";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const ADMIN_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";   // anvil's first account
+/**
+ * The Worker in `dir` under `wrangler dev` with `vars`, on a free port: `{ url, kill }` once `probe`
+ * answers. Its own process group, so `kill` takes workerd down with wrangler. Local bindings only.
+ */
+export async function wranglerDev(dir, vars = {}, { config, probe = "/", name = dir, log = () => {} } = {}) {
+    const free = () => new Promise((ok) => { const s = createServer().listen(0, "127.0.0.1", () => { const p = s.address().port; s.close(() => ok(p)); }); });
+    // Its own inspector port too: two workers started at once both take wrangler's default (9229), and one dies.
+    const [port, inspector] = await Promise.all([free(), free()]);
+    const w = spawn("npx", ["wrangler", "dev", ...(config ? ["--config", config] : []), "--port", String(port), "--inspector-port", String(inspector), "--ip", "127.0.0.1",
+        "--persist-to", mkdtempSync(join(tmpdir(), "devnet-wrangler-")), ...Object.entries(vars).flatMap(([k, v]) => ["--var", `${k}:${v}`])],
+        { cwd: dir, detached: true, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, NO_D1_WARNING: "true" } });
+    let out = "";
+    w.stdout.on("data", (c) => { out += c; }); w.stderr.on("data", (c) => { out += c; });
+    const kill = () => { try { process.kill(-w.pid); } catch { /* gone */ } };
+    process.on("exit", kill);
+    const url = `http://127.0.0.1:${port}`;
+    for (const t0 = Date.now(); ; await new Promise((r) => setTimeout(r, 500))) {
+        if (w.exitCode !== null) throw new Error(`${name}: wrangler dev exited\n${out.slice(-2000)}`);
+        if (Date.now() - t0 > 120_000) { kill(); throw new Error(`${name}: no answer at ${url}${probe} in 2 minutes\n${out.slice(-2000)}`); }
+        if (await fetch(`${url}${probe}`).then(() => true, () => false)) break;
+    }
+    log(`${name} at ${url}`);
+    return { url, kill };
+}
+
 const listen = (server) => new Promise((ok) => server.listen(0, "127.0.0.1", () => ok(`http://127.0.0.1:${server.address().port}`)));
 
-export async function devnet({ contracts = process.env.FANGORN_CONTRACTS_DIR ?? resolve(HERE, "../../../contracts/solidity"), log = () => {} } = {}) {
+export async function devnet({ contracts = process.env.FANGORN_CONTRACTS_DIR ?? resolve(HERE, "../../../contracts"),
+                               webworker = process.env.FANGORN_WEBWORKER_DIR ?? resolve(HERE, "../../../webworker"), log = () => {} } = {}) {
     const kids = [], servers = [];
     const stop = () => { for (const k of kids) k.kill(); for (const s of servers) s.close(); };
     process.on("exit", stop);
@@ -32,17 +65,18 @@ export async function devnet({ contracts = process.env.FANGORN_CONTRACTS_DIR ??
     const rpcUrl = await new Promise((ok) => { let out = ""; anvil.stdout.on("data", (c) => { out += c; const m = /Listening on (\S+)/.exec(out); if (m) ok(`http://${m[1]}`); }); });
     const chain = createTestClient({ mode: "anvil", chain: FangornConfig.chain, transport: http(rpcUrl) }).extend(publicActions).extend(walletActions);
     const admin = privateKeyToAccount(ADMIN_KEY);
-    const artifact = (n) => { const j = JSON.parse(readFileSync(`${contracts}/out/${n}.sol/${n}.json`, "utf8")); return { abi: j.abi, bytecode: j.bytecode.object }; };
-    const deploy = async (n, args) => getAddress((await chain.waitForTransactionReceipt({ hash: await chain.deployContract({ account: admin, ...artifact(n), args }) })).contractAddress);
+    // `file`: the .sol it is in, when that isn't `n`.sol.
+    const artifact = (n, file = n) => { const j = JSON.parse(readFileSync(`${contracts}/out/${file}.sol/${n}.json`, "utf8")); return { abi: j.abi, bytecode: j.bytecode.object }; };
+    const deploy = async (n, args, file) => getAddress((await chain.waitForTransactionReceipt({ hash: await chain.deployContract({ account: admin, ...artifact(n, file), args }) })).contractAddress);
     const proxied = async (n, init) => deploy("ERC1967Proxy", [await deploy(n, []), init]);
-    const apps = await proxied("AppRegistry", encodeFunctionData({ abi: APP_REGISTRY_ABI, functionName: "initialize",
-        args: [admin.address, "0x000000000000000000000000000000000000dEaD", 0n, 30n * 24n * 3600n] }));
-    const data = await proxied("DataRegistry", encodeFunctionData({ abi: DATA_REGISTRY_ABI, functionName: "initialize", args: [admin.address, apps] }));
-    await chain.waitForTransactionReceipt({ hash: await chain.writeContract({ account: admin, address: apps, abi: APP_REGISTRY_ABI, functionName: "setDataRegistry", args: [data] }) });
+    const data = await proxied("DataRegistry", encodeFunctionData({ abi: DATA_REGISTRY_ABI, functionName: "initialize", args: [admin.address] }));
+    const usdc = await deploy("MockUSDC", [], "Mocks");
+    const settlement = await proxied("SettlementRegistry", encodeFunctionData({ abi: SETTLEMENT_REGISTRY_ABI, functionName: "initialize",
+        args: [admin.address, usdc, await deploy("MockSemaphore", [], "Mocks")] }));
     // As a Worker's CONFIG.deployment takes it: strings, no BigInt.
-    const deployment = { appRegistryContractAddress: apps, dataRegistryContractAddress: data, appRegistryFromBlock: "0" };
-    const config = { ...FangornConfig, ...deployment, appRegistryFromBlock: 0n, rpcUrl };
-    log(`anvil ${rpcUrl}, AppRegistry ${apps}, DataRegistry ${data}`);
+    const deployment = { dataRegistryContractAddress: data, settlementRegistryContractAddress: settlement, fromBlock: "0" };
+    const config = { ...FangornConfig, ...deployment, fromBlock: 0n, rpcUrl };
+    log(`anvil ${rpcUrl}, DataRegistry ${data}, SettlementRegistry ${settlement}`);
 
     // ── storage: a content-addressed store, and the gateway that serves it ────
     // multiformats, from the SDK's own dependencies.
@@ -65,10 +99,10 @@ export async function devnet({ contracts = process.env.FANGORN_CONTRACTS_DIR ??
     servers.push(gateway);
     const gatewayUrl = await listen(gateway);
 
-    /** A funded publisher, under `app` (or none). */
-    const client = async (app, privateKey = generatePrivateKey()) => {
+    /** A funded client. */
+    const client = async (privateKey = generatePrivateKey()) => {
         await chain.setBalance({ address: privateKeyToAccount(privateKey).address, value: parseEther("1") });
-        return Fangorn.create({ privateKey, config, appId: app, storage: { backend } });
+        return Fangorn.create({ privateKey, config, storage: { backend } });
     };
 
     /** An encoder on localhost that answers as the AI binding does: POST {text} → {data}; GET → the embedder it is. */
@@ -91,5 +125,22 @@ export async function devnet({ contracts = process.env.FANGORN_CONTRACTS_DIR ??
         return listen(server);
     };
 
-    return { rpcUrl, deployment, config, chain, backend, gatewayUrl, client, encoder, stop, kids };
+    // ── Workers, wired to this chain ─────────────────────────────────────────
+    const worker = (dir, vars, opts) => wranglerDev(dir, vars, { log, ...opts }).then(({ url, kill }) => (kids.push({ kill }), url));
+
+    /** The key server (fangorn-access-worker), with a fresh X25519 secret. */
+    const keyServer = () => worker(join(webworker, "fangorn-access-worker"),
+        { WORKER_X25519_SECRET: bytesToHex(crypto.getRandomValues(new Uint8Array(32))), SETTLEMENT_REGISTRY: settlement, RPC_URL: rpcUrl },
+        { probe: "/pubkey", name: "key server" });
+
+    /** Barliman, paying gas from a funded treasury key; `treasury` is the referrer on every register. */
+    const relay = async (treasury = privateKeyToAccount(generatePrivateKey()).address) => {
+        const key = generatePrivateKey();
+        await chain.setBalance({ address: privateKeyToAccount(key).address, value: parseEther("10") });
+        const url = await worker(join(webworker, "barliman"), { TREASURY_KEY: key, TREASURY: treasury, RPC_URL: rpcUrl,
+            DATA_REGISTRY: data, SETTLEMENT_REGISTRY: settlement }, { probe: "/supported", name: "relay (Barliman)" });
+        return { url, treasury };
+    };
+
+    return { rpcUrl, deployment, config, chain, usdc, backend, gatewayUrl, client, encoder, worker, keyServer, relay, stop, kids };
 }

package/src/publish/init.js

@@ -41,7 +41,7 @@ export function init(app, dir = app, { install = true, log = console.log } = {})
     }
     log(`${app} is in ${dir}. Next:
   1. app.json: the description, and the type's fields (role_map)
-  2. npx westmarch-ship app.json           # claims ${app} if it isn't yet, deploys the Worker, registers its agent`);
+  2. npx westmarch-ship app.json           # creates the repo ${app}, deploys the Worker, registers its agent`);
     return dir;
 }