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

package/src/discover/explore.js

@@ -15,13 +15,13 @@
 // `client` is a viem PublicClient (getLogs, readContract): passed in, so this
 // runs in a tab and in node, and the self-check needs no chain.
 //
-// ponytail: windows grow with the chain (1 + 8 at block 316M, ~0.2s). Index
-// the logs somewhere if that ever gets slow.
+// Windows grow with the chain. Pass `store` (apps.js cachedLogs) and only the
+// blocks since the last read are scanned; the page passes none.
 
 import { parseAbi, parseAbiItem } from "viem";
 // The config module alone (viem only), not the SDK's root: this runs in a tab too.
 import { BaseSepoliaConfig } from "@fangorn-network/sdk/lib/config.js";
-import { APP_EXTENSION } from "./apps.js";
+import { APP_EXTENSION, cachedLogs } from "./apps.js";
 import { survey, comparable } from "./directory.js";
 import { rankDomains, zFloor, lexScore } from "../core/rank.js";
 
@@ -123,14 +123,18 @@ async function reputation(client, agentId, chain) {
 }
 
 // `window`: the most blocks one getLogs may span on the client's RPC (chainOf says, per chain).
-async function getLogsSince(client, start, filter, window) {
+async function getLogsSince(client, start, filter, window, store) {
     const head = await client.getBlockNumber();
-    const windows = [];
-    for (let from = start; from <= head; from += window) {
-        const to = from + window - 1n < head ? from + window - 1n : head;
-        windows.push(client.getLogs({ ...filter, fromBlock: from, toBlock: to }));
-    }
-    return (await Promise.all(windows)).flat();   // in window order: oldest first still holds
+    const read = async (start, head) => {
+        const windows = [];
+        for (let from = start; from <= head; from += window) {
+            const to = from + window - 1n < head ? from + window - 1n : head;
+            windows.push(client.getLogs({ ...filter, fromBlock: from, toBlock: to }));
+        }
+        // In window order: oldest first still holds. Only what readDirectory reads, so a store stays small.
+        return (await Promise.all(windows)).flat().map(({ args, blockNumber }) => ({ args, blockNumber }));
+    };
+    return store ? cachedLogs(store, `${filter.address}:${filter.event.name}:${start}`, start, head, read) : read(start, head);
 }
 
 /**
@@ -140,11 +144,13 @@ async function getLogsSince(client, start, filter, window) {
  * `onUpdate({ apps, pending })`, if given, is called once the bindings are read
  * and again as each app lands or drops, so a page can show apps as they arrive.
  * `pending` counts the bound apps not yet settled.
+ * `store`, if given, keeps the logs read (apps.js cachedLogs), so the next read
+ * scans only the blocks since.
  */
-export async function readDirectory(client, { chain = CHAIN, onUpdate = () => {} } = {}) {
+export async function readDirectory(client, { chain = CHAIN, onUpdate = () => {}, store } = {}) {
     const [bindLogs, regLogs] = await Promise.all([
-        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }, chain.window ?? 1000n),
-        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }, chain.window ?? 1000n),
+        getLogsSince(client, chain.appRegistryFrom ?? 0n, { address: chain.appRegistry, event: APP_AGENT_CHANGED }, chain.window ?? 1000n, store),
+        getLogsSince(client, chain.identityFrom ?? 0n, { address: chain.identity, event: REGISTERED }, chain.window ?? 1000n, store),
     ]);
     const registered = regLogs.map((l) => ({ agentId: l.args.agentId, owner: l.args.owner, block: l.blockNumber }));
     const latest = new Map();   // logs come oldest first: the last write wins

package/src/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.
@@ -151,16 +149,6 @@ export function loadConfig(path) {
     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 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") }) {
@@ -186,13 +174,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 +217,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 +320,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 +331,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,7 +354,7 @@ 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.
@@ -335,12 +367,8 @@ export async function ship(configPath, { crawl = true, deploy = true, dry = fals
     const sale = (u) => {
         if (!cfg.paid) return { paid: null, sale: null };
         const T = terms(cfg.paid), price = units(cfg.paid.price, T.decimals), description = cfg.paid.description ?? "";
-        // A membership (MembershipRegistry, joined and claimed through Barliman) reads for free.
-        const membership = cfg.paid.membership ? { registry: cfg.paid.membership.registry, barliman: cfg.paid.membership.barliman.replace(/\/$/, ""),
-                                                   chainId: cfg.paid.membership.chainId ?? FangornConfig.caip2, appId } : null;
-        const paid = { url: `${u}/paid/{id}`, key_url: `${u}/key`, price, asset: T.asset, network: T.network, decimals: T.decimals, symbol: T.symbol,
-                       description, ...(membership ? { membership } : {}) };
-        return { paid, sale: { ...T, price, description, ...(membership ? { membership } : {}) } };
+        const paid = { url: `${u}/paid/{id}`, price, asset: T.asset, network: T.network, decimals: T.decimals, symbol: T.symbol, description };
+        return { paid, sale: { ...T, price, description } };
     };
     const access = (u) => {
         const X = cfg.private;
@@ -354,13 +382,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;
     };
@@ -384,7 +412,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 = () => {
@@ -407,7 +435,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 && !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`));
     }
@@ -583,21 +611,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;
@@ -611,7 +636,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;
@@ -705,8 +730,7 @@ 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 })))
         chain[`${owner}/${ns}`] = { records: records.map((r) => ({ ...r, cid: createHash("sha256").update(JSON.stringify(stable(r.payload))).digest("hex") })) };
@@ -715,7 +739,7 @@ export async function buildLocal(configPath, out, { crawl = false, only = null,
     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 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;
@@ -724,19 +748,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"]))
@@ -754,7 +765,7 @@ if (process.argv[1]?.endsWith("ship.js") || process.argv[1]?.endsWith("westmarch
             throw new Error(`private discovery: ${JSON.stringify(dp.x402)}`);
         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),
 });