@m0saic/templates 0.2.0

package/dist/m0saic/benchmark/run/v1/renderScenario.d.ts

@@ -0,0 +1,12 @@
+import type { ScenarioExecutor } from "./benchmarkRun";
+/**
+ * Build the real scenario executor: renders each frozen `.mosaic` via a
+ * `m0saic make … --report` subprocess and reads the resulting `.output.json`
+ * sidecar for the measured render time. The CLI's own `run.elapsedMs` is used
+ * (it times the render, excluding our spawn overhead).
+ */
+export declare function makeRealExecutor(opts: {
+    scenariosDir: string;
+    outDir: string;
+    onProgress?: (msg: string) => void;
+}): ScenarioExecutor;

package/dist/m0saic/benchmark/run/v1/renderScenario.js

@@ -0,0 +1,122 @@
+"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 });
+exports.makeRealExecutor = makeRealExecutor;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Fixed render envelope — the fairness invariant for every workload. */
+const BENCH_WIDTH = 1920;
+const BENCH_HEIGHT = 1080;
+function readReport(p) {
+    try {
+        return JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the `m0saic` CLI to spawn. Prefers an explicit `M0SAIC_CLI` override,
+ * else re-invokes the same CLI script currently running this template (so a run
+ * launched via a linked/bundled CLI re-uses it), else falls back to `m0saic` on
+ * PATH.
+ */
+function resolveCli() {
+    const override = process.env.M0SAIC_CLI;
+    if (override && override.trim())
+        return { file: override.trim(), prefix: [] };
+    const entry = process.argv[1];
+    if (entry && /m0saic|cli|index\.js$/i.test(entry)) {
+        return { file: process.execPath, prefix: [entry] };
+    }
+    return { file: "m0saic", prefix: [] };
+}
+/**
+ * Build the real scenario executor: renders each frozen `.mosaic` via a
+ * `m0saic make … --report` subprocess and reads the resulting `.output.json`
+ * sidecar for the measured render time. The CLI's own `run.elapsedMs` is used
+ * (it times the render, excluding our spawn overhead).
+ */
+function makeRealExecutor(opts) {
+    const cli = resolveCli();
+    fs.mkdirSync(opts.outDir, { recursive: true });
+    return async (s) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const input = path.join(opts.scenariosDir, s.file);
+        const outFile = path.join(opts.outDir, `${s.id}.mp4`);
+        const args = [
+            ...cli.prefix,
+            "make",
+            input,
+            "--width",
+            String(BENCH_WIDTH),
+            "--height",
+            String(BENCH_HEIGHT),
+            "--report",
+            "-o",
+            outFile,
+            "--quiet",
+        ];
+        if (s.codec)
+            args.push("--video-codec", s.codec);
+        if (s.durationMs)
+            args.push("--durationMs", String(s.durationMs));
+        (_a = opts.onProgress) === null || _a === void 0 ? void 0 : _a.call(opts, `▶ ${s.id}${s.codec ? ` [${s.codec}]` : ""}${s.durationMs ? ` (${Math.round(s.durationMs / 1000)}s)` : ""}`);
+        const res = (0, child_process_1.spawnSync)(cli.file, args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const report = readReport(outFile.replace(/\.mp4$/, ".output.json"));
+        const out = report === null || report === void 0 ? void 0 : report.output;
+        const measurement = {
+            ok: res.status === 0 && !!report && report.ok !== false,
+            elapsedMs: (_c = (_b = report === null || report === void 0 ? void 0 : report.run) === null || _b === void 0 ? void 0 : _b.elapsedMs) !== null && _c !== void 0 ? _c : null,
+            width: (_d = out === null || out === void 0 ? void 0 : out.width) !== null && _d !== void 0 ? _d : null,
+            height: (_e = out === null || out === void 0 ? void 0 : out.height) !== null && _e !== void 0 ? _e : null,
+            fps: (_f = out === null || out === void 0 ? void 0 : out.fps) !== null && _f !== void 0 ? _f : null,
+            durationMs: (_g = out === null || out === void 0 ? void 0 : out.durationMs) !== null && _g !== void 0 ? _g : null,
+            codec: (_k = (_j = (_h = out === null || out === void 0 ? void 0 : out.format) === null || _h === void 0 ? void 0 : _h.codec) !== null && _j !== void 0 ? _j : s.codec) !== null && _k !== void 0 ? _k : null,
+        };
+        if (measurement.ok) {
+            measurement.versions = report === null || report === void 0 ? void 0 : report.versions;
+        }
+        else {
+            const stderr = (res.stderr || "").trim().split(/\r?\n/).slice(-2).join(" ");
+            measurement.error = stderr || `exit ${(_l = res.status) !== null && _l !== void 0 ? _l : "unknown"}`;
+        }
+        return measurement;
+    };
+}

package/dist/m0saic/benchmark/run/v1/runner.d.ts

@@ -0,0 +1,10 @@
+import type { BenchmarkSet } from "@m0saic/types";
+export type BenchmarkRunProps = {
+    /** Which sets to run. Default: every set with shipped workloads. */
+    tests?: BenchmarkSet[];
+    /** Run label — distinguishes conditions, e.g. "idle" vs "loaded". */
+    label?: string;
+    /** Where to write the session folder. Default: current working directory. */
+    outputDir?: string;
+};
+export declare const BenchmarkRun: import("@m0saic/types").MosaicTemplate<BenchmarkRunProps, import("@m0saic/types").MosaicTemplateOutputs, import("@m0saic/types").MosaicTemplateUpstreamVariables, import("@m0saic/types").MosaicTemplateUpstreamData, import("@m0saic/types").MosaicTemplateSidecars>;

package/dist/m0saic/benchmark/run/v1/runner.js

@@ -0,0 +1,208 @@
+"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 });
+exports.BenchmarkRun = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const assetPath_1 = require("@m0saic/template-utils/dist/m0saic/assetPath");
+const types_1 = require("@m0saic/types");
+const template_utils_1 = require("@m0saic/template-utils");
+const system_1 = require("@m0saic/platform/system");
+const manifest_1 = require("../../battery/manifest");
+const benchmarkRun_1 = require("./benchmarkRun");
+const renderScenario_1 = require("./renderScenario");
+const confirmation_1 = require("./confirmation");
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    tests: {
+        type: "string[]",
+        required: false,
+        description: "Which benchmark sets to run. Default: all available.",
+        meta: {
+            control: {
+                multiple: true,
+                options: [
+                    { value: "sources", label: "Sources", description: "One workload per source kind (lavfi, text, nested, ref, video, audio)" },
+                    { value: "geometry", label: "Geometry", description: "144-cell grid — chunked-stitch path" },
+                    { value: "duration", label: "Duration", description: "60s render — longest wall-clock" },
+                    { value: "encoders", label: "Encoders", description: "Same job across software + detected hardware encoders" },
+                    { value: "real", label: "Real (heavy)", description: "Captured real templates (charts, video grid) at short/medium/long — minutes-long, the truest real-world cost signal" },
+                    { value: "sloth", label: "Sloth (blowups)", description: "Known complexity blowups (the donut's masked-sweep, ~70min at 30s) — run deliberately on their own; they'd dominate a normal run and flatten the chart" },
+                ],
+            },
+            ui: { label: "Tests", order: 1 },
+        },
+    },
+    label: {
+        type: "string",
+        required: false,
+        description: "Run condition — names the session folder and labels the shareable result, so machines compare like-for-like.",
+        meta: {
+            control: {
+                options: [
+                    { value: "idle", label: "Idle", description: "Nothing else running — the clean baseline" },
+                    { value: "loaded", label: "Loaded", description: "Browser + apps open, like a working machine" },
+                    { value: "gaming", label: "Gaming", description: "A game running alongside the render" },
+                    { value: "dedicated", label: "Dedicated render", description: "A render-only rig with nothing else competing" },
+                ],
+            },
+            ui: { label: "Label", order: 2 },
+        },
+    },
+    outputDir: {
+        type: "string",
+        required: false,
+        description: "Folder to write the benchmark session into. Default: current directory.",
+        meta: {
+            control: { placeholder: "current working directory", picker: "folder" },
+            ui: { label: "Output dir", order: 3 },
+        },
+    },
+});
+// Default to the STANDARD tier — a quick run. The `real` (heavy) tier is
+// minutes-long, so it's opt-in via the Tests selection.
+const DEFAULTS = { tests: manifest_1.BENCHMARK_STANDARD_SETS, label: "idle" };
+function slug(label) {
+    return label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "run";
+}
+/** Resolve the requested sets, defaulting to the standard tier; drop unknowns. */
+function resolveTests(props) {
+    var _a;
+    const raw = (_a = props.tests) !== null && _a !== void 0 ? _a : manifest_1.BENCHMARK_STANDARD_SETS;
+    return raw.filter((t) => benchmarkRun_1.AVAILABLE_SETS.includes(t));
+}
+/**
+ * The lightweight stand-in shown on preview / design hot paths (and as a guard
+ * if render() is ever invoked in design mode). It describes what pressing Make
+ * will do — it performs NO side effects (no subprocess, no fs writes).
+ */
+function buildLiteDoc(props, ctx) {
+    var _a;
+    const tests = resolveTests(props);
+    if (tests.length === 0) {
+        return (0, confirmation_1.buildConfirmationDoc)({
+            titleLine: "m0saic benchmark",
+            subLine: "Select test sets (sources, geometry, duration, encoders), then press Make to run",
+            ctx,
+        });
+    }
+    const count = (0, benchmarkRun_1.selectScenarios)(tests, []).length;
+    return (0, confirmation_1.buildConfirmationDoc)({
+        titleLine: "m0saic benchmark — press Make to run",
+        subLine: `${tests.join(", ")} · ${count}+ workloads · writes ./benchmark-${slug(((_a = props.label) !== null && _a !== void 0 ? _a : "run").trim() || "run")}/benchmark.json`,
+        ctx,
+    });
+}
+exports.BenchmarkRun = (0, template_utils_1.defineMosaicTemplate)({
+    id: (0, types_1.asTemplateId)("@m0saic/benchmark/run/v1"),
+    label: "Benchmark — Run",
+    version: 1,
+    description: "Measures this machine's render performance: renders a frozen battery of standardized .mosaic workloads (sources, geometry, long-duration, encoder comparison), times each via its --report sidecar, captures host specs, and writes a shareable benchmark.json session folder. Pair with the benchmark report template to render the results video.",
+    capabilities: {
+        tier: "capability",
+        caps: {
+            // Spawns `m0saic make` per workload and writes the session folder.
+            exec: { spawn: true },
+            fs: { read: true, write: true, list: true, temp: true },
+        },
+    },
+    tags: ["developer", "benchmark", "performance", "diagnostics", "capability", "developers", "animated"],
+    outputHints: {
+        width: 1920,
+        height: 1080,
+        fps: 30,
+        durationMs: 4000,
+        format: { kind: "video", container: "mp4" },
+    },
+    propsSchema,
+    defaultProps: DEFAULTS,
+    async render(props, ctx) {
+        var _a, _b;
+        // Preview / design hot path defense-in-depth: never run the battery just
+        // because a host rendered us in design mode. Preview hosts should call
+        // renderLite() (below), but guard here too in case render() is invoked
+        // directly with mode: "design".
+        if (ctx.mode === "design")
+            return buildLiteDoc(props, ctx);
+        // Omitted → all available sets; an explicit empty array → just the card
+        // (used by the E2E suite to avoid running the battery in CI).
+        const tests = resolveTests(props);
+        const label = ((_a = props.label) !== null && _a !== void 0 ? _a : "run").trim() || "run";
+        if (tests.length === 0)
+            return buildLiteDoc(props, ctx);
+        const systemInfo = (0, system_1.collectSystemInfo)();
+        const scenarios = (0, benchmarkRun_1.selectScenarios)(tests, systemInfo.ffmpeg.hwEncoders);
+        const outputDir = (_b = props.outputDir) !== null && _b !== void 0 ? _b : process.cwd();
+        const sessionDir = path.join(outputDir, `benchmark-${slug(label)}`);
+        // asar-translated: the frozen `.mosaic` scenarios are handed to a spawned
+        // `m0saic make` subprocess (see renderScenario), which cannot read inside
+        // app.asar. asarUnpack already mirrors them (they live under `assets/`).
+        const scenariosDir = (0, assetPath_1.unpackedAsarPath)(path.resolve(__dirname, "..", "..", "battery", manifest_1.BATTERY_SCENARIOS_SUBDIR));
+        const exec = (0, renderScenario_1.makeRealExecutor)({
+            scenariosDir,
+            outDir: path.join(sessionDir, "scenarios"),
+            onProgress: (m) => process.stderr.write(`${m}\n`),
+        });
+        const startedAt = Date.now();
+        const { results, versions } = await (0, benchmarkRun_1.runScenarios)(scenarios, exec);
+        const finishedAt = Date.now();
+        const session = (0, benchmarkRun_1.assembleSession)({
+            label,
+            systemInfo,
+            results,
+            selectedSets: tests,
+            startedAtIso: new Date(startedAt).toISOString(),
+            finishedAtIso: new Date(finishedAt).toISOString(),
+            elapsedMs: finishedAt - startedAt,
+            versions,
+        });
+        fs.mkdirSync(sessionDir, { recursive: true });
+        const jsonPath = path.join(sessionDir, "benchmark.json");
+        fs.writeFileSync(jsonPath, `${JSON.stringify(session, null, 2)}\n`, "utf8");
+        const okCount = results.filter((r) => r.ok).length;
+        process.stderr.write(`✅ benchmark "${label}": ${okCount}/${results.length} ok · score ${session.summary.score} → ${jsonPath}\n`);
+        return (0, confirmation_1.buildConfirmationDoc)({
+            titleLine: `m0saic benchmark · ${label}`,
+            subLine: `${okCount}/${results.length} scenarios · ${Math.round(session.summary.totalElapsedMs / 1000)}s · score ${session.summary.score}`,
+            ctx,
+        });
+    },
+    // Preview / design hot path: a lightweight instructional card. NO side
+    // effects — this is what the editor shows when the template is selected or
+    // its props change, so the battery only ever runs on an explicit Make.
+    renderLite(props, ctx) {
+        return buildLiteDoc(props, ctx);
+    },
+});
+(0, template_utils_1.registerTemplate)(exports.BenchmarkRun);

package/dist/m0saic/brand/business-card/v1/back-catalog.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @m0saic/brand/business-card/v1 — the back-of-card catalog.
+ *
+ * The back shows ONE shipped template, picked by the `back` prop. Every
+ * entry is rendered LIVE as a nested child (never a bundled poster — the
+ * publish gate keeps `assets/templates/*` out of the CLI tarball), so each
+ * entry must (a) be registered in the web build too (the QR opens it on
+ * Mosaic Web) and (b) freeze to a finished frame at t = 0: a still samples
+ * the first frame, and an intro that starts from nothing renders blank.
+ * `frozenProps` flips the same knobs the editor covers use (`anim.reduceMotion`
+ * / `animation.reduceMotion` / `animate`).
+ *
+ * Hardcoded on purpose: `template-registry.ts` is 700 lines of data and would
+ * ride into the web bundle; `back-catalog.test.ts` cross-checks every row
+ * against it instead.
+ */
+export declare const WEB_APP_URL = "https://app.m0saic.io";
+/** The marketing site — owner of the typeable short links the card prints. */
+export declare const SITE_HOST = "m0saic.io";
+export type BackEntry = {
+    /** The template rendered on the back. */
+    templateId: string;
+    /** Short display title (ASCII — svg glyphs). */
+    title: string;
+    /** Prop overrides layered over the template's defaults (light flavour only). */
+    flavour?: Record<string, unknown>;
+    /** The one-liner printed under the link. Default `npx m0saic make <id>`. */
+    command?: string;
+    /** The typeable url as printed. Default `m0saic.io/t/<pack>/<slug>/<vN>` (the site's route). */
+    typeable?: string;
+    /**
+     * Canvas the child renders at. Default: its own `outputHints` (the canvas its
+     * layout was designed for). `"cell"` = the poster cell itself — for a
+     * template whose layout is ABSOLUTE at the head (hello-world's card is
+     * `placeRects`): rendered at its native 1920x1080 and scaled into the cell
+     * its pixel-basis splits go sub-pixel when the editor flattens the card.
+     */
+    slot?: {
+        width: number;
+        height: number;
+    } | "cell";
+};
+export declare const BACK_KEYS: readonly ["hello-world", "agent-commit-feed", "trace-timeline", "year-card", "commit-feed", "donut", "bar-graph", "line-chart", "kpi-card", "heatmap", "treemap", "leaderboard", "timeline", "contributor-table", "snippet-morph"];
+export type BackKey = (typeof BACK_KEYS)[number];
+export declare const BACK_CATALOG: Record<BackKey, BackEntry>;
+export declare function pickBack(value: string | undefined): BackKey;
+/** The minimal Mosaic Web link — `/make?t=<id>` opens the template at its defaults. */
+export declare function makeUrl(templateId: string): string;
+/**
+ * The url as PRINTED: the site's typeable form (`m0saic.io/t/<pack>/<slug>/<vN>`
+ * — `@m0saic/` is implied by the route; hello-world has `/hello`), the same
+ * line the mobile showroom tells a phone to type. 39 chars at the longest, so
+ * it holds at the 8 pt floor; the app url (`makeUrl`) runs to 64. The QR
+ * keeps the app url — a scan never waits on the site's redirect.
+ */
+export declare function displayUrl(entry: BackEntry): string;
+/** The CLI one-liner; `make` writes `out.mp4` / `out.png` when `-o` is omitted. */
+export declare function commandFor(entry: BackEntry): string;
+/**
+ * The longest command in the catalog — it sets the ONE size every back's
+ * command prints at (mono, so longest = widest). Ties break on catalog order.
+ */
+export declare function longestCommand(): string;
+/**
+ * The child's props: its defaults, the entry's flavour, then every motion
+ * knob switched off so frame 0 is the finished picture.
+ */
+export declare function frozenProps(defaults: Record<string, unknown> | undefined, flavour?: Record<string, unknown>): Record<string, unknown>;

package/dist/m0saic/brand/business-card/v1/back-catalog.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * @m0saic/brand/business-card/v1 — the back-of-card catalog.
+ *
+ * The back shows ONE shipped template, picked by the `back` prop. Every
+ * entry is rendered LIVE as a nested child (never a bundled poster — the
+ * publish gate keeps `assets/templates/*` out of the CLI tarball), so each
+ * entry must (a) be registered in the web build too (the QR opens it on
+ * Mosaic Web) and (b) freeze to a finished frame at t = 0: a still samples
+ * the first frame, and an intro that starts from nothing renders blank.
+ * `frozenProps` flips the same knobs the editor covers use (`anim.reduceMotion`
+ * / `animation.reduceMotion` / `animate`).
+ *
+ * Hardcoded on purpose: `template-registry.ts` is 700 lines of data and would
+ * ride into the web bundle; `back-catalog.test.ts` cross-checks every row
+ * against it instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BACK_CATALOG = exports.BACK_KEYS = exports.SITE_HOST = exports.WEB_APP_URL = void 0;
+exports.pickBack = pickBack;
+exports.makeUrl = makeUrl;
+exports.displayUrl = displayUrl;
+exports.commandFor = commandFor;
+exports.longestCommand = longestCommand;
+exports.frozenProps = frozenProps;
+exports.WEB_APP_URL = "https://app.m0saic.io";
+/** The marketing site — owner of the typeable short links the card prints. */
+exports.SITE_HOST = "m0saic.io";
+exports.BACK_KEYS = [
+    "hello-world",
+    "agent-commit-feed",
+    "trace-timeline",
+    "year-card",
+    "commit-feed",
+    "donut",
+    "bar-graph",
+    "line-chart",
+    "kpi-card",
+    "heatmap",
+    "treemap",
+    "leaderboard",
+    "timeline",
+    "contributor-table",
+    "snippet-morph",
+];
+exports.BACK_CATALOG = {
+    "hello-world": {
+        templateId: "@m0saic/hello-world/v1",
+        title: "Hello, World",
+        command: "npx m0saic hello-world",
+        typeable: `${exports.SITE_HOST}/hello`, // next.config.ts redirect — the showroom's own hand-off line
+        slot: "cell",
+    },
+    // The WeAreDevelopers NA card for the AI-coding majority: who wrote this week's commits.
+    "agent-commit-feed": { templateId: "@m0saic/agents/commit-feed/v1", title: "Agent Commit Feed" },
+    // The "agents in production" card: one run as a waterfall of tool calls.
+    "trace-timeline": { templateId: "@m0saic/agents/trace-timeline/v1", title: "Agent Trace Timeline" },
+    // The card for everyone: a year of contributions on one card.
+    "year-card": { templateId: "@m0saic/github/year-card/v1", title: "GitHub Year Card" },
+    "commit-feed": { templateId: "@m0saic/alpine/commit-feed/v2", title: "Commit Feed" },
+    // The alpine charts, not charts/*: the alpine donut carries a legend (the
+    // charts one labels the ring only — founder pick 2026-09-16) and the trio
+    // shares the alpine chrome with the rest of the catalog.
+    donut: { templateId: "@m0saic/alpine/donut/v3", title: "Donut Chart" },
+    "bar-graph": { templateId: "@m0saic/alpine/bar-graph/v1", title: "Bar Graph" },
+    "line-chart": { templateId: "@m0saic/alpine/line-chart/v2", title: "Line Chart" },
+    "kpi-card": { templateId: "@m0saic/alpine/kpi-card/v2", title: "KPI Card" },
+    heatmap: { templateId: "@m0saic/alpine/heatmap/v2", title: "Heatmap" },
+    treemap: { templateId: "@m0saic/alpine/treemap/v2", title: "Treemap" },
+    leaderboard: { templateId: "@m0saic/alpine/leaderboard/v1", title: "Leaderboard" },
+    timeline: { templateId: "@m0saic/alpine/timeline/v2", title: "Timeline" },
+    "contributor-table": { templateId: "@m0saic/alpine/contributor-table/v1", title: "Contributor Table" },
+    "snippet-morph": { templateId: "@m0saic/code/snippet-morph/v1", title: "Code Snippet Morph" },
+};
+function pickBack(value) {
+    return exports.BACK_KEYS.includes(value !== null && value !== void 0 ? value : "") ? value : "hello-world";
+}
+/** The minimal Mosaic Web link — `/make?t=<id>` opens the template at its defaults. */
+function makeUrl(templateId) {
+    return `${exports.WEB_APP_URL}/make?t=${templateId}`;
+}
+/**
+ * The url as PRINTED: the site's typeable form (`m0saic.io/t/<pack>/<slug>/<vN>`
+ * — `@m0saic/` is implied by the route; hello-world has `/hello`), the same
+ * line the mobile showroom tells a phone to type. 39 chars at the longest, so
+ * it holds at the 8 pt floor; the app url (`makeUrl`) runs to 64. The QR
+ * keeps the app url — a scan never waits on the site's redirect.
+ */
+function displayUrl(entry) {
+    var _a;
+    return (_a = entry.typeable) !== null && _a !== void 0 ? _a : `${exports.SITE_HOST}/t/${entry.templateId.replace(/^@m0saic\//, "")}`;
+}
+/** The CLI one-liner; `make` writes `out.mp4` / `out.png` when `-o` is omitted. */
+function commandFor(entry) {
+    var _a;
+    return (_a = entry.command) !== null && _a !== void 0 ? _a : `npx m0saic make ${entry.templateId}`;
+}
+/**
+ * The longest command in the catalog — it sets the ONE size every back's
+ * command prints at (mono, so longest = widest). Ties break on catalog order.
+ */
+function longestCommand() {
+    return exports.BACK_KEYS.map((k) => commandFor(exports.BACK_CATALOG[k])).reduce((a, b) => (b.length > a.length ? b : a));
+}
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * The child's props: its defaults, the entry's flavour, then every motion
+ * knob switched off so frame 0 is the finished picture.
+ */
+function frozenProps(defaults, flavour) {
+    const out = { ...(defaults !== null && defaults !== void 0 ? defaults : {}), ...(flavour !== null && flavour !== void 0 ? flavour : {}) };
+    for (const key of ["anim", "animation"]) {
+        if (isRecord(out[key]))
+            out[key] = { ...out[key], reduceMotion: true };
+    }
+    if (typeof out.animate === "boolean")
+        out.animate = false;
+    return out;
+}

package/dist/m0saic/brand/business-card/v1/business-card.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ============================================================================
+ * @m0saic/brand/business-card/v1 — the m0saic business card, print-ready
+ * ============================================================================
+ *
+ * A double-sided US business card (3.5 x 2 in) rendered at press resolution.
+ * One render emits TWO PNG stills as an `emit: "multi"` pipeline — the CLI
+ * writes `<out>-front.png` and `<out>-back.png`; Make previews both faces.
+ *
+ *   FRONT — the brand surface: the Home-screen tile field cover-fit across the
+ *           bleed canvas, the M + wordmark lockup, then name / role and the
+ *           contact lines in the product's mono face.
+ *   BACK  — one shipped template (the `back` knob), rendered LIVE as a nested
+ *           child with its motion frozen, beside a QR that opens it on Mosaic
+ *           Web (`app.m0saic.io/make?t=<id>`), the site's typeable link
+ *           (`m0saic.io/t/<pack>/<slug>/<vN>`) and the `npx` one-liner.
+ *
+ * Print discipline lives in `layout.ts`: inches × dpi, trim centred on a
+ * bleed canvas (MOO's 3.66 x 2.16 in box by default — 1098 x 648 px at 300
+ * DPI, exact; 1/8 in for FedEx Office / Staples, 1/16 in for Vistaprint),
+ * a 1/8 in safe area, MOO's 8 pt type floor (the back's `npx` line is the one
+ * exception: every card prints it at the size the LONGEST catalog command
+ * fits), even lattice-friendly canvas edges.
+ * The engine writes no DPI metadata — tag the PNGs at 300 DPI before upload
+ * (`sips -s dpiWidth 300 -s dpiHeight 300 …` or sharp's `withMetadata`).
+ *
+ * Everything is real geometry (the Rect Thesis): field tiles, the glyph
+ * masks, every text line, the poster and QR cells are m0 cells laundered
+ * through `placeInsetPieces` — zero drift, bounded precision.
+ * ============================================================================
+ */
+import type { MosaicColor, MosaicTemplate } from "@m0saic/types";
+import { type LayoutConstraint } from "@m0saic/template-utils";
+import { type BackKey } from "./back-catalog";
+import { type Bleed, type CardCanvas } from "./layout";
+export type BusinessCardProps = {
+    /** Name — the bold line. */
+    name?: string;
+    /** Role / company line under the name. Empty = none. */
+    role?: string;
+    /** Email (mono). Empty = none. */
+    email?: string;
+    /** Website (mono). Empty = none. */
+    site?: string;
+    /** Social handle (mono, beside the site). Empty = none. */
+    handle?: string;
+    /** Which shipped template the back shows. */
+    back?: BackKey;
+    /** Printer bleed per side: MOO's 0.08 in box (default), none (trim only), 1/16 in, 1/8 in. */
+    bleed?: Bleed;
+    /** Print resolution; the whole card scales with it. Default 300. */
+    dpi?: number;
+    /** Field tile tint over the navy (Home uses 0.16; print wants more). */
+    fieldOpacity?: number;
+    /** Accent — the M and the wordmark's zero. */
+    accent?: MosaicColor;
+    /** Draw the trim and safe-area outlines (proofing only). */
+    guides?: boolean;
+    /** Dev-only: check the layout contract (marks keep their aspect, the back's template keeps ITS aspect, everything inside the safe area). */
+    debugLayout?: boolean;
+};
+/**
+ * The layout contract — label-keyed, canvas-independent, shared by `render`
+ * (`debugLayout`) and the gate test's canvas sweep. Every glyph/mark on a face
+ * must stay inside the safe area; the marks keep their aspect; and on the
+ * back the NESTED TEMPLATE keeps ITS OWN aspect (the cell is cut to the
+ * child's canvas, so a stretched poster is a contract violation, not a
+ * render surprise).
+ */
+export declare function businessCardConstraints(face: "front" | "back", c: CardCanvas, present: {
+    labels: readonly string[];
+    posterAspect?: number;
+}): LayoutConstraint[];
+/**
+ * The smallest QR version that encodes `text` with the template's carve
+ * (ECC H + the centre safe area). The QR template pins a cutout to version
+ * 6 exactly (~58 bytes of URL); a long template id overflows it and renders
+ * an error card. Same encoder, same arguments — so what fits here fits there.
+ */
+export declare function pickQrVersion(text: string, moduleColor: MosaicColor): number;
+export declare const BusinessCard: MosaicTemplate<BusinessCardProps>;
+export default BusinessCard;