@m0saic/templates 0.2.0

package/dist/m0saic/media/qr/animate/v2/index.d.ts

@@ -0,0 +1,2 @@
+export { QrAnimateV2, default } from "./qr-animate";
+export type { QrAnimateV2Props } from "./qr-animate";

package/dist/m0saic/media/qr/animate/v2/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.QrAnimateV2 = void 0;
+var qr_animate_1 = require("./qr-animate");
+Object.defineProperty(exports, "QrAnimateV2", { enumerable: true, get: function () { return qr_animate_1.QrAnimateV2; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(qr_animate_1).default; } });

package/dist/m0saic/media/qr/animate/v2/qr-animate.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @m0saic/media/qr/animate/v2
+ *
+ * Live-conversion QR animator. Takes an arbitrary URL (or a caller-supplied
+ * SVG) and produces an M0 string at render time:
+ *
+ *   - URL path: `qrToRenderable` from `@m0saic/template-utils` (which calls
+ *     the in-house `qrToM0` encoder). No SVG, no `sharp`, no PNG raster.
+ *   - SVG path: `svgToM0` from `@m0saic/dsl-stdlib` (caller supplies the
+ *     SVG geometry — useful for non-QR vector content or for testing
+ *     against a known-good fixture).
+ *
+ * Modules are then animated with the same pixelate-in expressions as v1
+ * Phase 1. The M-region phase from v1 is intentionally NOT carried over —
+ * v2 is the "any URL, any QR" template; the brand-M overlay is the job of
+ * the dictionary-driven flow (v1). The Phase 2 follow-up template carves a
+ * safe area and splices a user-supplied media asset in the centre.
+ */
+import type { MosaicColor, MosaicTemplate } from "@m0saic/types";
+import { type PackingMode } from "@m0saic/dsl-stdlib";
+export type QrAnimateV2Props = {
+    /**
+     * Text to encode as a QR (URL, plain string, or structured payload).
+     * Required when {@link svg} is not provided. The template runs the
+     * text through the in-house `qrToM0` encoder (via
+     * `@m0saic/template-utils`'s `qrToRenderable`) at render time —
+     * no SVG round-trip, no PNG raster. The resulting per-module mask is
+     * then animated.
+     */
+    text?: string;
+    /**
+     * Caller-supplied SVG string. Bypasses QR generation entirely — useful
+     * for testing, for non-QR vector content, or for callers that already
+     * generated their own QR. Must contain `<path>` or `<rect>` elements.
+     */
+    svg?: string;
+    /** Drift tolerance for grid inference (% of min canvas dim). Default 0. */
+    driftPercent?: number;
+    /** Layer-packing strategy. Default "multi". */
+    packing?: PackingMode;
+    /** Stagger between rank-0 and rank-1 tile fades, in ms. */
+    spawnDurMs?: number;
+    /** Per-tile fade-in duration in ms. */
+    tileFadeMs?: number;
+    /** How long every tile holds at full alpha after the spawn wave completes. */
+    holdDurMs?: number;
+    /** Global fade-out duration. Every tile drops to 0 by render end. */
+    fadeOutDurMs?: number;
+    /** Per-tile pixel offset (down + right) that decays to 0 during fade-in. */
+    tileOffsetPx?: number;
+    /** Brand variant selecting the canvas background. */
+    variant?: "light" | "dark";
+    /** Solid background colour. Overrides {@link variant}'s default. */
+    bgColor?: MosaicColor;
+    /** Solid colour for module tiles (brand orange by default). */
+    tileColor?: MosaicColor;
+    /**
+     * Optional per-cell gleam over the QR modules — a travelling shine. Off by
+     * default; sparing enough that scannability is only transiently affected.
+     */
+    gleam?: boolean;
+};
+export declare const QrAnimateV2: MosaicTemplate<QrAnimateV2Props>;
+export default QrAnimateV2;

package/dist/m0saic/media/qr/animate/v2/qr-animate.js

@@ -0,0 +1,341 @@
+"use strict";
+/**
+ * @m0saic/media/qr/animate/v2
+ *
+ * Live-conversion QR animator. Takes an arbitrary URL (or a caller-supplied
+ * SVG) and produces an M0 string at render time:
+ *
+ *   - URL path: `qrToRenderable` from `@m0saic/template-utils` (which calls
+ *     the in-house `qrToM0` encoder). No SVG, no `sharp`, no PNG raster.
+ *   - SVG path: `svgToM0` from `@m0saic/dsl-stdlib` (caller supplies the
+ *     SVG geometry — useful for non-QR vector content or for testing
+ *     against a known-good fixture).
+ *
+ * Modules are then animated with the same pixelate-in expressions as v1
+ * Phase 1. The M-region phase from v1 is intentionally NOT carried over —
+ * v2 is the "any URL, any QR" template; the brand-M overlay is the job of
+ * the dictionary-driven flow (v1). The Phase 2 follow-up template carves a
+ * safe area and splices a user-supplied media asset in the centre.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QrAnimateV2 = void 0;
+const types_1 = require("@m0saic/types");
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const template_utils_1 = require("@m0saic/template-utils");
+const expressions_1 = require("../v1/expressions");
+const BRAND_ORANGE = "#f97316";
+const BG_LIGHT = "#ffffff";
+const BG_DARK = "#000000";
+const DEFAULT_VARIANT = "light";
+const DEFAULT_TILE_COLOR = BRAND_ORANGE;
+const DEFAULT_SPAWN_DUR_MS = 1000;
+const DEFAULT_TILE_FADE_MS = 220;
+const DEFAULT_HOLD_DUR_MS = 600;
+const DEFAULT_FADE_OUT_DUR_MS = 700;
+const DEFAULT_TILE_OFFSET_PX = 1;
+const DEFAULT_PACKING = "multi";
+const DEFAULT_DRIFT_PERCENT = 0;
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    text: {
+        type: "string",
+        required: false,
+        description: "Text to encode as a QR at render time (URL, plain string, or structured payload). Required unless `svg` is provided.",
+        meta: { control: { flavor: "url", placeholder: "https://www.m0saic.io" }, ui: { label: "Text" } },
+    },
+    svg: {
+        type: "string",
+        required: false,
+        description: "Caller-supplied SVG. Bypasses QR generation. Required unless `text` is provided.",
+        meta: { control: { placeholder: "from Text (QR)" }, ui: { label: "SVG string" } },
+    },
+    driftPercent: {
+        type: "number",
+        required: false,
+        description: "Drift tolerance for grid inference (% of min canvas dim).",
+        meta: {
+            constraints: { min: 0, max: 5 },
+            ui: { label: "Drift %" },
+        },
+    },
+    packing: {
+        type: "string",
+        required: false,
+        description: 'Layer-packing strategy: "one" or "multi".',
+        meta: {
+            constraints: { oneOf: ["one", "multi"] },
+            // Irrelevant to the user at Make time — always rendered as the "multi"
+            // default. Kept in the schema for the SVG render path; hidden from the
+            // editor form so it isn't a confusing knob.
+            ui: { label: "Packing", hidden: true },
+        },
+    },
+    spawnDurMs: {
+        type: "number",
+        required: false,
+        description: "Stagger duration: time from first tile to last tile starting their fade-in.",
+        meta: {
+            constraints: { min: 100, max: 60000 },
+            ui: { label: "Spawn (ms)" },
+        },
+    },
+    tileFadeMs: {
+        type: "number",
+        required: false,
+        description: "Per-tile fade-in duration.",
+        meta: {
+            constraints: { min: 0, max: 10000 },
+            ui: { label: "Fade (ms)" },
+        },
+    },
+    holdDurMs: {
+        type: "number",
+        required: false,
+        description: "Hold duration at full alpha before fade-out begins.",
+        meta: {
+            constraints: { min: 0, max: 60000 },
+            ui: { label: "Hold (ms)" },
+        },
+    },
+    fadeOutDurMs: {
+        type: "number",
+        required: false,
+        description: "Global fade-out duration.",
+        meta: {
+            constraints: { min: 0, max: 10000 },
+            ui: { label: "Fade out (ms)" },
+        },
+    },
+    tileOffsetPx: {
+        type: "number",
+        required: false,
+        description: "Pixel offset (down/right) each tile starts from.",
+        meta: {
+            constraints: { min: 0, max: 100 },
+            ui: { label: "Settle (px)" },
+        },
+    },
+    variant: {
+        type: "string",
+        required: false,
+        description: "Brand variant: 'light' (white bg) or 'dark' (black bg). Modules stay brand orange.",
+        meta: {
+            constraints: { oneOf: ["light", "dark"] },
+            ui: { label: "Variant" },
+        },
+    },
+    bgColor: {
+        type: "string",
+        required: false,
+        description: "Background colour override. Defaults from variant.",
+        meta: {
+            constraints: { isColor: true },
+            ui: { label: "Background" },
+            control: { colorPicker: true, placeholder: BG_LIGHT },
+        },
+    },
+    tileColor: {
+        type: "string",
+        required: false,
+        description: "Module fill colour.",
+        meta: {
+            constraints: { isColor: true },
+            ui: { label: "Tile color" },
+            control: { colorPicker: true, placeholder: DEFAULT_TILE_COLOR },
+        },
+    },
+    gleam: {
+        type: "boolean",
+        required: false,
+        description: "Add a travelling per-cell shine over the QR modules.",
+        meta: { ui: { label: "Gleam" } },
+    },
+});
+exports.QrAnimateV2 = {
+    id: (0, types_1.asTemplateId)("@m0saic/media/qr/animate/v2"),
+    label: "QR Spawn (v2, deprecated)",
+    version: 2,
+    // BITMAP drafting mode (handbook §3c): the split counts ARE the QR module grid —
+    // never live-composed, so the latticeSmooth convention does not apply.
+    lattice: { mode: "bitmap" },
+    description: "Animated QR — modules pixelate in with a staggered fade, hold, then fade out. Accepts any URL (or a caller-supplied SVG).",
+    deprecated: {
+        reason: "Merged into QR Code (media/qr/code/v1): the spawn is its Output mp4 mode (envelope under Animation; fade-out opt-in via fadeOutDurMs; text path expression-identical) and the caller-SVG hatch is advanced.svg. The unified card adds module styles, the carved centre, and static output from the same surface. Render-time gleam retired by design. Kept as the spawn reference.",
+        replacement: (0, types_1.asTemplateId)("@m0saic/media/qr/code/v1"),
+        since: "2026-07-22",
+    },
+    capabilities: { tier: "core" },
+    tags: ["brand", "qr", "animated", "svg-to-mosaic"],
+    outputHints: {
+        fps: 30,
+        durationMs: DEFAULT_SPAWN_DUR_MS +
+            DEFAULT_TILE_FADE_MS +
+            DEFAULT_HOLD_DUR_MS +
+            DEFAULT_FADE_OUT_DUR_MS,
+        width: 1222,
+        height: 1222,
+        note: "Square QR; modules spawn-in → hold → fade out.",
+        // Editor preview lands mid-hold (after spawn + fade, half-way through the
+        // hold) so the QR is fully visible while the user types the URL. The
+        // render still starts at t=0; scrubbing back shows the spawn.
+        posterTimeMs: DEFAULT_SPAWN_DUR_MS + DEFAULT_TILE_FADE_MS + Math.round(DEFAULT_HOLD_DUR_MS / 2),
+        // Declared so the Make page's template-fetch effect snaps Output
+        // Type → Video on swap (otherwise a prior image-template selection
+        // would leave the Image chip stale).
+        format: { kind: "video", container: "mp4" },
+    },
+    propsSchema,
+    defaultProps: {
+        variant: DEFAULT_VARIANT,
+        driftPercent: DEFAULT_DRIFT_PERCENT,
+        packing: DEFAULT_PACKING,
+        spawnDurMs: DEFAULT_SPAWN_DUR_MS,
+        tileFadeMs: DEFAULT_TILE_FADE_MS,
+        holdDurMs: DEFAULT_HOLD_DUR_MS,
+        fadeOutDurMs: DEFAULT_FADE_OUT_DUR_MS,
+        tileOffsetPx: DEFAULT_TILE_OFFSET_PX,
+        tileColor: DEFAULT_TILE_COLOR,
+        gleam: false,
+    },
+    async render(props, ctx) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const variant = (_a = props.variant) !== null && _a !== void 0 ? _a : this.defaultProps.variant;
+        const bgColor = (_b = props.bgColor) !== null && _b !== void 0 ? _b : (variant === "dark" ? BG_DARK : BG_LIGHT);
+        const driftPercent = (_c = props.driftPercent) !== null && _c !== void 0 ? _c : this.defaultProps.driftPercent;
+        const packing = (_d = props.packing) !== null && _d !== void 0 ? _d : this.defaultProps.packing;
+        const spawnDurMs = (_e = props.spawnDurMs) !== null && _e !== void 0 ? _e : this.defaultProps.spawnDurMs;
+        const tileFadeMs = (_f = props.tileFadeMs) !== null && _f !== void 0 ? _f : this.defaultProps.tileFadeMs;
+        const holdDurMs = (_g = props.holdDurMs) !== null && _g !== void 0 ? _g : this.defaultProps.holdDurMs;
+        const fadeOutDurMs = (_h = props.fadeOutDurMs) !== null && _h !== void 0 ? _h : this.defaultProps.fadeOutDurMs;
+        const tileOffsetPx = (_j = props.tileOffsetPx) !== null && _j !== void 0 ? _j : this.defaultProps.tileOffsetPx;
+        const tileColor = (_k = props.tileColor) !== null && _k !== void 0 ? _k : this.defaultProps.tileColor;
+        const gleam = (_m = (_l = props.gleam) !== null && _l !== void 0 ? _l : this.defaultProps.gleam) !== null && _m !== void 0 ? _m : false;
+        // ── Validation ────────────────────────────────────────────────
+        const errs = [];
+        if (!props.text && !props.svg) {
+            errs.push("either `text` or `svg` is required");
+        }
+        if (props.text && props.svg) {
+            errs.push("specify exactly one of `text` or `svg` (not both)");
+        }
+        if (!(driftPercent >= 0 && driftPercent <= 5)) {
+            errs.push(`driftPercent must be in [0, 5] (got ${driftPercent})`);
+        }
+        if (packing !== "one" && packing !== "multi") {
+            errs.push(`packing must be "one" or "multi" (got "${packing}")`);
+        }
+        if (!(spawnDurMs >= 100 && spawnDurMs <= 60000)) {
+            errs.push(`spawnDurMs must be in [100, 60000] (got ${spawnDurMs})`);
+        }
+        if (!(tileFadeMs >= 0 && tileFadeMs <= 10000)) {
+            errs.push(`tileFadeMs must be in [0, 10000] (got ${tileFadeMs})`);
+        }
+        if (!(holdDurMs >= 0 && holdDurMs <= 60000)) {
+            errs.push(`holdDurMs must be in [0, 60000] (got ${holdDurMs})`);
+        }
+        if (!(fadeOutDurMs >= 0 && fadeOutDurMs <= 10000)) {
+            errs.push(`fadeOutDurMs must be in [0, 10000] (got ${fadeOutDurMs})`);
+        }
+        if (!(tileOffsetPx >= 0 && tileOffsetPx <= 100)) {
+            errs.push(`tileOffsetPx must be in [0, 100] (got ${tileOffsetPx})`);
+        }
+        if (errs.length) {
+            return (0, template_utils_1.makeErrorMosaic)(errs.join(" | "), {
+                title: `${this.id} props`,
+                width: ctx.output.width,
+                height: ctx.output.height,
+            });
+        }
+        // ── 1) Generate M0 directly (text via qrToRenderable, or SVG via svgToM0) ──
+        //
+        // Text path: qrToRenderable wraps the in-house `qrToM0` encoder. No SVG,
+        // no PNG raster — the m0 is the QR module grid and we ignore its
+        // sources here (Phase 2 below builds per-cell sources with animation
+        // overlays attached).
+        //
+        // SVG path: kept for caller-supplied SVGs (testing, non-QR vector
+        // content). Goes through `svgToM0`'s grid inference as before.
+        let m0;
+        try {
+            if (props.svg) {
+                m0 = String((0, dsl_stdlib_1.svgToM0)(props.svg, { driftPercent, packing }));
+            }
+            else {
+                const qr = (0, template_utils_1.qrToRenderable)({
+                    text: props.text,
+                    moduleColor: tileColor,
+                    errorCorrectionLevel: "H",
+                });
+                m0 = String(qr.m0);
+            }
+        }
+        catch (err) {
+            return (0, template_utils_1.makeErrorMosaic)(`QR generation failed: ${err instanceof Error ? err.message : String(err)}`, {
+                title: `${this.id} qr-gen`,
+                width: ctx.output.width,
+                height: ctx.output.height,
+            });
+        }
+        // ── 3) Identify visible (animatable) tiles ────────────────────
+        const visibleFrames = (0, dsl_stdlib_1.queryFrames)(m0, {
+            width: ctx.output.width,
+            height: ctx.output.height,
+        }).logical();
+        if (visibleFrames.length === 0) {
+            return (0, template_utils_1.makeErrorMosaic)("Converted m0 contains no visible tiles to animate", {
+                title: `${this.id} parse`,
+                width: ctx.output.width,
+                height: ctx.output.height,
+            });
+        }
+        // Pseudo-random ranks for the pixelate-in effect. Same expression
+        // module as v1; same deterministic hash-shuffle behaviour.
+        const tileInputs = visibleFrames.map((f) => ({
+            x: f.x,
+            y: f.y,
+            logicalIndex: f.logicalIndex,
+        }));
+        const ranks = (0, expressions_1.buildPseudoRanks)(tileInputs);
+        // ── 4) Phase timing ──────────────────────────────────────────
+        //
+        //   0 ─── spawn ──── modulesEnd ── hold ── exitStart ── fadeOut ── end
+        //
+        const spawnDurSec = spawnDurMs / 1000;
+        const tileFadeSec = tileFadeMs / 1000;
+        const modulesEndSec = spawnDurSec + tileFadeSec;
+        const exitStartSec = modulesEndSec + holdDurMs / 1000;
+        const fadeOutSec = fadeOutDurMs / 1000;
+        // ── 5) Build per-tile color sources ──────────────────────────
+        const sources = visibleFrames.map((_tile, i) => {
+            const rank = ranks[i];
+            const baseAlpha = (0, expressions_1.buildModuleAlphaExpr)(rank, {
+                spawnDurSec,
+                tileFadeSec,
+                exitStartSec,
+                fadeOutSec,
+            });
+            // Optional travelling per-cell shine over the modules (shows during the
+            // hold). Keeps a high floor alpha, so the QR stays scannable.
+            const alpha = gleam
+                ? `(${baseAlpha})*(${(0, expressions_1.buildModuleGleamFactor)(rank)})`
+                : baseAlpha;
+            const offsetExpr = (0, expressions_1.buildTileOffsetExpr)(rank, {
+                spawnDurSec,
+                tileFadeSec,
+                offsetPx: tileOffsetPx,
+            });
+            return (0, template_utils_1.makeColorTile)(tileColor, {
+                overlay: { alpha, xExpr: offsetExpr, yExpr: offsetExpr },
+            });
+        });
+        return {
+            kind: "mosaic_document",
+            version: 1,
+            m0: (0, dsl_stdlib_1.toM0String)(m0, "QrAnimateV2"),
+            sources,
+            assets: {},
+            backgroundColor: bgColor,
+        };
+    },
+};
+(0, template_utils_1.registerTemplate)(exports.QrAnimateV2);
+exports.default = exports.QrAnimateV2;

package/dist/m0saic/media/qr/basic/v1/index.d.ts

@@ -0,0 +1 @@
+export { BrandQr, QRCode, default } from "./qr";

package/dist/m0saic/media/qr/basic/v1/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.QRCode = exports.BrandQr = void 0;
+var qr_1 = require("./qr");
+Object.defineProperty(exports, "BrandQr", { enumerable: true, get: function () { return qr_1.BrandQr; } });
+Object.defineProperty(exports, "QRCode", { enumerable: true, get: function () { return qr_1.QRCode; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(qr_1).default; } });

package/dist/m0saic/media/qr/basic/v1/qr.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Brand QR v1 — scannable QR encoding arbitrary text.
+ *
+ * Default is a m0saic URL; any string the QR encoder can carry works
+ * (URLs, plain text, wifi credentials via `qrPayloadWifi`, vCard payloads
+ * via `qrPayloadVCard`, etc.). The `url` flavor on the text prop opts
+ * into the editor's URL UX (paste auto-prefix, open-in-browser) without
+ * restricting the value.
+ *
+ * Fully in-house: no SVG, no `sharp`, no PNG raster. Each QR module is
+ * its own lavfi colour tile in the document's m0 — the engine paints
+ * them directly. Background fill comes from the document's
+ * `backgroundColor` (omitted entirely for transparent mode so the
+ * alpha channel survives).
+ */
+type Props = {
+    text?: string;
+    mode?: "light" | "dark";
+    transparentBackground?: boolean;
+};
+export declare const BrandQr: import("@m0saic/types").MosaicTemplate<Props, import("@m0saic/types").MosaicTemplateOutputs, import("@m0saic/types").MosaicTemplateUpstreamVariables, import("@m0saic/types").MosaicTemplateUpstreamData, import("@m0saic/types").MosaicTemplateSidecars>;
+export default BrandQr;
+/** @deprecated Use BrandQr */
+export declare const QRCode: import("@m0saic/types").MosaicTemplate<Props, import("@m0saic/types").MosaicTemplateOutputs, import("@m0saic/types").MosaicTemplateUpstreamVariables, import("@m0saic/types").MosaicTemplateUpstreamData, import("@m0saic/types").MosaicTemplateSidecars>;

package/dist/m0saic/media/qr/basic/v1/qr.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Brand QR v1 — scannable QR encoding arbitrary text.
+ *
+ * Default is a m0saic URL; any string the QR encoder can carry works
+ * (URLs, plain text, wifi credentials via `qrPayloadWifi`, vCard payloads
+ * via `qrPayloadVCard`, etc.). The `url` flavor on the text prop opts
+ * into the editor's URL UX (paste auto-prefix, open-in-browser) without
+ * restricting the value.
+ *
+ * Fully in-house: no SVG, no `sharp`, no PNG raster. Each QR module is
+ * its own lavfi colour tile in the document's m0 — the engine paints
+ * them directly. Background fill comes from the document's
+ * `backgroundColor` (omitted entirely for transparent mode so the
+ * alpha channel survives).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QRCode = exports.BrandQr = void 0;
+const types_1 = require("@m0saic/types");
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const template_utils_1 = require("@m0saic/template-utils");
+const BRAND_ORANGE = "#f97316";
+const BG_LIGHT = "#ffffff";
+const BG_DARK = "#000000";
+const propsSchema = (0, template_utils_1.definePropsSchema)({
+    text: {
+        type: "string",
+        required: false,
+        description: "Text to encode (URL, plain string, or structured payload). Defaults to https://www.m0saic.io.",
+        meta: { control: { flavor: "url", placeholder: "https://www.m0saic.io" } },
+    },
+    mode: {
+        type: "string",
+        required: false,
+        description: "Color mode of the QR code",
+        meta: { constraints: { oneOf: ["light", "dark"] } },
+    },
+    transparentBackground: {
+        type: "boolean",
+        required: false,
+        description: "When true, light areas are transparent (alpha). When false, light/dark use solid background.",
+    },
+});
+exports.BrandQr = (0, template_utils_1.defineMosaicTemplate)({
+    id: (0, types_1.asTemplateId)("@m0saic/media/qr/basic/v1"),
+    label: "Brand QR (v1, deprecated)",
+    version: 1,
+    // BITMAP drafting mode (handbook §3c): the split counts ARE the QR module grid —
+    // never live-composed, so the latticeSmooth convention does not apply.
+    lattice: { mode: "bitmap" },
+    description: "Scannable QR encoding any text (URL, plain string, or structured payload). Orange modules on light, dark, or transparent backgrounds. The atomic QR.",
+    deprecated: {
+        reason: "Merged into QR Code (media/qr/code/v1) — its moduleStyle:\"square\" path is byte-identical to this template, and the unified card adds rounded/circle styles plus the carved centre asset. Kept as the plain-path reference.",
+        replacement: (0, types_1.asTemplateId)("@m0saic/media/qr/code/v1"),
+        since: "2026-07-21",
+    },
+    capabilities: { tier: "core" },
+    tags: ["brand", "qr"],
+    outputHints: {
+        width: 1080,
+        height: 1080,
+        fps: 30,
+        durationMs: 2000,
+        note: "Square QR rendered as in-house m0 (no PNG raster).",
+        format: {
+            kind: "image",
+            container: "png",
+            pixelFormat: "rgba",
+        },
+    },
+    propsSchema,
+    defaultProps: {
+        text: "https://www.m0saic.io",
+        mode: "dark",
+        // Default to a solid card. Transparent is opt-in (the user toggles
+        // it on when they want alpha PNG for compositing). Defaulting to
+        // false avoids the "blank canvas + orange modules" preview that
+        // looked broken when alpha was implicit.
+        transparentBackground: false,
+    },
+    async render(props, ctx) {
+        var _a, _b, _c;
+        const text = (_a = props.text) !== null && _a !== void 0 ? _a : this.defaultProps.text;
+        const mode = (_b = props.mode) !== null && _b !== void 0 ? _b : this.defaultProps.mode;
+        const transparentBackground = (_c = props.transparentBackground) !== null && _c !== void 0 ? _c : false;
+        let renderable;
+        try {
+            renderable = (0, template_utils_1.qrToRenderable)({
+                text,
+                moduleColor: BRAND_ORANGE,
+                errorCorrectionLevel: "H",
+            });
+        }
+        catch (err) {
+            return (0, template_utils_1.makeErrorMosaic)(`BrandQr: ${err instanceof Error ? err.message : String(err)}`, {
+                title: "Brand QR (v1)",
+                width: ctx.output.width,
+                height: ctx.output.height,
+            });
+        }
+        const doc = {
+            kind: "mosaic_document",
+            version: 1,
+            m0: (0, dsl_stdlib_1.toM0String)(String(renderable.m0), "BrandQr"),
+            sources: renderable.sources,
+            assets: {},
+            // Engine-decided timing, not hardcoded. `outputHints` above still supply
+            // 30 / 2000 as the DEFAULTS (they seed ctx.target when the caller asks
+            // for nothing); authoring literals here additionally beat an EXPLICIT
+            // ask, because `stampRenderableOutput` gives authored durationMs
+            // precedence over the resolved target (gate 26). That rule is safe only
+            // for templates that yield to user intent before authoring — a 5s
+            // request was silently rendering as 2s.
+            fps: ctx.target.fps,
+            durationMs: ctx.target.durationMs,
+            // `solidBackground` forces the bg's alpha to opaque on alpha-bearing
+            // output formats (our rgba PNG). Without it the engine's bgFill step
+            // defaults to `@0.0` and silently turns the canvas transparent. See
+            // `solidBackground` docs for the full engine branch reference.
+            ...(transparentBackground
+                ? {}
+                : {
+                    backgroundColor: (0, template_utils_1.solidBackground)(mode === "dark" ? BG_DARK : BG_LIGHT),
+                }),
+        };
+        return doc;
+    },
+});
+(0, template_utils_1.registerTemplate)(exports.BrandQr);
+exports.default = exports.BrandQr;
+/** @deprecated Use BrandQr */
+exports.QRCode = exports.BrandQr;

package/dist/m0saic/media/qr/code/v1/index.d.ts

@@ -0,0 +1,2 @@
+export { QrCode, default } from "./qr-code";
+export type { QrCodeProps, QrCodeModuleStyle, QrCodeStyleConfig, QrCodeCenterConfig } from "./qr-code";

package/dist/m0saic/media/qr/code/v1/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.QrCode = void 0;
+var qr_code_1 = require("./qr-code");
+Object.defineProperty(exports, "QrCode", { enumerable: true, get: function () { return qr_code_1.QrCode; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(qr_code_1).default; } });