@m0saic/templates 0.2.0

package/dist/m0saic/benchmark/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* Benchmark runner (capability tier) — renders the frozen workload battery and
+   writes a shareable benchmark.json session. */
+__exportStar(require("./run/v1"), exports);
+/* Benchmark report (core tier) — reads a benchmark.json session and renders the
+   standard shareable results dashboard video. */
+__exportStar(require("./report/v1"), exports);

package/dist/m0saic/benchmark/report/v1/assets/sample-session/benchmark.json

@@ -0,0 +1,41 @@
+{
+  "schemaVersion": 1,
+  "label": "idle",
+  "startedAtIso": "2026-06-18T00:00:00.000Z",
+  "finishedAtIso": "2026-06-18T00:02:11.000Z",
+  "elapsedMs": 131000,
+  "system": {
+    "cpu": { "model": "Apple M1", "cores": 8, "speedMhz": 2400 },
+    "ram": { "totalBytes": 8589934592, "totalGb": 8 },
+    "os": { "platform": "darwin", "arch": "arm64", "release": "23.6.0" },
+    "ffmpeg": {
+      "found": true,
+      "version": "ffmpeg version 8.0.1 Copyright (c) 2000-2025 the FFmpeg developers",
+      "hwEncoders": ["h264_videotoolbox", "hevc_videotoolbox", "prores_videotoolbox"]
+    }
+  },
+  "versions": { "cli": { "name": "m0saic-cli", "version": "0.1.0" } },
+  "sets": [
+    { "set": "sources", "version": 2, "scenarioIds": ["sources-lavfi", "sources-text", "sources-nested", "sources-ref", "sources-media", "sources-audio"] },
+    { "set": "geometry", "version": 1, "scenarioIds": ["geometry-grid"] },
+    { "set": "duration", "version": 1, "scenarioIds": ["duration-long"] },
+    { "set": "encoders", "version": 1, "scenarioIds": ["encoders-libopenh264", "encoders-libx264", "encoders-libx265"] }
+  ],
+  "scenarios": [
+    { "id": "sources-lavfi", "set": "sources", "label": "Lavfi generators", "ok": true, "elapsedMs": 4544, "outFps": 52.8, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libopenh264" },
+    { "id": "sources-text", "set": "sources", "label": "Text rasterization", "ok": true, "elapsedMs": 6039, "outFps": 39.7, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libopenh264" },
+    { "id": "sources-nested", "set": "sources", "label": "Nested mosaic", "ok": true, "elapsedMs": 4331, "outFps": 55.4, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libopenh264" },
+    { "id": "sources-ref", "set": "sources", "label": "Ref mirror", "ok": true, "elapsedMs": 2815, "outFps": 85.3, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libopenh264" },
+    { "id": "sources-media", "set": "sources", "label": "Video decode (4 clips)", "ok": true, "elapsedMs": 2755, "outFps": 43.6, "frames": 120, "width": 1920, "height": 1080, "durationMs": 4000, "fps": 30, "codec": "libx264" },
+    { "id": "sources-audio", "set": "sources", "label": "Audio + video", "ok": true, "elapsedMs": 2391, "outFps": 100.4, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libx264" },
+    { "id": "geometry-grid", "set": "geometry", "label": "144-cell grid", "ok": true, "elapsedMs": 31521, "outFps": 7.6, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libopenh264" },
+    { "id": "duration-long", "set": "duration", "label": "60s render", "ok": true, "elapsedMs": 32810, "outFps": 54.9, "frames": 1800, "width": 1920, "height": 1080, "durationMs": 60000, "fps": 30, "codec": "libopenh264" },
+    { "id": "encoders-libopenh264", "set": "encoders", "label": "libopenh264 (sw baseline)", "ok": true, "elapsedMs": 2000, "outFps": 120, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libopenh264" },
+    { "id": "encoders-libx264", "set": "encoders", "label": "libx264 (sw)", "ok": true, "elapsedMs": 2637, "outFps": 91, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libx264" },
+    { "id": "encoders-libx265", "set": "encoders", "label": "libx265 (sw)", "ok": true, "elapsedMs": 3227, "outFps": 74.4, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "libx265" },
+    { "id": "encoders-h264_videotoolbox", "set": "encoders", "label": "h264_videotoolbox (hw)", "ok": true, "elapsedMs": 2111, "outFps": 113.7, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "h264_videotoolbox" },
+    { "id": "encoders-hevc_videotoolbox", "set": "encoders", "label": "hevc_videotoolbox (hw)", "ok": true, "elapsedMs": 1935, "outFps": 124, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "hevc_videotoolbox" },
+    { "id": "encoders-prores_videotoolbox", "set": "encoders", "label": "prores_videotoolbox (hw)", "ok": true, "elapsedMs": 2085, "outFps": 115.1, "frames": 240, "width": 1920, "height": 1080, "durationMs": 8000, "fps": 30, "codec": "prores_videotoolbox" }
+  ],
+  "summary": { "totalElapsedMs": 103201, "scoreVersion": 1, "score": 47.4 }
+}

package/dist/m0saic/benchmark/report/v1/index.d.ts

@@ -0,0 +1 @@
+export * from "./report";

package/dist/m0saic/benchmark/report/v1/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./report"), exports);

package/dist/m0saic/benchmark/report/v1/report.d.ts

@@ -0,0 +1,23 @@
+import type { MosaicTemplate } from "@m0saic/types";
+/**
+ * @m0saic/benchmark/report/v1 — the packager.
+ *
+ * Reads a benchmark session's `benchmark.json` (written by
+ * @m0saic/benchmark/run/v1) and renders the STANDARD shareable results video:
+ * a machine-specs header, three headline KPIs, and a per-scenario render-time
+ * bar chart. KPIs and the chart are COMPOSED from the existing
+ * `@m0saic/charts/stat-card/v1` and `@m0saic/charts/bar-graph/v1` templates
+ * (reuse, not reinvention) — only the specs header is template-specific text.
+ * Deterministic given the session file.
+ */
+export type BenchmarkReportProps = {
+    /** Session folder (or path to a benchmark.json). Default: current directory. */
+    dir: string;
+    /**
+     * Animation length as a fraction of the video duration (0.1–1). Drives BOTH
+     * the KPI count-up and the bar growth — they're a single linked intro — then
+     * the rest of the video holds the final frame.
+     */
+    introFrac?: number;
+};
+export declare const BenchmarkReport: MosaicTemplate<BenchmarkReportProps>;

package/dist/m0saic/benchmark/report/v1/report.js

@@ -0,0 +1,242 @@
+"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.BenchmarkReport = 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 dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    dir: {
+        type: "string",
+        required: false,
+        description: "Benchmark session folder to report on (the dir written by the benchmark runner). May also point directly at a benchmark.json.",
+        meta: { control: { picker: "folder" }, ui: { label: "Session folder", order: 1 } },
+    },
+    introFrac: {
+        type: "number",
+        required: false,
+        description: "Animation length as a fraction of the video duration. One slider drives both the KPI count-up and the bar growth (they're linked); the rest of the video holds.",
+        meta: {
+            constraints: { min: 0.1, max: 1 },
+            control: { flavor: "slider", step: 0.05 },
+            ui: { label: "Animation length (× duration)", order: 2 },
+        },
+    },
+});
+const BG = "#000000";
+const CARD_BG = "#0a0a0a";
+const ACCENT = "#f97316"; // m0saic brand orange
+function resolveBenchmarkJson(input) {
+    const toJson = (p) => (p.toLowerCase().endsWith(".json") ? p : path.join(p, "benchmark.json"));
+    const candidates = [];
+    if (path.isAbsolute(input)) {
+        candidates.push(toJson(input));
+    }
+    else {
+        let dir = process.cwd();
+        for (;;) {
+            candidates.push(toJson(path.resolve(dir, input)));
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    for (const c of candidates) {
+        try {
+            if (fs.existsSync(c) && fs.statSync(c).isFile())
+                return c;
+        }
+        catch {
+            /* keep looking */
+        }
+    }
+    return null;
+}
+function formatMs(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    return `${Math.floor(s / 60)}m ${s % 60}s`;
+}
+function shortFfmpeg(version) {
+    var _a;
+    const m = version.match(/version\s+(\S+)/i);
+    return m ? m[1] : (_a = version.split(/\s+/)[0]) !== null && _a !== void 0 ? _a : version;
+}
+const color = (c) => c;
+/** A solid-background cell with vertically-stacked, centered text lines. */
+function textCell(lines, bg) {
+    const n = lines.length;
+    const gap = Math.round(Math.max(...lines.map((l) => l.size)) * 1.35);
+    const layers = lines.map((ln, i) => {
+        var _a;
+        const offset = i - (n - 1) / 2;
+        return {
+            content: { kind: "literal", text: ln.text },
+            style: { fontSize: ln.size, fontColor: color((_a = ln.color) !== null && _a !== void 0 ? _a : "#e8eef9"), fontFamily: "Arial" },
+            placement: { hAlign: "center", vAlign: "middle", yExpr: `(h-text_h)/2 + (${offset}) * ${gap}` },
+        };
+    });
+    return { type: "text", layers, visual: { backgroundColor: color(bg) }, renderMode: { kind: "image" } };
+}
+const headerLine = (text, size, c) => textCell([{ text, size, color: c }], BG);
+exports.BenchmarkReport = {
+    id: (0, types_1.asTemplateId)("@m0saic/benchmark/report/v1"),
+    label: "Benchmark — Report",
+    version: 1,
+    description: "Renders the standard shareable benchmark results video from a session's benchmark.json: machine-specs header, score / total-time / scenarios KPIs (stat-card), and a per-scenario render-time bar chart (bar-graph). Pair with the benchmark runner.",
+    capabilities: { tier: "core" },
+    tags: ["developer", "benchmark", "report", "dashboard", "performance", "developers", "animated"],
+    outputHints: {
+        width: 1920,
+        height: 1080,
+        fps: 30,
+        durationMs: 6000,
+        format: { kind: "video", container: "mp4" },
+    },
+    propsSchema,
+    defaultProps: { dir: ".", introFrac: 0.6 },
+    async render(props, ctx) {
+        var _a, _b, _c;
+        const W = ctx.target.width;
+        const H = ctx.target.height;
+        const durationMs = ctx.target.durationMs;
+        const errOpts = { width: W, height: H, title: "Benchmark Report" };
+        const jsonPath = resolveBenchmarkJson((_a = props.dir) !== null && _a !== void 0 ? _a : ".");
+        if (!jsonPath) {
+            return (0, template_utils_1.makeErrorMosaic)("No benchmark.json found. Point me at a benchmark session folder (the dir written by @m0saic/benchmark/run/v1).", errOpts);
+        }
+        let session;
+        try {
+            session = JSON.parse(fs.readFileSync(jsonPath, "utf8"));
+        }
+        catch (err) {
+            return (0, template_utils_1.makeErrorMosaic)(`Failed to read ${jsonPath}: ${err instanceof Error ? err.message : String(err)}`, errOpts);
+        }
+        const scen = (_b = session.scenarios) !== null && _b !== void 0 ? _b : [];
+        if (scen.length === 0)
+            return (0, template_utils_1.makeErrorMosaic)(`No scenarios in ${jsonPath}.`, errOpts);
+        // ── Header (3 lines of specs text) ──
+        const sys = session.system;
+        const hw = sys.ffmpeg.hwEncoders.length ? sys.ffmpeg.hwEncoders.join(", ") : "none";
+        const titleCell = headerLine(`m0saic benchmark · ${session.label}`, Math.round(W / 26), "#e8eef9");
+        const specsCell = headerLine(`${sys.cpu.model} · ${sys.cpu.cores} cores · ${sys.ram.totalGb} GB`, Math.round(W / 56), "#aab6d6");
+        const envCell = headerLine(`${sys.os.platform} ${sys.os.arch} · ffmpeg ${shortFfmpeg(sys.ffmpeg.version)} · hw: ${hw}`, Math.round(W / 72), "#8794b8");
+        // ── KPIs: reuse @m0saic/charts/stat-card/v1 ──
+        // Shared intro window so the KPI count-up and the bar growth start together
+        // at t=0 and run over the same duration — one slider (introFrac) drives both.
+        const introFrac = Math.min(1, Math.max(0.1, (_c = props.introFrac) !== null && _c !== void 0 ? _c : 0.6));
+        const introMs = Math.max(500, Math.round(durationMs * introFrac));
+        const okCount = scen.filter((s) => s.ok).length;
+        const kpiSlot = { width: Math.round(W * 0.29), height: Math.round(H * 0.2), durationMs };
+        const statCard = (label, value, sublabel) => (0, template_utils_1.renderNestedTemplate)("@m0saic/charts/stat-card/v1", { label, value, sublabel, delta: "", backgroundColor: CARD_BG, anim: { countUp: true, slideIn: true, introMs } }, ctx, { slot: kpiSlot });
+        const [kpiScore, kpiTime, kpiOk] = await Promise.all([
+            statCard("Score", `${session.summary.score}`, "higher is faster"),
+            statCard("Total render time", formatMs(session.summary.totalElapsedMs), session.label),
+            statCard("Scenarios ok", `${okCount}/${scen.length}`, `${scen.length} workloads`),
+        ]);
+        // ── Per-scenario render-time bars: reuse @m0saic/charts/bar-graph/v1 ──
+        // Cheap cost-scaling view: for a HEAVY session (captured real templates at
+        // several durations), color each bar by its source template so each
+        // workload's duration series reads as one colored cluster — its cost curve.
+        // Standard sessions stay single-accent. (A real line chart is a separate,
+        // not-yet-built template.)
+        const heavy = scen.some((s) => s.templateIds && s.templateIds.length > 0);
+        const BAR_PALETTE = ["#f97316", "#43c59e", "#a78bfa", "#60a5fa", "#f6c177", "#eb6f92"];
+        const groupKeys = [];
+        const barColors = scen.map((s) => {
+            const k = (s.templateIds && s.templateIds[0]) || s.set;
+            let i = groupKeys.indexOf(k);
+            if (i < 0) {
+                i = groupKeys.length;
+                groupKeys.push(k);
+            }
+            return BAR_PALETTE[i % BAR_PALETTE.length];
+        });
+        const bars = await (0, template_utils_1.renderNestedTemplate)("@m0saic/charts/bar-graph/v1", {
+            values: scen.map((s) => { var _a; return Math.round((((_a = s.elapsedMs) !== null && _a !== void 0 ? _a : 0) / 1000) * 10) / 10; }),
+            labels: scen.map((s) => s.label),
+            orientation: "horizontal",
+            preset: "terminal", // near-black card to match the black theme
+            barColor: heavy ? barColors : ACCENT,
+            valueLabels: { show: true, format: "raw", decimals: 1, suffix: "s" },
+            grid: { show: false },
+            valueAxis: { show: false },
+            baseline: { show: false }, // drop the zero-line strip (it renders with a small gap before the bars)
+            // Same intro window as the KPIs: start at t=0, run for introMs, tiny stagger.
+            anim: { intro: { durationSec: introMs / 1000, delaySec: 0, staggerSec: 0.02, ease: "smoothstep" }, reduceMotion: false },
+        }, ctx, { slot: { width: W, height: Math.round(H * 0.58), durationMs } });
+        // ── Mosaic M logo stamp (bundled brand-orange PNG, left of the KPI row).
+        //    A baked PNG (1 cheap image input) — far lighter than nesting the
+        //    rect-based logo template, which mints dozens of sub-renders. ──
+        const logoSource = {
+            type: "media",
+            mediaType: "image",
+            assetId: "mlogo",
+            placement: { fit: "contain" },
+        };
+        const logoAsset = (0, assetPath_1.fileAsset)(path.resolve(__dirname, "assets"), "m-logo.png", "image");
+        // ── Layout: header band (3 rows) / KPI band (M + 3 cards) / bars band ──
+        const headerM0 = (0, dsl_stdlib_1.weightedSplit)([38, 30, 32], "row");
+        const kpiBandM0 = (0, dsl_stdlib_1.weightedSplit)([13, 29, 29, 29], "col");
+        const m0 = (0, dsl_stdlib_1.weightedSplit)([22, 20, 58], "row", { claimants: [headerM0, kpiBandM0, "1"] });
+        return {
+            kind: "mosaic_document",
+            version: 1,
+            assets: { mlogo: logoAsset },
+            m0,
+            sources: [
+                titleCell,
+                specsCell,
+                envCell,
+                logoSource,
+                { type: "mosaic", ref: "kpi-score" },
+                { type: "mosaic", ref: "kpi-time" },
+                { type: "mosaic", ref: "kpi-ok" },
+                { type: "mosaic", ref: "bars" },
+            ],
+            children: { "kpi-score": kpiScore, "kpi-time": kpiTime, "kpi-ok": kpiOk, bars },
+            backgroundColor: color(BG),
+            fps: ctx.target.fps,
+            durationMs,
+            size: { width: W, height: H },
+        };
+    },
+};
+(0, template_utils_1.registerTemplate)(exports.BenchmarkReport);

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

@@ -0,0 +1,57 @@
+import type { BenchmarkScenarioResult, BenchmarkSession, BenchmarkSet, BenchmarkSystemInfo } from "@m0saic/types";
+/**
+ * Pure orchestration for a benchmark run. Side effects (spawning renders, the
+ * clock, the filesystem) are injected so this module is deterministic and
+ * unit-testable; the template (`runner.ts`) wires the real implementations.
+ */
+/** A scenario resolved for execution. `file` is the bare battery filename. */
+export type ResolvedScenario = {
+    id: string;
+    set: BenchmarkSet;
+    label: string;
+    file: string;
+    codec?: string;
+    templateIds?: string[];
+    /** Render-duration override (ms) for `make --durationMs`. */
+    durationMs?: number;
+};
+/** What an executor reports back after rendering one scenario. */
+export type ScenarioMeasurement = {
+    ok: boolean;
+    /** Render wall-clock from the scenario's `--report` sidecar (`run.elapsedMs`). */
+    elapsedMs: number | null;
+    width: number | null;
+    height: number | null;
+    fps: number | null;
+    durationMs: number | null;
+    codec: string | null;
+    /** Toolchain/package versions snapshot from the report (`report.versions`). */
+    versions?: Record<string, unknown>;
+    error?: string;
+};
+export type ScenarioExecutor = (s: ResolvedScenario) => Promise<ScenarioMeasurement>;
+/** The sets that actually have shipped workloads (a declared content version). */
+export declare const AVAILABLE_SETS: BenchmarkSet[];
+/**
+ * Resolve the workloads to run for the selected sets. Frozen workloads come
+ * straight from the manifest; the `encoders` set is additionally expanded with
+ * the host's detected hardware encoders (those are machine-dependent and so are
+ * NOT part of any frozen set version).
+ */
+export declare function selectScenarios(tests: BenchmarkSet[], hwEncoders: string[]): ResolvedScenario[];
+/** Run each scenario through the executor (sequentially — they compete for the CPU). */
+export declare function runScenarios(scenarios: ResolvedScenario[], exec: ScenarioExecutor): Promise<{
+    results: BenchmarkScenarioResult[];
+    versions?: Record<string, unknown>;
+}>;
+/** Assemble the final, shareable session object from measured results. */
+export declare function assembleSession(input: {
+    label: string;
+    systemInfo: BenchmarkSystemInfo;
+    results: BenchmarkScenarioResult[];
+    selectedSets: BenchmarkSet[];
+    startedAtIso: string;
+    finishedAtIso: string;
+    elapsedMs: number;
+    versions?: Record<string, unknown>;
+}): BenchmarkSession;

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AVAILABLE_SETS = void 0;
+exports.selectScenarios = selectScenarios;
+exports.runScenarios = runScenarios;
+exports.assembleSession = assembleSession;
+const types_1 = require("@m0saic/types");
+const manifest_1 = require("../../battery/manifest");
+const ALL_SETS = [
+    "sources",
+    "real",
+    "geometry",
+    "duration",
+    "encoders",
+    "sloth",
+];
+/** The sets that actually have shipped workloads (a declared content version). */
+exports.AVAILABLE_SETS = ALL_SETS.filter((s) => manifest_1.BENCHMARK_SET_VERSIONS[s] != null);
+function framesOf(durationMs, fps) {
+    if (durationMs == null || fps == null)
+        return null;
+    return Math.round((durationMs / 1000) * fps);
+}
+function outFpsOf(frames, elapsedMs) {
+    if (frames == null || !elapsedMs)
+        return null;
+    return Math.round((frames / (elapsedMs / 1000)) * 10) / 10;
+}
+/**
+ * Resolve the workloads to run for the selected sets. Frozen workloads come
+ * straight from the manifest; the `encoders` set is additionally expanded with
+ * the host's detected hardware encoders (those are machine-dependent and so are
+ * NOT part of any frozen set version).
+ */
+function selectScenarios(tests, hwEncoders) {
+    const wanted = new Set(tests);
+    const resolved = manifest_1.BENCHMARK_BATTERY.filter((s) => wanted.has(s.set)).map((s) => ({
+        id: s.id,
+        set: s.set,
+        label: s.label,
+        file: s.file,
+        ...(s.codec ? { codec: s.codec } : {}),
+        ...(s.templateIds ? { templateIds: s.templateIds } : {}),
+        ...(s.durationMs ? { durationMs: s.durationMs } : {}),
+    }));
+    if (wanted.has("encoders") && hwEncoders.length > 0) {
+        const base = manifest_1.BENCHMARK_BATTERY.find((s) => s.set === "encoders");
+        if (base) {
+            for (const enc of hwEncoders) {
+                resolved.push({
+                    id: `encoders-${enc}`,
+                    set: "encoders",
+                    label: `${enc} (hw)`,
+                    file: base.file,
+                    codec: enc,
+                });
+            }
+        }
+    }
+    return resolved;
+}
+/** Run each scenario through the executor (sequentially — they compete for the CPU). */
+async function runScenarios(scenarios, exec) {
+    var _a;
+    const results = [];
+    let versions;
+    for (const s of scenarios) {
+        let m;
+        try {
+            m = await exec(s);
+        }
+        catch (err) {
+            m = {
+                ok: false,
+                elapsedMs: null,
+                width: null,
+                height: null,
+                fps: null,
+                durationMs: null,
+                codec: (_a = s.codec) !== null && _a !== void 0 ? _a : null,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        if (!versions && m.versions)
+            versions = m.versions;
+        const frames = framesOf(m.durationMs, m.fps);
+        results.push({
+            id: s.id,
+            set: s.set,
+            label: s.label,
+            ...(s.templateIds ? { templateIds: s.templateIds } : {}),
+            ok: m.ok,
+            elapsedMs: m.elapsedMs,
+            outFps: outFpsOf(frames, m.elapsedMs),
+            frames,
+            width: m.width,
+            height: m.height,
+            durationMs: m.durationMs,
+            fps: m.fps,
+            codec: m.codec,
+            ...(m.error ? { error: m.error } : {}),
+        });
+    }
+    return { results, versions };
+}
+/** Per-set content-version records for the sets that actually ran. */
+function buildSetDefs(selectedSets) {
+    const defs = [];
+    for (const set of selectedSets) {
+        const version = manifest_1.BENCHMARK_SET_VERSIONS[set];
+        if (version == null)
+            continue; // set has no shipped workloads
+        const scenarioIds = manifest_1.BENCHMARK_BATTERY.filter((s) => s.set === set).map((s) => s.id);
+        if (scenarioIds.length === 0)
+            continue;
+        defs.push({ set, version, scenarioIds });
+    }
+    return defs;
+}
+/** Aggregate frames-per-second across all successful scenarios (the "score"). */
+function aggregateFps(results) {
+    let frames = 0;
+    let ms = 0;
+    for (const r of results) {
+        if (r.ok && r.frames != null && r.elapsedMs) {
+            frames += r.frames;
+            ms += r.elapsedMs;
+        }
+    }
+    return ms > 0 ? Math.round((frames / (ms / 1000)) * 10) / 10 : 0;
+}
+/** Assemble the final, shareable session object from measured results. */
+function assembleSession(input) {
+    const totalElapsedMs = input.results.reduce((sum, r) => sum + (r.ok && r.elapsedMs ? r.elapsedMs : 0), 0);
+    return {
+        schemaVersion: types_1.BENCHMARK_SESSION_SCHEMA_VERSION,
+        label: input.label,
+        startedAtIso: input.startedAtIso,
+        finishedAtIso: input.finishedAtIso,
+        elapsedMs: input.elapsedMs,
+        system: input.systemInfo,
+        ...(input.versions ? { versions: input.versions } : {}),
+        sets: buildSetDefs(input.selectedSets),
+        scenarios: input.results,
+        summary: {
+            totalElapsedMs,
+            scoreVersion: 1,
+            score: aggregateFps(input.results),
+        },
+    };
+}

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

@@ -0,0 +1,11 @@
+import type { MosaicDocument, MosaicEngineContext } from "@m0saic/types";
+/**
+ * The runner's own render output — a small two-row card (title + detail). Used
+ * both for the post-run confirmation and the preview/lite stand-in. Text wraps
+ * to the canvas width so long instruction lines never clip.
+ */
+export declare function buildConfirmationDoc(opts: {
+    titleLine: string;
+    subLine: string;
+    ctx: MosaicEngineContext;
+}): MosaicDocument;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfirmationDoc = buildConfirmationDoc;
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const template_utils_1 = require("@m0saic/template-utils");
+function clamp(n, lo, hi) {
+    return Math.max(lo, Math.min(hi, n));
+}
+/**
+ * A centered, word-wrapped text tile on a solid background (image-rasterized).
+ * The mosaic text renderer has no soft-wrap, so long lines are pre-broken into
+ * one layer per line via `multilineTextLayers` to avoid clipping off the cell.
+ */
+function textTile(text, fontSize, bg, cellWidth) {
+    // Coarse chars-per-line for this cell at this font size (see wrapText docs).
+    const maxChars = Math.max(8, Math.floor(cellWidth / (fontSize * 0.55)));
+    return {
+        type: "text",
+        style: { fontSize, fontColor: "#ffffff", fontFamily: "Arial" },
+        layers: (0, template_utils_1.multilineTextLayers)({ text, maxCharsPerLine: maxChars, fontSize }),
+        visual: { backgroundColor: bg },
+        renderMode: { kind: "image" },
+    };
+}
+/**
+ * The runner's own render output — a small two-row card (title + detail). Used
+ * both for the post-run confirmation and the preview/lite stand-in. Text wraps
+ * to the canvas width so long instruction lines never clip.
+ */
+function buildConfirmationDoc(opts) {
+    const { ctx } = opts;
+    const W = ctx.target.width;
+    const titleFont = clamp(Math.round(W / 26), 28, 80);
+    const subFont = clamp(Math.round(W / 46), 18, 44);
+    return {
+        kind: "mosaic_document",
+        version: 1,
+        m0: (0, dsl_stdlib_1.equalSplit)(2, "row"),
+        assets: {},
+        fps: ctx.target.fps,
+        durationMs: ctx.target.durationMs,
+        size: { width: ctx.target.width, height: ctx.target.height },
+        sources: [
+            textTile(opts.titleLine, titleFont, "#0b1020", W),
+            textTile(opts.subLine, subFont, "#11162a", W),
+        ],
+    };
+}

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

@@ -0,0 +1 @@
+export * from "./runner";

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

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./runner"), exports);