@fangorn-network/westmarch 2026.10.29 → 2026.11.4-dev

package/src/publish/view.js

@@ -4,8 +4,8 @@
 //   westmarch-view --app my-app [--repo catalog …] --out site/view     (a laptop, CI)
 //   site/worker.js, on a cron                                          (the free tier)
 //
-// Reads the registry and storage and nothing else: every repo the app presents (its
-// members' repos, less its exclusions, `appRepos`), at their latest heads; the schema
+// Reads the registry and storage and nothing else: every repo the app presents (any
+// publisher's repo of a name it lists), at their latest heads; the schema
 // (app.json's `types` + `relations`) comes from the caller. Embeds only records the view does not hold
 // yet, drops removed ones, and writes, through a store (a directory or an R2 bucket):
 //
@@ -15,21 +15,20 @@
 //
 // Stateless: the view's own files are its state, and each domain's manifest names the head
 // it was built from, so a run where no head moved reads one manifest per repo and nothing
-// else. A repo the app stops presenting (an exclusion) loses its domain on the next run.
+// else. A repo the app stops presenting loses its domain on the next run.
 //
-// The layout is quickbeam's (the hosted tier), so an app moves between the two by changing
-// one URL in its card:
-//   - URL layout, domain names (`domainFor`, byte-identical to quickbeam's `_domain_for`),
-//     row shape {track_id, fields, v}, manifest and catalog keys;
+// The layout is fixed, so any reader (shard.js, a tab, an agent) reads any app's view:
+//   - URL layout, domain names (`domainFor`: the publisher's address prefix and the repo),
+//     row shape {track_id, owner, fields, v}, manifest and catalog keys;
 //   - a record is a row: track_id = its CID, fields = payload + entityType (its type);
 //   - the schema: a declared type is embedded and shipped with exactly its role map;
-//   - the embedded text (`composeText` mirrors quickbeam's `compose_document_text`).
+//   - the embedded text (`composeText`).
 // The encoder is EmbeddingGemma (embed.js). Two runtimes of it agree closely but not bit for
 // bit, so the manifest names its `embedder` and this refuses to append to a view another
 // encoder built.
 //
-// ponytail: flat records. quickbeam folds a record's neighbours into its text and can fuse
-// publishers by shared identity; that is the hosted tier's job. A reference the schema
+// ponytail: flat records: a record's neighbours aren't folded into its text, and publishers
+// aren't fused by shared identity. A reference the schema
 // declares is written onto its source row instead (`linkRelations`), which is all a
 // serverless reader needs.
 
@@ -49,14 +48,13 @@ const MULTI = ["tags", "measures", "relations", "text"];
 // Refit coverage once a domain has grown this many times over what it was fit on.
 const COVERAGE_REFIT = 2;
 
-// ── the contract shared with quickbeam ────────────────────────────────────────
+// ── the view's contract ────────────────────────────────────────
 
 const slug = (s) => (String(s ?? "").replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "x");
-/** quickbeam `_domain_for` / registry `domainFor`, for an app id. */
-export const domainFor = (appId, owner, namespace) =>
-    `${slug(appId.slice(2, 10))}-${slug(owner.slice(2, 10))}-${slug(namespace)}`;
+/** A domain's name in the view: the publisher's address prefix and the repo. */
+export const domainFor = (owner, namespace) => `${slug(owner.slice(2, 10))}-${slug(namespace)}`;
 
-/** quickbeam `compose_document_text`, minus the `search_document: ` prefix that
+/** The text a row is embedded from, minus the `search_document: ` prefix that
  *  `embedDocumentDirect` adds itself. */
 export function composeText(fields, rm) {
     const tags = (rm.tags ?? []).map((t) => (typeof fields[t] === "string" ? fields[t] : "")).join(" ");
@@ -90,8 +88,8 @@ export function completeRoles(rm = {}) {
 }
 
 // ponytail: for a type the schema does not declare, a guess from field names and
-// value lengths — enough to show and search something, and loud about it. quickbeam's
-// `infer_roles` is richer; the fix either way is declaring the type.
+// value lengths — enough to show and search something, and loud about it. The fix is
+// declaring the type.
 export function guessRoles(rows) {
     const keys = [...new Set(rows.flatMap((r) => Object.keys(r)))].filter((k) => k !== "entityType");
     const find = (names) => keys.find((k) => names.includes(k.toLowerCase())) ?? null;
@@ -104,7 +102,7 @@ export function guessRoles(rows) {
     });
 }
 
-/** Merge the declared types a domain holds (most common first), like quickbeam's `domain_spec`. */
+/** Merge the declared types a domain holds (most common first). */
 export function domainSpec(schema, tags) {
     const decls = tags.map((t) => schema?.types?.[t]).filter(Boolean);
     if (!decls.length) return null;
@@ -148,11 +146,10 @@ export async function network(name = process.env.FANGORN_NETWORK || "baseSepolia
     return SupportedNetworks[name];
 }
 
-/** The IPFS gateway to read contents through: FANGORN_IPFS_GATEWAY, else the one in
- *  ~/.fangorn/config.json (what the fangorn CLI reads through), else none (the SDK default). */
+/** The IPFS gateway to read contents through: FANGORN_IPFS_GATEWAY, else none (the SDK
+ *  default, Fangorn's gateway). Not the deployer's CLI config: that would ship into the Worker. */
 export function ipfsGateway() {
-    let gateway = process.env.FANGORN_IPFS_GATEWAY ?? process.env.IPFS_GATEWAY;
-    try { gateway ??= JSON.parse(readFileSync(`${process.env.HOME}/.fangorn/config.json`, "utf8")).pinataGateway || undefined; } catch { /* no CLI config */ }
+    const gateway = process.env.FANGORN_IPFS_GATEWAY || process.env.IPFS_GATEWAY;
     return gateway && !/^https?:\/\//.test(gateway) ? `https://${gateway}` : gateway;
 }
 
@@ -170,7 +167,7 @@ export async function readOnlyFangorn() {
  *  `<owner>/<repo>` to `{ records: [{id, cid, type, payload}] }`, every one presented.
  *  A build that must not touch the chain — a candidate recipe graded before it ships —
  *  runs the exact code a real one does. */
-export function localFangorn(chain, { appId, owner }) {
+export function localFangorn(chain) {
     // Every version handed out is kept, so repoDiff can diff any two, as the SDK diffs two roots.
     const versions = new Map();
     const root = (k) => { const h = `0x${createHash("sha256").update(JSON.stringify(chain[k])).digest("hex")}`; versions.set(h, structuredClone(chain[k]?.records ?? [])); return h; };
@@ -182,9 +179,7 @@ export function localFangorn(chain, { appId, owner }) {
     };
     return {
         engine: { repoDiff }, reads: 0,
-        setAppId() {}, getAppId: () => appId,
-        getAppRegistry: () => ({ getAppOwner: async () => owner }),
-        appRepos: async () => Object.keys(chain).map((k) => ({ owner: k.split("/")[0], repo: k.split("/").slice(1).join("/"), root: root(k) })),
+        repos: async () => Object.keys(chain).map((k) => ({ owner: k.split("/")[0], repo: k.split("/").slice(1).join("/"), root: root(k) })),
         readRepo: async function (o, repo) { this.reads++; const c = chain[`${o}/${repo}`]; return { tip: c ? root(`${o}/${repo}`) : null, contents: { records: c?.records ?? [] } }; },
     };
 }
@@ -285,26 +280,26 @@ const sha256 = (s) => createHash("sha256").update(s).digest("hex");
 /**
  * Bring the view up to date with what the app presents. `fangorn` is an SDK client (reads
  * only); `schema` is app.json's { types, relations } (a type it leaves out is guessed); the view goes to `store`, or the directory `out`. `repos` narrows it to those repo
- * names (every publisher's); without it, every repo the app presents. `fromBlock` must be
+ * names (every publisher's); without it, every repo. `fromBlock` must be
  * at or before the first update to a repo the app presents, or a repo the scan misses is left out;
  * left out, the SDK's deployment start. `embedBatch(texts)` embeds many at once where the
  * encoder batches (a Worker's AI binding); `embedder` is what the manifest records.
- * `presented` replaces the `appRepos` scan with a list the caller keeps itself
- * ([{owner, repo, root}], exclusions already applied), as a Worker does across runs.
+ * `presented` replaces the `repos` scan with a list the caller keeps itself
+ * ([{owner, repo, root}]), as a Worker does across runs.
  * Returns per-domain counts of what changed.
  */
 export async function publishView({ fangorn, app, schema, repos, out, store = fsStore(out), fromBlock, presented, rebake = false,
                                     embed = embedDocumentDirect, embedBatch = (ts) => Promise.all(ts.map(embed)),
-                                    embedder = EMBEDDER, log = console.log, shardRows = 20000, concurrency = 4, open = (p) => p }) {
-    fangorn.setAppId(app);
-    const appId = fangorn.getAppId();
+                                    embedder = EMBEDDER, log = console.log, shardRows = 20000, concurrency = 4 }) {
     schema = schemaOf(schema);
     const declared = Object.keys(schema.types);
     log(`schema: ${declared.length ? declared.join(", ") : "no declared types"}`);
     const schemaHash = sha256(JSON.stringify(schema));
 
-    // Every repo the app presents, at its accepted head: one log scan, exclusions applied.
-    const listed = (presented ?? await retry(() => fangorn.appRepos(fromBlock == null ? {} : { fromBlock: BigInt(fromBlock) })))
+    // Every repo the app presents, at its latest head: one log scan.
+    // ponytail: open: any publisher's repo of a listed name, and with no names, every repo.
+    // Read the app's repo of citations instead once the SDK reads citations.
+    const listed = (presented ?? await retry(() => fangorn.repos(fromBlock == null ? {} : { fromBlock: BigInt(fromBlock) })))
         // ponytail: "fangorn.schema" is where apps shipped before 2026-10-22 committed their schema; never data.
         .filter((t) => t.repo !== "fangorn.schema" && (!repos?.length || repos.includes(t.repo)));
     log(`${listed.length} repo(s) presented${repos?.length ? ` of ${repos.join(", ")}` : ""}`);
@@ -316,19 +311,19 @@ export async function publishView({ fangorn, app, schema, repos, out, store = fs
     const queue = [...listed];
     const worker = async () => {
         for (let t; (t = queue.shift()) !== undefined;) {
-            const domain = domainFor(appId, t.owner, t.repo);
+            const domain = domainFor(t.owner, t.repo);
             live.add(domain);
             // One repo failing (unreadable, the encoder out for the day) keeps its last view and
             // does not stop the others; the next run tries it again.
             const r = await publishDomain({ fangorn, store, schema, schemaHash, publisher: t.owner, repo: t.repo, head: t.root, domain,
-                dir: `cdn/domains/${domain}`, rebake, embedBatch, embedder, log, shardRows, open })
+                dir: `cdn/domains/${domain}`, rebake, embedBatch, embedder, log, shardRows })
                 .catch((e) => { log(`${domain}: ✗ ${e.message}; left as it was`); return { added: 0, removed: 0, error: e.message }; });
             if (r) report[domain] = r;
         }
     };
     await Promise.all(Array.from({ length: concurrency }, worker));
 
-    // What the app no longer presents (excluded, or its publisher banned) is not served.
+    // What the app no longer presents is not served.
     for (const d of await store.list("cdn/domains")) {
         if (live.has(d)) continue;
         const m = await readJson(store, `cdn/domains/${d}/manifest`, null);
@@ -353,7 +348,7 @@ async function retry(f, tries = 6) {
 }
 
 const CHECKPOINT = 2048;   // rows embedded between saves; a killed run redoes at most this many
-async function publishDomain({ fangorn, store, schema, schemaHash, publisher, repo, head, domain, dir, rebake, embedBatch, embedder, log, shardRows, open }) {
+async function publishDomain({ fangorn, store, schema, schemaHash, publisher, repo, head, domain, dir, rebake, embedBatch, embedder, log, shardRows }) {
     // The head the domain was built from, and the schema it was built under: neither moved,
     // nothing to read. This is what keeps a cron run with nothing new to one read per repo.
     const was = rebake ? null : await readJson(store, `${dir}/manifest`, null);
@@ -369,9 +364,11 @@ async function publishDomain({ fangorn, store, schema, schemaHash, publisher, re
         ? await retry(() => fangorn.engine.repoDiff(was.head, head)).catch((e) => { log(`${domain}: diff from ${was.head} failed (${e.message}); reading it whole`); return null; })
         : null;
     const got = diff?.superseded ? diff.puts : (await retry(() => fangorn.readRepo(publisher, repo))).contents.records;
-    // `open`: a private app's rows are sealed on chain (x402.js's sealRow); the Worker opens them here.
-    const records = new Map(await Promise.all(got.filter((r) => r.payload && typeof r.payload === "object")
-        .map(async (r) => [r.cid, { id: r.id, fields: { ...(await open(r.payload)), entityType: r.type } }])));
+    // `@`-ids (`@card`, `@deposit/<generation>`) are the protocol's records, not the publisher's data.
+    const records = new Map(got.filter((r) => r.payload && typeof r.payload === "object" && !String(r.id).startsWith("@"))
+        .map((r) => [r.cid, { id: r.id, fields: { ...r.payload, entityType: r.type,
+            // A record its publisher sells (`fangorn commit --paid`): what a buyer quotes it by, and its price.
+            ...(r.payload["@terms"]?.terms ? { sale: { publisher, repo, id: r.id, price: String(r.payload["@terms"].terms.price) } } : {}) } }]));
     linkRelations(records, schema);
     const fieldsOf = (cid) => records.get(cid).fields;
 
@@ -449,7 +446,7 @@ async function publishDomain({ fangorn, store, schema, schemaHash, publisher, re
         const ids = fresh.slice(i, i + 32);
         try {
             const vs = await embedBatch(ids.map((id) => composeText(fieldsOf(id), rolesOf.get(fieldsOf(id).entityType))));
-            ids.forEach((id, j) => lines.push(JSON.stringify({ track_id: id, fields: fieldsOf(id), v: packVec(vs[j]) })));
+            ids.forEach((id, j) => lines.push(JSON.stringify({ track_id: id, owner: publisher, fields: fieldsOf(id), v: packVec(vs[j]) })));
         } catch (e) {
             // The encoder gave out (Workers AI's free daily allowance, say): keep what is embedded
             // and come back for the rest. Nothing served yet, nothing to save: fail as before.
@@ -545,6 +542,8 @@ export async function writeCatalog(store) {
         generated_at: Math.floor(Date.now() / 1000), embedding_model: EMBED_MODEL,
         domains: domains.map((m) => ({
             name: m.name, description: m.description, count: m.count, dim: m.dim,
+            // Whose it is: a reader can list publishers without opening a manifest.
+            ...(m.filter?.owner?.length === 1 ? { publisher: m.filter.owner[0], repo: m.filter.repo?.[0] } : {}),
             bytes: m.shards.reduce((s, x) => s + x.bytes, 0), shard_count: m.shards.length,
             entity_types: m.entity_types.map((e) => e.type), manifest: `${m.name}/manifest.json`,
             ...(m.link_hosts?.length ? { link_hosts: m.link_hosts } : {}),
@@ -563,11 +562,11 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     const manifestOf = (dir, d) => JSON.parse(readFileSync(`${dir}/cdn/domains/${d}/manifest`, "utf8"));
     const rec = (cid, type, payload, id = cid) => ({ id, cid, type, payload });
 
-    // quickbeam's own outputs, pinned: the contract, not an approximation of it.
-    eq(domainFor(`0x${"7e1497af".padEnd(64, "0")}`, "0x55cf6bd2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "media"), "7e1497af-55cf6bd2-media", "domain name = quickbeam's");
+    // The contract, pinned: domain names and embedded text never drift.
+    eq(domainFor("0x55cf6bd2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "media"), "55cf6bd2-media", "domain name: owner prefix and repo");
     eq(composeText({ name: "Oak", family: "Fagaceae", description: "big", entityType: "t" },
                    completeRoles({ title: "name", tags: ["family"], text: ["description"] })),
-       "Title: Oak. Tags: Fagaceae. big", "embedded text = quickbeam's compose_document_text");
+       "Title: Oak. Tags: Fagaceae. big", "embedded text is pinned");
 
     const APP = `0x${"ab".repeat(32)}`, OWNER = `0x${"11".repeat(20)}`, PUB = `0x${"22".repeat(20)}`;
     const TAG = "shop.item.v1";
@@ -580,7 +579,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
             rec("c3", "shop.note.v1", { title: "Note", body: "an undeclared type, with a body long enough to count as its text field" }),
         ] },
     };
-    const fangorn = localFangorn(chain, { appId: APP, owner: OWNER });
+    const fangorn = localFangorn(chain);
     const embedded = [];
     const embed = async (t) => { embedded.push(t); const v = new Array(EMBED_DIM).fill(0); for (const w of t.split(/\W+/)) if (w) v[w.length % EMBED_DIM] += 1; const n = Math.hypot(...v) || 1; return v.map((x) => x / n); };
     const out = mkdtempSync(`${tmpdir()}/view-`);
@@ -594,7 +593,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     embedded.length = 0; rmSync(`${out}/vectors.ndjson`);
     const run = () => publishView({ fangorn, app: APP, schema, out, embed, log: () => {} });
 
-    const d = domainFor(APP, PUB, "shop");
+    const d = domainFor(PUB, "shop");
     const split = mkdtempSync(`${tmpdir()}/view-`);
     await publishView({ fangorn, app: APP, schema, out: split, embed, log: () => {}, shardRows: 2 });
     eq(manifestOf(split, d).shards.map((s) => s.count), [2, 1], "rows past shardRows go to the next shard");
@@ -640,13 +639,13 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     const { rolesFrom } = await import("../core/roles.js");
     eq(getRow(got, "b2", rolesFrom([m]))?.id, "c2b", "get by the publisher's own id, not the CID");
 
-    // An exclusion: the app stops presenting the repo, and its domain stops being served.
+    // The app stops presenting the repo, and its domain stops being served.
     const shop = chain[`${PUB}/shop`];
     delete chain[`${PUB}/shop`];
     eq((await run())[d], { added: 0, removed: 2, dropped: true }, "a repo the app no longer presents is dropped");
     eq([existsSync(`${out}/cdn/domains/${d}`), JSON.parse(readFileSync(`${out}/cdn/catalog`, "utf8")).domains], [false, []], "with its files and its catalog entry");
     chain[`${PUB}/shop`] = shop;
-    eq((await run())[d], { added: 2, removed: 0 }, "and a restore brings it back");
+    eq((await run())[d], { added: 2, removed: 0 }, "and presenting it again brings it back");
 
     const setEmbedder = (e) => { const x = manifestOf(out, d); x.embedder = e; x.head = "moved"; writeFileSync(`${out}/cdn/domains/${d}/manifest`, JSON.stringify(x)); };
     setEmbedder({ ...EMBEDDER, runtime: "transformers.js cuda" });
@@ -660,7 +659,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     chain[BIG] = { records: Array.from({ length: 80 }, (_, i) => ({ id: `r${i}`, cid: `big${i}`, type: "shop.item.v1", payload: { sku: `r${i}`, name: `Thing ${i}` } })) };
     let budget = 40;
     const capped = (ts) => (budget -= ts.length) < 0 ? Promise.reject(new Error("daily allowance used")) : Promise.all(ts.map(embed));
-    const bd = domainFor(APP, PUB, "big");
+    const bd = domainFor(PUB, "big");
     eq((await publishView({ fangorn, app: APP, schema, out: big, repos: ["big"], embedBatch: capped, log: () => {} }))[bd],
        { added: 32, removed: 0, partial: true }, "an encoder that gives out keeps what it embedded");
     eq([manifestOf(big, bd).count, manifestOf(big, bd).head], [32, null], "served, and the head not taken");
@@ -730,8 +729,8 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
                 rec("i1", T, { item_id: "a#1", heading: "Rezone, committee", part_of: { local: "m" } }),
                 rec("i2", T, { item_id: "b#4", heading: "Rezone, council", cites: { local: "m" } }),
                 rec("m1", M, { matter_id: "plover:7", title: "Rezone" }, "m")] } };
-        const o = mkdtempSync(`${tmpdir()}/view-`), dr = domainFor(APP, PUB, "civic");
-        const go = () => publishView({ fangorn: localFangorn(rel, { appId: APP, owner: OWNER }), app: APP, schema: relSchema, out: o, embed, log: () => {} });
+        const o = mkdtempSync(`${tmpdir()}/view-`), dr = domainFor(PUB, "civic");
+        const go = () => publishView({ fangorn: localFangorn(rel), app: APP, schema: relSchema, out: o, embed, log: () => {} });
         const rows = async () => Object.fromEntries([...(await loadDomain(fsStore(o), `cdn/domains/${dr}`)).rows.values()]
             .map((r) => [r.fields.heading ?? r.fields.title, r.fields.part_of ?? r.fields.cites ?? null]));
         await go();
@@ -767,5 +766,5 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
         await r2.del(`cdn/domains/${d}`);
         eq([...objs.keys()].filter((k) => k.includes(d)), [], "del removes a folder and everything under it");
     }
-    console.log("view.js self-check ok — domain names and embedded text match quickbeam's, the schema is applied, an unmoved head reads nothing, additions ship as delta shards, removals compact the domain, an excluded repo is dropped and a restored one returns, the real reader sees exactly the live records by the publisher's id, another encoder's view is refused, declared references land on their source rows, and the view builds the same into R2");
+    console.log("view.js self-check ok — domain names and embedded text are stable, the schema is applied, an unmoved head reads nothing, additions ship as delta shards, removals compact the domain, an excluded repo is dropped and a restored one returns, the real reader sees exactly the live records by the publisher's id, another encoder's view is refused, declared references land on their source rows, and the view builds the same into R2");
 }

package/template/README.md

@@ -2,22 +2,20 @@
 
 This repo holds the app's recipe, not its data: what a record is (`app.json`), what a good
 answer looks like (`eval/`), and the Worker that serves it (`wrangler.json`). It can be
-public. The data lives on chain and IPFS, committed by the app's members; the Worker
+public. The data lives on chain and IPFS, committed by its publishers; the Worker
 indexes it every 5 minutes, and serves the site, the view, `/mcp` and the agent card.
 
 ## Deploy
 
 [![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/fangorn-network/westmarch/tree/main/template)
 
-1. Claim the app at [fangorn.network](https://fangorn.network).
-2. Press the button. Name the Worker after the app (`my-app`) and its R2 bucket
+1. Press the button. Name the Worker after the app (`my-app`) and its R2 bucket
    `my-app-view`. Cloudflare copies this repo into your GitHub, makes the bucket and
    deploys; every push to `main` deploys again.
-3. Back at fangorn.network, give the app its Worker's URL. Your wallet registers the
-   app's agent and binds its card there.
+2. At fangorn.network, give the app its Worker's URL. Your wallet creates the app's repo,
+   `<your wallet>:my-app`, and binds its card there.
 
-An app name with a dot or an underscore can't be a Worker name: set `"app"` in
-`app.json` to the name you claimed.
+An app name with a dot or an underscore can't be a Worker name.
 
 `npm run build` (`westmarch build`) is what Cloudflare runs: it builds the site and writes
 the app's config into `wrangler.json`, without signing or deploying anything.
@@ -29,13 +27,13 @@ fields in `role_map`. Push, and the Worker follows.
 
 ## Publish data
 
-Any member of the app commits records of its type, from anywhere:
+Any wallet commits records of its type, from anywhere:
 
 ```sh
 echo '{"records":[{"id":"first","type":"my-app.item.v1","payload":{"id":"first","title":"Hello","text":"The first item.","tags":["demo"]}}]}' > items.json
-fangorn --app my-app repo init items
-fangorn --app my-app commit items.json -m "first items"
-fangorn --app my-app push
+fangorn repo init items
+fangorn commit items.json -m "first items"
+fangorn push
 ```
 
 The view picks it up within 5 minutes at `<url>/view`. A source that crawls something

package/template/package.json

@@ -6,7 +6,7 @@
     "deploy": "wrangler deploy"
   },
   "dependencies": {
-    "@fangorn-network/westmarch": "2026.10.29",
+    "@fangorn-network/westmarch": "2026.11.3",
     "@huggingface/transformers": "^4.3.1",
     "wrangler": "^4.83.0"
   }

package/plugin/scripts/fx.mjs

@@ -1,266 +0,0 @@
-#!/usr/bin/env node
-// The Fangorn app index, headless. One command per verb, JSON on stdout.
-//
-// WHY THERE IS NO MCP SERVER HERE
-// -------------------------------
-// An index that POINTS AT apps rather than hosting them needs no runtime of its
-// own. Every verb below is a function `@fangorn/westmarch` already exports, and
-// the agent's shell is the transport. Nobody has to stand up a server to be in
-// the index — a publisher bakes a view, and that is the whole obligation.
-//
-// WHY THIS IS A PLUGIN AND NOT A PAGE
-// -----------------------------------
-// One thing here is not stateless: the taste kernel. It lives in
-// ~/.fangorn/taste.json — on the filesystem, between the human and the agent —
-// because it has to outlive any one app, any one tab and any one ORIGIN.
-// localStorage cannot do that: a taste learned in fangorn.tv is invisible to the
-// next app by construction, which is the whole reason apps keep rebuilding it.
-// A file the agent can read is the shortest thing that carries it across.
-//
-// ponytail: a plaintext file, no wallet, no sync. `src/taste/vault.js` is the
-// upgrade path — same object, sealed to a signature, kept in the graph — and it
-// is worth doing the day the kernel needs to travel between machines, not now.
-// ponytail: every command re-fetches its view. Fine at 917 rows, ~seconds at
-// 42k; add a disk cache keyed by view URL when a big corpus makes it hurt.
-
-import { homedir } from "node:os";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { configure, domainManifests, loadShard, trimView } from "../../src/core/shard.js";
-import { findCorpora, sourcesFromChain } from "../../src/discover/directory.js";
-import { linkOf, rolesFrom, textOf, titleOf } from "../../src/core/roles.js";
-import { exportTaste, recommend, taste } from "../../src/taste/taste.js";
-import { EMBED_MODEL, embedQuery, packVec, unpackVec } from "../../src/core/embed.js";
-import { browse, describe, facet, getRow, neighbors, search } from "../../src/agent/tools.js";
-
-const HOME = process.env.FANGORN_HOME ?? join(homedir(), ".fangorn");
-const TASTE = join(HOME, "taste.json");
-
-// ── the kernel on disk ───────────────────────────────────────────────────────
-const store = () => { try { return JSON.parse(readFileSync(TASTE, "utf8")); } catch { return { model: EMBED_MODEL, likes: [], dislikes: [] }; } };
-const save = (s) => { mkdirSync(HOME, { recursive: true }); writeFileSync(TASTE, JSON.stringify(s, null, 1)); };
-/** Picks are stored PACKED (base64 int8, the shard encoding) and unpacked here.
- *  Storing the picks rather than only the derived vector is what keeps the
- *  kernel correctable: you can read what it was built from and drop one. */
-const picks = (l = []) => l.map((p) => ({ ...p, vector: unpackVec(p.v) })).filter((p) => p.vector);
-const kernel = (s = store()) => taste(picks(s.likes), picks(s.dislikes));
-
-// ── args ─────────────────────────────────────────────────────────────────────
-const argv = process.argv.slice(2);
-const [cmd, ...rest] = argv;
-const pos = rest.filter((a) => !a.startsWith("--"));
-const flag = (n, d) => { const a = rest.find((x) => x.startsWith(`--${n}=`)); return a === undefined ? d : a.slice(n.length + 3); };
-const num = (n, d) => { const v = flag(n); return v === undefined ? d : Number(v); };
-const pairs = (s) => s ? Object.fromEntries(String(s).split(",").map((p) => p.split("=").map((x) => x.trim()))) : undefined;
-const list = (s) => String(s ?? "").split(",").map((x) => x.trim()).filter(Boolean);
-const out = (o) => console.log(JSON.stringify(o, null, 1));
-const die = (m) => { console.error(m); process.exit(1); };
-
-// ── a view, loaded ───────────────────────────────────────────────────────────
-let roles = rolesFrom([], []);
-async function load(view) {
-    if (!view) die("need a view URL");
-    const base = trimView(view);
-    configure({
-        resolveView: () => base,
-        // Roles must be ready BEFORE the first row is parsed: rowText runs during
-        // parsing, so deriving them afterwards leaves every row with empty text
-        // and lexical search silently matching nothing.
-        onManifests: (ms) => { roles = rolesFrom(ms); },
-        rowText: (f) => textOf(f, roles),
-    });
-    const rows = await loadShard(base);
-    roles = rolesFrom(domainManifests(), rows);
-    let model = null;
-    try { model = (await (await fetch(`${base}/cdn/catalog`)).json()).embedding_model ?? null; } catch { /* unranked, not fatal */ }
-    return { rows, roles, base, model };
-}
-
-/** A query vector, or null with the reason. Never throws: every verb here
- *  degrades to lexical and SAYS so rather than returning confident nonsense. */
-const qvOf = async (q) => { try { return { qv: await embedQuery(q), why: null }; } catch (e) { return { qv: null, why: e?.message ?? String(e) }; } };
-
-/** The corpus and the kernel must share an embedding space or cosine between
- *  them is noise that still looks like a score. */
-const mismatch = (model, s) => model && s.model && model !== s.model
-    ? `taste was built with ${s.model}, this corpus is ${model} — scores would be noise` : null;
-
-const sources = async () => {
-    const f = flag("sources"); if (f) return list(f);
-    if (process.env.FANGORN_SOURCES) return list(process.env.FANGORN_SOURCES);
-    try { return JSON.parse(readFileSync(join(HOME, "sources.json"), "utf8")); } catch { /* none pinned */ }
-    return chainSources();
-};
-
-// Every app bound on chain, the scan fangorn-mcp's list-apps runs, on FANGORN_NETWORK
-// (default arbitrumSepolia). From its AppRegistry's deployment; --from-block overrides.
-async function chainSources() {
-    const [{ Fangorn }, { generatePrivateKey }, { network }] = await Promise.all([
-        import("@fangorn-network/sdk"), import("viem/accounts"), import("../../src/publish/view.js")]);
-    const config = await network();
-    const fangorn = Fangorn.create({ privateKey: generatePrivateKey(), config });   // reads only
-    const { sources } = await sourcesFromChain(fangorn, { fromBlock: BigInt(flag("from-block", String(config.appRegistryFromBlock))) });
-    return sources;
-}
-
-// ── verbs ────────────────────────────────────────────────────────────────────
-switch (cmd) {
-
-// WHICH app has this. Downloads no corpus — coverage centroids only, ~4KB each.
-case "find": {
-    const src = await sources();
-    if (!src.length) die("no apps found on chain; pass --sources=a,b or write ~/.fangorn/sources.json");
-    out(await findCorpora(pos.join(" "), { sources: src, embed: embedQuery, model: EMBED_MODEL, limit: num("limit", 10) }));
-    break;
-}
-
-case "describe": {
-    const { rows, roles: r, model } = await load(pos[0]);
-    out({
-        ...describe(rows), model,
-        shape: r.declared ? "declared" : "sniffed",
-        title: r.title, subtitle: r.subtitle, tags: r.tags, text: r.text,
-        entityTypes: r.entityTypes, gates: r.gates,
-        // Where the reader goes next. The index's job ends here.
-        launch: r.launch, externalUrl: r.externalUrl, actions: r.actions,
-    });
-    break;
-}
-
-case "browse": {
-    const { rows, roles: r } = await load(pos[0]);
-    out(browse(rows, r, { type: flag("type"), where: pairs(flag("where")), sort: flag("sort"),
-                          desc: flag("asc") === undefined, limit: num("limit", 20), offset: num("offset", 0), fields: list(flag("fields")) }));
-    break;
-}
-
-case "search": {
-    const { rows, roles: r } = await load(pos[0]);
-    const q = pos.slice(1).join(" ");
-    const { qv, why } = await qvOf(q);
-    out({ query: q, mode: qv ? "semantic where rows have vectors" : "lexical", ...(why ? { why } : {}),
-          hits: search(rows, q, r, { qv, limit: num("limit", 10), where: pairs(flag("where")), fields: list(flag("fields")) }) });
-    break;
-}
-
-case "facet": {
-    const { rows } = await load(pos[0]);
-    out(facet(rows, pos[1], { limit: num("limit", 20), where: pairs(flag("where")) }));
-    break;
-}
-
-case "row": {
-    const { rows, roles: r } = await load(pos[0]);
-    const g = getRow(rows, pos[1], r);
-    out(g ? { ...g, url: linkOf(rows.find((x) => x.id === g.id) ?? {}, r) } : null);
-    break;
-}
-
-case "similar": {
-    const { rows, roles: r } = await load(pos[0]);
-    out(neighbors(rows, pos[1], r, { limit: num("limit", 10), fields: list(flag("fields")) }));
-    break;
-}
-
-// ── the kernel ───────────────────────────────────────────────────────────────
-case "like": case "dislike": {
-    const { rows, roles: r, base, model } = await load(pos[0]);
-    const s = store();
-    const into = cmd === "like" ? s.likes : s.dislikes;
-    const added = [];
-    for (const id of pos.slice(1)) {
-        const row = rows.find((x) => x.id === id);
-        if (!row) { console.error(`no row ${id}`); continue; }
-        if (!row.vector) { console.error(`${id} has no vector — nothing to learn from`); continue; }
-        // Newest last: taste() weights by recency, so order in the file is signal.
-        const at = into.findIndex((p) => p.id === id);
-        if (at >= 0) into.splice(at, 1);
-        into.push({ id, title: titleOf(row, r), view: base, at: new Date().toISOString().slice(0, 10), v: packVec(Array.from(row.vector)) });
-        added.push(id);
-    }
-    s.model ??= model ?? EMBED_MODEL;
-    save(s);
-    const t = kernel(s);
-    out({ added, likes: s.likes.length, dislikes: s.dislikes.length, taste: t && exportTaste(t), file: TASTE });
-    break;
-}
-
-case "forget": {
-    const s = store();
-    const drop = new Set(pos);
-    const before = s.likes.length + s.dislikes.length;
-    s.likes = s.likes.filter((p) => !drop.has(p.id));
-    s.dislikes = s.dislikes.filter((p) => !drop.has(p.id));
-    save(s);
-    out({ removed: before - s.likes.length - s.dislikes.length, likes: s.likes.length, dislikes: s.dislikes.length });
-    break;
-}
-
-case "taste": {
-    const s = store();
-    const t = kernel(s);
-    out(t ? { model: s.model, n: t.n, from: t.from, rejected: t.rejected, drift: t.drift,
-              // Where each pick was learned. A kernel built in one publisher's
-              // corpus is meant to be pointed at another's — this is the record
-              // of whether it actually has been.
-              views: [...new Set([...s.likes, ...s.dislikes].map((p) => p.view))],
-              export: exportTaste(t), file: TASTE }
-            : { n: 0, file: TASTE, note: "nothing liked yet — `fx like <view> <id>`" });
-    break;
-}
-
-// The headline: rank a corpus by a taste learned somewhere else entirely.
-case "recommend": {
-    const { rows, roles: r, model } = await load(pos[0]);
-    const s = store();
-    const t = kernel(s);
-    if (!t) die("no taste yet — `fx like <view> <id>` first");
-    const warn = mismatch(model, s);
-    if (warn) die(warn);
-    const seen = new Set([...s.likes, ...s.dislikes].map((p) => p.id));
-    out({ from: t.from, against: pos[0],
-          hits: recommend(rows, t, { limit: num("limit", 10), exclude: seen })
-              .map(({ row, score }) => ({ id: row.id, title: titleOf(row, r), score, url: linkOf(row, r) })) });
-    break;
-}
-
-// ── the handoff. The index points; the app does the work. ────────────────────
-case "launch": {
-    const { rows, roles: r } = await load(pos[0]);
-    const id = flag("row");
-    if (id) {
-        const row = rows.find((x) => x.id === id);
-        if (!row) die(`no row ${id}`);
-        out({ url: linkOf(row, r), title: titleOf(row, r) });
-        break;
-    }
-    if (!r.launch) die("this corpus declares no presentation.launch — nowhere to hand off to");
-    const t = kernel();
-    const fill = { taste: t ? JSON.stringify(exportTaste(t)) : "", q: pos.slice(1).join(" ") };
-    const url = String(r.launch).replace(/\{(\w+)\}/g, (_, k) => encodeURIComponent(fill[k] ?? ""));
-    const u = new URL(url);
-    if (u.protocol !== "https:" && u.protocol !== "http:") die(`refusing a ${u.protocol} launch URL`);
-    // The kernel travels in the URL because that is the only channel a page on
-    // someone else's origin can receive it on. It is the app's copy from here.
-    out({ url: u.toString(), carries: t ? { n: t.n, from: t.from } : null });
-    break;
-}
-
-default:
-    console.log(`fx <verb>
-
-  find <query> [--sources=a,b|--from-block=N]       which app has this. No corpus downloaded.
-  describe <view>                                  rows, field coverage, roles, where it hands off
-  browse <view> [--type= --where=k=v --sort= --asc --limit= --offset=]
-  search <view> <query> [--where=k=v --limit=]     semantic where rows have vectors, else lexical
-  facet <view> <field> [--where=k=v --limit=]      count a field's values
-  row <view> <id>                                  one record, whole
-  similar <view> <id> [--limit=]                   nearest by vector
-
-  like|dislike <view> <id...>                      teach the kernel. Writes ${TASTE}
-  forget <id...>                                   drop picks from it
-  taste                                            what it is, and what it was built from
-  recommend <view> [--limit=]                      rank ANY corpus by it
-
-  launch <view> [query] | launch <view> --row=<id> the handoff URL, carrying the kernel`);
-}

package/site/dist/assets/AccountNotFoundScreen-C4njXc69-DyVH4CEz.js

@@ -1 +0,0 @@
-import{$ as e,D as t}from"./privy-context-81KmsBw2-DiR6-Yq8.js";import{t as n}from"./jsx-runtime-CndCZlyt.js";import{t as r}from"./createLucideIcon-BsERoFTA.js";import{n as i}from"./modal-context-CwmSeFcv-DPWNJrfK.js";import{t as a}from"./ScreenLayout-OwaQQcxH-cfOTmyl0.js";var o=r(`circle-question-mark`,[[`circle`,{cx:`12`,cy:`12`,r:`10`,key:`1mglay`}],[`path`,{d:`M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3`,key:`1u773s`}],[`path`,{d:`M12 17h.01`,key:`p32p05`}]]),s=n(),c=({title:e=`Account not found`,subtitle:t,appName:n=`this app`,ctaText:r=`Try logging in again`,onRetry:i})=>(0,s.jsx)(a,{title:e,subtitle:t||`Please try logging in again or go to ${n} to create an account.`,icon:o,iconVariant:`warning`,primaryCta:{label:r,onClick:i},watermark:!0}),l={component:()=>{let{navigate:n,setModalData:r,data:a}=i(),o=t(),{getAuthMeta:l,client:u}=e();return(0,s.jsx)(c,{appName:o?.name,onRetry:()=>{let e=l();r({...a,login:{...a?.login,...e?.disableSignup?{disableSignup:!0}:{}}}),u?.authFlow&&(u.authFlow=void 0),n(`LandingScreen`)}})}};export{l as AccountNotFoundScreen,l as default,c as AccountNotFoundScreenView};