m0saic 0.0.0 → 0.2.0

package/node_modules/@m0saic/community-m/release.json

@@ -0,0 +1,4 @@
+{
+  "tag": "seed",
+  "publishedAt": "2026-09-06T00:00:00.000Z"
+}

package/node_modules/@m0saic/community-m/tools/assemble.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// Regenerate index.json and every ms/<id>/community-m-<id>.m0p from the
+// slot folders. `--check` writes nothing and fails if the committed files
+// differ (CI). Output is byte-stable: timestamps derive from claimedAt.
+import fs from "node:fs";
+import { computeClaimOrder } from "./claim-order.mjs";
+import { CONTRIBUTOR_CAPACITY, abs, allSlots, buildMs, geometry, GEOMETRY_TILES, newestClaimedAt, pkg, publicSlot, readJson, SCHEMA_VERSION, stable, stampDates, TILE_COUNT } from "./lib.mjs";
+
+const check = process.argv.includes("--check");
+const { m0c } = geometry();
+const p = pkg();
+const ms = buildMs({ computeClaimOrder });
+if (!check) for (const rel of stampDates(ms)) console.log(`✅ stamped dates into ${rel}`);
+const created = newestClaimedAt(ms);
+
+const outputs = new Map();
+
+for (const m of ms) {
+  const variants = {};
+  for (const s of allSlots(m)) {
+    const slotM0c = readJson(`ms/${m.id}/${s.dirName}/slot.m0c`);
+    const key = s.slot === 0 ? "tile-root" : `tile-${s.dirName.replace("slots/", "")}`;
+    variants[key] = {
+      meta: slotM0c.meta ?? null,
+      size: { width: m0c.size.width, height: m0c.size.height },
+      m0: m0c.m0,
+      labels: slotM0c.labels ?? null,
+      derive: { background: null },
+      masks: m0c.masks,
+      fill: { [s.stableKey]: { mediaRef: `${s.dirName}/tile.png` } },
+      insets: null,
+      rankSets: m0c.rankSets,
+      custom: { communityM: { m: m.id, slot: s.slot, tileIndex: s.tileIndex, stableKey: s.stableKey, handle: s.handle, ...(s.slot === 0 ? { root: true } : {}), ...(s.focus ? { focus: s.focus } : {}), ...(s.tileSha256 ? { tileSha256: s.tileSha256 } : {}) } },
+      created: s.claimedAt,
+    };
+  }
+  if (Object.keys(variants).length === 0) {
+    // A pack needs at least one variant: ship the bare M as `tile-00` so the
+    // file opens in Layout even before the first claim.
+    variants["tile-00"] = {
+      meta: { title: `${m.title} — no claims yet` },
+      size: { width: m0c.size.width, height: m0c.size.height },
+      m0: m0c.m0, labels: null, derive: { background: null }, masks: m0c.masks,
+      fill: null, insets: null, rankSets: m0c.rankSets, custom: { communityM: { m: m.id, slot: 0 } },
+    };
+  }
+  const pack = {
+    format: "m0p",
+    version: 1,
+    created,
+    app: "community-m-tools",
+    appVersion: p.version,
+    meta: {
+      title: m.title,
+      author: m.curator?.handle ?? null,
+      source: `https://github.com/${p.m0saic.repo}`,
+      note: `${m.claimed} / ${CONTRIBUTOR_CAPACITY} contributor tiles claimed · root ${m.root.status}` + (m.openedAt ? ` · opened ${m.openedAt.slice(0, 10)}` : "") + (m.completedAt ? ` · completed ${m.completedAt.slice(0, 10)}` : ""),
+    },
+    regions: null,
+    custom: { communityM: { m: m.id, status: m.status, claimOrder: m.claimOrder, root: m.root.status } },
+    variants,
+  };
+  outputs.set(m.pack, stable(pack));
+}
+
+const manifest = {
+  schemaVersion: SCHEMA_VERSION,
+  repo: p.m0saic.repo,
+  generatedAt: created,
+  tileCount: TILE_COUNT,
+  geometry: { entry: "brand/m-33", size: m0c.size.width, tiles: GEOMETRY_TILES },
+  ms: ms.map((m) => ({ ...m, root: { ...m.root, slot: m.root.slot ? publicSlot(m.root.slot) : null }, slots: m.slots.map(publicSlot) })),
+};
+outputs.set("index.json", stable(manifest));
+
+let stale = 0;
+for (const [rel, text] of outputs) {
+  const current = fs.existsSync(abs(rel)) ? fs.readFileSync(abs(rel), "utf8") : null;
+  if (current === text) continue;
+  stale++;
+  if (check) console.error(`✗ ${rel} is stale — run node tools/assemble.mjs`);
+  else { fs.writeFileSync(abs(rel), text); console.log(`✅ wrote ${rel}`); }
+}
+if (check) {
+  if (stale) process.exit(1);
+  console.log(`✅ ${outputs.size} generated files are current`);
+} else if (!stale) console.log(`✅ ${outputs.size} generated files already current`);

package/node_modules/@m0saic/community-m/tools/claim-order.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Farthest-first scatter — zero-dep mirror of @m0saic/platform's
+// `computeClaimOrder`. The two MUST agree; the monorepo pins both to the
+// same committed order (packages/platform/src/communityM/claimOrder.test.ts).
+//
+//   node tools/claim-order.mjs 001     # print M 001's order
+import { CONTRIBUTOR_CAPACITY, geometry, TIP_INDEX } from "./lib.mjs";
+
+export function computeClaimOrder(tiles, { tipIndex, tipFirst }) {
+  const tip = tiles.find((t) => t.tileIndex === tipIndex);
+  if (!tip) throw new Error(`computeClaimOrder: tipIndex ${tipIndex} not in tiles`);
+  const centroid = (t) => ({ x: t.x + t.w / 2, y: t.y + t.h / 2, area: t.w * t.h });
+  const anchors = [centroid(tip)];
+  const open = tiles.filter((t) => t.tileIndex !== tipIndex);
+  const scatter = [];
+  while (open.length > 0) {
+    let bestI = -1, bestD = -1, bestArea = -1;
+    for (let i = 0; i < open.length; i++) {
+      const c = centroid(open[i]);
+      let minD = Infinity;
+      for (const a of anchors) { const d = Math.hypot(a.x - c.x, a.y - c.y); if (d < minD) minD = d; }
+      const better =
+        minD > bestD ||
+        (minD === bestD && (c.area > bestArea || (c.area === bestArea && open[i].tileIndex < open[bestI].tileIndex)));
+      if (better) { bestI = i; bestD = minD; bestArea = c.area; }
+    }
+    const picked = open.splice(bestI, 1)[0];
+    anchors.push(centroid(picked));
+    scatter.push(picked.tileIndex);
+  }
+  return tipFirst ? [tipIndex, ...scatter] : [...scatter, tipIndex];
+}
+
+const isMain = process.argv[1] && import.meta.url.endsWith(process.argv[1].split(/[\\/]/).pop());
+if (isMain) {
+  const id = process.argv[2] ?? "001";
+  const { tiles } = geometry();
+  // The root (tip) is never dealt — every M deals the same 32.
+  const order = computeClaimOrder(tiles, { tipIndex: TIP_INDEX, tipFirst: false }).slice(0, CONTRIBUTOR_CAPACITY);
+  console.log(`contributor deal order for M ${id} (root = tile ${TIP_INDEX}, reserved):`);
+  console.log(order.join(", "));
+}

package/node_modules/@m0saic/community-m/tools/lib.mjs

@@ -0,0 +1,208 @@
+// Shared helpers for the community-m tools. Zero dependencies — this runs in
+// the public repo's CI before any @m0saic package is installable from npm.
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+export const TILE_COUNT = 33;
+/** Contributor tiles per M — the root (tip) is never dealt. */
+export const CONTRIBUTOR_CAPACITY = 32;
+export const SCHEMA_VERSION = 1;
+export const TIP_INDEX = 32;
+export const TIP_STABLE_KEY = "r/ov1c0/ov2c0/gcolc100/fc79";
+export const GEOMETRY_M0C = "geometry/m-33.m0c";
+export const GEOMETRY_TILES = "geometry/m-33-tiles.json";
+
+export const readJson = (rel) => JSON.parse(fs.readFileSync(path.join(ROOT, rel), "utf8"));
+export const exists = (rel) => fs.existsSync(path.join(ROOT, rel));
+export const abs = (rel) => path.join(ROOT, ...rel.split("/"));
+export const stable = (obj) => JSON.stringify(obj, null, 2) + "\n";
+
+export function pkg() {
+  return readJson("package.json");
+}
+
+export function geometry() {
+  const m0c = readJson(GEOMETRY_M0C);
+  const tiles = readJson(GEOMETRY_TILES).tiles;
+  return { m0c, tiles };
+}
+
+/** M ids in numeric order (folder names under ms/). */
+export function listMIds() {
+  const dir = path.join(ROOT, "ms");
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((n) => /^\d{3}$/.test(n) && fs.existsSync(path.join(dir, n, "m.json")))
+    .sort();
+}
+
+/** Slot folder names under ms/<id>/slots/, sorted. */
+export function listSlotDirs(mId) {
+  const dir = path.join(ROOT, "ms", mId, "slots");
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((n) => /^\d{2}$/.test(n)).sort();
+}
+
+/** True when ms/<id>/root/ carries an award (slot.json present). */
+export function hasRoot(mId) {
+  return fs.existsSync(path.join(ROOT, "ms", mId, "root", "slot.json"));
+}
+
+/** Build one slot record from a folder (`slots/NN` or `root`). */
+function slotFromDir(mId, dirName, slotNo, tileIndex, byIndex) {
+  const rel = `ms/${mId}/${dirName}`;
+  const s = readJson(`${rel}/slot.json`);
+  const t = byIndex.get(tileIndex);
+  const assetsDir = path.join(ROOT, "ms", mId, ...dirName.split("/"), "assets");
+  const assets = fs.existsSync(assetsDir)
+    ? fs.readdirSync(assetsDir).filter((f) => !f.startsWith(".")).sort().map((f) => `${rel}/assets/${f}`)
+    : [];
+  return {
+    slot: slotNo,
+    dirName,
+    tileIndex,
+    stableKey: t.stableKey,
+    handle: s.handle,
+    displayName: s.displayName,
+    ...(s.url !== undefined ? { url: s.url } : {}),
+    ...(s.note !== undefined ? { note: s.note } : {}),
+    claimedAt: s.claimedAt,
+    pr: s.pr ?? null,
+    tile: `${rel}/tile.png`,
+    ...(s.tileSha256 ? { tileSha256: s.tileSha256 } : {}),
+    // Optional: a fuller picture of the person behind the tile. The tile is
+    // the mark; this is who made it. Surfaced by the Community page's tile
+    // macro; contributors may leave it out.
+    ...(fs.existsSync(abs(`${rel}/portrait.jpg`)) ? { portrait: `${rel}/portrait.jpg` } : {}),
+    ...(s.portraitSha256 ? { portraitSha256: s.portraitSha256 } : {}),
+    piece: `${rel}/piece.mosaic`,
+    ...(s.pieceSha256 ? { pieceSha256: s.pieceSha256 } : {}),
+    assets,
+    ...(s.contribution !== undefined ? { contribution: s.contribution } : {}),
+    ...(s.focus !== undefined ? { focus: s.focus } : {}),
+  };
+}
+
+export const pad2 = (n) => String(n).padStart(2, "0");
+
+/** SHA-256 hex of a repo-relative file, or null when it does not exist. */
+export function sha256Of(rel) {
+  const p = abs(rel);
+  if (!fs.existsSync(p)) return null;
+  return createHash("sha256").update(fs.readFileSync(p)).digest("hex");
+}
+
+/**
+ * Derive the manifest view of every M from the folders on disk: status,
+ * claim order, slots. Pure given the filesystem; assemble.mjs serializes
+ * it, validate.mjs re-checks the committed files against it.
+ */
+export function buildMs({ computeClaimOrder }) {
+  const { tiles } = geometry();
+  const byIndex = new Map(tiles.map((t) => [t.tileIndex, t]));
+  const ids = listMIds();
+  const out = [];
+  let prevComplete = true; // M 001 may open
+  for (const id of ids) {
+    const number = Number(id);
+    const m = readJson(`ms/${id}/m.json`);
+    // The root (tip) is never dealt: the scatter runs over the other 32,
+    // anchored on the tip's centroid, and the tip is dropped from the order.
+    const claimOrder = computeClaimOrder(tiles, { tipIndex: TIP_INDEX, tipFirst: false }).slice(0, CONTRIBUTOR_CAPACITY);
+    const slotDirs = listSlotDirs(id);
+    const slots = slotDirs.map((dirName, i) => slotFromDir(id, `slots/${dirName}`, i + 1, claimOrder[i], byIndex));
+    const rootSlot = hasRoot(id) ? slotFromDir(id, "root", 0, TIP_INDEX, byIndex) : null;
+    const rootJson = hasRoot(id) ? readJson(`ms/${id}/root/slot.json`) : null;
+    let status;
+    if (slots.length >= CONTRIBUTOR_CAPACITY) status = "complete";
+    else if (prevComplete) status = "active";
+    else status = "locked";
+    // Dates: openedAt is authored for M 001 (the epoch) and inherited from
+    // the previous M's completedAt afterwards; completedAt is stamped from
+    // the 33rd claim the first time the M completes and then FROZEN in
+    // m.json (assemble writes both back — see `stampDates`).
+    const prev = out[out.length - 1];
+    const openedAt = m.openedAt ?? (status !== "locked" ? prev?.completedAt ?? null : null);
+    const completedAt = m.completedAt ?? (status === "complete" ? slots[slots.length - 1].claimedAt : null);
+    prevComplete = status === "complete";
+    out.push({
+      id,
+      number,
+      title: m.title ?? `Community M #${id}`,
+      status,
+      capacity: CONTRIBUTOR_CAPACITY,
+      claimed: slots.length,
+      root: {
+        tileIndex: TIP_INDEX,
+        stableKey: TIP_STABLE_KEY,
+        status: rootSlot ? "awarded" : "reserved",
+        slot: rootSlot,
+        ...(rootJson?.citation ? { citation: rootJson.citation } : {}),
+      },
+      openedAt,
+      completedAt,
+      ...(m.curator !== undefined ? { curator: m.curator } : {}),
+      ...(m.accent !== undefined ? { accent: m.accent } : {}),
+      claimOrder,
+      pack: `ms/${id}/community-m-${id}.m0p`,
+      slots,
+    });
+  }
+  return out;
+}
+
+/**
+ * Write derived `openedAt` / `completedAt` back into m.json when they were
+ * absent — the freeze moment. Never overwrites a value already recorded.
+ * Returns the list of files touched.
+ */
+export function stampDates(ms) {
+  const touched = [];
+  for (const m of ms) {
+    const rel = `ms/${m.id}/m.json`;
+    const mj = readJson(rel);
+    let changed = false;
+    if ((mj.openedAt ?? null) === null && m.openedAt) { mj.openedAt = m.openedAt; changed = true; }
+    if ((mj.completedAt ?? null) === null && m.completedAt) { mj.completedAt = m.completedAt; changed = true; }
+    if (changed) { fs.writeFileSync(abs(rel), stable(mj)); touched.push(rel); }
+  }
+  return touched;
+}
+
+/** Newest claimedAt across every slot, or the genesis epoch. Keeps generated files byte-stable. */
+export function newestClaimedAt(ms) {
+  let newest = "2026-04-15T00:00:00.000Z";
+  for (const m of ms) for (const s of [...m.slots, ...(m.root.slot ? [m.root.slot] : [])]) if (s.claimedAt > newest) newest = s.claimedAt;
+  return newest;
+}
+
+/**
+ * Pin a slot's tile + piece bytes into slot.json (the claim record). Called by
+ * new-slot on scaffold/regen: a later edit to the files must come with a
+ * re-pin, so the diff shows the change to the record explicitly.
+ */
+export function pinSlotHashes(mId, dirName) {
+  const rel = `ms/${mId}/${dirName}`;
+  const sj = readJson(`${rel}/slot.json`);
+  const t = sha256Of(`${rel}/tile.png`), pc = sha256Of(`${rel}/piece.mosaic`), po = sha256Of(`${rel}/portrait.jpg`);
+  if (t) sj.tileSha256 = t; else delete sj.tileSha256;
+  if (pc) sj.pieceSha256 = pc; else delete sj.pieceSha256;
+  if (po) sj.portraitSha256 = po; else delete sj.portraitSha256;
+  fs.writeFileSync(abs(`${rel}/slot.json`), stable(sj));
+  return sj;
+}
+
+/** Strip tool-only fields before a slot goes into index.json. */
+export function publicSlot(s) {
+  const { dirName, ...rest } = s;
+  return rest;
+}
+
+/** Every slot folder of an M (root first when awarded), for validation/download loops. */
+export function allSlots(m) {
+  return [...(m.root.slot ? [m.root.slot] : []), ...m.slots];
+}

package/node_modules/@m0saic/community-m/tools/new-slot.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// Scaffold the next contributor claim in an M, award its ROOT, or regenerate a
+// folder's .m0c from its slot.json.
+//
+//   node tools/new-slot.mjs --m 001 --handle octocat --name "Mona" [--url URL] [--note "..."] [--contribution ID] [--at ISO] [--focus x,y,zoom]
+//   node tools/new-slot.mjs --m 002 --root --handle octocat --name "Mona" --citation "..."   # award the root tile
+//   node tools/new-slot.mjs --m 001 --slot 01 --regen        # rewrite slots/01/slot.m0c (+ re-pin hashes)
+//   node tools/new-slot.mjs --m 001 --root --regen           # same for root/
+import fs from "node:fs";
+import { computeClaimOrder } from "./claim-order.mjs";
+import { CONTRIBUTOR_CAPACITY, abs, geometry, hasRoot, listSlotDirs, pad2, pinSlotHashes, pkg, readJson, stable, TIP_INDEX } from "./lib.mjs";
+
+const args = process.argv.slice(2);
+const val = (f) => { const i = args.indexOf(f); return i >= 0 ? args[i + 1] : undefined; };
+const mId = val("--m") ?? "001";
+if (!/^\d{3}$/.test(mId) || !fs.existsSync(abs(`ms/${mId}/m.json`))) {
+  console.error(`✗ unknown M "${mId}" (need ms/${mId}/m.json)`); process.exit(1);
+}
+const isRoot = args.includes("--root");
+const regen = args.includes("--regen");
+const { m0c, tiles } = geometry();
+const claimOrder = computeClaimOrder(tiles, { tipIndex: TIP_INDEX, tipFirst: false }).slice(0, CONTRIBUTOR_CAPACITY);
+const existing = listSlotDirs(mId);
+
+let slotNo, dirName, slotJson;
+if (regen) {
+  if (isRoot) {
+    if (!hasRoot(mId)) { console.error(`✗ ms/${mId}/root has no slot.json to regenerate`); process.exit(1); }
+    slotNo = 0; dirName = "root";
+  } else {
+    const s = val("--slot");
+    if (!s || !existing.includes(s)) { console.error(`✗ --regen needs an existing --slot NN (or --root)`); process.exit(1); }
+    slotNo = Number(s); dirName = `slots/${s}`;
+  }
+  slotJson = readJson(`ms/${mId}/${dirName}/slot.json`);
+} else {
+  const handle = val("--handle"), name = val("--name");
+  if (!handle || !name) { console.error("usage: --m 001 [--root] --handle <gh> --name <display> [--url] [--note] [--contribution] [--at] [--focus x,y,zoom] [--citation]"); process.exit(1); }
+  if (isRoot) {
+    if (hasRoot(mId)) { console.error(`✗ ms/${mId}/root is already awarded`); process.exit(1); }
+    slotNo = 0; dirName = "root";
+  } else {
+    if (existing.length >= CONTRIBUTOR_CAPACITY) { console.error(`✗ M ${mId} is complete (${CONTRIBUTOR_CAPACITY} contributor tiles) — only the root can still be awarded`); process.exit(1); }
+    slotNo = existing.length + 1; dirName = `slots/${pad2(slotNo)}`;
+  }
+  if (fs.existsSync(abs(`ms/${mId}/${dirName}`))) { console.error(`✗ ms/${mId}/${dirName} already exists`); process.exit(1); }
+  slotJson = {
+    handle, displayName: name,
+    ...(val("--url") ? { url: val("--url") } : {}),
+    ...(val("--note") ? { note: val("--note") } : {}),
+    claimedAt: val("--at") ?? new Date().toISOString(),
+    pr: null,
+    ...(val("--contribution") ? { contribution: val("--contribution") } : {}),
+    ...(val("--focus") ? { focus: (() => { const [x, y, zoom] = val("--focus").split(",").map(Number); return { x, y, zoom }; })() } : {}),
+    ...(isRoot && val("--citation") ? { citation: val("--citation") } : {}),
+  };
+}
+
+const tileIndex = isRoot ? TIP_INDEX : claimOrder[slotNo - 1];
+const tile = tiles.find((t) => t.tileIndex === tileIndex);
+const key = tile.stableKey;
+const dirRel = `ms/${mId}/${dirName}`;
+fs.mkdirSync(abs(`${dirRel}/assets`), { recursive: true });
+const label = isRoot ? `root · @${slotJson.handle}` : `slot ${pad2(slotNo)} · @${slotJson.handle}`;
+
+const m0cOut = {
+  format: "m0c",
+  version: 1,
+  created: slotJson.claimedAt,
+  app: "community-m-tools",
+  appVersion: pkg().version,
+  meta: {
+    title: `Community M #${mId} — ${isRoot ? "root" : `slot ${pad2(slotNo)}`} (@${slotJson.handle})`,
+    author: slotJson.handle,
+    source: `https://github.com/${pkg().m0saic.repo}`,
+    note: "Geometry is immutable — only the labelled tile is yours.",
+  },
+  agent: {
+    note: [
+      `# Community M #${mId} · ${isRoot ? "root" : `slot ${pad2(slotNo)}`}`,
+      "",
+      isRoot
+        ? `This is the ROOT tile of the M — reserved for a community-recognized contribution of exceptional value, and awarded to @${slotJson.handle}.`
+        : `This tile is yours, @${slotJson.handle}. It is tile **${tileIndex}** (\`${key}\`), dealt by the farthest-first scatter — claim #${slotNo} of ${CONTRIBUTOR_CAPACITY}.`,
+      "",
+      "**Do not edit the geometry.** Replace `tile.png` (square, ≥512 px PNG) and",
+      "`piece.mosaic` in this folder, run `node tools/validate.mjs`, and open a PR",
+      "that touches only this folder. Open `community-m-" + mId + ".m0p` in Mosaic",
+      "Desktop → Layout to see your tile in context.",
+    ].join("\n"),
+  },
+  size: { width: m0c.size.width, height: m0c.size.height },
+  m0: m0c.m0,
+  labels: { [key]: { text: label } },
+  derive: { background: null },
+  masks: m0c.masks,
+  fill: { [key]: { mediaRef: "tile.png" } },
+  insets: null,
+  rankSets: m0c.rankSets,
+  custom: { communityM: { m: mId, slot: slotNo, tileIndex, stableKey: key, ...(isRoot ? { root: true } : {}), ...(slotJson.focus ? { focus: slotJson.focus } : {}) } },
+};
+
+fs.writeFileSync(abs(`${dirRel}/slot.json`), stable(slotJson));
+if (!fs.existsSync(abs(`${dirRel}/piece.mosaic`))) {
+  fs.writeFileSync(abs(`${dirRel}/piece.mosaic`), stable({
+    kind: "mosaic_document", version: 1, m0: "1{1}",
+    size: { width: 1280, height: 720 }, fps: 30, durationMs: 4000,
+    backgroundColor: "#0E1220", assets: {},
+    sources: [
+      { type: "lavfi", color: "#0E1220" },
+      { type: "text", rasterizer: "svg", style: { fontSize: 56, fontColor: "#f97316" },
+        layers: [{ content: { kind: "literal", text: `@${slotJson.handle}` } }],
+        placement: { hAlign: "center", vAlign: "middle" }, renderMode: { kind: "image" } },
+    ],
+  }));
+}
+if (!fs.existsSync(abs(`${dirRel}/assets/.gitkeep`))) fs.writeFileSync(abs(`${dirRel}/assets/.gitkeep`), "");
+// Pin the bytes into the claim record, then write the .m0c so its custom block carries the pins.
+const pinned = pinSlotHashes(mId, dirName);
+m0cOut.custom.communityM = { ...m0cOut.custom.communityM, ...(pinned.tileSha256 ? { tileSha256: pinned.tileSha256 } : {}), ...(pinned.pieceSha256 ? { pieceSha256: pinned.pieceSha256 } : {}) };
+fs.writeFileSync(abs(`${dirRel}/slot.m0c`), stable(m0cOut));
+console.log(`✅ ${dirRel}: ${isRoot ? "ROOT" : `tile ${tileIndex}`} (${key}) for @${slotJson.handle}`);
+if (!fs.existsSync(abs(`${dirRel}/tile.png`))) console.log(`   next: add ${dirRel}/tile.png (square ≥512 px PNG), then node tools/validate.mjs`);