@m0saic/templates 0.2.0

package/dist/m0saic/wireframe/index.d.ts

@@ -0,0 +1,4 @@
+export { WireframeCell } from "./utils/wireframeCell";
+export { WireframeV2 } from "./base/v2";
+export { Wireframe, Wireframe as WireframeV1 } from "./base/v1";
+export { AnimatedWireframe } from "./animated/v1";

package/dist/m0saic/wireframe/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimatedWireframe = exports.WireframeV1 = exports.Wireframe = exports.WireframeV2 = exports.WireframeCell = void 0;
+var wireframeCell_1 = require("./utils/wireframeCell");
+Object.defineProperty(exports, "WireframeCell", { enumerable: true, get: function () { return wireframeCell_1.WireframeCell; } });
+// v2 is the current default (single-pass: each frame is one masked color tile,
+// text + border as glyph outlines). v1 is kept, deprecated, as the nested-cell
+// baseline — useful for perf comparison and as living documentation of how the
+// template evolved as we learned more about the engine.
+var v2_1 = require("./base/v2");
+Object.defineProperty(exports, "WireframeV2", { enumerable: true, get: function () { return v2_1.WireframeV2; } });
+var v1_1 = require("./base/v1");
+Object.defineProperty(exports, "Wireframe", { enumerable: true, get: function () { return v1_1.Wireframe; } });
+Object.defineProperty(exports, "WireframeV1", { enumerable: true, get: function () { return v1_1.Wireframe; } });
+var v1_2 = require("./animated/v1");
+Object.defineProperty(exports, "AnimatedWireframe", { enumerable: true, get: function () { return v1_2.AnimatedWireframe; } });

package/dist/m0saic/wireframe/utils/paperGrid.d.ts

@@ -0,0 +1,53 @@
+import type { MosaicColor, MosaicLavfiSource } from "@m0saic/types";
+/**
+ * Paper-grid lattice for the wireframe family (the `grid-paper` preset /
+ * `theme.paperGrid` knob).
+ *
+ * Until gate 29 the preset resolved `paperGrid: {enabled, stepFrac, alpha}`
+ * and NOTHING drew it — the Layout page sold it as "Textbook — hand-drawn
+ * paper grid" while it rendered as plain thumb-light. Audit-every-knob: a
+ * knob that exists must be wired. The lattice is ONE extra source — a flat
+ * ink tile masked to thin vertical + horizontal lines at the requested pitch,
+ * blended at the requested alpha — appended as a full-canvas TOP overlay so
+ * the graph-paper reads over the (opaque, rounded) thumb tiles. Interior
+ * lines only: the canvas edge is the frame, not a rule.
+ */
+/** Default pitch as a fraction of the canvas's shorter side (16 rows @ 1080). */
+export declare const PAPER_GRID_STEP_FRAC = 0.0625;
+/** Default lattice ink alpha (matches the `grid-paper` preset). */
+export declare const PAPER_GRID_ALPHA = 0.08;
+/**
+ * SVG path of the lattice in a `w`×`h` box: interior rules every `stepPx`,
+ * each `linePx` wide, as closed rects (non-zero fill; crossings simply
+ * overlap). Deterministic, integer-snapped.
+ */
+export declare function paperGridPath(w: number, h: number, stepPx: number, linePx: number): string;
+/**
+ * Append a full-canvas top overlay leaf to an m0 string: `X` → `X{1}`.
+ *
+ * A root that already carries an overlay (`A{B}`) cannot take a second one
+ * (`A{B}{1}` is an OVERLAY_CHAIN error), so the leaf is nested into the
+ * innermost root-overlay content instead: `A{B}` → `A{B{1}}`, `A{B{C}}` →
+ * `A{B{C{1}}}`. Every overlay content is itself a valid root form (primitive
+ * or split) spanning the parent rect, so the appended leaf always covers the
+ * whole canvas and always paints LAST (document order = paint order).
+ *
+ * Input must be canonical-or-pretty m0 with no whitespace (what the props
+ * schema validates); the caller re-validates via `toM0String`.
+ */
+export declare function appendTopOverlay(m0: string, leaf?: string): string;
+/**
+ * The lattice source: a flat `ink` tile masked to {@link paperGridPath},
+ * blended at `alpha` via `overlay.alpha` (makeColorTile honours only
+ * overlay / mask / placement / effects — opacity must ride the overlay).
+ * `bounds` = the canvas, so the mask scales 1:1 when the leaf is the
+ * full-canvas top overlay from {@link appendTopOverlay}.
+ */
+export declare function makePaperGridSource(opts: {
+    width: number;
+    height: number;
+    ink: MosaicColor;
+    stepFrac?: number;
+    alpha?: number;
+    linePx?: number;
+}): MosaicLavfiSource;

package/dist/m0saic/wireframe/utils/paperGrid.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAPER_GRID_ALPHA = exports.PAPER_GRID_STEP_FRAC = void 0;
+exports.paperGridPath = paperGridPath;
+exports.appendTopOverlay = appendTopOverlay;
+exports.makePaperGridSource = makePaperGridSource;
+const template_utils_1 = require("@m0saic/template-utils");
+/**
+ * Paper-grid lattice for the wireframe family (the `grid-paper` preset /
+ * `theme.paperGrid` knob).
+ *
+ * Until gate 29 the preset resolved `paperGrid: {enabled, stepFrac, alpha}`
+ * and NOTHING drew it — the Layout page sold it as "Textbook — hand-drawn
+ * paper grid" while it rendered as plain thumb-light. Audit-every-knob: a
+ * knob that exists must be wired. The lattice is ONE extra source — a flat
+ * ink tile masked to thin vertical + horizontal lines at the requested pitch,
+ * blended at the requested alpha — appended as a full-canvas TOP overlay so
+ * the graph-paper reads over the (opaque, rounded) thumb tiles. Interior
+ * lines only: the canvas edge is the frame, not a rule.
+ */
+/** Default pitch as a fraction of the canvas's shorter side (16 rows @ 1080). */
+exports.PAPER_GRID_STEP_FRAC = 0.0625;
+/** Default lattice ink alpha (matches the `grid-paper` preset). */
+exports.PAPER_GRID_ALPHA = 0.08;
+/** Smallest pitch we draw — below this the lattice is noise, not paper. */
+const MIN_STEP_PX = 8;
+/**
+ * SVG path of the lattice in a `w`×`h` box: interior rules every `stepPx`,
+ * each `linePx` wide, as closed rects (non-zero fill; crossings simply
+ * overlap). Deterministic, integer-snapped.
+ */
+function paperGridPath(w, h, stepPx, linePx) {
+    const t = Math.max(1, Math.round(linePx));
+    const step = Math.max(MIN_STEP_PX, Math.round(stepPx));
+    const half = t / 2;
+    const parts = [];
+    for (let x = step; x < w - half; x += step) {
+        const x0 = Math.round(x - half);
+        parts.push(`M${x0} 0 h${t} v${h} h-${t} Z`);
+    }
+    for (let y = step; y < h - half; y += step) {
+        const y0 = Math.round(y - half);
+        parts.push(`M0 ${y0} h${w} v${t} h-${w} Z`);
+    }
+    return parts.join(" ");
+}
+/**
+ * Append a full-canvas top overlay leaf to an m0 string: `X` → `X{1}`.
+ *
+ * A root that already carries an overlay (`A{B}`) cannot take a second one
+ * (`A{B}{1}` is an OVERLAY_CHAIN error), so the leaf is nested into the
+ * innermost root-overlay content instead: `A{B}` → `A{B{1}}`, `A{B{C}}` →
+ * `A{B{C{1}}}`. Every overlay content is itself a valid root form (primitive
+ * or split) spanning the parent rect, so the appended leaf always covers the
+ * whole canvas and always paints LAST (document order = paint order).
+ *
+ * Input must be canonical-or-pretty m0 with no whitespace (what the props
+ * schema validates); the caller re-validates via `toM0String`.
+ */
+function appendTopOverlay(m0, leaf = "1") {
+    let k = 0;
+    while (k < m0.length && m0[m0.length - 1 - k] === "}")
+        k++;
+    const head = m0.slice(0, m0.length - k);
+    return `${head}{${leaf}}${"}".repeat(k)}`;
+}
+/**
+ * The lattice source: a flat `ink` tile masked to {@link paperGridPath},
+ * blended at `alpha` via `overlay.alpha` (makeColorTile honours only
+ * overlay / mask / placement / effects — opacity must ride the overlay).
+ * `bounds` = the canvas, so the mask scales 1:1 when the leaf is the
+ * full-canvas top overlay from {@link appendTopOverlay}.
+ */
+function makePaperGridSource(opts) {
+    var _a, _b, _c;
+    const w = Math.max(1, Math.round(opts.width));
+    const h = Math.max(1, Math.round(opts.height));
+    const minSide = Math.min(w, h);
+    const stepFrac = (_a = opts.stepFrac) !== null && _a !== void 0 ? _a : exports.PAPER_GRID_STEP_FRAC;
+    const stepPx = Math.max(MIN_STEP_PX, Math.round(minSide * stepFrac));
+    const linePx = (_b = opts.linePx) !== null && _b !== void 0 ? _b : Math.max(1, Math.round(minSide * 0.001));
+    const alpha = Math.max(0, Math.min(1, (_c = opts.alpha) !== null && _c !== void 0 ? _c : exports.PAPER_GRID_ALPHA));
+    return (0, template_utils_1.makeColorTile)(opts.ink, {
+        mask: {
+            kind: "inline-mask",
+            localPath: paperGridPath(w, h, stepPx, linePx),
+            bounds: { x: 0, y: 0, width: w, height: h },
+        },
+        overlay: { alpha: String(alpha) },
+    });
+}

package/dist/m0saic/wireframe/utils/wireframeCell.d.ts

@@ -0,0 +1,35 @@
+import type { MosaicTextStyleProps, MosaicTemplate, MosaicColor, RoundingOptions } from "@m0saic/types";
+export type WireframeCellTheme = {
+    tileBackgroundColor?: MosaicColor;
+    borderColor?: MosaicColor;
+    borderAlpha?: number;
+    borderWidthFrac?: number;
+    rounding?: RoundingOptions;
+    dropShadow?: {
+        dx?: number;
+        dy?: number;
+        blur?: number;
+        color?: string;
+    };
+};
+export type WireframeCellSchemaProps = {
+    orderString: string;
+    showOrderString?: boolean;
+    text?: string;
+    /**
+     * Optional base font size used for the orderString.
+     * The optional text overlay will scale relative to this.
+     */
+    textSize?: number;
+    /** Render mode: "debug" shows labels/dims, "thumb" shows clean tiles only. */
+    mode?: "debug" | "thumb";
+};
+type WireframeCellStyles = {
+    baseFrameStyle?: MosaicTextStyleProps;
+    textStyle?: MosaicTextStyleProps;
+};
+export type WireframeCellProps = WireframeCellSchemaProps & WireframeCellStyles & {
+    theme?: WireframeCellTheme;
+};
+export declare const WireframeCell: MosaicTemplate<WireframeCellProps>;
+export {};

package/dist/m0saic/wireframe/utils/wireframeCell.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WireframeCell = void 0;
+const types_1 = require("@m0saic/types");
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const template_utils_1 = require("@m0saic/template-utils");
+// ── Debug-mode layout constants ──
+const INDEX_PADDING_X = 0.03;
+const INDEX_PADDING_Y = 0.03;
+const INDEX_FONT_SCALE = 0.9;
+const INDEX_FONT_MIN = 10;
+const INDEX_FONT_MAX = 120;
+const DIM_FONT_SCALE = 1.25;
+const AR_FONT_SCALE = 0.85;
+// Stack gap: the dims line's descenders touched the ratio line's caps at 1.2
+// (gate-30 battery eyeball) — 1.45 opens a real gap without breaking the
+// fit model in animated/v1 (CELL_LINE_SPACING mirrors this value).
+const LINE_SPACING = 1.45;
+const CENTER_BLOCK_NUDGE = 0.02;
+// public props schema for editors and validation (meta per mosaic-templates.ts)
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    orderString: {
+        type: "string",
+        required: true,
+        description: "Primary label for the cell (e.g., '1', 'A1', 'B3')",
+        meta: {
+            control: {
+                placeholder: "e.g., 1, A1, B3",
+            },
+            ui: {
+                label: "Order Label",
+            },
+        },
+    },
+    showOrderString: {
+        type: "boolean",
+        required: false,
+        description: "If true, renders the orderString label. Default: true.",
+        meta: {
+            ui: {
+                label: "Show Order Label",
+            },
+        },
+    },
+    text: {
+        type: "string",
+        required: false,
+        description: "Optional label for this cell",
+        meta: {
+            control: {
+                placeholder: "Optional cell label",
+            },
+            ui: {
+                label: "Cell Text",
+            },
+        },
+    },
+    textSize: {
+        type: "number",
+        required: false,
+        description: "Base font size for the orderString; the text overlay scales relative to this.",
+        meta: {
+            constraints: {
+                min: 8,
+                max: 200,
+            },
+            control: {
+                placeholder: "e.g., 64",
+            },
+            ui: {
+                label: "Text Size",
+            },
+        },
+    },
+    mode: {
+        type: "string",
+        required: false,
+        description: 'Render mode. "debug" (default) shows labels/dims. "thumb" shows clean tiles only.',
+        meta: {
+            constraints: { oneOf: ["debug", "thumb"] },
+            control: {
+                options: [
+                    { value: "debug", label: "Debug" },
+                    { value: "thumb", label: "Thumbnail" },
+                ],
+            },
+            ui: { label: "Mode" },
+        },
+    },
+});
+exports.WireframeCell = {
+    id: (0, types_1.asTemplateId)("@m0saic/wireframe/cell/v1"),
+    label: "Wireframe Cell",
+    version: 1,
+    description: "Single numbered wireframe cell with optional text overlay",
+    capabilities: {
+        tier: "core",
+    },
+    tags: ["wireframe", "docs-only"],
+    internal: true, // Building block for wireframe template, not meant for direct use
+    outputHints: {
+        width: 640,
+        height: 480,
+        fps: 30,
+        durationMs: 1000,
+        note: "Single wireframe cell for documentation",
+    },
+    propsSchema,
+    defaultProps: {
+        mode: "debug",
+        orderString: "1",
+        showOrderString: true,
+        text: "",
+        textSize: 64,
+        baseFrameStyle: {
+            fontSize: 64,
+            fontColor: "#000000",
+            fontFamily: "Arial, sans-serif",
+            borderWidth: 0.005,
+            borderColor: "#000000",
+        },
+        textStyle: {
+            fontColor: "#000000",
+            fontSize: 48,
+        },
+    },
+    render(props, _ctx) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const { orderString, text, theme } = props;
+        const isThumb = props.mode === "thumb";
+        // ── Thumb mode: lavfi color source, no text at all ──
+        if (isThumb) {
+            const tileColor = (_a = theme === null || theme === void 0 ? void 0 : theme.tileBackgroundColor) !== null && _a !== void 0 ? _a : "#141824";
+            const effects = {
+                rounding: (_b = theme === null || theme === void 0 ? void 0 : theme.rounding) !== null && _b !== void 0 ? _b : {
+                    borderRadius: 0.04,
+                    cornerStyle: "rounded",
+                },
+                stroke: {
+                    width: (_c = theme === null || theme === void 0 ? void 0 : theme.borderWidthFrac) !== null && _c !== void 0 ? _c : 0.0015,
+                    color: ((_d = theme === null || theme === void 0 ? void 0 : theme.borderColor) !== null && _d !== void 0 ? _d : "#ffffff"),
+                    alpha: (_e = theme === null || theme === void 0 ? void 0 : theme.borderAlpha) !== null && _e !== void 0 ? _e : 0.10,
+                    position: "inner",
+                },
+            };
+            if (theme === null || theme === void 0 ? void 0 : theme.dropShadow) {
+                effects.dropShadow = theme.dropShadow;
+            }
+            const cellSource = {
+                type: "lavfi",
+                color: tileColor,
+                effects,
+            };
+            return Promise.resolve({
+                kind: "mosaic_document",
+                version: 1,
+                assets: {},
+                m0: (0, dsl_stdlib_1.toM0String)("F", "WireframeCell"),
+                sources: [cellSource],
+            });
+        }
+        // ── Debug mode ──
+        const showOrderString = props.showOrderString !== false;
+        const baseFontSize = (_f = props.textSize) !== null && _f !== void 0 ? _f : 64;
+        const overlayFontSize = Math.round(baseFontSize * 0.75);
+        // Base style for the order index / frame text
+        let baseFrameStyle = {
+            fontSize: 64,
+            fontColor: "#000000",
+            fontFamily: "Arial, sans-serif",
+            borderWidth: 0.005,
+            borderColor: "#000000",
+            ...((_g = props.baseFrameStyle) !== null && _g !== void 0 ? _g : {}),
+        };
+        // Style for geometry / overlay text
+        let textStyle = {
+            fontColor: "#000000",
+            fontSize: 48,
+            ...((_h = props.textStyle) !== null && _h !== void 0 ? _h : {}),
+        };
+        if (props.textSize != null) {
+            baseFrameStyle = { ...baseFrameStyle, fontSize: baseFontSize };
+            textStyle = { ...textStyle, fontSize: overlayFontSize };
+        }
+        // When theme provides effects-based border, zero out text-style border to avoid double
+        const hasThemeEffects = theme && (theme.borderWidthFrac != null || theme.rounding);
+        if (hasThemeEffects) {
+            baseFrameStyle = { ...baseFrameStyle, borderWidth: 0 };
+        }
+        const geometryText = (text !== null && text !== void 0 ? text : "").trim();
+        const lines = geometryText
+            ? geometryText.split("\n").filter((l) => l.length > 0)
+            : [];
+        const layers = [];
+        if (lines.length > 0) {
+            const baseTextFont = (_j = textStyle.fontSize) !== null && _j !== void 0 ? _j : overlayFontSize;
+            const dimFontSize = Math.round(baseTextFont * DIM_FONT_SCALE);
+            const arFontSize = Math.round(baseTextFont * AR_FONT_SCALE);
+            const lineHeights = lines.map((_, i) => i === 0 ? `${dimFontSize}*${LINE_SPACING}` : `${arFontSize}*${LINE_SPACING}`);
+            const blockHeightExpr = lineHeights.map((lh) => `(${lh})`).join("+");
+            const y0Expr = `(h-(${blockHeightExpr}))/2 - h*${CENTER_BLOCK_NUDGE}`;
+            lines.forEach((line, i) => {
+                const isDim = i === 0;
+                layers.push({
+                    content: { kind: "literal", text: line },
+                    style: {
+                        ...textStyle,
+                        fontSize: isDim ? dimFontSize : arFontSize,
+                    },
+                    placement: {
+                        hAlign: "left",
+                        vAlign: "top",
+                        xExpr: "(w-text_w)/2",
+                        yExpr: `${y0Expr} + (${lineHeights[i]})*${i}`,
+                    },
+                });
+            });
+        }
+        // index in top-left (ONLY if enabled)
+        if (showOrderString) {
+            const indexFontSize = Math.max(INDEX_FONT_MIN, Math.min(INDEX_FONT_MAX, Math.round(baseFontSize * INDEX_FONT_SCALE)));
+            layers.push({
+                content: { kind: "literal", text: orderString },
+                placement: {
+                    fit: "contain",
+                    hAlign: "left",
+                    vAlign: "top",
+                    padding: { x: INDEX_PADDING_X, y: INDEX_PADDING_Y },
+                },
+                style: { ...baseFrameStyle, fontSize: indexFontSize },
+            });
+        }
+        // A cell that shows nothing (blank custom label, or an unlabeled cell
+        // under `unlabeledCells: "empty"`) must still be a renderable text
+        // source: the engine refuses `layers: []` ("must have non-empty
+        // layers[]") and the whole render exits 1 (gate 30 battery catch). One
+        // empty literal keeps the frame border + background and draws no glyphs.
+        if (layers.length === 0) {
+            layers.push({ content: { kind: "literal", text: "" } });
+        }
+        const cellSource = {
+            type: "text",
+            style: baseFrameStyle,
+            visual: {
+                backgroundColor: (_k = theme === null || theme === void 0 ? void 0 : theme.tileBackgroundColor) !== null && _k !== void 0 ? _k : "#ffffff",
+            },
+            layers,
+        };
+        // Apply theme-based effects in debug mode (rounding, stroke, dropShadow)
+        if (hasThemeEffects || (theme === null || theme === void 0 ? void 0 : theme.dropShadow)) {
+            const effects = {};
+            if (theme === null || theme === void 0 ? void 0 : theme.rounding) {
+                effects.rounding = theme.rounding;
+            }
+            if ((theme === null || theme === void 0 ? void 0 : theme.borderWidthFrac) != null) {
+                effects.stroke = {
+                    width: theme.borderWidthFrac,
+                    color: ((_l = theme.borderColor) !== null && _l !== void 0 ? _l : "#000000"),
+                    alpha: (_m = theme.borderAlpha) !== null && _m !== void 0 ? _m : 1.0,
+                    position: "inner",
+                };
+            }
+            if (theme === null || theme === void 0 ? void 0 : theme.dropShadow) {
+                effects.dropShadow = theme.dropShadow;
+            }
+            cellSource.effects = effects;
+        }
+        const doc = {
+            kind: "mosaic_document",
+            version: 1,
+            assets: {},
+            m0: (0, dsl_stdlib_1.toM0String)("F", "WireframeCell"),
+            sources: [cellSource],
+        };
+        return Promise.resolve(doc);
+    },
+};
+(0, template_utils_1.registerTemplate)(exports.WireframeCell);

package/dist/registry.d.ts

@@ -0,0 +1,4 @@
+import "./m0saic/wireframe";
+import "./m0saic/brand";
+import "./m0saic/media";
+import "./m0saic/hero";

package/dist/registry.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Import templates for side effects: each template file calls registerTemplate(...)
+require("./m0saic/wireframe");
+require("./m0saic/brand");
+require("./m0saic/media");
+require("./m0saic/hero");

package/dist/repo.d.ts

@@ -0,0 +1,11 @@
+import type { MosaicTemplatePackDescriptor, MosaicTemplateRepoDescriptor } from "@m0saic/types";
+export declare const TEMPLATE_REPO: MosaicTemplateRepoDescriptor;
+/**
+ * Named packs in this repo — the releasable groupings template ids roll up into
+ * (keyed by the `{pack}` segment, e.g. `@m0saic/alpine/bar-graph/v1` → `alpine`).
+ *
+ * Only packs with their own identity / marketing need a descriptor here; a pack
+ * segment without an entry still works (hosts fall back to the raw pack name).
+ * The manifest generator emits this array as `manifest.packs`.
+ */
+export declare const TEMPLATE_PACKS: MosaicTemplatePackDescriptor[];

package/dist/repo.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_PACKS = exports.TEMPLATE_REPO = void 0;
+const types_1 = require("@m0saic/types");
+exports.TEMPLATE_REPO = {
+    schemaVersion: 1,
+    repoId: (0, types_1.asRepoId)("m0saic/templates"),
+    displayName: "m0saic Templates",
+    description: "Official templates bundled with m0saic.",
+    curator: "m0saic",
+    assets: {
+        templatesDir: "assets/templates",
+    },
+    // The front door — what `m0saic hello-world` renders and the first card a
+    // newcomer sees (the hello-world convention, 2026-09-14).
+    helloWorld: (0, types_1.asTemplateId)("@m0saic/hello-world/v1"),
+};
+/**
+ * Named packs in this repo — the releasable groupings template ids roll up into
+ * (keyed by the `{pack}` segment, e.g. `@m0saic/alpine/bar-graph/v1` → `alpine`).
+ *
+ * Only packs with their own identity / marketing need a descriptor here; a pack
+ * segment without an entry still works (hosts fall back to the raw pack name).
+ * The manifest generator emits this array as `manifest.packs`.
+ */
+exports.TEMPLATE_PACKS = [
+    {
+        id: "alpine",
+        title: "Alpine Data Viz",
+        description: "Friendly mobile-marketing chart pack — rounded cards, soft palette, clean type.",
+        publisher: "m0saic",
+    },
+    {
+        id: "web",
+        title: "Web",
+        description: "Privacy-preserving templates that translate anonymous webpage geometry into editable m0 visuals.",
+        publisher: "m0saic",
+    },
+];

package/dist/template-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Authoring registry for official built-in templates.
+ *
+ * Each entry provides the metadata needed to generate template-manifest.json.
+ * This is the single source of truth for browse metadata (title, description,
+ * tags, preview paths) for the official template pack.
+ *
+ * ALL registered templates belong here — including internal ones — so that
+ * preview assets and repo metadata are resolved for every template.
+ */
+import type { MosaicTemplateRepoManifestEntry } from "@m0saic/types";
+export type OfficialTemplateRegistryEntry = Omit<MosaicTemplateRepoManifestEntry, "templateKey"> & {
+    /** The template's id field (= templateKey in manifest). */
+    templateId: string;
+    /** Named export from dist/index.js (must match barrel export). */
+    exportName: string;
+};
+export declare const templateRegistry: OfficialTemplateRegistryEntry[];