@m0saic/templates 0.2.0

package/dist/gen-geometry-matrix.d.ts

@@ -0,0 +1 @@
+import "./m0saic";

package/dist/gen-geometry-matrix.js

@@ -0,0 +1,177 @@
+"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 GEOMETRY-MATRIX.md — the curated intent-vs-realized sweep.
+ *
+ * For every registered template that ADOPTS the geometry contract (its props
+ * schema exposes `debugGeometry`), resolve `defaultProps + debugGeometry:true`
+ * at each canvas in the principled tier set (composition-arithmetic §2:
+ * modern-core / adjacent / hostile + the template's own outputHints), read the
+ * stamped `editor.geometryContract` (resolve + parse only — NO ffmpeg), and
+ * report ok / violations (kind · piece · axis · Δpx) / floors with a §3c routing
+ * hint per failure.
+ *
+ * Deterministic: renders `defaultProps` (no wall-clock/random) with the debug
+ * gate on. Run: `npm run audit:geometry-matrix`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const template_utils_1 = require("@m0saic/template-utils");
+const geometry_audit_1 = require("./geometry-audit");
+require("./m0saic"); // side-effect: register every template
+const ROOT = path.resolve(__dirname, "..");
+const OUT = path.join(ROOT, "GEOMETRY-MATRIX.md");
+function ctxFor(w, h) {
+    const t = { width: w, height: h, fps: 30, durationMs: 2000 };
+    return { mode: "render", target: t, output: { ...t, workspaceDir: "/tmp/geom-matrix" }, media: {} };
+}
+/** A template adopts the contract iff its props schema exposes `debugGeometry`. */
+function adoptsContract(tpl) {
+    const schema = tpl.propsSchema;
+    return !!schema && "debugGeometry" in schema;
+}
+async function stampAt(tpl, w, h) {
+    var _a, _b, _c;
+    try {
+        const doc = (await tpl.render({ ...((_a = tpl.defaultProps) !== null && _a !== void 0 ? _a : {}), debugGeometry: true }, ctxFor(w, h)));
+        const stamp = (_b = doc === null || doc === void 0 ? void 0 : doc.editor) === null || _b === void 0 ? void 0 : _b.geometryContract;
+        if (!stamp)
+            return { error: "no geometryContract stamp (debug gate not plumbed?)" };
+        return { stamp };
+    }
+    catch (e) {
+        return { error: String((_c = e === null || e === void 0 ? void 0 : e.message) !== null && _c !== void 0 ? _c : e).slice(0, 120) };
+    }
+}
+function anchor(id) {
+    return id.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function violationLine(stamp) {
+    if (stamp.ok)
+        return "✓";
+    return stamp.violations
+        .slice(0, 3)
+        .map((v) => `${v.kind}${v.axis ? `/${v.axis}` : ""}${v.name ? ` \`${v.name}\`` : ""}${v.deltaPx != null ? ` Δ${v.deltaPx}px` : ""}`)
+        .join("; ") + (stamp.violations.length > 3 ? ` …+${stamp.violations.length - 3}` : "");
+}
+function floorsCell(stamp) {
+    const f = stamp.floors;
+    const spread = f.maxSpreadPx === Infinity ? "∞" : f.maxSpreadPx.toFixed(1);
+    return `${f.feasible ? "feas" : "**INFEAS**"} · ${f.meetsPrecision ? "prec" : "sub-prec"} · spread ${spread}`;
+}
+async function main() {
+    const ids = (0, template_utils_1.listRegisteredTemplateIds)()
+        .map(String)
+        .filter((id) => {
+        const t = (0, template_utils_1.getTemplate)(id);
+        return !!t && !t.deprecated && adoptsContract(t);
+    })
+        .sort();
+    const perTemplate = [];
+    for (const id of ids) {
+        const tpl = (0, template_utils_1.getTemplate)(id);
+        const outputHints = tpl.outputHints;
+        const cells = [];
+        for (const c of (0, geometry_audit_1.matrixCanvases)(outputHints)) {
+            process.stderr.write(`[geometry-matrix] ${id} @ ${c.w}×${c.h} …\n`);
+            const { stamp, error } = await stampAt(tpl, c.w, c.h);
+            cells.push({ w: c.w, h: c.h, tier: c.tier, hostile: (0, geometry_audit_1.isHostileCanvas)(c.w, c.h), stamp, error });
+        }
+        const failCount = cells.filter((c) => c.error || (c.stamp && !c.stamp.ok)).length;
+        perTemplate.push({ id, cells, failCount });
+    }
+    const out = [];
+    out.push("# Template geometry matrix\n");
+    out.push("> Auto-generated by `gen-geometry-matrix` (do NOT edit by hand). For every " +
+        "template that ADOPTS the geometry contract (props schema exposes " +
+        "`debugGeometry`), resolves `defaultProps + debugGeometry:true` at the " +
+        "principled canvas tiers (composition-arithmetic §2) and reads the stamped " +
+        "`editor.geometryContract` — resolve + parse only, NO ffmpeg. A green row " +
+        "means every computed rect survived to the pixels at that canvas. Hostile " +
+        "canvases (primes / coprime pairs) degrade to EXACT placement — the " +
+        "contract still holds. See the internal template-geometry-contract notes.\n");
+    const withFails = perTemplate.filter((t) => t.failCount > 0);
+    out.push(`## ⚠ Violations (${withFails.length} template${withFails.length === 1 ? "" : "s"})\n`);
+    if (withFails.length === 0) {
+        out.push(`_None — all ${perTemplate.length} adopting template(s) hold at every canvas._\n`);
+    }
+    else {
+        out.push("| template | failing canvases |");
+        out.push("|---|---|");
+        for (const t of withFails)
+            out.push(`| [\`${t.id}\`](#${anchor(t.id)}) | ${t.failCount} |`);
+        out.push("");
+    }
+    out.push(`**${perTemplate.length} adopting template(s) swept.**\n`);
+    for (const t of perTemplate) {
+        out.push(`### ${t.id}\n`);
+        out.push(`- ${t.failCount === 0 ? "**all canvases hold** ✓" : `**${t.failCount} canvas(es) violate**`}\n`);
+        out.push("| canvas | tier | result | floors |");
+        out.push("|---|---|---|---|");
+        for (const c of t.cells) {
+            const result = c.error ? `⚠ ${c.error}` : violationLine(c.stamp);
+            const floors = c.error ? "—" : floorsCell(c.stamp);
+            out.push(`| ${c.w}×${c.h}${c.hostile ? " ¹" : ""} | ${c.tier} | ${result} | ${floors} |`);
+        }
+        out.push("");
+        // Routing hints for the distinct failing kinds.
+        const kinds = new Map(); // kind → allHostile
+        for (const c of t.cells) {
+            if (!c.stamp || c.stamp.ok)
+                continue;
+            for (const v of c.stamp.violations) {
+                const prev = kinds.get(v.kind);
+                kinds.set(v.kind, prev === undefined ? c.hostile : prev && c.hostile);
+            }
+        }
+        if (kinds.size > 0) {
+            out.push("**Routing:**\n");
+            for (const [kind, allHostile] of kinds)
+                out.push(`- \`${kind}\` → ${(0, geometry_audit_1.routingHint)(kind, allHostile)}`);
+            out.push("");
+        }
+    }
+    out.push("_¹ hostile canvas (prime / coprime axis) — degradation to exact placement is expected; the contract still asserts the exact intent._\n");
+    fs.writeFileSync(OUT, out.join("\n") + "\n", "utf8");
+    const totalFails = perTemplate.reduce((a, t) => a + t.failCount, 0);
+    // eslint-disable-next-line no-console
+    console.log(`[geometry-matrix] wrote ${path.relative(ROOT, OUT)} — ${perTemplate.length} template(s), ${totalFails} failing cell(s)`);
+}
+main().catch((e) => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exit(1);
+});

package/dist/gen-geometry-proof.d.ts

@@ -0,0 +1 @@
+import "./m0saic";

package/dist/gen-geometry-proof.js

@@ -0,0 +1,259 @@
+"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 });
+/**
+ * gen-geometry-proof — the sloth-tier, one-template EXHAUSTIVE geometry proof.
+ *
+ * The matrix (`gen-geometry-matrix`) is the curated everyday sweep. This is its
+ * opt-in counterpart (like `test:cli:sloth` — NEVER in the merge gate): ONE
+ * template id, a caller-defined canvas SET, EVERY member checked, one clustered
+ * report that PROVES the contract across the whole set.
+ *
+ *   npm run audit:geometry-proof -- --template @m0saic/alpine/stat-card/v1 \
+ *     [--canvases 480x480,386x277,...]      # explicit list
+ *     [--range 240:3840x240:2160 --step 1]  # cartesian range (step 1 = exhaustive)
+ *     [--ar 16:9,9:16,1:1 --scales 240:2160]# aspect families × scale sweep
+ *     [--props '{"...":"..."}']             # merged over defaultProps; debug forced on
+ *     [--seeds seeds.json]                  # ProofEstimateSeed[] for the estimator
+ *     [--estimate]                          # probe only — print the projection, run nothing
+ *     [--yes]                               # accept a sloth-scale projection without prompting
+ *     [--out packages/templates/geometry-proofs/]
+ *
+ * Resolve-only (JS + one parse per canvas) — NO ffmpeg. The estimator probe runs
+ * FIRST, always, and refuses a sloth-scale set without `--yes`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const dsl_1 = require("@m0saic/dsl");
+const template_utils_1 = require("@m0saic/template-utils");
+const geometry_audit_1 = require("./geometry-audit");
+require("./m0saic"); // side-effect: register every template
+const ROOT = path.resolve(__dirname, "..");
+// ── args ─────────────────────────────────────────────────────
+const argv = process.argv.slice(2);
+const argVal = (name) => {
+    const i = argv.indexOf(name);
+    return i >= 0 && i + 1 < argv.length ? argv[i + 1] : undefined;
+};
+const hasFlag = (name) => argv.includes(name);
+const median = (xs) => {
+    if (xs.length === 0)
+        return 0;
+    const s = [...xs].sort((a, b) => a - b);
+    return s[Math.floor(s.length / 2)];
+};
+function slugify(id) {
+    return id.replace(/^@/, "").replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function hashProps(obj) {
+    var _a;
+    const s = (_a = JSON.stringify(obj)) !== null && _a !== void 0 ? _a : "";
+    let h = 5381;
+    for (let i = 0; i < s.length; i++)
+        h = ((h << 5) + h + s.charCodeAt(i)) >>> 0;
+    return h.toString(16).padStart(8, "0");
+}
+function ctxFor(w, h) {
+    const t = { width: w, height: h, fps: 30, durationMs: 2000 };
+    return { mode: "render", target: t, output: { ...t, workspaceDir: "/tmp/geom-proof" }, media: {} };
+}
+async function main() {
+    var _a, _b;
+    const templateId = argVal("--template");
+    if (!templateId) {
+        console.error("gen-geometry-proof: --template <id> is required.");
+        process.exit(2);
+    }
+    const tpl = (0, template_utils_1.getTemplate)(templateId);
+    if (!tpl) {
+        console.error(`gen-geometry-proof: template not registered: ${templateId}`);
+        process.exit(2);
+    }
+    const schema = tpl.propsSchema;
+    if (!schema || !("debugGeometry" in schema)) {
+        console.error(`gen-geometry-proof: ${templateId} does not adopt the geometry contract (no debugGeometry prop). Nothing to prove.`);
+        process.exit(2);
+    }
+    const extraProps = argVal("--props") ? JSON.parse(argVal("--props")) : {};
+    const baseProps = { ...((_a = tpl.defaultProps) !== null && _a !== void 0 ? _a : {}), ...extraProps };
+    const spec = {
+        canvases: argVal("--canvases"),
+        range: argVal("--range"),
+        step: argVal("--step") ? Number(argVal("--step")) : undefined,
+        ar: argVal("--ar"),
+        scales: argVal("--scales"),
+        scaleStep: argVal("--scale-step") ? Number(argVal("--scale-step")) : undefined,
+    };
+    const count = (0, geometry_audit_1.proofCanvasCount)(spec);
+    if (count <= 0) {
+        console.error("gen-geometry-proof: empty canvas set — pass --canvases / --range / --ar+--scales.");
+        process.exit(2);
+    }
+    // Resolve with debug OFF → the real geometry m0 (not an error mosaic) for timing.
+    const resolveM0 = async (w, h) => {
+        try {
+            const doc = (await tpl.render({ ...baseProps, debugGeometry: false }, ctxFor(w, h)));
+            return (doc === null || doc === void 0 ? void 0 : doc.m0) != null ? String(doc.m0) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Resolve with debug ON → the stamped contract result.
+    const stampAt = async (w, h) => {
+        var _a, _b;
+        try {
+            const doc = (await tpl.render({ ...baseProps, debugGeometry: true }, ctxFor(w, h)));
+            const stamp = (_a = doc === null || doc === void 0 ? void 0 : doc.editor) === null || _a === void 0 ? void 0 : _a.geometryContract;
+            return stamp ? { stamp } : { error: "no geometryContract stamp" };
+        }
+        catch (e) {
+            return { error: String((_b = e === null || e === void 0 ? void 0 : e.message) !== null && _b !== void 0 ? _b : e).slice(0, 120) };
+        }
+    };
+    // ── Estimator probe (always first) ──
+    const seedsFile = argVal("--seeds");
+    const seeds = [];
+    const resolveTimes = [];
+    if (seedsFile) {
+        const parsed = JSON.parse(fs.readFileSync(path.resolve(seedsFile), "utf8"));
+        for (const s of parsed) {
+            seeds.push(s);
+            const t0 = node_perf_hooks_1.performance.now();
+            await resolveM0(s.w, s.h);
+            resolveTimes.push(node_perf_hooks_1.performance.now() - t0);
+        }
+    }
+    else {
+        for (const [w, h] of (0, geometry_audit_1.proofSeedCanvases)(spec)) {
+            const t0 = node_perf_hooks_1.performance.now();
+            const m0 = await resolveM0(w, h);
+            resolveTimes.push(node_perf_hooks_1.performance.now() - t0);
+            if (m0)
+                seeds.push({ m0, w, h, label: "auto" });
+        }
+    }
+    const resolveMed = median(resolveTimes);
+    // Worst seed's median parse (the estimate errs long, never short).
+    const K = 5;
+    let worstParseMed = 0;
+    for (const s of seeds) {
+        const reps = [];
+        for (let k = 0; k < K; k++) {
+            const t0 = node_perf_hooks_1.performance.now();
+            (0, dsl_1.parseM0StringComplete)(s.m0, s.w, s.h);
+            reps.push(node_perf_hooks_1.performance.now() - t0);
+        }
+        worstParseMed = Math.max(worstParseMed, median(reps));
+    }
+    const projectedMs = (0, geometry_audit_1.projectProofTime)(resolveMed, worstParseMed, count);
+    const verdict = (0, geometry_audit_1.verdictTier)(projectedMs);
+    console.log(`[geometry-proof] ${templateId} · ${count.toLocaleString()} canvases · ` +
+        `~${(resolveMed + worstParseMed).toFixed(2)}ms/canvas → projected ${(projectedMs / 1000).toFixed(1)}s · ${verdict.label}`);
+    if (hasFlag("--estimate"))
+        return;
+    if (verdict.tier === "sloth" && !hasFlag("--yes")) {
+        console.error(`[geometry-proof] REFUSING a sloth-scale run (~${(projectedMs / 60000).toFixed(1)} min). Re-run with --yes to accept.`);
+        process.exit(3);
+    }
+    // ── Run: resolve + read stamp per canvas; store only failures (bounded). ──
+    const started = node_perf_hooks_1.performance.now();
+    const failures = [];
+    let total = 0, passes = 0, hostileTotal = 0, hostilePass = 0;
+    let firstInfeasible = null, firstSubPrec = null;
+    let maxSpread = 0, maxSpreadCanvas = "";
+    const hostileExamples = [];
+    for (const [w, h] of (0, geometry_audit_1.proofCanvases)(spec)) {
+        total++;
+        const hostile = (0, geometry_audit_1.isHostileCanvas)(w, h);
+        if (hostile) {
+            hostileTotal++;
+            if (hostileExamples.length < 8)
+                hostileExamples.push(`${w}x${h}`);
+        }
+        const { stamp, error } = await stampAt(w, h);
+        if (error) {
+            failures.push({ w, h, error });
+            continue;
+        }
+        const f = stamp.floors;
+        if (!f.feasible && !firstInfeasible)
+            firstInfeasible = `${w}x${h}`;
+        if (!f.meetsPrecision && !firstSubPrec)
+            firstSubPrec = `${w}x${h}`;
+        if (f.maxSpreadPx !== Infinity && f.maxSpreadPx > maxSpread) {
+            maxSpread = f.maxSpreadPx;
+            maxSpreadCanvas = `${w}x${h}`;
+        }
+        if (stamp.ok) {
+            passes++;
+            if (hostile)
+                hostilePass++;
+        }
+        else
+            failures.push({ w, h, ok: false, violations: stamp.violations, floors: f });
+        if (total % 1000 === 0)
+            process.stderr.write(`[geometry-proof] ${total.toLocaleString()}/${count.toLocaleString()} …\n`);
+    }
+    const wallMs = node_perf_hooks_1.performance.now() - started;
+    // ── Report (shared, tested builder) ──
+    const specStr = spec.canvases ? `list ${spec.canvases}` : spec.range ? `range ${spec.range} step ${(_b = spec.step) !== null && _b !== void 0 ? _b : 1}` : spec.ar ? `ar ${spec.ar} × scales ${spec.scales}` : "matrix";
+    const { md, proven } = (0, geometry_audit_1.buildProofReport)({
+        templateId,
+        specStr,
+        total,
+        propsHash: hashProps(baseProps),
+        wallMs,
+        projectedMs,
+        tier: verdict.tier,
+        passes,
+        failures,
+        floors: { firstInfeasible, firstSubPrec, maxSpread, maxSpreadCanvas },
+        hostile: { total: hostileTotal, passed: hostilePass, examples: hostileExamples },
+    });
+    const outDir = argVal("--out") ? path.resolve(argVal("--out")) : path.join(ROOT, "geometry-proofs");
+    fs.mkdirSync(outDir, { recursive: true });
+    const outFile = path.join(outDir, `${slugify(templateId)}.md`);
+    fs.writeFileSync(outFile, md, "utf8");
+    console.log(`[geometry-proof] ${proven ? "PROVEN" : "FAILED"} — ${passes.toLocaleString()}/${total.toLocaleString()} passed · ` +
+        `wrote ${path.relative(ROOT, outFile)} in ${(wallMs / 1000).toFixed(1)}s`);
+    if (!proven)
+        process.exitCode = 1;
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/gen-layout-envelope.d.ts

@@ -0,0 +1 @@
+import "./m0saic";

package/dist/gen-layout-envelope.js

@@ -0,0 +1,120 @@
+"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;
+    };
+})();
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Generate LAYOUT-ENVELOPE.md — per-invariant "where does my layout hold?".
+ *
+ * For every template that adopts the LAYOUT contract (its props schema exposes
+ * `debugLayout`), sweep the aspect families × a scale range, resolve with
+ * `debugLayout:true`, read the stamped `editor.layoutContract`, and report — per
+ * declared invariant (`label · rule`) — the canvas range where it holds vs
+ * breaks, with the boundary. Resolve + parse only, NO ffmpeg.
+ *
+ * This is the layout-solver report: instead of a green/red table it tells you
+ * the feasible canvas envelope, so you either fix the geometry math for the
+ * range you need or declare the template's supported output range as the proven
+ * envelope. Run: `npm run audit:layout-envelope`.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const template_utils_1 = require("@m0saic/template-utils");
+const geometry_audit_1 = require("./geometry-audit");
+require("./m0saic"); // side-effect: register every template
+const ROOT = path.resolve(__dirname, "..");
+const OUT = path.join(ROOT, "LAYOUT-ENVELOPE.md");
+// The sweep: aspect families across a scale range (override via env).
+const AR = (_a = process.env.ENVELOPE_AR) !== null && _a !== void 0 ? _a : "16:9,9:16,1:1";
+const SCALES = (_b = process.env.ENVELOPE_SCALES) !== null && _b !== void 0 ? _b : "240:2160";
+const SCALE_STEP = Number((_c = process.env.ENVELOPE_SCALE_STEP) !== null && _c !== void 0 ? _c : 120);
+const SWEEP_DESC = `ar ${AR} × scales ${SCALES} step ${SCALE_STEP}`;
+function ctxFor(w, h) {
+    const t = { width: w, height: h, fps: 30, durationMs: 2000 };
+    return { mode: "render", target: t, output: { ...t, workspaceDir: "/tmp/layout-env" }, media: {} };
+}
+function adoptsLayout(tpl) {
+    const schema = tpl.propsSchema;
+    return !!schema && "debugLayout" in schema;
+}
+async function sampleAt(tpl, w, h) {
+    var _a, _b;
+    try {
+        const doc = (await tpl.render({ ...((_a = tpl.defaultProps) !== null && _a !== void 0 ? _a : {}), debugLayout: true }, ctxFor(w, h)));
+        const stamp = (_b = doc === null || doc === void 0 ? void 0 : doc.editor) === null || _b === void 0 ? void 0 : _b.layoutContract;
+        if (!stamp)
+            return null;
+        return { w, h, violated: stamp.violations.map((v) => `${v.label}|${v.rule}`) };
+    }
+    catch {
+        // A resolve/flatten error is a total break: mark every declared invariant
+        // as violated at this canvas via a sentinel key.
+        return { w, h, violated: ["<render-error>"] };
+    }
+}
+async function main() {
+    const ids = (0, template_utils_1.listRegisteredTemplateIds)()
+        .map(String)
+        .filter((id) => {
+        const t = (0, template_utils_1.getTemplate)(id);
+        return !!t && !t.deprecated && adoptsLayout(t);
+    })
+        .sort();
+    const spec = { ar: AR, scales: SCALES, scaleStep: SCALE_STEP };
+    const sections = [];
+    for (const id of ids) {
+        const tpl = (0, template_utils_1.getTemplate)(id);
+        const samples = [];
+        for (const [w, h] of (0, geometry_audit_1.proofCanvases)(spec)) {
+            process.stderr.write(`[layout-envelope] ${id} @ ${w}×${h} …\n`);
+            const s = await sampleAt(tpl, w, h);
+            if (s)
+                samples.push(s);
+        }
+        if (samples.length === 0)
+            continue;
+        sections.push((0, geometry_audit_1.buildEnvelopeReport)(id, SWEEP_DESC, samples));
+    }
+    const header = ids.length === 0
+        ? `# Layout envelope\n\n> Auto-generated by \`gen-layout-envelope\`. No template adopts the layout contract yet (expose a \`debugLayout\` prop + wrap the return in \`withLayoutContract\`).\n`
+        : `# Layout envelope\n\n> Auto-generated by \`gen-layout-envelope\` — ${ids.length} adopting template(s), sweep ${SWEEP_DESC}.\n\n---\n\n`;
+    fs.writeFileSync(OUT, header + sections.join("\n---\n\n"), "utf8");
+    // eslint-disable-next-line no-console
+    console.log(`[layout-envelope] wrote ${path.relative(ROOT, OUT)} — ${ids.length} adopting template(s)`);
+}
+main().catch((e) => {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    process.exit(1);
+});

package/dist/gen-precision-sweep.d.ts

@@ -0,0 +1 @@
+import "./m0saic";