yamlover 0.3.2 → 0.3.4

package/dist/server.js

@@ -912,8 +912,8 @@ function walkNodes(node, path8, visit, parent = null, label = null, pos = null)
   if (!node.entries) return;
   node.entries.forEach((e2, i) => {
     if (isPointer(e2.value)) return;
-    const childPath = (path8 === ":" ? "" : path8) + (e2.key != null ? ":" + e2.key : "[" + i + "]");
-    walkNodes(e2.value, childPath, visit, path8, e2.key, i);
+    const childPath2 = (path8 === ":" ? "" : path8) + (e2.key != null ? ":" + e2.key : "[" + i + "]");
+    walkNodes(e2.value, childPath2, visit, path8, e2.key, i);
   });
 }
 function formatFromMeta(node) {
@@ -1465,7 +1465,7 @@ var Block = class {
   node(minIndent) {
     const l = this.peek();
     if (!l || l.indent < minIndent) return null;
-    if (/^!!(mix|omni|set)(?=\s|$)/.test(l.text)) {
+    if (/^!!(mix|var|omni|set)(?=\s|$)/.test(l.text)) {
       this.i++;
       return this.valueAfter(l.text, l.indent - 1, l.n, l.indent);
     }
@@ -1604,9 +1604,9 @@ var Block = class {
       ({ rest, col } = adv(rest, close + 1, col));
     }
     let typeTag;
-    const tag = /^!!(mix|omni|set)(?=\s|$)/.exec(rest);
+    const tag = /^!!(mix|var|omni|set)(?=\s|$)/.exec(rest);
     if (tag) {
-      typeTag = tag[1];
+      typeTag = tag[1] === "var" ? "omni" : tag[1];
       ({ rest, col } = adv(rest, tag[0].length, col));
     }
     const anchors = [];
@@ -2346,6 +2346,8 @@ async function walkTreeAsync(absDir, opts = {}) {
   return r.value;
 }
 var BUILTIN_TAG_SCHEMA = "type: object\nformat: x-yamlover-tag\nproperties:\n  color:\n    type: string\nadditionalProperties: *:: yamlover: $defs: tag\n";
+var BUILTIN_FRAGMENT_SCHEMA = "type: object\nformat: x-yamlover-fragment\n";
+var BUILTIN_ANNOTATION_SCHEMA = "type: variant\nformat: x-yamlover-annotation\n";
 var BUILTIN_TAGS_BODY = '!!<*yamlover:$defs:tag>\ncolors: The palette\n  yellow:\n    color: "#f9e2af"\n  green:\n    color: "#a6e3a1"\n  sky:\n    color: "#89dceb"\n  mauve:\n    color: "#cba6f7"\n  pink:\n    color: "#f5c2e7"\n  peach:\n    color: "#fab387"\n';
 var builtinTemplate = null;
 function builtinYamloverGraft() {
@@ -2354,15 +2356,29 @@ function builtinYamloverGraft() {
     tags: parseYamlover(BUILTIN_TAGS_BODY, "tags/.yamlover/body.yamlover").root
   };
   const tagCopy = structuredClone(builtinTemplate.tag);
+  const fragCopy = parseYamlover(BUILTIN_FRAGMENT_SCHEMA, "$defs/fragment").root;
+  const annCopy = parseYamlover(BUILTIN_ANNOTATION_SCHEMA, "$defs/annotation").root;
   const node = {
     kind: "mapping",
     array: false,
     entries: [
-      { key: "$defs", edge: "contain", value: { kind: "mapping", array: false, entries: [{ key: "tag", edge: "contain", value: tagCopy }] } },
+      {
+        key: "$defs",
+        edge: "contain",
+        value: {
+          kind: "mapping",
+          array: false,
+          entries: [
+            { key: "tag", edge: "contain", value: tagCopy },
+            { key: "fragment", edge: "contain", value: fragCopy },
+            { key: "annotation", edge: "contain", value: annCopy }
+          ]
+        }
+      },
       { key: "tags", edge: "contain", value: structuredClone(builtinTemplate.tags) }
     ]
   };
-  return { node, defs: /* @__PURE__ */ new Map([["tag", tagCopy]]) };
+  return { node, defs: /* @__PURE__ */ new Map([["tag", tagCopy], ["fragment", fragCopy], ["annotation", annCopy]]) };
 }
 function* walkTreeGen(absDir, opts = {}) {
   const ctx = { root: path.resolve(absDir), opts, files: /* @__PURE__ */ new Map(), count: 0 };
@@ -3567,6 +3583,157 @@ function compact(xs) {
   return xs.filter((x) => x !== null);
 }
 
+// src/server/embed.ts
+var ANNOTATIONS_KEY = "yamlover-annotations";
+var FRAGMENTS_KEY = "yamlover-fragments";
+var indentOf = (line) => {
+  let i = 0;
+  while (line[i] === " ") i++;
+  return i;
+};
+var isContentLine = (line) => {
+  const t2 = line.trim();
+  return t2.length > 0 && !t2.startsWith("#");
+};
+function firstContentIndent(lines) {
+  for (const l of lines) if (isContentLine(l)) return indentOf(l);
+  return 0;
+}
+function keyToken(key) {
+  return /^[A-Za-z0-9_][A-Za-z0-9_-]*$/.test(key) ? key : JSON.stringify(key);
+}
+function findKeyLine(lines, lo, hi, indent, key) {
+  const tok = keyToken(key);
+  for (let i = lo; i < hi; i++) {
+    if (!isContentLine(lines[i])) continue;
+    const ind = indentOf(lines[i]);
+    if (ind < indent) return -1;
+    if (ind !== indent) continue;
+    const t2 = lines[i].trim();
+    if (t2 === `${key}:` || t2.startsWith(`${key}: `) || t2 === `${tok}:` || t2.startsWith(`${tok}: `)) return i;
+  }
+  return -1;
+}
+function trimBack(lines, floor, end) {
+  let e2 = end;
+  while (e2 > floor + 1 && !isContentLine(lines[e2 - 1])) e2--;
+  return e2;
+}
+function blockEnd(lines, from, hi, indent) {
+  let last = from;
+  for (let i = from; i < hi; i++) {
+    if (!isContentLine(lines[i])) continue;
+    if (indentOf(lines[i]) < indent) return trimBack(lines, last, i);
+    last = i;
+  }
+  return trimBack(lines, last, hi);
+}
+function reachBody(lines, within) {
+  let lo = 0;
+  let hi = lines.length;
+  let indent = firstContentIndent(lines);
+  if (lines.length === 1 && lines[0] === "") {
+    lines.length = 0;
+    hi = 0;
+    indent = 0;
+  }
+  for (const key of within) {
+    const L = findKeyLine(lines, lo, hi, indent, key);
+    if (L < 0) {
+      const at = trimBack(lines, lo - 1, hi);
+      lines.splice(at, 0, `${" ".repeat(indent)}${keyToken(key)}:`);
+      lo = at + 1;
+      hi = at + 1;
+      indent += 2;
+      continue;
+    }
+    const inline = lines[L].slice(indentOf(lines[L])).slice(`${lines[L].trim().split(":")[0]}:`.length);
+    const bodyLo = L + 1;
+    const bodyHi = blockEnd(lines, bodyLo, hi, indent + 1);
+    let childIndent = indent + 2;
+    for (let i = bodyLo; i < bodyHi; i++) {
+      if (isContentLine(lines[i]) && indentOf(lines[i]) > indent) {
+        childIndent = indentOf(lines[i]);
+        break;
+      }
+    }
+    lo = bodyLo;
+    hi = bodyHi;
+    indent = childIndent;
+  }
+  return { lo, hi, indent };
+}
+function seqItemLines(lines, region, key) {
+  const keyLine = findKeyLine(lines, region.lo, region.hi, region.indent, key);
+  if (keyLine < 0) return null;
+  const items = [];
+  let end = keyLine + 1;
+  for (let i = keyLine + 1; i < region.hi; i++) {
+    if (!isContentLine(lines[i])) continue;
+    const ind = indentOf(lines[i]);
+    if (ind < region.indent) break;
+    if (ind === region.indent) {
+      const t2 = lines[i].trim();
+      if (t2 === "-" || t2.startsWith("- ")) {
+        items.push(i);
+        end = i;
+        continue;
+      }
+      break;
+    }
+    end = i;
+  }
+  return { keyLine, items, end: trimBack(lines, end, region.hi) };
+}
+function appendAnnotation(text, within, render) {
+  const lines = text.replace(/\n$/, "").split("\n");
+  const region = reachBody(lines, within);
+  const seq = seqItemLines(lines, region, ANNOTATIONS_KEY);
+  if (!seq) {
+    const at = trimBack(lines, region.lo - 1, region.hi);
+    lines.splice(at, 0, `${" ".repeat(region.indent)}${ANNOTATIONS_KEY}:`, ...render(region.indent));
+  } else {
+    lines.splice(seq.end, 0, ...render(region.indent));
+  }
+  return lines.join("\n") + "\n";
+}
+function upsertFragment(text, within, slug, render) {
+  const lines = text.replace(/\n$/, "").split("\n");
+  const region = reachBody(lines, within);
+  let fragKey = findKeyLine(lines, region.lo, region.hi, region.indent, FRAGMENTS_KEY);
+  if (fragKey < 0) {
+    const at = trimBack(lines, region.lo - 1, region.hi);
+    lines.splice(at, 0, `${" ".repeat(region.indent)}${FRAGMENTS_KEY}:`);
+    fragKey = at;
+  }
+  const mapIndent = region.indent + 2;
+  const mapBody = { lo: fragKey + 1, hi: blockEnd(lines, fragKey + 1, lines.length, region.indent + 1), indent: mapIndent };
+  const existing = findKeyLine(lines, mapBody.lo, mapBody.hi, mapIndent, slug);
+  if (existing >= 0) {
+    const end = blockEnd(lines, existing + 1, mapBody.hi, mapIndent + 1);
+    lines.splice(existing, end - existing, ...render(mapIndent));
+  } else {
+    const at = trimBack(lines, fragKey, mapBody.hi);
+    lines.splice(at, 0, ...render(mapIndent));
+  }
+  return lines.join("\n") + "\n";
+}
+function removeAnnotation(text, within, predicate) {
+  const lines = text.replace(/\n$/, "").split("\n");
+  const region = reachBody(lines, within);
+  const seq = seqItemLines(lines, region, ANNOTATIONS_KEY);
+  if (!seq) return text;
+  for (let k = 0; k < seq.items.length; k++) {
+    const i = seq.items[k];
+    const itemText = lines[i].trim().replace(/^-\s*/, "");
+    if (!predicate(itemText)) continue;
+    const next = k + 1 < seq.items.length ? seq.items[k + 1] : seq.end;
+    lines.splice(i, next - i);
+    return lines.join("\n") + "\n";
+  }
+  return text;
+}
+
 // src/server/gitignore.ts
 var import_ignore = __toESM(require_ignore(), 1);
 import fs5 from "node:fs";
@@ -3652,6 +3819,14 @@ function scalarType(v) {
   if (typeof v === "number") return Number.isInteger(v) ? "integer" : "number";
   return "string";
 }
+function facetsOf(s, p, row) {
+  const ents = ownedEntries(s, p);
+  return {
+    valueType: row.type === "scalar" ? scalarType(row.value) : row.type === "blob" ? "binary" : null,
+    hasKeyed: ents.some((e2) => e2.label !== null),
+    hasOrdinal: ents.some((e2) => e2.label === null)
+  };
+}
 
 // src/server/tasks.ts
 var PROGRESS_EMIT_MS = 150;
@@ -3899,31 +4074,40 @@ function createHandlers(dataRoot, opts = {}) {
       }
       if (req.method === "POST" && url.pathname === "/api/annotate") {
         readBody(req).then(
-          (data) => (
-            // Queued: an incremental row added while a full walk (whose disk snapshot predates
-            // this annotation) is committing would be silently swapped away.
-            enqueue(() => {
-              const a = data;
-              const tagStore = storePath(strToSegs(a.tag ?? ""));
-              if (!a?.tag || s.node(tagStore)?.format !== TAG_FORMAT) {
-                throw new Error("annotation needs a `tag` that is an x-yamlover-tag node");
-              }
-              const annPath = writeAnnotation(dataRoot, settings.annotations.location, a);
-              const doc = parseYamlover(fs6.readFileSync(path7.join(dataRoot, ...strToSegs(annPath).map(String)), "utf8"), annPath);
-              s.addAnnotation(storePath(strToSegs(annPath)), storePath(strToSegs(a.target)), doc, tagStore);
-              announce({ added: [relFileOf(annPath)] });
-              return { path: annPath };
-            })
-          )
+          (data) => enqueue(async () => {
+            const a = data;
+            const tagStore = storePath(strToSegs(a.tag ?? ""));
+            if (!a?.tag || s.node(tagStore)?.format !== TAG_FORMAT) {
+              throw new Error("annotation needs a `tag` that is an x-yamlover-tag node");
+            }
+            embedAnnotation(dataRoot, s, a);
+            broadcast(await doReindex());
+            scheduleHasher();
+            return { ok: true };
+          })
+        ).then((body) => sendJson(res, 201, body)).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/fragment") {
+        readBody(req).then(
+          (data) => enqueue(async () => {
+            const f = data;
+            if (!f?.selector || typeof f.selector !== "object") throw new Error("a fragment needs a selector");
+            const made = embedFragment(dataRoot, s, f);
+            broadcast(await doReindex());
+            scheduleHasher();
+            return made;
+          })
         ).then((body) => sendJson(res, 201, body)).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
         return;
       }
       if (req.method === "DELETE" && url.pathname === "/api/annotate") {
-        const annPath = url.searchParams.get("path") || "";
-        enqueue(() => {
-          deleteAnnotation(dataRoot, s, annPath);
-          s.removeAnnotation(storePath(strToSegs(annPath)));
-          announce({ removed: [relFileOf(annPath)] });
+        const target = url.searchParams.get("target") ?? "";
+        const tag = url.searchParams.get("tag") || "";
+        enqueue(async () => {
+          if (!tag) throw new Error("delete needs a `tag`");
+          unembedAnnotation(dataRoot, s, target, tag);
+          broadcast(await doReindex());
         }).then(() => sendJson(res, 200, { ok: true })).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
         return;
       }
@@ -4023,6 +4207,8 @@ function createHandlers(dataRoot, opts = {}) {
           path: segsToStr(segs),
           type: tocType(s, p, row),
           format: row.format ?? null,
+          ...facetsOf(s, p, row),
+          // valueType / hasKeyed / hasOrdinal — the renderer dispatch facets (TYPES.md §9)
           concrete: concreteOf(dataRoot, segs, row),
           // dir | yamlover | null (stat-derived; engine tracks no per-node concrete yet)
           documentPath: documentPath(s, segs),
@@ -4148,7 +4334,7 @@ function linkMarker(dataRoot, s, segs) {
   const p = storePath(segs);
   const row = s.node(p);
   const k = displayKind(s, p, row);
-  const info = { kind: k, type: tocType(s, p, row), path: segsToStr(segs) };
+  const info = { kind: k, type: tocType(s, p, row), ...facetsOf(s, p, row), path: segsToStr(segs) };
   if (row.format) info.format = row.format;
   const concrete = concreteOf(dataRoot, segs, row);
   if (concrete) info.concrete = concrete;
@@ -4207,6 +4393,7 @@ function buildTree(dataRoot, s, segs, label, depth) {
     label,
     type: tocType(s, p, row),
     format: row.format ?? null,
+    ...facetsOf(s, p, row),
     concrete: concreteOf(dataRoot, segs, row),
     hasChildren: s.hasChildren(p),
     children: []
@@ -4225,45 +4412,77 @@ function labelFor(s, p, keyOrIdx) {
   return typeof keyOrIdx === "number" ? `[${keyOrIdx}]` : keyOrIdx;
 }
 var TAG_FORMAT = "x-yamlover-tag";
-function appliedTag(s, annStorePath) {
-  const e2 = s.relationships(annStorePath).out.find(
-    (t2) => t2.kind === "back" && t2.label === null && s.node(t2.to)?.format === TAG_FORMAT
-  );
-  if (!e2) return null;
-  const segs = storePathToSegs(e2.to);
-  const color = s.node(e2.to + ":color")?.value;
+var ANN_KEY = "yamlover-annotations";
+var FRAG_KEY = "yamlover-fragments";
+var CROP_DIR = "fragments";
+var childPath = (parent, key) => (parent === ":" ? "" : parent) + ":" + key;
+function projectTag(s, tagStore) {
+  if (s.node(tagStore)?.format !== TAG_FORMAT) return null;
+  const segs = storePathToSegs(tagStore);
+  const color = s.node(tagStore + ":color")?.value;
   return { path: segsToStr(segs), name: String(segs[segs.length - 1] ?? ""), color: typeof color === "string" ? color : null };
 }
+function readAnnotations(s, hostStore) {
+  const arr = childPath(hostStore, ANN_KEY);
+  if (!s.node(arr)) return [];
+  const out = [];
+  for (const e2 of s.entries(arr)) {
+    if (e2.kind === "ref") {
+      const tag = projectTag(s, e2.to);
+      if (tag) out.push({ tag });
+    } else if (e2.kind === "contain") {
+      const tagEdge = s.relationships(e2.to).out.find((o) => o.kind === "ref" && o.label === "tag");
+      const tag = tagEdge ? projectTag(s, tagEdge.to) : null;
+      if (!tag) continue;
+      const params = {};
+      let description;
+      for (const c of s.children(e2.to)) {
+        const v = s.node(c.to)?.value;
+        if (c.label === "description") description = v == null ? void 0 : String(v);
+        else if (c.label) params[c.label] = v;
+      }
+      out.push({ tag, description, params: Object.keys(params).length ? params : void 0 });
+    }
+  }
+  return out;
+}
+function readFragments(s, hostStore) {
+  const frags = childPath(hostStore, FRAG_KEY);
+  if (!s.node(frags)) return [];
+  const out = [];
+  for (const fc of s.children(frags)) {
+    if (!fc.label) continue;
+    const selector = {};
+    for (const c of s.children(fc.to)) {
+      if (c.label && c.label !== ANN_KEY && c.label !== "created") selector[c.label] = s.node(c.to)?.value;
+    }
+    const imgEdge = s.relationships(fc.to).out.find((o) => o.kind === "ref" && o.label === "image");
+    const imageUrl = imgEdge ? `/api/blob?path=${encodeURIComponent(segsToStr(storePathToSegs(imgEdge.to)))}` : void 0;
+    out.push({ slug: fc.label, node: fc.to, selector, imageUrl });
+  }
+  return out;
+}
 function annotationsFor(dataRoot, s, segs) {
   const p = storePath(segs);
   const out = [];
-  for (const e2 of s.relationships(p).in) {
-    if (e2.kind !== "ref") continue;
-    const src = s.node(e2.from);
-    if (src?.format !== "x-yamlover-annotation") continue;
-    const aSegs = storePathToSegs(e2.from);
-    out.push({
-      path: segsToStr(aSegs),
-      tag: appliedTag(s, e2.from),
-      ...projectValue(dataRoot, s, aSegs, 6, true)
-    });
+  for (const a of readAnnotations(s, p)) out.push({ ...a });
+  for (const f of readFragments(s, p)) {
+    for (const a of readAnnotations(s, f.node)) {
+      out.push({ ...a, selector: f.selector, fragmentSlug: f.slug, ...f.imageUrl ? { imageUrl: f.imageUrl } : {} });
+    }
   }
   return out;
 }
 function taggedMaterials(dataRoot, s, tagStorePath) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const backs = s.relationships(tagStorePath).in.filter((e2) => e2.kind === "back" && e2.from).sort((a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : 0);
-  for (const e2 of backs) {
-    let material = e2.from;
-    if (s.node(e2.from)?.format === "x-yamlover-annotation") {
-      const t2 = s.relationships(e2.from).out.find((o) => o.kind === "ref" && o.label === "target");
-      if (!t2) continue;
-      material = t2.to;
-    }
-    if (seen.has(material) || !s.node(material)) continue;
-    seen.add(material);
-    out.push(linkMarker(dataRoot, s, storePathToSegs(material)));
+  const ins = s.relationships(tagStorePath).in.filter((e2) => (e2.kind === "ref" || e2.kind === "back") && e2.from).sort((a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : 0);
+  for (const e2 of ins) {
+    const arrOwner = e2.from.replace(/\[\d+\]$/, "").match(/^(.*):yamlover-annotations$/);
+    const owner = arrOwner ? arrOwner[1] || ":" : e2.from;
+    if (owner === tagStorePath || seen.has(owner) || !s.node(owner)) continue;
+    seen.add(owner);
+    out.push(linkMarker(dataRoot, s, storePathToSegs(owner)));
   }
   return out;
 }
@@ -4277,25 +4496,77 @@ function pointerRaw(clientPath) {
 function yScalar(v) {
   return typeof v === "number" || typeof v === "boolean" ? String(v) : JSON.stringify(String(v ?? ""));
 }
-function writeAnnotation(dataRoot, location, a) {
-  if (!a?.target || !a?.tag) throw new Error("annotation needs a target and a tag");
-  const dir = path7.resolve(dataRoot, ...strToSegs(location).map(String));
-  const root = path7.resolve(dataRoot);
-  if (dir !== root && !dir.startsWith(root + path7.sep)) throw new Error("annotation location escapes the data root");
-  fs6.mkdirSync(dir, { recursive: true });
-  const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  const file = `${id}.yamlover`;
-  const lines = [
-    "!!<*yamlover/$defs/annotation>",
-    `target: ${pointerToken(pointerRaw(a.target))}`,
-    anchorToken(`${pointerRaw(a.tag)}[]`)
-    // the applied tag holds me (ordinal path anchor)
-  ];
-  if (a.selector) lines.push("selector:", ...Object.entries(a.selector).map(([k, v]) => `  ${k}: ${yScalar(v)}`));
-  if (a.description) lines.push(`description: ${yScalar(a.description)}`);
-  lines.push(`created: ${(/* @__PURE__ */ new Date()).toISOString()}`, "");
-  fs6.writeFileSync(path7.join(dir, file), lines.join("\n"));
-  return `${location}:${file}`;
+function hostFor(dataRoot, s, segs) {
+  for (let i = segs.length; i >= 0; i--) {
+    const sub = segs.slice(0, i);
+    const abs = path7.resolve(dataRoot, ...sub.map(String));
+    let st;
+    try {
+      st = fs6.statSync(abs);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) return { bodyFile: path7.join(abs, ".yamlover", "body.yamlover"), within: segs.slice(i).map(String) };
+    if (st.isFile()) {
+      const node = s.node(storePath(sub));
+      if (node?.meta?.documentRoot && node.type === "mapping" && !node.is_array) {
+        return { bodyFile: abs, within: segs.slice(i).map(String) };
+      }
+      const dir = path7.resolve(dataRoot, ...sub.slice(0, -1).map(String));
+      return { bodyFile: path7.join(dir, ".yamlover", "body.yamlover"), within: segs.slice(i - 1).map(String) };
+    }
+  }
+  return { bodyFile: path7.join(dataRoot, ".yamlover", "body.yamlover"), within: segs.map(String) };
+}
+function annotationItemLines(a, indent) {
+  const pad = " ".repeat(indent);
+  const ptr = pointerToken(pointerRaw(a.tag));
+  const params = { ...a.params ?? {} };
+  if (a.description != null && a.description !== "") params.description = a.description;
+  const keys = Object.keys(params);
+  if (keys.length === 0) return [`${pad}- ${ptr}`];
+  return [`${pad}- tag: ${ptr}`, ...keys.map((k) => `${pad}  ${keyToken(k)}: ${yScalar(params[k])}`)];
+}
+function fragmentBlockLines(slug, selector, imagePtr, indent) {
+  const pad = " ".repeat(indent);
+  const lines = [`${pad}${keyToken(slug)}: !!<*::yamlover:$defs:fragment>`];
+  for (const [k, v] of Object.entries(selector)) lines.push(`${pad}  ${keyToken(k)}: ${yScalar(v)}`);
+  if (imagePtr) lines.push(`${pad}  image: ${imagePtr}`);
+  lines.push(`${pad}  created: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  return lines;
+}
+function embedAnnotation(dataRoot, s, a) {
+  const { bodyFile, within } = hostFor(dataRoot, s, strToSegs(a.target || ":"));
+  fs6.mkdirSync(path7.dirname(bodyFile), { recursive: true });
+  const src = fs6.existsSync(bodyFile) ? fs6.readFileSync(bodyFile, "utf8") : "";
+  fs6.writeFileSync(bodyFile, appendAnnotation(src, within, (indent) => annotationItemLines(a, indent)));
+}
+function embedFragment(dataRoot, s, f) {
+  const segs = strToSegs(f.target || ":");
+  const { bodyFile, within } = hostFor(dataRoot, s, segs);
+  const slug = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  let imagePtr = null;
+  if (f.imageBase64) {
+    const bytes = Buffer.from(String(f.imageBase64).replace(/^data:[^,]*,/, ""), "base64");
+    if (bytes.length > 0) {
+      const cropDir = path7.join(dataRoot, CROP_DIR);
+      fs6.mkdirSync(cropDir, { recursive: true });
+      const cropName = `${slug}.png`;
+      writeInside(dataRoot, cropDir, cropName, bytes);
+      imagePtr = pointerToken(pointerRaw(segsToStr([CROP_DIR, cropName])));
+    }
+  }
+  fs6.mkdirSync(path7.dirname(bodyFile), { recursive: true });
+  const src = fs6.existsSync(bodyFile) ? fs6.readFileSync(bodyFile, "utf8") : "";
+  fs6.writeFileSync(bodyFile, upsertFragment(src, within, slug, (indent) => fragmentBlockLines(slug, f.selector, imagePtr, indent)));
+  return { slug, fragmentPath: segsToStr([...segs, FRAG_KEY, slug]) };
+}
+function unembedAnnotation(dataRoot, s, target, tag) {
+  const { bodyFile, within } = hostFor(dataRoot, s, strToSegs(target || ":"));
+  if (!fs6.existsSync(bodyFile)) return;
+  const needle = pointerRaw(tag);
+  const src = fs6.readFileSync(bodyFile, "utf8");
+  fs6.writeFileSync(bodyFile, removeAnnotation(src, within, (itemText) => itemText.includes(needle)));
 }
 function writeTag(dataRoot, location, name) {
   if (/[/\\\r\n:]/.test(name)) throw new Error("a tag name cannot contain '/', '\\', ':' or line breaks");
@@ -4306,7 +4577,7 @@ function writeTag(dataRoot, location, name) {
   const createdFile = !fs6.existsSync(file);
   const head = "# Named tags created from the annotation picker (settings.yamlover: tags.location).\n";
   const existing = createdFile ? head : fs6.readFileSync(file, "utf8");
-  const body = (existing === "" || existing.endsWith("\n") ? existing : existing + "\n") + `${name}: !!<*yamlover/$defs/tag>
+  const body = (existing === "" || existing.endsWith("\n") ? existing : existing + "\n") + `${name}: !!<*::yamlover:$defs:tag>
 `;
   const entries = parseYamlover(body, file).root.entries ?? [];
   const pos = entries.findIndex((e2) => e2.key === name);
@@ -4318,16 +4589,6 @@ function writeTag(dataRoot, location, name) {
   fs6.writeFileSync(file, body);
   return { node: entry.value, pos, file: [...strToSegs(location).map(String), ".yamlover", "body.yamlover"].join("/"), createdFile };
 }
-function deleteAnnotation(dataRoot, s, annPath) {
-  const segs = strToSegs(annPath);
-  if (!String(segs[segs.length - 1] ?? "").endsWith(".yamlover")) throw new Error("not an annotation file");
-  if (s.node(storePath(segs))?.format !== "x-yamlover-annotation") throw new Error("not an annotation node");
-  const root = path7.resolve(dataRoot);
-  const file = path7.resolve(dataRoot, ...segs.map(String));
-  if (!file.startsWith(root + path7.sep)) throw new Error("outside the served root");
-  if (!fs6.existsSync(file) || fs6.statSync(file).isDirectory()) throw new Error("not an annotation file");
-  fs6.rmSync(file, { force: true });
-}
 function handlePaste(dataRoot, s, input) {
   const segs = strToSegs(input.path || ":");
   const row = s.node(storePath(segs));
@@ -4398,7 +4659,7 @@ function pasteTextAsChapterFile(dataRoot, segs, text) {
   const dir = path7.resolve(dataRoot, ...dirSegs.map(String));
   const title = titleFromText(text);
   const final = uniqueName(dir, chapterFileName(title));
-  const src = ["!!<*yamlover/$defs/chapter>", `title: ${JSON.stringify(title)}`, "chunks:", ...textChunkLines(text, 0), ""].join("\n");
+  const src = ["!!<*::yamlover:$defs:chapter>", `title: ${JSON.stringify(title)}`, "chunks:", ...textChunkLines(text, 0), ""].join("\n");
   writeInside(dataRoot, dir, final, Buffer.from(src, "utf8"));
   return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
 }
@@ -4486,7 +4747,7 @@ function pasteRichAsChapter(dataRoot, segs, rich) {
   return { path: segsToStr([...dirSegs, name]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
 }
 function renderChapterSource(title, rich, pointerFor) {
-  const lines = ["!!<*yamlover/$defs/chapter>", `title: ${JSON.stringify(title)}`];
+  const lines = ["!!<*::yamlover:$defs:chapter>", `title: ${JSON.stringify(title)}`];
   if (rich.chunks.length) lines.push("chunks:", ...rich.chunks.flatMap((c) => richItemLines(c, 0, pointerFor)));
   if (rich.children.length) lines.push("children:", ...rich.children.flatMap((k) => richChildLines(k, 0, pointerFor)));
   return lines.join("\n") + "\n";
@@ -4522,12 +4783,12 @@ function writeInside(dataRoot, dir, name, bytes) {
   if (target !== root && !target.startsWith(root + path7.sep)) throw new Error("target escapes the data root");
   fs6.writeFileSync(target, bytes);
 }
-var indentOf = (line) => {
+var indentOf2 = (line) => {
   let i = 0;
   while (line[i] === " ") i++;
   return i;
 };
-var isContentLine = (line) => {
+var isContentLine2 = (line) => {
   const t2 = line.trim();
   return t2.length > 0 && !t2.startsWith("#");
 };
@@ -4543,10 +4804,10 @@ function appendToList(text, chapterPath, key, renderItems) {
   const lines = text.split("\n");
   let lo = 0;
   let hi = lines.length;
-  let indent = firstContentIndent(lines);
+  let indent = firstContentIndent2(lines);
   for (let i = 0; i < chapterPath.length; i += 2) {
     const idx = Number(chapterPath[i + 1]);
-    const kids = findKeyLine(lines, lo, hi, indent, "children");
+    const kids = findKeyLine2(lines, lo, hi, indent, "children");
     if (kids < 0) throw new Error(`no 'children:' at indent ${indent}`);
     const items = seqItems(lines, kids + 1, hi, indent);
     if (!(idx >= 0 && idx < items.length)) throw new Error(`children[${idx}] out of range (${items.length})`);
@@ -4554,9 +4815,9 @@ function appendToList(text, chapterPath, key, renderItems) {
     lo = items[idx] + 1;
     indent += 2;
   }
-  const keyLine = findKeyLine(lines, lo, hi, indent, key);
+  const keyLine = findKeyLine2(lines, lo, hi, indent, key);
   if (keyLine < 0) {
-    const end = trimBack(lines, lo - 1, hi);
+    const end = trimBack2(lines, lo - 1, hi);
     lines.splice(end, 0, `${" ".repeat(indent)}${key}:`, ...renderItems(indent));
   } else {
     const end = seqEnd(lines, keyLine + 1, hi, indent);
@@ -4564,14 +4825,14 @@ function appendToList(text, chapterPath, key, renderItems) {
   }
   return lines.join("\n");
 }
-function firstContentIndent(lines) {
-  for (const l of lines) if (isContentLine(l)) return indentOf(l);
+function firstContentIndent2(lines) {
+  for (const l of lines) if (isContentLine2(l)) return indentOf2(l);
   return 0;
 }
-function findKeyLine(lines, lo, hi, indent, key) {
+function findKeyLine2(lines, lo, hi, indent, key) {
   for (let i = lo; i < hi; i++) {
-    if (!isContentLine(lines[i])) continue;
-    const ind = indentOf(lines[i]);
+    if (!isContentLine2(lines[i])) continue;
+    const ind = indentOf2(lines[i]);
     if (ind < indent) return -1;
     if (ind !== indent) continue;
     const t2 = lines[i].trim();
@@ -4582,8 +4843,8 @@ function findKeyLine(lines, lo, hi, indent, key) {
 function seqItems(lines, from, hi, indent) {
   const out = [];
   for (let i = from; i < hi; i++) {
-    if (!isContentLine(lines[i])) continue;
-    const ind = indentOf(lines[i]);
+    if (!isContentLine2(lines[i])) continue;
+    const ind = indentOf2(lines[i]);
     if (ind < indent) break;
     if (ind !== indent) continue;
     const t2 = lines[i].trim();
@@ -4595,24 +4856,24 @@ function seqItems(lines, from, hi, indent) {
 function seqEnd(lines, from, hi, indent) {
   let last = from;
   for (let i = from; i < hi; i++) {
-    if (!isContentLine(lines[i])) continue;
-    const ind = indentOf(lines[i]);
-    if (ind < indent) return trimBack(lines, last, i);
+    if (!isContentLine2(lines[i])) continue;
+    const ind = indentOf2(lines[i]);
+    if (ind < indent) return trimBack2(lines, last, i);
     if (ind === indent) {
       const t2 = lines[i].trim();
       if (t2 === "-" || t2.startsWith("- ")) {
         last = i;
         continue;
       }
-      return trimBack(lines, last, i);
+      return trimBack2(lines, last, i);
     }
     last = i;
   }
-  return trimBack(lines, last, hi);
+  return trimBack2(lines, last, hi);
 }
-function trimBack(lines, lastItemLine, end) {
+function trimBack2(lines, lastItemLine, end) {
   let e2 = end;
-  while (e2 > lastItemLine + 1 && !isContentLine(lines[e2 - 1])) e2--;
+  while (e2 > lastItemLine + 1 && !isContentLine2(lines[e2 - 1])) e2--;
   return e2;
 }
 function readBody(req) {