mellos-mapping 0.20.3 → 0.23.0

package/dist/watch.mjs

@@ -2,9 +2,8 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
 // src/watch/watch.ts
-import { realpathSync, statSync as statSync2 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
+import { dirname as dirname9, join as join8 } from "node:path";
 
 // src/domain/types.ts
 var ok = (value) => ({ ok: true, value });
@@ -235,6 +234,392 @@ function updateNode(map, input) {
   return ok({ ...map, nodes: map.nodes.map((n) => n.id === input.id ? updated : n) });
 }
 
+// src/store/project.ts
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir, tmpdir } from "node:os";
+function resolveProjectDirectory(cwd, stopAt = [homedir(), tmpdir()]) {
+  let start = resolve(cwd);
+  try {
+    start = realpathSync(start);
+  } catch {
+  }
+  let dir = start;
+  const boundaries = new Set(stopAt.map((path) => {
+    try {
+      return realpathSync(path);
+    } catch {
+      return resolve(path);
+    }
+  }));
+  while (true) {
+    if (dir !== start && boundaries.has(dir)) return start;
+    if (existsSync(join(dir, ".git")) || existsSync(join(dir, ".mellos", "map.json")) || existsSync(join(dir, ".mellos", "pages"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return start;
+    dir = parent;
+  }
+}
+
+// src/store/transaction.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { randomUUID, createHash } from "node:crypto";
+
+// src/domain/context.ts
+function sourceError(raw) {
+  if (!Array.isArray(raw) || raw.length > 100) return "sources must be an array of at most 100 file references";
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return "source must be an object";
+    const s = item;
+    if (Object.keys(s).some((k) => k !== "path" && k !== "sha256")) return "unknown source field";
+    if (typeof s.path !== "string" || s.path.length > 1024 || !s.path || /[\u0000-\u001f\u007f-\u009f\\:]/.test(s.path) || s.path.startsWith("/") || s.path.split("/").some((p) => !p || p === "." || p === "..")) return "source path must be relative to the project, with forward slashes and no traversal";
+    if (s.sha256 !== void 0 && (typeof s.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(s.sha256))) return "source sha256 must be a lowercase SHA256 hash";
+  }
+  return void 0;
+}
+function contextError(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return "context must be an object";
+  for (const [key, value] of Object.entries(raw)) {
+    if (key !== "summary" && key !== "next") return "unknown context field";
+    if (typeof value !== "string" || value.length > 2e3 || /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/.test(value)) return "context fields must be text of at most 2000 characters";
+  }
+  return void 0;
+}
+
+// src/domain/text.ts
+var NO_CONTROLS = /^[^\u0000-\u001f\u007f-\u009f]*$/;
+var NO_CONTROLS_TEXT = "one line of text; control characters (ESC, newline, tab) are not allowed";
+var NO_CONTROLS_BUT_BREAKS = /^[^\u0000-\u0008\u000b-\u001f\u007f-\u009f]*$/;
+var NO_CONTROLS_BUT_BREAKS_TEXT = "text with optional newlines (\\n) and tabs; other control characters (ESC, BEL, CR) are not allowed";
+function mapTextError(map) {
+  if (map.context !== void 0) {
+    const error2 = contextError(map.context);
+    if (error2) return error2;
+  }
+  const check = (field, value, multiline = false) => value === void 0 || (multiline ? NO_CONTROLS_BUT_BREAKS : NO_CONTROLS).test(value) ? void 0 : `${field}: ${multiline ? NO_CONTROLS_BUT_BREAKS_TEXT : NO_CONTROLS_TEXT}`;
+  let error = check("title", map.title);
+  if (error) return error;
+  for (const [i, layer] of map.layers.entries()) {
+    error = check(`layers[${i}].name`, layer.name);
+    if (error) return error;
+  }
+  for (const name of ["lanes", "groups"]) {
+    for (const [i, item] of map[name].entries()) {
+      error = check(`${name}[${i}].label`, item.label);
+      if (error) return error;
+    }
+  }
+  for (const [i, node] of map.nodes.entries()) {
+    if (node.sources !== void 0) {
+      const error2 = sourceError(node.sources);
+      if (error2) return `nodes[${i}]: ${error2}`;
+    }
+    for (const name of ["label", "evidence", "detail"]) {
+      error = check(`nodes[${i}].${name}`, node[name], name !== "label");
+      if (error) return error;
+    }
+  }
+  for (const [i, edge] of map.edges.entries()) {
+    error = check(`edges[${i}].label`, edge.label);
+    if (error) return error;
+  }
+  return void 0;
+}
+function terminalText(text, multiline = false) {
+  return text.replace(multiline ? /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g : /[\u0000-\u001f\u007f-\u009f]/g, "?");
+}
+
+// src/store/format.ts
+var STATE_FILE_VERSION = 1;
+function makePageId(raw) {
+  return ID_RULE.test(raw) ? ok(raw) : err({ kind: "invalid-id", raw, rule: ID_RULE_TEXT });
+}
+function describeStoreError(e) {
+  switch (e.kind) {
+    case "not-found":
+      return `no map file at ${e.path}`;
+    case "malformed-json":
+      return `map file ${e.path} is not valid JSON: ${e.detail}`;
+    case "bad-shape":
+      return `map file ${e.path} has an unexpected shape: ${e.detail}`;
+    case "invariant-violation":
+      return `map file ${e.path} violates a structural invariant: ${describeMapError(e.violation)}`;
+    case "save-failed":
+      return `could not write ${e.path}: ${e.detail}`;
+    case "delete-failed":
+      return `could not delete ${e.path}: ${e.detail}`;
+  }
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function describeValue(v) {
+  if (v === void 0) return "missing";
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "an array";
+  return `a ${typeof v}`;
+}
+function badShape(path, where, expected, got) {
+  return err({ kind: "bad-shape", path, detail: `${where} is ${describeValue(got)}, expected ${expected}` });
+}
+function arrayField(raw, key, path, presence) {
+  const v = raw[key];
+  if (Array.isArray(v)) return ok(v);
+  if (v === void 0 && presence === "optional") return ok([]);
+  return badShape(path, `"${key}"`, "an array", v);
+}
+function requiredString(rec, key, where, path) {
+  const v = rec[key];
+  return typeof v === "string" ? ok(v) : badShape(path, `${where}.${key}`, "a string", v);
+}
+function optionalString(rec, key, where, path) {
+  const v = rec[key];
+  if (v === void 0) return ok(void 0);
+  return typeof v === "string" ? ok(v) : badShape(path, `${where}.${key}`, "a string", v);
+}
+function parseMap(raw, path) {
+  if (!isRecord(raw)) return err({ kind: "bad-shape", path, detail: "root is not an object" });
+  if (raw["version"] !== STATE_FILE_VERSION && raw["version"] !== 2) {
+    return err({ kind: "bad-shape", path, detail: `version is ${String(raw["version"])}, expected ${STATE_FILE_VERSION} or 2` });
+  }
+  const layers = arrayField(raw, "layers", path, "required");
+  if (!layers.ok) return layers;
+  const nodes = arrayField(raw, "nodes", path, "required");
+  if (!nodes.ok) return nodes;
+  const edges = arrayField(raw, "edges", path, "required");
+  if (!edges.ok) return edges;
+  const lanes = arrayField(raw, "lanes", path, "optional");
+  if (!lanes.ok) return lanes;
+  const groups = arrayField(raw, "groups", path, "optional");
+  if (!groups.ok) return groups;
+  let map = EMPTY_MAP;
+  if (raw["context"] !== void 0) {
+    const error = contextError(raw["context"]);
+    if (error) return err({ kind: "bad-shape", path, detail: error });
+    map = { ...map, context: raw["context"] };
+  }
+  const title = optionalString(raw, "title", "map", path);
+  if (!title.ok) return title;
+  if (title.value !== void 0) map = setTitle(map, title.value);
+  const rawKind = optionalString(raw, "kind", "map", path);
+  if (!rawKind.ok) return rawKind;
+  if (rawKind.value !== void 0) {
+    const kind = makeMapKind(rawKind.value);
+    if (!kind.ok) return err({ kind: "invariant-violation", path, violation: kind.error });
+    map = setKind(map, kind.value);
+  }
+  for (const [i, rawLayer] of layers.value.entries()) {
+    const where = `layers[${i}]`;
+    if (!isRecord(rawLayer)) return badShape(path, where, "an object", rawLayer);
+    const rawId = requiredString(rawLayer, "id", where, path);
+    if (!rawId.ok) return rawId;
+    const id = makeLayerId(rawId.value);
+    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
+    const name = requiredString(rawLayer, "name", where, path);
+    if (!name.ok) return name;
+    const rawRank = rawLayer["rank"];
+    if (typeof rawRank !== "number") return badShape(path, `${where}.rank`, "a number", rawRank);
+    const rank = makeRank(rawRank);
+    if (!rank.ok) return err({ kind: "invariant-violation", path, violation: rank.error });
+    const next = declareLayer(map, { id: id.value, name: name.value, rank: rank.value });
+    if (!next.ok) return err({ kind: "invariant-violation", path, violation: next.error });
+    map = next.value;
+  }
+  for (const [i, rawLane] of lanes.value.entries()) {
+    const where = `lanes[${i}]`;
+    if (!isRecord(rawLane)) return badShape(path, where, "an object", rawLane);
+    const rawId = requiredString(rawLane, "id", where, path);
+    if (!rawId.ok) return rawId;
+    const id = makeLaneId(rawId.value);
+    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
+    const label = requiredString(rawLane, "label", where, path);
+    if (!label.ok) return label;
+    const declared = declareLane(map, { id: id.value, label: label.value });
+    if (!declared.ok) return err({ kind: "invariant-violation", path, violation: declared.error });
+    map = declared.value;
+  }
+  for (const [i, rawGroup] of groups.value.entries()) {
+    const where = `groups[${i}]`;
+    if (!isRecord(rawGroup)) return badShape(path, where, "an object", rawGroup);
+    const rawId = requiredString(rawGroup, "id", where, path);
+    if (!rawId.ok) return rawId;
+    const id = makeGroupId(rawId.value);
+    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
+    const rawLayer = requiredString(rawGroup, "layer", where, path);
+    if (!rawLayer.ok) return rawLayer;
+    const layer = makeLayerId(rawLayer.value);
+    if (!layer.ok) return err({ kind: "invariant-violation", path, violation: layer.error });
+    const label = requiredString(rawGroup, "label", where, path);
+    if (!label.ok) return label;
+    const declared = declareGroup(map, { id: id.value, label: label.value, layer: layer.value });
+    if (!declared.ok) return err({ kind: "invariant-violation", path, violation: declared.error });
+    map = declared.value;
+  }
+  for (const [i, rawNode] of nodes.value.entries()) {
+    const where = `nodes[${i}]`;
+    if (!isRecord(rawNode)) return badShape(path, where, "an object", rawNode);
+    const rawId = requiredString(rawNode, "id", where, path);
+    if (!rawId.ok) return rawId;
+    const id = makeNodeId(rawId.value);
+    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
+    const rawLayer = requiredString(rawNode, "layer", where, path);
+    if (!rawLayer.ok) return rawLayer;
+    const layer = makeLayerId(rawLayer.value);
+    if (!layer.ok) return err({ kind: "invariant-violation", path, violation: layer.error });
+    const rawStatus = requiredString(rawNode, "status", where, path);
+    if (!rawStatus.ok) return rawStatus;
+    const status = makeNodeStatus(rawStatus.value);
+    if (!status.ok) return err({ kind: "invariant-violation", path, violation: status.error });
+    const label = requiredString(rawNode, "label", where, path);
+    if (!label.ok) return label;
+    const detail = optionalString(rawNode, "detail", where, path);
+    if (!detail.ok) return detail;
+    const rawGroup = optionalString(rawNode, "group", where, path);
+    if (!rawGroup.ok) return rawGroup;
+    let group;
+    if (rawGroup.value !== void 0) {
+      const made = makeGroupId(rawGroup.value);
+      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
+      group = made.value;
+    }
+    const rawNodeKind = optionalString(rawNode, "kind", where, path);
+    if (!rawNodeKind.ok) return rawNodeKind;
+    let nodeKind;
+    if (rawNodeKind.value !== void 0) {
+      const made = makeNodeKind(rawNodeKind.value);
+      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
+      nodeKind = made.value;
+    }
+    const rawLane = optionalString(rawNode, "lane", where, path);
+    if (!rawLane.ok) return rawLane;
+    let lane;
+    if (rawLane.value !== void 0) {
+      const made = makeLaneId(rawLane.value);
+      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
+      lane = made.value;
+    }
+    const rawSubmap = optionalString(rawNode, "submap", where, path);
+    if (!rawSubmap.ok) return rawSubmap;
+    let submap;
+    if (rawSubmap.value !== void 0) {
+      const made = makeSubmapRef(rawSubmap.value);
+      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
+      submap = made.value;
+    }
+    const declared = declareNode(map, {
+      id: id.value,
+      label: label.value,
+      layer: layer.value,
+      status: status.value,
+      ...detail.value !== void 0 ? { detail: detail.value } : {},
+      ...group !== void 0 ? { group } : {},
+      ...nodeKind !== void 0 ? { kind: nodeKind } : {},
+      ...lane !== void 0 ? { lane } : {},
+      ...submap !== void 0 ? { submap } : {}
+    });
+    if (!declared.ok) return err({ kind: "invariant-violation", path, violation: declared.error });
+    map = declared.value;
+    const evidence = optionalString(rawNode, "evidence", where, path);
+    if (!evidence.ok) return evidence;
+    if (evidence.value !== void 0) {
+      const updated = updateNode(map, { id: id.value, evidence: evidence.value });
+      if (!updated.ok) return err({ kind: "invariant-violation", path, violation: updated.error });
+      map = updated.value;
+    }
+    if (rawNode["sources"] !== void 0) {
+      const error = sourceError(rawNode["sources"]);
+      if (error) return err({ kind: "bad-shape", path, detail: `${where}: ${error}` });
+      map = { ...map, nodes: map.nodes.map((n) => n.id === id.value ? { ...n, sources: rawNode["sources"] } : n) };
+    }
+  }
+  for (const [i, rawEdge] of edges.value.entries()) {
+    const where = `edges[${i}]`;
+    if (!isRecord(rawEdge)) return badShape(path, where, "an object", rawEdge);
+    const rawFrom = requiredString(rawEdge, "from", where, path);
+    if (!rawFrom.ok) return rawFrom;
+    const from = makeNodeId(rawFrom.value);
+    if (!from.ok) return err({ kind: "invariant-violation", path, violation: from.error });
+    const rawTo = requiredString(rawEdge, "to", where, path);
+    if (!rawTo.ok) return rawTo;
+    const to = makeNodeId(rawTo.value);
+    if (!to.ok) return err({ kind: "invariant-violation", path, violation: to.error });
+    const label = optionalString(rawEdge, "label", where, path);
+    if (!label.ok) return label;
+    const linked = linkNodes(map, from.value, to.value, label.value);
+    if (!linked.ok) return err({ kind: "invariant-violation", path, violation: linked.error });
+    map = linked.value;
+  }
+  const textError = mapTextError(map);
+  return textError ? err({ kind: "bad-shape", path, detail: textError }) : ok(map);
+}
+
+// src/store/transaction.ts
+var LedgerError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+};
+function storeDirectory(file) {
+  const dir = dirname2(file);
+  return dir.endsWith("/pages") || dir.endsWith("\\pages") ? dirname2(dir) : dir;
+}
+function deadOwner(lock) {
+  try {
+    const owner = JSON.parse(readFileSync(join2(lock, "owner.json"), "utf8"));
+    if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0) return false;
+    try {
+      process.kill(owner.pid, 0);
+      return false;
+    } catch (e) {
+      return e.code === "ESRCH";
+    }
+  } catch {
+    return false;
+  }
+}
+function withStoreLock(file, action) {
+  const dir = storeDirectory(file);
+  mkdirSync(dir, { recursive: true });
+  const lock = join2(dir, ".write-lock");
+  const owner = join2(lock, "owner.json");
+  const token = randomUUID();
+  try {
+    mkdirSync(lock);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    if (!deadOwner(lock)) throw new LedgerError("BUSY", `Another writer owns ${lock}; retry after it completes. An orphan without owner metadata needs manual inspection.`);
+    try {
+      mkdirSync(join2(lock, ".reap"));
+    } catch {
+      throw new LedgerError("BUSY", "Another process is recovering the writer lock.");
+    }
+    if (!deadOwner(lock)) {
+      rmSync(join2(lock, ".reap"), { recursive: true, force: true });
+      throw new LedgerError("BUSY", "Writer ownership changed.");
+    }
+    rmSync(lock, { recursive: true });
+    try {
+      mkdirSync(lock);
+    } catch {
+      throw new LedgerError("BUSY", "Another writer acquired the recovered lock.");
+    }
+  }
+  let initialized = false;
+  try {
+    writeFileSync(owner, JSON.stringify({ pid: process.pid, token }), { flag: "wx" });
+    initialized = true;
+    return action();
+  } finally {
+    try {
+      if (!initialized || JSON.parse(readFileSync(owner, "utf8")).token === token) rmSync(lock, { recursive: true });
+    } catch {
+    }
+  }
+}
+
 // src/semantics/vocabulary.ts
 var STATUS_GLYPHS = {
   planned: ["\xB7", "."],
@@ -573,6 +958,7 @@ function displayWidth(text) {
   return w;
 }
 function fitWidth(s, width) {
+  s = terminalText(s);
   if (displayWidth(s) <= width) return s;
   let out = "";
   let w = 0;
@@ -588,7 +974,7 @@ function wrapWidth(s, width) {
   const lines = [];
   let line = "";
   let w = 0;
-  for (const ch of s.replace(/\r/g, "")) {
+  for (const ch of terminalText(s.replace(/\r/g, "").replace(/\t/g, "  "), true)) {
     if (ch === "\n") {
       lines.push(line);
       line = "";
@@ -617,7 +1003,9 @@ var SGR = {
   greenDim: "32;2",
   // done, but nothing behind the claim: green, not fully lit
   red: "31",
-  faint: "90"
+  faint: "90",
+  focus: "97"
+  // bright foreground without changing font weight
 };
 var ANSI_RESET = "\x1B[0m";
 var UP = 1;
@@ -678,7 +1066,7 @@ var Canvas = class {
   /** Write literal text starting at (x, y). Returns the column just past it. */
   text(x, y, s, style, bold = false) {
     let cx = x;
-    for (const ch of s) {
+    for (const ch of terminalText(s)) {
       const w = charWidth(ch.codePointAt(0));
       if (w === 0) {
         const base = this.cell(Math.max(0, cx - 1), y);
@@ -737,7 +1125,7 @@ var Canvas = class {
         } else if (charWidth(ch.codePointAt(0)) === 2 && x + 1 >= vp.x + vp.width) {
           ch = " ";
         }
-        const params = ch === " " ? "" : isWire ? c.bright ? "1" : SGR.faint : [SGR[c.style], c.bold ? "1" : ""].filter(Boolean).join(";");
+        const params = ch === " " ? "" : isWire ? c.bright ? SGR.focus : SGR.faint : [SGR[c.style], c.bold ? "1" : ""].filter(Boolean).join(";");
         if (opts.color && params !== open) {
           line += (open !== "" ? ANSI_RESET : "") + (params !== "" ? `\x1B[${params}m` : "");
           open = params;
@@ -1086,6 +1474,7 @@ function drawBands(canvas, columns, rows, wiredWidth, totalWidth) {
 function drawBox(canvas, box, opts, neutral, face, focused = false) {
   const { node, x, y, w } = box;
   const skin = neutral ? neutralSkin(opts.unicode) : skinFor(face, opts.unicode);
+  const borderStyle = focused ? "focus" : skin.style;
   const slotGlyph = neutral ? neutralGlyph(node, opts.unicode) : glyphFor(face, opts);
   if (box.borderless) {
     canvas.text(x + 1, y, slotGlyph, skin.style, true);
@@ -1093,18 +1482,18 @@ function drawBox(canvas, box, opts, neutral, face, focused = false) {
   }
   const inner = w - 2;
   const pad = box.pad === 1 ? " " : "";
-  canvas.text(x, y, skin.corners[0] + skin.h.repeat(inner) + skin.corners[1], skin.style, focused);
-  canvas.text(x, y + 1, skin.v, skin.style, focused);
+  canvas.text(x, y, skin.corners[0] + skin.h.repeat(inner) + skin.corners[1], borderStyle);
+  canvas.text(x, y + 1, skin.v, borderStyle);
   canvas.text(x + 1, y + 1, `${pad}${slotGlyph} ${box.label}${pad}`, skin.style, true);
-  canvas.text(x + w - 1, y + 1, skin.v, skin.style, focused);
+  canvas.text(x + w - 1, y + 1, skin.v, borderStyle);
   for (let i = 0; i < box.extra.length; i++) {
     const row = box.extra[i];
     const yy = y + 2 + i;
-    canvas.text(x, yy, skin.v, skin.style, focused);
+    canvas.text(x, yy, skin.v, borderStyle);
     canvas.text(x + 1, yy, row.text, row.style);
-    canvas.text(x + w - 1, yy, skin.v, skin.style, focused);
+    canvas.text(x + w - 1, yy, skin.v, borderStyle);
   }
-  canvas.text(x, y + box.h - 1, skin.corners[2] + skin.h.repeat(inner) + skin.corners[3], skin.style, focused);
+  canvas.text(x, y + box.h - 1, skin.corners[2] + skin.h.repeat(inner) + skin.corners[3], borderStyle);
 }
 function drawEdges(canvas, edges, rows, opts) {
   for (const edge of edges) {
@@ -1234,322 +1623,133 @@ function layoutColumns(map, geo, unicode, neutral) {
       }
     }
   }
-  const placed = /* @__PURE__ */ new Map();
-  for (const [, spec] of sized) placed.set(spec, { ...spec, x: columnOf.get(spec) ?? LEFT_MARGIN });
-  const bandBoxes = bandSized.map((row) => row.map((spec) => placed.get(spec)));
-  const boxOf = /* @__PURE__ */ new Map();
-  for (const node of map.nodes) boxOf.set(node.id, placed.get(sized.get(node.id)));
-  const bandLabel = bands.map((l, i) => {
-    const row = bandBoxes[i];
-    const done = row.filter((b) => b.node.status === "done").length;
-    return geo.bandCounts && row.length > 0 && !neutral ? ` ${l.name} ${done}/${row.length}` : ` ${l.name}`;
-  });
-  let contentWidth = LEFT_MARGIN + BAR_MIN_RUN;
-  for (const row of bandBoxes) for (const box of row) contentWidth = Math.max(contentWidth, box.x + box.w);
-  for (const lane of lanes) contentWidth = Math.max(contentWidth, lane.x + lane.w);
-  return { bands, bandIndexOf, bandBoxes, boxOf, lanes, bandLabel, contentWidth };
-}
-function layoutRows(columns, geo, gapRowCount, hasTitle, hasLanes) {
-  let y = 0;
-  if (hasTitle) y += 1 + geo.titleGap;
-  let laneHeaderY;
-  if (hasLanes) {
-    laneHeaderY = y;
-    y += 1 + geo.barGap;
-  }
-  const barY = [];
-  const gapTrackStartY = [];
-  const bandBoxes = [];
-  const placed = /* @__PURE__ */ new Map();
-  const gapCount = columns.bands.length - 1;
-  for (let b = 0; b < columns.bands.length; b++) {
-    barY.push(y);
-    y += 1 + geo.barGap;
-    const row = columns.bandBoxes[b];
-    for (const box of row) placed.set(box, { ...box, y });
-    bandBoxes.push(row.map((box) => placed.get(box)));
-    y += row.reduce((max, box) => Math.max(max, box.h), geo.mode === "constellation" ? 1 : BOX_H);
-    if (b < gapCount) {
-      y += geo.breathe;
-      gapTrackStartY.push(y);
-      y += gapRowCount[b];
-      y += geo.breathe;
-    }
-  }
-  const boxOf = /* @__PURE__ */ new Map();
-  for (const [id, box] of columns.boxOf) boxOf.set(id, placed.get(box));
-  return { boxOf, bandBoxes, barY, gapTrackStartY, laneHeaderY, legendY: y + 1 };
-}
-
-// src/render/render.ts
-function renderMapWindow(map, opts, viewport) {
-  const built = buildCanvas(map, opts);
-  return {
-    lines: built.canvas.emit(opts, viewport),
-    contentWidth: built.canvas.width,
-    contentHeight: built.canvas.height,
-    hits: built.hits
-  };
-}
-function buildCanvas(map, opts) {
-  const oriented = flipForSequence(map);
-  const plainGeo = zoomGeometry(opts.zoom ?? ZOOM_DEFAULT);
-  const aggregated = plainGeo.mode === "constellation" ? aggregateMap(oriented) : void 0;
-  const drawn = aggregated ?? oriented;
-  return paint(drawn, opts, aggregated !== void 0 ? AGGREGATE_GEO : plainGeo, unverifiedDoneIds(oriented, drawn));
-}
-function paint(map, opts, geo, unverified) {
-  const canvas = new Canvas();
-  if (map.layers.length === 0) {
-    canvas.text(0, 0, map.title ?? "mellos mapping", "none", true);
-    canvas.text(0, 2, "(empty map \u2014 declare layers and nodes to begin)", "dim");
-    return { canvas, hits: [] };
-  }
-  const neutral = isNeutralKind(map);
-  const columns = layoutColumns(map, geo, opts.unicode, neutral);
-  const routing = routeEdges(map, columns);
-  const rows = layoutRows(columns, geo, routing.gapRowCount, map.title !== void 0, map.lanes.length > 0);
-  const wiredWidth = routing.fallbackCount > 0 ? columns.contentWidth + 2 + routing.fallbackCount * 2 : columns.contentWidth;
-  const totalWidth = wiredWidth + Math.max(...columns.bandLabel.map(displayWidth));
-  if (map.title !== void 0) drawTitle(canvas, map.title);
-  drawLaneHeaders(canvas, map, columns, rows);
-  drawBands(canvas, columns, rows, wiredWidth, totalWidth);
-  const faceOf = (id, status) => unverified.has(id) ? "done-unverified" : status;
-  for (const box of rows.boxOf.values()) {
-    const id = box.node.id;
-    drawBox(canvas, box, opts, neutral, faceOf(id, box.node.status), opts.focus !== void 0 && id === opts.focus);
-  }
-  drawEdges(canvas, routing.edges, rows, opts);
-  drawLegend(canvas, map, opts, rows.legendY, neutral, unverified.size > 0);
-  const hits = [...rows.boxOf.values()].map((b) => ({
-    id: b.node.id,
-    x: b.x,
-    y: b.y,
-    w: b.w,
-    h: b.h
-  }));
-  return { canvas, hits };
-}
-
-// src/store/store.ts
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-
-// src/store/format.ts
-var STATE_FILE_VERSION = 1;
-function makePageId(raw) {
-  return ID_RULE.test(raw) ? ok(raw) : err({ kind: "invalid-id", raw, rule: ID_RULE_TEXT });
-}
-function describeStoreError(e) {
-  switch (e.kind) {
-    case "not-found":
-      return `no map file at ${e.path}`;
-    case "malformed-json":
-      return `map file ${e.path} is not valid JSON: ${e.detail}`;
-    case "bad-shape":
-      return `map file ${e.path} has an unexpected shape: ${e.detail}`;
-    case "invariant-violation":
-      return `map file ${e.path} violates a structural invariant: ${describeMapError(e.violation)}`;
-    case "save-failed":
-      return `could not write ${e.path}: ${e.detail}`;
-    case "delete-failed":
-      return `could not delete ${e.path}: ${e.detail}`;
-  }
-}
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function describeValue(v) {
-  if (v === void 0) return "missing";
-  if (v === null) return "null";
-  if (Array.isArray(v)) return "an array";
-  return `a ${typeof v}`;
-}
-function badShape(path, where, expected, got) {
-  return err({ kind: "bad-shape", path, detail: `${where} is ${describeValue(got)}, expected ${expected}` });
-}
-function arrayField(raw, key, path, presence) {
-  const v = raw[key];
-  if (Array.isArray(v)) return ok(v);
-  if (v === void 0 && presence === "optional") return ok([]);
-  return badShape(path, `"${key}"`, "an array", v);
-}
-function requiredString(rec, key, where, path) {
-  const v = rec[key];
-  return typeof v === "string" ? ok(v) : badShape(path, `${where}.${key}`, "a string", v);
-}
-function optionalString(rec, key, where, path) {
-  const v = rec[key];
-  if (v === void 0) return ok(void 0);
-  return typeof v === "string" ? ok(v) : badShape(path, `${where}.${key}`, "a string", v);
-}
-function parseMap(raw, path) {
-  if (!isRecord(raw)) return err({ kind: "bad-shape", path, detail: "root is not an object" });
-  if (raw["version"] !== STATE_FILE_VERSION) {
-    return err({ kind: "bad-shape", path, detail: `version is ${String(raw["version"])}, expected ${STATE_FILE_VERSION}` });
-  }
-  const layers = arrayField(raw, "layers", path, "required");
-  if (!layers.ok) return layers;
-  const nodes = arrayField(raw, "nodes", path, "required");
-  if (!nodes.ok) return nodes;
-  const edges = arrayField(raw, "edges", path, "required");
-  if (!edges.ok) return edges;
-  const lanes = arrayField(raw, "lanes", path, "optional");
-  if (!lanes.ok) return lanes;
-  const groups = arrayField(raw, "groups", path, "optional");
-  if (!groups.ok) return groups;
-  let map = EMPTY_MAP;
-  const title = optionalString(raw, "title", "map", path);
-  if (!title.ok) return title;
-  if (title.value !== void 0) map = setTitle(map, title.value);
-  const rawKind = optionalString(raw, "kind", "map", path);
-  if (!rawKind.ok) return rawKind;
-  if (rawKind.value !== void 0) {
-    const kind = makeMapKind(rawKind.value);
-    if (!kind.ok) return err({ kind: "invariant-violation", path, violation: kind.error });
-    map = setKind(map, kind.value);
-  }
-  for (const [i, rawLayer] of layers.value.entries()) {
-    const where = `layers[${i}]`;
-    if (!isRecord(rawLayer)) return badShape(path, where, "an object", rawLayer);
-    const rawId = requiredString(rawLayer, "id", where, path);
-    if (!rawId.ok) return rawId;
-    const id = makeLayerId(rawId.value);
-    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
-    const name = requiredString(rawLayer, "name", where, path);
-    if (!name.ok) return name;
-    const rawRank = rawLayer["rank"];
-    if (typeof rawRank !== "number") return badShape(path, `${where}.rank`, "a number", rawRank);
-    const rank = makeRank(rawRank);
-    if (!rank.ok) return err({ kind: "invariant-violation", path, violation: rank.error });
-    const next = declareLayer(map, { id: id.value, name: name.value, rank: rank.value });
-    if (!next.ok) return err({ kind: "invariant-violation", path, violation: next.error });
-    map = next.value;
-  }
-  for (const [i, rawLane] of lanes.value.entries()) {
-    const where = `lanes[${i}]`;
-    if (!isRecord(rawLane)) return badShape(path, where, "an object", rawLane);
-    const rawId = requiredString(rawLane, "id", where, path);
-    if (!rawId.ok) return rawId;
-    const id = makeLaneId(rawId.value);
-    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
-    const label = requiredString(rawLane, "label", where, path);
-    if (!label.ok) return label;
-    const declared = declareLane(map, { id: id.value, label: label.value });
-    if (!declared.ok) return err({ kind: "invariant-violation", path, violation: declared.error });
-    map = declared.value;
-  }
-  for (const [i, rawGroup] of groups.value.entries()) {
-    const where = `groups[${i}]`;
-    if (!isRecord(rawGroup)) return badShape(path, where, "an object", rawGroup);
-    const rawId = requiredString(rawGroup, "id", where, path);
-    if (!rawId.ok) return rawId;
-    const id = makeGroupId(rawId.value);
-    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
-    const rawLayer = requiredString(rawGroup, "layer", where, path);
-    if (!rawLayer.ok) return rawLayer;
-    const layer = makeLayerId(rawLayer.value);
-    if (!layer.ok) return err({ kind: "invariant-violation", path, violation: layer.error });
-    const label = requiredString(rawGroup, "label", where, path);
-    if (!label.ok) return label;
-    const declared = declareGroup(map, { id: id.value, label: label.value, layer: layer.value });
-    if (!declared.ok) return err({ kind: "invariant-violation", path, violation: declared.error });
-    map = declared.value;
-  }
-  for (const [i, rawNode] of nodes.value.entries()) {
-    const where = `nodes[${i}]`;
-    if (!isRecord(rawNode)) return badShape(path, where, "an object", rawNode);
-    const rawId = requiredString(rawNode, "id", where, path);
-    if (!rawId.ok) return rawId;
-    const id = makeNodeId(rawId.value);
-    if (!id.ok) return err({ kind: "invariant-violation", path, violation: id.error });
-    const rawLayer = requiredString(rawNode, "layer", where, path);
-    if (!rawLayer.ok) return rawLayer;
-    const layer = makeLayerId(rawLayer.value);
-    if (!layer.ok) return err({ kind: "invariant-violation", path, violation: layer.error });
-    const rawStatus = requiredString(rawNode, "status", where, path);
-    if (!rawStatus.ok) return rawStatus;
-    const status = makeNodeStatus(rawStatus.value);
-    if (!status.ok) return err({ kind: "invariant-violation", path, violation: status.error });
-    const label = requiredString(rawNode, "label", where, path);
-    if (!label.ok) return label;
-    const detail = optionalString(rawNode, "detail", where, path);
-    if (!detail.ok) return detail;
-    const rawGroup = optionalString(rawNode, "group", where, path);
-    if (!rawGroup.ok) return rawGroup;
-    let group;
-    if (rawGroup.value !== void 0) {
-      const made = makeGroupId(rawGroup.value);
-      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
-      group = made.value;
-    }
-    const rawNodeKind = optionalString(rawNode, "kind", where, path);
-    if (!rawNodeKind.ok) return rawNodeKind;
-    let nodeKind;
-    if (rawNodeKind.value !== void 0) {
-      const made = makeNodeKind(rawNodeKind.value);
-      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
-      nodeKind = made.value;
-    }
-    const rawLane = optionalString(rawNode, "lane", where, path);
-    if (!rawLane.ok) return rawLane;
-    let lane;
-    if (rawLane.value !== void 0) {
-      const made = makeLaneId(rawLane.value);
-      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
-      lane = made.value;
+  const placed = /* @__PURE__ */ new Map();
+  for (const [, spec] of sized) placed.set(spec, { ...spec, x: columnOf.get(spec) ?? LEFT_MARGIN });
+  const bandBoxes = bandSized.map((row) => row.map((spec) => placed.get(spec)));
+  const boxOf = /* @__PURE__ */ new Map();
+  for (const node of map.nodes) boxOf.set(node.id, placed.get(sized.get(node.id)));
+  const bandLabel = bands.map((l, i) => {
+    const row = bandBoxes[i];
+    const done = row.filter((b) => b.node.status === "done").length;
+    return geo.bandCounts && row.length > 0 && !neutral ? ` ${l.name} ${done}/${row.length}` : ` ${l.name}`;
+  });
+  let contentWidth = LEFT_MARGIN + BAR_MIN_RUN;
+  for (const row of bandBoxes) for (const box of row) contentWidth = Math.max(contentWidth, box.x + box.w);
+  for (const lane of lanes) contentWidth = Math.max(contentWidth, lane.x + lane.w);
+  return { bands, bandIndexOf, bandBoxes, boxOf, lanes, bandLabel, contentWidth };
+}
+function layoutRows(columns, geo, gapRowCount, hasTitle, hasLanes) {
+  let y = 0;
+  if (hasTitle) y += 1 + geo.titleGap;
+  let laneHeaderY;
+  if (hasLanes) {
+    laneHeaderY = y;
+    y += 1 + geo.barGap;
+  }
+  const barY = [];
+  const gapTrackStartY = [];
+  const bandBoxes = [];
+  const placed = /* @__PURE__ */ new Map();
+  const gapCount = columns.bands.length - 1;
+  for (let b = 0; b < columns.bands.length; b++) {
+    barY.push(y);
+    y += 1 + geo.barGap;
+    const row = columns.bandBoxes[b];
+    for (const box of row) placed.set(box, { ...box, y });
+    bandBoxes.push(row.map((box) => placed.get(box)));
+    y += row.reduce((max, box) => Math.max(max, box.h), geo.mode === "constellation" ? 1 : BOX_H);
+    if (b < gapCount) {
+      y += geo.breathe;
+      gapTrackStartY.push(y);
+      y += gapRowCount[b];
+      y += geo.breathe;
     }
-    const rawSubmap = optionalString(rawNode, "submap", where, path);
-    if (!rawSubmap.ok) return rawSubmap;
-    let submap;
-    if (rawSubmap.value !== void 0) {
-      const made = makeSubmapRef(rawSubmap.value);
-      if (!made.ok) return err({ kind: "invariant-violation", path, violation: made.error });
-      submap = made.value;
+  }
+  const boxOf = /* @__PURE__ */ new Map();
+  for (const [id, box] of columns.boxOf) boxOf.set(id, placed.get(box));
+  return { boxOf, bandBoxes, barY, gapTrackStartY, laneHeaderY, legendY: y + 1 };
+}
+
+// src/render/render.ts
+function renderMapWindow(map, opts, viewport) {
+  return renderSceneWindow(prepareScene(map, opts), opts, viewport);
+}
+function createWindowRenderer() {
+  let previous;
+  let frame;
+  return (map, opts, viewport) => {
+    const zoom = opts.zoom ?? ZOOM_DEFAULT;
+    if (previous?.map !== map || previous.unicode !== opts.unicode || previous.zoom !== zoom) {
+      previous = { map, unicode: opts.unicode, zoom, scene: prepareScene(map, opts) };
     }
-    const declared = declareNode(map, {
-      id: id.value,
-      label: label.value,
-      layer: layer.value,
-      status: status.value,
-      ...detail.value !== void 0 ? { detail: detail.value } : {},
-      ...group !== void 0 ? { group } : {},
-      ...nodeKind !== void 0 ? { kind: nodeKind } : {},
-      ...lane !== void 0 ? { lane } : {},
-      ...submap !== void 0 ? { submap } : {}
-    });
-    if (!declared.ok) return err({ kind: "invariant-violation", path, violation: declared.error });
-    map = declared.value;
-    const evidence = optionalString(rawNode, "evidence", where, path);
-    if (!evidence.ok) return evidence;
-    if (evidence.value !== void 0) {
-      const updated = updateNode(map, { id: id.value, evidence: evidence.value });
-      if (!updated.ok) return err({ kind: "invariant-violation", path, violation: updated.error });
-      map = updated.value;
+    const scene = previous.scene;
+    if (frame?.scene !== scene || frame.spinner !== opts.spinnerFrame || frame.focus !== opts.focus || frame.color !== opts.color) {
+      frame = { scene, spinner: opts.spinnerFrame, focus: opts.focus, color: opts.color, built: paint(scene, opts) };
     }
+    return emitWindow(frame.built, opts, viewport);
+  };
+}
+function renderSceneWindow(scene, opts, viewport) {
+  return emitWindow(paint(scene, opts), opts, viewport);
+}
+function emitWindow(built, opts, viewport) {
+  return {
+    lines: built.canvas.emit(opts, viewport),
+    contentWidth: built.canvas.width,
+    contentHeight: built.canvas.height,
+    hits: built.hits
+  };
+}
+function prepareScene(map, opts) {
+  const oriented = flipForSequence(map);
+  const plainGeo = zoomGeometry(opts.zoom ?? ZOOM_DEFAULT);
+  const aggregated = plainGeo.mode === "constellation" ? aggregateMap(oriented) : void 0;
+  const drawn = aggregated ?? oriented;
+  const unverified = unverifiedDoneIds(oriented, drawn);
+  if (drawn.layers.length === 0) return { map: drawn, unverified };
+  return { map: drawn, unverified, geometry: prepareGeometry(drawn, opts, aggregated !== void 0 ? AGGREGATE_GEO : plainGeo) };
+}
+function prepareGeometry(map, opts, geo) {
+  const neutral = isNeutralKind(map);
+  const columns = layoutColumns(map, geo, opts.unicode, neutral);
+  const routing = routeEdges(map, columns);
+  const rows = layoutRows(columns, geo, routing.gapRowCount, map.title !== void 0, map.lanes.length > 0);
+  const wiredWidth = routing.fallbackCount > 0 ? columns.contentWidth + 2 + routing.fallbackCount * 2 : columns.contentWidth;
+  const totalWidth = wiredWidth + Math.max(...columns.bandLabel.map(displayWidth));
+  const hits = [...rows.boxOf.values()].map((b) => ({
+    id: b.node.id,
+    x: b.x,
+    y: b.y,
+    w: b.w,
+    h: b.h
+  }));
+  return { neutral, columns, routing, rows, wiredWidth, totalWidth, hits };
+}
+function paint(scene, opts) {
+  const { map, unverified, geometry } = scene;
+  const canvas = new Canvas();
+  if (geometry === void 0) {
+    canvas.text(0, 0, map.title ?? "mellos mapping", "none", true);
+    canvas.text(0, 2, "(empty map \u2014 declare layers and nodes to begin)", "dim");
+    return { canvas, hits: [] };
   }
-  for (const [i, rawEdge] of edges.value.entries()) {
-    const where = `edges[${i}]`;
-    if (!isRecord(rawEdge)) return badShape(path, where, "an object", rawEdge);
-    const rawFrom = requiredString(rawEdge, "from", where, path);
-    if (!rawFrom.ok) return rawFrom;
-    const from = makeNodeId(rawFrom.value);
-    if (!from.ok) return err({ kind: "invariant-violation", path, violation: from.error });
-    const rawTo = requiredString(rawEdge, "to", where, path);
-    if (!rawTo.ok) return rawTo;
-    const to = makeNodeId(rawTo.value);
-    if (!to.ok) return err({ kind: "invariant-violation", path, violation: to.error });
-    const label = optionalString(rawEdge, "label", where, path);
-    if (!label.ok) return label;
-    const linked = linkNodes(map, from.value, to.value, label.value);
-    if (!linked.ok) return err({ kind: "invariant-violation", path, violation: linked.error });
-    map = linked.value;
+  const { neutral, columns, routing, rows, wiredWidth, totalWidth, hits } = geometry;
+  if (map.title !== void 0) drawTitle(canvas, map.title);
+  drawLaneHeaders(canvas, map, columns, rows);
+  drawBands(canvas, columns, rows, wiredWidth, totalWidth);
+  const faceOf = (id, status) => unverified.has(id) ? "done-unverified" : status;
+  for (const box of rows.boxOf.values()) {
+    const id = box.node.id;
+    drawBox(canvas, box, opts, neutral, faceOf(id, box.node.status), opts.focus !== void 0 && id === opts.focus);
   }
-  return ok(map);
+  drawEdges(canvas, routing.edges, rows, opts);
+  drawLegend(canvas, map, opts, rows.legendY, neutral, unverified.size > 0);
+  return { canvas, hits };
 }
 
-// src/store/store.ts
-var RENAME_MAX_ATTEMPTS = 10;
+// src/store/atomic.ts
+import { mkdirSync as mkdirSync2, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 var RENAME_BACKOFF_STEP_MS = 10;
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOENT"]);
 function sleepSync(ms) {
@@ -1557,18 +1757,18 @@ function sleepSync(ms) {
 }
 function discardTemp(tmp) {
   try {
-    rmSync(tmp, { force: true });
+    rmSync2(tmp, { force: true });
   } catch {
   }
 }
 function errnoOf(e) {
   return e.code ?? e.message;
 }
-function writeFileAtomic(path, contents) {
+function writeAtomic(path, contents, maxAttempts) {
   const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2, 10)}.tmp`;
   try {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(tmp, contents, "utf8");
+    mkdirSync2(dirname3(path), { recursive: true });
+    writeFileSync2(tmp, contents, "utf8");
   } catch (e) {
     discardTemp(tmp);
     return err({ kind: "save-failed", path, detail: `writing the temp file failed: ${errnoOf(e)}` });
@@ -1580,7 +1780,7 @@ function writeFileAtomic(path, contents) {
       return ok(void 0);
     } catch (e) {
       const code = errnoOf(e);
-      if (!TRANSIENT_RENAME_CODES.has(code) || attempt >= RENAME_MAX_ATTEMPTS) {
+      if (!TRANSIENT_RENAME_CODES.has(code) || attempt >= maxAttempts) {
         discardTemp(tmp);
         return err({ kind: "save-failed", path, detail: `${code} after ${attempt} attempt(s)` });
       }
@@ -1589,17 +1789,15 @@ function writeFileAtomic(path, contents) {
     }
   }
 }
-function isRecord2(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function stripBom(text) {
-  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
-}
+
+// src/store/pages.ts
+import { existsSync as existsSync2, readdirSync, rmSync as rmSync3 } from "node:fs";
+import { basename, dirname as dirname4, join as join3 } from "node:path";
 var STORE_DIR_NAME = ".mellos";
-var STATE_FILE_RELATIVE_PATH = join(STORE_DIR_NAME, "map.json");
+var STATE_FILE_RELATIVE_PATH = join3(STORE_DIR_NAME, "map.json");
 var PAGES_DIR_NAME = "pages";
 function pageFilePath(defaultFile, page) {
-  return page === void 0 ? defaultFile : join(dirname(defaultFile), PAGES_DIR_NAME, `${page}.json`);
+  return page === void 0 ? defaultFile : join3(dirname4(defaultFile), PAGES_DIR_NAME, `${page}.json`);
 }
 function pageIdOfFile(defaultFile, path) {
   if (path === defaultFile) return void 0;
@@ -1608,126 +1806,161 @@ function pageIdOfFile(defaultFile, path) {
 }
 function listPageFiles(defaultFile) {
   const out = [];
-  if (existsSync(defaultFile)) out.push(defaultFile);
+  if (existsSync2(defaultFile)) out.push(defaultFile);
   let entries = [];
   try {
-    entries = readdirSync(join(dirname(defaultFile), PAGES_DIR_NAME));
+    entries = readdirSync(join3(dirname4(defaultFile), PAGES_DIR_NAME));
   } catch {
   }
   for (const e of entries.sort()) {
-    if (e.endsWith(".json")) out.push(join(dirname(defaultFile), PAGES_DIR_NAME, e));
+    if (e.endsWith(".json")) out.push(join3(dirname4(defaultFile), PAGES_DIR_NAME, e));
   }
   return out;
 }
 function deletePageFile(path) {
   try {
-    rmSync(path, { force: true });
+    rmSync3(path, { force: true });
     return ok(void 0);
   } catch (e) {
     return err({ kind: "delete-failed", path, detail: errnoOf(e) });
   }
 }
+
+// src/store/channels.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync as rmSync5 } from "node:fs";
+import { dirname as dirname6, join as join5 } from "node:path";
+
+// src/store/json-text.ts
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+
+// src/store/viewers.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, statSync, rmSync as rmSync4 } from "node:fs";
+import { dirname as dirname5, join as join4 } from "node:path";
+var VIEWERS_DIR_NAME = "viewers";
+var VIEWER_FILE_VERSION = 1;
+var VIEWER_HEARTBEAT_MS = 1e3;
+function viewersDirPath(defaultFile) {
+  return join4(dirname5(defaultFile), VIEWERS_DIR_NAME);
+}
+function viewerFilePath(defaultFile, pid) {
+  return join4(viewersDirPath(defaultFile), `${pid}.json`);
+}
+function publishViewer(defaultFile, pid, report) {
+  const body = { version: VIEWER_FILE_VERSION, page: report.page ?? null, follow: report.follow, owner: report.owner };
+  return writeAtomic(viewerFilePath(defaultFile, pid), `${JSON.stringify(body, null, 2)}
+`, 1);
+}
+function retireViewer(defaultFile, pid) {
+  try {
+    rmSync4(viewerFilePath(defaultFile, pid), { force: true });
+  } catch {
+  }
+}
+
+// src/store/channels.ts
 var FOCUS_FILE_NAME = "focus";
-function focusFilePath(defaultFile) {
-  return join(dirname(defaultFile), FOCUS_FILE_NAME);
+function focusFilePath(defaultFile, pid) {
+  return paneChannelPath(defaultFile, FOCUS_FILE_NAME, pid);
 }
-function takeFocusRequest(defaultFile) {
-  const path = focusFilePath(defaultFile);
+function paneChannelPath(defaultFile, channel, pid) {
+  if (pid === void 0) return join5(dirname6(defaultFile), channel);
+  if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error("Invalid pane process id");
+  return join5(viewersDirPath(defaultFile), `${pid}.${channel}`);
+}
+function takeFocusRequest(defaultFile, pid) {
+  const targeted = pid === void 0 ? void 0 : focusFilePath(defaultFile, pid);
+  const path = targeted !== void 0 && existsSync3(targeted) ? targeted : focusFilePath(defaultFile);
   let raw;
   try {
-    raw = readFileSync(path, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return void 0;
   }
   try {
-    rmSync(path, { force: true });
+    rmSync5(path, { force: true });
   } catch {
   }
-  let parsed;
+  let parsed2;
   try {
-    parsed = JSON.parse(raw);
+    parsed2 = JSON.parse(raw);
   } catch {
     return void 0;
   }
-  if (typeof parsed !== "object" || parsed === null) return void 0;
-  const page = parsed.page;
+  if (typeof parsed2 !== "object" || parsed2 === null) return void 0;
+  const page = parsed2.page;
   if (page === void 0 || page === null) return { page: void 0 };
   if (typeof page !== "string") return void 0;
   const id = makePageId(page);
   return id.ok ? { page: id.value } : void 0;
 }
 var QUIT_FILE_NAME = "quit";
-function quitFilePath(defaultFile) {
-  return join(dirname(defaultFile), QUIT_FILE_NAME);
+function quitFilePath(defaultFile, pid) {
+  return paneChannelPath(defaultFile, QUIT_FILE_NAME, pid);
 }
-function takeQuitRequest(defaultFile) {
-  const path = quitFilePath(defaultFile);
+function takeQuitRequest(defaultFile, pid) {
+  const targeted = pid === void 0 ? void 0 : quitFilePath(defaultFile, pid);
+  const path = targeted !== void 0 && existsSync3(targeted) ? targeted : quitFilePath(defaultFile);
   let raw;
   try {
-    raw = readFileSync(path, "utf8");
+    raw = readFileSync3(path, "utf8");
   } catch {
     return false;
   }
-  sweepQuitRequest(defaultFile);
-  let parsed;
+  sweepQuitRequest(defaultFile, path === targeted ? pid : void 0);
+  let parsed2;
   try {
-    parsed = JSON.parse(stripBom(raw));
+    parsed2 = JSON.parse(stripBom(raw));
   } catch {
     return false;
   }
-  return isRecord2(parsed);
-}
-function sweepQuitRequest(defaultFile) {
-  try {
-    rmSync(quitFilePath(defaultFile), { force: true });
-  } catch {
-  }
-}
-var VIEWERS_DIR_NAME = "viewers";
-var VIEWER_FILE_VERSION = 1;
-var VIEWER_HEARTBEAT_MS = 1e3;
-function viewersDirPath(defaultFile) {
-  return join(dirname(defaultFile), VIEWERS_DIR_NAME);
-}
-function viewerFilePath(defaultFile, pid) {
-  return join(viewersDirPath(defaultFile), `${pid}.json`);
+  return isRecord2(parsed2);
 }
-function publishViewer(defaultFile, pid, report) {
-  const body = { version: VIEWER_FILE_VERSION, page: report.page ?? null, follow: report.follow };
-  return writeFileAtomic(viewerFilePath(defaultFile, pid), `${JSON.stringify(body, null, 2)}
-`);
-}
-function retireViewer(defaultFile, pid) {
+function sweepQuitRequest(defaultFile, pid) {
   try {
-    rmSync(viewerFilePath(defaultFile, pid), { force: true });
+    rmSync5(quitFilePath(defaultFile, pid), { force: true });
   } catch {
   }
 }
+
+// src/store/policy.ts
+import { dirname as dirname7, join as join6 } from "node:path";
 var CONFIG_FILE_NAME = "config.json";
 function configFilePath(defaultFile) {
-  return join(dirname(defaultFile), CONFIG_FILE_NAME);
+  return join6(dirname7(defaultFile), CONFIG_FILE_NAME);
 }
-var LEGACY_STATE_FILE_RELATIVE_PATH = join(".claude", "mellos-mapping.json");
+
+// src/store/migration.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "node:fs";
+import { dirname as dirname8, join as join7 } from "node:path";
+var LEGACY_STATE_FILE_RELATIVE_PATH = join7(".claude", "mellos-mapping.json");
 var LEGACY_PAGES_DIR_NAME = "mellos-mapping.pages";
 var LEGACY_CONFIG_FILE_NAME = "mellos-mapping.config.json";
 function migrateLegacyStore(defaultFile) {
-  const projectRoot = dirname(dirname(defaultFile));
-  const legacyDefault = join(projectRoot, LEGACY_STATE_FILE_RELATIVE_PATH);
-  const legacyPages = join(dirname(legacyDefault), LEGACY_PAGES_DIR_NAME);
-  const legacyConfig = join(dirname(legacyDefault), LEGACY_CONFIG_FILE_NAME);
-  const hasLegacy = existsSync(legacyDefault) || existsSync(legacyPages) || existsSync(legacyConfig);
-  const hasCurrent = existsSync(defaultFile) || existsSync(join(dirname(defaultFile), PAGES_DIR_NAME)) || existsSync(configFilePath(defaultFile));
+  const projectRoot = dirname8(dirname8(defaultFile));
+  const legacyDefault = join7(projectRoot, LEGACY_STATE_FILE_RELATIVE_PATH);
+  const legacyPages = join7(dirname8(legacyDefault), LEGACY_PAGES_DIR_NAME);
+  const legacyConfig = join7(dirname8(legacyDefault), LEGACY_CONFIG_FILE_NAME);
+  const hasLegacy = existsSync4(legacyDefault) || existsSync4(legacyPages) || existsSync4(legacyConfig);
+  const hasCurrent = existsSync4(defaultFile) || existsSync4(join7(dirname8(defaultFile), PAGES_DIR_NAME)) || existsSync4(configFilePath(defaultFile));
   if (!hasLegacy || hasCurrent) return false;
-  mkdirSync(dirname(defaultFile), { recursive: true });
-  if (existsSync(legacyDefault)) renameSync(legacyDefault, defaultFile);
-  if (existsSync(legacyPages)) renameSync(legacyPages, join(dirname(defaultFile), PAGES_DIR_NAME));
-  if (existsSync(legacyConfig)) renameSync(legacyConfig, configFilePath(defaultFile));
+  mkdirSync3(dirname8(defaultFile), { recursive: true });
+  if (existsSync4(legacyDefault)) renameSync2(legacyDefault, defaultFile);
+  if (existsSync4(legacyPages)) renameSync2(legacyPages, join7(dirname8(defaultFile), PAGES_DIR_NAME));
+  if (existsSync4(legacyConfig)) renameSync2(legacyConfig, configFilePath(defaultFile));
   return true;
 }
+
+// src/store/maps.ts
+import { readFileSync as readFileSync4 } from "node:fs";
 function loadMapFile(path) {
   let text;
   try {
-    text = readFileSync(path, "utf8");
+    text = readFileSync4(path, "utf8");
   } catch (e) {
     const code = e.code;
     if (code === "ENOENT") return err({ kind: "not-found", path });
@@ -1843,6 +2076,175 @@ function parseInput(chunk) {
   return { events, rest: "" };
 }
 
+// src/watch/view-state.ts
+var defaultPage = () => ({ offsetX: 0, offsetY: 0, zoom: ZOOM_DEFAULT, selectedId: void 0 });
+function initialViewState() {
+  return {
+    ...defaultPage(),
+    pageViews: /* @__PURE__ */ new Map(),
+    hoverId: void 0,
+    dragAnchor: void 0,
+    press: void 0,
+    dividerDrag: false,
+    lastClick: void 0
+  };
+}
+function reduceView(state, event) {
+  switch (event.kind) {
+    case "reset":
+      return { ...state, offsetX: 0, offsetY: 0, zoom: ZOOM_DEFAULT };
+    case "pan":
+      return { ...state, offsetX: state.offsetX + event.dx, offsetY: state.offsetY + event.dy };
+    case "position":
+      return { ...state, offsetX: event.x, offsetY: event.y };
+    case "zoom":
+      return { ...state, zoom: event.value };
+    case "hover":
+      return event.id === state.hoverId ? state : { ...state, hoverId: event.id };
+    case "select":
+      return { ...state, selectedId: event.id };
+    case "down":
+      return {
+        ...state,
+        dividerDrag: event.divider,
+        dragAnchor: event.divider ? void 0 : { x: event.x, y: event.y, ox: state.offsetX, oy: state.offsetY },
+        press: event.divider ? void 0 : { moved: false }
+      };
+    case "drag": {
+      if (state.dividerDrag || !state.dragAnchor) return state;
+      const { x, y, ox, oy } = state.dragAnchor;
+      const offsetX = ox - (event.x - x);
+      const offsetY = oy - (event.y - y);
+      return offsetX === state.offsetX && offsetY === state.offsetY ? state : { ...state, offsetX, offsetY, press: { moved: true } };
+    }
+    case "up":
+      return { ...state, dragAnchor: void 0, press: void 0, dividerDrag: false };
+    case "pages": {
+      const pageViews = new Map([...state.pageViews].filter(([file]) => event.files.includes(file)));
+      if (event.previous === event.active || event.active === void 0) return { ...state, pageViews };
+      if (event.previous !== void 0 && event.files.includes(event.previous)) pageViews.set(event.previous, {
+        offsetX: state.offsetX,
+        offsetY: state.offsetY,
+        zoom: state.zoom,
+        selectedId: state.selectedId
+      });
+      return {
+        ...state,
+        ...pageViews.get(event.active) ?? defaultPage(),
+        pageViews,
+        hoverId: void 0,
+        dragAnchor: void 0,
+        press: void 0,
+        dividerDrag: false,
+        lastClick: void 0
+      };
+    }
+  }
+}
+function isPointerClick(state) {
+  return !state.dividerDrag && state.press !== void 0 && !state.press.moved;
+}
+function clickNode(state, id, now, doubleClickMs) {
+  const double = id !== void 0 && state.lastClick?.id === id && now - state.lastClick.at <= doubleClickMs;
+  return {
+    state: { ...state, selectedId: id, lastClick: double || id === void 0 ? void 0 : { id, at: now } },
+    diveId: double ? id : void 0
+  };
+}
+
+// src/watch/io.ts
+var nativeWatcherIO = () => ({
+  interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+  input: process.stdin,
+  output: process.stdout
+});
+
+// src/watch/terminal-session.ts
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var ENTER_SCREEN = "\x1B[?1049h";
+var LEAVE_SCREEN = "\x1B[?1049l";
+var CLEAR_SCREEN = "\x1B[H\x1B[2J";
+var MOUSE_ON = "\x1B[?1003h\x1B[?1006h";
+var MOUSE_OFF = "\x1B[?1003l\x1B[?1006l";
+var RESET = "\x1B[0m";
+function terminalRestoreSequence(mouseActive, alternateScreen = false) {
+  return (mouseActive ? MOUSE_OFF : "") + RESET + (alternateScreen ? LEAVE_SCREEN : "") + SHOW_CURSOR + (alternateScreen ? "" : "\n");
+}
+function openTerminalSession(options) {
+  const { interactive, write } = options;
+  const mouseActive = interactive && options.mouse;
+  write((interactive ? ENTER_SCREEN : "") + HIDE_CURSOR + CLEAR_SCREEN + (mouseActive ? MOUSE_ON : ""));
+  const timer = mouseActive ? setInterval(() => write(HIDE_CURSOR + MOUSE_ON), 1e3) : void 0;
+  timer?.unref();
+  let closed = false;
+  return {
+    close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(timer);
+      write(terminalRestoreSequence(mouseActive, interactive));
+    }
+  };
+}
+
+// src/watch/frame-output.ts
+function frameDifference(previous, next) {
+  const compatible = previous?.columns === next.columns;
+  let output = "";
+  for (let row = 0; row < Math.max(next.rows.length, previous?.rows.length ?? 0); row++) {
+    const text = next.rows[row] ?? "";
+    if (compatible && text === previous?.rows[row]) continue;
+    output += `\x1B[${row + 1};1H${text}\x1B[0m\x1B[K`;
+  }
+  return output;
+}
+function createFrameOutput(port) {
+  let previous;
+  let latest;
+  let pending;
+  let unsubscribe;
+  let closed = false;
+  const flush = () => {
+    if (closed || unsubscribe !== void 0 || pending === void 0) return;
+    const frame = pending;
+    pending = void 0;
+    const output = frameDifference(previous, frame);
+    if (output === "") return;
+    previous = frame;
+    if (!port.write(output)) {
+      unsubscribe = port.onDrain(() => {
+        unsubscribe?.();
+        unsubscribe = void 0;
+        flush();
+      });
+    }
+  };
+  const refresh = setInterval(() => {
+    previous = void 0;
+    pending = latest;
+    flush();
+  }, 1e3);
+  refresh.unref();
+  return {
+    present(frame) {
+      if (closed) return;
+      latest = pending = frame;
+      flush();
+    },
+    invalidate() {
+      previous = void 0;
+    },
+    close() {
+      closed = true;
+      clearInterval(refresh);
+      unsubscribe?.();
+      unsubscribe = void 0;
+      pending = latest = previous = void 0;
+    }
+  };
+}
+
 // src/watch/pane-state.ts
 function describePageFault(fault) {
   return fault.kind === "unreadable" ? `cannot read ${fault.path}: ${fault.detail}` : describeStoreError(fault);
@@ -2011,13 +2413,14 @@ function describeArgsError(e) {
 }
 var USAGE = "usage: mellos-mapping-watch [--file <map.json>] [--page <slug>] [--interval <ms>] [--ascii] [--no-color] [--no-mouse] [--no-follow]";
 function parseArgs(argv, cwd) {
-  let file = join2(cwd, STATE_FILE_RELATIVE_PATH);
+  let file = join8(resolveProjectDirectory(cwd), STATE_FILE_RELATIVE_PATH);
   let intervalMs = POLL_INTERVAL_DEFAULT_MS;
   let unicode = true;
   let color = true;
   let mouse = true;
   let page;
   let follow = true;
+  let owner;
   const valueOf = (flag, raw) => raw === void 0 || raw.startsWith("--") ? err({ kind: "missing-value", flag }) : ok(raw);
   for (let i = 0; i < argv.length; i++) {
     const flag = argv[i];
@@ -2031,9 +2434,17 @@ function parseArgs(argv, cwd) {
       case "--page": {
         const value = valueOf(flag, argv[++i]);
         if (!value.ok) return value;
-        const parsed = makePageId(value.value);
-        if (!parsed.ok) return err({ kind: "invalid-value", flag, raw: value.value, rule: parsed.error.rule });
-        page = parsed.value;
+        const parsed2 = makePageId(value.value);
+        if (!parsed2.ok) return err({ kind: "invalid-value", flag, raw: value.value, rule: parsed2.error.rule });
+        page = parsed2.value;
+        break;
+      }
+      case "--owner": {
+        const value = valueOf(flag, argv[++i]);
+        if (!value.ok) return value;
+        const parsed2 = makePageId(value.value);
+        if (!parsed2.ok) return err({ kind: "invalid-value", flag, raw: value.value, rule: parsed2.error.rule });
+        owner = parsed2.value;
         break;
       }
       case "--interval": {
@@ -2062,7 +2473,7 @@ function parseArgs(argv, cwd) {
         return err({ kind: "unknown-flag", flag });
     }
   }
-  return ok({ file, intervalMs, unicode, color, mouse, page, follow });
+  return ok({ file, intervalMs, unicode, color, mouse, page, follow, ...owner === void 0 ? {} : { owner } });
 }
 function readPage(file) {
   try {
@@ -2071,9 +2482,9 @@ function readPage(file) {
     return err({ kind: "unreadable", path: file, detail: e.code ?? e.message });
   }
 }
-function renderWindow(map, opts, viewport) {
+function renderWindow(map, opts, viewport, render = renderMapWindow) {
   try {
-    return ok(renderMapWindow(map, opts, viewport));
+    return ok(render(map, opts, viewport));
   } catch (e) {
     return err(`this map could not be drawn: ${e.message}`);
   }
@@ -2090,17 +2501,10 @@ function dividerRow(width, unicode, follow) {
   }
   return bar;
 }
-var HIDE_CURSOR = "\x1B[?25l";
-var SHOW_CURSOR = "\x1B[?25h";
 var CLEAR_ALL = "\x1B[H\x1B[2J";
 var HOME = "\x1B[H";
 var ERASE_LINE_END = "\x1B[K";
-var MOUSE_ON = "\x1B[?1003h\x1B[?1006h";
-var MOUSE_OFF = "\x1B[?1003l\x1B[?1006l";
-var RESET = "\x1B[0m";
-function terminalRestoreSequence(mouseActive) {
-  return (mouseActive ? MOUSE_OFF : "") + SHOW_CURSOR + RESET + "\n";
-}
+var RESET2 = "\x1B[0m";
 var PANEL_CONTENT_ROWS = 6;
 var PANEL_ROWS_MIN = 2;
 var MAP_ROWS_MIN = 4;
@@ -2291,7 +2695,7 @@ function waitingInfo(s, width) {
   const clock = s.elapsedMs !== void 0 ? ` \xB7 waiting ${elapsedLabel(s.elapsedMs)}` : "";
   const lines = [
     `watching  ${s.defaultFile}`,
-    `      and ${join2(s.pagesDir, "*.json")}`,
+    `      and ${join8(s.pagesDir, "*.json")}`,
     `polling every ${s.intervalMs} ms${clock}`
   ];
   for (const b of s.broken) lines.push(`! ${b}`);
@@ -2300,7 +2704,7 @@ function waitingInfo(s, width) {
 }
 function splashFrame(notice, info, frame, width, height, unicode, color) {
   if (width < 24 || height < info.length + 3) return void 0;
-  const dim = (s) => color ? `\x1B[90m${s}${RESET}` : s;
+  const dim = (s) => color ? `\x1B[90m${s}${RESET2}` : s;
   const spinner = SPINNER_FRAMES[unicode ? "unicode" : "ascii"];
   const status = fitWidth(`${spinner[frame % spinner.length]} ${notice}`, Math.max(1, width - 2));
   const statusIndent = " ".repeat(Math.max(0, Math.floor((width - displayWidth(status)) / 2)));
@@ -2331,17 +2735,12 @@ function viewerReportOf(pane, defaultFile) {
   const shown = pane.activeFile ?? pane.pendingFocusFile ?? defaultFile;
   return { page: pageIdOfFile(defaultFile, shown), follow: pane.follow };
 }
-function main() {
-  const parsed = parseArgs(process.argv.slice(2), process.cwd());
-  if (!parsed.ok) {
-    console.error(`mellos-mapping-watch: ${describeArgsError(parsed.error)}
-${USAGE}`);
-    process.exit(1);
-  }
-  const cfg = parsed.value;
+function runWatcher(cfg, io = nativeWatcherIO()) {
+  const renderScene = createWindowRenderer();
   if (migrateLegacyStore(cfg.file)) console.error("mellos-mapping: moved the legacy .claude map store to .mellos/ \u2014 commit the move.");
   sweepQuitRequest(cfg.file);
-  const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+  sweepQuitRequest(cfg.file, process.pid);
+  const interactive = io.interactive;
   const mouseActive = interactive && cfg.mouse;
   let lastFrame = "";
   let spinnerFrame = 0;
@@ -2350,28 +2749,19 @@ ${USAGE}`);
   const standbyNotice = "waiting for the first mmap_declare ...";
   let map;
   let notice = standbyNotice;
-  let lastCols = process.stdout.columns ?? 0;
-  let lastRows = process.stdout.rows ?? 0;
+  let lastCols = io.output.columns ?? 0;
+  let lastRows = io.output.rows ?? 0;
   let pane = initialPaneState(
     cfg.follow,
     cfg.page === void 0 ? void 0 : pageFilePath(cfg.file, cfg.page)
   );
-  const pageViews = /* @__PURE__ */ new Map();
+  let view = initialViewState();
   let lastTabSegments = [];
   let tabScroll = 0;
-  let offsetX = 0;
-  let offsetY = 0;
-  let zoom = ZOOM_DEFAULT;
-  let dragAnchor;
-  let press;
-  let hoverId;
-  let selectedId;
   let lastHits = [];
   let lastContent = { w: 0, h: 0 };
   let pendingInput = "";
   let panelContentRows = PANEL_CONTENT_ROWS;
-  let dividerDrag = false;
-  let lastClick;
   let flash;
   let lastTabFiles = [];
   const topFiles = () => topLevelFiles(cfg.file, filesOf(pane), mapsOf(pane));
@@ -2387,8 +2777,8 @@ ${USAGE}`);
     }
     return false;
   };
-  const viewWidth = () => usableColumns(process.stdout.columns ?? FALLBACK_COLUMNS);
-  const viewHeight = () => Math.max(1, (process.stdout.rows ?? FALLBACK_ROWS) - (1 + panelContentRows) - 1 - tabRows());
+  const viewWidth = () => usableColumns(io.output.columns ?? FALLBACK_COLUMNS);
+  const viewHeight = () => Math.max(1, (io.output.rows ?? FALLBACK_ROWS) - (1 + panelContentRows) - 1 - tabRows());
   const dividerY = () => tabRows() + viewHeight() + 1;
   const pageTabsOf = (files) => files.map((f) => {
     const entry = entryOf(pane, f);
@@ -2415,14 +2805,8 @@ ${USAGE}`);
   };
   const adoptView = (previous) => {
     const file = pane.activeFile;
+    view = reduceView(view, { kind: "pages", previous, active: file, files: filesOf(pane) });
     if (file === void 0 || file === previous) return;
-    if (previous !== void 0) pageViews.set(previous, { offsetX, offsetY, zoom, selectedId });
-    const view = pageViews.get(file);
-    offsetX = view?.offsetX ?? 0;
-    offsetY = view?.offsetY ?? 0;
-    zoom = view?.zoom ?? ZOOM_DEFAULT;
-    selectedId = view?.selectedId;
-    hoverId = void 0;
     const top = topFiles();
     const tabIndex = top.indexOf(file);
     if (tabIndex >= 0) {
@@ -2444,16 +2828,33 @@ ${USAGE}`);
     const sy = termY - 1 - tabRows();
     if (sx < 0 || sx >= viewWidth()) return void 0;
     if (sy < 0 || sy >= viewHeight()) return void 0;
-    const cx = sx + offsetX;
-    const cy = sy + offsetY;
+    const cx = sx + view.offsetX;
+    const cy = sy + view.offsetY;
     return lastHits.find((h) => cx >= h.x && cx < h.x + h.w && cy >= h.y && cy < h.y + h.h)?.id;
   };
   const publishPresence = () => {
-    publishViewer(cfg.file, process.pid, viewerReportOf(pane, cfg.file));
+    io.report?.(viewerReportOf(pane, cfg.file));
+    publishViewer(cfg.file, process.pid, {
+      ...viewerReportOf(pane, cfg.file),
+      ...cfg.owner === void 0 ? {} : { owner: cfg.owner }
+    });
   };
-  process.stdout.write(HIDE_CURSOR + CLEAR_ALL + (mouseActive ? MOUSE_ON : ""));
+  if (interactive) io.input.setRawMode(true);
+  const terminal = openTerminalSession({ interactive, mouse: cfg.mouse, write: (text) => io.output.write(text) });
+  const frameOutput = interactive ? createFrameOutput({
+    write: (text) => io.output.write(text),
+    onDrain: (ready) => {
+      io.output.once("drain", ready);
+      return () => {
+        io.output.off("drain", ready);
+      };
+    }
+  }) : void 0;
+  let paintTimer;
   process.on("exit", () => {
-    process.stdout.write(terminalRestoreSequence(mouseActive));
+    clearTimeout(paintTimer);
+    frameOutput?.close();
+    terminal.close();
     retireViewer(cfg.file, process.pid);
   });
   const quit = () => process.exit(0);
@@ -2465,20 +2866,31 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
 `);
     process.exit(1);
   });
+  const sceneOptions = () => ({
+    color: cfg.color,
+    unicode: cfg.unicode,
+    zoom: view.zoom,
+    focus: view.hoverId ?? view.selectedId,
+    // A spinner on another page must not invalidate this completed picture.
+    spinnerFrame: map?.nodes.some((node) => node.status === "in-progress") ? spinnerFrame : 0
+  });
   const paint2 = () => {
-    const cols = process.stdout.columns ?? FALLBACK_COLUMNS;
+    clearTimeout(paintTimer);
+    paintTimer = void 0;
+    const cols = io.output.columns ?? FALLBACK_COLUMNS;
     const viewW = viewWidth();
-    panelContentRows = clampPanelRows(panelContentRows, process.stdout.rows ?? FALLBACK_ROWS, tabRows());
+    panelContentRows = clampPanelRows(panelContentRows, io.output.rows ?? FALLBACK_ROWS, tabRows());
     const viewH = viewHeight();
-    const focus = hoverId ?? selectedId;
+    const focus = view.hoverId ?? view.selectedId;
     let body;
     let panned = "";
     let pannable = false;
     if (map !== void 0) {
       const rendered = renderWindow(
         map,
-        { color: cfg.color, unicode: cfg.unicode, spinnerFrame, focus, zoom },
-        { x: offsetX, y: offsetY, width: viewW, height: viewH }
+        sceneOptions(),
+        { x: view.offsetX, y: view.offsetY, width: viewW, height: viewH },
+        renderScene
       );
       if (!rendered.ok) {
         body = ["", fitWidth(`  ! ${rendered.error}`, viewW), ""];
@@ -2487,9 +2899,12 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
         const windowed = rendered.value;
         const maxX = Math.max(0, windowed.contentWidth - viewW);
         const maxY = Math.max(0, windowed.contentHeight - viewH);
-        if (offsetX > maxX || offsetY > maxY || offsetX < 0 || offsetY < 0) {
-          offsetX = Math.min(Math.max(0, offsetX), maxX);
-          offsetY = Math.min(Math.max(0, offsetY), maxY);
+        if (view.offsetX > maxX || view.offsetY > maxY || view.offsetX < 0 || view.offsetY < 0) {
+          view = reduceView(view, {
+            kind: "position",
+            x: Math.min(Math.max(0, view.offsetX), maxX),
+            y: Math.min(Math.max(0, view.offsetY), maxY)
+          });
           paint2();
           return;
         }
@@ -2497,13 +2912,13 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
         body = windowed.lines;
         lastHits = windowed.hits;
         lastContent = { w: windowed.contentWidth, h: windowed.contentHeight };
-        if (offsetX !== 0 || offsetY !== 0) panned = `  (+${offsetX},+${offsetY})`;
+        if (view.offsetX !== 0 || view.offsetY !== 0) panned = `  (+${view.offsetX},+${view.offsetY})`;
       }
     } else {
       const info = waitingInfo(
         {
           defaultFile: cfg.file,
-          pagesDir: join2(dirname2(cfg.file), PAGES_DIR_NAME),
+          pagesDir: join8(dirname9(cfg.file), PAGES_DIR_NAME),
           intervalMs: cfg.intervalMs,
           elapsedMs: interactive ? Date.now() - startedAt : void 0,
           broken: pane.pages.flatMap(
@@ -2522,15 +2937,15 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
     if (map === void 0) {
       panel = Array.from({ length: panelContentRows }, () => ({ text: "", sgr: "" }));
     } else if (focus !== void 0) {
-      panel = nodePanel(map, focus, cfg.unicode, panelWidth, selectedId === focus, panelContentRows) ?? mapPanel(map, cfg.unicode, panelWidth, panelContentRows);
+      panel = nodePanel(map, focus, cfg.unicode, panelWidth, view.selectedId === focus, panelContentRows) ?? mapPanel(map, cfg.unicode, panelWidth, panelContentRows);
     } else {
       panel = mapPanel(map, cfg.unicode, panelWidth, panelContentRows);
     }
     const separator = dividerRow(viewW, cfg.unicode, pane.follow);
     const panelRows = [
-      cfg.color ? `\x1B[90m${separator}${RESET}` : separator,
+      cfg.color ? `\x1B[90m${separator}${RESET2}` : separator,
       ...panel.map(
-        (l) => cfg.color && l.sgr !== "" && l.text !== "" ? ` \x1B[${l.sgr}m${l.text}${RESET}` : ` ${l.text}`
+        (l) => cfg.color && l.sgr !== "" && l.text !== "" ? ` \x1B[${l.sgr}m${l.text}${RESET2}` : ` ${l.text}`
       )
     ];
     let tabLine;
@@ -2552,43 +2967,53 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
         action: { kind: "back" }
       };
       lastTabSegments = [head, tail];
-      tabLine = lastTabSegments.map((s) => cfg.color && s.sgr !== "" ? `\x1B[${s.sgr}m${s.text}${RESET}` : s.text).join("");
+      tabLine = lastTabSegments.map((s) => cfg.color && s.sgr !== "" ? `\x1B[${s.sgr}m${s.text}${RESET2}` : s.text).join("");
     } else if (tabRows() > 0) {
       const segments = pageTabRow(pageTabsOf(lastTabFiles), viewW, cfg.unicode, tabScroll, mouseActive);
       lastTabSegments = segments;
-      tabLine = segments.map((s) => cfg.color && s.sgr !== "" ? `\x1B[${s.sgr}m${s.text}${RESET}` : s.text).join("");
+      tabLine = segments.map((s) => cfg.color && s.sgr !== "" ? `\x1B[${s.sgr}m${s.text}${RESET2}` : s.text).join("");
     } else {
       lastTabSegments = [];
     }
-    const zoomTag = `${cfg.unicode ? "\u2295" : "zoom"} ${zoomLabel(zoom)}`;
+    const zoomTag = `${cfg.unicode ? "\u2295" : "zoom"} ${zoomLabel(view.zoom)}`;
     const hint = !interactive ? cfg.file : (flash !== void 0 ? `${flash.text} \xB7 ` : "") + `${zoomTag} \xB7 wheel zoom \xB7 ` + (pannable ? "drag pan \xB7 " : "") + "hover/click \xB7 0 reset \xB7 x delete page \xB7 q quit";
     const footerText = fitWidth(` ${hint}${panned}`, viewW);
-    const footer = cfg.color ? `\x1B[90m${footerText}${RESET}` : footerText;
-    let frame = HOME;
-    if (tabLine !== void 0) frame += tabLine + ERASE_LINE_END + "\n";
-    for (let i = 0; i < viewH; i++) frame += (body[i] ?? "") + ERASE_LINE_END + "\n";
-    for (const row of panelRows) frame += row + ERASE_LINE_END + "\n";
-    frame += footer + ERASE_LINE_END;
-    if (frame !== lastFrame) {
-      process.stdout.write(frame);
-      lastFrame = frame;
+    const footer = cfg.color ? `\x1B[90m${footerText}${RESET2}` : footerText;
+    const rows = [
+      ...tabLine === void 0 ? [] : [tabLine],
+      ...Array.from({ length: viewH }, (_, i) => body[i] ?? ""),
+      ...panelRows,
+      footer
+    ];
+    if (frameOutput !== void 0) {
+      frameOutput.present({ columns: cols, rows });
+    } else {
+      const frame = HOME + rows.map((row) => row + ERASE_LINE_END).join("\n");
+      if (frame !== lastFrame) {
+        io.output.write(frame);
+        lastFrame = frame;
+      }
     }
   };
+  const requestPaint = () => {
+    paintTimer ??= setTimeout(paint2, 16);
+  };
   const handleResize = () => {
-    lastCols = process.stdout.columns ?? lastCols;
-    lastRows = process.stdout.rows ?? lastRows;
+    lastCols = io.output.columns ?? lastCols;
+    lastRows = io.output.rows ?? lastRows;
     lastFrame = "";
-    process.stdout.write(CLEAR_ALL);
+    frameOutput?.invalidate();
+    io.output.write(CLEAR_ALL);
     paint2();
   };
   const tick = () => {
-    if (takeQuitRequest(cfg.file)) quit();
-    if ((process.stdout.columns ?? lastCols) !== lastCols || (process.stdout.rows ?? lastRows) !== lastRows) {
+    if (takeQuitRequest(cfg.file, process.pid)) quit();
+    if ((io.output.columns ?? lastCols) !== lastCols || (io.output.rows ?? lastRows) !== lastRows) {
       handleResize();
     }
     const discovered = listPageFiles(cfg.file);
     const files = discovered.length > 0 ? discovered : [cfg.file];
-    const request = takeFocusRequest(cfg.file);
+    const request = takeFocusRequest(cfg.file, process.pid);
     const previous = pane.activeFile;
     const scanned = scan(pane, {
       files,
@@ -2603,12 +3028,9 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
       focusRequest: request === void 0 ? void 0 : pageFilePath(cfg.file, request.page),
       // a drag in progress holds auto-follow off: the user is engaged with
       // THIS page, and a missed switch is re-triggered by the next save
-      engaged: dragAnchor !== void 0
+      engaged: view.dragAnchor !== void 0
     });
     pane = scanned.state;
-    for (const known of [...pageViews.keys()]) {
-      if (!files.includes(known)) pageViews.delete(known);
-    }
     adoptView(previous);
     adoptPage();
     if (flash?.confirm === true && pane.pendingDelete === void 0) flash = void 0;
@@ -2644,15 +3066,20 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
       return;
     }
     const file = asked.request.file;
-    const removed = deletePageFile(file);
+    let removed;
+    try {
+      removed = withStoreLock(file, () => deletePageFile(file));
+    } catch (error) {
+      flash = { text: String(error), until: now + FLASH_NOTICE_MS };
+      return;
+    }
     flash = removed.ok ? { text: `deleted ${pageName(file)}`, until: now + FLASH_ACK_MS } : { text: describeStoreError(removed.error), until: now + FLASH_NOTICE_MS };
     tick();
   };
   if (interactive) {
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data", (chunk) => {
+    io.input.resume();
+    io.input.setEncoding("utf8");
+    io.input.on("data", (chunk) => {
       const parsed2 = parseInput(pendingInput + chunk);
       pendingInput = parsed2.rest;
       let dirty = false;
@@ -2662,22 +3089,19 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
             quit();
             return;
           case "reset":
-            offsetX = 0;
-            offsetY = 0;
-            zoom = ZOOM_DEFAULT;
+            view = reduceView(view, { kind: "reset" });
             dirty = true;
             break;
           case "clear":
             if (pane.pendingDelete !== void 0) {
               pane = disarmDelete(pane);
               flash = void 0;
-            } else if (selectedId !== void 0) selectedId = void 0;
+            } else if (view.selectedId !== void 0) view = reduceView(view, { kind: "select", id: void 0 });
             else climbBack();
             dirty = true;
             break;
           case "pan":
-            offsetX += event.dx;
-            offsetY += event.dy;
+            view = reduceView(view, event);
             dirty = true;
             break;
           case "zoom": {
@@ -2686,15 +3110,16 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
               dirty = true;
               break;
             }
-            const next = clampZoom(zoom + event.delta);
-            if (next === zoom || map === void 0) break;
-            const anchorId = hoverId ?? selectedId ?? nearestHit(lastHits, offsetX + viewWidth() / 2, offsetY + viewHeight() / 2)?.id;
+            const next = clampZoom(view.zoom + event.delta);
+            if (next === view.zoom || map === void 0) break;
+            const anchorId = view.hoverId ?? view.selectedId ?? nearestHit(lastHits, view.offsetX + viewWidth() / 2, view.offsetY + viewHeight() / 2)?.id;
             const before = lastHits.find((h) => h.id === anchorId);
-            zoom = next;
+            view = reduceView(view, { kind: "zoom", value: next });
             const measured = renderWindow(
               map,
-              { color: false, unicode: cfg.unicode, spinnerFrame: 0, zoom },
-              { x: 0, y: 0, width: 0, height: 0 }
+              sceneOptions(),
+              { x: 0, y: 0, width: 0, height: 0 },
+              renderScene
             );
             if (!measured.ok) {
               dirty = true;
@@ -2704,57 +3129,48 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
             const after = before === void 0 ? void 0 : sized.hits.find((h) => h.id === before.id);
             const moved = anchorOffsets(
               before !== void 0 && after !== void 0 ? { before, after } : void 0,
-              { x: offsetX, y: offsetY },
+              { x: view.offsetX, y: view.offsetY },
               lastContent,
               { w: sized.contentWidth, h: sized.contentHeight }
             );
-            offsetX = moved.x;
-            offsetY = moved.y;
+            view = reduceView(view, { kind: "position", ...moved });
+            lastHits = sized.hits;
+            lastContent = { w: sized.contentWidth, h: sized.contentHeight };
             dirty = true;
             break;
           }
           case "mouse-move": {
             const over = hitTest(event.x, event.y);
-            if (over !== hoverId) {
-              hoverId = over;
+            if (over !== view.hoverId) {
+              view = reduceView(view, { kind: "hover", id: over });
               dirty = true;
             }
             break;
           }
           case "mouse-down":
-            if (event.y === dividerY()) {
-              dividerDrag = true;
-              break;
-            }
-            dragAnchor = { x: event.x, y: event.y, ox: offsetX, oy: offsetY };
-            press = { moved: false };
+            view = reduceView(view, { kind: "down", x: event.x, y: event.y, divider: event.y === dividerY() });
             break;
           case "mouse-drag":
-            if (dividerDrag) {
-              const next = panelRowsFromDividerY(event.y, process.stdout.rows ?? FALLBACK_ROWS, tabRows());
+            if (view.dividerDrag) {
+              const next = panelRowsFromDividerY(event.y, io.output.rows ?? FALLBACK_ROWS, tabRows());
               if (next !== panelContentRows) {
                 panelContentRows = next;
                 dirty = true;
               }
               break;
             }
-            if (dragAnchor) {
-              const nx = dragAnchor.ox - (event.x - dragAnchor.x);
-              const ny = dragAnchor.oy - (event.y - dragAnchor.y);
-              if (nx !== offsetX || ny !== offsetY) {
-                offsetX = nx;
-                offsetY = ny;
-                if (press) press.moved = true;
-                dirty = true;
-              }
+            {
+              const nextView = reduceView(view, { kind: "drag", x: event.x, y: event.y });
+              dirty ||= nextView !== view;
+              view = nextView;
             }
             break;
           case "mouse-up":
-            if (dividerDrag) {
-              dividerDrag = false;
+            if (view.dividerDrag) {
+              view = reduceView(view, { kind: "up" });
               break;
             }
-            if (press && !press.moved) {
+            if (isPointerClick(view)) {
               const tabHit = tabRows() > 0 && event.y === 1 ? lastTabSegments.find((s) => event.x >= s.lo && event.x <= s.hi) : void 0;
               if (tabHit !== void 0) {
                 if (tabHit.action.kind === "back") {
@@ -2770,7 +3186,9 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
               } else {
                 const id = hitTest(event.x, event.y);
                 const now = Date.now();
-                if (id !== void 0 && lastClick?.id === id && now - lastClick.at <= DOUBLE_CLICK_MS) {
+                const clicked = clickNode(view, id, now, DOUBLE_CLICK_MS);
+                view = clicked.state;
+                if (clicked.diveId !== void 0) {
                   const submap = map?.nodes.find((n) => n.id === id)?.submap;
                   if (submap !== void 0 && pane.activeFile !== void 0) {
                     const target = pageFilePath(cfg.file, submap);
@@ -2782,16 +3200,11 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
                       flash = { text: `submap "${submap}" has no page yet`, until: now + FLASH_ACK_MS };
                     }
                   }
-                  lastClick = void 0;
-                } else {
-                  lastClick = id !== void 0 ? { id, at: now } : void 0;
                 }
-                selectedId = id;
               }
               dirty = true;
             }
-            dragAnchor = void 0;
-            press = void 0;
+            view = reduceView(view, { kind: "up" });
             break;
           case "next-page":
           case "prev-page": {
@@ -2829,9 +3242,13 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
             break;
         }
       }
-      if (dirty) paint2();
+      if (dirty) {
+        const motionOnly = parsed2.events.every((event) => event.kind === "mouse-move" || event.kind === "mouse-drag");
+        if (motionOnly) requestPaint();
+        else paint2();
+      }
     });
-    process.stdout.on("resize", handleResize);
+    io.output.on("resize", handleResize);
   }
   tick();
   setInterval(tick, cfg.intervalMs);
@@ -2845,43 +3262,12 @@ the map pane stopped: ${e instanceof Error ? e.stack ?? e.message : String(e)}
     }, SPLASH_FRAME_MS);
   }
 }
-function launchedAsEntry(argv1, moduleUrl) {
-  if (argv1 === void 0) return false;
-  try {
-    return realpathSync(argv1) === realpathSync(fileURLToPath(moduleUrl));
-  } catch {
-    return pathToFileURL(argv1).href === moduleUrl;
-  }
-}
-if (launchedAsEntry(process.argv[1], import.meta.url)) {
-  main();
-}
-export {
-  PANEL_ROWS_MIN,
-  USAGE,
-  anchorOffsets,
-  clampPanelRows,
-  describeArgsError,
-  describePageFault,
-  diveOrigin,
-  dividerRow,
-  elapsedLabel,
-  fitWidth,
-  launchedAsEntry,
-  mapPanel,
-  nearestHit,
-  nodePanel,
-  pageTabRow,
-  panelRowsFromDividerY,
-  parseArgs,
-  readPage,
-  renderWindow,
-  splashFrame,
-  tabScrollFor,
-  terminalRestoreSequence,
-  topLevelFiles,
-  usableColumns,
-  viewerReportOf,
-  waitingInfo,
-  wrapWidth
-};
+
+// src/watch/cli.ts
+var parsed = parseArgs(process.argv.slice(2), process.cwd());
+if (!parsed.ok) {
+  console.error(`mellos-mapping-watch: ${describeArgsError(parsed.error)}
+${USAGE}`);
+  process.exit(1);
+}
+runWatcher(parsed.value);