@m0saic/templates 0.2.0

package/dist/m0saic/brand/community-m/v1/manifest.js

@@ -0,0 +1,81 @@
+"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.tileLine = exports.identityLine = void 0;
+exports.resolveTarget = resolveTarget;
+exports.pieceAbsFor = pieceAbsFor;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const node_1 = require("@m0saic/platform/communityM/node");
+const paths_1 = require("./paths");
+const target_1 = require("./target");
+/**
+ * The NODE reader: load a community-m folder off disk and resolve the
+ * target inside it. The bundled seed by default; the app / CLI cache when
+ * the host pre-fills `communityDir`. Everything past this file is
+ * filesystem-free (see `target.ts`), which is what lets the browser build
+ * render the same beats.
+ */
+function resolveTarget(opts) {
+    const dir = opts.communityDir.trim() === "" ? (0, paths_1.seedCommunityDir)() : path.resolve(opts.communityDir);
+    const loaded = (0, node_1.loadCommunityManifestFromDir)(dir);
+    if (!loaded.ok)
+        return { ok: false, error: `community-m folder: ${loaded.error}` };
+    // A picture only counts if it is really on disk — a missing image paints
+    // as dormant, and never fails the render.
+    const pictureFor = (slot) => {
+        if (!slot.tile)
+            return null;
+        const abs = (0, node_1.resolveCommunityPath)(dir, slot.tile);
+        return fs.existsSync(abs) ? { kind: "file", path: abs } : null;
+    };
+    const r = (0, target_1.buildTarget)(loaded.manifest, { ...opts, pictureFor });
+    if (!r.ok)
+        return r;
+    // The subject's own piece must exist when we intend to read it.
+    if (!r.target.synthetic) {
+        const piece = (0, node_1.resolveCommunityPath)(dir, r.target.slot.piece);
+        if (!fs.existsSync(piece))
+            return { ok: false, error: `piece file missing: ${piece}` };
+    }
+    return { ok: true, target: r.target, dir };
+}
+/** Absolute path of a slot's `.mosaic` piece inside a community folder. */
+function pieceAbsFor(dir, slot) {
+    return (0, node_1.resolveCommunityPath)(dir, slot.piece);
+}
+var target_2 = require("./target");
+Object.defineProperty(exports, "identityLine", { enumerable: true, get: function () { return target_2.identityLine; } });
+Object.defineProperty(exports, "tileLine", { enumerable: true, get: function () { return target_2.tileLine; } });

package/dist/m0saic/brand/community-m/v1/mark.d.ts

@@ -0,0 +1,76 @@
+import type { AssetId, MosaicAssetManifest, MosaicDocument } from "@m0saic/types";
+/** Claimed-edge stroke width in 272-space (matches the app painter). */
+export declare const CLAIMED_EDGE_WIDTH = 1.2;
+/**
+ * One SVG with every claimed tile's outline — the D14 "claimed = orange
+ * edge" rule as a single overlay. Rect tiles use the dictionary frame;
+ * diagonal tiles use their mask path at its design-space bounds. Delivered
+ * as a data-URI media asset: the engine rasterizes SVG media to PNG before
+ * ffmpeg sees it, so one source paints all the edges and the mark's 33
+ * tiles stay on the grid sheet (no per-tile overlay chain).
+ */
+export declare function claimedEdgesSvg(claimedTiles: Iterable<number>, accent: string, sidePx: number): string;
+/**
+ * A claimed tile's picture: a file on disk (the node reader), a URL the host
+ * serves (the browser — the web app publishes the bundled seed's tiles), or
+ * an inline SVG (a preview stand-in).
+ */
+export type ClaimImage = {
+    kind: "file";
+    path: string;
+} | {
+    kind: "url";
+    url: string;
+} | {
+    kind: "data-uri";
+    uri: string;
+};
+/** The document asset for a claim's picture — one mapping, both consumers. */
+export declare function claimImageAsset(image: ClaimImage): MosaicAssetManifest[AssetId];
+export type MarkClaim = {
+    image: ClaimImage;
+    focus?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+};
+export type MarkDocOptions = {
+    /** Square side — MUST be k·272 (masks are authored in tile space; any other side stretches them). */
+    side: number;
+    fps: number;
+    durationMs: number;
+    /** Tile index → claimed image (cover-fit into the tile, focus-placed). */
+    claims: ReadonlyMap<number, MarkClaim>;
+    dormantColor: string;
+    canvasColor: string;
+    /** Accent for a reserved root (so the tip reads as special even when empty). */
+    accentColor: string;
+    rootReserved: boolean;
+    /** Optional: dim every tile except this one (spotlight) via overlay alpha keyframes. */
+    spotlight?: {
+        tileIndex: number;
+        alphaExpr: string;
+    };
+};
+/**
+ * The Community M as a document: the dictionary m0 as-is, one source per
+ * tile in SOURCE order — a claimed tile is its image, cover-fit and masked
+ * to the tile; an open tile is a dormant colour tile. The doc declares its
+ * own square size so nesting it never resizes the mark (child-size law).
+ */
+export declare function buildMarkDoc(o: MarkDocOptions): MosaicDocument;
+/** The 33 tiles alone — the dictionary m0 as-is, one source per tile in SOURCE order. */
+export declare function buildTilesDoc(o: MarkDocOptions): MosaicDocument;
+/**
+ * The brand logo for the closer: the same M, every tile in one colour (the
+ * app's orange mark). No claims, no edges — the company mark, not the
+ * community record.
+ */
+export declare function buildLogoDoc(o: {
+    side: number;
+    fps: number;
+    durationMs: number;
+    color: string;
+    canvasColor: string;
+}): MosaicDocument;

package/dist/m0saic/brand/community-m/v1/mark.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAIMED_EDGE_WIDTH = void 0;
+exports.claimedEdgesSvg = claimedEdgesSvg;
+exports.claimImageAsset = claimImageAsset;
+exports.buildMarkDoc = buildMarkDoc;
+exports.buildTilesDoc = buildTilesDoc;
+exports.buildLogoDoc = buildLogoDoc;
+const types_1 = require("@m0saic/types");
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+const template_utils_1 = require("@m0saic/template-utils");
+const geometry_1 = require("./geometry");
+/** Claimed-edge stroke width in 272-space (matches the app painter). */
+exports.CLAIMED_EDGE_WIDTH = 1.2;
+/**
+ * One SVG with every claimed tile's outline — the D14 "claimed = orange
+ * edge" rule as a single overlay. Rect tiles use the dictionary frame;
+ * diagonal tiles use their mask path at its design-space bounds. Delivered
+ * as a data-URI media asset: the engine rasterizes SVG media to PNG before
+ * ffmpeg sees it, so one source paints all the edges and the mark's 33
+ * tiles stay on the grid sheet (no per-tile overlay chain).
+ */
+function claimedEdgesSvg(claimedTiles, accent, sidePx) {
+    const geo = (0, geometry_1.markGeometry)();
+    const parts = [];
+    for (const tile of claimedTiles) {
+        const s = geo.tileToSource[tile];
+        const r = geo.sourceRects[s];
+        const mask = geo.maskFor(s);
+        if (mask && mask.kind === "inline-mask") {
+            parts.push(`<path d="${mask.localPath}" transform="translate(${mask.bounds.x} ${mask.bounds.y})" fill="none" stroke="${accent}" stroke-width="${exports.CLAIMED_EDGE_WIDTH}" stroke-linejoin="round"/>`);
+        }
+        else {
+            parts.push(`<rect x="${r.x}" y="${r.y}" width="${r.width}" height="${r.height}" fill="none" stroke="${accent}" stroke-width="${exports.CLAIMED_EDGE_WIDTH}" stroke-linejoin="round"/>`);
+        }
+    }
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${sidePx}" height="${sidePx}" viewBox="0 0 ${geometry_1.M_NATIVE} ${geometry_1.M_NATIVE}">${parts.join("")}</svg>`;
+}
+/** The document asset for a claim's picture — one mapping, both consumers. */
+function claimImageAsset(image) {
+    if (image.kind === "file")
+        return { kind: "file", path: image.path, mediaType: "image" };
+    if (image.kind === "url")
+        return { kind: "url", url: image.url, mediaType: "image" };
+    return { kind: "data-uri", uri: image.uri, mediaType: "image" };
+}
+/**
+ * The Community M as a document: the dictionary m0 as-is, one source per
+ * tile in SOURCE order — a claimed tile is its image, cover-fit and masked
+ * to the tile; an open tile is a dormant colour tile. The doc declares its
+ * own square size so nesting it never resizes the mark (child-size law).
+ */
+function buildMarkDoc(o) {
+    if (o.side % 272 !== 0)
+        throw new Error(`mark side must be a multiple of 272 (got ${o.side})`);
+    const tiles = buildTilesDoc(o);
+    const edgesId = (0, types_1.asAssetId)("claimed_edges");
+    const svg = claimedEdgesSvg(o.claims.keys(), o.accentColor, o.side);
+    return {
+        kind: "mosaic_document",
+        version: 1,
+        // base = the M's 33 tiles (nested, own size); overlay = one edge layer.
+        m0: (0, dsl_stdlib_1.toM0String)("1{1}", "CommunityMV1-mark"),
+        size: { width: o.side, height: o.side },
+        fps: o.fps,
+        durationMs: o.durationMs,
+        backgroundColor: o.canvasColor,
+        audio: { mode: "off" },
+        // URL-encoded, not base64, and with NO `;utf8` parameter: no `Buffer`
+        // (browser-safe), and the engine's plain-SVG data-URI parser only accepts
+        // `;key=value` params — see core `parsePlainSvgDataUri`.
+        assets: { [edgesId]: { kind: "data-uri", uri: `data:image/svg+xml,${encodeURIComponent(svg)}`, mediaType: "image" } },
+        children: { tiles },
+        sources: [
+            { type: "mosaic", ref: "tiles" },
+            { type: "media", mediaType: "image", assetId: edgesId, placement: { fit: "contain" } },
+        ],
+    };
+}
+/** The 33 tiles alone — the dictionary m0 as-is, one source per tile in SOURCE order. */
+function buildTilesDoc(o) {
+    const geo = (0, geometry_1.markGeometry)();
+    const assets = {};
+    const sources = geo.keys.map((_k, s) => {
+        var _a;
+        const tile = geo.sourceToTile[s];
+        const claim = o.claims.get(tile);
+        const mask = geo.maskFor(s);
+        const overlay = o.spotlight && o.spotlight.tileIndex !== tile ? { alpha: o.spotlight.alphaExpr } : undefined;
+        if (claim) {
+            const id = (0, types_1.asAssetId)(`tile_${tile}`);
+            assets[id] = claimImageAsset(claim.image);
+            const f = (_a = claim.focus) !== null && _a !== void 0 ? _a : { x: 0.5, y: 0.5, zoom: 1 };
+            return {
+                type: "media",
+                mediaType: "image",
+                assetId: id,
+                placement: { fit: "cover", focusX: f.x, focusY: f.y },
+                ...(mask ? { mask } : {}),
+                ...(overlay ? { overlay } : {}),
+            };
+        }
+        const isRoot = tile === 32;
+        const color = isRoot && o.rootReserved ? o.accentColor : o.dormantColor;
+        return (0, template_utils_1.makeColorTile)(color, { ...(mask ? { mask } : {}), ...(overlay ? { overlay } : {}) });
+    });
+    return {
+        kind: "mosaic_document",
+        version: 1,
+        m0: (0, dsl_stdlib_1.toM0String)(geo.m0, "CommunityMV1-tiles"),
+        size: { width: o.side, height: o.side },
+        fps: o.fps,
+        durationMs: o.durationMs,
+        backgroundColor: o.canvasColor,
+        audio: { mode: "off" },
+        assets,
+        sources,
+    };
+}
+/**
+ * The brand logo for the closer: the same M, every tile in one colour (the
+ * app's orange mark). No claims, no edges — the company mark, not the
+ * community record.
+ */
+function buildLogoDoc(o) {
+    return buildTilesDoc({
+        side: o.side,
+        fps: o.fps,
+        durationMs: o.durationMs,
+        claims: new Map(),
+        dormantColor: o.color,
+        canvasColor: o.canvasColor,
+        accentColor: o.color,
+        rootReserved: false,
+    });
+}

package/dist/m0saic/brand/community-m/v1/paths.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Where the bundled Community M seed lives: the `@m0saic/community-m`
+ * workspace package (the public repo's tree, shipped inside the app). Used
+ * when `communityDir` is "" so the template renders at defaults with no
+ * network and no host pre-fill.
+ */
+export declare function seedCommunityDir(): string;
+/**
+ * Inside a packaged Electron app, `require.resolve` points INTO app.asar,
+ * which ffmpeg cannot open; electron-builder's `asarUnpack` mirrors the
+ * files to `app.asar.unpacked/`. Same helper as brand/qr-stamp — a no-op
+ * for the CLI.
+ */
+export declare function unpackedAsarPath(p: string): string;

package/dist/m0saic/brand/community-m/v1/paths.js

@@ -0,0 +1,61 @@
+"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.seedCommunityDir = seedCommunityDir;
+exports.unpackedAsarPath = unpackedAsarPath;
+const path = __importStar(require("path"));
+/**
+ * Where the bundled Community M seed lives: the `@m0saic/community-m`
+ * workspace package (the public repo's tree, shipped inside the app). Used
+ * when `communityDir` is "" so the template renders at defaults with no
+ * network and no host pre-fill.
+ */
+function seedCommunityDir() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const pkgJson = require.resolve("@m0saic/community-m/package.json");
+    return unpackedAsarPath(path.dirname(pkgJson));
+}
+/**
+ * Inside a packaged Electron app, `require.resolve` points INTO app.asar,
+ * which ffmpeg cannot open; electron-builder's `asarUnpack` mirrors the
+ * files to `app.asar.unpacked/`. Same helper as brand/qr-stamp — a no-op
+ * for the CLI.
+ */
+function unpackedAsarPath(p) {
+    const inAsar = `${path.sep}app.asar${path.sep}`;
+    if (!p.includes(inAsar))
+        return p;
+    return p.split(inAsar).join(`${path.sep}app.asar.unpacked${path.sep}`);
+}

package/dist/m0saic/brand/community-m/v1/piece.d.ts

@@ -0,0 +1,28 @@
+import type { MosaicDocument } from "@m0saic/types";
+export type LoadedPiece = {
+    doc: MosaicDocument;
+    declaredMs: number;
+    size: {
+        width: number;
+        height: number;
+    };
+};
+/** How far the canvas starts inside its box before the pop (1/POP_SCALE of its size). */
+export declare const POP_SCALE: number;
+/**
+ * The contributor canvas, ready to pop: a wrapper that declares POP_SCALE×
+ * the fitted box and centres the piece (at its own declared size, contain-
+ * fit to `fitW×fitH`) inside it. Placed into a `fitW×fitH` box, the wrapper
+ * shows the piece at 84 %; a camera zoom 1 → POP_SCALE over `popMs`
+ * magnifies it to exactly the box — a scale-in "pop" from the engine's
+ * crop camera (which only ever magnifies). The wrapper's canvas colour
+ * matches the frame's, so the air around the piece is invisible.
+ */
+export declare function popWrapperDoc(o: {
+    fitW: number;
+    fitH: number;
+    fps: number;
+    durationMs: number;
+    piece: LoadedPiece;
+    canvasColor: string;
+}): MosaicDocument;

package/dist/m0saic/brand/community-m/v1/piece.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POP_SCALE = void 0;
+exports.popWrapperDoc = popWrapperDoc;
+const dsl_stdlib_1 = require("@m0saic/dsl-stdlib");
+/** How far the canvas starts inside its box before the pop (1/POP_SCALE of its size). */
+exports.POP_SCALE = 1 / 0.84;
+/**
+ * The contributor canvas, ready to pop: a wrapper that declares POP_SCALE×
+ * the fitted box and centres the piece (at its own declared size, contain-
+ * fit to `fitW×fitH`) inside it. Placed into a `fitW×fitH` box, the wrapper
+ * shows the piece at 84 %; a camera zoom 1 → POP_SCALE over `popMs`
+ * magnifies it to exactly the box — a scale-in "pop" from the engine's
+ * crop camera (which only ever magnifies). The wrapper's canvas colour
+ * matches the frame's, so the air around the piece is invisible.
+ */
+function popWrapperDoc(o) {
+    const cw = Math.max(o.fitW + 2, Math.round((o.fitW * exports.POP_SCALE) / 2) * 2);
+    const ch = Math.max(o.fitH + 2, Math.round((o.fitH * exports.POP_SCALE) / 2) * 2);
+    // ONE cell + a symmetric inset, not a placeRect grid: centring by margins
+    // costs a slot per pixel of margin (thousands), which drops the layout
+    // under the planner's px-per-weight floor and squashes cells.
+    return {
+        kind: "mosaic_document",
+        version: 1,
+        m0: (0, dsl_stdlib_1.toM0String)("1", "CommunityMV1-pop"),
+        size: { width: cw, height: ch },
+        fps: o.fps,
+        durationMs: o.durationMs,
+        backgroundColor: o.canvasColor,
+        assets: {},
+        children: { piece: { ...o.piece.doc, fps: o.fps, durationMs: o.durationMs } },
+        sources: [{ type: "mosaic", ref: "piece", placement: { fit: "contain", inset: { x: (cw - o.fitW) / 2 / cw, y: (ch - o.fitH) / 2 / ch } } }],
+    };
+}

package/dist/m0saic/brand/community-m/v1/pipeline.d.ts

@@ -0,0 +1,122 @@
+import type { MosaicDocument, MosaicDocumentPipeline } from "@m0saic/types";
+import { type ProvenanceTarget } from "./target";
+import { type ClaimImage, type MarkClaim } from "./mark";
+import type { LoadedPiece } from "./piece";
+import type { ResolvedProps } from "./props";
+import { type ImageSize, type PieceAxis, type Rect } from "./reveal";
+import type { Timeline } from "./timing";
+export type HarnessPlan = {
+    frameW: number;
+    frameH: number;
+    fps: number;
+    props: ResolvedProps;
+    target: ProvenanceTarget;
+    /** Every tile the M paints as claimed — real claims plus any preview stand-ins. */
+    claims: ReadonlyMap<number, MarkClaim>;
+    /** The tile the video is about (the resolved slot, or a preview override). */
+    tileIndex: number;
+    /** That tile's picture: its source, its dimensions (only the aspect matters) and its crop anchor. */
+    photo: {
+        image: ClaimImage;
+        size: ImageSize;
+        focus: {
+            x: number;
+            y: number;
+        };
+    };
+    /** Second caption line (the real slot line, or the preview stand-in line). */
+    tileCaption: string;
+    piece: LoadedPiece;
+    timeline: Timeline;
+    repo: string;
+};
+/**
+ * Caption-band height: ~4.5 % of the frame, nudged to the value in that
+ * band that shares the LARGEST common factor with the frame height.
+ *
+ * Why not just round: the row split is expressed in slots, and feeding raw
+ * pixel counts in makes every frame a 2160-slot split — far past the
+ * planner's px-per-weight floor, where cells quantize and squash (the
+ * `safeMinimumCanvas` convention). Sharing a factor lets the same pixel
+ * boundaries be written as a couple of dozen slots instead.
+ * `gcd(capH, stageH) === gcd(capH, frameH)` because `stageH = frameH − 2·capH`.
+ */
+export declare function captionBandHeight(frameH: number): number;
+/** Frame layout: the stage (the M, camera container) over two caption lines. */
+export declare function frameLayout(frameW: number, frameH: number): {
+    capH: number;
+    stageH: number;
+    side: number;
+    markX: number;
+    markY: number;
+    m0: import("@m0saic/dsl-stdlib").M0String;
+};
+type Layout = ReturnType<typeof frameLayout>;
+/** Where a tile sits inside the stage, in stage pixels. */
+export declare function tileRectInStage(tileIndex: number, layout: Layout): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type PhotoGeometry = {
+    layout: Layout;
+    tile: Rect;
+    zoom: number;
+    /** The original, un-clipped, exactly over its tile crop (frame px). */
+    aligned: Rect;
+    /** The original parked aside for the canvas (same size; moved on `axis` only). */
+    parked: Rect;
+    /** Which way it parks: "x" = left margin, piece to the right; "y" = top margin, piece below. */
+    axis: PieceAxis;
+    /** parked − aligned: the slide (the off-axis one is 0). */
+    dx: number;
+    dy: number;
+    pieceRect: Rect;
+};
+/**
+ * Zoom: the prop, else auto (the tile fills ~55 % of the tighter axis),
+ * then CAPPED so the whole original fits inside the stage with air — the
+ * reveal shows all of it without moving anything — AND so the piece beat
+ * can partition the frame (`zoomPartitionCap`): the parked original and
+ * the contributor canvas never share pixels. A `zoom` prop is a ceiling,
+ * not an override; the contract wins.
+ */
+export declare function resolveZoom(plan: HarnessPlan, layout: Layout): number;
+/** All the reveal / slide / canvas geometry, computed once per render. */
+export declare function photoGeometry(plan: HarnessPlan): PhotoGeometry;
+/** Beat 1+2: the whole M with its identity, then the dolly into the tile. */
+export declare function buildIntroDoc(plan: HarnessPlan, durationMs: number): MosaicDocument;
+/**
+ * Beat 3: parked on the tile, the framed M dissolves while the un-clipped
+ * original fades in EXACTLY over its crop (nothing moves), holds, then
+ * slides aside — left, or up on a frame where that shows more of it — to
+ * make room for the canvas (the partition contract in reveal.ts).
+ */
+export declare function buildRevealDoc(plan: HarnessPlan, durationMs: number): MosaicDocument;
+/**
+ * Beat 4: the original parked aside; the contributor canvas pops into its
+ * box (camera 1 → POP_SCALE on the padded wrapper) and plays at its own
+ * declared size, fading out over the last crossfade.
+ */
+export declare function buildPieceDoc(plan: HarnessPlan, durationMs: number): MosaicDocument;
+/** Beat 5: the original slides back over its tile, then dissolves into the parked M. */
+export declare function buildReturnDoc(plan: HarnessPlan, durationMs: number): MosaicDocument;
+/** Beat 6: back out from the tile to the whole M. */
+export declare function buildOutroDoc(plan: HarnessPlan, durationMs: number): MosaicDocument;
+/**
+ * Beat 7: the brand closer — the m0saic logo, the wordmark, where to claim a
+ * tile. The SAME frame as the outro it dissolves from: the stage row with
+ * the M at `layout.side` on the same pixels (the community M's tiles become
+ * the logo's tiles in place), the identity line becomes the wordmark, the
+ * tile line becomes the repo. Nothing jumps across the crossfade.
+ */
+export declare function buildCloserDoc(plan: HarnessPlan, durationMs: number): MosaicDocument;
+/**
+ * The whole provenance video as an emit:single pipeline under the timing
+ * law. Every join but the last is a CUT on an identical frame (the slide
+ * and the dissolves live inside their steps, so nothing jumps); only the
+ * outro → closer join is a crossfade, carried by the outgoing step.
+ */
+export declare function buildProvenancePipeline(plan: HarnessPlan): MosaicDocumentPipeline;
+export {};