@bitcobblers/wod-wiki-tools 0.36.2134 → 0.36.2136

package/dist/index.cjs

@@ -8,11 +8,17 @@ var path = require('path');
 var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
 var crypto = require('crypto');
 var promises = require('fs/promises');
+var stream = require('stream');
 var sql = require('@bitcobblers/wod-wiki-storage/sql');
 var wodWikiStorage = require('@bitcobblers/wod-wiki-storage');
+var http = require('http');
 var wodWikiEngine = require('@bitcobblers/wod-wiki-engine');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
+
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -1065,10 +1071,10 @@ var init_errors = __esm({
     };
   }
 });
-function bunFile(path) {
-  const bun2 = globalThis;
-  if (!bun2.Bun) throw new Error("the wod-wiki server handler requires the Bun runtime (https://bun.sh)");
-  return bun2.Bun.file(path);
+function streamFile(path) {
+  const bun = globalThis.Bun;
+  if (bun?.file) return bun.file(path);
+  return stream.Readable.toWeb(fs.createReadStream(path));
 }
 function jsonParam(url, name) {
   const raw = qget(url, name);
@@ -1157,14 +1163,14 @@ async function realpathSafe(path) {
 async function serveFile(real, rel) {
   const cache = rel.includes("seed/chunks/") ? "public, max-age=31536000, immutable" : "no-cache";
   const ext = rel.slice(rel.lastIndexOf(".") + 1).toLowerCase();
-  return new Response(bunFile(real), {
+  return new Response(streamFile(real), {
     headers: { "content-type": MIME[ext] ?? "application/octet-stream", "cache-control": cache }
   });
 }
 async function serveSpaShell(distRoot) {
   const index = await realpathSafe(path.join(distRoot, "index.html"));
   if (index && (index === distRoot || index.startsWith(distRoot + path.sep)) && await promises.stat(index).then((s) => s.isFile(), () => false)) {
-    return new Response(bunFile(index), {
+    return new Response(streamFile(index), {
       headers: { "content-type": MIME.html, "cache-control": "no-cache" }
     });
   }
@@ -1351,12 +1357,55 @@ var server_exports = {};
 __export(server_exports, {
   runCliServer: () => runCliServer
 });
-function bun() {
+function withResolvers() {
+  let resolve2;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve2, reject };
+}
+function startHttpServer(handler, host, port) {
   const b = globalThis.Bun;
-  if (!b) {
-    throw new Error("wod server/playground requires the Bun runtime (https://bun.sh)");
+  if (b?.serve) {
+    const s = b.serve({ port, hostname: host, fetch: handler });
+    return Promise.resolve({ stop: () => s.stop() });
   }
-  return b;
+  const { promise, resolve: resolve2, reject } = withResolvers();
+  const server = http__default.default.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", `http://${req.headers.host || `${host}:${port}`}`);
+      const hasBody = req.method !== "GET" && req.method !== "HEAD";
+      const webReq = new Request(url, {
+        method: req.method,
+        headers: req.headers,
+        body: hasBody ? stream.Readable.toWeb(req) : null,
+        ...hasBody ? { duplex: "half" } : {}
+      });
+      const webRes = await handler(webReq);
+      res.writeHead(webRes.status, Object.fromEntries(webRes.headers.entries()));
+      if (webRes.body) {
+        stream.Readable.fromWeb(webRes.body).pipe(res);
+      } else {
+        res.end();
+      }
+    } catch {
+      res.statusCode = 500;
+      res.end("internal server error");
+    }
+  });
+  server.once("error", reject);
+  server.listen(port, host, () => {
+    resolve2({
+      stop: () => {
+        const close = withResolvers();
+        server.close(() => close.resolve());
+        return close.promise;
+      }
+    });
+  });
+  return promise;
 }
 function moduleDir() {
   const p = nodePath();
@@ -1410,7 +1459,6 @@ function resolveBind(mode, options) {
   return { host, port };
 }
 async function runCliServer(mode, options, writeOut) {
-  const runtime = bun();
   const { host, port } = resolveBind(mode, options);
   let db;
   let dbLabel = "no database";
@@ -1431,7 +1479,7 @@ async function runCliServer(mode, options, writeOut) {
   try {
     const dist = resolveDist(mode, options);
     const handler = createHandler(db?.db ?? null, { playgroundDist: dist });
-    server = runtime.serve({ port, hostname: host, fetch: handler });
+    server = await startHttpServer(handler, host, port);
     if (mode === "server") {
       writeOut(`wod server: http://${host}:${port} \u2014 ${dbLabel} \xB7 dist ${dist}`);
     } else {
@@ -2129,18 +2177,24 @@ async function saveSource(db, options, startTime) {
       throw new Error(`Stale Note source revision for ${noteId}; expected ${expected}`);
     }
     let sourceRevision = existing?.rawContent === options.source ? existing.sourceRevision : (existing?.sourceRevision ?? 0) + 1;
+    const history = await tx.readonly("block_revisions").getAllFromIndex("by-note", noteId);
+    const latest = /* @__PURE__ */ new Map();
+    for (const row of history) {
+      if ((latest.get(row.blockId)?.version ?? 0) < row.version) latest.set(row.blockId, row);
+    }
+    let ordinal = 0;
     const blocks = wodWikiCore.reconcileNoteBlocks(options.source, {
       sourceRevision,
       blocks: options.blocks ?? (existing?.rawContent === options.source ? existing.blocks : void 0),
       registeredWidgets,
-      createId: randomId
+      createId: () => {
+        while (true) {
+          const candidate = uuid5(CLI_UUID_NAMESPACE, `${noteId}:block:${ordinal++}`);
+          if (!latest.has(candidate)) return candidate;
+        }
+      }
     });
     wodWikiCore.validateNoteBlocks(options.source, blocks, sourceRevision, { registeredWidgets });
-    const history = await tx.readonly("block_revisions").getAllFromIndex("by-note", noteId);
-    const latest = /* @__PURE__ */ new Map();
-    for (const row of history) {
-      if ((latest.get(row.blockId)?.version ?? 0) < row.version) latest.set(row.blockId, row);
-    }
     const revisions = [];
     for (const block of Object.values(blocks)) {
       const saved = latest.get(block.id);
@@ -2162,6 +2216,8 @@ async function saveSource(db, options, startTime) {
       sourceRevision++;
       for (const block of Object.values(blocks)) block.sourceRevision = sourceRevision;
     }
+    const fm = wodWikiEngine.readFrontmatterMeta(options.source);
+    const catalog = typeof fm["catalog"] === "string" && fm["catalog"].trim() || typeof fm["collection"] === "string" && fm["collection"].trim() || existing?.catalog;
     const note = {
       ...existing,
       id: noteId,
@@ -2171,7 +2227,8 @@ async function saveSource(db, options, startTime) {
       createdAt: existing?.createdAt ?? now,
       rawContent: options.source,
       sourceRevision,
-      blocks
+      blocks,
+      ...catalog ? { catalog } : {}
     };
     const priorRows = await tx.readonly("block_index").getAllFromIndex("by-note", noteId);
     const priorEfforts = await tx.readonly("block_efforts").getAllFromIndex("by-note", noteId);
@@ -2199,6 +2256,7 @@ async function saveSource(db, options, startTime) {
         noteTitle: note.title,
         createdAt: prior?.createdAt ?? now,
         blockContentId: fingerprint,
+        ...catalog ? { catalog } : {},
         ...note.sourceId ? { sourceId: note.sourceId } : {}
       });
       if (block.kind === "wod") {
@@ -2416,6 +2474,136 @@ function defaultSeedDirs(cwd) {
   return ["core", "community"].map((id) => nodePath().resolve(base, id)).filter((dir) => nodeFs().existsSync(nodePath().resolve(dir, "manifest.json")));
 }
 
+// src/cli/publish.ts
+init_db();
+init_contract();
+init_compiler();
+init_report();
+async function publishCatalogSeed(db, options) {
+  const t0 = Date.now();
+  const fs = nodeFs();
+  const path = nodePath();
+  const allNotes = await db.storage.readonly("notes").getAll();
+  if (allNotes.length === 0) {
+    throw new Error(`[wod publish] No notes found in database ${db.path}`);
+  }
+  const notesByCatalog = /* @__PURE__ */ new Map();
+  for (const note of allNotes) {
+    const fm = wodWikiEngine.readFrontmatterMeta(note.rawContent);
+    const cat = typeof fm["catalog"] === "string" && fm["catalog"].trim() || typeof fm["collection"] === "string" && fm["collection"].trim() || note.catalog || wodWikiWql.catalogOfItem(note);
+    const key = cat || "__uncataloged__";
+    const list = notesByCatalog.get(key) ?? [];
+    list.push(note);
+    notesByCatalog.set(key, list);
+  }
+  const targetCatalogs = /* @__PURE__ */ new Map();
+  if (options.catalog) {
+    const matching = notesByCatalog.get(options.catalog);
+    if (matching) {
+      targetCatalogs.set(options.catalog, matching);
+    } else if (notesByCatalog.has("__uncataloged__") && notesByCatalog.size === 1) {
+      targetCatalogs.set(options.catalog, notesByCatalog.get("__uncataloged__"));
+    } else {
+      const available = [...notesByCatalog.keys()].filter((k) => k !== "__uncataloged__");
+      throw new Error(
+        `[wod publish] Catalog "${options.catalog}" not found in ${db.path}.` + (available.length > 0 ? ` Available catalogs: ${available.join(", ")}` : "")
+      );
+    }
+  } else {
+    for (const [cat, notes] of notesByCatalog.entries()) {
+      targetCatalogs.set(cat === "__uncataloged__" ? "default" : cat, notes);
+    }
+  }
+  const allIndexRows = await db.storage.readonly("block_index").getAll();
+  const allEffortRows = await db.storage.readonly("block_efforts").getAll();
+  const indexByNote = /* @__PURE__ */ new Map();
+  for (const row of allIndexRows) {
+    const list = indexByNote.get(row.noteId) ?? [];
+    list.push(row);
+    indexByNote.set(row.noteId, list);
+  }
+  const effortsByNote = /* @__PURE__ */ new Map();
+  for (const row of allEffortRows) {
+    const list = effortsByNote.get(row.noteId) ?? [];
+    list.push(row);
+    effortsByNote.set(row.noteId, list);
+  }
+  const outDir = path.resolve(process.cwd(), options.outDir);
+  const chunksDir = path.join(outDir, "chunks");
+  fs.mkdirSync(chunksDir, { recursive: true });
+  const manifestChunks = [];
+  let totalNotes = 0;
+  const publishedCatalogs = [];
+  for (const [catalogName, notes] of targetCatalogs.entries()) {
+    publishedCatalogs.push(catalogName);
+    const chunkRows = [];
+    for (const note of notes) {
+      const stem = (note.title || note.id).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "") || "note";
+      const notePath = note.sourcePath ?? `markdown/collections/${catalogName}/${stem}.md`;
+      const noteBlockIndex = indexByNote.get(note.id) ?? [];
+      const noteBlockEfforts = effortsByNote.get(note.id) ?? [];
+      const blockIndex = noteBlockIndex.length > 0 ? noteBlockIndex.map((b) => ({
+        ...b,
+        isStatic: true,
+        sourceId: b.sourceId ?? `collection:${catalogName}/${stem}`,
+        sourcePath: b.sourcePath ?? notePath,
+        catalog: catalogName
+      })) : compileSeedRow(notePath, note.rawContent, {
+        routeId: `${catalogName}/${stem}`,
+        sourceId: `collection:${catalogName}/${stem}`,
+        createdAt: note.createdAt,
+        noteTitle: note.title
+      }).blockIndex;
+      const blockEfforts = noteBlockEfforts.map((e) => ({
+        ...e,
+        isStatic: true,
+        sourcePath: e.sourcePath ?? notePath
+      }));
+      chunkRows.push({
+        path: notePath,
+        content: note.rawContent,
+        blocks: note.blocks,
+        blockIndex,
+        blockEfforts
+      });
+    }
+    const chunkId = `collection.${catalogName}`;
+    const json2 = JSON.stringify(chunkRows);
+    const digest = nodeCrypto().createHash("sha256").update(json2).digest();
+    const sha = [...digest].map((b) => b.toString(16).padStart(2, "0")).join("");
+    const chunkFile = `chunks/${chunkId}.${sha.slice(0, 8)}.json`;
+    fs.writeFileSync(path.join(outDir, chunkFile), json2, "utf-8");
+    manifestChunks.push({
+      id: chunkId,
+      path: chunkFile,
+      sha256: sha,
+      bytes: Buffer.byteLength(json2, "utf8"),
+      count: chunkRows.length,
+      kind: "notes"
+    });
+    totalNotes += chunkRows.length;
+  }
+  const manifest = {
+    schema: SEED_SCHEMA2,
+    version: options.version ?? 1,
+    versionLabel: `v${options.version ?? 1}`,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks: manifestChunks
+  };
+  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  writeBuildReport(outDir, {
+    manifest,
+    totalMs: Date.now() - t0,
+    passMs: { scan: 0, blockIndex: 0, parseGate: 0, blockEfforts: 0, write: Date.now() - t0 },
+    fileCount: totalNotes});
+  return {
+    manifest,
+    outDir,
+    catalogs: publishedCatalogs,
+    totalNotes
+  };
+}
+
 // src/cli/formatters.ts
 function escapeCsvField(field) {
   if (field === void 0 || field === null) return "";
@@ -2706,7 +2894,7 @@ ${escapeCsvField(data.parsed.metric)},${data.scalar},${escapeCsvField(data.unit
 }
 
 // src/version.ts
-var VERSION = "0.36.2134";
+var VERSION = "0.36.2136";
 
 // src/cli/runner.ts
 function getFs2() {
@@ -2851,9 +3039,16 @@ function parseCliArgs(args) {
       i++;
     } else if (arg.startsWith("--dir=")) {
       result.dir = arg.slice("--dir=".length);
+    } else if (arg === "--seed-version") {
+      const v = Number(args[++i]);
+      if (Number.isSafeInteger(v) && v >= 0) result.seedVersion = v;
+      i++;
+    } else if (arg.startsWith("--seed-version=")) {
+      const v = Number(arg.slice("--seed-version=".length));
+      if (Number.isSafeInteger(v) && v >= 0) result.seedVersion = v;
       i++;
     } else if (!result.subcommand) {
-      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "import" || arg === "build" || arg === "seed" || arg === "reset" || arg === "init" || arg === "server" || arg === "serve" || arg === "playground" || arg === "help" || arg === "version") {
+      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "export" || arg === "import" || arg === "publish" || arg === "build" || arg === "seed" || arg === "reset" || arg === "init" || arg === "server" || arg === "serve" || arg === "playground" || arg === "help" || arg === "version") {
         result.subcommand = arg;
       } else {
         result.target = arg;
@@ -2879,9 +3074,9 @@ function parseCliArgs(args) {
 function readBunStdinText() {
   const g = globalThis;
   if (g && typeof g === "object" && "Bun" in g) {
-    const bun2 = g.Bun;
-    if (bun2 && typeof bun2 === "object" && "stdin" in bun2) {
-      const stdin = bun2.stdin;
+    const bun = g.Bun;
+    if (bun && typeof bun === "object" && "stdin" in bun) {
+      const stdin = bun.stdin;
       if (stdin && typeof stdin === "object" && "text" in stdin) {
         const text = stdin.text;
         if (typeof text === "function") return text;
@@ -2914,8 +3109,10 @@ USAGE:
   wod parse <file | -> [options]
   wod run <file | -> [options]
   wod query '<wql-string>' [options]
-  wod download <note|session|effort|equipment> <id> [options]
-  wod import <note|session|effort|equipment> <file> [options]
+  wod export <note|playground|session|effort|equipment> <id> [options]
+  wod download <note|playground|session|effort|equipment> <id> [options]
+  wod import <note|playground|session|effort|equipment> <file> [options]
+  wod publish [catalog] [options]
   wod build [dir] [options]
   wod seed [options]
   wod reset [options]
@@ -2935,23 +3132,23 @@ SUBCOMMANDS:
                      execution-log IR
   query '<wql>'       Evaluate WQL against the database (or an explicit
                      dataset) and emit QueryResult / RowsQueryResult IR
-  download note <id>  Export the note's authored markdown to <id>.md.
+  export note <id>   Export the note's authored markdown to <id>.md.
+                     (alias: export playground, download note).
                      The frontmatter identity stamp allows re-import.
                      Frontmatter tags (general + typed equipment/quality/\u2026)
                      are materialized into the tag graph on parse/import.
-  download session <id>
+  export session <id>
                      Write the session's generated metrics (event + summary
                      rows, one CSV row per metric) to <id>.csv. Import back
-                     with 'wod import session'.
-  download effort <slug>
+                     with 'wod import session'. (alias: download session).
+  export effort <slug>
                      Write the effort registry row as corpus-style markdown
-                     (frontmatter id/slug/label/aliases/baseAttributes + body)
                      to <slug>.md. Import back with 'wod import effort'.
-  download equipment
-                     Write every equipment tag as a one-column CSV to
+  export equipment   Write every equipment tag as a one-column CSV to
                      equipment.csv. Import back with 'wod import equipment'.
-  import note <file>  Re-import exported note markdown (same as parse with
-                     the stamped identity).
+  download \u2026         Accepted alias for 'wod export'.
+  import note <file> Re-import exported note markdown (alias: import playground;
+                     same as parse with the stamped identity).
   import session <file>
                      Import a session + its events from a downloaded CSV.
                      The exact saved block revision must already exist.
@@ -2959,6 +3156,10 @@ SUBCOMMANDS:
                      Upsert an effort registry row from corpus-style markdown.
   import equipment <file>
                      Create/upgrade equipment tags (CSV, one label per row).
+  publish [catalog]   Publish catalog notes from the database into a configured
+                     seed directory (manifest.json, chunks/, report.html)
+                     compatible with 'wod seed --source <dir>'. Override target
+                     with -o/--out/--output (defaults to ./dist/seed/<catalog>).
   build [dir]         Compile a seed corpus: validate every .md under
                      <dir>/markdown (parity gate + dashboard format gate) and
                      write manifest.json + content-hashed chunks/ +
@@ -3007,9 +3208,9 @@ DATABASE (init / parse / run / query / download / import / seed / reset / server
                       an error. Without it: ./.env when present, otherwise
                       the workspace-root .env. Credentials are never logged.
 
-HOSTING (for 'server' / 'playground'; requires the Bun runtime):
+HOSTING (for 'server' / 'playground'; supported on Node and Bun):
   server               HTTP API over the configured database plus the frontend
-                       packaged inside the engine module. Requires an
+                       packaged inside the tools module. Requires an
                        initialized database. ('serve' is an accepted alias.)
   playground           Serves the playground app backed by browser IndexedDB;
                        the configured database is not touched.
@@ -3269,21 +3470,22 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       writeDebugFile("query", ir);
       return 0;
     }
-    if (parsed.subcommand === "download") {
+    if (parsed.subcommand === "download" || parsed.subcommand === "export") {
+      const verb = parsed.subcommand;
       const kind = parsed.target;
       const id = parsed.target2;
-      const DOWNLOAD_KINDS = ["note", "session", "effort", "equipment"];
+      const DOWNLOAD_KINDS = ["note", "playground", "session", "effort", "equipment"];
       if (!id && kind !== "equipment" || !DOWNLOAD_KINDS.includes(kind ?? "")) {
-        writeErr("[wod download] Usage: wod download <note|session|effort|equipment> <id> [-o <path>]");
+        writeErr(`[wod ${verb}] Usage: wod ${verb} <note|playground|session|effort|equipment> <id> [-o <path>]`);
         return 1;
       }
       const targetId = id;
       const db = await openCliDb(cliDb());
       try {
-        if (kind === "note") {
+        if (kind === "note" || kind === "playground") {
           const bundle = await getNoteBundle(db.db, targetId);
           if (!bundle.note) {
-            writeErr(`[wod download] Note not found in ${db.path}: ${id}`);
+            writeErr(`[wod ${verb}] Note not found in ${db.path}: ${id}`);
             return 1;
           }
           const markdown = wodWikiEngine.composeNoteMarkdown(bundle.note);
@@ -3293,11 +3495,11 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           } else {
             nodeFs().writeFileSync(target, markdown, "utf-8");
           }
-          if (parsed.output !== "-") writeOut(`[wod download] note ${id} \u2192 ${target}`);
+          if (parsed.output !== "-") writeOut(`[wod ${verb}] ${kind} ${id} \u2192 ${target}`);
         } else if (kind === "session") {
           const bundle = await getSessionBundle(db.db, targetId);
           if (!bundle) {
-            writeErr(`[wod download] Session not found in ${db.path}: ${id}`);
+            writeErr(`[wod ${verb}] Session not found in ${db.path}: ${id}`);
             return 1;
           }
           const csv = wodWikiEngine.sessionToCsv(bundle.session, bundle.events);
@@ -3307,11 +3509,11 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           } else {
             nodeFs().writeFileSync(target, csv, "utf-8");
           }
-          if (parsed.output !== "-") writeOut(`[wod download] session ${id} \u2192 ${target} (${bundle.events.length} events)`);
+          if (parsed.output !== "-") writeOut(`[wod ${verb}] session ${id} \u2192 ${target} (${bundle.events.length} events)`);
         } else if (kind === "effort") {
           const effort = await getEffortBySlug(db.db, targetId);
           if (!effort) {
-            writeErr(`[wod download] Effort not found in ${db.path}: ${id}`);
+            writeErr(`[wod ${verb}] Effort not found in ${db.path}: ${id}`);
             return 1;
           }
           const markdown = wodWikiEngine.effortToMarkdown(effort);
@@ -3321,7 +3523,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           } else {
             nodeFs().writeFileSync(target, markdown, "utf-8");
           }
-          writeOut(`[wod download] effort ${id} \u2192 ${target}`);
+          writeOut(`[wod ${verb}] effort ${id} \u2192 ${target}`);
         } else {
           const labels = (await listTagsByType(db.db, "equipment")).map((t) => t.label).sort();
           const csv = wodWikiEngine.equipmentToCsv(labels);
@@ -3331,7 +3533,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
           } else {
             nodeFs().writeFileSync(target, csv, "utf-8");
           }
-          writeOut(`[wod download] equipment \u2192 ${target} (${labels.length} labels)`);
+          writeOut(`[wod ${verb}] equipment \u2192 ${target} (${labels.length} labels)`);
         }
       } finally {
         await db.close();
@@ -3341,9 +3543,9 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
     if (parsed.subcommand === "import") {
       const kind = parsed.target;
       const file = parsed.target2;
-      const IMPORT_KINDS = ["note", "session", "effort", "equipment"];
+      const IMPORT_KINDS = ["note", "playground", "session", "effort", "equipment"];
       if (!file || !IMPORT_KINDS.includes(kind ?? "")) {
-        writeErr("[wod import] Usage: wod import <note|session|effort|equipment> <file>");
+        writeErr("[wod import] Usage: wod import <note|playground|session|effort|equipment> <file>");
         return 1;
       }
       const fs = nodeFs();
@@ -3351,7 +3553,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         writeErr(`[wod import] File not found: ${file}`);
         return 1;
       }
-      if (kind === "note") {
+      if (kind === "note" || kind === "playground") {
         const source = fs.readFileSync(file, "utf-8");
         const identity = wodWikiEngine.extractNoteIdentity(source);
         const tags = wodWikiEngine.extractTypedTags(source);
@@ -3365,7 +3567,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
             tags
           });
           writeOut(
-            `[wod import] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db2.path}`
+            `[wod import] ${kind} ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db2.path}`
           );
         } finally {
           await db2.close();
@@ -3414,6 +3616,26 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       }
       return 0;
     }
+    if (parsed.subcommand === "publish") {
+      const isDir = (s) => Boolean(s && (s.startsWith(".") || s.startsWith("/") || s.includes("/") || s.includes("\\")));
+      const catalog = isDir(parsed.target) ? void 0 : parsed.target;
+      const targetDir = isDir(parsed.target) ? parsed.target : parsed.target2;
+      const outDir = parsed.output ?? targetDir ?? (catalog ? `./dist/seed/${catalog}` : "./dist/seed");
+      const db = await openCliDb(cliDb());
+      try {
+        const result = await publishCatalogSeed(db, {
+          catalog,
+          outDir,
+          version: parsed.seedVersion
+        });
+        writeOut(
+          `[wod publish] published ${result.catalogs.join(", ")} (${result.totalNotes} notes) \u2192 ${result.outDir} (manifest schema v${result.manifest.schema}, version ${result.manifest.version})`
+        );
+      } finally {
+        await db.close();
+      }
+      return 0;
+    }
     if (parsed.subcommand === "build") {
       const cwd = process.cwd();
       const root = nodePath().resolve(cwd, parsed.dir ?? parsed.target ?? ".");
@@ -3490,12 +3712,6 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       return 0;
     }
     if (parsed.subcommand === "server" || parsed.subcommand === "serve" || parsed.subcommand === "playground") {
-      if (!("Bun" in globalThis)) {
-        writeErr(
-          `[wod ${parsed.subcommand}] Error: hosting requires the Bun runtime (https://bun.sh). Install Bun to host: https://bun.sh`
-        );
-        return 1;
-      }
       const mode = parsed.subcommand === "playground" ? "playground" : "server";
       const { runCliServer: runCliServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
       const options = { env: cliEnv() };