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

package/docs/app-to-agent.md

@@ -19,9 +19,9 @@ which anything can produce: a scraper, a database export, a converted spreadshee
 
 ```
  your data ─► data/graph.json ─► fangorn commit/push ─┐
- schema/graph.json ─► fangorn commit/push ────────────┤  (namespace fangorn.schema)
                                                       ▼
                                                     chain ─► westmarch-view ─► site/view/
+ app.json types ──────────────────────────────────────────────┘
                                                              (embeds only what changed, applies the schema)
  app/ (page) ─► vite build ─► site/ ◄── the page loads site/view
  pipeline/agent-card.mjs ─► site/.well-known/agent-card.json (views: [site/view]) ─► deploy
@@ -69,7 +69,7 @@ update: each step checks the chain (or Cloudflare) first and acts only on a diff
 ```
 
 ```sh
-npx westmarch-ship app.json            # claim, join, schema, crawl + publish, view, site, card, deploy, agent
+npx westmarch-ship app.json            # claim, join, crawl + publish, view, site, card, deploy, agent
 npx westmarch-ship app.json --dry-run  # every step, printed, none done
 npx westmarch-ship app.json --no-crawl # rebuild view, site and card from what is on chain
 npx westmarch-ship app.json --replace  # each source's crawl becomes its namespace's whole state
@@ -81,21 +81,20 @@ Workers AI), the view, `/mcp`, and the page. What `ship` does, in order:
 
 1. **claim** the app on the first run, and record the claim block (the card's `fromBlock`);
    the claimer is the app's first member;
-2. **commit the schema** (`types`, `relations`) to `fangorn.schema`, if the chain's differs;
-3. **run each source**: a command that publishes into `--namespace` when given `--publish`.
+2. **run each source**: a command that publishes into `--namespace` when given `--publish`.
    Every quickbeam scraper Source does. A source with `"each": "rows.json"` is a template,
    one source per row (`{field}`, `{field|slug}`, `{args...}`), so adding a town, a feed or
    an account is adding a row;
-4. **the site** in `.ship/site`: the stock page (search, plus a feed of what is coming up and
+3. **the site** in `.ship/site`: the stock page (search, plus a feed of what is coming up and
    what just happened, by the `temporal` role and the first `facets` field; for rows that are
    not meetings, an explore page: `site.examples` as searches to try, the latest records by
    `temporal`, and each declared facet's values to browse), the agent card,
    `/openapi.json` and `/.well-known/x402` when anything is for sale, and `_headers`;
-5. **deploy the Worker** (`wrangler deploy`): its R2 bucket (created if missing), Workers AI,
-   the cron (`site.cron`, default every 5 minutes) and its CONFIG. With `paid`, it sells each
+4. **deploy the Worker** (`wrangler deploy`): its R2 bucket (created if missing), Workers AI,
+   the cron (`site.cron`, default every 5 minutes) and its CONFIG, which carries the schema. With `paid`, it sells each
    record over x402; only records whose sha256 a live row carries are for sale. If the app
    has no view yet, ship builds the first one here (`--index`) rather than wait for the cron;
-6. **register** the ERC-8004 agent and bind the card, if the chain points elsewhere. An
+5. **register** the ERC-8004 agent and bind the card, if the chain points elsewhere. An
    agent is minted once; later runs only rebind.
 
 State lives in `.ship/` next to `app.json`. In CI, cache `.ship/cache` and `.ship/stage`
@@ -304,40 +303,30 @@ What makes records work well:
 
 ## 5. Declare the schema
 
-The schema says what your data is. You commit it to a reserved namespace,
-`fangorn.schema`, in your app:
-- **Types:** each is a vertex tagged `fangorn.type.v1`.
-- **Relations:** the relations allowed between types are edges between those vertices.
+The schema says what your data is. It lives in `app.json` and nowhere else; nothing is
+committed on chain:
+- **`types`:** one entry per type tag: `description`, `role_map`, `presentation`.
+- **`relations`:** the references allowed between types, `{ "rel", "from", "to" }`.
 
-`westmarch-view` (and hosted quickbeam) read it for every record they embed, so it decides:
+`westmarch-ship` hands it to the Worker in its CONFIG, and `westmarch-view` reads it with
+`--config app.json`. It is applied to every record they embed, so it decides:
 - **what gets embedded:** the `text` role, plus title, subtitle and tags;
 - **what readers see:** titles, links, labels;
 - **what agents can do:** filters, counts, and choosing among views by their description.
 
-`schema/graph.json`:
+In `app.json`:
 
 ```json
-{
- "vertices": [
-  { "id": "tree", "tag": "fangorn.type.v1", "payload": {
-      "tag": "my-app.tree.v1",
-      "description": "Tree species: what they are, where they grow, and what they are good for.",
-      "role_map": { "identity": "id", "title": "name", "subtitle": "species",
-                    "tags": ["family", "region"], "text": ["description"] },
-      "presentation": { "externalUrl": { "my-app.tree.v1": "https://en.wikipedia.org/wiki/{species}" } } } }
- ],
- "edges": []
-}
-```
-
-```sh
-cd schema && fangorn repo init fangorn.schema \
-  && fangorn commit graph.json -m "schema v1" --replace && fangorn push && cd ..
+"types": {
+  "my-app.tree.v1": {
+    "description": "Tree species: what they are, where they grow, and what they are good for.",
+    "role_map": { "identity": "id", "title": "name", "subtitle": "species",
+                  "tags": ["family", "region"], "text": ["description"] },
+    "presentation": { "externalUrl": { "my-app.tree.v1": "https://en.wikipedia.org/wiki/{species}" } } }
+},
+"relations": []
 ```
 
-`fangorn repo init` tracks one namespace per directory (in `.fangorn/`), which is why the
-schema is committed from its own `schema/` folder.
-
 **`role_map`** says which field is what:
 
 | role | means | used for |
@@ -354,13 +343,10 @@ schema is committed from its own `schema/` folder.
   map inferred from its fields. That works for display and often fails for search: a
   field called `desc` or `nct` isn't recognized, and a `price` can end up as the date.
   Declare every type you publish.
-- **Only the app owner's schema counts.** Any publisher can write a namespace called
-  `fangorn.schema`; only the owner's is read.
-- **You can change it at any time** with another commit. A view takes the new role map and
-  description on its next `westmarch-view` run. **Records already embedded keep the text they were embedded
+- **You can change it at any time**: edit `app.json` and ship again. The view takes the new
+  role map and description on the Worker's next cron run (or the next `westmarch-view`). **Records already embedded keep the text they were embedded
   with** until they're re-embedded, so change the `text` role early.
-- **Relations** (edges between type vertices, e.g. `{ "rel": "grows_in", "from": "tree",
-  "to": "region" }`) declare which edges the app allows. Nothing enforces them yet; they
+- **Relations** (e.g. `{ "rel": "grows_in", "from": "my-app.tree.v1", "to": "my-app.region.v1" }`) declare which edges the app allows. Nothing enforces them yet; they
   are what publisher graphs will be validated against.
 
 ## 6. Commit and push the data

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fangorn-network/westmarch",
-  "version": "2026.10.21-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",
@@ -68,6 +68,7 @@
     "viem": "^2.56.3"
   },
   "bin": {
+    "westmarch": "./src/publish/init.js",
     "westmarch-publish": "./src/publish/cli.js",
     "westmarch-view": "./src/publish/view-cli.js",
     "westmarch-ship": "./src/publish/ship.js",
@@ -78,6 +79,7 @@
   },
   "files": [
     "src",
+    "template",
     "docs/app-to-agent.md",
     "site/agent.js",
     "site/dist",

package/site/worker.js

@@ -27,7 +27,7 @@
 // paying, so nobody pays for a record that does not exist, and decrypts and checks it after.
 //
 // Bindings: VIEW (R2), AI (Workers AI), ASSETS (the site), CONFIG (a JSON var: app, name,
-// description, fromBlock, repos, paid, deployment), and optionally RPC_URL and IPFS_GATEWAY
+// description, fromBlock, schema, repos, paid, deployment), and optionally RPC_URL and IPFS_GATEWAY
 // (vars) and PAID_SECRET (a secret).
 
 import { Fangorn, FangornConfig, SupportedNetworks, repoExcluded } from "@fangorn-network/sdk";
@@ -105,7 +105,7 @@ export async function index(env, { log = console.log } = {}) {
         // Imported here: x402.js's self-check imports this module, and a cycle at load would deadlock it.
         const { openRow } = await import("../src/agent/x402.js");
         const report = await publishView({
-            fangorn: r.fangorn, app: CONFIG.app, repos: CONFIG.repos, store: r2Store(env.VIEW),
+            fangorn: r.fangorn, app: CONFIG.app, schema: CONFIG.schema, repos: CONFIG.repos, store: r2Store(env.VIEW),
             presented: await presented(r, state), embedBatch: encode(env, DOCUMENT), embedder: await embedderOf(env), log,
             ...(CONFIG.private ? { open: (p) => openRow(env.PAID_SECRET, p) } : {}),
         });
@@ -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");
@@ -488,7 +498,7 @@ export default worker;
 
 // ── self-check: `node site/worker.js` — a fake bucket, a fake AI binding, a fake registry ──
 if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1]?.endsWith("/worker.js")) {
-    const { localFangorn, SCHEMA_REPO, TYPE_TAG } = await import("../src/publish/view.js");
+    const { localFangorn } = await import("../src/publish/view.js");
     const eq = (a, b, m) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(`${m}: ${JSON.stringify(a)} != ${JSON.stringify(b)}`); };
 
     const objs = new Map();
@@ -511,20 +521,20 @@ 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;
 
     const APP = `0x${"ab".repeat(32)}`, OWNER = `0x${"11".repeat(20)}`, PUB = `0x${"22".repeat(20)}`, TAG = "shop.item.v1";
     const rec = (cid, type, payload) => ({ id: cid, cid, type, payload });
+    CONFIG.schema = { types: { [TAG]: { role_map: { identity: "sku", title: "name", text: "about", media: "doc" } } } };
     const chain = {
-        [`${OWNER}/${SCHEMA_REPO}`]: { records: [rec("t", TYPE_TAG, { tag: TAG, role_map: { identity: "sku", title: "name", text: "about", media: "doc" } })] },
         [`${PUB}/shop`]: { records: [
             rec("c1", TAG, { sku: "a1", name: "Oak table", about: "a solid oak dining table", doc: "https://docs.example/oak.pdf" }),
             rec("c2", TAG, { sku: "b2", name: "Brass lamp", about: "a brass reading lamp" })] },
     };
     const fangorn = localFangorn(chain, { appId: APP, owner: OWNER });
-    await publishView({ fangorn, app: APP, store: r2Store(VIEW), embedBatch: encode(env, DOCUMENT), embedder: WORKER_EMBEDDER, log: () => {} });
+    await publishView({ fangorn, app: APP, schema: CONFIG.schema, store: r2Store(VIEW), embedBatch: encode(env, DOCUMENT), embedder: WORKER_EMBEDDER, log: () => {} });
     eq([calls[0].model, calls[0].text[0].startsWith(DOCUMENT)], [AI_MODEL, true], "documents go to the AI binding with the document prompt");
 
     const call = async (method, params) => (await (await worker.fetch(new Request("https://shop.test/mcp",
@@ -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");
@@ -551,7 +563,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     const sealedAgain = await sealRow(SECRET, { sku: "v1", name: "Velvet chair", about: "a green velvet armchair" });
     eq(sealedAgain, chain[`${PUB}/vault`].records[0].payload, "an unchanged row seals to the same bytes (the same CID: not embedded again)");
     if (JSON.stringify(sealedAgain).includes("Velvet")) throw new Error("a sealed row must not carry its plaintext");
-    await publishView({ fangorn, app: APP, store: r2Store(VIEW), embedBatch: encode(env, DOCUMENT), embedder: WORKER_EMBEDDER, log: () => {},
+    await publishView({ fangorn, app: APP, schema: CONFIG.schema, store: r2Store(VIEW), embedBatch: encode(env, DOCUMENT), embedder: WORKER_EMBEDDER, log: () => {},
         open: (p) => openRow(SECRET, p) });
     env.PAID_SECRET = SECRET;
     CONFIG = env.CONFIG = { ...env.CONFIG, private: { network: "eip155:84532", asset: `0x${"aa".repeat(20)}`, payTo: `0x${"5e".repeat(20)}`,

package/src/publish/init.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// 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");
+// What fangorn.network accepts: a name a shell and a URL need no quoting for.
+const APP_NAME = /^[a-z0-9][a-z0-9._-]{1,62}$/;
+
+export function init(app, dir = app, { install = true, log = console.log } = {}) {
+    if (!APP_NAME.test(app ?? "")) throw new Error(`"${app}": 2-63 characters, lowercase letters, digits, dot, dash or underscore`);
+    dir = resolve(dir);
+    if (existsSync(dir) && readdirSync(dir).length) throw new Error(`${dir} is not empty`);
+    cpSync(TEMPLATE, dir, { recursive: true });
+    renameSync(join(dir, "gitignore"), join(dir, ".gitignore"));   // npm drops a published .gitignore
+
+    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}`;
+    writeFileSync(join(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+
+    if (install) {
+        const sh = (cmd, ...args) => { if (spawnSync(cmd, args, { cwd: dir, stdio: "inherit" }).status !== 0) throw new Error(`${cmd} ${args[0]} failed`); };
+        sh("npm", "install");   // the lock CI installs from
+        sh("git", "init", "-q", "-b", "main");
+        sh("git", "add", "-A");
+        sh("git", "commit", "-q", "-m", `${app}: from the westmarch template`);
+    }
+    log(`${app} is in ${dir}. Next:
+  1. app.json: the description, and the type's fields (role_map)
+  2. npx westmarch-ship app.json           # claims ${app} if it isn't yet, deploys the Worker, registers its agent`);
+    return dir;
+}
+
+if (process.argv[2] === "--selfcheck") {
+    const dir = join(mkdtempSync(join(tmpdir(), "init-")), "app");
+    try {
+        init("my.app_1", dir, { install: false, log: () => {} });
+        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"))) 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; }
+        if (!threw) throw new Error("a one-letter name must be refused");
+        console.log("init: ok");
+    } finally { rmSync(dirname(dir), { recursive: true, force: true }); }
+} else if (process.argv[2] === "init") {
+    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] | westmarch build [app.json]");
+    process.exit(2);
+}

package/src/publish/ship.js

@@ -14,16 +14,15 @@
 //
 //   1. claim the app (first run only; the claim block becomes the card's fromBlock).
 //      The claimer is the app's first member, so its own updates are accepted.
-//   2. commit the schema, if the one on chain differs from app.json's `types`
-//   3. run each source, which crawls and publishes straight into the app
-//   4. the stock page, the card and _headers → .ship/site
-//   5. deploy the Worker: its R2 bucket, Workers AI, the cron, CONFIG
-//   6. register the ERC-8004 agent and bind the card, if the chain points elsewhere
+//   2. run each source, which crawls and publishes straight into the app
+//   3. the stock page, the card and _headers → .ship/site
+//   4. deploy the Worker: its R2 bucket, Workers AI, the cron, CONFIG (app.json's schema rides in it)
+//   5. register the ERC-8004 agent and bind the card, if the chain points elsewhere
 //
-// The Worker picks up what 2 and 3 published on its next cron run (every few minutes),
+// The Worker picks up what 2 published on its next cron run (every few minutes),
 // so the view follows the chain with nobody running anything.
 //
-// --register is the fast path, run before there is any data: 1, 4, 5 and 6 binding the card
+// --register is the fast path, run before there is any data: 1, 3, 4 and 5 binding the card
 // without minting. The mint copies the card's skills into its IPFS registration file and is
 // never redone, so it waits for the first full ship, when the card lists what the app does.
 //
@@ -35,10 +34,9 @@ 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";
-import { RELATION_TAG, TYPE_TAG } from "./view.js";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 // USDC per x402 network (CAIP-2): its address and EIP-712 domain, as each contract reports them.
@@ -90,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",
@@ -148,17 +149,16 @@ 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 schema commit for `types` + `relations`: one fangorn.type.v1 record per type, one
- *  fangorn.relation.v1 record per allowed reference. A file for `fangorn commit --replace`. */
-export function schemaRecords(types, relations = []) {
-    return { records: [
-        ...Object.entries(types).map(([tag, t]) => ({ id: `type:${tag}`, type: TYPE_TAG, payload: {
-            tag, description: t.description ?? "", role_map: t.role_map ?? {}, presentation: t.presentation ?? {} } })),
-        ...relations.map((r) => ({ id: `rel:${r.rel}:${r.from}:${r.to}`, type: RELATION_TAG, payload: { rel: r.rel, from: r.from, to: r.to } })),
-    ] };
+/** 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
@@ -186,13 +186,6 @@ export function wranglerConfig({ name, site, account, cron = "*/5 * * * *", conf
 const stable = (v) => Array.isArray(v) ? v.map(stable)
     : v && typeof v === "object" ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, stable(v[k])])) : v;
 
-/** Same shape parseSchema returns, so a config and the chain compare directly. */
-const canonical = (types, relations = []) => JSON.stringify(stable({
-    types: Object.fromEntries(Object.entries(types).sort(([a], [b]) => a.localeCompare(b))
-        .map(([tag, t]) => [tag, { description: t.description ?? "", role_map: t.role_map ?? {}, presentation: t.presentation ?? {} }])),
-    relations: [...relations].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b))),
-}));
-
 // ── processes ─────────────────────────────────────────────────────────────────
 
 /** `${VAR}` and `${VAR:-default}` from the environment, so one app.json runs on a laptop
@@ -236,12 +229,75 @@ 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 } = {}) {
     const cfg = loadConfig(configPath);
-    if (!register && (!Object.keys(cfg.types).length || !cfg.sources.length))
-        throw new Error(`${configPath}: no types or sources yet, so nothing to build; --register sets up the app alone`);
+    // No sources is fine: the app then presents whatever its members commit (repos: [] = all of them).
+    if (!register && !Object.keys(cfg.types).length)
+        throw new Error(`${configPath}: no types yet, so nothing to build; --register sets up the app alone`);
     // No default: one that changed would claim every app that leaned on it again, elsewhere.
     if (!cfg.network) throw new Error(`${configPath}: "network" is required: "baseSepolia" for a new app, or the network the app was claimed on (before 2026-10-20 the default was "arbitrumSepolia")`);
     CLI = cliArgv(cfg);
@@ -276,8 +332,9 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     const me = (fangornCli(cfg.app, ["wallet"]).match(/Address:\s+(0x[0-9a-fA-F]{40})/) ?? [])[1]?.toLowerCase();
     if (!me) throw new Error("`fangorn wallet` shows no address; run `fangorn init`");
     let owner = (await registry.getAppOwner()).toLowerCase();
+    const chain = createPublicClient({ transport: http(FangornConfig.rpcUrl) });
     if (/^0x0+$/.test(owner)) {
-        const block = await createPublicClient({ transport: http(FangornConfig.rpcUrl) }).getBlockNumber();
+        const block = await chain.getBlockNumber();
         state.fromBlock = String(block);
         log(`${cfg.app} is unclaimed; claiming it for ${me} (fromBlock ${block})`);
         fangornCli(cfg.app, ["app", "claim"], { dry });
@@ -286,25 +343,12 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     } else if (owner !== me) {
         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) state.fromBlock = await claimBlock(chain, FangornConfig, appId);
     state.fromBlock ??= String(cfg.fromBlock ?? FangornConfig.appRegistryFromBlock);
     log(`app ${cfg.app} = ${appId}, owner ${owner}, fromBlock ${state.fromBlock}`);
 
-    // 2. schema
-    if (!register) {
-        let onChain = null;
-        try { onChain = view.parseSchema((await fangorn.readRepo(owner, view.SCHEMA_REPO)).contents); } catch { /* none yet */ }
-        if (!onChain || canonical(onChain.types, onChain.relations) !== canonical(cfg.types, cfg.relations)) {
-            const sdir = join(dir, "schema");
-            mkdirSync(sdir, { recursive: true });
-            writeFileSync(join(sdir, "schema.json"), JSON.stringify(schemaRecords(cfg.types, cfg.relations), null, 1));
-            log(`schema ${onChain ? "changed" : "is new"}: committing ${Object.keys(cfg.types).join(", ")}`);
-            fangornCli(cfg.app, ["repo", "init", view.SCHEMA_REPO], { cwd: sdir, dry });
-            fangornCli(cfg.app, ["commit", "schema.json", "-m", "schema", "--replace"], { cwd: sdir, dry });
-            fangornCli(cfg.app, ["push"], { cwd: sdir, dry });
-        } else log("schema unchanged");
-    }
-
-    // 3. sources: crawl + publish straight into the app. One source failing (a site that
+    // 2. sources: crawl + publish straight into the app. One source failing (a site that
     // blocks us, a feed that is down) keeps its last published data and does not stop the
     // others; the ship still exits non-zero at the end, naming it.
     const failed = [];
@@ -322,12 +366,12 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
         }
     }
 
-    // 4. the page, the card, the headers
+    // 3. the page, the card, the headers
     const { site, writeCard } = await buildSite(cfg, base);
     // 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.
@@ -350,13 +394,13 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     const writeSite = (u) => writeCard(u, { fromBlock: state.fromBlock, repos, paid: sale(u).paid, access: access(u).card });
     writeSite(url ?? `https://${cfg.site.project}.workers.dev`);
 
-    // 5. the Worker
+    // 4. the Worker
     const workerConfig = (u) => {
         const path = join(dir, "wrangler.json");
         writeFileSync(path, JSON.stringify(wranglerConfig({
             name: cfg.site.project, site, account: cfg.site.account, cron: cfg.site.cron, url: cfg.site.url, ipfsGateway: view.ipfsGateway(),
             config: { app: cfg.app, name: cfg.name, description: cfg.description, fromBlock: state.fromBlock, network: cfg.network,
-                      repos: register ? [] : repos, paid: sale(u).sale, private: access(u).config },
+                      schema: { types: cfg.types, relations: cfg.relations }, repos: register ? [] : repos, paid: sale(u).sale, private: access(u).config },
         }), null, 1));
         return path;
     };
@@ -380,7 +424,7 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
         else if (cfg.paid) log("paid: set the key secret once with `npx wrangler secret put PAID_SECRET --config .ship/wrangler.json`");
     } else workerConfig(url ?? `https://${cfg.site.project}.workers.dev`);
 
-    // 6. ERC-8004 + the binding
+    // 5. ERC-8004 + the binding
     const cardUrl = `${url}/.well-known/agent-card.json`;
     const bound = await registry.appAgentUri(appId).catch(() => "");
     const mint = () => {
@@ -403,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 && !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`));
     }
@@ -579,21 +623,18 @@ export function readStage(cfg, base, { crawl = false, only = null, log: say = lo
 }
 
 /**
- * The whole app on this machine (devnet.js): a local chain and IPFS, the app claimed and its
- * schema committed there, what the sources staged published into it, and its Worker under
+ * The whole app on this machine (devnet.js): a local chain and IPFS, the app claimed there, what the sources staged published into it, and its Worker under
  * `wrangler dev` with a local R2 and an encoder on localhost (or Workers AI with ai=true).
  * Runs the indexer once, says where everything is, and stays up until interrupted.
  */
 export async function devnetShip(configPath, { crawl = false, only = null, port = 8787, ai = false } = {}) {
     const cfg = loadConfig(configPath);
     const base = dirname(resolve(configPath));
-    const [{ devnet }, { SCHEMA_REPO }] = await Promise.all([import("./devnet.js"), import("./view.js")]);
+    const { devnet } = await import("./devnet.js");
     const staged = readStage(cfg, base, { crawl, only });
     const net = await devnet({ log });
     const owner = await net.client(cfg.app);
     await owner.getAppRegistry().registerApp();
-    await owner.initRepo(SCHEMA_REPO);
-    await owner.uploadBatch(SCHEMA_REPO, schemaRecords(cfg.types, cfg.relations).records);
     // The claimer publishes the sources, as `fangorn` does in a ship.
     for (const [ns, records] of Object.entries(staged)) {
         if (!records.length) continue;
@@ -607,7 +648,7 @@ export async function devnetShip(configPath, { crawl = false, only = null, port
     const { site, writeCard } = await buildSite(cfg, base);
     writeCard(url, { fromBlock: "0", repos });
     const wcfg = wranglerConfig({ name: cfg.site.project, site, config: { app: cfg.app, name: cfg.name, description: cfg.description,
-        fromBlock: "0", repos, paid: null, deployment: net.deployment } });
+        fromBlock: "0", schema: { types: cfg.types, relations: cfg.relations }, repos, paid: null, deployment: net.deployment } });
     // Its own R2 and state, apart from a deployed app's.
     wcfg.vars.RPC_URL = net.rpcUrl;
     wcfg.vars.IPFS_GATEWAY = net.gatewayUrl;
@@ -701,17 +742,34 @@ export async function buildLocal(configPath, out, { crawl = false, only = null,
     env.cacheDir = `${homedir()}/.cache/fangorn-mcp/models`;
     // Not the app's real id or owner: nothing here is compared with the chain.
     const appId = `0x${createHash("sha256").update(cfg.app).digest("hex")}`, owner = `0x${"10ca1".padStart(40, "0")}`;
-    const chain = { [`${owner}/${view.SCHEMA_REPO}`]: {
-        records: schemaRecords(cfg.types, cfg.relations).records.map((r) => ({ ...r, cid: r.id })) } };
+    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,
-        repos, out, embed, log: say });
+        schema: { types: cfg.types, relations: cfg.relations }, repos, out, embed, log: say });
     const rows = Object.values(report).reduce((n, r) => n + r.added, 0);
     say(`local view: ${out}  ·  ${rows} records, ${embed.misses} embedded, ${rows - embed.misses} from the vector cache`);
     return report;
@@ -720,19 +778,6 @@ export async function buildLocal(configPath, out, { crawl = false, only = null,
 // ── cli ───────────────────────────────────────────────────────────────────────
 if (process.argv[1]?.endsWith("ship.js") || process.argv[1]?.endsWith("westmarch-ship")) {
     if (process.argv[2] === "--selfcheck") {
-        // The schema as committed, read back the way the chain returns it, must compare
-        // equal to the config, or every run re-commits an unchanged schema.
-        const { parseSchema } = await import("./view.js");
-        const types = { "t.v1": { description: "d", role_map: { title: "name", text: ["body"] }, presentation: { externalUrl: { "t.v1": "{url}" } } },
-                        "u.v1": { description: "e", role_map: { title: "label" } } };
-        const relations = [{ rel: "cites", from: "t.v1", to: "u.v1" }];
-        const g = schemaRecords(types, relations);
-        // Keys reversed at every depth, as a canonical (sorted) encoding hands them back.
-        const reverse = (v) => Array.isArray(v) ? v.map(reverse)
-            : v && typeof v === "object" ? Object.fromEntries(Object.keys(v).reverse().map((k) => [k, reverse(v[k])])) : v;
-        const readBack = parseSchema({ records: g.records.map((r) => ({ ...r, cid: `cid-${r.id}`, payload: reverse(r.payload) })) });
-        if (canonical(readBack.types, readBack.relations) !== canonical(types, relations)) throw new Error("schema does not round-trip");
-        if (canonical(readBack.types, readBack.relations) === canonical({ ...types, "v.v1": {} }, relations)) throw new Error("a new type must count as a change");
         const row = { city: "Wisconsin Rapids", state: "WI", site: "https://x", args: ["--archive-page", "/569/A"] };
         const cmd = fill(["py", "--site", "{site}", "--city", "{city}", "{args...}", "--ns", "us-{state|lower}-{city|slug}"], row);
         if (JSON.stringify(cmd) !== JSON.stringify(["py", "--site", "https://x", "--city", "Wisconsin Rapids", "--archive-page", "/569/A", "--ns", "us-wi-wisconsin-rapids"]))
@@ -748,9 +793,13 @@ 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 committed schema reads back equal to its config, a new type counts as a change, 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");
+        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");
         process.exit(0);
     }
     const [path, ...flags] = process.argv.slice(2);

package/src/publish/view-cli.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 // westmarch-view: publish what an app presents as a view (see view.js).
 //
-//   westmarch-view --app my-app --out site/view [--repo catalog …] [--from-block N] [--rebake]
+//   westmarch-view --app my-app --out site/view [--config app.json] [--repo catalog …] [--from-block N] [--rebake]
 //
+// The schema (types, relations) is read from --config; without it every type is guessed.
 // Reads only; needs no key. Deploy <out> with the site, and put its URL in the card's
 // `views`. An app on the free tier needs none of this: its Worker runs the same code on a
 // cron (site/worker.js).
 
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 
 const flags = { repo: [] };
@@ -18,7 +20,7 @@ for (let i = 2; i < process.argv.length; i++) {
     if (m[1] === "repo") flags.repo.push(v); else flags[m[1]] = v;
 }
 if (flags.help || !flags.app || !flags.out) {
-    console.error("usage: westmarch-view --app <name|0xid> --out <dir> [--repo <name> …] [--from-block N] [--rebake]");
+    console.error("usage: westmarch-view --app <name|0xid> --out <dir> [--config app.json] [--repo <name> …] [--from-block N] [--rebake]");
     process.exit(flags.help ? 0 : 2);
 }
 
@@ -31,7 +33,8 @@ const fangorn = await readOnlyFangorn();
 
 const t0 = Date.now();
 const report = await publishView({
-    fangorn, app: flags.app, repos: flags.repo, out: flags.out,
+    fangorn, app: flags.app, repos: flags.repo,
+    schema: flags.config ? JSON.parse(readFileSync(flags.config, "utf8")) : undefined, out: flags.out,
     fromBlock: flags["from-block"], rebake: !!flags.rebake,
     log: (s) => console.error(s),
 });

package/src/publish/view.js

@@ -5,8 +5,8 @@
 //   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, and the app
-// owner's schema (`fangorn.schema`, see below). Embeds only records the view does not hold
+// members' repos, less its exclusions, `appRepos`), 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):
 //
 //   cdn/catalog
@@ -40,15 +40,9 @@ import { dirname } from "node:path";
 import { EMBED_DIM, EMBED_DTYPE, EMBED_MODEL, embedDocumentDirect, packVec, unpackVec } from "../core/embed.js";
 import { coverage as fitCoverage } from "../market/reactions.js";
 
-/** The app owner's repo that declares the app's types: one TYPE_TAG record per type, one
- *  RELATION_TAG record per allowed reference between two of them. */
-export const SCHEMA_REPO = "fangorn.schema";
-export const TYPE_TAG = "fangorn.type.v1";
-export const RELATION_TAG = "fangorn.relation.v1";
 export const EMBEDDER = { runtime: "transformers.js", model: EMBED_MODEL, dtype: EMBED_DTYPE };
 const SINGULAR = ["identity", "title", "subtitle", "temporal", "spatial", "media", "thread"];
 const MULTI = ["tags", "measures", "relations", "text"];
-const ZERO = "0x0000000000000000000000000000000000000000";
 // Refit coverage once a domain has grown this many times over what it was fit on.
 const COVERAGE_REFIT = 2;
 
@@ -75,17 +69,13 @@ export function composeText(fields, rm) {
     return s.slice(0, 1000 - "search_document: ".length);
 }
 
-/** `fangorn.schema` records → { types: {tag: {description, role_map, presentation}}, relations }. */
-export function parseSchema(contents) {
-    const types = {}, relations = [];
-    for (const r of contents?.records ?? []) {
-        const p = r.payload ?? {};
-        if (r.type === TYPE_TAG && typeof p.tag === "string")
-            types[p.tag] = { description: String(p.description ?? ""), role_map: p.role_map ?? {}, presentation: p.presentation ?? {} };
-        else if (r.type === RELATION_TAG && p.rel && p.from && p.to)
-            relations.push({ rel: String(p.rel), from: String(p.from), to: String(p.to) });
-    }
-    return { types, relations };
+/** app.json's `types` + `relations` → { types: {tag: {description, role_map, presentation}}, relations }. */
+export function schemaOf({ types = {}, relations = [] } = {}) {
+    return {
+        types: Object.fromEntries(Object.entries(types).map(([tag, t]) =>
+            [tag, { description: String(t.description ?? ""), role_map: t.role_map ?? {}, presentation: t.presentation ?? {} }])),
+        relations: relations.filter((r) => r.rel && r.from && r.to).map((r) => ({ rel: String(r.rel), from: String(r.from), to: String(r.to) })),
+    };
 }
 
 /** Declared means declared: every role present, left-out ones empty. */
@@ -281,7 +271,7 @@ 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); the view goes to `store`, or the directory `out`. `repos` narrows it to those repo
+ * 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
  * 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
@@ -290,25 +280,20 @@ const sha256 = (s) => createHash("sha256").update(s).digest("hex");
  * ([{owner, repo, root}], exclusions already applied), as a Worker does across runs.
  * Returns per-domain counts of what changed.
  */
-export async function publishView({ fangorn, app, repos, out, store = fsStore(out), fromBlock, presented, rebake = false,
+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();
-    const owner = (await fangorn.getAppRegistry().getAppOwner()).toLowerCase();
-    let schema = { types: {}, relations: [] };
-    if (owner === ZERO) log(`app ${app} is unclaimed, so it has no schema; every type will be guessed`);
-    else {
-        try { schema = parseSchema((await retry(() => fangorn.readRepo(owner, SCHEMA_REPO))).contents); }
-        catch (e) { log(`schema: none read (${e.message}); every type will be guessed`); }
-    }
+    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) })))
-        .filter((t) => t.repo !== SCHEMA_REPO && (!repos?.length || repos.includes(t.repo)));
+        // 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(", ")}` : ""}`);
 
     const report = {};
@@ -535,10 +520,9 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
 
     const APP = `0x${"ab".repeat(32)}`, OWNER = `0x${"11".repeat(20)}`, PUB = `0x${"22".repeat(20)}`;
     const TAG = "shop.item.v1";
+    const schema = { types: { [TAG]: { description: "Things for a room.", role_map: { identity: "sku", title: "name", text: "about" },
+        presentation: { externalUrl: { [TAG]: "https://shop.example/{sku}" } } } } };
     const chain = {
-        [`${OWNER}/${SCHEMA_REPO}`]: { records: [rec("t1", TYPE_TAG, {
-            tag: TAG, description: "Things for a room.", role_map: { identity: "sku", title: "name", text: "about" },
-            presentation: { externalUrl: { [TAG]: "https://shop.example/{sku}" } } })] },
         [`${PUB}/shop`]: { records: [
             rec("c1", TAG, { sku: "a1", name: "Oak table", about: "a solid oak dining table", price: 3 }),
             rec("c2", TAG, { sku: "b2", name: "Lamp", about: "brass reading lamp", price: 1 }),
@@ -557,11 +541,11 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     appendFileSync(`${out}/vectors.ndjson`, '["cut sho');
     eq(packVec(await cachedEmbed(`${out}/vectors.ndjson`, embed)("Title: Oak")), packVec(v1), "a line cut short by a kill is skipped, not fatal");
     embedded.length = 0; rmSync(`${out}/vectors.ndjson`);
-    const run = () => publishView({ fangorn, app: APP, out, embed, log: () => {} });
+    const run = () => publishView({ fangorn, app: APP, schema, out, embed, log: () => {} });
 
     const d = domainFor(APP, PUB, "shop");
     const split = mkdtempSync(`${tmpdir()}/view-`);
-    await publishView({ fangorn, app: APP, out: split, embed, log: () => {}, shardRows: 2 });
+    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");
     embedded.length = 0;
     eq((await run())[d], { added: 3, removed: 0 }, "first run embeds everything");
@@ -626,16 +610,16 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     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");
-    eq((await publishView({ fangorn, app: APP, out: big, repos: ["big"], embedBatch: capped, log: () => {} }))[bd],
+    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");
     budget = 1e9;
-    eq((await publishView({ fangorn, app: APP, out: big, repos: ["big"], embedBatch: capped, log: () => {} }))[bd],
+    eq((await publishView({ fangorn, app: APP, schema, out: big, repos: ["big"], embedBatch: capped, log: () => {} }))[bd],
        { added: 48, removed: 0 }, "the next run embeds only the rest");
     eq(manifestOf(big, bd).count, 80, "and serves all of it");
     delete chain[BIG];
     rmSync(big, { recursive: true, force: true });
-    eq((await publishView({ fangorn, app: APP, out, embed, rebake: true, log: () => {} }))[d],
+    eq((await publishView({ fangorn, app: APP, schema, out, embed, rebake: true, log: () => {} }))[d],
        { added: 2, removed: 0 }, "--rebake starts the domain over");
     eq(readdirSync(`${out}/cdn/domains/${d}/shards`).length, 1, "and leaves no orphaned shards");
     rmSync(out, { recursive: true, force: true });
@@ -644,16 +628,16 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
     // undeclared one is left alone; a target whose identity moves relinks the row without embedding it.
     {
         const T = "civic.item.v1", M = "civic.matter.v1";
-        const rel = { [`${OWNER}/${SCHEMA_REPO}`]: { records: [
-            rec("ti", TYPE_TAG, { tag: T, role_map: { identity: "item_id", title: "heading", thread: "part_of" } }),
-            rec("tm", TYPE_TAG, { tag: M, role_map: { identity: "matter_id", title: "title" } }),
-            rec("tr", RELATION_TAG, { rel: "part_of", from: T, to: M })] },
+        const relSchema = { types: { [T]: { role_map: { identity: "item_id", title: "heading", thread: "part_of" } },
+                                     [M]: { role_map: { identity: "matter_id", title: "title" } } },
+                            relations: [{ rel: "part_of", from: T, to: M }] };
+        const rel = {
             [`${PUB}/civic`]: { records: [
                 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, out: o, embed, log: () => {} });
+        const go = () => publishView({ fangorn: localFangorn(rel, { appId: APP, owner: OWNER }), 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();
@@ -682,7 +666,7 @@ if (typeof process !== "undefined" && import.meta.url === `file://${process.argv
             },
         };
         const r2 = r2Store(bucket);
-        const via = await publishView({ fangorn, app: APP, store: r2, embed, log: () => {} });
+        const via = await publishView({ fangorn, app: APP, schema, store: r2, embed, log: () => {} });
         eq(Object.keys(via), [d], "a view builds into a bucket");
         eq(await r2.list("cdn/domains"), [d], "list names a folder's children");
         eq((await liveFields(r2)).length, 2, "and reads back");

package/template/README.md

@@ -0,0 +1,50 @@
+# 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 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
+
+Any member of the app 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
+```
+
+The view picks it up within 5 minutes at `<url>/view`. A source that crawls something
+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"}`), then grade the live view:
+`npx westmarch-eval <url>/view`.

package/template/app.json

@@ -0,0 +1,27 @@
+{
+ "app": "my-app",
+ "name": "my-app",
+ "description": "One sentence: what is in here, and who it is for.",
+ "network": "baseSepolia",
+ "site": {
+  "project": "my-app",
+  "examples": []
+ },
+ "tags": [],
+ "types": {
+  "my-app.item.v1": {
+   "description": "One item: what a record is, in the words a searcher would use.",
+   "role_map": {
+    "identity": "id",
+    "title": "title",
+    "tags": ["tags"],
+    "text": ["text"]
+   },
+   "presentation": {
+    "types": { "my-app.item.v1": { "singular": "item", "plural": "items" } },
+    "facets": ["tags"]
+   }
+  }
+ },
+ "sources": []
+}

package/template/eval/goals.md

@@ -0,0 +1,7 @@
+# Goals
+
+One section per kind of person this app serves. Each check in golden.jsonl names one with `goal`.
+
+## <goal-id>: who finds what
+- **They ask:** two or three real questions, in their words.
+- **Failure looks like:** what a wrong or missing answer would be.

package/template/gitignore

@@ -0,0 +1,3 @@
+.ship/*
+!.ship/state.json
+node_modules/

package/template/package.json

@@ -0,0 +1,13 @@
+{
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "westmarch build",
+    "deploy": "wrangler deploy"
+  },
+  "dependencies": {
+    "@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": {}
+}