@bitcobblers/wod-wiki-tools 0.36.2133 → 0.36.2135

package/dist/{chunk-OZI2FYPF.mjs → chunk-OTJAPVT2.mjs}

@@ -1,9 +1,10 @@
 import { createRequire } from 'module';
-import { openCliDb, nodeFs, sqliteIndexStore, sqliteEffortStore, sqliteBlockStore, sqliteNoteStore, sqliteEventStore, getNoteBundle, getSessionBundle, getEffortBySlug, listTagsByType, nodePath, loadSql, uuid5, CLI_UUID_NAMESPACE, stableNoteId, randomId } from './chunk-EUQWEX6Z.mjs';
+import { compileSeedRow, SEED_SCHEMA, writeBuildReport } from './chunk-FZKXOYMJ.mjs';
+import { openCliDb, nodeFs, sqliteIndexStore, sqliteEffortStore, sqliteBlockStore, sqliteNoteStore, sqliteEventStore, getNoteBundle, getSessionBundle, getEffortBySlug, listTagsByType, nodePath, loadSql, uuid5, CLI_UUID_NAMESPACE, nodeCrypto, stableNoteId, randomId } from './chunk-CYKNTEGY.mjs';
 import { __require } from './chunk-6L5ZDZJ7.mjs';
 import { createParser, frozenNow, createCompiler, createMockClock, RuntimeStack, EventBus, ScriptRuntime, createAnalyticsEngineForBlock, StartSessionAction, NextEvent, toStoredOutputStatement, bundledEfforts, parseScript } from '@bitcobblers/wod-wiki-lang';
-import { buildStatementTree, createIRFile, registerLanguagePack, extractNoteIdentity, extractTypedTags, composeNoteMarkdown, sessionToCsv, effortToMarkdown, equipmentToCsv, markdownToEffort, csvToEquipmentLabels, csvToSessionRows, isIRFile, inMemoryEventStore, assertSeedManifest, seedMetaKey, SEED_SCHEMA, emptySeedMeta, CANVAS_CHUNK_ID, assertSeedRows, seedNoteId, applySeedChunk } from '@bitcobblers/wod-wiki-engine';
-import { toEventRows, toSummaryEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery } from '@bitcobblers/wod-wiki-wql';
+import { buildStatementTree, createIRFile, registerLanguagePack, extractNoteIdentity, extractTypedTags, composeNoteMarkdown, sessionToCsv, effortToMarkdown, equipmentToCsv, markdownToEffort, csvToEquipmentLabels, csvToSessionRows, isIRFile, inMemoryEventStore, readFrontmatterMeta, assertSeedManifest, seedMetaKey, SEED_SCHEMA as SEED_SCHEMA$1, emptySeedMeta, CANVAS_CHUNK_ID, assertSeedRows, seedNoteId, applySeedChunk } from '@bitcobblers/wod-wiki-engine';
+import { toEventRows, toSummaryEventRows, parseQuery, QueryService, isPipelineQuery, isFindQuery, catalogOfItem } from '@bitcobblers/wod-wiki-wql';
 import { validateNoteBlocks, parseDocumentSections, blockContentId, reconcileNoteBlocks, KNOWN_SECTION_WIDGETS } from '@bitcobblers/wod-wiki-core';
 import { rowsEqual } from '@bitcobblers/wod-wiki-storage';
 
@@ -955,18 +956,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 = 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;
+        }
+      }
     });
     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);
@@ -988,6 +995,8 @@ async function saveSource(db, options, startTime) {
       sourceRevision++;
       for (const block of Object.values(blocks)) block.sourceRevision = sourceRevision;
     }
+    const fm = 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,
@@ -997,7 +1006,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);
@@ -1025,6 +1035,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") {
@@ -1196,7 +1207,7 @@ async function importSeedDir(db, dir, sourceId) {
   const manifest = assertSeedManifest(JSON.parse(fs.readFileSync(path.resolve(dir, "manifest.json"), "utf-8")));
   const key = seedMetaKey(source);
   let expected = await db.storage.readonly("meta").get(key);
-  if (expected && expected.schema !== SEED_SCHEMA) throw new Error("Incompatible seed checkpoint; recreate storage");
+  if (expected && expected.schema !== SEED_SCHEMA$1) throw new Error("Incompatible seed checkpoint; recreate storage");
   let meta = expected ?? emptySeedMeta(key);
   if (manifest.version < meta.seedVersion) throw new Error("Seed manifest is older than stored checkpoint");
   const summary = { sourceId: source, version: manifest.version, notes: 0, efforts: 0, blocks: 0, blockEfforts: 0, deleted: 0, skippedUserOwned: 0 };
@@ -1229,7 +1240,7 @@ async function importSeedDir(db, dir, sourceId) {
     expected = next;
   }
   if (plan.length || metadataChanged || Object.keys(meta.chunks).length !== Object.keys(expected?.chunks ?? {}).length) {
-    const next = { ...meta, schema: SEED_SCHEMA, seedVersion: manifest.version, builtAt: manifest.builtAt, importedAt: Date.now() };
+    const next = { ...meta, schema: SEED_SCHEMA$1, seedVersion: manifest.version, builtAt: manifest.builtAt, importedAt: Date.now() };
     await applySeedChunk(db.storage, { chunkId: null, rows: [], manifest, expectedMeta: expected, meta: next });
   }
   return summary;
@@ -1238,9 +1249,135 @@ function defaultSeedDirs(cwd) {
   const base = nodePath().resolve(cwd, "apps", "playground", "public", "seed");
   return ["core", "community"].map((id) => nodePath().resolve(base, id)).filter((dir) => nodeFs().existsSync(nodePath().resolve(dir, "manifest.json")));
 }
+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 = readFrontmatterMeta(note.rawContent);
+    const cat = typeof fm["catalog"] === "string" && fm["catalog"].trim() || typeof fm["collection"] === "string" && fm["collection"].trim() || note.catalog || 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 json = JSON.stringify(chunkRows);
+    const digest = nodeCrypto().createHash("sha256").update(json).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), json, "utf-8");
+    manifestChunks.push({
+      id: chunkId,
+      path: chunkFile,
+      sha256: sha,
+      bytes: Buffer.byteLength(json, "utf8"),
+      count: chunkRows.length,
+      kind: "notes"
+    });
+    totalNotes += chunkRows.length;
+  }
+  const manifest = {
+    schema: SEED_SCHEMA,
+    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,
+    outDir
+  });
+  return {
+    manifest,
+    outDir,
+    catalogs: publishedCatalogs,
+    totalNotes
+  };
+}
 
 // src/version.ts
-var VERSION = "0.36.2133";
+var VERSION = "0.36.2135";
 
 // src/cli/runner.ts
 function getFs2() {
@@ -1385,9 +1522,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;
@@ -1448,8 +1592,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]
@@ -1469,23 +1615,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.
@@ -1493,6 +1639,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/ +
@@ -1541,9 +1691,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.
@@ -1803,21 +1953,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 = composeNoteMarkdown(bundle.note);
@@ -1827,11 +1978,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 = sessionToCsv(bundle.session, bundle.events);
@@ -1841,11 +1992,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 = effortToMarkdown(effort);
@@ -1855,7 +2006,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 = equipmentToCsv(labels);
@@ -1865,7 +2016,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();
@@ -1875,9 +2026,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();
@@ -1885,7 +2036,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 = extractNoteIdentity(source);
         const tags = extractTypedTags(source);
@@ -1899,7 +2050,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();
@@ -1948,6 +2099,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 ?? ".");
@@ -1955,7 +2126,7 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         writeErr(`[wod build] No markdown/ corpus under ${root} \u2014 run from the content repo root (or pass its directory).`);
         return 1;
       }
-      const { generateSeed } = await import('./compiler-KT6P3AC6.mjs');
+      const { generateSeed } = await import('./compiler-CTPLIZJK.mjs');
       try {
         const result = generateSeed({
           corpusRoot: root,
@@ -2024,14 +2195,8 @@ 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) \u2014 run \`bun wod server\` / \`bun wod playground\`.`
-        );
-        return 1;
-      }
       const mode = parsed.subcommand === "playground" ? "playground" : "server";
-      const { runCliServer } = await import('./server-Z2T7IGZX.mjs');
+      const { runCliServer } = await import('./server-JXECWS4A.mjs');
       const options = { env: cliEnv() };
       if (mode === "server") options.database = cliDb();
       if (parsed.host !== void 0) options.host = parsed.host;
@@ -2057,5 +2222,5 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
 }
 
 export { PackLoadError, ParseSyntaxError, WqlSyntaxError, cliMain, formatExecutionOutput, formatParseOutput, formatQueryOutput, loadCliEnvironment, loadLanguagePack, loadQueryData, parseCliArgs, readStdin, resolveDatabaseConfig, runExecution, runParse, runQueryCli };
-//# sourceMappingURL=chunk-OZI2FYPF.mjs.map
-//# sourceMappingURL=chunk-OZI2FYPF.mjs.map
+//# sourceMappingURL=chunk-OTJAPVT2.mjs.map
+//# sourceMappingURL=chunk-OTJAPVT2.mjs.map