@fangorn-network/westmarch 0.0.20-dev → 2026.10.2-0.0-dev

package/src/core/embed.js

@@ -1,55 +1,54 @@
-// In-browser query embedder. Lifted from embeddings/examples/src/lib/embed.ts —
-// the query vector MUST come out of the same model and post-processing as the
+// The network's one embedding model, on both sides of every search. The query
+// vector MUST come out of the same model, prompt and post-processing as the
 // document vectors in the shard, or cosine is meaningless.
 //
-// Document side (quickbeam/embeddings.py): fastembed nomic-embed-text-v1.5 on
-//   "search_document: " + text, then matryoshka(vec, 256).
-// Query side (here): same model on "search_query: " + text (nomic is asymmetric),
-//   then the identical matryoshka.
+// EmbeddingGemma-300m, asymmetric by prompt (QUERY / DOCUMENT below), truncated
+// to 256 dims (it is Matryoshka-trained) and L2-normalized. Two runtimes run it:
+//   - a Fangorn app's Worker (Workers AI `@cf/google/embeddinggemma-300m`), the
+//     free tier's indexer (site/worker.js), on the document side;
+//   - transformers.js here, in a reader's tab or a Node publisher, on either side.
+// They agree closely but not bit for bit, so a view names its `embedder` and is only
+// ever appended to by the runtime that made it (view.js).
 //
-// If the embedding pipeline switches model or dim, change MODEL/DIM here to match.
-// transformers.js is dynamically imported so its ~MB runtime stays out of the main
+// transformers.js is dynamically imported so its runtime stays out of the main
 // bundle and a load failure degrades to lexical search instead of breaking the app.
 
-const MODEL = "nomic-ai/nomic-embed-text-v1.5";
+const MODEL = "google/embeddinggemma-300m";
+const ONNX = "onnx-community/embeddinggemma-300m-ONNX";
 const DIM = 256;
-// The document side's precision. q8 everywhere by default (the browser's queries are q8).
-// WESTMARCH_EMBED_DTYPE=fp16 is a different encoder (~0.96 cosine to q8): a view records it
-// and refuses to mix the two (view.js), so switching an app is one --rebake.
+/** The model card's retrieval prompts. Exported so every runtime uses the same text. */
+export const QUERY = "task: search result | query: ";
+export const DOCUMENT = "title: none | text: ";
+// The document side's precision in transformers.js. q8 by default (the browser's queries are q8).
+// EmbeddingGemma's activations do not survive fp16; WESTMARCH_EMBED_DTYPE=fp32 is the slow exact one.
 const DTYPE = globalThis.process?.env?.WESTMARCH_EMBED_DTYPE ?? "q8";
 export const EMBED_DTYPE = DTYPE;
 
-// Stamped onto every vector a publisher commits. Vectors from different models
-// (or dims) are not comparable — cosine between them is noise, and silently so.
-// The shard bake drops any vector whose stamp doesn't match rather than blending
-// corpora, which is the one thing that can quietly ruin a shared index.
+// Stamped onto every view. Vectors from different models (or dims) are not
+// comparable — cosine between them is noise, and silently so.
 export const EMBED_MODEL = MODEL;
 export const EMBED_DIM = DIM;
+/** A short name for the space a taste or a reaction lives in. */
+export const SPACE = `embeddinggemma-${DIM}`;
 
-let _extractor = null;
-const extractor = () => (_extractor ??= (async () => {
-    const { pipeline } = await import("@huggingface/transformers");
-    // WESTMARCH_EMBED_DEVICE=cuda puts the publisher's document side on a GPU (Node only; needs
-    // onnxruntime-node's CUDA binaries and the matching CUDA runtime, cuBLAS, cuRAND and cuDNN on
-    // LD_LIBRARY_PATH). q8's integer ops do not run on CUDA, so q8 there is slower than on CPU:
-    // pair it with WESTMARCH_EMBED_DTYPE=fp16, which is ~4x faster than CPU q8, batched.
+let _model = null;
+const model = () => (_model ??= (async () => {
+    const { AutoModel, AutoTokenizer } = await import("@huggingface/transformers");
+    // WESTMARCH_EMBED_DEVICE=cuda puts a Node publisher's document side on a GPU.
     const device = globalThis.process?.env?.WESTMARCH_EMBED_DEVICE;
-    return pipeline("feature-extraction", MODEL, { dtype: DTYPE, ...(device && { device }) });
+    const [tokenizer, m] = await Promise.all([AutoTokenizer.from_pretrained(ONNX),
+        AutoModel.from_pretrained(ONNX, { dtype: DTYPE, ...(device && { device }) })]);
+    // `sentence_embedding`, not mean pooling: the model's dense head runs after the pool.
+    return async (texts) => {
+        const { sentence_embedding: e } = await m(await tokenizer(texts, { padding: true, truncation: true }));
+        const d = e.dims.at(-1);
+        return texts.map((_, j) => matryoshka(e.data.slice(j * d, (j + 1) * d)));
+    };
 })());
 
-/** Standardize over the full vector, slice to `dim`, L2-normalize the slice. */
-function matryoshka(vec, dim = DIM) {
-    const n = vec.length;
-    let mean = 0;
-    for (let i = 0; i < n; i++) mean += vec[i];
-    mean /= n;
-    let varsum = 0;
-    for (let i = 0; i < n; i++) varsum += (vec[i] - mean) ** 2;
-    const std = Math.sqrt(varsum / n + 1e-5);
-
-    const out = new Array(Math.min(dim, n));
-    for (let i = 0; i < out.length; i++) out[i] = (vec[i] - mean) / std;
-
+/** Truncate to `dim` and L2-normalize: EmbeddingGemma's Matryoshka truncation. */
+export function matryoshka(vec, dim = DIM) {
+    const out = Array.from(vec.slice(0, dim), Number);
     let norm = 0;
     for (const x of out) norm += x * x;
     norm = Math.sqrt(norm);
@@ -60,9 +59,8 @@ function matryoshka(vec, dim = DIM) {
 /** Free text → 256-d L2-normalized vector. Throws if the model can't load —
  *  callers fall back to lexical. First call downloads the model (slow). */
 export async function embedQueryDirect(text) {
-    const ex = await extractor();
-    const output = await ex(`search_query: ${text}`, { pooling: "mean", normalize: false });
-    return matryoshka(output.data);
+    const [v] = await (await model())([QUERY + text]);
+    return v;
 }
 
 /** One document, in-process. Calls made together are embedded as one batch (a GPU's
@@ -79,20 +77,22 @@ async function flushDocuments() {
     const all = pending;
     pending = [];
     try {
-        const ex = await extractor();
-        for (let i = 0; i < all.length; i += BATCH) {
-            const part = all.slice(i, i + BATCH);
-            const output = await ex(part.map((p) => `search_document: ${p.text}`), { pooling: "mean", normalize: false });
-            const d = output.dims.at(-1);
-            part.forEach((p, j) => p.resolve(matryoshka(output.data.slice(j * d, (j + 1) * d))));
-        }
+        const vs = await embedRaw(all.map((p) => DOCUMENT + p.text));
+        all.forEach((p, j) => p.resolve(vs[j]));
     } catch (e) {
         for (const p of all) p.reject(e);
     }
 }
 
+/** Texts that already carry their prompt → vectors, in-process: a stand-in for the Worker's AI binding (devnet.js). */
+export async function embedRaw(texts) {
+    const run = await model(), out = [];
+    for (let i = 0; i < texts.length; i += BATCH) out.push(...await run(texts.slice(i, i + BATCH)));
+    return out;
+}
+
 /** Load the model in-process, and settle when it is actually ready. */
-export const warmDirect = () => extractor().then(() => {});
+export const warmDirect = () => model().then(() => {});
 
 // ── off the main thread ──────────────────────────────────────────────────────
 //
@@ -136,9 +136,8 @@ const ask = (kind, text) => new Promise((resolve, reject) => {
 export const embedQuery = (text) => (offThread() ? ask("query", text) : embedQueryDirect(text));
 
 /**
- * Document side. Same model, the OTHER nomic prefix — it's an asymmetric model,
- * so documents embedded with "search_query: " would rank against real queries
- * about as well as random.
+ * Document side. Same model, the OTHER prompt — it's asymmetric, so documents
+ * embedded with the query prompt rank against real queries worse.
  *
  * Runs one at a time on purpose: this executes in a publisher's browser during
  * publish, and a batch large enough to matter is a batch large enough to lock
@@ -235,7 +234,7 @@ export function unpackBits(b64) {
  * focus — the pipeline is a memoized singleton on whichever thread owns it.
  *
  * Call this on INTENT (the search box taking focus), never on page load: it is a
- * 131MB download, and until someone types there is nothing for it to embed. The
+ * ~300MB download, and until someone types there is nothing for it to embed. The
  * whole first-paint path — browse, shelves, channels, the field, the compass —
  * runs on the document vectors already in the shard.
  */

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/shard.js

@@ -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;
 }
@@ -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

package/src/discover/apps.js

@@ -34,13 +34,14 @@ function safeView(url) {
 export const APP_EXTENSION = "https://fangorn.network/a2a/app/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) {
+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;
     return {
-        appId, card: cardUrl, fromBlock, namespaces, views, paid,
+        appId, card: cardUrl, fromBlock, repos, views, paid,
+        mcp: safeView(ext?.params?.mcp),
         name: card.name ?? appId,
         desc: card.description ?? "",
         url: safeView(card.url),
@@ -97,7 +98,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
         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"] };
+            return { card: c, appId: c.capabilities.extensions[1].params.appId, fromBlock: 7n, repos: ["n"] };
         },
     };
     const { apps, rejected } = await listApps(fangorn, { fromBlock: 42 });

package/src/discover/explore.js

@@ -8,9 +8,9 @@
 //   ERC-8004 identity `Registered`  the agent minted for the app
 //   ERC-8004 reputation             feedback count and average per agent
 //
-// Both registries are scanned from their first event in 10M-block windows, in
-// parallel, so the page and the MCP tool read the same chain the same way, and
-// a new app shows up on the next read.
+// Both registries are scanned from their first event in windows as wide as the
+// chain's RPC allows (`chainOf`), in parallel, so the page and the MCP tool read
+// the same chain the same way, and a new app shows up on the next read.
 //
 // `client` is a viem PublicClient (getLogs, readContract): passed in, so this
 // runs in a tab and in node, and the self-check needs no chain.
@@ -19,22 +19,39 @@
 // the logs somewhere if that ever gets slow.
 
 import { parseAbi, parseAbiItem } from "viem";
+// The config module alone (viem only), not the SDK's root: this runs in a tab too.
+import { BaseSepoliaConfig } from "@fangorn-network/sdk/lib/config.js";
 import { APP_EXTENSION } from "./apps.js";
 import { survey, comparable } from "./directory.js";
 import { rankDomains, zFloor, lexScore } from "../core/rank.js";
 
-export const CHAIN = {
-    chainId: 421614,
-    appRegistry: "0x11d228c4774af3d9cae3b4b6874a12576a1a83ec",
-    identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
-    reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
-    // Each registry's first event (2026-10-05): nothing to read before it.
-    // Scanning from 0 instead was 32 windows per registry, ~5s of a 7.7s load.
-    appRegistryFrom: 311_639_205n,
-    identityFrom: 241_557_787n,
-    scan: (agentId) => `https://8004scan.io/agents/arbitrum-sepolia/${agentId}`,
+// The ERC-8004 registries per chain id, where `fangorn app agent` mints (agent0-sdk's
+// defaults, and the CLI's override for Arbitrum Sepolia, which agent0-sdk lacks).
+const ERC8004 = {
+    421614: { identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e", reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
+              // The identity registry's first event (2026-10-05). Its public RPC takes 10M-block windows.
+              identityFrom: 241_557_787n, window: 10_000_000n, scan: "arbitrum-sepolia" },
+    // ponytail: identity read from the AppRegistry's deployment, since an app's agent is minted after it.
+    // An agent minted before then and rebound with --skip-register is missed; scan earlier if that happens.
+    84532: { identity: "0x8004A818BFB912233c491871b3d84c89A494BD9e", reputation: "0x8004B663056A597Dffe9eCcC1965A193B7388713",
+             scan: "base-sepolia" },
 };
 
+/** What explore reads on one of the SDK's networks (`SupportedNetworks.baseSepolia`, …). */
+export function chainOf(net = BaseSepoliaConfig) {
+    const e = ERC8004[net.caip2];
+    if (!e) throw new Error(`explore: no ERC-8004 registries known for chain ${net.caip2}`);
+    return {
+        chainId: net.caip2, appRegistry: net.appRegistryContractAddress, identity: e.identity, reputation: e.reputation,
+        // Nothing to read before the registry's deployment; from 0 a scan is mostly empty windows.
+        appRegistryFrom: net.appRegistryFromBlock, identityFrom: e.identityFrom ?? net.appRegistryFromBlock,
+        window: e.window ?? net.logWindow ?? 1000n,
+        scan: (agentId) => `https://8004scan.io/agents/${e.scan}/${agentId}`,
+    };
+}
+
+export const CHAIN = chainOf();
+
 const APP_AGENT_CHANGED = parseAbiItem("event AppAgentChanged(bytes32 indexed app_id, string agent_uri)");
 const REGISTERED = parseAbiItem("event Registered(uint256 indexed agentId, string agentURI, address indexed owner)");
 const APPS = parseAbi(["function getAppOwner(bytes32) view returns (address)"]);
@@ -105,15 +122,12 @@ async function reputation(client, agentId, chain) {
     }
 }
 
-// The public Arbitrum Sepolia RPC refuses an address+event getLogs spanning more
-// than 10M blocks (from 2026-10; one call from 0 worked before).
-const LOG_WINDOW = 10_000_000n;
-
-async function getLogsSince(client, start, filter) {
+// `window`: the most blocks one getLogs may span on the client's RPC (chainOf says, per chain).
+async function getLogsSince(client, start, filter, window) {
     const head = await client.getBlockNumber();
     const windows = [];
-    for (let from = start; from <= head; from += LOG_WINDOW) {
-        const to = from + LOG_WINDOW - 1n < head ? from + LOG_WINDOW - 1n : head;
+    for (let from = start; from <= head; from += window) {
+        const to = from + window - 1n < head ? from + window - 1n : head;
         windows.push(client.getLogs({ ...filter, fromBlock: from, toBlock: to }));
     }
     return (await Promise.all(windows)).flat();   // in window order: oldest first still holds
@@ -129,8 +143,8 @@ async function getLogsSince(client, start, filter) {
  */
 export async function readDirectory(client, { chain = CHAIN, onUpdate = () => {} } = {}) {
     const [bindLogs, regLogs] = await Promise.all([
-        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }),
-        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }),
+        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }, chain.window ?? 1000n),
+        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }, chain.window ?? 1000n),
     ]);
     const registered = regLogs.map((l) => ({ agentId: l.args.agentId, owner: l.args.owner, block: l.blockNumber }));
     const latest = new Map();   // logs come oldest first: the last write wins

package/src/market/reactions.js

@@ -50,7 +50,7 @@
 // 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 { EMBED_MODEL, packVec } from "../core/embed.js";
 import { lineage } from "./terms.js";
 
 // 32, not 8: on Kingsfoil the top 3 of 23 views held 92% of the true top 10 with 32
@@ -216,7 +216,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",

package/src/publish/devnet.js

@@ -0,0 +1,95 @@
+// A Fangorn network on this machine: anvil with the contracts built from source behind their
+// proxies, a content-addressed store with an IPFS gateway over it, and (optionally) an encoder
+// that answers as the Worker's AI binding does. What `westmarch-ship --devnet` and
+// 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).
+
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, 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";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ADMIN_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";   // anvil's first account
+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 = () => {} } = {}) {
+    const kids = [], servers = [];
+    const stop = () => { for (const k of kids) k.kill(); for (const s of servers) s.close(); };
+    process.on("exit", stop);
+
+    // ── chain ─────────────────────────────────────────────────────────────────
+    if (spawnSync("forge", ["build"], { cwd: contracts, stdio: ["ignore", "ignore", "inherit"] }).status !== 0) throw new Error(`forge build failed in ${contracts}`);
+    const anvil = spawn("anvil", ["--port", "0", "--host", "127.0.0.1", "--chain-id", String(FangornConfig.chain.id)], { stdio: ["ignore", "pipe", "inherit"] });
+    kids.push(anvil);
+    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);
+    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] }) });
+    // 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}`);
+
+    // ── storage: a content-addressed store, and the gateway that serves it ────
+    // multiformats, from the SDK's own dependencies.
+    const sdk = createRequire(createRequire(import.meta.url).resolve("@fangorn-network/sdk"));
+    const [{ CID }, { sha256 }, raw] = await Promise.all(["multiformats/cid", "multiformats/hashes/sha2", "multiformats/codecs/raw"].map((m) => import(sdk.resolve(m))));
+    const store = new Map();   // multihash hex → bytes
+    const key = (cid) => Buffer.from(CID.parse(String(cid).replace(/^ipfs:\/\//, "")).multihash.bytes).toString("hex");
+    const unused = async () => { throw new Error("unused"); };
+    const backend = {
+        putBlock: async (b) => { store.set(key(b.cid), b.bytes); },
+        putFile: async (bytes) => { const cid = CID.createV1(raw.code, await sha256.digest(bytes)); store.set(key(cid), bytes); return `ipfs://${cid}`; },
+        getFile: async (uri) => store.get(key(uri)) ?? Promise.reject(new Error(`no ${uri}`)),
+        getRawBlock: async (uri) => store.get(key(uri)) ?? Promise.reject(new Error(`no ${uri}`)),
+        put: unused, putMany: unused, get: unused, delete: async () => {},
+    };
+    const gateway = createServer((req, res) => {
+        try { const b = store.get(key(req.url.replace(/^\/ipfs\//, ""))); if (!b) throw 0; res.end(Buffer.from(b)); }
+        catch { res.statusCode = 404; res.end(); }
+    });
+    servers.push(gateway);
+    const gatewayUrl = await listen(gateway);
+
+    /** A funded publisher, under `app` (or none). */
+    const client = async (app, privateKey = generatePrivateKey()) => {
+        await chain.setBalance({ address: privateKeyToAccount(privateKey).address, value: parseEther("1") });
+        return Fangorn.create({ privateKey, config, appId: app, storage: { backend } });
+    };
+
+    /** An encoder on localhost that answers as the AI binding does: POST {text} → {data}; GET → the embedder it is. */
+    const encoder = async () => {
+        const [{ embedRaw, EMBED_MODEL, EMBED_DTYPE }, { env }] = await Promise.all([import("../core/embed.js"), import("@huggingface/transformers")]);
+        env.cacheDir = `${process.env.HOME}/.cache/fangorn-mcp/models`;
+        const embedder = JSON.stringify({ runtime: "transformers.js", model: EMBED_MODEL, dtype: EMBED_DTYPE });
+        // One at a time: the Worker sends several batches at once, and the model runs one.
+        let queue = Promise.resolve();
+        const server = createServer((req, res) => {
+            if (req.method === "GET") return res.end(embedder);
+            let body = "";
+            req.on("data", (c) => { body += c; });
+            req.on("end", () => { queue = queue.then(async () => {
+                try { res.end(JSON.stringify({ data: await embedRaw(JSON.parse(body).text) })); }
+                catch (e) { res.statusCode = 500; res.end(String(e.message)); }
+            }); });
+        });
+        servers.push(server);
+        return listen(server);
+    };
+
+    return { rpcUrl, deployment, config, chain, backend, gatewayUrl, client, encoder, stop, kids };
+}

package/src/publish/lint.js

@@ -21,11 +21,12 @@
 import { configure, loadShard, resetShard, setDomains, trimView } from "../core/shard.js";
 import { shapeOf } from "../agent/ui.js";
 import { inSample, linkOf, rolesFrom, textOf } from "../core/roles.js";
+import { EMBED_MODEL } from "../core/embed.js";
 
 /** The model every corpus on this network is baked with. Cosine between two
  *  models' vectors is noise that still looks like a score, so a mismatch is not
  *  a warning — it is exclusion from the directory. */
-export const NETWORK_MODEL = "nomic-ai/nomic-embed-text-v1.5";
+export const NETWORK_MODEL = EMBED_MODEL;
 
 const F = (level, what, why, fix) => ({ level, what, why, fix });