yamlover 0.3.50 → 0.3.52

package/dist/server.js

@@ -67887,6 +67887,27 @@ function deadLinkDiagnostics(doc, store, dataRoot) {
   }
   return out;
 }
+function doubledFragmentDiagnostics(doc) {
+  const out = [];
+  const walk = (node, segs) => {
+    const entries = node.entries ?? [];
+    entries.forEach((e3, i2) => {
+      const key = typeof e3.key === "string" ? e3.key : null;
+      if (key === "fragments" && segs[segs.length - 1] === "fragments" && segs[segs.length - 2] === "yo") {
+        out.push({
+          code: "annotations/doubled-fragments",
+          severity: "warning",
+          message: `a \`fragments:\` mapping nested inside \`yo: fragments:\` \u2014 left by a pre-fix annotate over the flat spelling`,
+          path: ":" + [...segs, key].join(":"),
+          hint: "move its child fragments up one level, into the enclosing fragments mapping"
+        });
+      }
+      if (e3.value !== null && typeof e3.value === "object") walk(e3.value, [...segs, key ?? String(i2)]);
+    });
+  };
+  walk(doc.root, []);
+  return out;
+}
 function deadLinkTargets(doc, store) {
   const out = /* @__PURE__ */ new Set();
   for (const l2 of scanTextLinks(doc)) {
@@ -67935,6 +67956,18 @@ function findKeyLine(lines, lo, hi, indent, key) {
   }
   return -1;
 }
+function flatRun(line, keys, k) {
+  let rest = line.trim();
+  let n2 = 0;
+  while (k + n2 < keys.length && rest !== "") {
+    const key = keys[k + n2];
+    const tok = [key, keyToken(key)].find((t3) => rest === `${t3}:` || rest.startsWith(`${t3}: `));
+    if (tok === void 0) break;
+    rest = rest === `${tok}:` ? "" : rest.slice(tok.length + 2);
+    n2++;
+  }
+  return Math.max(1, n2);
+}
 function trimBack(lines, floor, end) {
   let e3 = end;
   while (e3 > floor + 1 && !isContentLine(lines[e3 - 1])) e3--;
@@ -67971,7 +68004,8 @@ function bodyUnder(lines, L2, hi, indent) {
 }
 function reachBodyAt(lines, start, within) {
   let { lo, hi, indent } = start;
-  for (const key of within) {
+  for (let k = 0; k < within.length; ) {
+    const key = within[k];
     const L2 = findKeyLine(lines, lo, hi, indent, key);
     if (L2 < 0) {
       const at = trimBack(lines, lo - 1, hi);
@@ -67979,18 +68013,23 @@ function reachBodyAt(lines, start, within) {
       lo = at + 1;
       hi = at + 1;
       indent += 2;
+      k++;
       continue;
     }
+    const consumed = flatRun(lines[L2], within, k);
     ({ lo, hi, indent } = bodyUnder(lines, L2, hi, indent));
+    k += consumed;
   }
   return { lo, hi, indent };
 }
 function findBody(lines, within) {
   let region = { lo: 0, hi: lines.length, indent: firstContentIndent(lines) };
-  for (const key of within) {
-    const L2 = findKeyLine(lines, region.lo, region.hi, region.indent, key);
+  for (let k = 0; k < within.length; ) {
+    const L2 = findKeyLine(lines, region.lo, region.hi, region.indent, within[k]);
     if (L2 < 0) return null;
+    const consumed = flatRun(lines[L2], within, k);
     region = bodyUnder(lines, L2, region.hi, region.indent);
+    k += consumed;
   }
   return region;
 }
@@ -68016,31 +68055,40 @@ function seqItemLines(lines, region, key) {
   }
   return { keyLine, items, end: trimBack(lines, end, region.hi) };
 }
-function upsertMapEntry(text, within, mapKey, entryKey, render) {
+function upsertMapEntry(text, within, mapPath, entryKey, render) {
   const lines = text.replace(/\n$/, "").split("\n");
-  upsertMapEntryAt(lines, reachBody(lines, within), mapKey, entryKey, render);
+  upsertMapEntryAt(lines, reachBody(lines, [...within, ...mapPath]), entryKey, render);
   return lines.join("\n") + "\n";
 }
-function upsertMapEntryAt(lines, region, mapKey, entryKey, render) {
-  let mapLine = findKeyLine(lines, region.lo, region.hi, region.indent, mapKey);
-  if (mapLine < 0) {
-    const at = trimBack(lines, region.lo - 1, region.hi);
-    lines.splice(at, 0, `${" ".repeat(region.indent)}${keyToken(mapKey)}:`);
-    mapLine = at;
-  }
-  const mapIndent = region.indent + 2;
-  const mapBody = { lo: mapLine + 1, hi: blockEnd(lines, mapLine + 1, lines.length, region.indent + 1), indent: mapIndent };
-  const existing = findKeyLine(lines, mapBody.lo, mapBody.hi, mapIndent, entryKey);
+function upsertMapEntryAt(lines, body, entryKey, render) {
+  const existing = findKeyLine(lines, body.lo, body.hi, body.indent, entryKey);
   if (existing >= 0) {
-    const end = blockEnd(lines, existing + 1, mapBody.hi, mapIndent + 1);
-    lines.splice(existing, end - existing, ...render(mapIndent));
+    const end = blockEnd(lines, existing + 1, body.hi, body.indent + 1);
+    lines.splice(existing, end - existing, ...render(body.indent));
   } else {
-    const at = trimBack(lines, mapLine, mapBody.hi);
-    lines.splice(at, 0, ...render(mapIndent));
+    const at = trimBack(lines, body.lo - 1, body.hi);
+    lines.splice(at, 0, ...render(body.indent));
   }
 }
+function replaceSeqEntryAt(lines, region, key, render) {
+  const keyLine = findKeyLine(lines, region.lo, region.hi, region.indent, key);
+  if (keyLine < 0) {
+    const at = trimBack(lines, region.lo - 1, region.hi);
+    lines.splice(at, 0, ...render(region.indent));
+    return;
+  }
+  let end = keyLine + 1;
+  for (let i2 = keyLine + 1; i2 < region.hi; i2++) {
+    if (!isContentLine(lines[i2])) continue;
+    const ind = indentOf(lines[i2]);
+    if (ind < region.indent) break;
+    if (ind === region.indent && seqMarkLen(lines[i2].trim()) === null) break;
+    end = i2 + 1;
+  }
+  lines.splice(keyLine, trimBack(lines, keyLine, end) - keyLine, ...render(region.indent));
+}
 function upsertFragment(text, within, slug, render) {
-  return upsertMapEntry(text, [...within, YO_KEY], FRAGMENTS_SUBKEY, slug, render);
+  return upsertMapEntry(text, within, [YO_KEY, FRAGMENTS_SUBKEY], slug, render);
 }
 function pruneEmptyKeyAt(lines, region, key) {
   const L2 = findKeyLine(lines, region.lo, region.hi, region.indent, key);
@@ -68103,7 +68151,7 @@ function pruneEmptyYo(text, within) {
   return pruneEmptyKeyAt(lines, region, YO_KEY) ? lines.join("\n") + "\n" : text;
 }
 function upsertThumbnail(text, within, resKey, render) {
-  return upsertMapEntry(text, within, THUMBNAILS_KEY, resKey, render);
+  return upsertMapEntry(text, within, [THUMBNAILS_KEY], resKey, render);
 }
 function annotationsRemainAt(lines, region) {
   const seq = seqItemLines(lines, region, ANNOTATIONS_KEY);
@@ -68144,31 +68192,126 @@ function pruneEmptyAnnotations(text, within, pruneHosts) {
   const droppedHosts = pruneHosts && pruneEmptyKeys(lines, within);
   return droppedHusk || droppedHosts ? lines.join("\n") + "\n" : text;
 }
-function removeMapEntry(text, within, mapKey, entryKey) {
+function findMapping(lines, region, mapPath) {
+  let r2 = region;
+  let line = -1;
+  for (let k = 0; k < mapPath.length; ) {
+    const L2 = findKeyLine(lines, r2.lo, r2.hi, r2.indent, mapPath[k]);
+    if (L2 < 0) return null;
+    const consumed = flatRun(lines[L2], mapPath, k);
+    line = L2;
+    r2 = bodyUnder(lines, L2, r2.hi, r2.indent);
+    k += consumed;
+  }
+  return line < 0 ? null : { line, body: r2 };
+}
+function removeMapEntry(text, within, mapPath, entryKey) {
   const lines = text.replace(/\n$/, "").split("\n");
-  return removeMapEntryAt(lines, reachBody(lines, within), mapKey, entryKey) ? lines.join("\n") + "\n" : text;
-}
-function removeMapEntryAt(lines, region, mapKey, entryKey) {
-  const mapLine = findKeyLine(lines, region.lo, region.hi, region.indent, mapKey);
-  if (mapLine < 0) return false;
-  const mapIndent = region.indent + 2;
-  const mapHi = blockEnd(lines, mapLine + 1, lines.length, region.indent + 1);
-  const entry = findKeyLine(lines, mapLine + 1, mapHi, mapIndent, entryKey);
+  const region = findBody(lines, within);
+  if (!region) return text;
+  return removeMapEntryAt(lines, region, mapPath, entryKey) ? lines.join("\n") + "\n" : text;
+}
+function removeMapEntryAt(lines, region, mapPath, entryKey) {
+  const map = findMapping(lines, region, mapPath);
+  if (!map) return false;
+  const entry = findKeyLine(lines, map.body.lo, map.body.hi, map.body.indent, entryKey);
   if (entry < 0) return false;
-  const end = blockEnd(lines, entry + 1, mapHi, mapIndent + 1);
+  const end = blockEnd(lines, entry + 1, map.body.hi, map.body.indent + 1);
   lines.splice(entry, end - entry);
-  const newHi = blockEnd(lines, mapLine + 1, lines.length, region.indent + 1);
+  const mapIndent = indentOf(lines[map.line]);
+  const newHi = blockEnd(lines, map.line + 1, lines.length, mapIndent + 1);
   let hasChild = false;
-  for (let i2 = mapLine + 1; i2 < newHi; i2++) {
-    if (isContentLine(lines[i2]) && indentOf(lines[i2]) === mapIndent) {
+  for (let i2 = map.line + 1; i2 < newHi; i2++) {
+    if (isContentLine(lines[i2]) && indentOf(lines[i2]) === map.body.indent) {
       hasChild = true;
       break;
     }
   }
-  if (!hasChild) lines.splice(mapLine, blockEnd(lines, mapLine + 1, lines.length, region.indent + 1) - mapLine);
+  if (!hasChild) lines.splice(map.line, newHi - map.line);
   return true;
 }
 
+// src/board-model.ts
+var supersetOf = (tags, wanted) => wanted.every((t3) => tags.has(t3));
+function compartmentAt(structure, at) {
+  if (!at) return null;
+  return structure[at.lane]?.[at.comp] ?? null;
+}
+function reconcile(structure, chapters) {
+  let changed = false;
+  const out = structure.map(
+    (lane) => lane.map((comp) => {
+      if (comp.tags.length === 0) {
+        const kept2 = comp.items.filter((it) => !chapters.has(it.path));
+        if (kept2.length === comp.items.length) return comp;
+        changed = true;
+        return { tags: comp.tags, items: kept2 };
+      }
+      const kept = [];
+      const seen = /* @__PURE__ */ new Set();
+      let compChanged = false;
+      for (const item of comp.items) {
+        if (seen.has(item.path)) {
+          compChanged = true;
+          continue;
+        }
+        const tags = chapters.get(item.path);
+        if (tags && !supersetOf(tags, comp.tags)) {
+          compChanged = true;
+          continue;
+        }
+        kept.push(item);
+        seen.add(item.path);
+      }
+      for (const [p2, tags] of chapters) {
+        if (seen.has(p2) || !supersetOf(tags, comp.tags)) continue;
+        kept.push({ path: p2 });
+        seen.add(p2);
+        compChanged = true;
+      }
+      if (!compChanged) return comp;
+      changed = true;
+      return { tags: comp.tags, items: kept };
+    })
+  );
+  return changed ? { structure: out, changed } : { structure, changed };
+}
+function moveDeltas(chapterTags, from, to2) {
+  const toTags = new Set(to2?.tags ?? []);
+  const untag = (from?.tags ?? []).filter((t3) => chapterTags.has(t3) && !toTags.has(t3));
+  const tag = (to2?.tags ?? []).filter((t3) => !chapterTags.has(t3));
+  return { untag, tag };
+}
+function applyMove(structure, task, from, to2) {
+  let moved = { path: task };
+  const out = structure.map(
+    (lane, li) => lane.map((comp, ci) => {
+      let items = comp.items;
+      if (from && from.lane === li && from.comp === ci) {
+        const i2 = items.findIndex((it) => it.path === task);
+        if (i2 >= 0) {
+          moved = items[i2];
+          items = [...items.slice(0, i2), ...items.slice(i2 + 1)];
+        }
+      }
+      return items === comp.items ? comp : { tags: comp.tags, items };
+    })
+  );
+  if (to2) {
+    const dest = out[to2.lane]?.[to2.comp];
+    if (dest && !dest.items.some((it) => it.path === task)) {
+      out[to2.lane] = out[to2.lane].map((c3, ci) => ci === to2.comp ? { tags: c3.tags, items: [...c3.items, moved] } : c3);
+    }
+  }
+  return out;
+}
+function seedFromWorkflow(statePaths) {
+  return statePaths.map((p2) => [{ tags: [p2], items: [] }]);
+}
+function seedFromOldLanes(lanes) {
+  return lanes.map((laneTags) => laneTags.length === 0 ? [{ tags: [], items: [] }] : laneTags.map((t3) => ({ tags: [t3], items: [] })));
+}
+
 // src/concrete.ts
 var OVERLAY_DIR = ".yo";
 var BODY_FILE2 = "body.yo";
@@ -69355,7 +69498,7 @@ function createHandlers(dataRoot, opts = {}) {
     }
   };
   let reconcilePending = null;
-  const reconcile = () => {
+  const reconcile2 = () => {
     if (reconcilePending) return reconcilePending;
     const p2 = enqueue(async () => {
       reconcilePending = null;
@@ -69400,7 +69543,7 @@ function createHandlers(dataRoot, opts = {}) {
       return;
     }
     log(`watch: ${external.length} change(s) \u2014 ${external.slice(0, 5).join(", ")}${external.length > 5 ? ", \u2026" : ""}`);
-    reconcile().catch(() => {
+    reconcile2().catch(() => {
     });
   }, { ignore: ignore2 }) : null;
   const handler = (req, res, url) => {
@@ -69424,14 +69567,14 @@ function createHandlers(dataRoot, opts = {}) {
         return;
       }
       if (req.method === "POST" && url.pathname === "/api/reindex") {
-        reconcile().then((diff2) => sendJson(res, 200, diff2)).catch((e3) => sendJson(res, 500, { error: String(e3.message || e3) }));
+        reconcile2().then((diff2) => sendJson(res, 200, diff2)).catch((e3) => sendJson(res, 500, { error: String(e3.message || e3) }));
         return;
       }
       if (url.pathname === "/api/doctor") {
         try {
           const v = validateTree(scanTree(dataRoot, ignore2));
           const doc = cachedDoc ?? walkTree(dataRoot, walkOpts).doc;
-          sendJson(res, 200, { allowed: v.allowed, diagnostics: [...v.diagnostics, ...deadLinkDiagnostics(doc, s2, dataRoot)] });
+          sendJson(res, 200, { allowed: v.allowed, diagnostics: [...v.diagnostics, ...deadLinkDiagnostics(doc, s2, dataRoot), ...doubledFragmentDiagnostics(doc)] });
         } catch (e3) {
           sendJson(res, 500, { error: String(e3.message || e3) });
         }
@@ -69585,14 +69728,48 @@ function createHandlers(dataRoot, opts = {}) {
         readBody(req).then(
           (data) => enqueue(async () => {
             const b = data;
-            const lanes = Array.isArray(b?.lanes) ? b.lanes.map((lane) => Array.isArray(lane) ? lane.map((p3) => String(p3)) : []) : [];
-            const { bodyFile } = hostFor(dataRoot, s2, strToSegs(b?.path || ":"));
-            mkdirInside(dataRoot, path11.dirname(bodyFile), { recursive: true });
-            const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
-            writeBody(dataRoot, s2, bodyFile, writeBoardLanes(src, lanes));
-            broadcast(await doReindex());
-            scheduleHasher();
-            return { ok: true };
+            const boardSegs = strToSegs(b?.path || ":");
+            const boardStore = storePath(boardSegs);
+            if (!s2.node(boardStore)) throw new Error(`no board at ${b?.path || ":"}`);
+            const op = String(b?.op ?? "");
+            const read2 = readBoardStructure(s2, boardStore);
+            const structure = read2 ?? seedBoardStructure(s2, boardStore);
+            const writeStructure = async (st) => {
+              const { bodyFile } = hostFor(dataRoot, s2, boardSegs);
+              mkdirInside(dataRoot, path11.dirname(bodyFile), { recursive: true });
+              const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
+              writeBody(dataRoot, s2, bodyFile, writeBoardStructure(src, st));
+              broadcast(await doReindexFile(bodyFile));
+            };
+            if (op === "structure") {
+              const st = sanitizeBoardStructure(b.structure);
+              const rec = reconcile(st, memberTagSets(s2, boardMembers(dataRoot, s2, boardStore)));
+              await writeStructure(rec.structure);
+              scheduleHasher();
+              return { seeded: false, ...resolveBoard(dataRoot, s2, boardMembers(dataRoot, s2, boardStore), rec.structure) };
+            }
+            if (op === "move") {
+              const task = String(b.task ?? "");
+              const taskStore = storePath(strToSegs(task));
+              if (!task || !s2.node(taskStore)) throw new Error("move needs a `task` naming an existing node");
+              const from = boardCoord(b.from);
+              const to2 = boardCoord(b.to);
+              const deltas = moveDeltas(memberTagSets(s2, [task]).get(task), compartmentAt(structure, from), compartmentAt(structure, to2));
+              for (const t3 of deltas.untag) broadcast(await doReindexFile(unembedAnnotation(dataRoot, s2, task, t3)));
+              for (const t3 of deltas.tag) broadcast(await doReindexFile(embedAnnotation(dataRoot, s2, settings.sidecars, { target: task, tag: t3 })));
+              const moved = applyMove(structure, task, from, to2);
+              const rec = reconcile(moved, memberTagSets(s2, boardMembers(dataRoot, s2, boardStore)));
+              await writeStructure(rec.structure);
+              scheduleHasher();
+              return { seeded: false, ...resolveBoard(dataRoot, s2, boardMembers(dataRoot, s2, boardStore), rec.structure) };
+            }
+            if (op === "reconcile") {
+              const rec = reconcile(structure, memberTagSets(s2, boardMembers(dataRoot, s2, boardStore)));
+              if (read2 !== null && rec.changed) await writeStructure(rec.structure);
+              scheduleHasher();
+              return { seeded: read2 === null, ...resolveBoard(dataRoot, s2, boardMembers(dataRoot, s2, boardStore), rec.structure) };
+            }
+            throw new Error(`unknown board op: ${op || "(none)"}`);
           })
         ).then((body) => sendJson(res, 201, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
         return;
@@ -69660,7 +69837,7 @@ function createHandlers(dataRoot, opts = {}) {
       }
       if (url.pathname === "/api/content" || url.pathname.startsWith("/api/content/")) {
         (async () => {
-          if (!cachedDoc) await reconcile();
+          if (!cachedDoc) await reconcile2();
           const doc = cachedDoc;
           if (!doc) throw new Error("the merged document is unavailable (index rebuild failed)");
           const rest = url.pathname === "/api/content" ? "" : url.pathname.slice("/api/content/".length);
@@ -69809,6 +69986,15 @@ function createHandlers(dataRoot, opts = {}) {
         sendJson(res, 200, taggedMaterials(dataRoot, s2, p2));
         return;
       }
+      if (url.pathname === "/api/board") {
+        const row2 = s2.node(p2);
+        if (!row2) return notFound(res, url);
+        const read2 = readBoardStructure(s2, p2);
+        const members = boardMembers(dataRoot, s2, p2);
+        const { structure } = reconcile(read2 ?? seedBoardStructure(s2, p2), memberTagSets(s2, members));
+        sendJson(res, 200, { seeded: read2 === null, ...resolveBoard(dataRoot, s2, members, structure) });
+        return;
+      }
       if (url.pathname === "/api/tree") {
         const row2 = s2.node(p2);
         if (!row2) return notFound(res, url);
@@ -69841,15 +70027,18 @@ function createHandlers(dataRoot, opts = {}) {
           }
           return sendJson(res, 415, { error: `no thumbnail for format: ${fmt ?? "unknown"}` });
         }
-        const serve = (file) => {
+        const serve = (file, mime2 = "image/jpeg") => {
           res.statusCode = 200;
-          res.setHeader("Content-Type", "image/jpeg");
+          res.setHeader("Content-Type", mime2);
           res.setHeader("Content-Length", String(fs10.statSync(file).size));
           res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
           const stream = fs10.createReadStream(file);
           stream.on("error", () => res.destroy());
           stream.pipe(res);
         };
+        if (segs.some((g) => String(g) === OVERLAY_DIR)) {
+          return serve(sourceAbs, sourceAbs.endsWith(".png") ? "image/png" : "image/jpeg");
+        }
         const ready2 = existingThumb(dataRoot, s2, settings.sidecars, segs, sourceRow, w, h);
         if (ready2) return serve(ready2);
         if (readOnly) return sendJson(res, 415, { error: `thumbnail not pre-generated (read-only)` });
@@ -70272,21 +70461,131 @@ function pointerRaw(clientPath) {
   }
   return "::" + out;
 }
-function writeBoardLanes(src, lanes) {
-  const laneLine = (lane) => `- [${lane.map((p2) => pointerToken(pointerRaw(p2))).join(", ")}]`;
-  const block = lanes.length === 0 ? ["lanes: []"] : ["lanes:", ...lanes.map(laneLine)];
+var LANES_SUBKEY = "lanes";
+var BOARD_CONFIG_KEYS = /* @__PURE__ */ new Set(["workflow", "lanes", "yamlover", "ontos", YO_KEY2]);
+var TAGISH_FORMATS = /* @__PURE__ */ new Set([ONTO_FORMAT, "x-yamlover-workflow", "x-yamlover-board"]);
+function writeBoardStructure(src, structure) {
   let lines = src.replace(/\n+$/, "").split("\n");
   if (src.trim() === "") lines = ["!!<*yamlover:$defs:board>"];
-  const start = lines.findIndex((l2) => /^lanes:/.test(l2));
-  if (start >= 0) {
-    let end = start + 1;
-    while (end < lines.length && (lines[end] === "" || /^[ \t-]/.test(lines[end]))) end++;
-    lines.splice(start, end - start, ...block);
-  } else {
-    lines.push(...block);
-  }
+  const render = (indent) => {
+    const pad = " ".repeat(indent);
+    if (structure.length === 0) return [`${pad}lanes: []`];
+    const out = [`${pad}lanes:`];
+    const cpad = " ".repeat(indent + 2);
+    const bpad = " ".repeat(indent + 4);
+    for (const lane of structure) {
+      const comps = lane.length ? lane : [{ tags: [], items: [] }];
+      comps.forEach((comp, ci) => {
+        out.push(ci === 0 ? `${pad}- -` : `${cpad}-`);
+        for (const t3 of comp.tags) out.push(`${bpad}&${pointerRaw(t3)}:-`);
+        for (const it of comp.items)
+          out.push(it.key !== void 0 ? `${bpad}${keyToken(it.key)}: *${pointerRaw(it.path)}` : `${bpad}- *${pointerRaw(it.path)}`);
+      });
+    }
+    return out;
+  };
+  replaceSeqEntryAt(lines, reachBody(lines, [YO_KEY2]), LANES_SUBKEY, render);
   return lines.join("\n") + "\n";
 }
+function membershipPathsOf(s2, store) {
+  return s2.relationships(store).out.filter((e3) => e3.kind === "back" && e3.label == null).map((e3) => segsToStr(storePathToSegs(e3.to)));
+}
+function readBoardStructure(s2, boardStore) {
+  const lanesStore = childPath(childPath(boardStore, YO_KEY2), LANES_SUBKEY);
+  if (!s2.node(lanesStore)) return null;
+  return s2.children(lanesStore).map(
+    (lane) => s2.children(lane.to).map((comp) => ({
+      tags: membershipPathsOf(s2, comp.to),
+      items: s2.entries(comp.to).filter((e3) => e3.kind === "ref").map((e3) => ({ path: segsToStr(storePathToSegs(e3.to)), ...e3.label != null ? { key: e3.label } : {} }))
+    }))
+  );
+}
+function seedBoardStructure(s2, boardStore) {
+  const oldLanes = childPath(boardStore, LANES_SUBKEY);
+  if (s2.node(oldLanes)) {
+    return seedFromOldLanes(
+      s2.children(oldLanes).map(
+        (lane) => s2.entries(lane.to).filter((e3) => e3.kind === "ref" && e3.label == null).map((e3) => segsToStr(storePathToSegs(e3.to)))
+      )
+    );
+  }
+  const wf = s2.relationships(boardStore).out.find((e3) => e3.kind === "ref" && e3.label === "workflow");
+  if (wf) {
+    const children2 = s2.children(wf.to).filter((c3) => c3.label && c3.label !== "initial" && c3.label !== "color");
+    const ontos = children2.filter((c3) => s2.node(c3.to)?.format === ONTO_FORMAT);
+    return seedFromWorkflow((ontos.length ? ontos : children2).map((c3) => segsToStr(storePathToSegs(c3.to))));
+  }
+  return [];
+}
+function boardMembers(dataRoot, s2, boardStore) {
+  const out = [];
+  for (const c3 of s2.children(boardStore)) {
+    if (!c3.label || BOARD_CONFIG_KEYS.has(c3.label) || isHidden(s2, c3.to)) continue;
+    const n2 = s2.node(c3.to);
+    if (!n2 || n2.format && TAGISH_FORMATS.has(n2.format)) continue;
+    const segs = storePathToSegs(c3.to);
+    if (n2.type === "scalar" && s2.children(c3.to).length === 0 && !fs10.existsSync(path11.resolve(dataRoot, ...segs.map(String)))) continue;
+    out.push(segsToStr(segs));
+  }
+  return out;
+}
+function memberTagSets(s2, members) {
+  return new Map(members.map((p2) => [p2, new Set(membershipPathsOf(s2, storePath(strToSegs(p2))))]));
+}
+function boardCardStub(dataRoot, s2, p2) {
+  const segs = strToSegs(p2);
+  const store = storePath(segs);
+  const row = s2.node(store);
+  const field = (k) => {
+    const v = s2.node(childPath(store, k))?.value;
+    return v == null ? null : String(v);
+  };
+  return {
+    path: p2,
+    title: (row ? displayNameOf(s2, store) : null) ?? String(segs[segs.length - 1] ?? p2),
+    type: row ? tocType(s2, store, row) : null,
+    format: row?.format ?? null,
+    concrete: row ? concreteOf(s2, dataRoot, segs, row) : null,
+    priority: field("priority"),
+    assignee: field("assignee"),
+    due: field("due"),
+    // resolved refs, not bare paths — the card FACE shows its tags (names + colors)
+    tags: membershipPathsOf(s2, store).map((t3) => projectTag(s2, storePath(strToSegs(t3)))).filter(Boolean)
+  };
+}
+function resolveBoard(dataRoot, s2, members, structure) {
+  const inComp = /* @__PURE__ */ new Set();
+  const lanes = structure.map(
+    (lane) => lane.map((comp) => ({
+      tags: comp.tags.map((t3) => projectTag(s2, storePath(strToSegs(t3)))).filter(Boolean),
+      items: comp.items.map((it) => {
+        inComp.add(it.path);
+        return { ...boardCardStub(dataRoot, s2, it.path), ...it.key !== void 0 ? { key: it.key } : {} };
+      })
+    }))
+  );
+  const backlog = members.filter((p2) => !inComp.has(p2)).map((p2) => boardCardStub(dataRoot, s2, p2));
+  return { lanes, backlog };
+}
+function sanitizeBoardStructure(raw) {
+  if (!Array.isArray(raw)) throw new Error("board structure must be an array of lanes");
+  return raw.map(
+    (lane) => (Array.isArray(lane) ? lane : []).map((comp) => {
+      const c3 = comp;
+      return {
+        tags: Array.isArray(c3?.tags) ? c3.tags.map(String) : [],
+        items: Array.isArray(c3?.items) ? c3.items.map((it) => {
+          const o2 = it;
+          return { path: String(o2?.path ?? ""), ...o2?.key != null ? { key: String(o2.key) } : {} };
+        }).filter((it) => it.path !== "") : []
+      };
+    })
+  );
+}
+function boardCoord(v) {
+  const o2 = v;
+  return o2 != null && typeof o2.lane === "number" && typeof o2.comp === "number" ? { lane: o2.lane, comp: o2.comp } : null;
+}
 function overlaidDir(bodyFile) {
   if (bodyFile.endsWith(path11.join(OVERLAY_DIR, BODY_FILE2))) return path11.dirname(path11.dirname(bodyFile));
   return path11.basename(bodyFile) === INDEX_FILE2 ? path11.dirname(bodyFile) : null;
@@ -70436,15 +70735,34 @@ function embedAnnotation(dataRoot, s2, mode, a2) {
     writeBody(dataRoot, s2, bodyFile2, lines.join("\n") + "\n");
     return bodyFile2;
   }
+  const own = ownDocFile(dataRoot, segs);
+  if (own) {
+    writeBody(dataRoot, s2, own, appendBookmark(fs10.readFileSync(own, "utf8"), [], tokens));
+    return own;
+  }
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
   mkdirInside(dataRoot, path11.dirname(bodyFile), { recursive: true });
   const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
   writeBody(dataRoot, s2, bodyFile, appendBookmark(src, within, tokens));
   return bodyFile;
 }
+function ownDocFile(dataRoot, segs) {
+  if (segs.length === 0 || segs.some((s2) => typeof s2 === "number")) return null;
+  const abs = path11.resolve(dataRoot, ...segs.map(String));
+  if (!/\.(yo|yamlover)$/i.test(abs)) return null;
+  try {
+    return fs10.statSync(abs).isFile() ? abs : null;
+  } catch {
+    return null;
+  }
+}
 function embedFragment(dataRoot, s2, mode, f2) {
   const segs = strToSegs(f2.target || ":");
-  const slug = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const chosen = typeof f2.slug === "string" ? f2.slug.trim() : "";
+  if (chosen !== "" && s2.node(storePath([...segs, YO_KEY2, FRAGS_SUBKEY, chosen]))) {
+    throw new Error(`a fragment \`${chosen}\` already exists on this node`);
+  }
+  const slug = chosen !== "" ? chosen : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
   if (isChunkTarget(s2, segs)) {
     const { docSegs, bodyFile: bodyFile2 } = chapterSource(dataRoot, s2, segs);
     const { indices, keys } = splitChunkWithin(segs.slice(docSegs.length));
@@ -70457,7 +70775,7 @@ function embedFragment(dataRoot, s2, mode, f2) {
       /*ensureOmni*/
       true
     );
-    upsertMapEntryAt(lines, reachBodyAt(lines, region, [YO_KEY2]), FRAGS_SUBKEY, slug, (indent) => fragmentBlockLines(slug, f2.selector, null, indent));
+    upsertMapEntryAt(lines, reachBodyAt(lines, region, [YO_KEY2, FRAGS_SUBKEY]), slug, (indent) => fragmentBlockLines(slug, f2.selector, null, indent));
     writeBody(dataRoot, s2, bodyFile2, lines.join("\n") + "\n");
     return { slug, fragmentPath: segsToStr([...segs, YO_KEY2, FRAGS_SUBKEY, slug]) };
   }
@@ -70542,7 +70860,7 @@ function unembedAnnotation(dataRoot, s2, target, tag, sel) {
     ), keys);
     removeBookmarkAt(lines, fragRegion, pred);
     if (isFragmentSegs(keys) && !bookmarksRemainAt(lines, fragRegion())) {
-      removeMapEntryAt(lines, reachBodyAt(lines, chunkFieldRegion(lines, indices, false), keys.slice(0, -2)), FRAGS_SUBKEY, keys[keys.length - 1]);
+      removeMapEntryAt(lines, chunkFieldRegion(lines, indices, false), keys.slice(0, -1), keys[keys.length - 1]);
       pruneEmptyKeyAt(lines, chunkFieldRegion(lines, indices, false), YO_KEY2);
       collapseChunkOmni(lines, indices);
     } else if (keys.length === 0 && !bookmarksRemainAt(lines, fragRegion())) {
@@ -70551,12 +70869,21 @@ function unembedAnnotation(dataRoot, s2, target, tag, sel) {
     writeBody(dataRoot, s2, bodyFile2, lines.join("\n") + "\n");
     return bodyFile2;
   }
+  const own = ownDocFile(dataRoot, segs);
+  if (own) {
+    const before = fs10.readFileSync(own, "utf8");
+    const after = removeBookmark(before, [], pred);
+    if (after !== before) {
+      writeBody(dataRoot, s2, own, after);
+      return own;
+    }
+  }
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
   if (!fs10.existsSync(bodyFile)) return bodyFile;
   let src = removeBookmark(fs10.readFileSync(bodyFile, "utf8"), within, pred);
   const overlay2 = overlaidDir(bodyFile) !== null;
   if (isFragmentSegs(within) && !bookmarksRemain(src, within)) {
-    src = removeMapEntry(src, within.slice(0, -2), FRAGS_SUBKEY, within[within.length - 1]);
+    src = removeMapEntry(src, within.slice(0, -3), [YO_KEY2, FRAGS_SUBKEY], within[within.length - 1]);
     src = pruneEmptyYo(src, within.slice(0, -3));
     src = pruneEmptyAnnotations(src, within.slice(0, -3), overlay2);
   } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yamlover",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "description": "A local-first, editable knowledge graph for humans and LLMs: npx yamlover <root> serves a browser UI over a plain-text directory, with an editor, live queries, pointers, and an LLM-agent API.",
   "type": "module",
   "license": "MIT",