@m0saic/templates 0.2.0

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityMV1 = void 0;
+const types_1 = require("@m0saic/types");
+const template_utils_1 = require("@m0saic/template-utils");
+const loadPiece_node_1 = require("./loadPiece.node");
+const preview_1 = require("./preview");
+const imageSize_node_1 = require("./imageSize.node");
+const target_1 = require("./target");
+const pipeline_1 = require("./pipeline");
+const props_1 = require("./props");
+const manifest_1 = require("./manifest");
+const timing_1 = require("./timing");
+/**
+ * `@m0saic/brand/community-m/v1` — the provenance video for one tile of the
+ * Community M.
+ *
+ * Beats (founder shot list, 2026-09-06):
+ *   1. The M with its identity (which M, opened / completed), claimed tiles
+ *      as their images with the orange edge, open tiles dormant.
+ *   2. A dolly into the chosen tile.
+ *   3. The M dissolves while the tile's un-clipped original fades in EXACTLY
+ *      over its crop (nothing moves), then slides aside.
+ *   4. The contributor's canvas pops into its box beside the original and
+ *      plays at its own declared size (vertical allowed).
+ *   5. The original slides back and dissolves into the M; the camera backs
+ *      out to the whole M; then the brand closer — the same frame, the M's
+ *      tiles turning into the logo in place, the wordmark and the repo in
+ *      the caption rows.
+ *
+ * m0saic owns the harness; the piece is the contributor's (data only,
+ * validated). Everything is read from a community-m folder — the bundled
+ * seed by default, the app / CLI cache when the host pre-fills it. No
+ * network, no randomness; the same folder renders the same bytes.
+ */
+exports.CommunityMV1 = (0, template_utils_1.defineMosaicTemplate)({
+    id: (0, types_1.asTemplateId)("@m0saic/brand/community-m/v1"),
+    label: "Community M — Provenance",
+    version: 1,
+    // BITMAP drafting mode (handbook §3c): the split counts ARE the m0saic M as a traced bitmap —
+    // never live-composed, so the latticeSmooth convention does not apply.
+    lattice: { mode: "bitmap" },
+    description: "Your tile's provenance video: the Community M with its identity, a zoom into your tile, your original image, your own canvas, then back to the M. Renders from the community-m repo — no app release needed for new claims.",
+    capabilities: { tier: "core" },
+    tags: ["brand", "community-m", "provenance", "animated", "designers", "developers", "community", "open-source"],
+    outputHints: {
+        width: 3840,
+        height: 2160,
+        fps: 30,
+        durationMs: 19100,
+        note: "Official 4K canvas; the M renders at 7× (1904 px). The natural length is the harness plus the piece's declared duration (capped by pieceMaxMs).",
+        format: { kind: "video", container: "mp4" },
+    },
+    propsSchema: props_1.propsSchema,
+    defaultProps: props_1.DEFAULT_PROPS,
+    async render(props, ctx) {
+        var _a, _b, _c;
+        const frameW = ctx.output.width;
+        const frameH = ctx.output.height;
+        const fps = ctx.target.fps;
+        const fail = (title, message) => (0, template_utils_1.makeErrorMosaic)(message, { title: `${this.id} ${title}`, width: frameW, height: frameH });
+        const rp = (0, props_1.resolveProps)(props);
+        if (!rp.ok)
+            return fail("props", rp.errors.join(" | "));
+        const p = rp.value;
+        if (Math.min(frameW, frameH) < 340)
+            return fail("canvas", `canvas too small: the short side must be at least 340 px (got ${frameW}×${frameH})`);
+        // ── Dev levers (preview.ts): stand-in claims, a stand-in subject tile,
+        //    a generated canvas. All off by default — the defaults render the
+        //    real seed exactly as they always did. With any lever on, an
+        //    UNCLAIMED tile stands up as a stand-in instead of erroring: that is
+        //    how you design the zoom and framing for tiles nobody holds yet.
+        const pv = p.preview;
+        const rt = (0, manifest_1.resolveTarget)({ communityDir: p.communityDir, m: p.m, tile: p.tile, asOf: p.asOf, allowUnclaimed: (0, target_1.previewIsOn)(pv) });
+        if (!rt.ok)
+            return fail("target", rt.error);
+        const target = rt.target;
+        const subject = (0, target_1.subjectOf)(target, pv);
+        const claims = (0, target_1.harnessClaims)(target, pv, subject, preview_1.simulatedClaims);
+        const photo = (_a = subject.photo) !== null && _a !== void 0 ? _a : {
+            image: target.tileImage,
+            size: (0, imageSize_node_1.readImageSize)(target.tileImage.path),
+            focus: (_b = target.slot.focus) !== null && _b !== void 0 ? _b : { x: 0.5, y: 0.5 },
+        };
+        let piece;
+        if (pv.piece !== "off" || target.synthetic) {
+            // A stood-up slot has no piece on disk, so it always gets a card.
+            piece = (0, preview_1.previewPiece)({ style: pv.piece === "off" ? "lorem" : pv.piece, aspect: pv.pieceAspect, fps, canvasColor: p.canvasColor, accentColor: p.accentColor, textColor: p.textColor });
+        }
+        else {
+            const lp = (0, loadPiece_node_1.loadPiece)((0, manifest_1.pieceAbsFor)(rt.dir, target.slot));
+            if (!lp.ok)
+                return fail("piece", lp.error);
+            piece = lp.piece;
+        }
+        const tl = (0, timing_1.resolveTimeline)(p, piece.declaredMs, ctx);
+        if (!tl.ok)
+            return fail("duration", tl.error);
+        const plan = {
+            frameW,
+            frameH,
+            fps,
+            props: p,
+            target,
+            claims,
+            tileIndex: subject.tileIndex,
+            photo,
+            tileCaption: subject.caption,
+            piece,
+            timeline: tl.timeline,
+            repo: (_c = target.manifest.repo) !== null && _c !== void 0 ? _c : "m0saic-project/community-m",
+        };
+        return (0, pipeline_1.buildProvenancePipeline)(plan);
+    },
+});
+(0, template_utils_1.registerTemplate)(exports.CommunityMV1);
+exports.default = exports.CommunityMV1;

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

@@ -0,0 +1,3 @@
+import { type CommunityMProvenanceProps } from "./props";
+export declare const CommunityMV1Web: import("@m0saic/types").MosaicTemplate<CommunityMProvenanceProps, import("@m0saic/types").MosaicTemplateOutputs, import("@m0saic/types").MosaicTemplateUpstreamVariables, import("@m0saic/types").MosaicTemplateUpstreamData, import("@m0saic/types").MosaicTemplateSidecars>;
+export default CommunityMV1Web;

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

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityMV1Web = void 0;
+const types_1 = require("@m0saic/types");
+const template_utils_1 = require("@m0saic/template-utils");
+const platform_1 = require("@m0saic/platform");
+const index_json_1 = __importDefault(require("@m0saic/community-m/index.json"));
+const pipeline_1 = require("./pipeline");
+const preview_1 = require("./preview");
+const props_1 = require("./props");
+const target_1 = require("./target");
+const timing_1 = require("./timing");
+const webPiece_1 = require("./webPiece");
+/**
+ * `@m0saic/brand/community-m/v1` — BROWSER build.
+ *
+ * The same id and the same beats as the desktop template, assembled from
+ * the same node-free modules (`target` / `pipeline` / `mark` / `preview`).
+ * Only one of the two entries is ever bundled: `../../../../web.ts` imports
+ * THIS one, `./community-m` is the node one.
+ *
+ * The web app SERVES the bundled seed's tile images (the copy step puts them
+ * under `/community-m/…`), so the real claims paint their real pictures here
+ * through `kind: "url"` assets — the founder's own provenance video is the
+ * real thing in the browser, not an impression of it. Only what the browser
+ * genuinely cannot reach falls back: a community-m folder of your own, and a
+ * contributor's `.mosaic` canvas when it is not among the served files. Those
+ * say so and point at Mosaic Desktop rather than quietly rendering something
+ * else.
+ */
+const DESKTOP = "Mosaic Desktop renders this for real.";
+/** Where the web app serves the bundled seed's tile images from. */
+const SEED_TILE_BASE = "/community-m";
+/**
+ * A served tile's real pixel dimensions. Only the ASPECT matters (it decides
+ * how the un-clipped original is sized over its tile crop), and the browser
+ * is the only thing here that can read it — so decode the image the preview
+ * is about to load anyway. Anything unreadable falls back to square, which
+ * is right for the tiles the rules ask for.
+ */
+async function imageSizeOf(image) {
+    try {
+        if (image.kind !== "url" || typeof Image === "undefined")
+            return { width: 1, height: 1 };
+        const img = new Image();
+        img.src = image.url;
+        await img.decode();
+        if (img.naturalWidth > 0 && img.naturalHeight > 0)
+            return { width: img.naturalWidth, height: img.naturalHeight };
+    }
+    catch {
+        /* a 404 or a decode failure — the harness still runs, square-ish */
+    }
+    return { width: 1, height: 1 };
+}
+/**
+ * Browser overrides for the dev levers — none. The seed's tiles AND pieces
+ * are served, so the defaults render the real video here exactly as they do
+ * on the desktop; the levers behave identically.
+ */
+const WEB_PREVIEW = {};
+function webProps(props) {
+    var _a;
+    const given = Object.fromEntries(Object.entries((_a = props.preview) !== null && _a !== void 0 ? _a : {}).filter(([, v]) => v !== undefined));
+    return { ...props, preview: { ...WEB_PREVIEW, ...given } };
+}
+exports.CommunityMV1Web = (0, template_utils_1.defineMosaicTemplate)({
+    id: (0, types_1.asTemplateId)("@m0saic/brand/community-m/v1"),
+    label: "Community M — Provenance",
+    version: 1,
+    // BITMAP drafting mode (handbook §3c): the split counts ARE the m0saic M as a traced bitmap —
+    // never live-composed, so the latticeSmooth convention does not apply.
+    lattice: { mode: "bitmap" },
+    description: "Your tile's provenance video: the Community M with its identity, a zoom into your tile, your original image, your own canvas, then back to the M. In the browser the pictures are stand-ins — Mosaic Desktop renders the real repo.",
+    capabilities: { tier: "core" },
+    tags: ["brand", "community-m", "provenance", "animated"],
+    outputHints: {
+        width: 3840,
+        height: 2160,
+        fps: 30,
+        durationMs: 19100,
+        note: "Official 4K canvas; the M renders at 7x (1904 px). In the browser every tile is a stand-in and the canvas is a generated card.",
+        format: { kind: "video", container: "mp4" },
+    },
+    propsSchema: props_1.propsSchema,
+    // The browser opens on a full, alive M with a generated canvas — the real
+    // seed has one claim and no readable pictures here, so an empty M would be
+    // a worse first impression than an honest simulated one.
+    defaultProps: props_1.DEFAULT_PROPS,
+    async render(props, ctx) {
+        var _a, _b, _c;
+        const frameW = ctx.output.width;
+        const frameH = ctx.output.height;
+        const fps = ctx.target.fps;
+        const fail = (title, message) => (0, template_utils_1.makeErrorMosaic)(message, { title: `${this.id} ${title}`, width: frameW, height: frameH });
+        const rp = (0, props_1.resolveProps)(webProps(props));
+        if (!rp.ok)
+            return fail("props", rp.errors.join(" | "));
+        const p = rp.value;
+        if (Math.min(frameW, frameH) < 340)
+            return fail("canvas", `canvas too small: the short side must be at least 340 px (got ${frameW}x${frameH})`);
+        // The two things the browser genuinely cannot do.
+        if (p.communityDir.trim() !== "") {
+            return fail("desktop only", `Reading a community-m folder needs the filesystem. ${DESKTOP} Here, leave the folder empty and use Dev preview.`);
+        }
+        const parsed = (0, platform_1.parseCommunityMManifest)(index_json_1.default);
+        if (!parsed.ok)
+            return fail("seed", `bundled community-m seed is invalid: ${parsed.error}`);
+        // The served seed: a claim's tile is a real URL the browser can load.
+        const rt = (0, target_1.buildTarget)(parsed.manifest, {
+            m: p.m,
+            tile: p.tile,
+            asOf: p.asOf,
+            allowUnclaimed: (0, target_1.previewIsOn)(p.preview),
+            pictureFor: (slot) => (slot.tile ? { kind: "url", url: `${SEED_TILE_BASE}/${slot.tile}` } : null),
+        });
+        if (!rt.ok)
+            return fail("target", rt.error);
+        const target = rt.target;
+        const subject = (0, target_1.subjectOf)(target, p.preview);
+        const claims = (0, target_1.harnessClaims)(target, p.preview, subject, preview_1.simulatedClaims);
+        const photo = (_a = subject.photo) !== null && _a !== void 0 ? _a : {
+            image: target.tileImage,
+            size: await imageSizeOf(target.tileImage),
+            focus: (_b = target.slot.focus) !== null && _b !== void 0 ? _b : { x: 0.5, y: 0.5 },
+        };
+        // The contributor's own canvas when it is served and browser-safe;
+        // otherwise the generated card (and `piece: "off"` says why).
+        const card = () => (0, preview_1.previewPiece)({
+            style: p.preview.piece === "off" ? "lorem" : p.preview.piece,
+            aspect: p.preview.pieceAspect,
+            fps,
+            canvasColor: p.canvasColor,
+            accentColor: p.accentColor,
+            textColor: p.textColor,
+        });
+        let piece = card();
+        if (p.preview.piece === "off") {
+            if (target.synthetic || !target.slot.piece) {
+                return fail("desktop only", `That tile has no canvas in the bundled seed. ${DESKTOP} Here, pick a generated canvas under Dev preview.`);
+            }
+            const served = await (0, webPiece_1.fetchWebPiece)(`${SEED_TILE_BASE}/${target.slot.piece}`);
+            if (!served.ok) {
+                return fail("desktop only", `${served.error}. ${DESKTOP} Here, pick a generated canvas under Dev preview.`);
+            }
+            piece = served.piece;
+        }
+        const tl = (0, timing_1.resolveTimeline)(p, piece.declaredMs, ctx);
+        if (!tl.ok)
+            return fail("duration", tl.error);
+        const plan = {
+            frameW,
+            frameH,
+            fps,
+            props: p,
+            target,
+            claims,
+            tileIndex: subject.tileIndex,
+            photo,
+            tileCaption: subject.caption,
+            piece,
+            timeline: tl.timeline,
+            repo: (_c = target.manifest.repo) !== null && _c !== void 0 ? _c : "m0saic-project/community-m",
+        };
+        return (0, pipeline_1.buildProvenancePipeline)(plan);
+    },
+});
+(0, template_utils_1.registerTemplate)(exports.CommunityMV1Web);
+exports.default = exports.CommunityMV1Web;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,59 @@
+"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 });
+/**
+ * Write the founder's seed piece — `ms/001/root/piece.mosaic` in the bundled
+ * `@m0saic/community-m` package — from `buildSeedPiece()`.
+ *
+ * Usage:  node dist/m0saic/brand/community-m/v1/gen-seed-piece.js
+ *
+ * Then, from `packages/community-m`, re-pin the claim record and rebuild the
+ * index (the public repo's own tools):
+ *   node tools/new-slot.mjs --m 001 --root --regen && node tools/assemble.mjs && node tools/validate.mjs
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const paths_1 = require("./paths");
+const seedPiece_1 = require("./seedPiece");
+const out = path.join((0, paths_1.seedCommunityDir)(), "ms", "001", "root", "piece.mosaic");
+const next = (0, seedPiece_1.seedPieceJson)();
+const prev = fs.existsSync(out) ? fs.readFileSync(out, "utf8") : null;
+if (prev === next) {
+    console.log(`[gen-seed-piece] unchanged: ${out}`);
+}
+else {
+    fs.writeFileSync(out, next);
+    console.log(`[gen-seed-piece] wrote ${out} (${next.length} chars) — re-pin: cd packages/community-m && node tools/new-slot.mjs --m 001 --root --regen && node tools/assemble.mjs`);
+}

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

@@ -0,0 +1,44 @@
+import type { MosaicDictionaryEntryResolved, MosaicSourceMask } from "@m0saic/types";
+export declare const DICT_ID = "brand/m-33";
+/** Native design side of the brand M. Every render is an integer multiple of this (mask law). */
+export declare const M_NATIVE = 272;
+export type MarkGeometry = {
+    entry: MosaicDictionaryEntryResolved;
+    /** The mark's m0 — the baked copy, present in every build (see below). */
+    m0: string;
+    /** Source-order stableKeys (index i = the i-th emitted frame of the m0). */
+    keys: readonly string[];
+    /** Frame rects in 272-space, indexed by SOURCE order. */
+    sourceRects: ReadonlyArray<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    /** Source index → Community M flat tile index (brand-mark SVG order). */
+    sourceToTile: readonly number[];
+    /** Tile index → source index. */
+    tileToSource: readonly number[];
+    /** Inline mask per SOURCE index, or undefined for plain rects. */
+    maskFor: (sourceIndex: number) => MosaicSourceMask | undefined;
+};
+/**
+ * The Community M's geometry. The m0 comes from the BAKED copy in
+ * `@m0saic/platform` rather than the dictionary entry: the browser
+ * dictionary ships `m0: ""` with a lazily-fetched `m0File` that the web app
+ * does not even serve, and the mark has to draw identically in both builds
+ * with no network. The masks still come from the dictionary entry, which
+ * carries them inline in every build. `mTiles.test.ts` pins the baked m0 to
+ * the dictionary's so the two cannot drift.
+ *
+ * Source order (how the engine feeds `sources[]`) and Community M tile
+ * order (the manifest's `tileIndex`) differ; both are keyed by stableKey,
+ * so the join is exact.
+ */
+export declare function markGeometry(): MarkGeometry;
+/**
+ * Side of the M for a frame: the largest integer multiple of 272 that fits
+ * `share` of the frame's shorter side. 3840×2160 → 1904 (7×); 1280×720 →
+ * 544 (2×); anything under ~302 px tall → 272 (1×, the floor).
+ */
+export declare function markSideFor(frameW: number, frameH: number, share?: number): number;

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.M_NATIVE = exports.DICT_ID = void 0;
+exports.markGeometry = markGeometry;
+exports.markSideFor = markSideFor;
+const dsl_1 = require("@m0saic/dsl");
+const dictionary_1 = require("@m0saic/dictionary");
+const types_1 = require("@m0saic/types");
+const platform_1 = require("@m0saic/platform");
+exports.DICT_ID = "brand/m-33";
+/** Native design side of the brand M. Every render is an integer multiple of this (mask law). */
+exports.M_NATIVE = 272;
+let _cached = null;
+/**
+ * The Community M's geometry. The m0 comes from the BAKED copy in
+ * `@m0saic/platform` rather than the dictionary entry: the browser
+ * dictionary ships `m0: ""` with a lazily-fetched `m0File` that the web app
+ * does not even serve, and the mark has to draw identically in both builds
+ * with no network. The masks still come from the dictionary entry, which
+ * carries them inline in every build. `mTiles.test.ts` pins the baked m0 to
+ * the dictionary's so the two cannot drift.
+ *
+ * Source order (how the engine feeds `sources[]`) and Community M tile
+ * order (the manifest's `tileIndex`) differ; both are keyed by stableKey,
+ * so the join is exact.
+ */
+function markGeometry() {
+    var _a;
+    if (_cached)
+        return _cached;
+    const entry = dictionary_1.registry.byId[exports.DICT_ID];
+    if (!entry)
+        throw new Error(`dictionary entry "${exports.DICT_ID}" not found`);
+    const m0 = platform_1.M_GEOMETRY_M0;
+    const keys = (0, dictionary_1.getSourceOrderStableKeysForM0)(exports.DICT_ID, m0, exports.M_NATIVE, exports.M_NATIVE).map(String);
+    const frames = (0, dsl_1.parseM0StringToLogicalFrames)(m0, exports.M_NATIVE, exports.M_NATIVE);
+    if (frames.length !== keys.length)
+        throw new Error(`${exports.DICT_ID}: ${frames.length} frames vs ${keys.length} keys`);
+    const sourceRects = frames.map((f) => ({ x: f.x, y: f.y, width: f.width, height: f.height }));
+    const tileByKey = new Map(platform_1.M_TILES.map((t) => [t.stableKey, t.tileIndex]));
+    const sourceToTile = keys.map((k) => {
+        const t = tileByKey.get(k);
+        if (t === undefined)
+            throw new Error(`${exports.DICT_ID}: stableKey ${k} has no Community M tile`);
+        return t;
+    });
+    const tileToSource = new Array(keys.length).fill(-1);
+    sourceToTile.forEach((t, s) => { tileToSource[t] = s; });
+    if (keys[tileToSource[types_1.COMMUNITY_M_TIP_TILE_INDEX]] !== types_1.COMMUNITY_M_TIP_STABLE_KEY) {
+        throw new Error(`${exports.DICT_ID}: root tile is not ${types_1.COMMUNITY_M_TIP_STABLE_KEY} — dictionary / manifest drift`);
+    }
+    const masks = (_a = entry.masks) !== null && _a !== void 0 ? _a : null;
+    const maskFor = (i) => {
+        const m = masks === null || masks === void 0 ? void 0 : masks[keys[i]];
+        return m ? { kind: "inline-mask", localPath: m.localPath, bounds: m.bounds } : undefined;
+    };
+    _cached = { entry, m0, keys, sourceRects, sourceToTile, tileToSource, maskFor };
+    return _cached;
+}
+/**
+ * Side of the M for a frame: the largest integer multiple of 272 that fits
+ * `share` of the frame's shorter side. 3840×2160 → 1904 (7×); 1280×720 →
+ * 544 (2×); anything under ~302 px tall → 272 (1×, the floor).
+ */
+function markSideFor(frameW, frameH, share = 0.9) {
+    const k = Math.max(1, Math.floor((Math.min(frameW, frameH) * share) / exports.M_NATIVE));
+    return k * exports.M_NATIVE;
+}

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

@@ -0,0 +1,3 @@
+import type { ImageSize } from "./reveal";
+/** Image dimensions from the PNG header (the repo commits PNG tiles). Unknown → square (only the aspect matters). */
+export declare function readImageSize(abs: string): ImageSize;

package/dist/m0saic/brand/community-m/v1/imageSize.node.js

@@ -0,0 +1,60 @@
+"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.readImageSize = readImageSize;
+const fs = __importStar(require("fs"));
+/** Image dimensions from the PNG header (the repo commits PNG tiles). Unknown → square (only the aspect matters). */
+function readImageSize(abs) {
+    try {
+        const fd = fs.openSync(abs, "r");
+        try {
+            const buf = Buffer.alloc(24);
+            const n = fs.readSync(fd, buf, 0, 24, 0);
+            if (n === 24 && buf.toString("latin1", 1, 4) === "PNG" && buf.toString("latin1", 12, 16) === "IHDR") {
+                const width = buf.readUInt32BE(16);
+                const height = buf.readUInt32BE(20);
+                if (width > 0 && height > 0)
+                    return { width, height };
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    return { width: 1, height: 1 };
+}

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

@@ -0,0 +1 @@
+export { CommunityMV1 } from "./community-m";

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityMV1 = void 0;
+var community_m_1 = require("./community-m");
+Object.defineProperty(exports, "CommunityMV1", { enumerable: true, get: function () { return community_m_1.CommunityMV1; } });

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

@@ -0,0 +1,14 @@
+import type { LoadedPiece } from "./piece";
+/**
+ * Load + validate the contributor's `.mosaic` piece (data only: local
+ * media, colour, text, inline children; bounded size and duration; every
+ * asset inside its own folder). Never throws — a bad piece is an error
+ * card, not a crash.
+ */
+export declare function loadPiece(pieceAbs: string): {
+    ok: true;
+    piece: LoadedPiece;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/m0saic/brand/community-m/v1/loadPiece.node.js

@@ -0,0 +1,69 @@
+"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.loadPiece = loadPiece;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loadMosaicDocument_1 = require("@m0saic/platform/mosaic/loadMosaicDocument");
+const node_1 = require("@m0saic/platform/communityM/node");
+/**
+ * Load + validate the contributor's `.mosaic` piece (data only: local
+ * media, colour, text, inline children; bounded size and duration; every
+ * asset inside its own folder). Never throws — a bad piece is an error
+ * card, not a crash.
+ */
+function loadPiece(pieceAbs) {
+    let raw;
+    try {
+        raw = fs.readFileSync(pieceAbs, "utf8");
+    }
+    catch (err) {
+        return { ok: false, error: `piece unreadable: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    let loaded;
+    try {
+        loaded = (0, loadMosaicDocument_1.loadMosaicDocument)(raw, pieceAbs);
+    }
+    catch (err) {
+        return { ok: false, error: `piece invalid: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const v = (0, node_1.validateCommunityPiece)(loaded, { pieceDir: path.dirname(pieceAbs), ...node_1.COMMUNITY_PIECE_DEFAULT_LIMITS });
+    if (!v.ok)
+        return { ok: false, error: `piece rejected: ${v.errors.join("; ")}` };
+    const doc = loaded;
+    if (!doc.size || typeof doc.durationMs !== "number")
+        return { ok: false, error: "piece must declare size and durationMs" };
+    return { ok: true, piece: { doc, declaredMs: doc.durationMs, size: { width: doc.size.width, height: doc.size.height } } };
+}

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

@@ -0,0 +1,22 @@
+import type { CommunityMSlot } from "@m0saic/types";
+import { type BuildTargetResult } from "./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.
+ */
+export declare function resolveTarget(opts: {
+    communityDir: string;
+    m: string;
+    tile: string;
+    asOf: "now" | "claim";
+    allowUnclaimed?: boolean;
+}): BuildTargetResult & {
+    dir?: string;
+};
+/** Absolute path of a slot's `.mosaic` piece inside a community folder. */
+export declare function pieceAbsFor(dir: string, slot: CommunityMSlot): string;
+export { identityLine, tileLine } from "./target";
+export type { ProvenanceTarget } from "./target";