@fangorn-network/westmarch 2026.10.22-dev → 2026.10.26-dev

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fangorn-network/westmarch",
-  "version": "2026.10.22-dev",
+  "version": "2026.10.26-dev",
   "description": "all-in-one builder for fangorn apps",
   "license": "MIT",
   "type": "module",
@@ -56,7 +56,7 @@
     }
   },
   "devDependencies": {
-    "@fangorn-network/sdk": "^2026.10.21-dev",
+    "@fangorn-network/sdk": "^2026.10.26-dev",
     "@huggingface/transformers": "^4.2.0",
     "@noble/curves": "^1.9.1",
     "@privy-io/react-auth": "^3.47.0",

package/site/worker.js

@@ -455,6 +455,9 @@ async function paidCall(origin, tool, payment, run) {
     return { ...result, _meta: { ...result._meta, "x402/payment-response": settled } };
 }
 
+export const ORIGIN = "https://origin.westmarch.invalid";
+const BY_ORIGIN = new Set(["/.well-known/agent-card.json", "/openapi.json", "/.well-known/x402"]);
+
 const worker = {
     async fetch(request, env) {
         CONFIG = env.CONFIG ?? CONFIG;
@@ -473,7 +476,14 @@ const worker = {
         if (p === "/paid" && request.method === "POST") return CONFIG.paid ? sellBatch(request, env, url) : json({ error: "nothing is sold here" }, 404);
         if (p.startsWith("/paid/")) return CONFIG.paid ? sell(request, env, url) : json({ error: "nothing is sold here" }, 404);
 
-        const res = await env.ASSETS.fetch(request);
+        let res = await env.ASSETS.fetch(request);
+        // A site built before its URL was known (`westmarch build`, under the deploy button) names
+        // ORIGIN wherever it means its own: it is wherever it is served from.
+        if (res.ok && BY_ORIGIN.has(p)) {
+            const body = (await res.text()).replaceAll(ORIGIN, url.origin);
+            res = new Response(body, { status: res.status, headers: res.headers });
+            res.headers.delete("content-length");
+        }
         const out = new Response(res.body, res);
         if (p === "/.well-known/agent-card.json") out.headers.set("access-control-allow-origin", "*");
         if (p.startsWith("/assets/")) out.headers.set("cache-control", "public, max-age=31536000, immutable");
@@ -511,7 +521,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     const calls = [];
     const AI = { run: async (model, { text }) => { calls.push({ model, text });
         return { data: text.map((t) => { const v = new Array(768).fill(0); for (const w of t.toLowerCase().split(/\W+/)) if (w.length > 3) v[[...w].reduce((h, c) => (h * 31 + c.charCodeAt(0)) % 256, 7)] += 1; return v; }) }; } };
-    const env = { VIEW, AI, ASSETS: { fetch: async () => new Response("<!doctype html>site") },
+    const env = { VIEW, AI, ASSETS: { fetch: async (r) => new Response(new URL(r.url).pathname.endsWith("agent-card.json") ? `{"url":"${ORIGIN}/"}` : "<!doctype html>site") },
                   CONFIG: { app: "shop", name: "Shop", description: "Things for a room.", repos: [] } };
     CONFIG = env.CONFIG;
 
@@ -540,6 +550,8 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     eq((await (await worker.fetch(new Request("https://shop.test/mcp", { method: "POST", body: '{"jsonrpc":"2.0","method":"notifications/initialized"}' }), env)).status), 202, "a notification is accepted, not answered");
 
     const cat = await worker.fetch(new Request("https://shop.test/view/cdn/catalog"), env);
+    const card = await worker.fetch(new Request("https://shop.example.workers.dev/.well-known/agent-card.json"), env);
+    eq([await card.json(), card.headers.get("access-control-allow-origin")], [{ url: "https://shop.example.workers.dev/" }, "*"], "a card built before its URL was known names the origin it is served from");
     eq([cat.status, cat.headers.get("access-control-allow-origin"), (await cat.json()).domains[0].link_hosts], [200, "*", ["docs.example"]], "the view is served from R2, with the hosts its records link to");
     eq((await worker.fetch(new Request("https://shop.test/doc?u=https://evil.example/x.pdf"), env)).status, 403, "/doc refuses a host no record links to");
     eq((await worker.fetch(new Request("https://shop.test/view/cdn/nope"), env)).status, 404, "a missing file is a 404");

package/src/publish/init.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
-// A new app from the template: its recipe (app.json, eval/, ci/), no data.
+// A new app from the template: its recipe (app.json, wrangler.json, eval/), no data.
 //   npx @fangorn-network/westmarch init <app> [dir] [--no-install]
+//   westmarch build      the deploy button's build step (ship.js buildForDeploy)
 // The app's data is what its members commit; the repo this makes can be public.
 import { cpSync, existsSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { buildForDeploy, nameApp } from "./ship.js";
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), "../..");
 const TEMPLATE = join(ROOT, "template");
@@ -20,12 +22,11 @@ export function init(app, dir = app, { install = true, log = console.log } = {})
     cpSync(TEMPLATE, dir, { recursive: true });
     renameSync(join(dir, "gitignore"), join(dir, ".gitignore"));   // npm drops a published .gitignore
 
-    const cfg = JSON.parse(readFileSync(join(dir, "app.json"), "utf8"));
-    const tag = `${app}.item.v1`;
-    const type = JSON.parse(JSON.stringify(cfg.types["my-app.item.v1"]).replaceAll("my-app.item.v1", tag));
-    Object.assign(cfg, { app, name: app, types: { [tag]: type } });
-    cfg.site.project = app.replace(/[._]/g, "-");                   // a Worker name: letters, digits, dashes
+    const cfg = nameApp(JSON.parse(readFileSync(join(dir, "app.json"), "utf8")), app);
     writeFileSync(join(dir, "app.json"), JSON.stringify(cfg, null, 1) + "\n");
+    const w = JSON.parse(readFileSync(join(dir, "wrangler.json"), "utf8"));
+    Object.assign(w, { name: cfg.site.project, r2_buckets: [{ ...w.r2_buckets[0], bucket_name: `${cfg.site.project}-view` }] });
+    writeFileSync(join(dir, "wrangler.json"), JSON.stringify(w, null, 1) + "\n");
     writeFileSync(join(dir, "README.md"), readFileSync(join(dir, "README.md"), "utf8").replaceAll("my-app", app));
     const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
     pkg.dependencies["@fangorn-network/westmarch"] = `^${JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8")).version}`;
@@ -40,13 +41,7 @@ export function init(app, dir = app, { install = true, log = console.log } = {})
     }
     log(`${app} is in ${dir}. Next:
   1. app.json: the description, and the type's fields (role_map)
-  2. gh repo create ${app} --private --source ${dir} --push
-  3. gh secret set ETH_PRIVATE_KEY        # the wallet that claimed ${app}; read from the prompt, never echoed
-     gh secret set PINATA_JWT
-     gh variable set PINATA_GATEWAY --body <your-gateway>.mypinata.cloud
-     gh secret set CLOUDFLARE_API_TOKEN
-     gh secret set CLOUDFLARE_ACCOUNT_ID
-  4. gh workflow run ship                  # deploys the Worker; then publish records (README.md)`);
+  2. npx westmarch-ship app.json           # claims ${app} if it isn't yet, deploys the Worker, registers its agent`);
     return dir;
 }
 
@@ -57,7 +52,9 @@ if (process.argv[2] === "--selfcheck") {
         const cfg = JSON.parse(readFileSync(join(dir, "app.json"), "utf8"));
         if (cfg.app !== "my.app_1" || cfg.site.project !== "my-app-1" || !cfg.types["my.app_1.item.v1"]?.presentation.types["my.app_1.item.v1"])
             throw new Error(`app.json not filled: ${JSON.stringify(cfg)}`);
-        if (!existsSync(join(dir, ".gitignore")) || !existsSync(join(dir, ".github/workflows/ship.yml"))) throw new Error("template files missing");
+        if (!existsSync(join(dir, ".gitignore"))) throw new Error("template files missing");
+        const w = JSON.parse(readFileSync(join(dir, "wrangler.json"), "utf8"));
+        if (w.name !== "my-app-1" || w.r2_buckets[0].bucket_name !== "my-app-1-view") throw new Error(`wrangler.json not filled: ${JSON.stringify(w)}`);
         if (readFileSync(join(dir, "README.md"), "utf8").includes("my-app")) throw new Error("README still names my-app");
         let threw = false;
         try { init("x", join(dir, "y"), { install: false, log: () => {} }); } catch { threw = true; }
@@ -68,7 +65,10 @@ if (process.argv[2] === "--selfcheck") {
     const [app, dir] = process.argv.slice(3).filter((a) => !a.startsWith("--"));
     try { init(app, dir, { install: !process.argv.includes("--no-install") }); }
     catch (e) { console.error(e.message); process.exit(1); }
+} else if (process.argv[2] === "build") {
+    try { await buildForDeploy(process.argv[3] ?? "app.json"); }
+    catch (e) { console.error(e.message); process.exit(1); }
 } else {
-    console.error("usage: westmarch init <app> [dir] [--no-install]");
+    console.error("usage: westmarch init <app> [dir] [--no-install] | westmarch build [app.json]");
     process.exit(2);
 }

package/src/publish/ship.js

@@ -34,7 +34,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -88,6 +88,9 @@ const log = (s) => console.error(`[ship] ${s}`);
 //   "types": { "<tag>": { "description": "…", "role_map": {…}, "presentation": {…} } },
 //   "relations": [{ "rel": "…", "from": "<tag>", "to": "<tag>" }],
 //   "sources": [{ "namespace": "…", "cwd": "…", "command": ["python", "-m", "…", …] }],
+//   "live": ["readings"],     // optional: namespaces members push to from their own wallets (devices,
+//                             //   contributors), presented beside the sources'; true = every repo they push.
+//                             //   Without sources the app already presents every member's repo.
 //   "network": "baseSepolia", // required: the SDK's network name. baseSepolia for a new app; an app
 //                             //   already claimed on arbitrumSepolia keeps it (a different name re-claims it there)
 //   "fangorn": "fangorn",     // the CLI that signs; e.g. "node ~/fangorn/fangorn/lib/cli/cli.js",
@@ -146,9 +149,18 @@ export function loadConfig(path) {
     if (!c.site.project) throw new Error(`${path}: site.project names the Cloudflare Worker`);
     for (const s of c.sources) if (!s.namespace || !Array.isArray(s.command))
         throw new Error(`${path}: each source needs a namespace and a command (an argv array)`);
+    if (c.live != null && c.live !== true && !(Array.isArray(c.live) && c.live.every((n) => typeof n === "string")))
+        throw new Error(`${path}: live is true (every repo members push) or a list of the namespaces they push to`);
     return { relations: [], tags: [], types: {}, ...c };
 }
 
+/** The repo names the view presents: the sources' namespaces plus `live`'s, the ones members push
+ *  to themselves (devices, contributors). [] means every repo the app presents: no sources, or live: true. */
+export function presentedRepos(cfg) {
+    if (cfg.live === true) return [];
+    return [...new Set([...cfg.sources.map((s) => s.namespace), ...(cfg.live ?? [])])];
+}
+
 /** The Worker's wrangler config: the stock worker, the site as its assets, its bucket, the AI
  *  binding, the cron and CONFIG. `worker` is site/worker.js unless a test points elsewhere. */
 export function wranglerConfig({ name, site, account, cron = "*/5 * * * *", config, url, ipfsGateway, worker = join(HERE, "../../site/worker.js") }) {
@@ -217,6 +229,68 @@ function assertSameDeployment(cli) {
         "they talk to different contracts. Point app.json's \"fangorn\" at a matching CLI.");
 }
 
+/** The block `appId` was claimed in, or undefined: the AppRegistered log, window by window. */
+export async function claimBlock(chain, FangornConfig, appId) {
+    const { parseAbiItem } = await import("viem");
+    const from = BigInt(FangornConfig.appRegistryFromBlock), to = await chain.getBlockNumber(), step = BigInt(FangornConfig.logWindow ?? 10000);
+    const event = parseAbiItem("event AppRegistered(bytes32 indexed app_id, address indexed owner)");
+    for (let a = from; a <= to; a += step) {
+        const [claimed] = await chain.getLogs({ address: FangornConfig.appRegistryContractAddress, event, args: { app_id: appId },
+                                                fromBlock: a, toBlock: a + step - 1n < to ? a + step - 1n : to });
+        if (claimed) return String(claimed.blockNumber);
+    }
+}
+
+/** The template's app.json as `app`'s: its name, its type tag `<app>.item.v1` and the Worker. */
+export const TEMPLATE_APP = "my-app";
+export function nameApp(cfg, app) {
+    const from = `${TEMPLATE_APP}.item.v1`, tag = `${app}.item.v1`;
+    const types = Object.fromEntries(Object.entries(cfg.types ?? {}).map(([k, t]) =>
+        k === from ? [tag, JSON.parse(JSON.stringify(t).replaceAll(from, tag))] : [k, t]));
+    return { ...cfg, app, name: cfg.name === TEMPLATE_APP ? app : cfg.name, types,
+             site: { ...cfg.site, project: app.replace(/[._]/g, "-") } };   // a Worker name: letters, digits, dashes
+}
+
+/**
+ * `westmarch build`: what Workers Builds runs under the deploy button. The site, with a card
+ * that names ORIGIN for its own URL (the Worker fills it in), and CONFIG, into the app's own
+ * wrangler.json, which `wrangler deploy` then ships with the bucket, AI and cron it declares.
+ * No chain writes and no Cloudflare calls: the owner claims the app and registers its agent
+ * from fangorn.network. While app.json still names the template's app, the app is the Worker's name.
+ *
+ * ponytail: free apps only; a paid or private one ships with westmarch-ship, which sets its secret.
+ */
+export async function buildForDeploy(configPath, wranglerPath = join(dirname(resolve(configPath)), "wrangler.json")) {
+    const w = JSON.parse(readFileSync(wranglerPath, "utf8"));
+    let cfg = loadConfig(configPath);
+    if (cfg.app === TEMPLATE_APP) cfg = nameApp(cfg, w.name);
+    if (cfg.paid || cfg.private) throw new Error(`${configPath}: a paid or private app ships with westmarch-ship`);
+    if (!cfg.network) throw new Error(`${configPath}: "network" is required`);
+    if (!w.r2_buckets?.[0]?.bucket_name?.includes(w.name))
+        log(`the R2 bucket ${w.r2_buckets?.[0]?.bucket_name} doesn't name the Worker; two apps sharing one overwrite each other's view`);
+
+    process.env.FANGORN_NETWORK = process.env.CHAIN_NAME = cfg.network;
+    const [{ createPublicClient, http }, view, { ORIGIN }] = await Promise.all([import("viem"), import("./view.js"), import("../../site/worker.js")]);
+    const FangornConfig = await view.network(cfg.network);
+    const fangorn = await view.readOnlyFangorn();
+    fangorn.setAppId(cfg.app);
+    if (/^0x0+$/.test(await fangorn.getAppRegistry().getAppOwner()))
+        throw new Error(`${cfg.app} is unclaimed: claim it at fangorn.network first${/[._]/.test(cfg.app) ? "" : `, or set "app" in app.json to the name you claimed`}`);
+    const chain = createPublicClient({ transport: http(FangornConfig.rpcUrl) });
+    const fromBlock = cfg.fromBlock != null ? String(cfg.fromBlock) : await claimBlock(chain, FangornConfig, fangorn.getAppId());
+
+    const base = dirname(resolve(configPath));
+    const { site, writeCard } = await buildSite(cfg, base);
+    writeCard(ORIGIN, { fromBlock, repos: [] });
+    const gateway = process.env.FANGORN_IPFS_GATEWAY;
+    w.assets = { ...w.assets, directory: relative(dirname(resolve(wranglerPath)), site) };
+    w.vars = { ...w.vars, CONFIG: { app: cfg.app, name: cfg.name, description: cfg.description, fromBlock, network: cfg.network,
+                                    schema: { types: cfg.types, relations: cfg.relations }, repos: [], paid: null, private: null },
+               ...(gateway ? { IPFS_GATEWAY: gateway } : {}) };
+    writeFileSync(wranglerPath, JSON.stringify(w, null, 1) + "\n");
+    log(`built ${cfg.app} (fromBlock ${fromBlock}) into ${site}; wrangler deploy ships it`);
+}
+
 // ── the steps ─────────────────────────────────────────────────────────────────
 
 export async function ship(configPath, { crawl = true, deploy = true, dry = false, replace = false, only = null, register = false } = {}) {
@@ -245,7 +319,7 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
 
     // The SDK's network name: view.js reads with it, and the CLI and the sources spawned below sign on it.
     process.env.FANGORN_NETWORK = process.env.CHAIN_NAME = cfg.network;
-    const [{ createPublicClient, http, parseAbiItem }, view] = await Promise.all([import("viem"), import("./view.js")]);
+    const [{ createPublicClient, http }, view] = await Promise.all([import("viem"), import("./view.js")]);
     const FangornConfig = await view.network(cfg.network);
     const fangorn = await view.readOnlyFangorn();
     fangorn.setAppId(cfg.app);
@@ -270,15 +344,7 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
         throw new Error(`${cfg.app} belongs to ${owner}, not this wallet (${me}); pick another name`);
     }
     // Claimed elsewhere (fangorn.network, the CLI): the view starts at the claim, found once.
-    if (state.fromBlock == null && cfg.fromBlock == null) {
-        const from = BigInt(FangornConfig.appRegistryFromBlock), to = await chain.getBlockNumber(), step = BigInt(FangornConfig.logWindow ?? 10000);
-        const event = parseAbiItem("event AppRegistered(bytes32 indexed app_id, address indexed owner)");
-        for (let a = from; a <= to && state.fromBlock == null; a += step) {
-            const [claimed] = await chain.getLogs({ address: FangornConfig.appRegistryContractAddress, event, args: { app_id: appId },
-                                                    fromBlock: a, toBlock: a + step - 1n < to ? a + step - 1n : to });
-            if (claimed) state.fromBlock = String(claimed.blockNumber);
-        }
-    }
+    if (state.fromBlock == null && cfg.fromBlock == null) state.fromBlock = await claimBlock(chain, FangornConfig, appId);
     state.fromBlock ??= String(cfg.fromBlock ?? FangornConfig.appRegistryFromBlock);
     log(`app ${cfg.app} = ${appId}, owner ${owner}, fromBlock ${state.fromBlock}`);
 
@@ -305,7 +371,7 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     // site.url: the app's own domain, routed to the Worker. Otherwise its workers.dev URL,
     // which is only known once it is deployed: the first deploy learns it and the card follows.
     let url = cfg.site.url?.replace(/\/$/, "") ?? state.url ?? null;
-    const repos = [...new Set(cfg.sources.map((s) => s.namespace))];
+    const repos = presentedRepos(cfg);
     // Paid records are in the committed rows already, encrypted (`paid_ct`: AES-256-GCM under
     // HMAC-SHA256(PAID_SECRET, id), see x402.js). The Worker sells keys, never records, so the
     // data a buyer pays for is on IPFS, committed, and in their hands before they pay.
@@ -381,7 +447,7 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     } else if (deploy) log("card already bound");
 
     // A new app has no view until the cron runs, which may be hours off: build the first one now.
-    if (deploy && !dry && !register && cfg.sources.length && !await fetch(`${url}/view/cdn/catalog`).then((r) => r.ok, () => false)) {
+    if (deploy && !dry && !register && (cfg.sources.length || cfg.live) && !await fetch(`${url}/view/cdn/catalog`).then((r) => r.ok, () => false)) {
         log("no view yet: indexing it here rather than waiting for the cron");
         await indexHere(configPath).catch((e) => log(`✗ first index: ${e.message}; the cron will build it`));
     }
@@ -678,12 +744,30 @@ export async function buildLocal(configPath, out, { crawl = false, only = null,
     const appId = `0x${createHash("sha256").update(cfg.app).digest("hex")}`, owner = `0x${"10ca1".padStart(40, "0")}`;
     const chain = {};
     // Storage addresses a record by its content, and so does this.
-    for (const [ns, records] of Object.entries(readStage(cfg, base, { crawl, only, log: say })))
+    if (cfg.sources.length) for (const [ns, records] of Object.entries(readStage(cfg, base, { crawl, only, log: say })))
         chain[`${owner}/${ns}`] = { records: records.map((r) => ({ ...r, cid: createHash("sha256").update(JSON.stringify(stable(r.payload))).digest("hex") })) };
+    // What members already pushed to the live namespaces, read from the chain (reads only, no gas),
+    // so a recipe is graded on contributed data too, not just on what the sources staged.
+    if (cfg.live) {
+        if (cfg.network) process.env.FANGORN_NETWORK = process.env.CHAIN_NAME = cfg.network;
+        const fangorn = await view.readOnlyFangorn();
+        fangorn.setAppId(cfg.app);
+        const statePath = join(base, ".ship/state.json");
+        const fromBlock = (existsSync(statePath) ? JSON.parse(readFileSync(statePath, "utf8")).fromBlock : null) ?? cfg.fromBlock;
+        const staged = new Set(cfg.sources.map((s) => s.namespace));
+        for (const t of await fangorn.appRepos(fromBlock == null ? {} : { fromBlock: BigInt(fromBlock) })) {
+            if (t.repo === "fangorn.schema" || staged.has(t.repo) || (only && !only.includes(t.repo))
+                || (cfg.live !== true && !cfg.live.includes(t.repo))) continue;
+            const { contents } = await fangorn.readRepo(t.owner, t.repo);
+            chain[`${t.owner.toLowerCase()}/${t.repo}`] = { records: contents.records };
+            say(`live ${t.owner}/${t.repo}: ${contents.records.length} records, from the chain`);
+        }
+    }
+    if (!Object.keys(chain).length) throw new Error("nothing to build: no sources staged anything and no member has pushed to a live namespace");
     rmSync(out, { recursive: true, force: true });
     mkdirSync(join(base, ".ship"), { recursive: true });
     const embed = view.cachedEmbed(join(base, ".ship/vectors.ndjson"));
-    const repos = [...new Set(cfg.sources.map((s) => s.namespace))].filter((n) => !only || only.includes(n));
+    const repos = presentedRepos(cfg).filter((n) => !only || only.includes(n));
     const report = await view.publishView({ fangorn: view.localFangorn(chain, { appId, owner }), app: cfg.app,
         schema: { types: cfg.types, relations: cfg.relations }, repos, out, embed, log: say });
     const rows = Object.values(report).reduce((n, r) => n + r.added, 0);
@@ -709,6 +793,10 @@ if (process.argv[1]?.endsWith("ship.js") || process.argv[1]?.endsWith("westmarch
         const dp = discovery({ name: "Q", description: "q" }, "https://q.example", null, { pass: "5000000", days: 30, call: "10000", decimals: 6 });
         if (dp.openapi.paths["/pass"].post["x-payment-info"].price.amount !== "5" || dp.x402.resources.join() !== "https://q.example/pass" || dp.openapi.paths["/paid"])
             throw new Error(`private discovery: ${JSON.stringify(dp.x402)}`);
+        const src = [{ namespace: "towns", command: ["py"] }];
+        if (presentedRepos({ sources: src }).join() !== "towns" || presentedRepos({ sources: src, live: ["readings", "towns"] }).join() !== "towns,readings"
+            || presentedRepos({ sources: src, live: true }).length || presentedRepos({ sources: [] }).length)
+            throw new Error("presentedRepos: sources plus live namespaces; [] (every repo) for live: true or no sources");
         if (units("0.01") !== "10000" || units("5") !== "5000000" || units("1.5", 2) !== "150") throw new Error("units");
         if (USDC["eip155:84532"].name !== "USDC" || USDC["eip155:8453"].name !== "USD Coin") throw new Error("USDC's EIP-712 name differs on Base Sepolia and Base");
         console.log("ship.js self-check ok — a source template fills per row, the Worker config binds its bucket, AI and cron, and the paid route is priced per id in /openapi.json and named in /.well-known/x402");

package/template/README.md

@@ -1,21 +1,31 @@
 # A Fangorn app
 
 This repo holds the app's recipe, not its data: what a record is (`app.json`), what a good
-answer looks like (`eval/`), and how to ship it (`ci/`). It can be public. The data lives
-on chain and IPFS, committed by the app's publishers; the Worker indexes it every 5
-minutes, and serves the site, the view, `/mcp` and the agent card.
-
-## Set up (testnet, your own Cloudflare)
-
-1. Edit `app.json`: `app` (the name you claim, globally unique), `name`, `description`,
-   `site.project` (the Worker's name), and the type: rename `my-app.item.v1` and map your
-   fields in `role_map`.
-2. Add repo secrets (Settings → Secrets and variables → Actions):
-   - `ETH_PRIVATE_KEY`: a Base Sepolia wallet with test ETH; it claims and owns the app
-   - `PINATA_JWT`, and the variable `PINATA_GATEWAY`
-   - `CLOUDFLARE_API_TOKEN` (template "Edit Cloudflare Workers", plus R2 and Workers AI) and `CLOUDFLARE_ACCOUNT_ID`
-3. Push `app.json` to `main`. The `ship` workflow claims the app, deploys the Worker and
-   binds its agent, then commits `.ship/state.json` back. Ship again whenever `app.json` changes.
+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
+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
+   `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.
+
+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.
+
+`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.
+
+## Make it yours
+
+Edit `app.json`: `name`, `description`, and the type: rename `my-app.item.v1` and map your
+fields in `role_map`. Push, and the Worker follows.
 
 ## Publish data
 
@@ -29,10 +39,12 @@ fangorn --app my-app push
 ```
 
 The view picks it up within 5 minutes at `<url>/view`. A source that crawls something
-on a schedule goes in `app.json` `sources`; see westmarch's docs.
+on a schedule goes in `app.json` `sources`, and publishes with
+`npx westmarch-ship app.json --no-deploy` (the push to `main` deploys; without the flag it
+would deploy a second copy over this Worker). See westmarch's docs.
 
 ## Keep it good
 
 Write `eval/goals.md` (who it serves) and `eval/golden.jsonl` (one check per line:
-`{"id","q","expect","min","goal"}`). The workflow grades the live view daily, and the run
-goes red when a check fails. `ci/ship.sh` runs the same steps on any CI or a laptop.
+`{"id","q","expect","min","goal"}`), then grade the live view:
+`npx westmarch-eval <url>/view`.

package/template/app.json

@@ -1,6 +1,6 @@
 {
  "app": "my-app",
- "name": "My App",
+ "name": "my-app",
  "description": "One sentence: what is in here, and who it is for.",
  "network": "baseSepolia",
  "site": {

package/template/package.json

@@ -1,8 +1,13 @@
 {
   "private": true,
   "type": "module",
+  "scripts": {
+    "build": "westmarch build",
+    "deploy": "wrangler deploy"
+  },
   "dependencies": {
-    "@fangorn-network/westmarch": "^2026.10.21-dev",
-    "@huggingface/transformers": "^4.3.1"
+    "@fangorn-network/westmarch": "2026.10.2-2.0-dev",
+    "@huggingface/transformers": "^4.3.1",
+    "wrangler": "^4.83.0"
   }
 }

package/template/wrangler.json

@@ -0,0 +1,12 @@
+{
+ "name": "my-app",
+ "main": "node_modules/@fangorn-network/westmarch/site/worker.js",
+ "compatibility_date": "2025-09-15",
+ "compatibility_flags": ["nodejs_compat"],
+ "assets": { "directory": ".ship/site", "binding": "ASSETS" },
+ "r2_buckets": [{ "binding": "VIEW", "bucket_name": "my-app-view" }],
+ "ai": { "binding": "AI" },
+ "triggers": { "crons": ["*/5 * * * *"] },
+ "alias": { "@huggingface/transformers": "./node_modules/@fangorn-network/westmarch/site/no-model.js" },
+ "vars": {}
+}

package/template/.github/workflows/ship.yml

@@ -1,33 +0,0 @@
-# Ship when app.json changes (or by hand); grade the live view daily. Data never comes
-# through here: publishers commit it to the app, and the Worker indexes it every 5 minutes.
-name: ship
-on:
-  push: { branches: [main], paths: [app.json] }
-  schedule: [{ cron: "17 13 * * *" }]
-  workflow_dispatch:
-concurrency: { group: ship, cancel-in-progress: false }
-permissions: { contents: write }   # to commit .ship/state.json back
-jobs:
-  ship:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    env:
-      ETH_PRIVATE_KEY: ${{ secrets.ETH_PRIVATE_KEY }}
-      PINATA_JWT: ${{ secrets.PINATA_JWT }}
-      PINATA_GATEWAY: ${{ vars.PINATA_GATEWAY }}
-      CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
-      CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with: { node-version: 22, cache: npm }
-      - if: github.event_name != 'schedule'
-        run: ci/ship.sh ship
-      - if: github.event_name != 'schedule'
-        name: keep the claim block, URL and agent id
-        run: |
-          git add .ship/state.json
-          git diff --cached --quiet || { git -c user.name=github-actions -c user.email=41898282+github-actions[bot]@users.noreply.github.com commit -m "ship: state" && git push; }
-      - uses: actions/cache@v4
-        with: { path: ~/.cache/fangorn-mcp/models, key: models-embeddinggemma }
-      - run: ci/ship.sh eval

package/template/ci/ship.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-# Portable CI: any runner (or a laptop) with node 22 and jq.
-#   ci/ship.sh ship   claim on first run, commit the schema, build the site, deploy the Worker, bind the agent
-#   ci/ship.sh eval   grade the live view against eval/golden.jsonl
-# Env: ETH_PRIVATE_KEY, PINATA_JWT, PINATA_GATEWAY, CLOUDFLARE_API_TOKEN, CLOUDFLARE_ACCOUNT_ID
-set -euo pipefail
-cd "$(dirname "$0")/.."
-export FANGORN_IPFS_GATEWAY="${FANGORN_IPFS_GATEWAY:-${PINATA_GATEWAY:-}}"   # westmarch reads this name, not PINATA_GATEWAY
-
-grep -q '"app": "my-app"' app.json && { echo "edit app.json first: app, name, description, site.project, the type" >&2; exit 1; }
-[ -d node_modules ] || npm ci
-# ship signs with the fangorn CLI, which must be the SDK version westmarch reads with
-command -v fangorn >/dev/null || npm i -g "@fangorn-network/sdk@$(node -p 'require("@fangorn-network/sdk/package.json").version')"
-
-case "${1:-}" in
-  ship) npx westmarch-ship app.json ;;
-  eval)
-    [ -s eval/golden.jsonl ] || { echo "no golden queries in eval/golden.jsonl yet: nothing to grade"; exit 0; }
-    npx westmarch-eval "$(jq -r .url .ship/state.json)/view" ;;
-  *) echo "usage: ci/ship.sh ship|eval" >&2; exit 2 ;;
-esac