@bitcobblers/wod-wiki-engine 0.11.43 → 0.35.2116

package/dist/compiler-KTBR6OEL.mjs

@@ -0,0 +1,787 @@
+import { createRequire } from 'module';
+import './chunk-6L5ZDZJ7.mjs';
+import { parseScript, isEffortDiscipline } from '@bitcobblers/wod-wiki-lang';
+import { parseDocumentSections } from '@bitcobblers/wod-wiki-core';
+import { parseDashboardNote, buildDashboardDocument, isDashboardWidgetType, resolveWidgetType, parseQuery } from '@bitcobblers/wod-wiki-wql';
+import { execSync } from 'child_process';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, rmSync, readdirSync } from 'fs';
+import { join, relative } from 'path';
+import { createHash } from 'crypto';
+
+if (typeof globalThis.require === 'undefined') {
+  try { globalThis.require = createRequire(import.meta.url); } catch {}
+}
+
+// src/cli/seedbuild/contract.ts
+var SEED_SCHEMA = 7;
+var TEMPLATE_CHUNK_ID = "template";
+var DASHBOARDS_CHUNK_ID = "dashboards";
+var BLOCK_INDEX_CHUNK_PREFIX = "block-index.";
+var BLOCK_EFFORTS_CHUNK_PREFIX = "block-efforts.";
+function canvasRouteSlug(content) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (fm?.[1] && !/^template:\s*canvas\s*$/m.test(fm[1])) return null;
+  const route = fm?.[1]?.match(/^route:\s*(\S+)\s*$/m)?.[1];
+  if (!route) return null;
+  return route.replace(/^\//, "") || null;
+}
+
+// src/cli/seedbuild/effort-slugs.ts
+function extractEffortSlugs(statements) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const statement of statements) {
+    if (statement.exerciseId) {
+      slugs.add(statement.exerciseId);
+    } else {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effort = effortMetric && typeof effortMetric.value === "string" ? effortMetric.value : void 0;
+      if (effort) {
+        const slug = effort.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+        if (slug) slugs.add(slug);
+      }
+    }
+  }
+  return Array.from(slugs);
+}
+
+// src/cli/seedbuild/filename.ts
+var FILE_TITLE_STOP_WORDS = {
+  and: true,
+  or: true,
+  of: true,
+  for: true,
+  to: true,
+  in: true,
+  on: true,
+  at: true,
+  by: true,
+  with: true,
+  the: true,
+  a: true,
+  an: true
+};
+function fileToDisplayName(filename) {
+  const base = filename.replace(/\.md$/, "");
+  if (base.toUpperCase() === "README") return "Overview";
+  const cleaned = base.replace(/^day-\d+-/, "");
+  const tokens = cleaned.split(/[-_]/);
+  const titled = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const next = tokens[i + 1];
+    const after = tokens[i + 2];
+    const prev = tokens[i - 1];
+    if (/^\d{1,2}$/.test(token) && /^\d{1,2}$/.test(next ?? "") && !/^\d+$/.test(prev ?? "") && !/^\d+$/.test(after ?? "")) {
+      titled.push(`${token}.${next}`);
+      i++;
+      continue;
+    }
+    if (titled.length > 0 && FILE_TITLE_STOP_WORDS[token.toLowerCase()]) {
+      titled.push(token.toLowerCase());
+      continue;
+    }
+    titled.push(token.charAt(0).toUpperCase() + token.slice(1));
+  }
+  return titled.join(" ");
+}
+
+// src/cli/seedbuild/frontmatter.ts
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function unquote(value) {
+  return value.replace(
+    /^(['"])(.*)\1$/,
+    (_match, quote, inner) => quote === '"' ? inner.replace(/\\(["\\])/g, "$1") : inner
+  );
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(FRONTMATTER_RE);
+  if (!match) return { meta: {}, body: raw };
+  return { meta: parseMetaLines(match[1].split(/\r?\n/)), body: raw.slice(match[0].length) };
+}
+function parseMetaLines(lines) {
+  const meta = {};
+  for (let i = 0; i < lines.length; i++) {
+    const keyMatch = lines[i].match(/^([A-Za-z][\w.-]*)\s*:(.*)$/);
+    if (!keyMatch) continue;
+    const key = keyMatch[1];
+    const rawVal = keyMatch[2].trim();
+    if (rawVal === "") {
+      const items = [];
+      while (i + 1 < lines.length) {
+        const itemMatch = lines[i + 1].match(/^\s+-\s+(.+)$/);
+        if (!itemMatch) break;
+        items.push(itemMatch[1].trim());
+        i++;
+      }
+      meta[key] = items.length > 0 ? items : "";
+    } else {
+      const wasQuoted = /^(['"])(.*)\1$/.test(rawVal);
+      const value = unquote(rawVal);
+      const num = Number(value);
+      meta[key] = !wasQuoted && value !== "" && !isNaN(num) ? num : value;
+    }
+  }
+  return meta;
+}
+function getScalar(meta, key) {
+  const value = meta[key];
+  return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function getList(meta, key) {
+  const value = meta[key];
+  return Array.isArray(value) ? value : [];
+}
+
+// src/cli/seedbuild/effort-file.ts
+function parseDiscipline(val) {
+  if (!val) return void 0;
+  const normalized = unquoteYaml(val.trim()).toLowerCase();
+  if (isEffortDiscipline(normalized)) return normalized;
+  console.warn(`[effort-file] unknown discipline '${val}' \u2014 treating as unset`);
+  return void 0;
+}
+function unquoteYaml(val) {
+  if (val.startsWith('"') && val.endsWith('"')) {
+    return val.slice(1, -1).replace(/\\(["\\])/g, "$1");
+  }
+  if (val.startsWith("'") && val.endsWith("'")) {
+    return val.slice(1, -1).replace(/\\'/g, "'");
+  }
+  return val;
+}
+function coerceNestedScalar(raw) {
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw !== "" && !Number.isNaN(Number(raw))) return Number(raw);
+  return raw;
+}
+function readNestedSection(lines, key) {
+  const start = lines.findIndex((l) => new RegExp(`^${key}:\\s*$`).test(l));
+  if (start === -1) return void 0;
+  const result = {};
+  let subKey = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S/.test(line)) break;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const m = trimmed.match(/^([\w.-]+):\s*(.*)$/);
+    if (!m) continue;
+    const [, k, rawVal] = m;
+    if (indent === 2) {
+      if (rawVal === "") {
+        subKey = k;
+        result[k] = {};
+      } else {
+        subKey = null;
+        result[k] = coerceNestedScalar(rawVal);
+      }
+    } else if (indent >= 4 && subKey !== null) {
+      result[subKey][k] = coerceNestedScalar(rawVal);
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function parseEffortFile(raw) {
+  const blockMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!blockMatch) return null;
+  const { meta, body } = parseFrontmatter(raw);
+  const innerLines = blockMatch[1].split(/\r?\n/);
+  const id = getScalar(meta, "id");
+  const slug = getScalar(meta, "slug");
+  const label = getScalar(meta, "label");
+  const aliases = getList(meta, "aliases");
+  const baseAttrs = readNestedSection(innerLines, "baseAttributes");
+  const hints = readNestedSection(innerLines, "hints");
+  const derivation = readNestedSection(innerLines, "derivation");
+  const metRaw = baseAttrs?.met;
+  const met = typeof metRaw === "number" ? metRaw : Number(metRaw);
+  if (!id || !slug || !label || metRaw === void 0 || Number.isNaN(met)) return null;
+  const discipline = parseDiscipline(
+    typeof baseAttrs?.discipline === "string" ? baseAttrs.discipline : void 0
+  );
+  const intensityTier = baseAttrs?.intensityTier;
+  const trimmedBody = body.trim();
+  return {
+    id: String(id),
+    slug: String(slug),
+    label: String(label),
+    aliases,
+    baseAttributes: {
+      met,
+      ...discipline ? { discipline } : {},
+      ...intensityTier ? { intensityTier } : {}
+    },
+    registrySource: "bundled",
+    ...trimmedBody ? { body: trimmedBody } : {},
+    ...hints ? { hints } : {},
+    ...derivation ? { derivation } : {}
+  };
+}
+var UNKNOWN_GIT_VERSION = {
+  version: 0,
+  versionLabel: "unknown",
+  commit: "",
+  dirty: false
+};
+function resolveGitVersion(repoRoot) {
+  try {
+    const run = (args) => execSync(`git ${args}`, { cwd: repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const count = Number(run("rev-list --count HEAD"));
+    return {
+      version: Number.isFinite(count) && count > 0 ? count : 0,
+      versionLabel: run("describe --tags --long --always --dirty"),
+      commit: run("rev-parse HEAD"),
+      dirty: run("status --porcelain") !== ""
+    };
+  } catch {
+    return UNKNOWN_GIT_VERSION;
+  }
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function rowHtml(c) {
+  const kind = c.kind ?? "notes";
+  return `<tr><td>${escapeHtml(c.id)}</td><td>${kind}</td><td>${c.count}</td><td>${(c.bytes / 1024).toFixed(1)} KB</td><td><code>${c.sha256.slice(0, 8)}</code></td></tr>`;
+}
+function writeBuildReport(outDir, data) {
+  const { manifest, totalMs, passMs, fileCount } = data;
+  const totalBytes = manifest.chunks.reduce((s, c) => s + c.bytes, 0);
+  const dirtyBadge = manifest.dirty ? ' <strong style="color:#b45309">(dirty working tree \u2014 not reproducible from <code>' + escapeHtml(manifest.commit ?? "") + "</code>)</strong>" : "";
+  const html = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Seed build report</title>
+<style>
+  body { font-family: system-ui, sans-serif; max-width: 960px; margin: 2rem auto; padding: 0 1rem; color: #1f2937; }
+  h1 { font-size: 1.4rem; } h2 { font-size: 1.1rem; margin-top: 2rem; }
+  table { border-collapse: collapse; width: 100%; font-size: 0.9rem; }
+  th, td { text-align: left; padding: 0.3rem 0.6rem; border-bottom: 1px solid #e5e7eb; }
+  code { font-size: 0.85em; }
+  dl { display: grid; grid-template-columns: max-content 1fr; gap: 0.2rem 1rem; font-size: 0.95rem; }
+  dt { font-weight: 600; }
+</style>
+</head>
+<body>
+<h1>Seed build report</h1>
+<h2>Version</h2>
+<dl>
+  <dt>version</dt><dd>${manifest.version} <code>${escapeHtml(manifest.versionLabel ?? "")}</code>${dirtyBadge}</dd>
+  <dt>commit</dt><dd><code>${escapeHtml(manifest.commit ?? "unknown")}</code></dd>
+  <dt>built at</dt><dd>${escapeHtml(manifest.builtAt)}</dd>
+  <dt>schema</dt><dd>v${manifest.schema}</dd>
+</dl>
+<h2>Benchmarks</h2>
+<dl>
+  <dt>total</dt><dd>${totalMs} ms</dd>
+  <dt>corpus scan + partition</dt><dd>${passMs.scan} ms (${fileCount} files)</dd>
+  <dt>block-index derivation</dt><dd>${passMs.blockIndex} ms</dd>
+  <dt>block-efforts derivation</dt><dd>${passMs.blockEfforts} ms</dd>
+  <dt>chunk writes</dt><dd>${passMs.write} ms</dd>
+</dl>
+<h2>Chunks (${manifest.chunks.length}, ${(totalBytes / 1024).toFixed(0)} KB total)</h2>
+<table>
+<thead><tr><th>id</th><th>kind</th><th>rows</th><th>size</th><th>sha256</th></tr></thead>
+<tbody>
+${manifest.chunks.map(rowHtml).join("\n")}
+</tbody>
+</table>
+</body>
+</html>
+`;
+  const file = join(outDir, "report.html");
+  writeFileSync(file, html, "utf8");
+  return file;
+}
+function listMarkdownFiles(dir, prefix = "") {
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) out.push(...listMarkdownFiles(join(dir, entry.name), rel));
+    else if (entry.isFile() && entry.name.endsWith(".md")) out.push(rel);
+  }
+  return out.sort();
+}
+function chunkIdFor(relPath) {
+  const parts = relPath.split("/");
+  if (parts[0] !== "markdown" || parts.length < 2) return null;
+  const corpus = parts[1];
+  if (parts.length === 2) return null;
+  const slug = parts[2]?.replace(/\.md$/, "");
+  switch (corpus) {
+    case "canvas":
+    case "dashboards":
+    case "efforts":
+      return corpus;
+    case "collections":
+      return parts.length === 3 ? `collection._root` : `collection.${slug}`;
+    case "feeds":
+      return parts.length === 3 ? `feed._root` : `feed.${slug}`;
+    default:
+      return null;
+  }
+}
+function collectCorpusMarkdown(markdownDir) {
+  return listMarkdownFiles(markdownDir).map((p) => `markdown/${p}`);
+}
+function partitionIntoChunks(paths) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const id = chunkIdFor(p);
+    if (id === null) {
+      throw new Error(
+        `[generate-seed] Parity failure: '${p}' is not part of any known corpus (canvas | dashboards | efforts | collections | feeds). Extend chunkIdFor() if this is a new corpus.`
+      );
+    }
+    const list = byId.get(id);
+    if (list) list.push(p);
+    else byId.set(id, [p]);
+  }
+  return [...byId.entries()].sort(([a], [b]) => a < b ? -1 : 1).map(([id, files]) => ({ id, files }));
+}
+function validateDashboardNote(raw) {
+  const problems = [];
+  const { meta } = parseFrontmatter(raw);
+  const { sections } = parseDashboardNote(raw);
+  const doc = buildDashboardDocument(sections, meta);
+  if (!doc.isDashboard) return ["file is not a dashboard note (missing dashboard frontmatter)"];
+  if (doc.title === void 0) problems.push("dashboard has no title");
+  if (doc.widgets.length < 3) problems.push(`dashboard has only ${doc.widgets.length} widgets (the locked format has \u2265 3)`);
+  const declared = new Set(doc.tokens.map((t) => t.name));
+  for (const widget of doc.widgets) {
+    const where = `widget '${widget.title ?? widget.body.slice(0, 40)}'`;
+    if (widget.title === void 0) problems.push(`${where}: missing title`);
+    if (!isDashboardWidgetType(resolveWidgetType(widget.type))) {
+      problems.push(`${where}: unknown widget type '${widget.type}'`);
+    }
+    const parsed = parseQuery(widget.body);
+    if (parsed.error !== void 0) problems.push(`${where}: WQL parse error: ${parsed.error}`);
+    for (const ref of [
+      ...widget.body.matchAll(/\$([A-Za-z][\w-]*)/g),
+      ...Object.values(widget.attributes).flatMap((v) => [...String(v).matchAll(/\$([A-Za-z][\w-]*)/g)])
+    ]) {
+      if (!declared.has(ref[1])) problems.push(`${where}: undeclared token $${ref[1]}`);
+    }
+  }
+  return problems;
+}
+function gateDashboards(groups, corpusRoot) {
+  for (const group of groups) {
+    if (group.id !== DASHBOARDS_CHUNK_ID) continue;
+    for (const p of group.files) {
+      const problems = validateDashboardNote(readFileSync(join(corpusRoot, p), "utf8"));
+      if (problems.length > 0) {
+        throw new Error(`[generate-seed] Dashboard validation failed for '${p}':
+  - ${problems.join("\n  - ")}`);
+      }
+    }
+  }
+}
+function toSegmentDataType(section) {
+  switch (section.type) {
+    case "time":
+    case "log":
+      return "wod";
+    case "title": {
+      const l = section.level ?? 1;
+      return `h${Math.min(Math.max(l, 1), 6)}`;
+    }
+    case "frontmatter":
+      return "frontmatter";
+    case "markdown":
+    case "widget":
+    case "embed":
+    case "code":
+      return "markdown";
+    default:
+      return "markdown";
+  }
+}
+function getFileCreatedAt(file, repoRoot) {
+  try {
+    const out = execSync(`git log -1 --format=%ct -- '${file}'`, { cwd: repoRoot, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    const ts = Number(out) * 1e3;
+    return Number.isFinite(ts) && ts > 0 ? ts : 0;
+  } catch {
+    return 0;
+  }
+}
+function feedDateToCreatedAt(dateKey) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateKey)) return 0;
+  const ts = Date.parse(`${dateKey}T00:00:00Z`);
+  return Number.isNaN(ts) ? 0 : ts;
+}
+var BLOCK_INDEX_ROWS_PER_CHUNK = 4e3;
+function buildBlockIndexRows(markdownDir, corpusRoot) {
+  const index = [];
+  for (const file of listMarkdownFiles(join(markdownDir, "collections"))) {
+    const rel = `markdown/collections/${file}`;
+    const parts = rel.split("/");
+    if (parts.length < 4) continue;
+    const dirName = parts[parts.length - 2];
+    const fileNameExt = parts[parts.length - 1];
+    const isReadme = fileNameExt.toLowerCase() === "readme.md";
+    const fileName = fileNameExt.replace(/\.md$/, "");
+    const noteId = isReadme ? dirName : `${dirName}/${fileName}`;
+    const content = readFileSync(join(corpusRoot, rel), "utf8");
+    const headingMatch = isReadme ? content.match(/^#\s+(.+)$/m) : null;
+    const noteTitle = headingMatch?.[1]?.trim() || fileToDisplayName(isReadme ? dirName : fileNameExt);
+    const createdAt = getFileCreatedAt(rel, corpusRoot);
+    const sections = parseDocumentSections(content);
+    let position = 0;
+    for (const section of sections) {
+      const blockContentId = section.scriptBlock?.contentId ?? void 0;
+      index.push({
+        id: `static:${noteId}:${section.id}:1`,
+        noteId,
+        segmentId: section.id,
+        segmentVersion: 1,
+        position: position++,
+        dataType: toSegmentDataType(section),
+        blockContentId,
+        rawContent: section.displayContent,
+        noteTitle,
+        createdAt,
+        isStatic: true,
+        sourceId: isReadme ? `collection:${dirName}` : `collection:${noteId}`,
+        sourcePath: rel
+      });
+    }
+  }
+  for (const file of listMarkdownFiles(join(markdownDir, "feeds"))) {
+    const rel = `markdown/feeds/${file}`;
+    const parts = rel.split("/");
+    if (parts.length < 5) continue;
+    const dirName = parts[parts.length - 3];
+    const dateKey = parts[parts.length - 2];
+    const fileNameExt = parts[parts.length - 1];
+    if (fileNameExt.toLowerCase() === "readme.md") continue;
+    const fileName = fileNameExt.replace(/\.md$/, "");
+    const noteId = `feeds/${dirName}/${dateKey}/${fileName}`;
+    const noteTitle = fileToDisplayName(fileNameExt);
+    const content = readFileSync(join(corpusRoot, rel), "utf8");
+    const sections = parseDocumentSections(content);
+    let position = 0;
+    for (const section of sections) {
+      const blockContentId = section.scriptBlock?.contentId ?? void 0;
+      index.push({
+        id: `static:${noteId}:${section.id}:1`,
+        noteId,
+        segmentId: section.id,
+        segmentVersion: 1,
+        position: position++,
+        dataType: toSegmentDataType(section),
+        blockContentId,
+        rawContent: section.displayContent,
+        noteTitle,
+        createdAt: feedDateToCreatedAt(dateKey),
+        isStatic: true,
+        sourceId: `feed:${noteId}`,
+        sourcePath: rel
+      });
+    }
+  }
+  for (const file of listMarkdownFiles(join(markdownDir, "canvas"))) {
+    const rel = `markdown/canvas/${file}`;
+    const content = readFileSync(join(corpusRoot, rel), "utf8");
+    const noteId = canvasRouteSlug(content);
+    if (!noteId) continue;
+    const fileNameExt = file.split("/").pop() ?? file;
+    const noteTitle = fileToDisplayName(fileNameExt);
+    const createdAt = getFileCreatedAt(rel, corpusRoot);
+    const sections = parseDocumentSections(content);
+    let position = 0;
+    for (const section of sections) {
+      const blockContentId = section.scriptBlock?.contentId ?? void 0;
+      index.push({
+        id: `static:${noteId}:${section.id}:1`,
+        noteId,
+        segmentId: section.id,
+        segmentVersion: 1,
+        position: position++,
+        dataType: toSegmentDataType(section),
+        blockContentId,
+        rawContent: section.displayContent,
+        noteTitle,
+        createdAt,
+        isStatic: true,
+        sourceId: `guides:${noteId}`,
+        sourcePath: rel
+      });
+    }
+  }
+  return index;
+}
+var NON_EFFORT_SLUGS = {
+  "amrap": true,
+  "emom": true,
+  "tabata": true,
+  "for-time": true,
+  "rounds": true,
+  "sets": true,
+  "repetitions": true,
+  "count-down": true,
+  "total-reps": true,
+  "warmup": true,
+  "cooldown": true,
+  "cool-down": true,
+  "transition": true,
+  "rest": true,
+  "break": true,
+  "work": true,
+  "i-suck-at-this": true,
+  "isuckatthis": true,
+  "movement": true,
+  "movement-you": true,
+  "selected-exercise": true,
+  "training-setup": true,
+  "grade-system": true,
+  "hangs": true,
+  "warm-light-wind": true,
+  "basin": true,
+  "rock-canyon": true,
+  "b-onsight": true,
+  "a-redpoint": true,
+  "d-redpoint": true,
+  "v0-flash": true,
+  "v2-flash": true,
+  "v7-redpoint": true,
+  "avgrpe-mean": true,
+  "calculate": true,
+  "totalload-sum": true,
+  "query": true,
+  "by": true,
+  "": true,
+  "-": true,
+  "...": true,
+  "x": true,
+  "s": true,
+  "bw": true
+};
+function formatDiscoveredLabel(raw) {
+  const clean = raw.replace(/[-_]+/g, " ").trim();
+  return clean.split(/\s+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function loadExistingEffortMap(markdownDir) {
+  const slugs = /* @__PURE__ */ new Set();
+  const aliasToCanonical = /* @__PURE__ */ new Map();
+  const effortsDir = join(markdownDir, "efforts");
+  for (const file of listMarkdownFiles(effortsDir)) {
+    const raw = readFileSync(join(effortsDir, file), "utf8");
+    const parsed = parseEffortFile(raw);
+    if (!parsed) continue;
+    slugs.add(parsed.slug);
+    aliasToCanonical.set(parsed.slug, parsed.slug);
+    aliasToCanonical.set(parsed.label.toLowerCase(), parsed.slug);
+    aliasToCanonical.set(parsed.slug.replace(/-/g, " "), parsed.slug);
+    for (const alias of parsed.aliases) {
+      aliasToCanonical.set(alias.toLowerCase(), parsed.slug);
+      aliasToCanonical.set(alias.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, ""), parsed.slug);
+    }
+  }
+  return { slugs, aliasToCanonical };
+}
+function discoverUncatalogedEfforts(markdownDir, corpusRoot) {
+  const { slugs, aliasToCanonical } = loadExistingEffortMap(markdownDir);
+  const blocks = buildBlockIndexRows(markdownDir, corpusRoot);
+  const discovered = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent) continue;
+    const script = parseScript(block.rawContent);
+    for (const statement of script.statements) {
+      const effortMetric = statement.metrics?.getMetric?.("effort");
+      const effortLabel = (effortMetric && typeof effortMetric.value === "string" ? effortMetric.value : void 0) ?? statement.exerciseId;
+      if (!effortLabel) continue;
+      const slugified = effortLabel.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      if (!slugified || NON_EFFORT_SLUGS[slugified]) continue;
+      const canonical = aliasToCanonical.get(slugified) ?? aliasToCanonical.get(effortLabel.toLowerCase());
+      if (canonical && slugs.has(canonical)) continue;
+      const existing = discovered.get(slugified);
+      if (existing) {
+        existing.rawLabels.add(effortLabel);
+      } else {
+        discovered.set(slugified, {
+          label: formatDiscoveredLabel(effortLabel),
+          rawLabels: /* @__PURE__ */ new Set([effortLabel])
+        });
+      }
+    }
+  }
+  return Array.from(discovered.entries()).map(([slug, data]) => ({
+    slug,
+    label: data.label,
+    rawLabels: Array.from(data.rawLabels)
+  }));
+}
+function scaffoldDiscoveredEfforts(discovered, markdownDir) {
+  const targetDir = join(markdownDir, "efforts", "discovered");
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+  const createdPaths = [];
+  for (const effort of discovered) {
+    const filePath = join(targetDir, `${effort.slug}.md`);
+    if (existsSync(filePath)) continue;
+    const aliases = effort.rawLabels.filter((l) => l.toLowerCase() !== effort.label.toLowerCase()).map((l) => `  - "${l.replace(/"/g, '\\"')}"`);
+    const content = [
+      "---",
+      `id: effort-bundled-${effort.slug}`,
+      `slug: ${effort.slug}`,
+      `label: "${effort.label.replace(/"/g, '\\"')}"`,
+      aliases.length > 0 ? `aliases:
+${aliases.join("\n")}` : "aliases: []",
+      "baseAttributes:",
+      "  met: 5.0",
+      "  discipline: general",
+      "  intensityTier: moderate",
+      "registrySource: bundled",
+      "---",
+      ""
+    ].join("\n");
+    writeFileSync(filePath, content, "utf8");
+    createdPaths.push(filePath);
+  }
+  return createdPaths;
+}
+function buildBlockEffortRows(markdownDir, corpusRoot) {
+  const efforts = [];
+  const { aliasToCanonical } = loadExistingEffortMap(markdownDir);
+  const blocks = buildBlockIndexRows(markdownDir, corpusRoot);
+  for (const block of blocks) {
+    if (block.dataType !== "wod" || !block.rawContent) continue;
+    const script = parseScript(block.rawContent);
+    const effortSlugs = extractEffortSlugs(script.statements);
+    for (const rawSlug of effortSlugs) {
+      const norm = rawSlug.toLowerCase().trim();
+      const canonicalSlug = aliasToCanonical.get(norm) ?? aliasToCanonical.get(norm.replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "")) ?? norm.replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+      if (!canonicalSlug || NON_EFFORT_SLUGS[canonicalSlug] || NON_EFFORT_SLUGS[norm]) {
+        continue;
+      }
+      efforts.push({
+        id: `${block.id}:${canonicalSlug}`,
+        noteId: block.noteId,
+        blockId: block.segmentId,
+        blockContentId: block.blockContentId,
+        effortSlug: canonicalSlug,
+        isStatic: block.isStatic,
+        sourcePath: block.sourcePath,
+        createdAt: block.createdAt
+      });
+    }
+  }
+  return efforts;
+}
+function buildStaticParentMap(blockRows) {
+  const map = {};
+  for (const row of blockRows) {
+    if (!row.sourcePath) continue;
+    const prev = map[row.noteId];
+    if (prev && prev.sourcePath !== row.sourcePath) {
+      throw new Error(
+        `[generate-seed] ambiguous static parent '${row.noteId}' maps to both '${prev.sourcePath}' and '${row.sourcePath}'`
+      );
+    }
+    map[row.noteId] = { sourcePath: row.sourcePath, sourceId: row.sourceId };
+  }
+  return map;
+}
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function generateSeed(options = {}) {
+  const t0 = Date.now();
+  const passMs = { scan: 0, blockIndex: 0, blockEfforts: 0, write: 0 };
+  const corpusRoot = options.corpusRoot ?? process.cwd();
+  const markdownDir = options.markdownDir ?? join(corpusRoot, "markdown");
+  const outDir = options.outDir ?? join(corpusRoot, "dist");
+  const gitVersion = options.version !== void 0 ? { ...resolveGitVersion(corpusRoot), version: options.version } : resolveGitVersion(corpusRoot);
+  if (options.scaffoldDiscoveredEfforts) {
+    const discovered = discoverUncatalogedEfforts(markdownDir, corpusRoot);
+    if (discovered.length > 0) {
+      scaffoldDiscoveredEfforts(discovered, markdownDir);
+    }
+  }
+  const tScan = Date.now();
+  const paths = collectCorpusMarkdown(markdownDir);
+  const groups = partitionIntoChunks(paths);
+  gateDashboards(groups, corpusRoot);
+  if (options.templateFile && existsSync(options.templateFile)) {
+    const templateRowPath = options.templateRowPath ?? relative(corpusRoot, options.templateFile).split("\\").join("/");
+    groups.push({ id: TEMPLATE_CHUNK_ID, files: [templateRowPath] });
+  }
+  passMs.scan = Date.now() - tScan;
+  const chunksDir = join(outDir, "chunks");
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(chunksDir, { recursive: true });
+  const manifestChunks = [];
+  let totalFiles = 0;
+  const tWrite = Date.now();
+  for (const { id, files } of groups) {
+    const templateSource = id === TEMPLATE_CHUNK_ID ? options.templateFile : void 0;
+    const rows = files.map((p) => ({
+      path: p,
+      content: readFileSync(templateSource ?? join(corpusRoot, p), "utf8")
+    }));
+    const bytes = Buffer.from(JSON.stringify(rows), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    writeFileSync(join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: rows.length });
+    totalFiles += rows.length;
+  }
+  const tBlockIndex = Date.now();
+  const blockRows = buildBlockIndexRows(markdownDir, corpusRoot);
+  passMs.blockIndex = Date.now() - tBlockIndex;
+  writeFileSync(
+    join(outDir, "block-parent-map.json"),
+    JSON.stringify(buildStaticParentMap(blockRows), null, 2) + "\n"
+  );
+  for (let i = 0; blockRows.length > 0 && i * BLOCK_INDEX_ROWS_PER_CHUNK < blockRows.length; i++) {
+    const part = blockRows.slice(i * BLOCK_INDEX_ROWS_PER_CHUNK, (i + 1) * BLOCK_INDEX_ROWS_PER_CHUNK);
+    if (part.length === 0) break;
+    const id = `${BLOCK_INDEX_CHUNK_PREFIX}${i}`;
+    const bytes = Buffer.from(JSON.stringify(part), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    writeFileSync(join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: part.length, kind: "block-index" });
+  }
+  const tBlockEfforts = Date.now();
+  const effortRows = buildBlockEffortRows(markdownDir, corpusRoot);
+  passMs.blockEfforts = Date.now() - tBlockEfforts;
+  for (let i = 0; effortRows.length > 0 && i * BLOCK_INDEX_ROWS_PER_CHUNK < effortRows.length; i++) {
+    const part = effortRows.slice(i * BLOCK_INDEX_ROWS_PER_CHUNK, (i + 1) * BLOCK_INDEX_ROWS_PER_CHUNK);
+    if (part.length === 0) break;
+    const id = `${BLOCK_EFFORTS_CHUNK_PREFIX}${i}`;
+    const bytes = Buffer.from(JSON.stringify(part), "utf8");
+    const sha = sha256Hex(bytes);
+    const file = `chunks/${id}.${sha.slice(0, 8)}.json`;
+    writeFileSync(join(outDir, file), bytes);
+    manifestChunks.push({ id, path: file, sha256: sha, bytes: bytes.length, count: part.length, kind: "block-efforts" });
+  }
+  passMs.write = Date.now() - tWrite;
+  const manifest = {
+    schema: SEED_SCHEMA,
+    version: gitVersion.version,
+    versionLabel: gitVersion.versionLabel,
+    commit: gitVersion.commit,
+    dirty: gitVersion.dirty,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks: manifestChunks
+  };
+  writeFileSync(join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2) + "\n");
+  const reportPath = writeBuildReport(outDir, {
+    manifest,
+    totalMs: Date.now() - t0,
+    passMs,
+    fileCount: paths.length});
+  return { manifest, outDir, totalFiles, reportPath, passMs };
+}
+
+export { buildBlockEffortRows, buildBlockIndexRows, buildStaticParentMap, chunkIdFor, collectCorpusMarkdown, discoverUncatalogedEfforts, feedDateToCreatedAt, generateSeed, loadExistingEffortMap, partitionIntoChunks, scaffoldDiscoveredEfforts, validateDashboardNote };
+//# sourceMappingURL=compiler-KTBR6OEL.mjs.map
+//# sourceMappingURL=compiler-KTBR6OEL.mjs.map