@m0saic/templates 0.2.0

package/dist/gen-template-audit.js

@@ -0,0 +1,379 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Generate TEMPLATE-AUDIT.md — the positioning audit for the template shelf.
+ *
+ * Usage:  node dist/gen-template-audit.js
+ *
+ * A template is a function `(props, canvas) → m0`. You can't know its output
+ * statically, but you can PROBE it: render `defaultProps` across a grid of
+ * canvases (portrait / square / desktop × 240p → 4K) and watch how
+ * `computeFeasibility` (min-feasible px) and `precision` (max split count per
+ * axis) respond.
+ *
+ *   - precision that TRACKS the canvas (slope ≈ 1) ⇒ ABSOLUTE positioning
+ *     (per-pixel basis, e.g. placeRects). Fine for a head/hero — it knows its
+ *     canvas — but it does NOT nest: it eats whatever cell it's given and hits
+ *     the feasibility wall.
+ *   - precision that STAYS STABLE across canvases ⇒ RATIO positioning (weighted
+ *     splits). Composes cleanly.
+ *
+ * A template marked `primitive` (meant to nest) that probes ABSOLUTE is a
+ * composability warning (`PRIMITIVE_ABSOLUTE_POSITIONING`).
+ *
+ * The desktop-1080p probe also reads the template's LATTICE: its split counts
+ * and their LCM per axis (`latticeReport`, @m0saic/template-utils). A split
+ * count above 12 with a prime factor outside {2, 3, 5} is a composability
+ * warning (`LATTICE_NOT_SMOOTH`) — the same fact the build gate's
+ * `latticeSmooth` convention reports; here it is a column. See
+ * the internal template-positioning-audit notes +
+ * the internal ratio-vs-absolute-m0-drafting notes.
+ *
+ * Deterministic: renders `defaultProps` (no wall-clock/random), so the output
+ * is reproducible across builds.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const dsl_1 = require("@m0saic/dsl");
+const platform_1 = require("@m0saic/platform");
+const template_utils_1 = require("@m0saic/template-utils");
+require("./m0saic"); // side-effect: register every template
+const ROOT = path.resolve(__dirname, "..");
+const OUT = path.join(ROOT, "TEMPLATE-AUDIT.md");
+// Probe grid: three aspects (portrait constrains width, desktop constrains
+// height, square is neutral) × a resolution sweep from 240p to 4K.
+const ASPECTS = [
+    { name: "square", ratio: 1 },
+    { name: "portrait", ratio: 9 / 16 },
+    { name: "desktop", ratio: 16 / 9 },
+];
+const HEIGHTS = [240, 540, 1080, 2160];
+/** Max |slope| of precision-vs-canvas before we call it absolute. */
+const ABSOLUTE_SLOPE = 0.3;
+/** Skip the full probe above this default-props frame count (bitmap/sloth). */
+const HEAVY_FRAMES = 4000;
+/**
+ * Only `capabilities.tier === "core"` templates are probed. **Capability-tier
+ * templates are skipped by default** — they may hit APIs / do side effects
+ * (fetchers, post-render wrappers, workload runners), which `render()`-probing
+ * would trigger. On top of that, a few CORE templates are still unsafe to probe
+ * — intrinsically heavy (bitmap rasters, atlas bakes) or media-source-dependent
+ * (video probing) — and are skipped by id substring below.
+ */
+const SKIP_SUBSTRINGS = [
+    "benchmark/", //         benchmark/report renders a heavy dashboard
+    "media/video_to_png", "media/screencap", // probe/strip source video (need ctx.media)
+    "brand/logo", //         bitmap raster (heavy m0)
+    "/scatter-bake/", //     225-source atlas bake
+];
+/** The canvas whose probe feeds the lattice column — the modern core's landscape member. */
+const LATTICE_PROBE = { aspect: "desktop", h: 1080 };
+/** `X=120 · Y=30` (an LCM past 1e15 prints as ∞). */
+function fmtLattice(r) {
+    const n = (v) => (Number.isFinite(v) ? v.toLocaleString("en-US") : "∞");
+    return `X=${n(r.selfLattice.x)} · Y=${n(r.selfLattice.y)}`;
+}
+function ctxFor(w, h) {
+    const t = { width: w, height: h, fps: 30, durationMs: 2000 };
+    return { mode: "render", target: t, output: { ...t, workspaceDir: "/tmp/tpl-audit" }, media: {} };
+}
+/**
+ * Render defaultProps at (w,h) and return the m0 that actually describes the
+ * spatial layout. Flat leaf → `doc.m0`; nested → the FLATTENED m0 (the trivial
+ * top-level m0 of a composite hides its children's positioning). A flatten that
+ * fails (`SPLIT_EXCEEDS_AXIS`) is itself an absolute/infeasible signal.
+ */
+async function m0For(tpl, w, h) {
+    var _a;
+    const doc = await tpl.render({ ...((_a = tpl.defaultProps) !== null && _a !== void 0 ? _a : {}) }, ctxFor(w, h));
+    if (!doc || doc.kind !== "mosaic_document")
+        return null;
+    const mdoc = doc;
+    const nested = !!(mdoc.children && Object.keys(mdoc.children).length > 0);
+    if (!nested)
+        return { m0: String(mdoc.m0), nested: false };
+    const flat = (0, platform_1.flattenMosaicDocument)({ file: mdoc, width: w, height: h, resolveRef: () => null });
+    if (!flat.ok)
+        return "flatten-fail";
+    return { m0: String(flat.file.m0), nested: true };
+}
+/** Least-squares slope of y over x. */
+function slope(xs, ys) {
+    const n = xs.length;
+    if (n < 2)
+        return 0;
+    const sx = xs.reduce((a, b) => a + b, 0);
+    const sy = ys.reduce((a, b) => a + b, 0);
+    const sxx = xs.reduce((a, b) => a + b * b, 0);
+    const sxy = xs.reduce((a, b, i) => a + b * ys[i], 0);
+    const d = n * sxx - sx * sx;
+    return d === 0 ? 0 : (n * sxy - sx * sy) / d;
+}
+async function probe(id) {
+    var _a, _b, _c, _d;
+    const tpl = (0, template_utils_1.getTemplate)(id);
+    const primitive = !!(tpl === null || tpl === void 0 ? void 0 : tpl.primitive);
+    const role = primitive ? "primitive" : ((_b = (_a = tpl === null || tpl === void 0 ? void 0 : tpl.capabilities) === null || _a === void 0 ? void 0 : _a.tier) !== null && _b !== void 0 ? _b : "");
+    const base = { id, role, primitive, status: "ok", warnings: [] };
+    if (!tpl)
+        return { ...base, status: "render-failed", note: "not registered" };
+    // Heavy guard — render once small and weigh; skip the sweep if it's a bitmap.
+    try {
+        const first = await m0For(tpl, 240, 240);
+        if (first && first !== "flatten-fail") {
+            const fc = (0, dsl_1.getComplexityMetricsFast)(first.m0).frameCount;
+            if (fc > HEAVY_FRAMES)
+                return { ...base, status: "heavy", note: `${fc.toLocaleString()} frames at 240p` };
+        }
+    }
+    catch (e) {
+        return { ...base, status: "render-failed", note: String((_c = e === null || e === void 0 ? void 0 : e.message) !== null && _c !== void 0 ? _c : e).slice(0, 90) };
+    }
+    const byAspect = {};
+    let nested = false;
+    let flattenFails = 0;
+    let total = 0;
+    let latticeAt;
+    for (const a of ASPECTS) {
+        byAspect[a.name] = [];
+        for (const h of HEIGHTS) {
+            const w = Math.max(1, Math.round(h * a.ratio));
+            try {
+                const r = await m0For(tpl, w, h);
+                if (r === "flatten-fail") {
+                    flattenFails++;
+                    continue;
+                }
+                if (!r)
+                    continue;
+                nested = nested || r.nested;
+                if (a.name === LATTICE_PROBE.aspect && h === LATTICE_PROBE.h) {
+                    const decl = tpl.lattice;
+                    const report = (0, template_utils_1.latticeReport)([r.m0], { allow: ((_d = decl === null || decl === void 0 ? void 0 : decl.allow) !== null && _d !== void 0 ? _d : []).map((x) => x.count) });
+                    latticeAt = { report, bitmap: (decl === null || decl === void 0 ? void 0 : decl.mode) === "bitmap", canvas: `${w}×${h}` };
+                }
+                const f = (0, dsl_1.computeFeasibility)(r.m0);
+                const p = (0, dsl_1.getComplexityMetricsFast)(r.m0).precision;
+                byAspect[a.name].push({ aspect: a.name, w, h, pX: p.maxSplitX, pY: p.maxSplitY, mW: f.minWidthPx, mH: f.minHeightPx });
+                total++;
+            }
+            catch {
+                /* skip a bad canvas */
+            }
+        }
+    }
+    if (total < 3 && flattenFails === 0)
+        return { ...base, status: "empty", note: "no probeable canvases" };
+    let maxSlope = 0;
+    for (const rows of Object.values(byAspect)) {
+        if (rows.length < 3)
+            continue;
+        maxSlope = Math.max(maxSlope, Math.abs(slope(rows.map((r) => r.h), rows.map((r) => r.pY))), Math.abs(slope(rows.map((r) => r.w), rows.map((r) => r.pX))));
+    }
+    // Frequent flatten failures across the sweep are a strong absolute/infeasible signal.
+    const verdict = maxSlope > ABSOLUTE_SLOPE || flattenFails >= HEIGHTS.length ? "absolute" : "ratio";
+    const warnings = [];
+    if (primitive && verdict === "absolute") {
+        warnings.push(`PRIMITIVE_ABSOLUTE_POSITIONING — precision scales with the canvas (slope ${maxSlope.toFixed(2)}` +
+            `${flattenFails ? `, ${flattenFails} flatten-fails` : ""}). Marked a primitive but won't compose: it eats its cell and hits the feasibility wall when nested. Fix by returning a ratio m0 (not placeRects).`);
+    }
+    if (latticeAt && !latticeAt.bitmap && latticeAt.report.offenders.length > 0) {
+        const offenders = latticeAt.report.offenders;
+        const list = offenders.map((c) => `${c.n} (${c.factors})`).join(", ");
+        warnings.push(`LATTICE_NOT_SMOOTH — split count${offenders.length > 1 ? "s" : ""} ${list} at ${latticeAt.canvas} ` +
+            `carry a prime factor outside {2, 3, 5}; composing this template costs the LCM (self-lattice ${fmtLattice(latticeAt.report)}). ` +
+            `Cap weighted bands with weightedSplit(…, { precision: 120 }) or place rects with placeInsetPieces — never per-weight rounding to a cap (the 119/121 fencepost).`);
+    }
+    return { ...base, verdict, maxSlope, nested, flattenFails, byAspect, lattice: latticeAt, warnings };
+}
+/** Smallest canvas at which NEITHER precision nor feasibility bites, per axis:
+ *  max(precisionX, feasW) × max(precisionY, feasH). The one number to glance at. */
+function safeW(r) {
+    return Math.max(r.pX, r.mW);
+}
+function safeH(r) {
+    return Math.max(r.pY, r.mH);
+}
+/** Aspect × resolution table with a per-Row cell formatter. Header row = the
+ *  probed heights; rows = aspects. Missing samples render as `—`. */
+function fmtGrid(byAspect, cell) {
+    var _a;
+    const lines = [];
+    lines.push(`| aspect | ${HEIGHTS.map((h) => `${h}p`).join(" | ")} |`);
+    lines.push(`|---|${HEIGHTS.map(() => "---:").join("|")}|`);
+    for (const a of ASPECTS) {
+        const byH = new Map(((_a = byAspect[a.name]) !== null && _a !== void 0 ? _a : []).map((r) => [r.h, r]));
+        const cells = HEIGHTS.map((h) => {
+            const r = byH.get(h);
+            return r ? cell(r) : "—";
+        });
+        lines.push(`| ${a.name} | ${cells.join(" | ")} |`);
+    }
+    return lines;
+}
+function renderMd(results) {
+    var _a, _b, _c;
+    const warned = results.filter((r) => r.warnings.length > 0);
+    const skipped = results.filter((r) => r.status !== "ok");
+    const out = [];
+    out.push("# Template positioning audit");
+    out.push("");
+    out.push("> Auto-generated by `gen-template-audit` (do NOT edit by hand). Probes each " +
+        "**core-tier** template's `defaultProps` across canvases (portrait / square / desktop × " +
+        "240p→4K) — capability-tier templates are skipped (they may hit APIs / do side effects). " +
+        "Precision that **scales with the canvas** ⇒ **absolute** positioning (won't nest); " +
+        "**stable** ⇒ **ratio** (composes). A `primitive` that probes absolute is a warning. " +
+        "The **lattice** line is the split-count census at the desktop 1080p probe: the LCM of the counts per axis, the largest count, " +
+        "and any count above 12 with a prime factor outside {2, 3, 5} (`LATTICE_NOT_SMOOTH` — the build gate's `latticeSmooth` convention). " +
+        "See the internal template-positioning-audit notes and the handbook's `composition-arithmetic.md`.");
+    out.push("");
+    // ── ToC: warnings first ──
+    out.push(`## ⚠ Warnings (${warned.length})`);
+    out.push("");
+    if (warned.length === 0) {
+        out.push("_None._");
+    }
+    else {
+        out.push("| template | role | warning |");
+        out.push("|---|---|---|");
+        for (const r of warned) {
+            for (const w of r.warnings) {
+                const code = w.split(" — ")[0];
+                const extra = code === "PRIMITIVE_ABSOLUTE_POSITIONING" ? ` (slope ${(_a = r.maxSlope) === null || _a === void 0 ? void 0 : _a.toFixed(2)})` : r.lattice ? ` (${fmtLattice(r.lattice.report)})` : "";
+                out.push(`| [\`${r.id}\`](#${anchor(r.id)}) | ${r.role} | ${code}${extra} |`);
+            }
+        }
+    }
+    out.push("");
+    // ── Skipped ──
+    if (skipped.length > 0) {
+        out.push(`## Not probed (${skipped.length})`);
+        out.push("");
+        out.push("| template | reason |");
+        out.push("|---|---|");
+        for (const r of skipped)
+            out.push(`| \`${r.id}\` | ${r.status}${r.note ? ` — ${r.note}` : ""} |`);
+        out.push("");
+    }
+    // ── Summary counts ──
+    const ok = results.filter((r) => r.status === "ok");
+    const abs = ok.filter((r) => r.verdict === "absolute");
+    const ratio = ok.filter((r) => r.verdict === "ratio");
+    const measured = ok.filter((r) => r.lattice && !r.lattice.bitmap);
+    const onLattice = measured.filter((r) => r.lattice.report.offenders.length === 0);
+    out.push(`**${ok.length} probed** · ${ratio.length} ratio · ${abs.length} absolute · ${warned.length} warnings · ${skipped.length} skipped · ` +
+        `lattice: ${onLattice.length}/${measured.length} on the 5-smooth lattice (${ok.length - measured.length} bitmap-declared or not probed at 1080p).`);
+    out.push("");
+    // ── Per-template, by slug ──
+    out.push("## All templates (by slug)");
+    out.push("");
+    for (const r of results) {
+        out.push(`### ${r.id}`);
+        out.push("");
+        if (r.status !== "ok") {
+            out.push(`- **${r.status}**${r.note ? ` — ${r.note}` : ""}`);
+            out.push("");
+            continue;
+        }
+        const verdictBadge = r.verdict === "absolute" ? "**ABSOLUTE**" : "ratio";
+        out.push(`- role: \`${r.role}\` · verdict: ${verdictBadge} · max precision slope ${(_b = r.maxSlope) === null || _b === void 0 ? void 0 : _b.toFixed(2)}` +
+            `${r.nested ? " · nested (flattened to probe)" : ""}` +
+            `${r.flattenFails ? ` · ${r.flattenFails} flatten-fails` : ""}`);
+        if (r.lattice) {
+            const rep = r.lattice.report;
+            const verdict = r.lattice.bitmap
+                ? "bitmap (declared `lattice.mode`; not held to the lattice)"
+                : rep.offenders.length === 0
+                    ? `5-smooth ✓${rep.allowed.length ? ` (allowed content counts ${rep.allowed.map((c) => c.n).join(", ")})` : ""}`
+                    : `✗ ${rep.offenders.map((c) => `${c.n} (${c.factors})`).join(", ")}`;
+            out.push(`- lattice @${r.lattice.canvas}: ${fmtLattice(rep)} · max N ${rep.maxN} · ${verdict}`);
+        }
+        for (const w of r.warnings)
+            out.push(`- ⚠ ${w}`);
+        const byAspect = (_c = r.byAspect) !== null && _c !== void 0 ? _c : {};
+        out.push("");
+        out.push("**Safe canvas** — smallest w×h where neither precision nor feasibility bites:");
+        out.push("");
+        out.push(...fmtGrid(byAspect, (row) => `${safeW(row)}×${safeH(row)}`));
+        out.push("");
+        out.push("_A safe canvas that climbs across a row scales with the canvas ⇒ absolute; one that stays flat ⇒ ratio._");
+        out.push("");
+        out.push("<details><summary>precision · feasibility breakdown</summary>");
+        out.push("");
+        out.push(...fmtGrid(byAspect, (row) => `${row.pX}×${row.pY} · ${row.mW}×${row.mH}`));
+        out.push("");
+        out.push("_Cell = precision (maxSplitX×maxSplitY) · min-feasibility (px). Safe canvas above = the per-axis max of the two. Usually precision > feasibility, but not always._");
+        out.push("");
+        out.push("</details>");
+        out.push("");
+    }
+    return out.join("\n") + "\n";
+}
+function anchor(id) {
+    return id.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+async function main() {
+    var _a, _b;
+    const ids = (0, template_utils_1.listRegisteredTemplateIds)()
+        .map(String)
+        .filter((id) => { var _a; return !((_a = (0, template_utils_1.getTemplate)(id)) === null || _a === void 0 ? void 0 : _a.deprecated); })
+        .sort();
+    const results = [];
+    for (const id of ids) {
+        const t = (0, template_utils_1.getTemplate)(id);
+        const tier = (_b = (_a = t === null || t === void 0 ? void 0 : t.capabilities) === null || _a === void 0 ? void 0 : _a.tier) !== null && _b !== void 0 ? _b : "(none)";
+        const meta = { id, role: (t === null || t === void 0 ? void 0 : t.primitive) ? "primitive" : tier, primitive: !!(t === null || t === void 0 ? void 0 : t.primitive), warnings: [] };
+        // Only probe core templates — capability-tier may hit APIs / do side effects.
+        if (tier !== "core") {
+            results.push({ ...meta, status: "skipped", note: `${tier} tier (not core — may hit APIs / side effects)` });
+            continue;
+        }
+        const skip = SKIP_SUBSTRINGS.find((s) => id.includes(s));
+        if (skip) {
+            results.push({ ...meta, status: "skipped", note: `core, but skip-list (${skip})` });
+            continue;
+        }
+        process.stderr.write(`[template-audit] probing ${id} …\n`);
+        results.push(await probe(id));
+    }
+    fs.writeFileSync(OUT, renderMd(results));
+    const warned = results.filter((r) => r.warnings.length > 0);
+    for (const r of warned)
+        for (const w of r.warnings)
+            console.warn(`[template-audit] ⚠ ${r.id}: ${w.split(" — ")[0]}`);
+    console.log(`[template-audit] wrote ${path.relative(ROOT, OUT)} — ${results.length} templates, ${warned.length} with warnings`);
+}
+void main();

package/dist/gen-template-manifest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gen-template-manifest.js

@@ -0,0 +1,162 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Generate template-manifest.json from the authoring registry.
+ *
+ * Usage:  node dist/gen-template-manifest.js
+ *
+ * This script reads the compiled template-registry, validates entries,
+ * discovers preview assets via convention, and writes the manifest to
+ * the package root.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const types_1 = require("@m0saic/types");
+const platform_1 = require("@m0saic/platform");
+const template_registry_1 = require("./template-registry");
+const repo_1 = require("./repo");
+const ROOT = path.resolve(__dirname, "..");
+const TEMPLATES_DIR = "assets/templates";
+const ENTRY_MODULE = "./dist/index.js";
+/* ── Helpers ─────────────────────────────────────────────── */
+function encodeTemplateKey(templateKey) {
+    return templateKey.replace(/\//g, "__");
+}
+function absFromRepo(relPath) {
+    return path.join(ROOT, relPath);
+}
+function existsRepoRel(relPath) {
+    return fs.existsSync(absFromRepo(relPath));
+}
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function ensurePreviewPathsExist(preview, templateKey) {
+    if (!preview)
+        return;
+    const check = (p, field) => {
+        if (!p)
+            return;
+        assert(existsRepoRel(p), `Template "${templateKey}" preview.${field} points to missing file: "${p}"`);
+    };
+    check(preview.image, "image");
+    check(preview.video, "video");
+    check(preview.poster, "poster");
+}
+function buildPreviewFromConvention(templateKey) {
+    const encoded = encodeTemplateKey(templateKey);
+    const baseDir = `${TEMPLATES_DIR}/${encoded}`;
+    const image = `${baseDir}/preview.png`;
+    const video = `${baseDir}/preview.mp4`;
+    const poster = `${baseDir}/poster.png`;
+    const preview = {};
+    if (existsRepoRel(image))
+        preview.image = image;
+    if (existsRepoRel(video))
+        preview.video = video;
+    if (existsRepoRel(poster))
+        preview.poster = poster;
+    return preview.image || preview.video || preview.poster ? preview : undefined;
+}
+function mergePreview(explicit, fallback) {
+    var _a, _b, _c;
+    if (!explicit && !fallback)
+        return undefined;
+    const merged = {
+        image: (_a = explicit === null || explicit === void 0 ? void 0 : explicit.image) !== null && _a !== void 0 ? _a : fallback === null || fallback === void 0 ? void 0 : fallback.image,
+        video: (_b = explicit === null || explicit === void 0 ? void 0 : explicit.video) !== null && _b !== void 0 ? _b : fallback === null || fallback === void 0 ? void 0 : fallback.video,
+        poster: (_c = explicit === null || explicit === void 0 ? void 0 : explicit.poster) !== null && _c !== void 0 ? _c : fallback === null || fallback === void 0 ? void 0 : fallback.poster,
+    };
+    return merged.image || merged.video || merged.poster ? merged : undefined;
+}
+/* ── Validate ────────────────────────────────────────────── */
+// Slugs are unique PER PACK, not globally — the npm-scope model where a pack
+// namespaces its slugs. So `@m0saic/charts/bar-graph` and `@m0saic/alpine/bar-graph`
+// coexist (same bare slug, different pack). The fully-qualified templateId stays
+// globally unique (separate check below).
+const seenSlugKeys = new Set();
+const seenTemplateIds = new Set();
+const seenExports = new Set();
+for (const entry of template_registry_1.templateRegistry) {
+    assert(entry.slug, `Entry missing slug (exportName=${entry.exportName})`);
+    assert(entry.templateId, `Entry "${entry.slug}" missing templateId`);
+    const pack = (0, platform_1.parseTemplateId)(entry.templateId).pack;
+    const slugKey = pack ? `${pack}/${entry.slug}` : entry.slug;
+    assert(!seenSlugKeys.has(slugKey), `Duplicate pack-scoped slug: "${slugKey}"`);
+    seenSlugKeys.add(slugKey);
+    assert(!seenTemplateIds.has(entry.templateId), `Duplicate templateId: "${entry.templateId}"`);
+    seenTemplateIds.add(entry.templateId);
+    assert(entry.exportName, `Entry "${entry.slug}" missing exportName`);
+    assert(!seenExports.has(entry.exportName), `Duplicate exportName: "${entry.exportName}"`);
+    seenExports.add(entry.exportName);
+}
+/* ── Build manifest ──────────────────────────────────────── */
+const templates = template_registry_1.templateRegistry.map((entry) => {
+    const templateKey = entry.templateId;
+    // Validate explicit preview paths if provided
+    ensurePreviewPathsExist(entry.preview, templateKey);
+    // Merge explicit preview with convention-based discovery
+    const preview = mergePreview(entry.preview, buildPreviewFromConvention(templateKey));
+    // If a video preview exists but no poster is provided,
+    // use the video itself as the poster fallback.
+    if ((preview === null || preview === void 0 ? void 0 : preview.video) && !preview.poster) {
+        preview.poster = preview.video;
+    }
+    const pack = (0, platform_1.parseTemplateId)(templateKey).pack;
+    return {
+        slug: entry.slug,
+        templateKey: (0, types_1.asTemplateId)(templateKey),
+        title: entry.title,
+        description: entry.description,
+        tags: entry.tags,
+        ...(pack ? { pack } : {}),
+        ...(entry.author ? { author: entry.author } : {}),
+        preview,
+    };
+});
+const manifest = {
+    schemaVersion: 1,
+    repo: repo_1.TEMPLATE_REPO,
+    entryModule: ENTRY_MODULE,
+    templates,
+    ...(repo_1.TEMPLATE_PACKS.length ? { packs: repo_1.TEMPLATE_PACKS } : {}),
+};
+const outPath = path.join(ROOT, "template-manifest.json");
+fs.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+const previewCount = templates.filter((t) => t.preview).length;
+console.log(`[gen-template-manifest] wrote ${path.relative(ROOT, outPath)} ` +
+    `(${templates.length} templates, ${previewCount} with preview assets)`);

package/dist/gen-web-template-ids.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gen-web-template-ids.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Generate web-template-ids.json — the template ids the BROWSER entry registers.
+ *
+ * Usage:  node dist/gen-web-template-ids.js   (a FRESH process — see below)
+ *
+ * The browser entry (`./web`) registers the curated node-clean subset of the
+ * library, and that subset is exactly what Mosaic Web can open: the web
+ * receiver of a `/make?t=…` link classifies by membership in its registry
+ * listing. The registry is process-global, so the only faithful way to read
+ * "what web registers" is to import `./web` in a process that has NOT loaded
+ * the node entry — this script, run on its own by the package build.
+ *
+ * Consumers read the file through `isWebTemplateId` / `listWebTemplateIds`
+ * (`./webTemplateIds`) — the CLI uses it to decide whether the Mosaic Web
+ * customize link is worth printing after a render.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const web_1 = require("./web");
+const webTemplateIds_1 = require("./webTemplateIds");
+const ROOT = path.resolve(__dirname, "..");
+const ids = (0, web_1.listRegisteredTemplateIds)()
+    .map(String)
+    .sort();
+if (ids.length === 0) {
+    throw new Error("gen-web-template-ids: the browser entry registered no templates");
+}
+const outPath = path.join(ROOT, webTemplateIds_1.WEB_TEMPLATE_IDS_FILE);
+fs.writeFileSync(outPath, JSON.stringify({ schemaVersion: 1, entryModule: "./dist/web.js", ids }, null, 2) + "\n", "utf8");
+console.log(`Wrote ${outPath} (${ids.length} template ids)`);