@fangorn-network/westmarch 0.0.19-dev → 0.1.0

package/src/core/embed.worker.js

@@ -1,6 +1,6 @@
 // The embedder, off the main thread.
 //
-// nomic-embed-text-v1.5 q8 is a 131MB ONNX download, and ONNX Runtime's WASM init
+// EmbeddingGemma-300m q8 is a ~300MB ONNX download, and ONNX Runtime's WASM init
 // and every inference after it are synchronous CPU. On the main thread that is a
 // frozen tab for as long as it takes — which on a first visit is a minute or two
 // of an app that looks broken rather than busy.

package/src/core/rank.js

@@ -159,7 +159,7 @@ export function rankDomains(domains = [], q) {
 }
 
 // ── self-check: `node src/core/rank.js` ──────────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/rank.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/rank.js")) {
     // Word boundaries: the bug this replaced ranked "intoxicated" for "cat".
     if (lexScore({ text: "intoxicated education" }, "cat") !== 0) throw new Error("substring matched — word boundaries lost");
     if (lexScore({ text: "a cat sat" }, "cat") <= 0) throw new Error("whole word must match");

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. */
@@ -371,7 +371,7 @@ export function actionsOf(row, roles) {
 }
 
 // ── self-check: `node src/core/roles.js` ─────────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/roles.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/roles.js")) {
     // The real places manifest's shape.
     const places = {
         role_map: {
@@ -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
@@ -52,6 +52,7 @@ const _meta = new Map(); // view base → [manifest, …]
 let _rowText = (f) => [f.name, f.path, f.desc].filter(Boolean).join(" ");
 /** How to learn the default view. Overridden by the app; unset means an app that
  *  always passes an explicit view base, which is a legitimate way to use this. */
+let _fetch = (url) => fetch(url);
 let _resolveView = null;
 /** Called with the domain manifests once they land and BEFORE the first shard is
  *  parsed. See configure(). */
@@ -74,8 +75,11 @@ let _onManifests = null;
  * the argument the second corpus loaded would silently be parsed with the
  * first one's text role.
  */
-export function configure({ resolveView, rowText, onManifests } = {}) {
+export function configure({ resolveView, rowText, onManifests, fetch: f } = {}) {
     if (resolveView) _resolveView = resolveView;
+    // `fetch`: how a view's files are read. A Worker serving its own view reads them from
+    // its bucket, since a Worker cannot fetch its own URL.
+    if (f) _fetch = f;
     if (rowText) _rowText = rowText;
     if (onManifests) _onManifests = onManifests;
 }
@@ -135,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
@@ -171,7 +175,7 @@ export async function loadShard(base, onRows) {
  *  below. Exported because an app resolving its own view reads config the same
  *  way, and a second copy of the sniff would drift. */
 export async function fetchText(url) {
-    const res = await fetch(url);
+    const res = await _fetch(url);
     if (!res.ok) throw new Error(`shard: HTTP ${res.status} for ${url}`);
 
     // Who gunzips depends on the server. `cdn serve` sends a shard as
@@ -266,7 +270,7 @@ async function verifyShard(url, expect, chunks, gz) {
  *  read, so this is an optimisation and never a requirement.
  */
 async function fetchLines(url, onLine, expect) {
-    const res = await fetch(url);
+    const res = await _fetch(url);
     if (!res.ok) throw new Error(`shard: HTTP ${res.status} for ${url}`);
     if (!res.body) {
         // The buffered path has every byte before it parses one, so it can verify
@@ -343,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();
@@ -438,7 +442,7 @@ export async function suggestDomains(q, { url } = {}) {
 }
 
 // ── self-check: `node src/core/shard.js` — no network, no view ────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/shard.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/shard.js")) {
     const { gzipSync } = await import("node:zlib");
     const warn = console.warn, info = console.info;
     console.warn = console.info = () => {}; // the fallback warnings are behaviour under test, not output
@@ -662,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,85 +24,126 @@ 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";
 
-/** A verified card → an app entry. `views` is westmarch's param; the SDK does not read it. */
-export function toApp({ card, appId, fromBlock, namespaces }, 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;
+/** The app's agent skill, `{url, sha256}`, when its card names one well-formed; else null. */
+export const skillOf = (ext) => {
+    const k = ext?.params?.skill;
+    return k && safeView(k.url) && /^[0-9a-f]{64}$/.test(k.sha256 ?? "") ? { url: k.url, sha256: k.sha256 } : null;
+};
+
+// The app's Claude Code plugin, for what a skill can't do (hooks). Both fields reach a shell command
+// in the reader's agent, so they are held to a GitHub owner/repo (or https URL) and a plain name.
+export const PLUGIN_MARKETPLACE = /^([\w.-]+\/[\w.-]+|https:\/\/[\w.\/-]+)$/, PLUGIN_NAME = /^[a-z0-9][a-z0-9-]*$/;
+export const pluginOf = (ext) => {
+    const p = ext?.params?.plugin;
+    return p && PLUGIN_MARKETPLACE.test(p.marketplace ?? "") && PLUGIN_NAME.test(p.name ?? "") ? { marketplace: p.marketplace, name: p.name } : 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, namespaces, views, paid,
-        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),
     };
 }
 
+// Blocks this close to the head can still reorg: read again every time, never stored.
+const SETTLED = 64n;
+
+/**
+ * Logs from `start` to `head`, oldest first, reading only the blocks `store`
+ * has not seen. A scan from the registry's deployment grows with the chain;
+ * this one grows with the time since the last call. `store` is `{ get, set }`
+ * of `{ to, logs }` by `key`; `read(from, to)` returns logs with `blockNumber`.
+ */
+export async function cachedLogs(store, key, start, head, read) {
+    const hit = store.get(key) ?? { to: start - 1n, logs: [] };
+    const fresh = hit.to < head ? await read(hit.to + 1n, head) : [];
+    const settled = head - SETTLED;
+    if (settled > hit.to) store.set(key, { to: settled, logs: [...hit.logs, ...fresh.filter((l) => l.blockNumber <= settled)] });
+    return [...hit.logs, ...fresh];
+}
+
 /**
- * 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.
+ * 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 } = {}) {
-    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 logs = await fangorn.getAppRegistry().getAppAgentLogs({ fromBlock: 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 };
 }
 
 // ── self-check: `node src/discover/apps.js` ──────────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/apps.js")) {
+if (import.meta.url === `file://${globalThis.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, namespaces: ["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 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));
+    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");
 
-    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/corpora.js

@@ -189,7 +189,7 @@ export function follow(picks = [], corpora = [], { at = null } = {}) {
 }
 
 // ── self-check: `node src/discover/corpora.js` ───────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/corpora.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/corpora.js")) {
     const s = session();
     const add = (view, name, n) => {
         const c = s.slot(view);

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,11 +164,11 @@ 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` ─────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/directory.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/directory.js")) {
     const warn = console.warn; console.warn = () => {};
     const cov = (...vectors) => ({ dim: 2, sampled: 100, vectors, counts: vectors.map(() => 50) });
 

package/src/market/cohort.js

@@ -247,7 +247,7 @@ export function readout(total, cohort, { minSupport = MIN_SUPPORT } = {}) {
 }
 
 // ── self-check: `node src/market/cohort.js` ──────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/cohort.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/cohort.js")) {
     const vec = (a, b) => { const v = new Float32Array(STAT_DIM); v[0] = a; v[1] = b; return v; };
     const log = (n, seed) => Array.from({ length: n }, (_, i) => ({
         id: `row-${seed}-${i}`, corpus: "films", reaction: i % 4 === 3 ? "skip" : "like",

package/src/market/demand.js

@@ -383,7 +383,7 @@ export function brief(rep, { title = "demand" } = {}) {
 }
 
 // ── self-check: `node src/market/demand.js` ────────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/demand.js")) {
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/demand.js")) {
     const { keypair, statistics, contribute, aggregate, readout } = await import("./cohort.js");
 
     // A shelf with two genuine regions and a hole between them. 128 dims so the

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.
@@ -50,8 +50,25 @@
 // IS that reaction's vector under another name, which is the same leak wearing a
 // hat, and a reader with nine reactions is exactly who most needs this to hold.
 
-import { packVec } from "../core/embed.js";
-import { lineage } from "./terms.js";
+import { EMBED_MODEL, packVec } from "../core/embed.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.
@@ -216,7 +233,7 @@ export function reactionCorpus(events = [], {
         description: description ?? `${rows.length} reactions from one reader across ${byCorpus.size} corpora — what held their attention, and what did not.`,
         count: rows.length,
         dim: rows[0].vector.length,
-        model: "nomic-ai/nomic-embed-text-v1.5",
+        model: EMBED_MODEL,
         distance: "Cosine",
         role_map: {
             identity: "event", title: "label", subtitle: "corpus", temporal: "month",
@@ -237,8 +254,7 @@ 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");
+if (import.meta.url === `file://${globalThis.process?.argv?.[1]}` && process.argv[1].endsWith("/reactions.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");
 }