slidemind 0.3.20 → 0.4.1

package/src/lib/lint-converted.mjs

@@ -4,19 +4,20 @@
 // A converted slide invokes a server-minted ConvertedHost layout, so the
 // add-in's capability-table lint rejects it as an unregistered layout and
 // src/builders/build.mjs skips it. That left the authored half of an adopted
-// deck completely unchecked, and a real proposal shipped with the master's
+// deck completely unchecked, and a real deck shipped with the master's
 // prompt text still in it ("[Action title …]", "xxx", "adjust footer"), a
 // sentence written into the slide-number field frame, and 12pt bold body copy
 // spilling out of fixed `noAutofit` boxes.
 //
 // These four rules are the ones that would have caught that, and they are
 // structural — they read the dialect's own attributes (data-sm-text-frame,
-// data-sm-para, data-sm-rpr, data-sm-field), not the brand.
+// data-sm-para, data-sm-rpr, data-sm-field), not the brand. A fifth, (e),
+// measures the one-line `wrap: "none"` frames the height rule cannot see.
 
 import fs from "node:fs";
 import path from "node:path";
 
-import { estimateLines } from "./text-fit.mjs";
+import { estimateLines, textWidth } from "./text-fit.mjs";
 
 const PT_TO_PX = 96 / 72;
 
@@ -195,6 +196,45 @@ function textOf(source) {
 
 const lineAt = (src, offset) => src.slice(0, offset).split("\n").length;
 
+// How far a measured wrap:none line may run past its frame before rule (e)
+// reports it. The Arial table is exact for Arial runs, so this only absorbs
+// rounding and the flat bold factor: 1px, or 3% of a wide frame.
+const NOWRAP_SLACK = 0.03;
+
+// The widest line of a wrap:none frame, measured run by run at each run's own
+// size and weight (a <br /> starts a new line; trailing spaces take no room).
+// Text outside a data-sm-rpr run is not measured — the dialect writes none.
+function widestNoWrapLine(paras) {
+  let widest = null;
+  for (const para of paras) {
+    const paraPt = px(styleProp(para, "fontSize")) || 18;
+    let line = { width: 0, text: "", pt: 0, tail: { pt: paraPt, bold: false } };
+    const close = () => {
+      const trailing = /\s+$/.exec(line.text)?.[0] ?? "";
+      const width = line.width - textWidth(trailing, line.tail.pt, { bold: line.tail.bold });
+      if (line.text.trim() && (!widest || width > widest.width)) widest = { width, text: line.text.trim(), pt: line.pt };
+      line = { width: 0, text: "", pt: 0, tail: { pt: paraPt, bold: false } };
+    };
+    for (const node of walk(para)) {
+      if (node.name === "br") {
+        close();
+        continue;
+      }
+      if (attr(node, "data-sm-rpr") === null) continue;
+      const rpr = jsonAttr(node, "data-sm-rpr") ?? {};
+      const pt = px(rpr.sz) / 100 || px(styleProp(node, "fontSize")) || paraPt;
+      const bold = rpr.b === true;
+      const text = textOf(node.inner);
+      line.width += textWidth(text, pt, { bold });
+      line.text += text;
+      line.pt = Math.max(line.pt, pt);
+      line.tail = { pt, bold };
+    }
+    close();
+  }
+  return widest;
+}
+
 // ---------------------------------------------------------------------------
 
 /**
@@ -311,9 +351,33 @@ export function lintConvertedSource(fileName, source, { strict = false } = {}) {
     const frameHeight = px(styleProp(frame, "height"));
     if (!(innerWidth > 0) || !(frameHeight > 0)) continue;
     // `wrap: "none"` shapes never break a line — the text runs on past the
-    // shape edge, which is a width problem this rule does not judge.
+    // shape edge, which is a width problem the height rule below does not
+    // judge; rule (e) does.
     const wraps = meta.wrap !== "none";
 
+    // (e) A `wrap: "none"` line wider than its `spAutoFit` frame. PowerPoint
+    // sized that frame to the text it held; it re-sizes only when PowerPoint
+    // re-lays the text out, which an edit to the jsx never triggers, so the
+    // stored width ships and LibreOffice breaks the word at it. A Gantt month
+    // tick relabelled from "Jan" to "May" in the master's 25px frame came out
+    // as `Ma/y` (2026-10-06 proposal sim). A `noAutofit` wrap:none label that
+    // overhangs is left alone: that is how the source deck draws it (every such
+    // hit across the sim decks was an untouched library reference). Field
+    // frames are left out too: the slide number or date replaces their text.
+    if (!wraps && meta.autofit === "spAutoFit" && !paras.some((p) => [...walk(p)].some((n) => attr(n, "data-sm-field") !== null))) {
+      const widest = widestNoWrapLine(paras);
+      if (widest && widest.width > innerWidth + Math.max(1, innerWidth * NOWRAP_SLACK)) {
+        add(
+          "warn",
+          "converted:nowrap-overflow",
+          frame.start,
+          `converted:nowrap-overflow — ${JSON.stringify(widest.text.slice(0, 40))} measures ${Math.round(widest.width)}px at ${widest.pt}pt in a ${Math.round(innerWidth)}px wrap:none frame` +
+            `${sourceId ? ` (data-sm-source-id={${sourceId}})` : ""}. The frame keeps its stored width and does not wrap: widen it to at least ${Math.ceil(widest.width)}px or shorten the text.`,
+          { width: Math.round(widest.width * 10) / 10, frame: Math.round(innerWidth * 10) / 10 },
+        );
+      }
+    }
+
     // A trailing empty paragraph (PowerPoint's endParaRPr carrier) takes a line
     // but pushes nothing out of view — it is not an overflow.
     const fitParas = [...paras];

package/src/lib/merge-json.mjs

@@ -0,0 +1,163 @@
+// Pure three-way JSON merge — the one policy both the local save path and the
+// shared-plan service apply, so a conflict looks the same whether it was found
+// against another process on this machine or against SharePoint.
+//
+// Parity partner: the backend's record-service three-way merge (merge3).
+// Both are pinned to test/fixtures/workspace/merge/*.json; change the fixtures
+// first, then both implementations. No storage, no plan knowledge: the only
+// structural convention is that an array whose every element is an object with
+// a string `id` is a keyed collection, matched by id instead of by position.
+//
+// Rules, in order, at every path:
+//   1. theirs == mine                    → mine
+//   2. base == mine (only they moved it)  → theirs, path recorded in `applied`
+//   3. base == theirs (only we moved it)  → mine
+//   4. all plain objects                  → per key (union of keys)
+//   5. all keyed arrays                   → per id; order below
+//   6. anything else                      → conflict; `merged` takes theirs
+//
+// Keyed arrays: delete vs unchanged is a deletion; delete vs edit is a conflict;
+// a duplicate id is invalid input (Merge3Error, never a silent shadow). The
+// order of the surviving items follows whichever side reordered them; if both
+// reordered incompatibly that is a conflict on the array path carrying both
+// candidate layouts, never "theirs wins" — a reorder is an edit like any other.
+//
+// `SERVER_OWNED_TOP_LEVEL` keys are stripped from all three inputs before the
+// walk and are absent from `merged`: the caller's owner rule (the service's
+// approval rule, the pack's amendment rule) decides them, never the merge.
+
+import { isDeepStrictEqual } from "node:util";
+
+export const SERVER_OWNED_TOP_LEVEL = Object.freeze(["approval", "status", "amends", "revision"]);
+
+export class Merge3Error extends Error {
+  constructor(code, path, message) {
+    super(message);
+    this.name = "Merge3Error";
+    this.code = code;
+    this.path = path;
+  }
+}
+
+/** @returns {{ merged: unknown, conflicts: Array<{path:string, base:unknown, theirs:unknown, mine:unknown}>, applied: string[] }} */
+export function merge3(base, theirs, mine) {
+  const conflicts = [];
+  const applied = [];
+  const merged = walk("", strip(base), strip(theirs), strip(mine), conflicts, applied);
+  return { merged, conflicts, applied };
+}
+
+function strip(value) {
+  if (!isPlainObject(value)) return value;
+  const copy = { ...value };
+  for (const key of SERVER_OWNED_TOP_LEVEL) delete copy[key];
+  return copy;
+}
+
+function walk(path, base, theirs, mine, conflicts, applied) {
+  if (isDeepStrictEqual(theirs, mine)) return mine;
+  if (isDeepStrictEqual(base, mine)) {
+    applied.push(path);
+    return theirs;
+  }
+  if (isDeepStrictEqual(base, theirs)) return mine;
+
+  if (isPlainObject(base) && isPlainObject(theirs) && isPlainObject(mine)) {
+    const out = {};
+    for (const key of unionKeys(theirs, mine, base)) {
+      const value = walk(`${path}/${key}`, base[key], theirs[key], mine[key], conflicts, applied);
+      if (value !== undefined) out[key] = value; // a surviving deletion, not a value
+    }
+    return out;
+  }
+
+  if (isIdArray(base) && isIdArray(theirs) && isIdArray(mine)) {
+    return mergeById(path, base, theirs, mine, conflicts, applied);
+  }
+
+  conflicts.push({ path, base, theirs, mine });
+  return theirs;
+}
+
+function mergeById(path, base, theirs, mine, conflicts, applied) {
+  const b = byId(base, path);
+  const t = byId(theirs, path);
+  const m = byId(mine, path);
+  const kept = new Map(); // id → merged item, for every id that survives
+
+  for (const [id, theirItem] of t) {
+    const itemPath = `${path}/${id}`;
+    const myItem = m.get(id);
+    if (myItem !== undefined) {
+      kept.set(id, walk(itemPath, b.get(id), theirItem, myItem, conflicts, applied));
+      continue;
+    }
+    const baseItem = b.get(id);
+    if (baseItem === undefined) {
+      applied.push(itemPath); // they added it
+      kept.set(id, theirItem);
+      continue;
+    }
+    if (isDeepStrictEqual(baseItem, theirItem)) continue; // we removed it, they left it alone
+    conflicts.push({ path: itemPath, base: baseItem, theirs: theirItem, mine: null });
+    kept.set(id, theirItem); // we removed it while they edited it: theirs stands
+  }
+  for (const [id, myItem] of m) {
+    if (t.has(id)) continue;
+    const itemPath = `${path}/${id}`;
+    const baseItem = b.get(id);
+    if (baseItem === undefined) {
+      kept.set(id, myItem); // we added it
+      continue;
+    }
+    if (isDeepStrictEqual(baseItem, myItem)) continue; // they removed it, we left it alone
+    conflicts.push({ path: itemPath, base: baseItem, theirs: null, mine: myItem }); // merged takes theirs: removed
+  }
+
+  // Order. Among the ids both sides still have, whoever moved them decides;
+  // the other side's additions follow in its own order.
+  const common = [...kept.keys()].filter((id) => t.has(id) && m.has(id));
+  const inCommon = new Set(common);
+  const order = (items) => items.map((item) => item.id).filter((id) => inCommon.has(id));
+  const tOrder = order(theirs);
+  const mOrder = order(mine);
+  const bOrder = order(base);
+  const inBase = new Set(bOrder);
+  const unmoved = (side) => isDeepStrictEqual(side.filter((id) => inBase.has(id)), bOrder);
+  const layout = (primary, other) => [
+    ...primary.map((item) => item.id).filter((id) => kept.has(id)),
+    ...other.map((item) => item.id).filter((id) => kept.has(id) && !primary.some((p) => p.id === id)),
+  ].map((id) => kept.get(id));
+
+  if (isDeepStrictEqual(tOrder, mOrder) || unmoved(mOrder)) {
+    if (!isDeepStrictEqual(tOrder, mOrder)) applied.push(path); // only they reordered
+    return layout(theirs, mine);
+  }
+  if (unmoved(tOrder)) return layout(mine, theirs);
+  const asTheirs = layout(theirs, mine);
+  conflicts.push({ path, base, theirs: asTheirs, mine: layout(mine, theirs) });
+  return asTheirs;
+}
+
+function byId(items, path) {
+  const map = new Map();
+  for (const item of items) {
+    if (map.has(item.id)) throw new Merge3Error("duplicate_id", path, `duplicate id "${item.id}" at ${path || "/"}`);
+    map.set(item.id, item);
+  }
+  return map;
+}
+
+function isIdArray(value) {
+  return Array.isArray(value) && value.every((item) => isPlainObject(item) && typeof item.id === "string");
+}
+
+function unionKeys(...objects) {
+  const seen = new Set();
+  for (const object of objects) for (const key of Object.keys(object)) seen.add(key);
+  return [...seen];
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/lib/overwrite-guard.mjs

@@ -63,9 +63,9 @@ export function detectManualEdits(outPath) {
     // …with the chart hash dropped from BOTH sides: this repo has no chart
     // reader, so it always projects `chart: null` (see the CHART HASH note in
     // pptx/tags.mjs). Comparing an add-in baseline's real hash against that null
-    // would refuse EVERY rebuild of a deck that holds a chart, which is a
-    // certain harm; missing a chart-ONLY manual edit is the bounded one, and the
-    // add-in's own drift check still catches it on the next push.
+    // would refuse EVERY rebuild of a deck that holds a chart. A chart-ONLY edit
+    // is the add-in's to see: reconcile.mjs sends every chart-holding slide to
+    // it as its package, whatever this comparison says.
     const current = computeProjection(files, slidePath);
     if (
       JSON.stringify(withoutChartHashes(current)) ===