@patterkit/cli 0.2.6 → 0.3.0

package/dist/cli.js

@@ -192615,6 +192615,7 @@ function readDirSafe(dir2) {
 function walkFiles(dir2, ext) {
   const out = [];
   for (const e of readDirSafe(dir2)) {
+    if (e.name.startsWith(".")) continue;
     const p = join(dir2, e.name);
     if (e.isDirectory()) out.push(...walkFiles(p, ext));
     else if (e.isFile() && e.name.endsWith(ext)) out.push(p);
@@ -192748,6 +192749,347 @@ import { dirname as dirname2 } from "path";
 // ../ops/src/validate.ts
 import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 
+// ../ops/src/merge.ts
+var UnsupportedMergeError = class extends Error {
+};
+var eq = (a, b) => canonicalStringify(a) === canonicalStringify(b);
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var CONFLICT_SIDECAR = ".patterconflict";
+function sidecarIssues(sidecarPaths) {
+  return sidecarPaths.map((file) => ({
+    file,
+    message: "unresolved merge conflict - resolve it and delete the .patterconflict sidecar before committing"
+  }));
+}
+function detectMergeType(file) {
+  const s = typeof file.schema === "string" ? file.schema : "";
+  if (s.startsWith("patter/flow")) return "flow";
+  if (s.startsWith("patter/strings")) return "loc";
+  if (s.startsWith("patter/authoring")) return "authoring";
+  if (s.startsWith("patter/project")) return "project";
+  throw new UnsupportedMergeError(`cannot detect a Patter merge type from schema '${s}'`);
+}
+function runMerge(base, ours, theirs, opts) {
+  const type = opts?.type ?? detectMergeType(ours);
+  switch (type) {
+    case "loc":
+      return mergeLoc(base, ours, theirs);
+    case "authoring":
+      return mergeAuthoring(base, ours, theirs);
+    case "flow":
+      return mergeFlow(base, ours, theirs);
+    case "project":
+      return mergeProject(base, ours, theirs);
+  }
+}
+function deletedKind(base, ours, theirs) {
+  const deleted = base !== void 0 && (ours === void 0 || theirs === void 0);
+  return deleted ? "delete-vs-edit" : "both-changed";
+}
+function merge3(base, ours, theirs, id, path, conflicts) {
+  if (eq(ours, theirs)) return ours;
+  if (eq(base, ours)) return theirs;
+  if (eq(base, theirs)) return ours;
+  conflicts.push({ id, path, base, ours, theirs, kind: deletedKind(base, ours, theirs) });
+  return ours;
+}
+function mergeMap(base, ours, theirs, prefix, conflicts, resolve6) {
+  const out = {};
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
+    const b = base[k], o = ours[k], t = theirs[k];
+    let v;
+    if (eq(o, t)) v = o;
+    else if (eq(b, o)) v = t;
+    else if (eq(b, t)) v = o;
+    else {
+      const r = resolve6?.(k, b, o, t);
+      if (r && r.resolved) v = r.value;
+      else {
+        conflicts.push({ id: k, path: `${prefix}.${k}`, base: b, ours: o, theirs: t, kind: r ? r.kind : deletedKind(b, o, t) });
+        v = o;
+      }
+    }
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+var asMap = (v) => isObj(v) ? v : {};
+var asArr = (v) => Array.isArray(v) ? v : [];
+function setIf(obj2, key2, val) {
+  if (Array.isArray(val) ? val.length > 0 : Object.keys(val).length > 0) obj2[key2] = val;
+}
+function mergeLoc(base, ours, theirs) {
+  const conflicts = [];
+  const merged = {};
+  for (const f of ["schema", "scene", "locale", "default"]) {
+    const v = merge3(base[f], ours[f], theirs[f], "", f, conflicts);
+    if (v !== void 0) merged[f] = v;
+  }
+  merged.strings = mergeMap(asMap(base.strings), asMap(ours.strings), asMap(theirs.strings), "strings", conflicts);
+  return { type: "loc", merged, conflicts, warnings: [] };
+}
+function mergeAuthoring(base, ours, theirs) {
+  const conflicts = [];
+  const merged = {};
+  merged.schema = merge3(base.schema, ours.schema, theirs.schema, "", "schema", conflicts) ?? ours.schema;
+  setIf(merged, "comments", mergeComments(asArr(base.comments), asArr(ours.comments), asArr(theirs.comments)));
+  const edits = mergeEdits(asMap(base.edits), asMap(ours.edits), asMap(theirs.edits));
+  setIf(merged, "edits", edits);
+  const lww = lastWriterWins(asMap(ours.edits), asMap(theirs.edits));
+  for (const f of ["writing", "recording", "audio"]) {
+    setIf(merged, f, mergeMap(asMap(base[f]), asMap(ours[f]), asMap(theirs[f]), f, conflicts, lww));
+  }
+  setIf(merged, "documentation", mergeMap(asMap(base.documentation), asMap(ours.documentation), asMap(theirs.documentation), "documentation", conflicts));
+  setIf(merged, "cut", mergeMap(asMap(base.cut), asMap(ours.cut), asMap(theirs.cut), "cut", conflicts, void 0));
+  setIf(merged, "suggestions", mergeById(asArr(base.suggestions), asArr(ours.suggestions), asArr(theirs.suggestions), "suggestions", conflicts));
+  setIf(merged, "rerecord", mergeMap(asMap(base.rerecord), asMap(ours.rerecord), asMap(theirs.rerecord), "rerecord", conflicts, void 0));
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
+    if (k in merged || AUTHORING_HANDLED.has(k)) continue;
+    const v = merge3(base[k], ours[k], theirs[k], "", k, conflicts);
+    if (v !== void 0) merged[k] = v;
+  }
+  return { type: "authoring", merged, conflicts, warnings: [] };
+}
+var AUTHORING_HANDLED = /* @__PURE__ */ new Set(["schema", "comments", "edits", "writing", "recording", "audio", "documentation", "cut", "suggestions", "rerecord"]);
+function mergeById(base, ours, theirs, path, conflicts) {
+  const index2 = (arr) => {
+    const m = {};
+    for (const r of arr) if (isObj(r) && typeof r.id === "string") m[r.id] = r;
+    return m;
+  };
+  const merged = mergeMap(index2(base), index2(ours), index2(theirs), path, conflicts);
+  return Object.values(merged).sort((a, b) => String(asMap(a).ts ?? "").localeCompare(String(asMap(b).ts ?? "")));
+}
+function mergeComments(base, ours, theirs) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const c2 of [...base, ...ours, ...theirs]) {
+    if (isObj(c2) && typeof c2.id === "string" && !byId.has(c2.id)) byId.set(c2.id, c2);
+  }
+  return [...byId.values()].sort((a, b) => String(a.ts ?? "").localeCompare(String(b.ts ?? "")));
+}
+function lastWriterWins(oursEdits, theirsEdits) {
+  return (id, _b, o, t) => {
+    const om = asMap(oursEdits[id]).modifiedAt, tm = asMap(theirsEdits[id]).modifiedAt;
+    if (typeof om === "string" && typeof tm === "string") return { resolved: true, value: om >= tm ? o : t };
+    return { resolved: false, kind: "no-timestamp" };
+  };
+}
+function mergeEdits(base, ours, theirs) {
+  const out = {};
+  for (const id of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
+    const o = ours[id], t = theirs[id];
+    if (eq(o, t)) {
+      if (o !== void 0) out[id] = o;
+      continue;
+    }
+    if (o === void 0) {
+      if (t !== void 0) out[id] = t;
+      continue;
+    }
+    if (t === void 0) {
+      out[id] = o;
+      continue;
+    }
+    out[id] = mergeEditRecord(asMap(o), asMap(t));
+  }
+  return out;
+}
+function mergeEditRecord(o, t) {
+  const om = typeof o.modifiedAt === "string" ? o.modifiedAt : "";
+  const tm = typeof t.modifiedAt === "string" ? t.modifiedAt : "";
+  const newer = om >= tm ? o : t;
+  const ol = asMap(o.localisedAt), tl = asMap(t.localisedAt);
+  const loc = {};
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(ol), ...Object.keys(tl)])) {
+    const a = typeof ol[k] === "string" ? ol[k] : "";
+    const b = typeof tl[k] === "string" ? tl[k] : "";
+    loc[k] = a >= b ? ol[k] ?? tl[k] : tl[k] ?? ol[k];
+  }
+  const merged = { ...newer };
+  if (Object.keys(loc).length > 0) merged.localisedAt = loc;
+  return merged;
+}
+function mergeKeyedByName(base, ours, theirs, path, conflicts) {
+  const byName = (arr) => {
+    const m = {};
+    for (const p of arr) if (isObj(p) && typeof p.name === "string") m[p.name] = p;
+    return m;
+  };
+  const merged = mergeMap(byName(base), byName(ours), byName(theirs), path, conflicts);
+  return Object.keys(merged).sort().map((name) => merged[name]);
+}
+function mergeProject(base, ours, theirs) {
+  const conflicts = [];
+  const merged = {};
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
+    if (k === "properties" || k === "cast") {
+      const v = mergeKeyedByName(asArr(base[k]), asArr(ours[k]), asArr(theirs[k]), k, conflicts);
+      if (v.length > 0) merged[k] = v;
+    } else if (k === "gameDataFields") {
+      const v = mergeGameDataFields(asMap(base[k]), asMap(ours[k]), asMap(theirs[k]), conflicts);
+      if (Object.keys(v).length > 0) merged[k] = v;
+    } else if (k === "locales") {
+      merged.locales = mergeLocales(asMap(base.locales), asMap(ours.locales), asMap(theirs.locales), conflicts);
+    } else {
+      const v = merge3(base[k], ours[k], theirs[k], "", k, conflicts);
+      if (v !== void 0) merged[k] = v;
+    }
+  }
+  return { type: "project", merged, conflicts, warnings: [] };
+}
+function mergeGameDataFields(b, o, t, conflicts) {
+  const out = {};
+  for (const kind of /* @__PURE__ */ new Set([...Object.keys(b), ...Object.keys(o), ...Object.keys(t)])) {
+    const v = mergeKeyedByName(asArr(b[kind]), asArr(o[kind]), asArr(t[kind]), `gameDataFields.${kind}`, conflicts);
+    if (v.length > 0) out[kind] = v;
+  }
+  return out;
+}
+function mergeLocales(b, o, t, conflicts) {
+  const out = {};
+  const def = merge3(b.default, o.default, t.default, "", "locales.default", conflicts);
+  if (def !== void 0) out.default = def;
+  const all = [];
+  for (const arr of [asArr(b.all), asArr(o.all), asArr(t.all)]) {
+    for (const x of arr) if (typeof x === "string" && !all.includes(x)) all.push(x);
+  }
+  out.all = all;
+  return out;
+}
+var CHILD_KEYS = ["blocks", "children", "beats"];
+function toTree(raw) {
+  const childKey = CHILD_KEYS.find((k) => Array.isArray(raw[k]));
+  const fields = {};
+  for (const [k, v] of Object.entries(raw)) if (k !== childKey) fields[k] = v;
+  const children = childKey ? raw[childKey].filter(isObj).map(toTree) : [];
+  return { id: typeof raw.id === "string" ? raw.id : "", fields, childKey, children };
+}
+function fromTree(n) {
+  const out = { ...n.fields };
+  if (n.childKey) out[n.childKey] = n.children.map(fromTree);
+  return out;
+}
+function mergeFlow(base, ours, theirs) {
+  const conflicts = [];
+  const warnings = [];
+  const merged = {};
+  merged.schema = merge3(base.schema, ours.schema, theirs.schema, "", "schema", conflicts) ?? ours.schema;
+  const bScene = isObj(base.scene) ? toTree(base.scene) : void 0;
+  const oScene = toTree(asMap(ours.scene));
+  const tScene = isObj(theirs.scene) ? toTree(theirs.scene) : void 0;
+  const mergedScene = mergeNode(bScene, oScene, tScene, "scene", conflicts, warnings);
+  merged.scene = fromTree(mergedScene);
+  checkDuplicateIds(mergedScene, conflicts);
+  return { type: "flow", merged, conflicts, warnings };
+}
+function mergeNode(b, o, t, path, conflicts, warnings) {
+  const fields = mergeFields(b?.fields ?? {}, o.fields, t?.fields ?? {}, o.id, path, conflicts);
+  const childKey = o.childKey ?? t?.childKey ?? b?.childKey;
+  const children = childKey ? mergeChildren(b?.children ?? [], o.children, t?.children ?? [], `${path}.${childKey}`, conflicts, warnings) : [];
+  return { id: o.id, fields, childKey, children };
+}
+function mergeFields(b, o, t, id, path, conflicts) {
+  const out = {};
+  for (const k of /* @__PURE__ */ new Set([...Object.keys(b), ...Object.keys(o), ...Object.keys(t)])) {
+    const v = merge3(b[k], o[k], t[k], id, `${path}.${k}`, conflicts);
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function mergeChildren(B, O, T, path, conflicts, warnings) {
+  const Bm = idMap(B), Om = idMap(O), Tm = idMap(T);
+  const Bset = new Set(Bm.keys()), Oset = new Set(Om.keys()), Tset = new Set(Tm.keys());
+  const merged = /* @__PURE__ */ new Map();
+  const here = (id) => `${path}[${id}]`;
+  for (const id of /* @__PURE__ */ new Set([...Bm.keys(), ...Om.keys(), ...Tm.keys()])) {
+    const b = Bm.get(id), o = Om.get(id), t = Tm.get(id);
+    const inB = Bset.has(id), inO = Oset.has(id), inT = Tset.has(id);
+    if (inO && inT) {
+      if (!inB && !eq(fromTree(o), fromTree(t))) {
+        conflicts.push({ id, path: here(id), base: void 0, ours: fromTree(o), theirs: fromTree(t), kind: "added-both" });
+        merged.set(id, o);
+      } else {
+        merged.set(id, mergeNode(b, o, t, here(id), conflicts, warnings));
+      }
+    } else if (inO && !inT) {
+      if (inB && !eq(fromTree(o), fromTree(b))) {
+        conflicts.push({ id, path: here(id), base: fromTree(b), ours: fromTree(o), theirs: void 0, kind: "delete-vs-edit" });
+        merged.set(id, o);
+      } else if (!inB) {
+        merged.set(id, o);
+      }
+    } else if (!inO && inT) {
+      if (inB && !eq(fromTree(t), fromTree(b))) {
+        conflicts.push({ id, path: here(id), base: fromTree(b), ours: void 0, theirs: fromTree(t), kind: "delete-vs-edit" });
+      } else if (!inB) {
+        merged.set(id, t);
+      }
+    }
+  }
+  return orderChildren(merged, B, O, T, path, conflicts, warnings);
+}
+function orderChildren(merged, B, O, T, path, conflicts, warnings) {
+  const Bids = B.map((n) => n.id), Oids = O.map((n) => n.id), Tids = T.map((n) => n.id);
+  const Oidset = new Set(Oids);
+  const common = new Set(Bids.filter((id) => merged.has(id)));
+  const restrict = (ids) => ids.filter((id) => common.has(id));
+  const relB = restrict(Bids), relO = restrict(Oids), relT = restrict(Tids);
+  const fullO = relO.length === common.size, fullT = relT.length === common.size;
+  let commonOrder;
+  if (!fullO && !fullT) commonOrder = relB;
+  else if (!fullO) commonOrder = relT;
+  else if (!fullT) commonOrder = relO;
+  else if (arrEq(relO, relB)) commonOrder = relT;
+  else if (arrEq(relT, relB)) commonOrder = relO;
+  else if (arrEq(relO, relT)) commonOrder = relO;
+  else {
+    conflicts.push({ id: "", path, base: relB, ours: relO, theirs: relT, kind: "moved" });
+    commonOrder = relO;
+  }
+  const anchorIn = (ids, id) => {
+    for (let i = ids.indexOf(id) - 1; i >= 0; i--) if (common.has(ids[i])) return ids[i];
+    return null;
+  };
+  const byAnchor = /* @__PURE__ */ new Map();
+  const group = (a) => {
+    let g = byAnchor.get(a);
+    if (!g) {
+      g = { ours: [], theirs: [] };
+      byAnchor.set(a, g);
+    }
+    return g;
+  };
+  for (const n of O) if (merged.has(n.id) && !common.has(n.id)) group(anchorIn(Oids, n.id)).ours.push(n.id);
+  for (const n of T) if (merged.has(n.id) && !common.has(n.id) && !Oidset.has(n.id)) group(anchorIn(Tids, n.id)).theirs.push(n.id);
+  const out = [];
+  const emit = (anchor) => {
+    const g = byAnchor.get(anchor);
+    if (!g) return;
+    if (g.ours.length > 0 && g.theirs.length > 0) warnings.push({ id: anchor ?? "", path, message: "both sides inserted here; kept ours-then-theirs - review the order" });
+    out.push(...g.ours, ...g.theirs);
+  };
+  emit(null);
+  for (const id of commonOrder) {
+    out.push(id);
+    emit(id);
+  }
+  return out.map((id) => merged.get(id));
+}
+function checkDuplicateIds(root2, conflicts) {
+  const seen = /* @__PURE__ */ new Set(), dup = /* @__PURE__ */ new Set();
+  const walk2 = (n) => {
+    if (n.id) {
+      if (seen.has(n.id)) dup.add(n.id);
+      else seen.add(n.id);
+    }
+    n.children.forEach(walk2);
+  };
+  walk2(root2);
+  for (const id of dup) conflicts.push({ id, path: "scene", base: void 0, ours: void 0, theirs: void 0, kind: "structural" });
+}
+var idMap = (nodes) => new Map(nodes.filter((n) => n.id).map((n) => [n.id, n]));
+var arrEq = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+
 // ../../../expr/packages/expr/src/parser.ts
 var ParseError = class extends Error {
   constructor(message, pos2, source2) {
@@ -194286,6 +194628,201 @@ function exportBundle(input) {
   };
 }
 
+// ../ops/src/reachability.ts
+var normaliseRef = (ref) => ref.includes(".") ? ref : `@patter.${ref.slice(1)}`;
+var SEP = "\0";
+var keyOf = (ref, sceneId) => ref.startsWith("@scene.") ? `${sceneId}${SEP}${ref}` : ref;
+var shown = (key2) => {
+  const bare = key2.includes(SEP) ? key2.slice(key2.indexOf(SEP) + 1) : key2;
+  const at = bare.indexOf(":");
+  return at < 0 ? bare : `${bare.slice(0, at)} +${bare.slice(at + 1)}`;
+};
+var svRef = (ast) => Array.isArray(ast) && ast[0] === "sv" ? `@${String(ast[1])}.${String(ast[2])}` : void 0;
+function latchOf(ast, sceneId) {
+  const direct = svRef(ast);
+  if (direct !== void 0) return keyOf(direct, sceneId);
+  if (!Array.isArray(ast)) return void 0;
+  if (ast[0] === "bin" && ast[1] === "==") {
+    const [, , l2, r] = ast;
+    for (const [a, b] of [[l2, r], [r, l2]]) {
+      const ref = svRef(a);
+      if (ref !== void 0 && Array.isArray(b) && b[0] === "b" && b[1] === true) return keyOf(ref, sceneId);
+    }
+    return void 0;
+  }
+  if (ast[0] === "call" && ast[1] === "check_flags") {
+    const ref = svRef(ast[2]);
+    const args = ast.slice(3);
+    if (ref === void 0 || args.length !== 1) return void 0;
+    const arg = args[0];
+    if (Array.isArray(arg) && arg[0] === "fd" && arg[1] === "+") return `${keyOf(ref, sceneId)}:${String(arg[2])}`;
+  }
+  return void 0;
+}
+function disjuncts(ast) {
+  if (Array.isArray(ast) && ast[0] === "bin" && ast[1] === "or") {
+    const [, , l2, r] = ast;
+    return [...disjuncts(l2), ...disjuncts(r)];
+  }
+  return [ast];
+}
+function terms(ast, sceneId, negated = false, into = []) {
+  const latch = latchOf(ast, sceneId);
+  if (latch !== void 0) {
+    into.push({ key: latch, negated });
+    return into;
+  }
+  if (!Array.isArray(ast)) return into;
+  if (ast[0] === "u" && ast[1] === "not") return terms(ast[2], sceneId, !negated, into);
+  if (ast[0] === "bin" && ast[1] === "and" && !negated) {
+    terms(ast[2], sceneId, false, into);
+    terms(ast[3], sceneId, false, into);
+  }
+  return into;
+}
+var requirementsOf = (expr, sceneId) => expr === void 0 ? [] : terms(expr.ast, sceneId);
+var asFlags = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+function reachabilityIssues(loaded, compiled) {
+  const bundle = compiled ?? exportBundle({ project: loaded.project, scenes: loaded.scenes, locales: loaded.locales });
+  const hostTokens = new Set((loaded.project.scopeRegistry?.scopes ?? []).map((s) => s.token));
+  const preset = /* @__PURE__ */ new Set();
+  const notALatch = (decl, key2) => {
+    if (decl.temporary) {
+      preset.add(key2);
+      for (const v of decl.values ?? []) preset.add(`${key2}:${v}`);
+      return;
+    }
+    if (decl.type === "boolean" && decl.default === true) preset.add(key2);
+    if (decl.type === "flags") for (const v of asFlags(decl.default)) preset.add(`${key2}:${v}`);
+  };
+  for (const decl of loaded.project.properties ?? []) notALatch(decl, `@patter.${decl.name}`);
+  for (const scene of loaded.scenes) {
+    for (const decl of scene.sceneProps ?? []) notALatch(decl, `${scene.id}${SEP}@scene.${decl.name}`);
+  }
+  const latched = /* @__PURE__ */ new Set();
+  const broken = /* @__PURE__ */ new Set();
+  const writers = /* @__PURE__ */ new Map();
+  const noteWrite = (key2, requires) => {
+    latched.add(key2);
+    (writers.get(key2) ?? writers.set(key2, []).get(key2)).push({ requires });
+  };
+  const breakKey = (key2) => {
+    broken.add(key2);
+    for (const k of latched) if (k.startsWith(`${key2}:`)) broken.add(k);
+  };
+  const scanEffects = (effects, sceneId, need) => {
+    for (const e of effects ?? []) {
+      const ref = normaliseRef(e.target);
+      const key2 = keyOf(ref, sceneId);
+      const ast = e.value.ast;
+      if (Array.isArray(ast) && ast[0] === "b" && ast[1] === true) {
+        noteWrite(key2, need);
+        continue;
+      }
+      if (Array.isArray(ast) && ast[0] === "call" && ast[1] === "set_flags" && svRef(ast[2]) === ref) {
+        let clean3 = true;
+        for (const arg of ast.slice(3)) {
+          if (Array.isArray(arg) && arg[0] === "fd" && arg[1] === "+") noteWrite(`${key2}:${String(arg[2])}`, need);
+          else clean3 = false;
+        }
+        if (clean3) continue;
+      }
+      breakKey(key2);
+    }
+  };
+  const walk2 = (nodes, sceneId, gate) => {
+    for (const node of nodes) {
+      const here = [...gate, ...requirementsOf(node.condition, sceneId)];
+      if (node.type === "group") walk2(node.children, sceneId, here);
+      else {
+        scanEffects(node.onEnter, sceneId, here);
+        scanEffects(node.onExit, sceneId, here);
+      }
+    }
+  };
+  for (const scene of Object.values(bundle.scenes)) {
+    scanEffects(scene.onEntry, scene.id, []);
+    for (const block of scene.blocks) walk2(block.children, scene.id, []);
+  }
+  for (const key2 of [...latched]) {
+    const at = key2.indexOf(":");
+    if (at > 0 && broken.has(key2.slice(0, at))) broken.add(key2);
+  }
+  const hostDriven = (key2) => hostTokens.has(key2.slice(1, key2.indexOf(".")));
+  const monotonic = (key2) => latched.has(key2) && !broken.has(key2) && !preset.has(key2) && !hostDriven(key2);
+  const cache2 = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Set();
+  const mustHold = (key2) => {
+    const done = cache2.get(key2);
+    if (done !== void 0) return { need: done, cut: false };
+    if (inFlight.has(key2)) return { need: /* @__PURE__ */ new Set(), cut: true };
+    const routes = writers.get(key2);
+    if (routes === void 0 || routes.length === 0) return { need: /* @__PURE__ */ new Set(), cut: false };
+    inFlight.add(key2);
+    let shared;
+    let cut = false;
+    for (const route of routes) {
+      const need = /* @__PURE__ */ new Set();
+      for (const t of route.requires) {
+        if (t.negated || !monotonic(t.key)) continue;
+        need.add(t.key);
+        const deeper = mustHold(t.key);
+        cut ||= deeper.cut;
+        for (const k of deeper.need) need.add(k);
+      }
+      shared = shared === void 0 ? need : new Set([...shared].filter((k) => need.has(k)));
+    }
+    inFlight.delete(key2);
+    const result = shared ?? /* @__PURE__ */ new Set();
+    if (!cut) cache2.set(key2, result);
+    return { need: result, cut };
+  };
+  const refute = (gate) => {
+    for (const no of gate.filter((t) => t.negated)) {
+      if (!monotonic(no.key)) continue;
+      if (gate.some((t) => !t.negated && t.key === no.key)) {
+        return `it asks for ${shown(no.key)} to be both set and not set`;
+      }
+      for (const yes of gate.filter((t) => !t.negated && t.key !== no.key)) {
+        if (!monotonic(yes.key)) continue;
+        const chain = mustHold(yes.key);
+        if (!chain.cut && chain.need.has(no.key)) {
+          return `${shown(yes.key)} can only become true after ${shown(no.key)}, which nothing sets back, so this condition can never hold`;
+        }
+      }
+    }
+    return void 0;
+  };
+  const issues = [];
+  const report = (nodes, sceneId, gate) => {
+    for (const node of nodes) {
+      const own = node.condition;
+      const branches = own ? disjuncts(own.ast) : [void 0];
+      let reason;
+      const refuted = branches.every((b) => {
+        const r = refute([...gate, ...b ? terms(b, sceneId) : []]);
+        reason ??= r;
+        return r !== void 0;
+      });
+      if (refuted && reason !== void 0 && own) {
+        issues.push({
+          nodeId: node.id,
+          field: "condition",
+          src: own.src,
+          severity: "warning",
+          message: `this can never run: ${reason}`
+        });
+        continue;
+      }
+      if (node.type === "group") report(node.children, sceneId, [...gate, ...requirementsOf(own, sceneId)]);
+    }
+  };
+  for (const scene of Object.values(bundle.scenes)) {
+    for (const block of scene.blocks) report(block.children, scene.id, []);
+  }
+  return issues;
+}
+
 // ../ops/src/validate.ts
 function runValidate(loaded) {
   const { project, scenes, locales } = loaded;
@@ -194295,19 +194832,42 @@ function runValidate(loaded) {
   const interpolation = validateInterpolation({ project, scenes, locales }, { foreignScopes });
   const hygiene = checkHygiene([loaded.projectFile, ...Object.values(loaded.sceneFiles), ...loaded.localeFiles, ...loaded.authoringFiles]);
   const staleBundles = checkBundles(loaded);
-  const unresolvedMerges = walkFiles(loaded.root, ".patterconflict").map((file) => ({
-    file,
-    message: "unresolved merge conflict - resolve it and delete the .patterconflict sidecar before committing"
-  }));
+  const unresolvedMerges = sidecarIssues(walkFiles(loaded.root, CONFLICT_SIDECAR));
+  const orphans = orphanShards(loaded);
+  const reachability = structural.length === 0 && conditions.length === 0 ? reachabilityIssues(loaded) : [];
   return {
     structural,
     conditions,
     interpolation,
+    reachability,
     hygiene,
     staleBundles,
     unresolvedMerges,
-    ok: structural.length === 0 && conditions.length === 0 && interpolation.length === 0 && hygiene.length === 0 && staleBundles.length === 0 && unresolvedMerges.length === 0
+    orphans,
+    ok: structural.length === 0 && conditions.length === 0 && interpolation.length === 0 && hygiene.length === 0 && staleBundles.length === 0 && unresolvedMerges.length === 0 && orphans.length === 0
+  };
+}
+function orphanShards(loaded) {
+  const collected = /* @__PURE__ */ new Set([
+    loaded.projectFile,
+    ...Object.values(loaded.sceneFiles),
+    ...loaded.localeFiles,
+    ...loaded.authoringFiles
+  ]);
+  const kind = {
+    ".patterflow": "scene",
+    ".patterloc": "locale",
+    ".patterx": "authoring",
+    ".patterproj": "project"
   };
+  const out = [];
+  for (const [ext, what] of Object.entries(kind)) {
+    for (const file of walkFiles(loaded.root, ext)) {
+      if (collected.has(file)) continue;
+      out.push({ file, message: `a ${what} shard outside the project's layout - nothing loads it, so its content is not in the project (move it under the configured folder, or delete it)` });
+    }
+  }
+  return out;
 }
 function checkBundles(loaded) {
   const issues = [];
@@ -194388,7 +194948,16 @@ function compileScenes(loaded) {
     blocks: s.blocks.map((b) => ({ ...b, children: b.children.map(clean3) }))
   }));
 }
+function refuseUnresolvedMerge(loaded) {
+  const issues = sidecarIssues(walkFiles(loaded.root, CONFLICT_SIDECAR));
+  if (!issues.length) return;
+  throw new Error(
+    `${issues.length} unresolved merge conflict(s) - resolve them and delete the .patterconflict sidecar(s) first:
+` + issues.map((i) => `  ${i.file}`).join("\n")
+  );
+}
 function runExport(loaded) {
+  refuseUnresolvedMerge(loaded);
   const { project, locales } = loaded;
   const full = exportBundle({ project, scenes: compileScenes(loaded), locales });
   const loc = project.export?.localisation;
@@ -194397,6 +194966,7 @@ function runExport(loaded) {
   return { ...full, strings, localisation: { mode: "ids", ...loc.sourceDebug ? { sourceDebug: true } : {} } };
 }
 function runExportFull(loaded) {
+  refuseUnresolvedMerge(loaded);
   const { project, locales } = loaded;
   return exportBundle({ project, scenes: compileScenes(loaded), locales });
 }
@@ -196456,7 +197026,7 @@ function stringsByLocale(loaded) {
   }
   return byLocale;
 }
-function mergeAuthoring(loaded) {
+function mergeAuthoring2(loaded) {
   const writing = /* @__PURE__ */ new Map();
   const recording = /* @__PURE__ */ new Map();
   const cut = /* @__PURE__ */ new Set();
@@ -196586,40 +197156,113 @@ function targetHostRef(target, hostTokens) {
   const m = /^@([A-Za-z_][\w]*)\.(.+)$/.exec(target);
   return m && hostTokens.has(m[1]) ? `@${m[1]}.${m[2]}` : void 0;
 }
+function flagKeys(node, hostTokens, fn) {
+  if (node.kind !== "call" || node.name !== fn) return [];
+  const subject = node.args[0];
+  if (!subject || subject.kind !== "scopedvar" || !hostTokens.has(subject.scope)) return [];
+  const ref = `@${subject.scope}.${subject.name}`;
+  return node.args.slice(1).filter((a) => a.kind === "flagdelta").map((a) => `${ref}:${a.name}`);
+}
+function fineRefsIn(node, hostTokens, out) {
+  for (const k of flagKeys(node, hostTokens, "check_flags")) out.add(k);
+  switch (node.kind) {
+    case "unary":
+      fineRefsIn(node.operand, hostTokens, out);
+      break;
+    case "binary":
+      fineRefsIn(node.left, hostTokens, out);
+      fineRefsIn(node.right, hostTokens, out);
+      break;
+    case "call":
+      for (const a of node.args) fineRefsIn(a, hostTokens, out);
+      break;
+    default:
+      break;
+  }
+}
 function analyzeHostScopes(bundle, hostTokens) {
   const written = /* @__PURE__ */ new Set();
   const gatesByBeat = /* @__PURE__ */ new Map();
+  const fineGatesByBeat = /* @__PURE__ */ new Map();
   const proposals = /* @__PURE__ */ new Map();
-  if (hostTokens.size === 0) return { written, gatesByBeat, proposals };
+  const writerSites = /* @__PURE__ */ new Map();
+  const opaqueWrites = /* @__PURE__ */ new Set();
+  const empty = { written, gatesByBeat, proposals, fineGatesByBeat, writerSites, opaqueWrites };
+  if (hostTokens.size === 0) return empty;
   const refsIn = (expr) => {
     const refs = /* @__PURE__ */ new Set();
     if (expr) scanExpr(deserialiseAst(expr.ast), hostTokens, refs, proposals);
     return refs;
   };
-  const scanEffects = (effects) => {
+  const fineIn = (expr) => {
+    const refs = /* @__PURE__ */ new Set();
+    if (expr) fineRefsIn(deserialiseAst(expr.ast), hostTokens, refs);
+    return refs;
+  };
+  const addSite = (key2, witnesses) => {
+    (writerSites.get(key2) ?? writerSites.set(key2, []).get(key2)).push(witnesses);
+  };
+  const scanEffects = (effects, witnesses) => {
     for (const e of effects ?? []) {
-      const t = targetHostRef(e.target, hostTokens);
-      if (t) written.add(t);
+      const target = targetHostRef(e.target, hostTokens);
+      if (target) {
+        written.add(target);
+        addSite(target, witnesses);
+        const flags = e.value ? flagKeys(deserialiseAst(e.value.ast), hostTokens, "set_flags") : [];
+        if (flags.length) for (const k of flags) addSite(k, witnesses);
+        else opaqueWrites.add(target);
+      }
       refsIn(e.value);
     }
   };
-  const walk2 = (nodes, gate) => {
+  const walk2 = (nodes, gate, fine) => {
     for (const node of nodes) {
       const here = /* @__PURE__ */ new Set([...gate, ...refsIn(node.condition)]);
+      const hereFine = /* @__PURE__ */ new Set([...fine, ...fineIn(node.condition)]);
       if (node.type === "group") {
-        walk2(node.children, here);
+        walk2(node.children, here, hereFine);
       } else {
-        scanEffects(node.onEnter);
-        scanEffects(node.onExit);
-        for (const beat of node.beats ?? []) gatesByBeat.set(beat.id, here);
+        const witnesses = (node.beats ?? []).map((b) => b.id);
+        scanEffects(node.onEnter, witnesses);
+        scanEffects(node.onExit, witnesses);
+        for (const beat of node.beats ?? []) {
+          gatesByBeat.set(beat.id, here);
+          fineGatesByBeat.set(beat.id, hereFine);
+        }
       }
     }
   };
   for (const scene of Object.values(bundle.scenes)) {
-    scanEffects(scene.onEntry);
-    for (const block of scene.blocks) walk2(block.children, /* @__PURE__ */ new Set());
+    const sceneBeats = [];
+    const collect = (nodes) => {
+      for (const n of nodes) {
+        if (n.type === "group") collect(n.children);
+        else for (const b of n.beats ?? []) sceneBeats.push(b.id);
+      }
+    };
+    for (const block of scene.blocks) collect(block.children);
+    scanEffects(scene.onEntry, sceneBeats);
+    for (const block of scene.blocks) walk2(block.children, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
   }
-  return { written, gatesByBeat, proposals };
+  return empty;
+}
+function blockedGates(beatId, analysis, drivenRefs, reachedRuns) {
+  const out = [];
+  const gates = /* @__PURE__ */ new Set([...analysis.gatesByBeat.get(beatId) ?? [], ...analysis.fineGatesByBeat.get(beatId) ?? []]);
+  for (const ref of [...gates].sort()) {
+    const coarse = ref.includes(":") ? ref.slice(0, ref.indexOf(":")) : ref;
+    if (drivenRefs.has(coarse)) continue;
+    if (!analysis.written.has(coarse)) continue;
+    if (ref !== coarse && analysis.opaqueWrites.has(coarse)) continue;
+    if (ref === coarse && [...gates].some((g) => g !== ref && g.startsWith(`${ref}:`))) continue;
+    const sites = analysis.writerSites.get(ref) ?? [];
+    if (!sites.length) continue;
+    if (sites.some((s) => !s.length || s.some((w) => !reachedRuns.has(w)))) continue;
+    if (!sites.every((s) => s.every((w) => reachedRuns.get(w) === 0))) continue;
+    const writers = [...new Set(sites.flat())].sort();
+    out.push({ ref, writers });
+  }
+  return out;
 }
 function proposeCoverageDrivers(loaded) {
   const hostTokens = new Set((loaded.project.scopeRegistry?.scopes ?? []).map((s) => s.token));
@@ -196752,12 +197395,15 @@ function* sweep(loaded, options = {}, hooks = {}) {
     const m = meta.get(id);
     const reached = reachedRuns.get(id);
     let needsInput;
+    let blockedBy;
     if (reached === 0) {
       const gates = [...analysis.gatesByBeat.get(id) ?? []].filter((r) => !analysis.written.has(r) && !drivenRefs.has(r));
       if (gates.length) {
         needsInput = gates;
         for (const g of gates) unwrittenInputs.add(g);
       }
+      const blocked = blockedGates(id, analysis, drivenRefs, reachedRuns);
+      if (blocked.length) blockedBy = blocked;
     }
     return {
       id,
@@ -196768,7 +197414,8 @@ function* sweep(loaded, options = {}, hooks = {}) {
       hits: hitCount.get(id),
       reachedRuns: reached,
       reachPct: executed ? reached / executed * 100 : 0,
-      ...needsInput ? { needsInput } : {}
+      ...needsInput ? { needsInput } : {},
+      ...blockedBy ? { blockedBy } : {}
     };
   });
   const neverHit = beats.filter((b) => b.reachedRuns === 0).length;
@@ -196821,9 +197468,16 @@ function renderCoverageText(report, sceneName = (id) => id) {
     out.push("");
     out.push(`${sceneName(scene)}${dead ? `  (${dead} never reached)` : ""}`);
     for (const b of beats) {
-      const mark = b.reachedRuns === 0 ? b.needsInput ? "? " : "\u203C " : "  ";
+      const mark = b.reachedRuns === 0 ? b.needsInput || b.blockedBy ? "? " : "\u203C " : "  ";
       const label = b.character ? `${b.character}: ${clip(b.preview)}` : clip(b.preview || `(${b.kind})`);
       out.push(`  ${mark}${b.reachPct.toFixed(0).padStart(3)}%  ${String(b.hits).padStart(6)}  ${label}`);
+      for (const bg of b.blockedBy ?? []) {
+        const names = bg.writers.map((w) => {
+          const target = report.beats.find((x) => x.id === w);
+          return target ? clip(target.preview || target.id, 28) : w;
+        });
+        out.push(`         gated on ${bg.ref}, written only by: ${names.join(", ")} (never played either)`);
+      }
     }
   }
   return out;
@@ -196875,7 +197529,7 @@ function runReport(loaded, recordingOverride) {
   const thresholdIdx = estimatingOn ? writingIndex.get(est?.thresholdStatus ?? "") ?? 0 : -1;
   const defaultLines = est?.defaultLines ?? 0;
   const tagMap = new Map((est?.tagEstimates ?? []).map((t) => [t.tag, t.lines]));
-  const { writing: writingOf, recording: manualRecordingOf, cut: cutSet, rerecord: rerecordSet, edits: editsOf } = mergeAuthoring(loaded);
+  const { writing: writingOf, recording: manualRecordingOf, cut: cutSet, rerecord: rerecordSet, edits: editsOf } = mergeAuthoring2(loaded);
   const recordingBase = recordingOverride ?? manualRecordingOf;
   const recordingOf = (id) => effectiveRecording(id, recordingBase, rerecordSet, recordingLadder[0]);
   const byLocale = stringsByLocale(loaded);
@@ -197232,7 +197886,7 @@ function classesForChannel(classes, channel) {
 function resolveDocumentation(loaded, channel) {
   const classes = loaded.project.documentationClasses ?? DEFAULT_DOCUMENTATION_CLASSES;
   const allowed = classesForChannel(classes, channel);
-  const docsOf = mergeAuthoring(loaded).documentation;
+  const docsOf = mergeAuthoring2(loaded).documentation;
   const own = (id) => (docsOf.get(id) ?? []).filter((l2) => l2.type !== void 0 && allowed.has(l2.type));
   const out = /* @__PURE__ */ new Map();
   const visit = (id, inherited) => {
@@ -197268,7 +197922,7 @@ function extractLoc(loaded, opts = {}) {
   const targetLocale = isTemplate ? void 0 : opts.locale;
   const source2 = tableFor(loaded, defaultLocale);
   const target = targetLocale ? tableFor(loaded, targetLocale) : {};
-  const edits = mergeAuthoring(loaded).edits;
+  const edits = mergeAuthoring2(loaded).edits;
   const docs = resolveDocumentation(loaded, "loc");
   const commentsOf = (id) => (docs.get(id) ?? []).map((d) => d.text);
   const staleFor = (id, translation) => {
@@ -197608,7 +198262,7 @@ function runVoiceScript(loaded, opts = {}) {
   const stub = writingLadder[0];
   const recordThreshold = ladderDecls.findIndex((s) => s.readyToRecord);
   const writingIndex = new Map(writingLadder.map((name, i) => [name, i]));
-  const { writing: writingOf, recording: manualRecordingOf, cut: cutSet, rerecord: rerecordSet, documentation: docsOf } = mergeAuthoring(loaded);
+  const { writing: writingOf, recording: manualRecordingOf, cut: cutSet, rerecord: rerecordSet, documentation: docsOf } = mergeAuthoring2(loaded);
   const recordingBase = opts.recordingOverride ?? manualRecordingOf;
   const recordingOf = (id) => effectiveRecording(id, recordingBase, rerecordSet, recordingLadder[0]);
   const source2 = sourceStrings(loaded);
@@ -197804,7 +198458,7 @@ function sequenceLabel(node) {
 function runScriptDoc(loaded) {
   const { project } = loaded;
   const source2 = sourceStrings(loaded);
-  const { cut } = mergeAuthoring(loaded);
+  const { cut } = mergeAuthoring2(loaded);
   const sceneOf = /* @__PURE__ */ new Map();
   const blockTrail = /* @__PURE__ */ new Map();
   const blockName = /* @__PURE__ */ new Map();
@@ -238165,6 +238819,13 @@ async function runPack(startPath) {
   const projectFile = findProjectFile(startPath);
   const root2 = dirname4(projectFile);
   const project = parseSource(readFileSync4(projectFile, "utf8"));
+  const unresolved = sidecarIssues(walkFiles(root2, CONFLICT_SIDECAR));
+  if (unresolved.length) {
+    throw new Error(
+      `${unresolved.length} unresolved merge conflict(s) - resolve them before packing, or the recipient gets your side of a disagreement with no sign of it:
+` + unresolved.map((i) => `  ${i.file}`).join("\n")
+    );
+  }
   const files = SHARD_EXTENSIONS.flatMap((ext) => walkFiles(root2, ext)).map((abs) => ({ abs, rel: relative(root2, abs).split(sep2).join("/") })).sort((a, b) => a.rel.localeCompare(b.rel));
   const manifest = {
     schema: "patter/document@0",
@@ -238181,325 +238842,6 @@ async function runPack(startPath) {
 var import_jszip2 = __toESM(require_lib3(), 1);
 import { join as join5, normalize, isAbsolute as isAbsolute2, resolve as resolve4, sep as sep3 } from "path";
 import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
-
-// ../ops/src/merge.ts
-var UnsupportedMergeError = class extends Error {
-};
-var eq = (a, b) => canonicalStringify(a) === canonicalStringify(b);
-var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-function detectMergeType(file) {
-  const s = typeof file.schema === "string" ? file.schema : "";
-  if (s.startsWith("patter/flow")) return "flow";
-  if (s.startsWith("patter/strings")) return "loc";
-  if (s.startsWith("patter/authoring")) return "authoring";
-  if (s.startsWith("patter/project")) return "project";
-  throw new UnsupportedMergeError(`cannot detect a Patter merge type from schema '${s}'`);
-}
-function runMerge(base, ours, theirs, opts) {
-  const type = opts?.type ?? detectMergeType(ours);
-  switch (type) {
-    case "loc":
-      return mergeLoc(base, ours, theirs);
-    case "authoring":
-      return mergeAuthoring2(base, ours, theirs);
-    case "flow":
-      return mergeFlow(base, ours, theirs);
-    case "project":
-      return mergeProject(base, ours, theirs);
-  }
-}
-function deletedKind(base, ours, theirs) {
-  const deleted = base !== void 0 && (ours === void 0 || theirs === void 0);
-  return deleted ? "delete-vs-edit" : "both-changed";
-}
-function merge3(base, ours, theirs, id, path, conflicts) {
-  if (eq(ours, theirs)) return ours;
-  if (eq(base, ours)) return theirs;
-  if (eq(base, theirs)) return ours;
-  conflicts.push({ id, path, base, ours, theirs, kind: deletedKind(base, ours, theirs) });
-  return ours;
-}
-function mergeMap(base, ours, theirs, prefix, conflicts, resolve6) {
-  const out = {};
-  for (const k of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
-    const b = base[k], o = ours[k], t = theirs[k];
-    let v;
-    if (eq(o, t)) v = o;
-    else if (eq(b, o)) v = t;
-    else if (eq(b, t)) v = o;
-    else {
-      const r = resolve6?.(k, b, o, t);
-      if (r && r.resolved) v = r.value;
-      else {
-        conflicts.push({ id: k, path: `${prefix}.${k}`, base: b, ours: o, theirs: t, kind: r ? r.kind : deletedKind(b, o, t) });
-        v = o;
-      }
-    }
-    if (v !== void 0) out[k] = v;
-  }
-  return out;
-}
-var asMap = (v) => isObj(v) ? v : {};
-var asArr = (v) => Array.isArray(v) ? v : [];
-function setIf(obj2, key2, val) {
-  if (Array.isArray(val) ? val.length > 0 : Object.keys(val).length > 0) obj2[key2] = val;
-}
-function mergeLoc(base, ours, theirs) {
-  const conflicts = [];
-  const merged = {};
-  for (const f of ["schema", "scene", "locale", "default"]) {
-    const v = merge3(base[f], ours[f], theirs[f], "", f, conflicts);
-    if (v !== void 0) merged[f] = v;
-  }
-  merged.strings = mergeMap(asMap(base.strings), asMap(ours.strings), asMap(theirs.strings), "strings", conflicts);
-  return { type: "loc", merged, conflicts, warnings: [] };
-}
-function mergeAuthoring2(base, ours, theirs) {
-  const conflicts = [];
-  const merged = {};
-  merged.schema = merge3(base.schema, ours.schema, theirs.schema, "", "schema", conflicts) ?? ours.schema;
-  setIf(merged, "comments", mergeComments(asArr(base.comments), asArr(ours.comments), asArr(theirs.comments)));
-  const edits = mergeEdits(asMap(base.edits), asMap(ours.edits), asMap(theirs.edits));
-  setIf(merged, "edits", edits);
-  const lww = lastWriterWins(asMap(ours.edits), asMap(theirs.edits));
-  for (const f of ["writing", "recording", "audio"]) {
-    setIf(merged, f, mergeMap(asMap(base[f]), asMap(ours[f]), asMap(theirs[f]), f, conflicts, lww));
-  }
-  setIf(merged, "documentation", mergeMap(asMap(base.documentation), asMap(ours.documentation), asMap(theirs.documentation), "documentation", conflicts));
-  setIf(merged, "cut", mergeMap(asMap(base.cut), asMap(ours.cut), asMap(theirs.cut), "cut", conflicts, void 0));
-  return { type: "authoring", merged, conflicts, warnings: [] };
-}
-function mergeComments(base, ours, theirs) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const c2 of [...base, ...ours, ...theirs]) {
-    if (isObj(c2) && typeof c2.id === "string" && !byId.has(c2.id)) byId.set(c2.id, c2);
-  }
-  return [...byId.values()].sort((a, b) => String(a.ts ?? "").localeCompare(String(b.ts ?? "")));
-}
-function lastWriterWins(oursEdits, theirsEdits) {
-  return (id, _b, o, t) => {
-    const om = asMap(oursEdits[id]).modifiedAt, tm = asMap(theirsEdits[id]).modifiedAt;
-    if (typeof om === "string" && typeof tm === "string") return { resolved: true, value: om >= tm ? o : t };
-    return { resolved: false, kind: "no-timestamp" };
-  };
-}
-function mergeEdits(base, ours, theirs) {
-  const out = {};
-  for (const id of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
-    const o = ours[id], t = theirs[id];
-    if (eq(o, t)) {
-      if (o !== void 0) out[id] = o;
-      continue;
-    }
-    if (o === void 0) {
-      if (t !== void 0) out[id] = t;
-      continue;
-    }
-    if (t === void 0) {
-      out[id] = o;
-      continue;
-    }
-    out[id] = mergeEditRecord(asMap(o), asMap(t));
-  }
-  return out;
-}
-function mergeEditRecord(o, t) {
-  const om = typeof o.modifiedAt === "string" ? o.modifiedAt : "";
-  const tm = typeof t.modifiedAt === "string" ? t.modifiedAt : "";
-  const newer = om >= tm ? o : t;
-  const ol = asMap(o.localisedAt), tl = asMap(t.localisedAt);
-  const loc = {};
-  for (const k of /* @__PURE__ */ new Set([...Object.keys(ol), ...Object.keys(tl)])) {
-    const a = typeof ol[k] === "string" ? ol[k] : "";
-    const b = typeof tl[k] === "string" ? tl[k] : "";
-    loc[k] = a >= b ? ol[k] ?? tl[k] : tl[k] ?? ol[k];
-  }
-  const merged = { ...newer };
-  if (Object.keys(loc).length > 0) merged.localisedAt = loc;
-  return merged;
-}
-function mergeKeyedByName(base, ours, theirs, path, conflicts) {
-  const byName = (arr) => {
-    const m = {};
-    for (const p of arr) if (isObj(p) && typeof p.name === "string") m[p.name] = p;
-    return m;
-  };
-  const merged = mergeMap(byName(base), byName(ours), byName(theirs), path, conflicts);
-  return Object.keys(merged).sort().map((name) => merged[name]);
-}
-function mergeProject(base, ours, theirs) {
-  const conflicts = [];
-  const merged = {};
-  for (const k of /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)])) {
-    if (k === "properties" || k === "cast") {
-      const v = mergeKeyedByName(asArr(base[k]), asArr(ours[k]), asArr(theirs[k]), k, conflicts);
-      if (v.length > 0) merged[k] = v;
-    } else if (k === "gameDataFields") {
-      const v = mergeGameDataFields(asMap(base[k]), asMap(ours[k]), asMap(theirs[k]), conflicts);
-      if (Object.keys(v).length > 0) merged[k] = v;
-    } else if (k === "locales") {
-      merged.locales = mergeLocales(asMap(base.locales), asMap(ours.locales), asMap(theirs.locales), conflicts);
-    } else {
-      const v = merge3(base[k], ours[k], theirs[k], "", k, conflicts);
-      if (v !== void 0) merged[k] = v;
-    }
-  }
-  return { type: "project", merged, conflicts, warnings: [] };
-}
-function mergeGameDataFields(b, o, t, conflicts) {
-  const out = {};
-  for (const kind of /* @__PURE__ */ new Set([...Object.keys(b), ...Object.keys(o), ...Object.keys(t)])) {
-    const v = mergeKeyedByName(asArr(b[kind]), asArr(o[kind]), asArr(t[kind]), `gameDataFields.${kind}`, conflicts);
-    if (v.length > 0) out[kind] = v;
-  }
-  return out;
-}
-function mergeLocales(b, o, t, conflicts) {
-  const out = {};
-  const def = merge3(b.default, o.default, t.default, "", "locales.default", conflicts);
-  if (def !== void 0) out.default = def;
-  const all = [];
-  for (const arr of [asArr(b.all), asArr(o.all), asArr(t.all)]) {
-    for (const x of arr) if (typeof x === "string" && !all.includes(x)) all.push(x);
-  }
-  out.all = all;
-  return out;
-}
-var CHILD_KEYS = ["blocks", "children", "beats"];
-function toTree(raw) {
-  const childKey = CHILD_KEYS.find((k) => Array.isArray(raw[k]));
-  const fields = {};
-  for (const [k, v] of Object.entries(raw)) if (k !== childKey) fields[k] = v;
-  const children = childKey ? raw[childKey].filter(isObj).map(toTree) : [];
-  return { id: typeof raw.id === "string" ? raw.id : "", fields, childKey, children };
-}
-function fromTree(n) {
-  const out = { ...n.fields };
-  if (n.childKey) out[n.childKey] = n.children.map(fromTree);
-  return out;
-}
-function mergeFlow(base, ours, theirs) {
-  const conflicts = [];
-  const warnings = [];
-  const merged = {};
-  merged.schema = merge3(base.schema, ours.schema, theirs.schema, "", "schema", conflicts) ?? ours.schema;
-  const bScene = isObj(base.scene) ? toTree(base.scene) : void 0;
-  const oScene = toTree(asMap(ours.scene));
-  const tScene = isObj(theirs.scene) ? toTree(theirs.scene) : void 0;
-  const mergedScene = mergeNode(bScene, oScene, tScene, "scene", conflicts, warnings);
-  merged.scene = fromTree(mergedScene);
-  checkDuplicateIds(mergedScene, conflicts);
-  return { type: "flow", merged, conflicts, warnings };
-}
-function mergeNode(b, o, t, path, conflicts, warnings) {
-  const fields = mergeFields(b?.fields ?? {}, o.fields, t?.fields ?? {}, o.id, path, conflicts);
-  const childKey = o.childKey ?? t?.childKey ?? b?.childKey;
-  const children = childKey ? mergeChildren(b?.children ?? [], o.children, t?.children ?? [], `${path}.${childKey}`, conflicts, warnings) : [];
-  return { id: o.id, fields, childKey, children };
-}
-function mergeFields(b, o, t, id, path, conflicts) {
-  const out = {};
-  for (const k of /* @__PURE__ */ new Set([...Object.keys(b), ...Object.keys(o), ...Object.keys(t)])) {
-    const v = merge3(b[k], o[k], t[k], id, `${path}.${k}`, conflicts);
-    if (v !== void 0) out[k] = v;
-  }
-  return out;
-}
-function mergeChildren(B, O, T, path, conflicts, warnings) {
-  const Bm = idMap(B), Om = idMap(O), Tm = idMap(T);
-  const Bset = new Set(Bm.keys()), Oset = new Set(Om.keys()), Tset = new Set(Tm.keys());
-  const merged = /* @__PURE__ */ new Map();
-  const here = (id) => `${path}[${id}]`;
-  for (const id of /* @__PURE__ */ new Set([...Bm.keys(), ...Om.keys(), ...Tm.keys()])) {
-    const b = Bm.get(id), o = Om.get(id), t = Tm.get(id);
-    const inB = Bset.has(id), inO = Oset.has(id), inT = Tset.has(id);
-    if (inO && inT) {
-      if (!inB && !eq(fromTree(o), fromTree(t))) {
-        conflicts.push({ id, path: here(id), base: void 0, ours: fromTree(o), theirs: fromTree(t), kind: "added-both" });
-        merged.set(id, o);
-      } else {
-        merged.set(id, mergeNode(b, o, t, here(id), conflicts, warnings));
-      }
-    } else if (inO && !inT) {
-      if (inB && !eq(fromTree(o), fromTree(b))) {
-        conflicts.push({ id, path: here(id), base: fromTree(b), ours: fromTree(o), theirs: void 0, kind: "delete-vs-edit" });
-        merged.set(id, o);
-      } else if (!inB) {
-        merged.set(id, o);
-      }
-    } else if (!inO && inT) {
-      if (inB && !eq(fromTree(t), fromTree(b))) {
-        conflicts.push({ id, path: here(id), base: fromTree(b), ours: void 0, theirs: fromTree(t), kind: "delete-vs-edit" });
-      } else if (!inB) {
-        merged.set(id, t);
-      }
-    }
-  }
-  return orderChildren(merged, B, O, T, path, conflicts, warnings);
-}
-function orderChildren(merged, B, O, T, path, conflicts, warnings) {
-  const Bids = B.map((n) => n.id), Oids = O.map((n) => n.id), Tids = T.map((n) => n.id);
-  const Oidset = new Set(Oids);
-  const common = new Set(Bids.filter((id) => merged.has(id)));
-  const restrict = (ids) => ids.filter((id) => common.has(id));
-  const relB = restrict(Bids), relO = restrict(Oids), relT = restrict(Tids);
-  const fullO = relO.length === common.size, fullT = relT.length === common.size;
-  let commonOrder;
-  if (!fullO && !fullT) commonOrder = relB;
-  else if (!fullO) commonOrder = relT;
-  else if (!fullT) commonOrder = relO;
-  else if (arrEq(relO, relB)) commonOrder = relT;
-  else if (arrEq(relT, relB)) commonOrder = relO;
-  else if (arrEq(relO, relT)) commonOrder = relO;
-  else {
-    conflicts.push({ id: "", path, base: relB, ours: relO, theirs: relT, kind: "moved" });
-    commonOrder = relO;
-  }
-  const anchorIn = (ids, id) => {
-    for (let i = ids.indexOf(id) - 1; i >= 0; i--) if (common.has(ids[i])) return ids[i];
-    return null;
-  };
-  const byAnchor = /* @__PURE__ */ new Map();
-  const group = (a) => {
-    let g = byAnchor.get(a);
-    if (!g) {
-      g = { ours: [], theirs: [] };
-      byAnchor.set(a, g);
-    }
-    return g;
-  };
-  for (const n of O) if (merged.has(n.id) && !common.has(n.id)) group(anchorIn(Oids, n.id)).ours.push(n.id);
-  for (const n of T) if (merged.has(n.id) && !common.has(n.id) && !Oidset.has(n.id)) group(anchorIn(Tids, n.id)).theirs.push(n.id);
-  const out = [];
-  const emit = (anchor) => {
-    const g = byAnchor.get(anchor);
-    if (!g) return;
-    if (g.ours.length > 0 && g.theirs.length > 0) warnings.push({ id: anchor ?? "", path, message: "both sides inserted here; kept ours-then-theirs - review the order" });
-    out.push(...g.ours, ...g.theirs);
-  };
-  emit(null);
-  for (const id of commonOrder) {
-    out.push(id);
-    emit(id);
-  }
-  return out.map((id) => merged.get(id));
-}
-function checkDuplicateIds(root2, conflicts) {
-  const seen = /* @__PURE__ */ new Set(), dup = /* @__PURE__ */ new Set();
-  const walk2 = (n) => {
-    if (n.id) {
-      if (seen.has(n.id)) dup.add(n.id);
-      else seen.add(n.id);
-    }
-    n.children.forEach(walk2);
-  };
-  walk2(root2);
-  for (const id of dup) conflicts.push({ id, path: "scene", base: void 0, ours: void 0, theirs: void 0, kind: "structural" });
-}
-var idMap = (nodes) => new Map(nodes.filter((n) => n.id).map((n) => [n.id, n]));
-var arrEq = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
-
-// ../ops/src/unpack.ts
 var MANIFEST = "patter.manifest.json";
 var UnsafeEntryError = class extends Error {
 };
@@ -238562,10 +238904,17 @@ async function runUnpackMerge(returnedBytes, baseBytes, projectDir) {
       shards.push({ path: rel, added: true });
       continue;
     }
-    const oursObj = parseSource(readFileSync5(outPath, "utf8"));
-    const theirsObj = parseSource(theirText);
+    const readSide = (side, text) => {
+      try {
+        return parseSource(text);
+      } catch (e) {
+        throw new Error(`${rel}: the ${side} copy is not readable Patter source - ${e instanceof Error ? e.message : String(e)}`);
+      }
+    };
+    const oursObj = readSide("ours", readFileSync5(outPath, "utf8"));
+    const theirsObj = readSide("theirs", theirText);
     const baseText = base.get(rel);
-    const baseObj = baseText !== void 0 ? parseSource(baseText) : {};
+    const baseObj = baseText !== void 0 ? readSide("base", baseText) : {};
     const result = runMerge(baseObj, oursObj, theirsObj);
     writes.push({ path: outPath, content: canonicalStringify(result.merged) });
     if (result.conflicts.length > 0) {
@@ -240467,6 +240816,44 @@ function writeTextFiles(files, encoding = "utf8") {
   return { success: results.every((r) => r.success), results };
 }
 
+// package.json
+var package_default = {
+  name: "@patterkit/cli",
+  version: "0.3.0",
+  description: "The `patter` CLI: validate, format, export, and play a Patter project.",
+  type: "module",
+  license: "MIT",
+  author: "Ian Thomas",
+  homepage: "https://patterkit.dev",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/patterkit/patter.git",
+    directory: "packages/cli"
+  },
+  bugs: "https://github.com/patterkit/patter/issues",
+  publishConfig: {
+    access: "public"
+  },
+  bin: {
+    patter: "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    "build:standalone": "node scripts/build-standalone.mjs",
+    "build:standalone:mac": "node scripts/build-standalone.mjs --targets=darwin-arm64,darwin-x64",
+    "build:standalone:others": "node scripts/build-standalone.mjs --targets=linux-x64,linux-arm64,windows-x64"
+  },
+  dependencies: {
+    "@patterkit/core": "0.2.1",
+    "@patterkit/ops": "0.5.0",
+    "@wildwinter/simple-vc-lib": "^0.4.1"
+  }
+};
+
 // src/main.ts
 var isPatterSource = (path) => SHARD_EXTENSIONS.some((ext) => path.endsWith(ext));
 function writeMergeResult(result, out, announce) {
@@ -240486,6 +240873,8 @@ function writeMergeResult(result, out, announce) {
 var USAGE = `patter - Patter CLI
 
 Usage:
+  patter --version                Print the version (also -v / version)
+  patter --help                   Print this usage (also -h / help)
   patter init    [dir]            Scaffold a new project (the <dir>.patter folder, starter scene, VCS config)
                  [--name X] [--vcs git|perforce|plastic|svn] [--bundle commit|ignore]
   patter validate [path]          Validate a project (structural + expressions + encoding + bundle)
@@ -240603,6 +240992,14 @@ async function main(argv) {
     console.log(USAGE);
     return 0;
   }
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    console.log(package_default.version);
+    return 0;
+  }
+  if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+    console.log(USAGE);
+    return 0;
+  }
   const canonical = cmd === "fmt" ? "format" : cmd === "stats" ? "report" : cmd;
   if (!(canonical in FLAGS)) {
     console.log(USAGE);
@@ -240689,15 +241086,18 @@ async function run(cmd, positionals, flags) {
     }
     case "validate": {
       const loaded = loadProject(positionals[0] ?? ".");
-      const { structural, conditions, interpolation, hygiene, staleBundles, unresolvedMerges, ok } = runValidate(loaded);
+      const { structural, conditions, interpolation, hygiene, staleBundles, unresolvedMerges, orphans, reachability, ok } = runValidate(loaded);
       for (const i of structural) console.error(`  [${i.code}] ${i.message}`);
       for (const i of conditions) console.error(`  [${i.field}] ${i.nodeId}: ${i.message}  (${i.src})`);
       for (const i of interpolation) console.error(`  [${i.field}] ${i.nodeId}: ${i.message}  (${i.src})`);
       for (const i of hygiene) console.error(`  [hygiene] ${i.file}: ${i.message}`);
       for (const i of staleBundles) console.error(`  [stale-bundle] ${i.file}: ${i.message}`);
       for (const i of unresolvedMerges) console.error(`  [unresolved-merge] ${i.file}: ${i.message}`);
-      const count = structural.length + conditions.length + interpolation.length + hygiene.length + staleBundles.length + unresolvedMerges.length;
-      if (ok) console.log(`ok - ${loaded.scenes.length} scene(s), no issues`);
+      for (const i of orphans) console.error(`  [not-in-project] ${i.file}: ${i.message}`);
+      for (const i of reachability) console.error(`  [unreachable] ${i.nodeId}: ${i.message}  (${i.src})`);
+      const count = structural.length + conditions.length + interpolation.length + hygiene.length + staleBundles.length + unresolvedMerges.length + orphans.length;
+      const advisory = reachability.length ? `, ${reachability.length} warning(s) above` : "";
+      if (ok) console.log(`ok - ${loaded.scenes.length} scene(s), no issues${advisory}`);
       else console.error(`
 ${count} issue(s)`);
       return ok ? 0 : 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patterkit/cli",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "The `patter` CLI: validate, format, export, and play a Patter project.",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   },
   "dependencies": {
     "@patterkit/core": "0.2.1",
-    "@patterkit/ops": "0.3.6",
+    "@patterkit/ops": "0.5.0",
     "@wildwinter/simple-vc-lib": "^0.4.1"
   }
 }