@m0saic/templates 0.2.0

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignedPhotoRect = alignedPhotoRect;
+exports.roundRect = roundRect;
+exports.zoomFitCap = zoomFitCap;
+exports.pieceBeatBudget = pieceBeatBudget;
+exports.pieceAxisFor = pieceAxisFor;
+exports.zoomPartitionCap = zoomPartitionCap;
+exports.assertPieceBeatDisjoint = assertPieceBeatDisjoint;
+exports.pieceBeatLayout = pieceBeatLayout;
+const template_utils_1 = require("@m0saic/template-utils");
+/** Where the tile's whole source image sits on the frame once the camera is parked at `zoom` (frame px, unrounded). */
+function alignedPhotoRect(o) {
+    const Z = o.zoom;
+    const fx = (o.tile.x + o.tile.width / 2) / o.stageW;
+    const fy = (o.tile.y + o.tile.height / 2) / o.stageH;
+    const cx = Z > 1 ? o.stageW * (Z - 1) * (0, template_utils_1.centerFocus)(fx, Z) : 0;
+    const cy = Z > 1 ? o.stageH * (Z - 1) * (0, template_utils_1.centerFocus)(fy, Z) : 0;
+    const s = Math.max(o.tile.width / o.image.width, o.tile.height / o.image.height);
+    const sw = o.image.width * s;
+    const sh = o.image.height * s;
+    const ox = (sw - o.tile.width) * o.focus.x;
+    const oy = (sh - o.tile.height) * o.focus.y;
+    return { x: (o.tile.x - ox) * Z - cx, y: (o.tile.y - oy) * Z - cy, width: sw * Z, height: sh * Z };
+}
+/** Round a frame rect to whole pixels (even sides keep chroma happy). */
+function roundRect(r) {
+    const width = Math.max(2, Math.round(r.width / 2) * 2);
+    const height = Math.max(2, Math.round(r.height / 2) * 2);
+    return { x: Math.round(r.x), y: Math.round(r.y), width, height };
+}
+/**
+ * The largest zoom ≤ `maxZoom` at which the whole original fits inside the
+ * stage with `margin` px of air on every side (so the reveal can show all
+ * of it without moving). Monotone in Z → bisection; never below `minZoom`.
+ *
+ * Kept for callers that only need the stage fit; the provenance pipeline
+ * uses `zoomPartitionCap`, which adds the piece-beat partition.
+ */
+function zoomFitCap(o) {
+    var _a, _b;
+    const minZoom = (_a = o.minZoom) !== null && _a !== void 0 ? _a : 1.02;
+    const fits = (Z) => {
+        const r = alignedPhotoRect({ ...o, zoom: Z });
+        return r.x >= o.margin && r.y >= o.margin && r.x + r.width <= o.stageW - o.margin && r.y + r.height <= o.stageH - o.margin;
+    };
+    return (_b = largestZoom(fits, minZoom, o.maxZoom)) !== null && _b !== void 0 ? _b : minZoom;
+}
+/** Margins, gap and floors for a frame: everything the partition needs. */
+function pieceBeatBudget(frameW, frameH) {
+    const margin = Math.round(Math.min(frameW, frameH) * 0.045);
+    const gap = margin;
+    const pieceMinW = Math.round(frameW * 0.3);
+    const pieceMinH = Math.round(frameH * 0.3);
+    return {
+        margin,
+        gap,
+        pieceMinW,
+        pieceMinH,
+        photoMaxW: frameW - 2 * margin - gap - pieceMinW,
+        photoMaxH: frameH - 2 * margin - gap - pieceMinH,
+    };
+}
+/** Which axis a photo of this size can share the frame on; null = neither (the cap prevents this). */
+function pieceAxisFor(photo, b) {
+    const x = photo.width <= b.photoMaxW;
+    const y = photo.height <= b.photoMaxH;
+    if (x && y)
+        return photo.width / b.photoMaxW <= photo.height / b.photoMaxH ? "x" : "y";
+    if (x)
+        return "x";
+    if (y)
+        return "y";
+    return null;
+}
+/** Largest Z in [minZoom, maxZoom] with pred(Z) true; pred must be monotone (true below some Z, false above). */
+function largestZoom(pred, minZoom, maxZoom) {
+    if (pred(maxZoom))
+        return maxZoom;
+    if (!pred(minZoom))
+        return null;
+    let lo = minZoom, hi = maxZoom;
+    for (let i = 0; i < 40; i++) {
+        const mid = (lo + hi) / 2;
+        if (pred(mid))
+            lo = mid;
+        else
+            hi = mid;
+    }
+    return Math.floor(lo * 1000) / 1000;
+}
+/**
+ * The zoom for the whole reveal → piece → return arc: the largest Z ≤
+ * `maxZoom` at which the original (a) fits inside the stage with `margin`
+ * of air (the reveal shows all of it without moving) AND (b) leaves the
+ * piece its floor on SOME axis. Every photo dimension grows with Z, so both
+ * are monotone and the largest Z on the better axis is the answer. When the
+ * stage fit alone is impossible even at `minZoom` (a very tall original in
+ * a small tile) it is tolerated exactly as before — the original overflows
+ * the frame edge — but the partition is never given up: the pinned
+ * dimension is bounded by the tile, so an axis always exists.
+ */
+function zoomPartitionCap(o) {
+    var _a, _b, _c;
+    const minZoom = (_a = o.minZoom) !== null && _a !== void 0 ? _a : 1.02;
+    const b = pieceBeatBudget(o.frameW, o.frameH);
+    const rectAt = (Z) => alignedPhotoRect({ ...o, zoom: Z });
+    const fitsStage = (r) => r.x >= o.margin && r.y >= o.margin && r.x + r.width <= o.stageW - o.margin && r.y + r.height <= o.stageH - o.margin;
+    const onX = (r) => r.width <= b.photoMaxW;
+    const onY = (r) => r.height <= b.photoMaxH;
+    const best = (extra) => {
+        const zx = largestZoom((Z) => { const r = rectAt(Z); return extra(r) && onX(r); }, minZoom, o.maxZoom);
+        const zy = largestZoom((Z) => { const r = rectAt(Z); return extra(r) && onY(r); }, minZoom, o.maxZoom);
+        if (zx === null && zy === null)
+            return null;
+        return Math.max(zx !== null && zx !== void 0 ? zx : -Infinity, zy !== null && zy !== void 0 ? zy : -Infinity);
+    };
+    return (_c = (_b = best(fitsStage)) !== null && _b !== void 0 ? _b : best(() => true)) !== null && _c !== void 0 ? _c : minZoom;
+}
+/** Throws unless the two rects are separated by at least `gap` on the partition axis. */
+function assertPieceBeatDisjoint(axis, parked, piece, gap) {
+    const ok = axis === "x" ? piece.x >= parked.x + parked.width + gap : piece.y >= parked.y + parked.height + gap;
+    if (!ok) {
+        throw new Error(`community-m: piece-beat layout contract violated on axis ${axis} — parked photo ${JSON.stringify(parked)} vs piece ${JSON.stringify(piece)} (gap ${gap}). This is a bug in the zoom cap, not the inputs.`);
+    }
+}
+/**
+ * The piece beat's geometry. The photo keeps its size; the piece is
+ * contain-fit into the remainder on the chosen axis. Throws when neither
+ * axis has room — which `zoomPartitionCap` makes unreachable; the throw is
+ * the contract, not a code path.
+ */
+function pieceBeatLayout(o) {
+    const b = pieceBeatBudget(o.frameW, o.frameH);
+    const axis = pieceAxisFor(o.photo, b);
+    if (axis === null) {
+        throw new Error(`community-m: the parked original (${o.photo.width}×${o.photo.height}) leaves the contributor canvas no room on a ${o.frameW}×${o.frameH} frame (needs width ≤ ${b.photoMaxW} or height ≤ ${b.photoMaxH}); the zoom cap must run first.`);
+    }
+    const parked = axis === "x" ? { ...o.photo, x: b.margin } : { ...o.photo, y: b.margin };
+    // The remainder past the gap — by construction on the far side of the photo.
+    const area = axis === "x"
+        ? { x: parked.x + parked.width + b.gap, y: b.margin, width: o.frameW - b.margin - (parked.x + parked.width + b.gap), height: o.frameH - 2 * b.margin }
+        : { x: b.margin, y: parked.y + parked.height + b.gap, width: o.frameW - 2 * b.margin, height: o.frameH - b.margin - (parked.y + parked.height + b.gap) };
+    const scale = Math.min(area.width / o.piece.width, area.height / o.piece.height);
+    const width = Math.max(2, Math.floor((o.piece.width * scale) / 2) * 2);
+    const height = Math.max(2, Math.floor((o.piece.height * scale) / 2) * 2);
+    const pieceRect = {
+        x: area.x + Math.round((area.width - width) / 2),
+        y: area.y + Math.round((area.height - height) / 2),
+        width,
+        height,
+    };
+    assertPieceBeatDisjoint(axis, parked, pieceRect, b.gap);
+    return { axis, parked, parkedX: parked.x, parkedY: parked.y, dx: parked.x - o.photo.x, dy: parked.y - o.photo.y, pieceRect, gap: b.gap };
+}

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

@@ -0,0 +1,57 @@
+import type { MosaicDocument } from "@m0saic/types";
+/**
+ * The founder's piece for the root tile of Community M #001 — the seed
+ * `ms/001/root/piece.mosaic`, the canvas that pops in beside the original
+ * in the provenance video and the reference every contributor copies.
+ *
+ * "Mosaic itself — the first contribution": the M assembles from its own
+ * 26 rectangles (dormant grey flying in and turning the accent, the
+ * hello-world assembly); the 7 V-leg pieces drawbox cannot draw FADE in as
+ * the last rects land (never a snap — the founder's note, 2026-09-16);
+ * then the line rises in: one tile, forever.
+ *
+ * DATA ONLY, like any contributor's piece (`validateCommunityPiece`): a
+ * colour surface, drawbox tracks, one masked colour tile, one svg text
+ * layer. No media, no assets. Regenerate the committed file with
+ * `node dist/m0saic/brand/community-m/v1/gen-seed-piece.js`; the test pins
+ * the committed bytes to this builder so the two cannot drift.
+ */
+/** Square canvas — the same navy / accent / ink the harness renders at defaults. */
+export declare const SEED_PIECE_SIDE = 1080;
+export declare const SEED_PIECE_DURATION_MS = 4000;
+export declare const SEED_PIECE_FPS = 30;
+export declare const SEED_PIECE_LINE = "one tile, forever";
+/** The beats, in piece seconds (the harness pops the canvas in over its first ~0.45 s). */
+export declare const SEED_PIECE_TIMELINE: {
+    readonly assembleStart: 0.4;
+    readonly assembleDur: 1;
+    /** The V-legs fade in (smoothstep) while the last rects settle — starting
+     *  before the assembly lands (1.4 s), so the M completes in one motion
+     *  (founder, 2026-09-16: at 1.25 s the legs registered as late). */
+    readonly legsStart: 1.05;
+    readonly legsDur: 0.6;
+    readonly lineStart: 1.9;
+    readonly lineDur: 0.5;
+};
+type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/** Layout: the M over the line, centred, a hair above the middle. */
+export declare function seedPieceLayout(S?: number): {
+    mark: Rect;
+    line: Rect;
+};
+/**
+ * The 7 diagonal V-leg pieces of the brand M — every subpath of the
+ * silhouette whose box is NOT one of the 26 rects the assembly draws (a
+ * rect can be drawn with `L` segments, so the test is geometric).
+ */
+export declare function mLegPaths(): string[];
+/** The seed piece as a document — pure; the same bytes every call. */
+export declare function buildSeedPiece(): MosaicDocument;
+/** The committed file's exact text: 2-space JSON + trailing newline. */
+export declare function seedPieceJson(): string;
+export {};

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

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEED_PIECE_TIMELINE = exports.SEED_PIECE_LINE = exports.SEED_PIECE_FPS = exports.SEED_PIECE_DURATION_MS = exports.SEED_PIECE_SIDE = void 0;
+exports.seedPieceLayout = seedPieceLayout;
+exports.mLegPaths = mLegPaths;
+exports.buildSeedPiece = buildSeedPiece;
+exports.seedPieceJson = seedPieceJson;
+const template_utils_1 = require("@m0saic/template-utils");
+/**
+ * The founder's piece for the root tile of Community M #001 — the seed
+ * `ms/001/root/piece.mosaic`, the canvas that pops in beside the original
+ * in the provenance video and the reference every contributor copies.
+ *
+ * "Mosaic itself — the first contribution": the M assembles from its own
+ * 26 rectangles (dormant grey flying in and turning the accent, the
+ * hello-world assembly); the 7 V-leg pieces drawbox cannot draw FADE in as
+ * the last rects land (never a snap — the founder's note, 2026-09-16);
+ * then the line rises in: one tile, forever.
+ *
+ * DATA ONLY, like any contributor's piece (`validateCommunityPiece`): a
+ * colour surface, drawbox tracks, one masked colour tile, one svg text
+ * layer. No media, no assets. Regenerate the committed file with
+ * `node dist/m0saic/brand/community-m/v1/gen-seed-piece.js`; the test pins
+ * the committed bytes to this builder so the two cannot drift.
+ */
+/** Square canvas — the same navy / accent / ink the harness renders at defaults. */
+exports.SEED_PIECE_SIDE = 1080;
+exports.SEED_PIECE_DURATION_MS = 4000;
+exports.SEED_PIECE_FPS = 30;
+exports.SEED_PIECE_LINE = "one tile, forever";
+const CANVAS = "#0E1220";
+const ACCENT = "#f97316";
+const DORMANT = "#34343A";
+const INK = "#F4F4F5";
+/** The beats, in piece seconds (the harness pops the canvas in over its first ~0.45 s). */
+exports.SEED_PIECE_TIMELINE = {
+    assembleStart: 0.4,
+    assembleDur: 1.0,
+    /** The V-legs fade in (smoothstep) while the last rects settle — starting
+     *  before the assembly lands (1.4 s), so the M completes in one motion
+     *  (founder, 2026-09-16: at 1.25 s the legs registered as late). */
+    legsStart: 1.05,
+    legsDur: 0.6,
+    lineStart: 1.9,
+    lineDur: 0.5,
+};
+/** Layout: the M over the line, centred, a hair above the middle. */
+function seedPieceLayout(S = exports.SEED_PIECE_SIDE) {
+    const side = Math.round(S * 0.54);
+    const mark = { x: Math.round((S - side) / 2), y: Math.round(S * 0.139), w: side, h: side };
+    const lineH = Math.round(S * 0.118);
+    const line = { x: Math.round(S * 0.074), y: Math.round(S * 0.737), w: S - 2 * Math.round(S * 0.074), h: lineH };
+    return { mark, line };
+}
+/** Bounding box of one absolute M/L/H/V/Z subpath of the silhouette (272-space). */
+function subpathBBox(d) {
+    var _a;
+    const tokens = (_a = d.match(/[MLHVZ]|-?\d*\.?\d+(?:e-?\d+)?/gi)) !== null && _a !== void 0 ? _a : [];
+    let cmd = "M", x = 0, y = 0, pending = null;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    const mark = () => { minX = Math.min(minX, x); maxX = Math.max(maxX, x); minY = Math.min(minY, y); maxY = Math.max(maxY, y); };
+    for (const tok of tokens) {
+        if (/^[MLHVZ]$/i.test(tok)) {
+            cmd = tok.toUpperCase();
+            pending = null;
+            continue;
+        }
+        const n = Number(tok);
+        if (cmd === "H") {
+            x = n;
+            mark();
+        }
+        else if (cmd === "V") {
+            y = n;
+            mark();
+        }
+        else if (pending === null)
+            pending = n;
+        else {
+            x = pending;
+            y = n;
+            pending = null;
+            mark();
+        }
+    }
+    return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+}
+/**
+ * The 7 diagonal V-leg pieces of the brand M — every subpath of the
+ * silhouette whose box is NOT one of the 26 rects the assembly draws (a
+ * rect can be drawn with `L` segments, so the test is geometric).
+ */
+function mLegPaths() {
+    const isRect = (b) => template_utils_1.M_RECTS.some(([x, y, w, h]) => Math.abs(b.x - x) < 0.25 && Math.abs(b.y - y) < 0.25 && Math.abs(b.w - w) < 0.25 && Math.abs(b.h - h) < 0.25);
+    return template_utils_1.HEADER_M_GLYPH.path.split(/(?=M)/).map((d) => d.trim()).filter((d) => d && !isRect(subpathBBox(d)));
+}
+const r3 = (n) => Number(n.toFixed(3));
+function ramp(atSec, durSec) {
+    return (0, template_utils_1.easingExpr)("easeOut", (0, template_utils_1.progressExpr)(r3(atSec), Math.max(0.001, r3(durSec))));
+}
+/** Fade in place — a gentle smoothstep, no onset the eye reads as a pop. */
+function fadeIn(atSec, durSec) {
+    return { alpha: (0, template_utils_1.easingExpr)("smoothstep", (0, template_utils_1.progressExpr)(r3(atSec), Math.max(0.001, r3(durSec)))), startAtSec: r3(atSec), window: { startSec: r3(atSec) } };
+}
+/** Rise in from `dyPx` below while fading up. */
+function riseIn(atSec, durSec, dyPx) {
+    const p = ramp(atSec, durSec);
+    return { alpha: p, yExpr: `(1-${p})*${dyPx}`, startAtSec: r3(atSec), window: { startSec: r3(atSec) } };
+}
+/** The seed piece as a document — pure; the same bytes every call. */
+function buildSeedPiece() {
+    const S = exports.SEED_PIECE_SIDE;
+    const t = exports.SEED_PIECE_TIMELINE;
+    const { mark, line } = seedPieceLayout(S);
+    const full = { x: 0, y: 0, w: S, h: S };
+    const assembly = (0, template_utils_1.markAssembly)({
+        W: S,
+        H: S,
+        S,
+        mark,
+        startSec: t.assembleStart,
+        durSec: t.assembleDur,
+        fps: exports.SEED_PIECE_FPS,
+        fromColor: DORMANT,
+        toColor: ACCENT,
+    });
+    const legs = { bounds: template_utils_1.HEADER_M_GLYPH.bounds, path: mLegPaths().join(" ") };
+    const pieces = [
+        { rect: { ...full, importance: 0 }, source: (0, template_utils_1.makeColorTile)(CANVAS) },
+        ...(0, template_utils_1.assemblyTracks)(assembly.boxes, ACCENT).map((source, i) => ({ rect: { ...full, importance: 1 + i }, source })),
+        { rect: { ...mark, importance: 10 }, source: { ...(0, template_utils_1.brandGlyphTile)(legs, ACCENT), overlay: fadeIn(t.legsStart, t.legsDur) } },
+        {
+            rect: { ...line, importance: 11 },
+            source: { ...(0, template_utils_1.svgLabel)(exports.SEED_PIECE_LINE, line.w, line.h, { color: INK, maxPx: Math.round(S * 0.07), maxLines: 1 }), overlay: riseIn(t.lineStart, t.lineDur, Math.round(S * 0.03)) },
+        },
+    ];
+    const placed = (0, template_utils_1.placeInsetPieces)({ rootW: S, rootH: S, pieces });
+    return {
+        kind: "mosaic_document",
+        version: 1,
+        m0: placed.m0,
+        size: { width: S, height: S },
+        fps: exports.SEED_PIECE_FPS,
+        durationMs: exports.SEED_PIECE_DURATION_MS,
+        backgroundColor: CANVAS,
+        assets: {},
+        sources: placed.sources,
+    };
+}
+/** The committed file's exact text: 2-space JSON + trailing newline. */
+function seedPieceJson() {
+    return JSON.stringify(buildSeedPiece(), null, 2) + "\n";
+}

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

@@ -0,0 +1,88 @@
+import type { CommunityMEntry, CommunityMManifest, CommunityMSlot } from "@m0saic/types";
+import type { ClaimImage, MarkClaim } from "./mark";
+import { type PreviewOptions, type PreviewPhoto } from "./preview";
+import type { ResolvedPreview } from "./props";
+/**
+ * Everything the harness needs about ONE tile of ONE Community M, with no
+ * filesystem in sight. The node entry hands it real file paths; the browser
+ * entry hands it nothing and every picture becomes a stand-in.
+ */
+export type ProvenanceTarget = {
+    manifest: CommunityMManifest;
+    entry: CommunityMEntry;
+    /** The slot the video is about (a contributor claim, the root award, or a stood-up preview). */
+    slot: CommunityMSlot;
+    /** The slot's tile picture, or null when there is no readable file for it. */
+    tileImage: ClaimImage | null;
+    /** Tile index → picture + slot for every claim the M shows (per `asOf`). */
+    claimedTiles: Map<number, {
+        image: ClaimImage;
+        slot: CommunityMSlot;
+    }>;
+    /** Whether the root reads as awarded in this view. */
+    rootShown: boolean;
+    /**
+     * True when nobody has claimed this slot and the dev preview stood it up
+     * anyway: the picture and the canvas are generated, not read from the repo.
+     */
+    synthetic: boolean;
+};
+export type BuildTargetResult = {
+    ok: true;
+    target: ProvenanceTarget;
+} | {
+    ok: false;
+    error: string;
+};
+export type BuildTargetOptions = {
+    m: string;
+    tile: string;
+    asOf: "now" | "claim";
+    allowUnclaimed?: boolean;
+    /**
+     * The picture for a slot, or null when it cannot be read here (a claim
+     * whose file is missing, or the browser, which has no files at all). A
+     * null picture paints as dormant rather than failing the render.
+     */
+    pictureFor: (slot: CommunityMSlot) => ClaimImage | null;
+};
+/** Resolve the M, the slot and the claims to paint. Never throws. */
+export declare function buildTarget(manifest: CommunityMManifest, o: BuildTargetOptions): BuildTargetResult;
+/**
+ * The slot an unclaimed reference WOULD become: claim N takes the N-th tile
+ * of the M's own deal order, and "root" is always the V-tip. Everything else
+ * (a handle nobody holds) has no tile to stand up.
+ */
+export declare function syntheticSlot(entry: CommunityMEntry, tileRef: string): CommunityMSlot | null;
+/** "Community M #001 - opened 2026-04-15 - in progress" / "… - completed 2026-06-05". */
+export declare function identityLine(entry: CommunityMEntry): string;
+/** "tile 32 - root - @m0saic-dev - 2026-04-15" / "tile 20 - claim 1 of 32 - @octocat - 2026-05-01". */
+export declare function tileLine(entry: CommunityMEntry, slot: CommunityMSlot): string;
+/** True when any dev lever is on — which is also what lets an unclaimed tile stand up. */
+export declare function previewIsOn(pv: ResolvedPreview): boolean;
+export type Subject = {
+    tileIndex: number;
+    standIn: boolean;
+    caption: string;
+    photo: PreviewPhoto | null;
+};
+/**
+ * The "Subject tile" lever speaks AWARD ORDER, the one number the Community
+ * page, the caption ("claim 1 of 32") and the "claims" lever all agree on:
+ * claim N (1..32) is `entry.claimOrder[N-1]`, 0 is the root. The geometry
+ * index (0..32 in mark order) is an implementation detail nobody sees —
+ * exposing it here is what made "Subject tile 1" light a tile the Community
+ * page lists fifteenth (founder, 2026-09-16).
+ */
+export declare function awardToTileIndex(entry: CommunityMEntry, claimNo: number): {
+    tileIndex: number;
+    claimNo: number | null;
+};
+/**
+ * Which tile the video is about: the explicit lever wins, else the tile the
+ * slot resolves to. It is a stand-in whenever nobody really holds it (or
+ * whenever its picture cannot be read here).
+ */
+export declare function subjectOf(target: ProvenanceTarget, pv: ResolvedPreview): Subject;
+/** Every tile the M paints as claimed: the real claims, plus stand-ins for the levers. */
+export declare function harnessClaims(target: ProvenanceTarget, pv: ResolvedPreview, subject: Subject, simulate: (entry: CommunityMEntry, real: ReadonlySet<number>, o: PreviewOptions) => Map<number, MarkClaim>): Map<number, MarkClaim>;

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTarget = buildTarget;
+exports.syntheticSlot = syntheticSlot;
+exports.identityLine = identityLine;
+exports.tileLine = tileLine;
+exports.previewIsOn = previewIsOn;
+exports.awardToTileIndex = awardToTileIndex;
+exports.subjectOf = subjectOf;
+exports.harnessClaims = harnessClaims;
+const types_1 = require("@m0saic/types");
+const platform_1 = require("@m0saic/platform");
+const preview_1 = require("./preview");
+/** Resolve the M, the slot and the claims to paint. Never throws. */
+function buildTarget(manifest, o) {
+    const r = (0, platform_1.resolveCommunitySlot)(manifest, o.m, o.tile);
+    // An UNCLAIMED slot is normally the end of the road — there is no
+    // provenance to tell. With the dev preview on it is the whole point: stand
+    // the slot up so its tile's zoom and framing can be designed now.
+    if (!r.ok && !(r.code === "UNCLAIMED" && o.allowUnclaimed)) {
+        return { ok: false, error: r.code === "UNCLAIMED" ? `${r.error}. Turn on Dev preview (filled tiles, or a generated canvas) to preview it anyway.` : r.error };
+    }
+    const entry = r.ok ? r.m : manifest.ms.find((e) => e.id === o.m);
+    if (!entry)
+        return { ok: false, error: `Community M "${o.m}" not found` };
+    const synthetic = !r.ok;
+    const slot = r.ok ? r.slot : syntheticSlot(entry, o.tile);
+    if (!slot)
+        return { ok: false, error: `tile "${o.tile}" does not name a slot of Community M ${o.m}` };
+    const cutoff = o.asOf === "claim" ? slot.claimedAt : null;
+    const visible = (s) => cutoff === null || s.claimedAt <= cutoff;
+    const claimedTiles = new Map();
+    const add = (s) => {
+        const image = o.pictureFor(s);
+        if (image)
+            claimedTiles.set(s.tileIndex, { image, slot: s });
+    };
+    for (const s of entry.slots)
+        if (visible(s))
+            add(s);
+    const rootShown = !!entry.root.slot && visible(entry.root.slot);
+    if (entry.root.slot && rootShown)
+        add(entry.root.slot);
+    const tileImage = synthetic ? null : o.pictureFor(slot);
+    return { ok: true, target: { manifest, entry, slot, tileImage, claimedTiles, rootShown, synthetic } };
+}
+/**
+ * The slot an unclaimed reference WOULD become: claim N takes the N-th tile
+ * of the M's own deal order, and "root" is always the V-tip. Everything else
+ * (a handle nobody holds) has no tile to stand up.
+ */
+function syntheticSlot(entry, tileRef) {
+    var _a;
+    const ref = tileRef.trim();
+    const at = (tileIndex, slot, stableKey) => {
+        var _a;
+        return ({
+            slot, tileIndex, stableKey,
+            handle: "preview", displayName: "Preview",
+            claimedAt: (_a = entry.openedAt) !== null && _a !== void 0 ? _a : "",
+            tile: "", piece: "",
+        });
+    };
+    if (ref.toLowerCase() === "root" || ref === "0")
+        return at(types_1.COMMUNITY_M_TIP_TILE_INDEX, 0, types_1.COMMUNITY_M_TIP_STABLE_KEY);
+    if (!/^\d+$/.test(ref))
+        return null;
+    const n = Number(ref);
+    const tileIndex = entry.claimOrder[n - 1];
+    if (tileIndex === undefined)
+        return null;
+    const key = (_a = platform_1.M_TILES.find((t) => t.tileIndex === tileIndex)) === null || _a === void 0 ? void 0 : _a.stableKey;
+    return key ? at(tileIndex, n, key) : null;
+}
+/** "Community M #001 - opened 2026-04-15 - in progress" / "… - completed 2026-06-05". */
+function identityLine(entry) {
+    const opened = entry.openedAt ? `opened ${entry.openedAt.slice(0, 10)}` : "not yet open";
+    const state = entry.completedAt ? `completed ${entry.completedAt.slice(0, 10)}` : entry.status === "locked" ? "locked" : "in progress";
+    return `${entry.title} - ${opened} - ${state}`;
+}
+/** "tile 32 - root - @m0saic-dev - 2026-04-15" / "tile 20 - claim 1 of 32 - @octocat - 2026-05-01". */
+function tileLine(entry, slot) {
+    const which = slot.slot === 0 ? "root" : `claim ${slot.slot} of ${entry.capacity}`;
+    return `tile ${slot.tileIndex} - ${which} - @${slot.handle} - ${slot.claimedAt.slice(0, 10)}`;
+}
+// ── The subject of the video, and what the M paints ──────────────────────
+/** True when any dev lever is on — which is also what lets an unclaimed tile stand up. */
+function previewIsOn(pv) {
+    return pv.claims > 0 || pv.tile !== null || pv.piece !== "off";
+}
+/**
+ * The "Subject tile" lever speaks AWARD ORDER, the one number the Community
+ * page, the caption ("claim 1 of 32") and the "claims" lever all agree on:
+ * claim N (1..32) is `entry.claimOrder[N-1]`, 0 is the root. The geometry
+ * index (0..32 in mark order) is an implementation detail nobody sees —
+ * exposing it here is what made "Subject tile 1" light a tile the Community
+ * page lists fifteenth (founder, 2026-09-16).
+ */
+function awardToTileIndex(entry, claimNo) {
+    if (claimNo <= 0)
+        return { tileIndex: entry.root.tileIndex, claimNo: null };
+    const tileIndex = entry.claimOrder[claimNo - 1];
+    if (tileIndex === undefined)
+        throw new Error(`community-m: claim ${claimNo} is past this M's award order (${entry.claimOrder.length} claims)`);
+    return { tileIndex, claimNo };
+}
+/**
+ * Which tile the video is about: the explicit lever wins, else the tile the
+ * slot resolves to. It is a stand-in whenever nobody really holds it (or
+ * whenever its picture cannot be read here).
+ */
+function subjectOf(target, pv) {
+    const lever = pv.tile === null ? null : awardToTileIndex(target.entry, pv.tile);
+    const tileIndex = lever ? lever.tileIndex : target.slot.tileIndex;
+    const standIn = pv.tile !== null || target.tileImage === null;
+    return {
+        tileIndex,
+        standIn,
+        caption: standIn ? (0, preview_1.previewTileLine)(tileIndex, pv.style, lever ? lever.claimNo : null, target.entry.capacity) : tileLine(target.entry, target.slot),
+        photo: standIn ? (0, preview_1.standInPhoto)(tileIndex, pv) : null,
+    };
+}
+/** Every tile the M paints as claimed: the real claims, plus stand-ins for the levers. */
+function harnessClaims(target, pv, subject, simulate) {
+    const claims = new Map();
+    for (const [i, c] of target.claimedTiles)
+        claims.set(i, { image: c.image, ...(c.slot.focus ? { focus: c.slot.focus } : {}) });
+    const opts = { ...pv, tile: subject.standIn ? subject.tileIndex : null };
+    for (const [i, c] of simulate(target.entry, new Set(claims.keys()), opts))
+        claims.set(i, c);
+    return claims;
+}

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

@@ -0,0 +1,32 @@
+import type { MosaicEngineContext } from "@m0saic/types";
+import type { ResolvedProps } from "./props";
+export type Timeline = {
+    introVisibleMs: number;
+    introHoldMs: number;
+    zoomMs: number;
+    tileHoldMs: number;
+    revealMs: number;
+    /** The original's slide aside (and back). */
+    slideMs: number;
+    /** The canvas pop at the top of the piece beat (inside pieceVisibleMs). */
+    popMs: number;
+    pieceVisibleMs: number;
+    outroMs: number;
+    closerMs: number;
+    xfadeMs: number;
+    totalMs: number;
+    source: "natural" | "pinned";
+};
+/**
+ * Visible time per beat. The stitched pipeline equals `totalMs` exactly
+ * (fades ride on the outgoing step). A pinned duration (`--durationMs` /
+ * Make) is honoured by shrinking the piece window first, then scaling the
+ * harness beats; below the floor the caller shows an error card.
+ */
+export declare function resolveTimeline(p: ResolvedProps, declaredPieceMs: number, ctx: MosaicEngineContext): {
+    ok: true;
+    timeline: Timeline;
+} | {
+    ok: false;
+    error: string;
+};