yamlover 0.3.49 → 0.3.50

package/dist/server.js

@@ -5760,14 +5760,14 @@ var require_gifutil = __commonJS({
       jimpImage.bitmap.data = bitmapImageToShare.bitmap.data;
       return jimpImage;
     };
-    exports.write = function(path11, frames, spec, encoder) {
+    exports.write = function(path12, frames, spec, encoder) {
       encoder = encoder || defaultCodec;
-      const matches = path11.match(/\.[a-zA-Z]+$/);
+      const matches = path12.match(/\.[a-zA-Z]+$/);
       if (matches !== null && INVALID_SUFFIXES.includes(matches[0].toLowerCase())) {
-        throw new Error(`GIF '${path11}' has an unexpected suffix`);
+        throw new Error(`GIF '${path12}' has an unexpected suffix`);
       }
       return encoder.encodeGif(frames, spec).then((gif2) => {
-        return _writeBinary(path11, gif2.buffer).then(() => {
+        return _writeBinary(path12, gif2.buffer).then(() => {
           return gif2;
         });
       });
@@ -5839,9 +5839,9 @@ var require_gifutil = __commonJS({
         }
       }
     }
-    function _readBinary(path11) {
+    function _readBinary(path12) {
       return new Promise((resolve3, reject) => {
-        fs11.readFile(path11, (err, buffer) => {
+        fs11.readFile(path12, (err, buffer) => {
           if (err) {
             return reject(err);
           }
@@ -5849,9 +5849,9 @@ var require_gifutil = __commonJS({
         });
       });
     }
-    function _writeBinary(path11, buffer) {
+    function _writeBinary(path12, buffer) {
       return new Promise((resolve3, reject) => {
-        fs11.writeFile(path11, buffer, (err) => {
+        fs11.writeFile(path12, buffer, (err) => {
           if (err) {
             return reject(err);
           }
@@ -7861,9 +7861,9 @@ var require_decoder = __commonJS({
         return a2 < 0 ? 0 : a2 > 255 ? 255 : a2;
       }
       constructor.prototype = {
-        load: function load(path11) {
+        load: function load(path12) {
           var xhr = new XMLHttpRequest();
-          xhr.open("GET", path11, true);
+          xhr.open("GET", path12, true);
           xhr.responseType = "arraybuffer";
           xhr.onload = function() {
             var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);
@@ -18725,8 +18725,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path11, errorMaps, issueData } = params;
-      const fullPath = [...path11, ...issueData.path || []];
+      const { data, path: path12, errorMaps, issueData } = params;
+      const fullPath = [...path12, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -19034,11 +19034,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path11, key) {
+      constructor(parent, value, path12, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path11;
+        this._path = path12;
         this._key = key;
       }
       get path() {
@@ -24036,11 +24036,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path11) {
-      path11 = String(path11);
-      let last = path11.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path12) {
+      path12 = String(path12);
+      let last = path12.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path11.length;
+      let hasPath = last.length < path12.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -30577,8 +30577,8 @@ function isTokenizerStreamBoundsError(error) {
   }
   return /strtok3[/\\]lib[/\\]stream[/\\]/.test(error.stack);
 }
-async function fileTypeFromFile(path11, options) {
-  return new FileTypeParser2(options).fromFile(path11, options);
+async function fileTypeFromFile(path12, options) {
+  return new FileTypeParser2(options).fromFile(path12, options);
 }
 async function fileTypeFromStream(stream, options) {
   return new FileTypeParser2(options).fromStream(stream);
@@ -30609,9 +30609,9 @@ var init_file_type = __esm({
           }
         }
       }
-      async fromFile(path11) {
+      async fromFile(path12) {
         this.options.signal?.throwIfAborted();
-        const fileHandle = await fs7.open(path11, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
+        const fileHandle = await fs7.open(path12, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
         const fileStat = await fileHandle.stat();
         if (!fileStat.isFile()) {
           await fileHandle.close();
@@ -30620,7 +30620,7 @@ var init_file_type = __esm({
         const tokenizer = new FileTokenizer(fileHandle, {
           ...this.getTokenizerOptions(),
           fileInfo: {
-            path: path11,
+            path: path12,
             size: fileStat.size
           }
         });
@@ -30955,9 +30955,9 @@ function createJimp({ plugins: pluginsArg, formats: formatsArg } = {}) {
      * await image.write("test/output.png");
      * ```
      */
-    async write(path11, options) {
-      const mimeType = import_lite.default.getType(path11);
-      await writeFile(path11, await this.getBuffer(mimeType, options));
+    async write(path12, options) {
+      const mimeType = import_lite.default.getType(path12);
+      await writeFile(path12, await this.getBuffer(mimeType, options));
     }
     /**
      * Clone the image into a new Jimp instance.
@@ -42379,7 +42379,7 @@ var init_simpleXmlToJson_min = __esm({
 });
 
 // ../../node_modules/@jimp/plugin-print/dist/esm/load-bitmap-font.js
-import path7 from "path";
+import path8 from "path";
 function isBinary(buf) {
   if (typeof buf === "string") {
     return buf.substring(0, 3) === "BMF";
@@ -42470,7 +42470,7 @@ async function processBitmapFont(file, font) {
     ...font,
     chars,
     kernings,
-    pages: await Promise.all(font.pages.map(async (page) => CharacterJimp.read(path7.join(path7.dirname(file), page))))
+    pages: await Promise.all(font.pages.map(async (page) => CharacterJimp.read(path8.join(path8.dirname(file), page))))
   };
 }
 var import_parse_bmfont_ascii, import_parse_bmfont_xml, import_parse_bmfont_binary, convertXML, isWebWorker, CharacterJimp, HEADER;
@@ -48594,8 +48594,8 @@ var require_descriptor = __commonJS({
           var sig = (0, psdReader_1.readSignature)(reader);
           (0, psdReader_1.readInt32LE)(reader);
           var charsCount = (0, psdReader_1.readInt32LE)(reader);
-          var path11 = (0, psdReader_1.readUnicodeStringWithLengthLE)(reader, charsCount);
-          return { sig, path: path11 };
+          var path12 = (0, psdReader_1.readUnicodeStringWithLengthLE)(reader, charsCount);
+          return { sig, path: path12 };
         }
         default:
           throw new Error("Invalid TySh descriptor OSType: ".concat(type2, " at ").concat(reader.offset.toString(16)));
@@ -54366,7 +54366,7 @@ var require_additionalInfo = __commonJS({
     function readVectorMask(reader, vectorMask, width, height, size) {
       var end = reader.offset + size;
       var paths = vectorMask.paths;
-      var path11 = void 0;
+      var path12 = void 0;
       while (end - reader.offset >= 26) {
         var selector = (0, psdReader_1.readUint16)(reader);
         switch (selector) {
@@ -54376,21 +54376,21 @@ var require_additionalInfo = __commonJS({
             var boolOp = (0, psdReader_1.readInt16)(reader);
             var flags = (0, psdReader_1.readUint16)(reader);
             (0, psdReader_1.skipBytes)(reader, 18);
-            path11 = {
+            path12 = {
               open: selector === 3,
               knots: [],
               fillRule: flags === 2 ? "non-zero" : "even-odd"
             };
             if (boolOp !== -1)
-              path11.operation = exports.booleanOperations[boolOp];
-            paths.push(path11);
+              path12.operation = exports.booleanOperations[boolOp];
+            paths.push(path12);
             break;
           }
           case 1:
           case 2:
           case 4:
           case 5:
-            path11.knots.push({ linked: selector === 1 || selector === 4, points: readBezierKnot(reader, width, height) });
+            path12.knots.push({ linked: selector === 1 || selector === 4, points: readBezierKnot(reader, width, height) });
             break;
           case 6:
             (0, psdReader_1.skipBytes)(reader, 24);
@@ -54450,15 +54450,15 @@ var require_additionalInfo = __commonJS({
       (0, psdWriter_1.writeUint16)(writer, vectorMask.fillStartsWithAllPixels ? 1 : 0);
       (0, psdWriter_1.writeZeros)(writer, 22);
       for (var _i = 0, _b = vectorMask.paths; _i < _b.length; _i++) {
-        var path11 = _b[_i];
-        (0, psdWriter_1.writeUint16)(writer, path11.open ? 3 : 0);
-        (0, psdWriter_1.writeUint16)(writer, path11.knots.length);
-        (0, psdWriter_1.writeUint16)(writer, path11.operation ? exports.booleanOperations.indexOf(path11.operation) : -1);
-        (0, psdWriter_1.writeUint16)(writer, path11.fillRule === "non-zero" ? 2 : 1);
+        var path12 = _b[_i];
+        (0, psdWriter_1.writeUint16)(writer, path12.open ? 3 : 0);
+        (0, psdWriter_1.writeUint16)(writer, path12.knots.length);
+        (0, psdWriter_1.writeUint16)(writer, path12.operation ? exports.booleanOperations.indexOf(path12.operation) : -1);
+        (0, psdWriter_1.writeUint16)(writer, path12.fillRule === "non-zero" ? 2 : 1);
         (0, psdWriter_1.writeZeros)(writer, 18);
-        var linkedKnot = path11.open ? 4 : 1;
-        var unlinkedKnot = path11.open ? 5 : 2;
-        for (var _c = 0, _d = path11.knots; _c < _d.length; _c++) {
+        var linkedKnot = path12.open ? 4 : 1;
+        var unlinkedKnot = path12.open ? 5 : 2;
+        for (var _c = 0, _d = path12.knots; _c < _d.length; _c++) {
           var _e = _d[_c], linked = _e.linked, points = _e.points;
           (0, psdWriter_1.writeUint16)(writer, linked ? linkedKnot : unlinkedKnot);
           writeBezierKnot(writer, points, width, height);
@@ -56177,12 +56177,12 @@ var require_additionalInfo = __commonJS({
                       _name: "",
                       _classID: "PaCm",
                       shapeOperation: "shapeOperation.".concat(c3.shapeOperation),
-                      SbpL: c3.paths.map(function(path11) {
+                      SbpL: c3.paths.map(function(path12) {
                         return {
                           _name: "",
                           _classID: "Sbpl",
-                          Clsp: path11.closed,
-                          "Pts ": path11.points.map(function(pt) {
+                          Clsp: path12.closed,
+                          "Pts ": path12.points.map(function(pt) {
                             return {
                               _name: "",
                               _classID: "Pthp",
@@ -59210,11 +59210,11 @@ var init_webp_dec = __esm({
         var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
         var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
         var scriptDirectory = "";
-        function locateFile(path11) {
+        function locateFile(path12) {
           if (Module3["locateFile"]) {
-            return Module3["locateFile"](path11, scriptDirectory);
+            return Module3["locateFile"](path12, scriptDirectory);
           }
-          return scriptDirectory + path11;
+          return scriptDirectory + path12;
         }
         var read_, readAsync, readBinary2, setWindowTitle;
         if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
@@ -60650,11 +60650,11 @@ var init_avif_dec = __esm({
         var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
         var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
         var scriptDirectory = "";
-        function locateFile(path11) {
+        function locateFile(path12) {
           if (Module3["locateFile"]) {
-            return Module3["locateFile"](path11, scriptDirectory);
+            return Module3["locateFile"](path12, scriptDirectory);
           }
-          return scriptDirectory + path11;
+          return scriptDirectory + path12;
         }
         var read_, readAsync, readBinary2;
         if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
@@ -62171,17 +62171,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path11, originalPath, doThrow) => {
-      if (!isString(path11)) {
+    var checkPath = (path12, originalPath, doThrow) => {
+      if (!isString(path12)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path11) {
+      if (!path12) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path11)) {
+      if (checkPath.isNotRelative(path12)) {
         const r2 = "`path.relative()`d";
         return doThrow(
           `path should be a ${r2} string, but got "${originalPath}"`,
@@ -62190,7 +62190,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
+    var isNotRelative = (path12) => REGEX_TEST_INVALID_PATH.test(path12);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p2) => p2;
     var Ignore = class {
@@ -62249,7 +62249,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path11, checkUnignored) {
+      _testOne(path12, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -62257,7 +62257,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path11);
+          const matched = rule.regex.test(path12);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -62270,24 +62270,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path11 = originalPath && checkPath.convert(originalPath);
+        const path12 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path11,
+          path12,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path11, cache, checkUnignored, slices);
+        return this._t(path12, cache, checkUnignored, slices);
       }
-      _t(path11, cache, checkUnignored, slices) {
-        if (path11 in cache) {
-          return cache[path11];
+      _t(path12, cache, checkUnignored, slices) {
+        if (path12 in cache) {
+          return cache[path12];
         }
         if (!slices) {
-          slices = path11.split(SLASH);
+          slices = path12.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path11] = this._testOne(path11, checkUnignored);
+          return cache[path12] = this._testOne(path12, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -62295,24 +62295,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path11] = parent.ignored ? parent : this._testOne(path11, checkUnignored);
+        return cache[path12] = parent.ignored ? parent : this._testOne(path12, checkUnignored);
       }
-      ignores(path11) {
-        return this._test(path11, this._ignoreCache, false).ignored;
+      ignores(path12) {
+        return this._test(path12, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path11) => !this.ignores(path11);
+        return (path12) => !this.ignores(path12);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path11) {
-        return this._test(path11, this._testCache, true);
+      test(path12) {
+        return this._test(path12, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
+    var isPathValid = (path12) => checkPath(path12 && checkPath.convert(path12), path12, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -62323,13 +62323,13 @@ var require_ignore = __commonJS({
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path11) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
+      checkPath.isNotRelative = (path12) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path12) || isNotRelative(path12);
     }
   }
 });
 
 // src/server/engine-api.ts
-import path10 from "node:path";
+import path11 from "node:path";
 import fs10 from "node:fs";
 import os from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
@@ -62535,7 +62535,7 @@ function portionName(p2) {
 }
 function renderPointer(p2, opts = {}) {
   const spaced = opts.spaced !== false;
-  const sep2 = spaced ? ": " : ":";
+  const sep3 = spaced ? ": " : ":";
   const toks = [];
   for (const st of p2.steps) {
     if (st.sel === "parent") {
@@ -62562,18 +62562,18 @@ function renderPointer(p2, opts = {}) {
     if (toks.length > 0) toks[toks.length - 1] += t3;
     else toks.push(t3);
   }
-  const body = toks.join(sep2);
+  const body = toks.join(sep3);
   switch (p2.base.scope) {
     case "current":
       return body;
     case "parent":
-      return body === "" ? ".." : ".." + sep2 + body;
+      return body === "" ? ".." : ".." + sep3 + body;
     case "document":
       return ":" + (body === "" ? "" : (spaced ? " " : "") + body);
     case "link": {
       const ladder = p2.base.world === true ? ":::" : "::";
       const auth = colonSegment(p2.base.authority);
-      return ladder + (spaced ? " " : "") + auth + (body === "" ? "" : sep2 + body);
+      return ladder + (spaced ? " " : "") + auth + (body === "" ? "" : sep3 + body);
     }
   }
 }
@@ -62590,21 +62590,21 @@ function makeAnchor(body, fail, yaml = false) {
   if (body.endsWith("[]") && !body.endsWith("\\[]")) {
     fail(`the "[]" append was removed \u2014 write a trailing ": -" segment (a bookmark's keyless membership)`);
   }
-  const path11 = parsePointer(body, yaml, { allowAppend: true });
-  if (path11.steps.some((s2) => s2.sel === "relindex")) fail('a bookmark may not claim a position \u2014 "[.\xB1k]" is link-only');
+  const path12 = parsePointer(body, yaml, { allowAppend: true });
+  if (path12.steps.some((s2) => s2.sel === "relindex")) fail('a bookmark may not claim a position \u2014 "[.\xB1k]" is link-only');
   let ordinal = false;
-  const last = path11.steps[path11.steps.length - 1];
+  const last = path12.steps[path12.steps.length - 1];
   if (last?.sel === "append") {
     ordinal = true;
-    path11.steps = path11.steps.slice(0, -1);
+    path12.steps = path12.steps.slice(0, -1);
   }
-  if (path11.steps.some((s2) => s2.sel === "append")) fail('a mid-path "-" segment is reserved \u2014 only the trailing append is defined');
+  if (path12.steps.some((s2) => s2.sel === "append")) fail('a mid-path "-" segment is reserved \u2014 only the trailing append is defined');
   if (!ordinal) {
     if (last === void 0) fail('a bookmark path needs a key segment (or a trailing ": -" for keyless membership)');
     if (last.sel === "nullkey") fail("a bookmark cannot create the null key");
     if (last.sel !== "key") fail('a bookmark may not claim a position \u2014 use a trailing ": -" for keyless membership');
   }
-  return { path: path11, ...ordinal ? { ordinal: true } : {} };
+  return { path: path12, ...ordinal ? { ordinal: true } : {} };
 }
 
 // ../parser/ts/src/pathseg.ts
@@ -62617,13 +62617,13 @@ function pathOfSegs(segs) {
   if (segs.length === 0) return ":";
   return segs.map((s2) => ":" + segToken(s2)).join("");
 }
-function childSeg(path11, seg) {
-  return (path11 === ":" ? "" : path11) + ":" + segToken(seg);
+function childSeg(path12, seg) {
+  return (path12 === ":" ? "" : path12) + ":" + segToken(seg);
 }
-function segsOfPath(path11, opts = {}) {
+function segsOfPath(path12, opts = {}) {
   const segs = [];
   let i2 = 0;
-  const s2 = path11;
+  const s2 = path12;
   while (i2 < s2.length) {
     const c3 = s2[i2];
     if (c3 === ":") {
@@ -62707,6 +62707,233 @@ function safeDecode(s2) {
   }
 }
 
+// ../parser/ts/src/marklower-links.ts
+var LABEL = String.raw`(?:[^\[\]]|\[[^\]]*\])*?`;
+var TOKEN = new RegExp(
+  "(`{3,})[\\s\\S]*?\\1|" + // 1: fenced block — atomic, never re-interpreted
+  String.raw`\$\$([\s\S]+?)\$\$|` + // 2: math
+  "`([^`]+?)`|" + // 3: code
+  String.raw`\[(${LABEL})\]\(([^)]+?)\)`,
+  // 4,5: link
+  "g"
+);
+var ATOMIC = new RegExp(
+  "(`{3,})[\\s\\S]*?\\1|" + // 1: fenced block
+  String.raw`\$\$([\s\S]+?)\$\$|` + // 2: math
+  "`([^`]+?)`",
+  // 3: code
+  "g"
+);
+function unquoteScalar(t3) {
+  if (t3.length >= 2 && t3[0] === "'" && t3[t3.length - 1] === "'") return t3.slice(1, -1).replace(/''/g, "'");
+  if (t3.length >= 2 && t3[0] === '"' && t3[t3.length - 1] === '"') {
+    try {
+      return JSON.parse(t3);
+    } catch {
+      return t3.slice(1, -1);
+    }
+  }
+  return t3;
+}
+function parseLabel(label) {
+  const bookmarks = [];
+  let rest = label;
+  for (; ; ) {
+    const t3 = rest.replace(/^\s+/, "");
+    if (!t3.startsWith("&")) {
+      rest = t3;
+      break;
+    }
+    if (t3[1] === "'") {
+      const close = t3.indexOf("'", 2);
+      if (close < 0) {
+        rest = t3;
+        break;
+      }
+      bookmarks.push(t3.slice(0, close + 1));
+      rest = t3.slice(close + 1).replace(/^\s*:?\s*/, "");
+    } else {
+      const m = /^&[^,]*?:\s*-\s*(?=:|$)/.exec(t3);
+      if (!m) {
+        rest = t3;
+        break;
+      }
+      bookmarks.push(m[0].replace(/\s+/g, " ").trim());
+      rest = t3.slice(m[0].length).replace(/^\s*:?\s*/, "");
+    }
+  }
+  return { bookmarks, valueRaw: rest.trim() };
+}
+function splitFields(inner) {
+  const out = [];
+  let depth = 0;
+  let quote = null;
+  let start = 0;
+  for (let i2 = 0; i2 < inner.length; i2++) {
+    const ch = inner[i2];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth--;
+    else if (ch === "," && depth === 0) {
+      out.push({ text: inner.slice(start, i2), at: start });
+      start = i2 + 1;
+    }
+  }
+  out.push({ text: inner.slice(start), at: start });
+  return out;
+}
+function readFragToken(src, at) {
+  let i2 = at + 1;
+  let depth = 0;
+  let quote = null;
+  for (; i2 < src.length; i2++) {
+    const ch = src[i2];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === "[") {
+      if (depth > 0) return null;
+      depth++;
+    } else if (ch === "]") {
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      break;
+    } else if (ch === "\n") return null;
+  }
+  if (i2 >= src.length || src[i2] !== "]" || src[i2 + 1] !== "(") return null;
+  const label = src.slice(at + 1, i2);
+  let j = i2 + 2;
+  depth = 0;
+  quote = null;
+  for (; j < src.length; j++) {
+    const ch = src[j];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === "(") depth++;
+    else if (ch === ")") {
+      if (depth > 0) {
+        depth--;
+        continue;
+      }
+      break;
+    }
+  }
+  if (j >= src.length || src[j] !== ")") return null;
+  const parens = src.slice(i2 + 2, j);
+  const end = j + 1;
+  const { bookmarks, valueRaw } = parseLabel(label);
+  const value = unquoteScalar(valueRaw);
+  let link = null;
+  let linkStart = -1;
+  let linkEnd = -1;
+  let plainLink = false;
+  const fields = [];
+  const parensAbs = i2 + 2;
+  const trimmed = parens.trim();
+  if (trimmed !== "") {
+    if (parseLinkTarget(trimmed).kind !== "unresolved") {
+      link = trimmed;
+      linkStart = parensAbs + (parens.length - parens.replace(/^\s+/, "").length);
+      linkEnd = linkStart + trimmed.length;
+      plainLink = true;
+    } else {
+      for (const part of splitFields(parens)) {
+        const pt = part.text.trim();
+        if (!pt) continue;
+        if (link === null && parseLinkTarget(pt).kind !== "unresolved") {
+          link = pt;
+          linkStart = parensAbs + part.at + (part.text.length - part.text.replace(/^\s+/, "").length);
+          linkEnd = linkStart + pt.length;
+          continue;
+        }
+        const kv = /^([A-Za-z0-9_][A-Za-z0-9_-]*)\s*:\s*([\s\S]*)$/.exec(pt);
+        if (kv) fields.push({ key: kv[1], raw: kv[2] });
+      }
+    }
+  }
+  return {
+    kind: "frag",
+    start: at,
+    end,
+    raw: src.slice(at, end),
+    label,
+    parens,
+    bookmarks,
+    value,
+    valueRaw,
+    link,
+    linkStart,
+    linkEnd,
+    fields,
+    plainLink
+  };
+}
+function scanMarklower(src) {
+  const out = [];
+  ATOMIC.lastIndex = 0;
+  let i2 = 0;
+  let m = ATOMIC.exec(src);
+  while (i2 < src.length) {
+    while (m && m.index < i2) m = ATOMIC.exec(src);
+    let frag = null;
+    const limit = m ? m.index : src.length;
+    for (let k = src.indexOf("[", i2); k >= 0 && k < limit; k = src.indexOf("[", k + 1)) {
+      const f2 = readFragToken(src, k);
+      if (f2) {
+        frag = f2;
+        break;
+      }
+    }
+    if (frag) {
+      out.push(frag);
+      i2 = frag.end;
+      continue;
+    }
+    if (!m) break;
+    const kind = m[1] !== void 0 ? "fence" : m[2] !== void 0 ? "math" : "code";
+    out.push({ kind, start: m.index, end: m.index + m[0].length, raw: m[0], body: m[2] ?? m[3] ?? m[0] });
+    i2 = m.index + m[0].length;
+    m = ATOMIC.exec(src);
+  }
+  return out;
+}
+function linkTargets(src) {
+  const out = [];
+  for (const t3 of scanMarklower(src)) {
+    if (t3.kind !== "frag" || t3.link === null) continue;
+    out.push({ target: t3.link, raw: t3.raw, start: t3.start, end: t3.end, targetStart: t3.linkStart, targetEnd: t3.linkEnd });
+  }
+  return out;
+}
+var hasScheme = (s2) => /^[a-z][a-z0-9+.-]*:(?!\s|$)/i.test(s2);
+function parseLinkTarget(target) {
+  const raw = target.trim();
+  if (!raw) return { kind: "unresolved" };
+  if (raw.startsWith("&")) return { kind: "anchor", raw };
+  if (raw.startsWith("*") || raw.startsWith(":")) {
+    const expr = raw.startsWith("*") ? raw.slice(1) : raw;
+    try {
+      return { kind: "pointer", ptr: parsePointer(expr), sigiled: raw.startsWith("*") };
+    } catch {
+      return { kind: "unresolved" };
+    }
+  }
+  if (raw.startsWith("//") || raw.startsWith("/")) return { kind: "legacy-slash", raw };
+  if (hasScheme(raw)) return { kind: "external", href: raw };
+  return { kind: "unresolved" };
+}
+
 // ../engine/ts/src/boundary.ts
 var BOUNDARY_FORMATS = /* @__PURE__ */ new Set(["x-yamlover-xyflow"]);
 function tagFormat(node) {
@@ -62918,6 +63145,100 @@ function buildChains(root) {
   walk(root, []);
   return m;
 }
+var PROSE_TEXT_FORMATS = /* @__PURE__ */ new Set([void 0, "text/marklower"]);
+var PRESENTATIONAL_FORMATS = /* @__PURE__ */ new Set(["x-yamlover-bullets", "x-yamlover-numbered", "x-yamlover-table"]);
+function textLinkPath(ptr3, holder, docRoot) {
+  let base;
+  switch (ptr3.base.scope) {
+    case "link":
+      base = ptr3.base.world ? "" : ":" + segToken(ptr3.base.authority);
+      break;
+    case "document":
+      base = docRoot;
+      break;
+    case "current":
+      base = holder;
+      break;
+    case "parent": {
+      const segs = segsOfPath(holder);
+      if (segs.length === 0) return null;
+      base = pathOfSegs(segs.slice(0, -1));
+      break;
+    }
+  }
+  if (ptr3.base.scope === "link" && ptr3.base.world) return null;
+  let p2 = base === ":" ? "" : base;
+  for (const st of ptr3.steps) {
+    if (st.sel === "parent") {
+      const segs = segsOfPath(p2 === "" ? ":" : p2);
+      if (segs.length === 0) return null;
+      p2 = pathOfSegs(segs.slice(0, -1));
+      if (p2 === ":") p2 = "";
+    } else if (st.sel === "key") p2 += ":" + segToken(st.name);
+    else if (st.sel === "index") p2 += ":" + st.n;
+    else if (st.sel === "nullkey") p2 += ":~";
+    else return null;
+  }
+  return p2 === "" ? ":" : p2;
+}
+function scanTextLinks(doc) {
+  const out = [];
+  const walk = (node, base, parent, docRoot, uri, entrySpan, inPres) => {
+    const dr = isDocumentBoundary(node) ? base : docRoot;
+    const u2 = node.meta?.span?.uri ?? uri;
+    const fmt = node.meta?.derivedFormat;
+    const pres = PRESENTATIONAL_FORMATS.has(fmt) || inPres && fmt === void 0;
+    if (node.kind === "scalar" && typeof node.value === "string" && PROSE_TEXT_FORMATS.has(node.meta?.derivedFormat)) {
+      const span = node.meta?.span ?? entrySpan;
+      const holder = node.entries && !pres ? base : parent;
+      for (const l2 of linkTargets(node.value)) {
+        const t3 = parseLinkTarget(l2.target);
+        if (t3.kind === "pointer") {
+          out.push({
+            from: base,
+            holder,
+            docRoot: dr,
+            ptr: t3.ptr,
+            sigiled: t3.sigiled,
+            anchor: false,
+            target: textLinkPath(t3.ptr, holder, dr),
+            raw: l2.raw,
+            uri: u2,
+            span
+          });
+        } else if (t3.kind === "anchor") {
+          let ptr3 = null;
+          try {
+            ptr3 = parsePointer(t3.raw.slice(1));
+          } catch {
+          }
+          if (ptr3 !== null) {
+            out.push({
+              from: base,
+              holder,
+              docRoot: dr,
+              ptr: ptr3,
+              sigiled: true,
+              anchor: true,
+              target: textLinkPath(ptr3, holder, dr),
+              raw: l2.raw,
+              uri: u2,
+              span
+            });
+          }
+        }
+      }
+    }
+    const prefix = base === ":" ? "" : base;
+    const frame = pres ? parent : base;
+    node.entries?.forEach((e3, i2) => {
+      if (isPointer(e3.value)) return;
+      walk(e3.value, prefix + ":" + segToken(e3.nullKey === true ? null : e3.key ?? i2), frame, dr, u2, e3.meta?.span ?? null, pres);
+    });
+  };
+  walk(doc.root, ":", ":", ":", doc.source?.uri ?? null, null, false);
+  return out;
+}
 function pathOf(chain) {
   let s2 = "";
   for (let i2 = 1; i2 < chain.length; i2++) {
@@ -62935,7 +63256,7 @@ function pathOf(chain) {
 
 // ../engine/ts/src/store.ts
 import { DatabaseSync } from "node:sqlite";
-var SCHEMA_VERSION = 11;
+var SCHEMA_VERSION = 13;
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS node (
   path         TEXT PRIMARY KEY,
@@ -63027,7 +63348,7 @@ var Store = class {
     try {
       this.db.exec("DELETE FROM node; DELETE FROM edge; DELETE FROM dangling;");
       if (files) this.db.exec("DELETE FROM file;");
-      walkNodes(doc.root, ":", (path11, node, parent, label, pos, labelNull) => {
+      walkNodes(doc.root, ":", (path12, node, parent, label, pos, labelNull) => {
         const meta = node.meta ? JSON.stringify(node.meta) : null;
         const owned = node.entries?.filter((e3) => e3.edge !== "back") ?? [];
         const isArray = node.array || node.kind === "mapping" && owned.length > 0 && owned.every((e3) => e3.key === null && e3.nullKey !== true);
@@ -63035,8 +63356,8 @@ var Store = class {
         const format = node.kind === "blob" ? node.format : formatFromMeta(node);
         const hash = node.kind === "blob" ? node.contentHash : null;
         const size = node.kind === "blob" ? node.size : null;
-        insNode.run(path11, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
-        if (parent !== null) insEdge.run(parent, path11, label, labelNull ? 1 : 0, "contain", pos);
+        insNode.run(path12, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
+        if (parent !== null) insEdge.run(parent, path12, label, labelNull ? 1 : 0, "contain", pos);
       });
       const insDangling = this.db.prepare(INSERT_DANGLING);
       for (const r2 of resolveDocument(doc)) {
@@ -63174,7 +63495,7 @@ var Store = class {
    *  fresh `/tags` has no rows yet), then the tag's subtree and its containment edge. Approximate
    *  by design — the next reconcile re-walks the edited taxonomy body and trues everything up;
    *  these rows only have to answer queries until then. */
-  addTag(taxonomyStorePath, name, pos, node) {
+  addOnto(taxonomyStorePath, name, pos, node) {
     const insNode = this.db.prepare(
       `INSERT OR REPLACE INTO node (path, type, format, value, content_hash, size, is_array, meta)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
@@ -63271,24 +63592,24 @@ var Store = class {
     }));
   }
   /** A node's attributes (null if no such path). */
-  node(path11) {
-    const row = this.db.prepare("SELECT * FROM node WHERE path = ?").get(path11);
+  node(path12) {
+    const row = this.db.prepare("SELECT * FROM node WHERE path = ?").get(path12);
     return row ? rowToNode(row) : null;
   }
   /** Direct containment children of a node, in source order (by `pos`). */
-  children(path11) {
-    return this.db.prepare("SELECT to_path, label, pos FROM edge WHERE from_path = ? AND kind = 'contain' ORDER BY pos").all(path11).map((r2) => ({ to: r2.to_path, label: r2.label ?? null, pos: r2.pos ?? null }));
+  children(path12) {
+    return this.db.prepare("SELECT to_path, label, pos FROM edge WHERE from_path = ? AND kind = 'contain' ORDER BY pos").all(path12).map((r2) => ({ to: r2.to_path, label: r2.label ?? null, pos: r2.pos ?? null }));
   }
   /** ALL of a node's entries in source order — containment children AND `*`/`~` pointer
    *  entries (ref/back). Unlike {@link children} this keeps positional pointers (`- *file`)
    *  in place, so an array that mixes inline values and pointers (e.g. a chapter's `chunks`)
    *  projects in full. `kind` says whether `to` is an owned child (contain) or a pointer target. */
-  entries(path11) {
-    return this.db.prepare("SELECT to_path, label, pos, kind FROM edge WHERE from_path = ? AND kind IN ('contain','ref','back') ORDER BY pos").all(path11).map((r2) => ({ to: r2.to_path, label: r2.label ?? null, pos: r2.pos ?? null, kind: r2.kind }));
+  entries(path12) {
+    return this.db.prepare("SELECT to_path, label, pos, kind FROM edge WHERE from_path = ? AND kind IN ('contain','ref','back') ORDER BY pos").all(path12).map((r2) => ({ to: r2.to_path, label: r2.label ?? null, pos: r2.pos ?? null, kind: r2.kind }));
   }
   /** Whether a node has any containment children (expandable in the TOC). */
-  hasChildren(path11) {
-    const r2 = this.db.prepare("SELECT 1 FROM edge WHERE from_path = ? AND kind = 'contain' LIMIT 1").get(path11);
+  hasChildren(path12) {
+    const r2 = this.db.prepare("SELECT 1 FROM edge WHERE from_path = ? AND kind = 'contain' LIMIT 1").get(path12);
     return r2 != null;
   }
   /** The containment subtree rooted at `path`, up to `depth` levels (TOC). A recursive CTE
@@ -63296,7 +63617,7 @@ var Store = class {
    *  (`meta.hidden` — the `.yo` overlay, the grafted `yamlover` self-import) are plumbing,
    *  not contents: they are pruned here with their whole subtrees, so every TOC consumer gets the
    *  same view without re-filtering. */
-  toc(path11 = ":", depth = Infinity) {
+  toc(path12 = ":", depth = Infinity) {
     const rows = this.db.prepare(
       `WITH RECURSIVE sub(from_path, to_path, label, pos, lvl) AS (
            SELECT e.from_path, e.to_path, e.label, e.pos, 1 FROM edge e
@@ -63313,10 +63634,10 @@ var Store = class {
          SELECT s.to_path AS path, s.from_path AS parent, s.label, s.pos, n.type, n.format
            FROM sub s JOIN node n ON n.path = s.to_path
            ORDER BY s.lvl, s.from_path, s.pos`
-    ).all(path11, depth === Infinity ? Number.MAX_SAFE_INTEGER : depth);
+    ).all(path12, depth === Infinity ? Number.MAX_SAFE_INTEGER : depth);
     const byPath = /* @__PURE__ */ new Map();
-    const root = { path: path11, label: null, type: this.node(path11)?.type ?? "mapping", format: null, children: [] };
-    byPath.set(path11, root);
+    const root = { path: path12, label: null, type: this.node(path12)?.type ?? "mapping", format: null, children: [] };
+    byPath.set(path12, root);
     for (const r2 of rows) {
       const tn = {
         path: r2.path,
@@ -63332,9 +63653,9 @@ var Store = class {
   }
   /** Edges in/out of a node, by kind. `derived` inverses are computed here on demand (never
    *  stored) per ENGINE.md — for each ref/back into/out of the node, the reverse direction. */
-  relationships(path11) {
-    const out = this.db.prepare("SELECT * FROM edge WHERE from_path = ? AND kind != 'contain'").all(path11).map(rowToEdge);
-    const inc = this.db.prepare("SELECT * FROM edge WHERE to_path = ? AND kind != 'contain'").all(path11).map(rowToEdge);
+  relationships(path12) {
+    const out = this.db.prepare("SELECT * FROM edge WHERE from_path = ? AND kind != 'contain'").all(path12).map(rowToEdge);
+    const inc = this.db.prepare("SELECT * FROM edge WHERE to_path = ? AND kind != 'contain'").all(path12).map(rowToEdge);
     const derivedIn = inc.filter((e3) => e3.kind === "ref" || e3.kind === "back").map((e3) => ({ from: e3.to, to: e3.from, label: e3.label, kind: "derived", pos: null }));
     return { out, in: [...inc, ...derivedIn] };
   }
@@ -63346,13 +63667,13 @@ function insDanglingRef(stmt, r2) {
   const reason = r2.target.kind === "external" ? r2.target.authority : r2.target.reason;
   stmt.run(r2.from, r2.raw, reason, r2.anchor ? "" : r2.holder, r2.label, r2.pos, r2.edge, ext ? 1 : 0);
 }
-function walkNodes(node, path11, visit2, parent = null, label = null, pos = null, labelNull = false) {
-  visit2(path11, node, parent, label, pos, labelNull);
+function walkNodes(node, path12, visit2, parent = null, label = null, pos = null, labelNull = false) {
+  visit2(path12, node, parent, label, pos, labelNull);
   if (!node.entries) return;
   node.entries.forEach((e3, i2) => {
     if (isPointer(e3.value)) return;
-    const childPath2 = childSeg(path11, e3.nullKey === true ? null : e3.key ?? i2);
-    walkNodes(e3.value, childPath2, visit2, path11, e3.key, i2, e3.nullKey === true);
+    const childPath2 = childSeg(path12, e3.nullKey === true ? null : e3.key ?? i2);
+    walkNodes(e3.value, childPath2, visit2, path12, e3.key, i2, e3.nullKey === true);
   });
 }
 function formatFromMeta(node) {
@@ -63608,9 +63929,9 @@ function parseYamlover(src, uri = "<yamlover>", opts = {}) {
   const yaml = opts.yaml === true;
   const raw = [];
   const lineStarts = [];
-  const sep2 = /\r\n|\r|\n/g;
+  const sep3 = /\r\n|\r|\n/g;
   let at = 0;
-  for (let m = sep2.exec(src); m !== null; m = sep2.exec(src)) {
+  for (let m = sep3.exec(src); m !== null; m = sep3.exec(src)) {
     raw.push(src.slice(at, m.index));
     lineStarts.push(at);
     at = m.index + m[0].length;
@@ -63765,8 +64086,14 @@ var Block = class {
       body = quotedScalar(text.slice(1, j + 1)).value;
       tokenLen = j + 1;
     } else if (hasSeparatorColon(inline ? text.slice(1).split(/[ \t]/, 1)[0] : text.slice(1))) {
-      body = text.slice(1).trim();
-      tokenLen = text.length;
+      if (inline && !this.yaml) {
+        tokenLen = this.anchorChainEnd(text);
+        body = text.slice(1, tokenLen).trim();
+        if (body.endsWith(":")) body = body.slice(0, -1).trimEnd();
+      } else {
+        body = text.slice(1).trim();
+        tokenLen = text.length;
+      }
     } else {
       let j = 1;
       while (j < text.length && text[j] !== " " && text[j] !== "	") {
@@ -63781,6 +64108,60 @@ var Block = class {
     const a2 = adv(text, tokenLen, col);
     return { anchor, rest: a2.rest, col: a2.col };
   }
+  /** Where an INLINE colon-form anchor chain ends (docs/language/flattening combinations):
+   *  the scope colons and the FIRST name always belong; each further `: `-terminated portion
+   *  extends the chain; a lone `-` portion (the keyless-membership suffix) belongs too. The
+   *  chain stops before the next `&` (another bookmark) and before any other colon-less
+   *  token (the value). Returns the index in `text` just past the chain (text[0] is `&`). */
+  anchorChainEnd(text) {
+    let i2 = 1;
+    while (text[i2] === ":") i2++;
+    let end = i2;
+    let first = true;
+    for (; ; ) {
+      let j = end;
+      while (text[j] === " " || text[j] === "	") j++;
+      if (j >= text.length) return text.length;
+      if (text[j] === "&" && !first) return end;
+      if (text[j] === "*") return end;
+      let q = null;
+      let k = j;
+      let sawColon = false;
+      for (; k < text.length; k++) {
+        const c3 = text[k];
+        if (q !== null) {
+          if (c3 !== q) continue;
+          if (q === "'" && text[k + 1] === "'") {
+            k++;
+            continue;
+          }
+          q = null;
+          continue;
+        }
+        if (c3 === "'" || c3 === '"') {
+          q = c3;
+          continue;
+        }
+        if (c3 === ":" && (text[k + 1] === void 0 || text[k + 1] === " " || text[k + 1] === "	")) {
+          sawColon = true;
+          break;
+        }
+        if (c3 === " " || c3 === "	") break;
+      }
+      const token = text.slice(j, k);
+      if (sawColon) {
+        end = k + 1;
+        first = false;
+        continue;
+      }
+      if (first || token === "-") {
+        end = k;
+        first = false;
+        continue;
+      }
+      return end;
+    }
+  }
   /** Attach anchors to a (non-pointer) node's meta, appending to any it already has. */
   attachAnchors(value, anchors) {
     if (anchors.length === 0) return;
@@ -63801,6 +64182,104 @@ var Block = class {
     this.attachAnchors(out, cont.meta?.anchors ?? []);
     return out;
   }
+  /** Is this residue a FLAT-row continuation (docs/language/flattening) — itself a keyed or
+   *  `-:` line, so the fold unrolls one more level? `!!<`, `*`, `&`, block indicators and
+   *  `~` open VALUES/decorations, never path segments; quotes are decided by splitKV (a
+   *  quoted KEY has a top-level `: `, a quoted VALUE does not). Never in .yaml mode. */
+  flatTail(rest) {
+    if (this.yaml || rest === "") return false;
+    if (/^(!!|\*|&|[|>~])/.test(rest)) return false;
+    if (seqMarkLen(rest, false) === 2) return true;
+    if (isSeqLine(rest, false)) return false;
+    const kv = splitKV(rest);
+    return kv !== null && kv.key !== "" && kv.key !== "~" && !kv.key.startsWith(":");
+  }
+  /** THE PAVING (docs/language/flattening: rows are commands): a FLAT spine merges into the
+   *  sibling it addresses — a named segment pairs with the LAST same-key sibling, a middle
+   *  `-` with the LAST keyless one (and never adds). Returns false when the row simply
+   *  CREATES (the plain push). */
+  paveMerge(list, e3) {
+    if (this.yaml) return false;
+    const child = this.spineChild(e3.value);
+    if (e3.key === null) {
+      if (e3.nullKey === true || e3.edge === "back" || child === null) return false;
+      const t4 = [...list].reverse().find((x2) => x2.key === null && x2.nullKey !== true && x2.edge !== "back");
+      if (!t4) this.fail('a middle "-" segment addresses the LAST keyless element - none exists here');
+      this.paveInto(t4, child);
+      return true;
+    }
+    if (e3.meta?.keyConcrete === void 0 && child === null) return false;
+    const t3 = [...list].reverse().find((x2) => x2.key === e3.key && x2.edge !== "back");
+    if (!t3) {
+      this.validateFreshSpine(e3);
+      return false;
+    }
+    if (child === null) {
+      this.paveValue(t3, e3.value);
+      return true;
+    }
+    this.paveInto(t3, child);
+    return true;
+  }
+  /** A spine about to be CREATED fresh may not contain a MIDDLE `-` — the middle segment
+   *  addresses an existing element and never adds one, so with nothing to address it fails
+   *  here rather than silently minting an element. */
+  validateFreshSpine(e3) {
+    for (let c3 = this.spineChild(e3.value); c3 !== null; c3 = this.spineChild(c3.value)) {
+      if (c3.key === null && c3.nullKey !== true && this.spineChild(c3.value) !== null) {
+        this.fail('a middle "-" segment addresses the LAST keyless element - none exists here');
+      }
+    }
+  }
+  /** The next flat segment of a spine, when the fold continues below `v` — a mapping whose
+   *  single entry wears the flat concrete. A continuation BLOCK's entries are first
+   *  segments of their own lines (unmarked), so the spine detection stops there. */
+  spineChild(v) {
+    if (isPointer(v) || v.kind !== "mapping") return null;
+    const ents = v.entries ?? [];
+    if (ents.length !== 1 || ents[0].meta?.keyConcrete !== "yamlover/key/flat") return null;
+    if ((v.meta?.anchors ?? []).length > 0) return null;
+    return ents[0];
+  }
+  /** Pave the spine's next segment INTO an existing node — the child-adding walk (a valued
+   *  scalar grows fields: the omni). Paving through a reference is refused: an edge is not
+   *  a node. */
+  paveInto(t3, seg) {
+    if (isPointer(t3.value)) this.fail("cannot pave through a reference - a pointer is an edge, not a node");
+    const v = t3.value;
+    if (v.kind === "blob") this.fail("cannot pave into a blob");
+    if (v.entries === void 0) v.entries = [];
+    if (!this.paveMerge(v.entries, seg)) v.entries.push(seg);
+    const owned = v.entries.filter((x2) => x2.edge !== "back");
+    v.array = owned.length > 0 && owned.every((x2) => x2.key === null && x2.nullKey !== true);
+  }
+  /** Land a flat row's PAYLOAD on the existing node it addressed — THE WRITE-ONCE LAW: a
+   *  scalar value may change only while the node is null-valued AND childless. A block
+   *  continuation is child-adding and merges (mergeCont enforces the one-value law). */
+  paveValue(t3, val) {
+    if (!isPointer(val) && val.kind === "mapping") {
+      if (isPointer(t3.value)) this.fail("a reference is exclusive - it takes no continuation block");
+      t3.value = this.mergeCont(t3.value, val);
+      return;
+    }
+    const freshNull = !isPointer(val) && val.kind === "scalar" && val.value === null && (val.raw ?? "") === "" && (val.entries?.length ?? 0) === 0 && val.meta?.anchors === void 0 && val.meta?.schema === void 0;
+    if (freshNull) return;
+    if (isPointer(t3.value)) this.fail("the flat row would overwrite a reference - a value may land only on a null-valued, childless node (write-once)");
+    const old = t3.value;
+    const oldNull = old.kind === "scalar" && old.value === null && (old.raw ?? "") === "";
+    const oldChildless = (old.entries?.length ?? 0) === 0;
+    if (!oldNull || !oldChildless) {
+      this.fail("the flat row would overwrite - a value may land only on a null-valued, childless node (write-once)");
+    }
+    const oldAnchors = old.meta?.anchors ?? [];
+    t3.value = val;
+    if (isPointer(val)) {
+      if (oldAnchors.length > 0) this.fail("a reference is exclusive - it may not carry the bookmarks paved before it");
+      t3.edge = "ref";
+    } else if (oldAnchors.length > 0) {
+      this.attachAnchors(val, oldAnchors);
+    }
+  }
   fail(msg) {
     const l2 = this.lines[this.i] ?? this.lines[this.i - 1];
     const where = l2 ? `${this.uri}:${l2.n + 1}` : this.uri;
@@ -63856,15 +64335,16 @@ var Block = class {
     for (; ; ) {
       const l2 = this.peek();
       if (!l2 || l2.indent !== indent) break;
+      const lCol = l2.col ?? l2.indent;
       const startLineN = l2.n;
-      const startCol = l2.indent;
+      const startCol = lCol;
       const startBlank = l2.blankBefore === true;
       let value;
       let entry;
       if (l2.text.startsWith("&")) {
         if (keylessOnly) break;
         this.i++;
-        let { rest, col } = { rest: l2.text, col: l2.indent };
+        let { rest, col } = { rest: l2.text, col: lCol };
         while (rest.startsWith("&")) {
           const r2 = this.anchorToken(rest, l2.n, col);
           anchors.push(r2.anchor);
@@ -63891,22 +64371,26 @@ var Block = class {
         this.i++;
         const afterDash = l2.text.slice(mark);
         const lead = afterDash.length - afterDash.trimStart().length;
-        const contentCol = l2.indent + mark + lead;
+        const contentCol = lCol + mark + lead;
         const rest = afterDash.trim();
-        if (rest === "") {
-          value = this.node(indent + 1) ?? nul();
+        if (mark === 2 && this.flatTail(rest)) {
+          this.i--;
+          this.lines[this.i] = { indent: indent + 1, col: contentCol, text: rest, n: l2.n, flat: true, base: l2.base ?? indent };
+          value = this.container(indent + 1);
+        } else if (rest === "") {
+          value = this.node((l2.base ?? indent) + 1) ?? nul();
         } else if (isSeqLine(rest, this.yaml) || !/^(!!<|\*|&)/.test(rest) && splitKV(rest)) {
           this.i--;
           this.lines[this.i] = { indent: contentCol, text: rest, n: l2.n };
           value = this.container(contentCol);
         } else {
-          value = this.valueAfter(rest, indent, l2.n, contentCol);
+          value = this.valueAfter(rest, l2.base ?? indent, l2.n, contentCol);
         }
         entry = { key: null, edge: isPointer(value) ? "ref" : "contain", value };
       } else if (isBackSeqLine(l2.text)) {
         if (keylessOnly) break;
         this.i++;
-        const a2 = adv(l2.text, 2, l2.indent);
+        const a2 = adv(l2.text, 2, lCol);
         const rest = a2.rest;
         if (!rest.startsWith("*")) this.fail('a "~-" entry needs a pointer value (the container that holds this node)');
         const ptr3 = parsePointer(rest.slice(1).trim());
@@ -63929,7 +64413,7 @@ var Block = class {
               /*allowBlock*/
               false,
               l2.n,
-              l2.indent
+              lCol
             );
             if (isPointer(iv) || iv.kind !== "scalar") this.fail("unexpected content (expected an entry, an anchor, or a scalar value line)");
             v = iv;
@@ -63947,7 +64431,13 @@ var Block = class {
           back = true;
           rawKey = rawKey.slice(1);
         }
-        value = this.valueAfter(kv.rest, indent, l2.n, l2.indent + kv.restCol);
+        if (!nullKey && !back && this.flatTail(kv.rest)) {
+          this.i--;
+          this.lines[this.i] = { indent: indent + 1, col: lCol + kv.restCol, text: kv.rest, n: l2.n, flat: true, base: l2.base ?? indent };
+          value = this.container(indent + 1);
+        } else {
+          value = this.valueAfter(kv.rest, l2.base ?? indent, l2.n, lCol + kv.restCol);
+        }
         if (nullKey) {
           entry = { key: null, nullKey: true, edge: isPointer(value) ? "ref" : "contain", value };
         } else {
@@ -63961,9 +64451,11 @@ var Block = class {
       }
       const endLine = this.lines[this.i - 1];
       const start = (this.lineStarts[startLineN] ?? 0) + startCol;
-      const end = endLine ? (this.lineStarts[endLine.n] ?? 0) + endLine.indent + endLine.text.length : start;
+      const end = endLine ? (this.lineStarts[endLine.n] ?? 0) + (endLine.col ?? endLine.indent) + endLine.text.length : start;
       entry.meta = { ...entry.meta, span: { uri: this.uri, start, end }, ...startBlank ? { blankBefore: true } : {} };
-      entries.push(entry);
+      if (l2.flat === true) entry.meta = { ...entry.meta, keyConcrete: "yamlover/key/flat" };
+      if (l2.flat !== true && this.paveMerge(entries, entry)) {
+      } else entries.push(entry);
     }
     const owned = entries.filter((e3) => e3.edge !== "back");
     const array = owned.length > 0 && owned.every((e3) => e3.key === null && e3.nullKey !== true);
@@ -64009,6 +64501,9 @@ var Block = class {
       }
       break;
     }
+    if (anchors.length > 0 && rest.startsWith("*")) {
+      this.fail("a reference is exclusive - no bookmark may share its row (a pointer is an edge, not a node)");
+    }
     let value;
     if (/^[|>][+-]?\d*$/.test(rest)) {
       value = this.blockScalar(rest, parentIndent, srcLineN);
@@ -64849,9 +65344,9 @@ function loadBundledTaxonomy() {
   if (!dir) return cached = null;
   const defsRoot = walkTree(path.join(dir, "$defs"), { noGraft: true }).doc.root;
   const entries = [{ key: "$defs", edge: "contain", value: defsRoot }];
-  const tagsDir = path.join(dir, "tags");
-  if (fs.existsSync(tagsDir)) {
-    entries.push({ key: "tags", edge: "contain", value: walkTree(tagsDir, { noGraft: true }).doc.root });
+  const ontosDir = path.join(dir, "ontos");
+  if (fs.existsSync(ontosDir)) {
+    entries.push({ key: "ontos", edge: "contain", value: walkTree(ontosDir, { noGraft: true }).doc.root });
   }
   const defs = defsMap(defsRoot);
   return cached = { node: { kind: "mapping", array: false, entries }, defs };
@@ -64916,17 +65411,17 @@ async function walkTreeAsync(absDir, opts = {}) {
   }
   return r2.value;
 }
-var BUILTIN_TAG_SCHEMA = "type: object\nformat: x-yamlover-tag\nproperties:\n  color:\n    type: string\nadditionalProperties: *:: yamlover: $defs: tag\n";
+var BUILTIN_ONTO_SCHEMA = "type: variant\nformat: x-yamlover-onto\nmembers:\n  color:\n    type: string\nothers: *:: yamlover: $defs: onto\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 BUILTIN_ONTOS_BODY = '!!<*yamlover:$defs:onto>\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() {
   builtinTemplate ??= {
-    tag: parseYamlover(BUILTIN_TAG_SCHEMA, "$defs/tag").root,
-    tags: parseYamlover(BUILTIN_TAGS_BODY, "tags/.yo/body.yo").root
+    onto: parseYamlover(BUILTIN_ONTO_SCHEMA, "$defs/onto").root,
+    ontos: parseYamlover(BUILTIN_ONTOS_BODY, "ontos/.yo/body.yo").root
   };
-  const tagCopy = structuredClone(builtinTemplate.tag);
+  const tagCopy = structuredClone(builtinTemplate.onto);
   const fragCopy = parseYamlover(BUILTIN_FRAGMENT_SCHEMA, "$defs/fragment").root;
   const annCopy = parseYamlover(BUILTIN_ANNOTATION_SCHEMA, "$defs/annotation").root;
   const node = {
@@ -64940,16 +65435,16 @@ function builtinYamloverGraft() {
           kind: "mapping",
           array: false,
           entries: [
-            { key: "tag", edge: "contain", value: tagCopy },
+            { key: "onto", edge: "contain", value: tagCopy },
             { key: "fragment", edge: "contain", value: fragCopy },
             { key: "annotation", edge: "contain", value: annCopy }
           ]
         }
       },
-      { key: "tags", edge: "contain", value: structuredClone(builtinTemplate.tags) }
+      { key: "ontos", edge: "contain", value: structuredClone(builtinTemplate.ontos) }
     ]
   };
-  return { node, defs: /* @__PURE__ */ new Map([["tag", tagCopy], ["fragment", fragCopy], ["annotation", annCopy]]) };
+  return { node, defs: /* @__PURE__ */ new Map([["onto", tagCopy], ["fragment", fragCopy], ["annotation", annCopy]]) };
 }
 function* walkTreeGen(absDir, opts = {}) {
   const ctx = { root: path2.resolve(absDir), opts, files: /* @__PURE__ */ new Map(), count: 0, open: opts.snapshot ? [] : void 0 };
@@ -64975,8 +65470,8 @@ function* walkTreeGen(absDir, opts = {}) {
       let node;
       if (fs2.existsSync(defsDir)) {
         const shared = [{ key: "$defs", edge: "contain", value: yield* dirNode(defsDir, ctx) }];
-        const tagsDir = path2.join(defsRoot, "tags");
-        if (fs2.existsSync(tagsDir)) shared.push({ key: "tags", edge: "contain", value: yield* dirNode(tagsDir, ctx) });
+        const ontosDir = path2.join(defsRoot, "ontos");
+        if (fs2.existsSync(ontosDir)) shared.push({ key: "ontos", edge: "contain", value: yield* dirNode(ontosDir, ctx) });
         node = { kind: "mapping", entries: shared, array: false };
       } else {
         const built = graftTaxonomy() ?? builtinYamloverGraft();
@@ -65058,7 +65553,7 @@ async function reindexPathAsync(store, absDir, cachedDoc, changedRel, opts = {})
   const yi = parts.indexOf(YAMLOVER_DIR);
   const dirSegs = yi >= 0 ? parts.slice(0, yi) : parts.slice(0, -1);
   if (dirSegs.length === 0) return null;
-  if (dirSegs[0] === "$defs" || dirSegs[0] === "tags") return null;
+  if (dirSegs[0] === "$defs" || dirSegs[0] === "ontos") return null;
   let entries = cachedDoc.root.entries;
   let target = null;
   for (let d2 = 0; d2 < dirSegs.length; d2++) {
@@ -65230,18 +65725,45 @@ function readTracked(ctx, abs) {
   record(ctx, abs, hashBytes(bytes), stat.size, stat.mtimeMs);
   return bytes;
 }
+function parseClauses(plain) {
+  const meta = { exact: {}, patterns: [] };
+  let badPattern;
+  const clause = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+  const p2 = plain;
+  for (const src of [clause(p2?.properties), clause(p2?.members)]) {
+    for (const [key, entry] of Object.entries(src)) {
+      if (entry && typeof entry === "object" && entry.pattern) {
+        try {
+          meta.patterns.push({ re: new RegExp(key), entry });
+        } catch {
+          badPattern ??= key;
+        }
+      } else {
+        meta.exact[key] = entry;
+      }
+    }
+  }
+  return { meta, badPattern };
+}
+function metaFor(meta, name) {
+  if (!meta) return void 0;
+  if (Object.prototype.hasOwnProperty.call(meta.exact, name)) return meta.exact[name];
+  return meta.patterns.find((p2) => p2.re.test(name))?.entry;
+}
 function loadMeta(dir, ctx) {
   const file = path2.join(dir, YAMLOVER_DIR, "meta.yo");
-  if (!fs2.existsSync(file)) return { props: {} };
+  if (!fs2.existsSync(file)) return { props: { exact: {}, patterns: [] } };
   try {
     const plain = toPlain(parseYamlover(readTracked(ctx, file).toString("utf8"), file).root);
-    const props = plain?.properties ?? {};
-    return { props: props && typeof props === "object" ? props : {} };
+    const { meta, badPattern } = parseClauses(plain);
+    if (badPattern !== void 0)
+      return { props: meta, error: noteFileError(ctx, file, new Error(`pattern clause is not a valid regexp: ${badPattern}`)) };
+    return { props: meta };
   } catch (e3) {
-    return { props: {}, error: noteFileError(ctx, file, e3) };
+    return { props: { exact: {}, patterns: [] }, error: noteFileError(ctx, file, e3) };
   }
 }
-function* dirNode(dir, ctx) {
+function* dirNode(dir, ctx, inherited) {
   const { props: meta, error: metaError } = loadMeta(dir, ctx);
   const overlay2 = overlayFile(dir);
   const consumesIndex = overlay2 !== null && path2.basename(overlay2) === INDEX_FILE;
@@ -65258,13 +65780,13 @@ function* dirNode(dir, ctx) {
       }
       continue;
     }
-    const child = yield* childNode(abs, meta[name], ctx);
+    const child = yield* childNode(abs, metaFor(meta, name) ?? metaFor(inherited, name), ctx);
     entries.push({ key: name, edge: "contain", value: child });
     yield { done: ++ctx.count, path: rel(ctx, abs) };
   }
   ctx.open?.pop();
   const node = { kind: "mapping", entries, array: false };
-  const merged = applyMeta(applyBody(overlay2, node, ctx), meta);
+  const merged = applyMeta(applyBody(overlay2, node, ctx), meta, inherited);
   return metaError && !merged.meta?.parseError ? { ...merged, meta: { ...merged.meta, parseError: metaError } } : merged;
 }
 function* yamloverDirNode(absYamlover, ctx) {
@@ -65288,9 +65810,16 @@ function* yamloverDirNode(absYamlover, ctx) {
 }
 function* childNode(abs, m, ctx) {
   const stat = fs2.statSync(abs);
-  if (stat.isDirectory()) return yield* dirNode(abs, ctx);
+  if (stat.isDirectory()) {
+    const nested = m && (m.members ?? m.properties) != null ? parseClauses(m).meta : void 0;
+    return yield* dirNode(abs, ctx, nested);
+  }
   const ext = path2.extname(abs).toLowerCase();
   const fmt = m?.format ?? EXT_FORMAT[ext] ?? null;
+  if (m?.concrete) {
+    const decoded = decodeConcrete(abs, m.concrete, m.format ?? null, stat, ctx);
+    if (decoded) return decoded;
+  }
   if (m?.type === "binary") return blob(abs, fmt ?? "application/octet-stream", ctx);
   if (fmt && (DOC_FORMATS[fmt] || TEXT_FORMATS.has(fmt))) {
     if (stat.size > MAX_DOC_BYTES) return blob(abs, fmt, ctx);
@@ -65301,10 +65830,59 @@ function* childNode(abs, m, ctx) {
   if (looksBinary(abs)) return blob(abs, "application/octet-stream", ctx);
   return parsedScalar(abs, ext, ctx);
 }
-function applyMeta(node, meta) {
+function decodeConcrete(abs, concrete, format, stat, ctx) {
+  const stamp = (n2) => ({ ...n2, meta: { ...n2.meta, concrete } });
+  const lang = DOC_CONCRETES[concrete];
+  if (lang) {
+    if (stat.size > MAX_DOC_BYTES) return stamp(blob(abs, format ?? "application/octet-stream", ctx));
+    return stamp(parsedDoc(abs, lang, ctx));
+  }
+  if (concrete === "base64") {
+    return stamp(blob(abs, format ?? "application/octet-stream", ctx));
+  }
+  const codec = /^binary\/int(8|16|32|64)\/(le|be)$/.exec(concrete);
+  if (codec) {
+    const bytes = readTracked(ctx, abs);
+    const width = Number(codec[1]) / 8;
+    const le = codec[2] === "le";
+    const refuse = (why) => stamp({
+      ...blob(abs, format ?? "application/octet-stream", ctx),
+      meta: { parseError: noteFileError(ctx, abs, new Error(`${concrete}: ${why}`)) }
+    });
+    if (bytes.length !== width) return refuse(`expected ${width} bytes, found ${bytes.length}`);
+    const dv2 = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    const value = width === 1 ? dv2.getInt8(0) : width === 2 ? dv2.getInt16(0, le) : width === 4 ? dv2.getInt32(0, le) : Number(dv2.getBigInt64(0, le));
+    if (!Number.isSafeInteger(value)) return refuse("value exceeds the safe integer range");
+    return stamp({
+      kind: "scalar",
+      value,
+      raw: String(value),
+      ...format ? { meta: { derivedFormat: format } } : {}
+    });
+  }
+  if (concrete.startsWith("text/")) {
+    let decoder;
+    try {
+      decoder = new TextDecoder(concrete.slice("text/".length), { fatal: false });
+    } catch {
+      return null;
+    }
+    if (stat.size > MAX_DOC_BYTES) return stamp(blob(abs, format ?? "text/plain", ctx));
+    const text = decoder.decode(readTracked(ctx, abs));
+    const span = decoder.encoding === "utf-8" ? { span: { uri: abs, start: 0, end: text.length } } : {};
+    return stamp({
+      kind: "scalar",
+      value: text,
+      raw: text,
+      meta: { ...format ? { derivedFormat: format } : {}, ...span }
+    });
+  }
+  return null;
+}
+function applyMeta(node, meta, inherited) {
   for (const e3 of node.entries ?? []) {
     if (e3.key == null || isPointer(e3.value)) continue;
-    const m = meta[e3.key];
+    const m = metaFor(meta, e3.key) ?? metaFor(inherited, e3.key);
     if (!m) continue;
     if (m.uniqueItems) e3.value = { ...e3.value, meta: { ...e3.value.meta, set: true } };
     if (e3.value.kind === "blob") continue;
@@ -65327,7 +65905,7 @@ function blob(abs, format, ctx) {
 }
 function textScalar(abs, format, ctx) {
   const text = readTracked(ctx, abs).toString("utf8");
-  return { kind: "scalar", value: text, raw: text, meta: { derivedFormat: format } };
+  return { kind: "scalar", value: text, raw: text, meta: { derivedFormat: format, span: { uri: abs, start: 0, end: text.length } } };
 }
 function parsedScalar(abs, ext, ctx) {
   const lang = ext === ".json" || ext === ".json5" || ext === ".json5p" ? "json5p" : ext === ".yaml" || ext === ".yml" ? "yaml" : "yamlover";
@@ -65387,14 +65965,17 @@ function applySchemas(root, defsRoot, builtinDefs) {
     }
     return { name: null, node: v };
   };
-  const isContainerSchema = (n2) => !!field(n2, "properties") || !!field(n2, "items") || !!field(n2, "allOf") || ["object", "variant", "mixed", "array"].includes(str(n2, "type") ?? "");
-  const OVERLAY_KEYS = /* @__PURE__ */ new Set(["yamlover-annotations", "yamlover-fragments"]);
+  const isContainerSchema = (n2) => !!field(n2, "members") || !!field(n2, "others") || !!field(n2, "properties") || !!field(n2, "items") || !!field(n2, "allOf") || ["object", "variant", "omni", "mixed", "kseq", "array"].includes(str(n2, "type") ?? "");
+  const OVERLAY_KEYS = /* @__PURE__ */ new Set(["yo"]);
   const elemIsContainer = (el) => el.kind === "mapping" || el.meta?.dirBacked === true || (el.entries ?? []).some((e3) => e3.key == null || !OVERLAY_KEYS.has(e3.key));
-  const applyItems = (inst, items, depth) => {
+  const ordinalElems = (inst) => {
+    const anchoredKeys = new Set(inst.meta?.anchored ?? []);
+    return (inst.entries ?? []).filter((e3) => (e3.key == null || anchoredKeys.has(e3.key)) && !isPointer(e3.value) && e3.value.meta?.yo !== true && !(e3.value.meta?.schema && isPointer(e3.value.meta.schema)));
+  };
+  const applyItems = (inst, items, depth, skip = 0) => {
     const { node: itemsNode } = resolveSchema(items);
     const anyOf = itemsNode ? field(itemsNode, "anyOf") : null;
-    const anchoredKeys = new Set(inst.meta?.anchored ?? []);
-    const elems = (inst.entries ?? []).filter((e3) => (e3.key == null || anchoredKeys.has(e3.key)) && !isPointer(e3.value) && e3.value.meta?.yo !== true && !(e3.value.meta?.schema && isPointer(e3.value.meta.schema)));
+    const elems = ordinalElems(inst).slice(skip);
     if (anyOf && !isPointer(anyOf) && anyOf.entries) {
       const branches = anyOf.entries.map((e3) => e3.value).map((b) => ({ ptr: b, ...resolveSchema(b) }));
       for (const e3 of elems) {
@@ -65411,22 +65992,33 @@ function applySchemas(root, defsRoot, builtinDefs) {
     const { name, node: s2 } = resolveSchema(schema);
     if (!s2 || isPointer(s2)) return;
     const stype = str(s2, "type");
-    const named = name && (stype === "object" || stype === "variant" || stype === "mixed" || !!field(s2, "allOf"));
+    const named = name && (stype === "object" || stype === "variant" || stype === "omni" || stype === "mixed" || stype === "kseq" || !!field(s2, "allOf"));
     const fmt = str(s2, "format") ?? (named ? `x-yamlover-${name}` : null);
     if (fmt && !hasFormat(inst)) inst.meta = { ...inst.meta, derivedFormat: fmt };
-    if (stype === "object" || stype === "variant" || stype === "mixed" || stype === "array" || field(s2, "items")) {
+    const members = field(s2, "members");
+    const membersNode = members && !isPointer(members) ? members : null;
+    const others = field(s2, "others");
+    const keylessClauses = (membersNode?.entries ?? []).filter((e3) => e3.key == null).map((e3) => e3.value);
+    if (stype === "object" || stype === "variant" || stype === "omni" || stype === "mixed" || stype === "kseq" || stype === "array" || membersNode || others || field(s2, "items")) {
       const props = field(s2, "properties");
       const addl = field(s2, "additionalProperties");
       for (const e3 of inst.entries ?? []) {
         if (e3.key == null || isPointer(e3.value)) continue;
         if (e3.value.meta?.schema && isPointer(e3.value.meta.schema)) continue;
         if (e3.value.meta?.yo === true) continue;
-        const declared = props && !isPointer(props) ? field(props, e3.key) : null;
-        const sub = declared ?? addl;
+        const declared = (membersNode ? field(membersNode, e3.key) : null) ?? (props && !isPointer(props) ? field(props, e3.key) : null);
+        const sub = declared ?? (others && !OVERLAY_KEYS.has(e3.key) ? others : null) ?? addl;
         if (sub) apply(e3.value, sub, depth + 1);
       }
-      const items = field(s2, "items");
-      if (items) applyItems(inst, items, depth);
+      if (keylessClauses.length) {
+        const elems = ordinalElems(inst);
+        keylessClauses.forEach((cl, i2) => {
+          const e3 = elems[i2];
+          if (e3) apply(e3.value, cl, depth + 1);
+        });
+      }
+      const sweep = others ?? field(s2, "items");
+      if (sweep) applyItems(inst, sweep, depth, keylessClauses.length);
     }
     const allOf = field(s2, "allOf");
     if (allOf && !isPointer(allOf) && allOf.entries) {
@@ -65445,6 +66037,16 @@ function overlayFile(dir) {
   const index = path2.join(dir, INDEX_FILE);
   return fs2.existsSync(index) ? index : null;
 }
+function ownerNodePath(absRoot, relPath) {
+  const parts = relPath.split("/");
+  const base = parts[parts.length - 1];
+  if (base === BODY_FILE && parts[parts.length - 2] === YAMLOVER_DIR && parts.length > 2) return parts.slice(0, -2).join("/");
+  if (base === INDEX_FILE && parts.length > 1) {
+    const dirRel = parts.slice(0, -1).join("/");
+    if (overlayFile(path2.join(absRoot, dirRel)) === path2.join(absRoot, dirRel, INDEX_FILE)) return dirRel;
+  }
+  return relPath;
+}
 function applyBody(file, node, ctx) {
   if (file === null) return node;
   let bodyDoc;
@@ -65603,6 +66205,20 @@ var DOC_FORMATS = {
   "json5p/meta": "json5p",
   "json/schema": "json5p"
 };
+var DOC_CONCRETES = {
+  "yamlover/stream": "yamlover",
+  "yamlover/code": "yamlover",
+  "yamlover/meta": "yamlover",
+  "yaml/stream": "yaml",
+  "yaml/code": "yaml",
+  "yaml/meta": "yaml",
+  "json/code": "json5p",
+  "json5/code": "json5p",
+  "json5p/code": "json5p",
+  "json/meta": "json5p",
+  "json5/meta": "json5p",
+  "json5p/meta": "json5p"
+};
 
 // ../engine/ts/src/rewrite.ts
 import * as path3 from "node:path";
@@ -65832,11 +66448,35 @@ var Emitter2 = class {
         this.seqItem(e3.value, indent);
       } else {
         const head = (e3.edge === "back" ? "~" : "") + (authoredKey(e3) ?? keyText(e3.key)) + ":";
-        this.keyed(head, e3.value, indent);
+        if (e3.edge !== "back" && this.canFold(e3.value) && ents.filter((s2) => s2.key === e3.key).length === 1) {
+          for (const c3 of e3.value.entries) this.flatChild([head], c3, indent);
+        } else {
+          this.keyed(head, e3.value, indent);
+        }
       }
       if (this.comments) this.emitTrailing(e3, indent, before);
     }
   }
+  /** Can this value still emit as FLAT rows losslessly? Delegates to {@link emitsFlat}. */
+  canFold(v) {
+    return emitsFlat(v);
+  }
+  /** One FLAT segment: descend while the fold stays lossless, else emit the LEAF row — the
+   *  joined prefix through the ordinary pair machinery at the ROW's own indent, so the leaf's
+   *  continuation block lands ONE STEP under the row, exactly as a normal key's block would
+   *  (the one-step indentation law — flattening does real re-indentation work, it is never a
+   *  pure line fold). A keyless element with container content takes this leaf path too: the
+   *  trailing `-:` row plus its block — the only APPEND spelling (inline `-` before key
+   *  segments would read back as the MIDDLE address). */
+  flatChild(prefix, e3, indent) {
+    const seg = e3.key === null ? "-" : authoredKey(e3) ?? keyText(e3.key);
+    const head = seg + ":";
+    if (e3.key !== null && this.canFold(e3.value)) {
+      for (const c3 of e3.value.entries) this.flatChild([...prefix, head], c3, indent);
+      return;
+    }
+    this.keyed(prefix.join(" ") + " " + head, e3.value, indent);
+  }
   /** A `trailing` comment rides the entry's line when the entry emitted a single line;
    *  otherwise (a block scalar / nested block) it falls to its own line below — never lost. */
   emitTrailing(e3, indent, before) {
@@ -65903,14 +66543,14 @@ var Emitter2 = class {
     } else if (value.kind === "scalar") {
       const block = typeof value.value === "string" ? blockOf(value) : null;
       if (block !== null) {
-        const inner = indent + STEP2 + (kept.length > 0 ? STEP2 : 0);
+        const inner = indent + STEP2 + (kept.length > 0 || this.anchorTokens(value).length > 0 ? STEP2 : 0);
         this.out.push(joinLine(pad + head, [...parts, block.header]));
         for (const l2 of block.lines) this.out.push(l2 === "" ? "" : " ".repeat(inner) + l2);
       } else {
         const tok = this.inline(
           value,
           /*needToken*/
-          kept.length > 0 || parts.length > 0
+          kept.length > 0 || parts.length > 0 || value.value != null && this.anchorTokens(value).length > 0
         );
         this.out.push(joinLine(pad + head, tok === "" ? parts : [...parts, tok]));
       }
@@ -66043,6 +66683,26 @@ function schemaText(v) {
 function schemaTagToken(v) {
   return `!!<${schemaText(v)}>`;
 }
+function emitsFlat(v) {
+  if (isPointer(v) || v.kind !== "mapping") return false;
+  const m = v.meta ?? {};
+  if (m.schema !== void 0 || m.set === true || m.yo === true || m.style !== void 0) return false;
+  if (m.concrete !== void 0) return false;
+  if ((m.anchors ?? []).length > 0 || (m.comments ?? []).length > 0) return false;
+  const ents = v.entries ?? [];
+  if (ents.length === 0) return false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const e3 of ents) {
+    if (e3.meta?.keyConcrete !== "yamlover/key/flat") return false;
+    if (e3.nullKey === true || e3.edge !== "contain" && e3.edge !== "ref") return false;
+    if ((e3.meta?.comments ?? []).length > 0 || e3.meta?.blankBefore === true) return false;
+    if (e3.key !== null) {
+      if (seen.has(e3.key)) return false;
+      seen.add(e3.key);
+    }
+  }
+  return true;
+}
 function leadingOf2(e3) {
   return (e3.meta?.comments ?? []).filter((c3) => c3.placement === "leading");
 }
@@ -66319,8 +66979,9 @@ function planRewrites(doc, edges, oldStore, newStore, opts = {}) {
           break;
         }
       }
+      if (cPtr === null) cPtr = linkPtr(container);
       if (cPtr === null) {
-        miss("anchor container left the holder's document");
+        miss("anchor container has no project-root spelling");
         continue;
       }
       const newBody = e3.label != null ? renderPointer(ptr2(cPtr.base, [...cPtr.steps, { sel: "key", name: e3.label }]), { spaced: false }) : renderPointer(cPtr, { spaced: false }) + ":-";
@@ -66347,30 +67008,13 @@ function planRewrites(doc, edges, oldStore, newStore, opts = {}) {
     const holder = mapPath(e3.holder);
     const docRoot = mapPath(e3.docRoot);
     const target = mapPath(e3.target.path);
-    let newPtr = null;
-    switch (e3.ptr.base.scope) {
-      case "link":
-        newPtr = linkPtr(target);
-        break;
-      case "document":
-        newPtr = under(target, docRoot) ? docPtr(docRoot, target) : null;
-        break;
-      case "current":
-        if (under(target, holder) && target !== holder) newPtr = ptr2({ scope: "current" }, stepsBelow(holder, target));
-        else if (under(target, docRoot)) newPtr = docPtr(docRoot, target);
-        break;
-      case "parent": {
-        const p2 = parentOf(holder);
-        if (p2 !== null && under(target, p2)) newPtr = ptr2({ scope: "parent" }, stepsBelow(p2, target));
-        else if (under(target, docRoot)) newPtr = docPtr(docRoot, target);
-        break;
-      }
-    }
+    const newPtr = retarget(e3.ptr.base.scope, holder, docRoot, target) ?? linkPtr(target);
     if (newPtr === null) {
-      miss("target left the holder's document");
+      miss("target has no project-root spelling");
       continue;
     }
-    const newRaw = renderPointer(newPtr);
+    const spaced = e3.raw.includes(": ") || !e3.raw.includes(":");
+    const newRaw = renderPointer(newPtr, { spaced });
     if (newRaw === e3.raw) continue;
     const token = isJson5pUri(span.uri) ? json5pToken(newRaw) : pointerToken(newRaw);
     const list = plan.edits.get(span.uri) ?? [];
@@ -66378,8 +67022,78 @@ function planRewrites(doc, edges, oldStore, newStore, opts = {}) {
     plan.edits.set(span.uri, list);
     plan.rewritten.push({ file: span.uri, from: e3.from, oldRaw: e3.raw, newRaw });
   }
+  const groups = /* @__PURE__ */ new Map();
+  for (const t3 of opts.textLinks ?? []) {
+    if (t3.target === null || !under(t3.target, oldStore)) continue;
+    const key = JSON.stringify([t3.span?.uri, t3.span?.start, t3.raw]);
+    const g = groups.get(key);
+    if (g) g.n++;
+    else groups.set(key, { t: t3, n: 1 });
+  }
+  for (const { t: t3, n: n2 } of groups.values()) {
+    const missLink = (reason) => {
+      plan.unrewritten.push({ file: t3.span?.uri ?? t3.uri ?? "<unknown>", from: t3.from, raw: t3.raw, reason });
+    };
+    const holder = mapPath(t3.holder);
+    const docRoot = mapPath(t3.docRoot);
+    const target = mapPath(t3.target);
+    const newPtr = retarget(t3.ptr.base.scope, holder, docRoot, target) ?? linkPtr(target);
+    if (newPtr === null) {
+      missLink("target has no project-root spelling");
+      continue;
+    }
+    if (renderPointer(newPtr, { spaced: false }) === renderPointer(t3.ptr, { spaced: false })) continue;
+    if (t3.anchor) {
+      missLink("&-target link is stale \u2014 reserved spelling, not rewritten (annotations refactor TODO)");
+      continue;
+    }
+    const spelling = "*" + renderPointer(newPtr, { spaced: false });
+    if (t3.span === null || opts.read === void 0) {
+      missLink("marklower prose link \u2014 no source span/reader (report only)");
+      continue;
+    }
+    if (opts.root !== void 0 && path3.relative(opts.root, t3.span.uri).startsWith("..")) {
+      missLink("source file is outside the served root (grafted)");
+      continue;
+    }
+    let text;
+    try {
+      text = opts.read(t3.span.uri);
+    } catch {
+      missLink("source file unreadable");
+      continue;
+    }
+    const slice = text.slice(t3.span.start, t3.span.end);
+    const hits = linkTargets(slice).filter((h) => h.raw === t3.raw);
+    if (hits.length === 0) {
+      missLink("link token not found verbatim in source (folded or escaped)");
+      continue;
+    }
+    const list = plan.edits.get(t3.span.uri) ?? [];
+    for (const h of hits) list.push({ start: t3.span.start + h.targetStart, end: t3.span.start + h.targetEnd, text: spelling });
+    plan.edits.set(t3.span.uri, list);
+    const newRaw = t3.raw.slice(0, hits[0].targetStart - hits[0].start) + spelling + ")";
+    plan.rewritten.push({ file: t3.span.uri, from: t3.from, oldRaw: t3.raw, newRaw });
+    if (hits.length < n2) missLink(`only ${hits.length} of ${n2} occurrences found verbatim (folded or escaped)`);
+  }
   return plan;
 }
+function retarget(scope, holder, docRoot, target) {
+  switch (scope) {
+    case "link":
+      return linkPtr(target);
+    case "document":
+      return under(target, docRoot) ? docPtr(docRoot, target) : null;
+    case "current":
+      if (under(target, holder) && target !== holder) return ptr2({ scope: "current" }, stepsBelow(holder, target));
+      return under(target, docRoot) ? docPtr(docRoot, target) : null;
+    case "parent": {
+      const p2 = parentOf(holder);
+      if (p2 !== null && under(target, p2)) return ptr2({ scope: "parent" }, stepsBelow(p2, target));
+      return under(target, docRoot) ? docPtr(docRoot, target) : null;
+    }
+  }
+}
 function applyEdits(text, edits) {
   const sorted = [...edits].sort((a2, b) => b.start - a2.start);
   for (let i2 = 1; i2 < sorted.length; i2++) {
@@ -66473,7 +67187,7 @@ function mv(absRoot, fromRel, toRel, opts = {}) {
   }
   const { doc } = walkTree(root, opts);
   const edges = resolveDocument(doc);
-  const plan = planRewrites(doc, edges, storeOf(relFrom), storeOf(relTo), { root });
+  const plan = planRewrites(doc, edges, storeOf(relFrom), storeOf(relTo), { root, textLinks: scanTextLinks(doc), read: fileReader() });
   const editedFiles = [];
   for (const [uri, edits] of plan.edits) {
     fs3.writeFileSync(uri, applyEdits(fs3.readFileSync(uri, "utf8"), edits));
@@ -66481,15 +67195,88 @@ function mv(absRoot, fromRel, toRel, opts = {}) {
   }
   fs3.mkdirSync(path4.dirname(absTo), { recursive: true });
   fs3.renameSync(absFrom, absTo);
-  return { from: relFrom, to: relTo, rewritten: plan.rewritten, unrewritten: plan.unrewritten, editedFiles };
+  const report = { from: relFrom, to: relTo, rewritten: plan.rewritten, unrewritten: plan.unrewritten, editedFiles };
+  if (bodyOrdersChild(doc, relFrom)) {
+    const r2 = relinkRenamed(absRoot, [{ from: storeOf(relFrom), to: storeOf(relTo) }], opts);
+    report.rewritten = [...report.rewritten, ...r2.rewritten];
+    const seen = new Set(report.unrewritten.map((u2) => JSON.stringify([u2.file, u2.from, u2.raw])));
+    report.unrewritten = [...report.unrewritten, ...r2.unrewritten.filter((u2) => !seen.has(JSON.stringify([u2.file, u2.from, u2.raw])))];
+    report.editedFiles = [.../* @__PURE__ */ new Set([...report.editedFiles, ...r2.editedFiles])];
+  }
+  return report;
+}
+function bodyOrdersChild(doc, relFrom) {
+  const segs = relFrom.split("/");
+  let node = doc.root;
+  for (const s2 of segs.slice(0, -1)) {
+    const e3 = node?.entries?.find((en) => en.key === s2);
+    node = e3 !== void 0 && !isPointer(e3.value) ? e3.value : void 0;
+  }
+  const anchored = node?.meta?.anchored;
+  return Array.isArray(anchored) && anchored.includes(segs[segs.length - 1]);
+}
+function fileReader() {
+  const cache = /* @__PURE__ */ new Map();
+  return (uri) => {
+    let t3 = cache.get(uri);
+    if (t3 === void 0) {
+      t3 = fs3.readFileSync(uri, "utf8");
+      cache.set(uri, t3);
+    }
+    return t3;
+  };
 }
 function relinkMoved(absRoot, moved, opts = {}) {
-  return relinkRenamed(absRoot, moved.map((m) => ({ from: storeOf(m.from), to: storeOf(m.to) })), opts);
+  const root = path4.resolve(absRoot);
+  const pairs = coalesceMoved(root, collapseOwners(root, moved));
+  return relinkRenamed(absRoot, pairs.map((m) => ({ from: storeOf(m.from), to: storeOf(m.to) })), opts);
+}
+function collapseOwners(root, moved) {
+  return moved.map((m) => {
+    const ownerTo = ownerNodePath(root, m.to);
+    if (ownerTo === m.to) return m;
+    const tail = m.to.slice(ownerTo.length);
+    if (!m.from.endsWith(tail)) return m;
+    return { from: m.from.slice(0, -tail.length), to: ownerTo };
+  });
+}
+function coalesceMoved(root, pairs) {
+  const m = new Map(pairs.map((p2) => [p2.from, p2.to]));
+  for (let changed = true; changed; ) {
+    changed = false;
+    const groups = /* @__PURE__ */ new Map();
+    for (const [from, to2] of m) {
+      const pf = parentPath(from);
+      const pt = parentPath(to2);
+      if (pf === null || pt === null) continue;
+      const k = pf + "\0" + pt;
+      groups.set(k, [...groups.get(k) ?? [], { from, to: to2 }]);
+    }
+    for (const [k, g] of groups) {
+      const [pf, pt] = k.split("\0");
+      if (!g.every((e3) => baseName(e3.from) === baseName(e3.to))) continue;
+      if (fs3.existsSync(path4.join(root, pf))) continue;
+      for (const e3 of g) m.delete(e3.from);
+      m.set(pf, pt);
+      changed = true;
+      break;
+    }
+  }
+  return [...m].map(([from, to2]) => ({ from, to: to2 }));
+}
+function parentPath(rel2) {
+  const i2 = rel2.lastIndexOf("/");
+  return i2 < 0 ? null : rel2.slice(0, i2);
+}
+function baseName(rel2) {
+  return rel2.slice(rel2.lastIndexOf("/") + 1);
 }
 function relinkRenamed(absRoot, moved, opts = {}) {
   const root = path4.resolve(absRoot);
   const { doc } = walkTree(root, opts);
   const edges = resolveDocument(doc);
+  const textLinks = scanTextLinks(doc);
+  const read2 = fileReader();
   const rewritten = [];
   const unrewritten = [];
   const merged = /* @__PURE__ */ new Map();
@@ -66501,7 +67288,7 @@ function relinkRenamed(absRoot, moved, opts = {}) {
       return nom !== null && under(nom, oldStore);
     });
     const shimmed = stale.map((e3) => ({ ...e3, target: { kind: "node", node: doc.root, path: nominalPath(doc, e3) } }));
-    const plan = planRewrites(doc, shimmed, oldStore, m.to, { root });
+    const plan = planRewrites(doc, shimmed, oldStore, m.to, { root, textLinks, read: read2 });
     for (const [uri, edits] of plan.edits) merged.set(uri, [...merged.get(uri) ?? [], ...edits]);
     rewritten.push(...plan.rewritten);
     unrewritten.push(...plan.unrewritten);
@@ -66583,7 +67370,7 @@ var DEFAULT_SETTINGS = {
   uri: void 0,
   exports: [],
   annotations: ":annotations",
-  tags: ":tags",
+  ontos: ":ontos",
   sidecars: "per-directory",
   width: void 0,
   theme: void 0
@@ -66597,7 +67384,7 @@ var DEFAULT_SETTINGS_SOURCE = `# .yo/settings.yo \u2014 project settings for thi
 !!<*yamlover:$defs:config>
 
 annotations: *:: annotations   # create new annotations in :annotations
-tags: *:: tags                 # create new tags in :tags
+ontos: *:: ontos                 # create new ontos in :ontos
 sidecars: per-directory        # where derived thumbnail/crop blobs go (enum, not a path)
 # width: 100                   # reading width (ch) for prose views; browser settings override it
 `;
@@ -66622,7 +67409,7 @@ function loadSettings(absRoot) {
     uri: uriSetting(valueAt(root, "uri")),
     exports: exportsSetting(valueAt(root, "exports")),
     annotations: locationSetting(valueAt(root, "annotations"), DEFAULT_SETTINGS.annotations),
-    tags: locationSetting(valueAt(root, "tags"), DEFAULT_SETTINGS.tags),
+    ontos: locationSetting(valueAt(root, "ontos"), DEFAULT_SETTINGS.ontos),
     sidecars: sidecarLocation(valueAt(root, "sidecars"), DEFAULT_SETTINGS.sidecars),
     width: intSetting(valueAt(root, "width"), 20, 400),
     theme: enumSetting(valueAt(root, "theme"), ["dark", "light"])
@@ -67058,6 +67845,7 @@ function metaOk(s2, p2, t3) {
       case "boolean":
         return row.type === "scalar" && typeof row.value === "boolean";
       case "variant":
+      case "omni":
         return row.type === "scalar" && hasOwnChild(s2, p2);
       default:
         return false;
@@ -67081,9 +67869,43 @@ function compact(xs) {
   return xs.filter((x2) => x2 !== null);
 }
 
+// src/server/link-check.ts
+import * as path7 from "node:path";
+function deadLinkDiagnostics(doc, store, dataRoot) {
+  const out = [];
+  for (const l2 of scanTextLinks(doc)) {
+    if (l2.anchor) continue;
+    if (l2.target === null) continue;
+    if (store.node(l2.target) !== null) continue;
+    out.push({
+      code: "link/dead-target",
+      severity: "warning",
+      message: `prose link ${l2.raw} addresses ${l2.target}, which names no node`,
+      path: l2.from,
+      ...l2.uri ? { fsPath: path7.relative(dataRoot, l2.uri).split(path7.sep).join("/") } : {}
+    });
+  }
+  return out;
+}
+function deadLinkTargets(doc, store) {
+  const out = /* @__PURE__ */ new Set();
+  for (const l2 of scanTextLinks(doc)) {
+    if (l2.anchor || l2.target === null) continue;
+    if (store.node(l2.target) === null) out.add(l2.target);
+  }
+  return [...out];
+}
+function logDeadLinks(found, log, max = 8) {
+  for (const d2 of found.slice(0, max)) {
+    log(`validate ${d2.severity}: ${d2.code} at ${d2.path ?? d2.fsPath ?? "?"} \u2014 ${d2.message}`);
+  }
+  if (found.length > max) log(`validate warning: link/dead-target \u2014 and ${found.length - max} more (GET /api/doctor lists all)`);
+}
+
 // src/server/embed.ts
 var ANNOTATIONS_KEY = "yamlover-annotations";
-var FRAGMENTS_KEY = "yamlover-fragments";
+var YO_KEY = "yo";
+var FRAGMENTS_SUBKEY = "fragments";
 var THUMBNAILS_KEY = "yamlover-thumbnails";
 var indentOf = (line) => {
   let i2 = 0;
@@ -67194,20 +68016,6 @@ function seqItemLines(lines, region, key) {
   }
   return { keyLine, items, end: trimBack(lines, end, region.hi) };
 }
-function appendAnnotation(text, within, render) {
-  const lines = text.replace(/\n$/, "").split("\n");
-  appendAnnotationAt(lines, reachBody(lines, within), render);
-  return lines.join("\n") + "\n";
-}
-function appendAnnotationAt(lines, region, render) {
-  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));
-  }
-}
 function upsertMapEntry(text, within, mapKey, entryKey, render) {
   const lines = text.replace(/\n$/, "").split("\n");
   upsertMapEntryAt(lines, reachBody(lines, within), mapKey, entryKey, render);
@@ -67232,14 +68040,70 @@ function upsertMapEntryAt(lines, region, mapKey, entryKey, render) {
   }
 }
 function upsertFragment(text, within, slug, render) {
-  return upsertMapEntry(text, within, FRAGMENTS_KEY, 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);
+  if (L2 < 0) return false;
+  const t3 = lines[L2].trim();
+  if (t3 !== `${key}:` && t3 !== `${keyToken(key)}:`) return false;
+  const body = bodyUnder(lines, L2, region.hi, region.indent);
+  for (let i2 = body.lo; i2 < body.hi; i2++) if (isContentLine(lines[i2])) return false;
+  lines.splice(L2, Math.max(1, body.hi - L2));
+  return true;
 }
-function upsertThumbnail(text, within, resKey, render) {
-  return upsertMapEntry(text, within, THUMBNAILS_KEY, resKey, render);
+var isBookmarkLine = (line) => line.trim().startsWith("&");
+function appendBookmarkAt(lines, region, tokens) {
+  const at = trimBack(lines, region.lo - 1, region.hi);
+  lines.splice(at, 0, ...tokens.map((t3) => `${" ".repeat(region.indent)}${t3}`));
 }
-function annotationsRemain(text, within) {
+function appendBookmark(text, within, tokens) {
   const lines = text.replace(/\n$/, "").split("\n");
-  return annotationsRemainAt(lines, reachBody(lines, within));
+  appendBookmarkAt(lines, reachBody(lines, within), tokens);
+  return lines.join("\n") + "\n";
+}
+function removeBookmarkAt(lines, region, predicate) {
+  let removed = false;
+  for (; ; ) {
+    const r2 = region();
+    let hit = -1;
+    for (let i2 = r2.lo; i2 < r2.hi; i2++) {
+      if (isContentLine(lines[i2]) && indentOf(lines[i2]) === r2.indent && isBookmarkLine(lines[i2]) && predicate(lines[i2].trim())) {
+        hit = i2;
+        break;
+      }
+    }
+    if (hit < 0) break;
+    lines.splice(hit, 1);
+    removed = true;
+  }
+  return removed;
+}
+function removeBookmark(text, within, predicate) {
+  const lines = text.replace(/\n$/, "").split("\n");
+  const region = findBody(lines, within);
+  if (!region) return text;
+  return removeBookmarkAt(lines, () => findBody(lines, within) ?? region, predicate) ? lines.join("\n") + "\n" : text;
+}
+function bookmarksRemainAt(lines, region) {
+  for (let i2 = region.lo; i2 < region.hi; i2++) {
+    if (isContentLine(lines[i2]) && indentOf(lines[i2]) === region.indent && isBookmarkLine(lines[i2])) return true;
+  }
+  return false;
+}
+function bookmarksRemain(text, within) {
+  const lines = text.replace(/\n$/, "").split("\n");
+  const region = findBody(lines, within);
+  return region !== null && bookmarksRemainAt(lines, region);
+}
+function pruneEmptyYo(text, within) {
+  const lines = text.replace(/\n$/, "").split("\n");
+  const region = findBody(lines, within);
+  if (!region) return text;
+  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);
 }
 function annotationsRemainAt(lines, region) {
   const seq = seqItemLines(lines, region, ANNOTATIONS_KEY);
@@ -67304,27 +68168,6 @@ function removeMapEntryAt(lines, region, mapKey, entryKey) {
   if (!hasChild) lines.splice(mapLine, blockEnd(lines, mapLine + 1, lines.length, region.indent + 1) - mapLine);
   return true;
 }
-function removeAnnotation(text, within, predicate) {
-  const lines = text.replace(/\n$/, "").split("\n");
-  return removeAnnotationAt(lines, () => reachBody(lines, within), predicate) ? lines.join("\n") + "\n" : text;
-}
-function removeAnnotationAt(lines, region, predicate) {
-  let removed = false;
-  for (; ; ) {
-    const seq = seqItemLines(lines, region(), ANNOTATIONS_KEY);
-    if (!seq) break;
-    const k = seq.items.findIndex((i3) => {
-      const t3 = lines[i3].trim();
-      return predicate(stripSeqMark(t3) ?? t3);
-    });
-    if (k < 0) break;
-    const i2 = seq.items[k];
-    const next = k + 1 < seq.items.length ? seq.items[k + 1] : seq.end;
-    lines.splice(i2, next - i2);
-    removed = true;
-  }
-  return removed;
-}
 
 // src/concrete.ts
 var OVERLAY_DIR = ".yo";
@@ -67415,7 +68258,7 @@ var psdExtractor = {
 
 // src/server/extract/wasm.ts
 import fs8 from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
@@ -67424,7 +68267,7 @@ async function loadWasm(npmSpecifier, prodFile) {
   try {
     bytes = fs8.readFileSync(require2.resolve(npmSpecifier));
   } catch {
-    bytes = fs8.readFileSync(path8.join(path8.dirname(fileURLToPath2(import.meta.url)), "wasm", prodFile));
+    bytes = fs8.readFileSync(path9.join(path9.dirname(fileURLToPath2(import.meta.url)), "wasm", prodFile));
   }
   return WebAssembly.compile(new Uint8Array(bytes));
 }
@@ -67496,7 +68339,7 @@ async function renderThumbnail(bytes, format, w, h) {
 // src/server/gitignore.ts
 var import_ignore = __toESM(require_ignore(), 1);
 import fs9 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 function buildGitIgnore(dataRoot) {
   const gitRoot = findGitRoot(dataRoot) ?? dataRoot;
   const cache = /* @__PURE__ */ new Map();
@@ -67504,7 +68347,7 @@ function buildGitIgnore(dataRoot) {
     if (!cache.has(dir)) {
       let ig = null;
       try {
-        const gi = path9.join(dir, ".gitignore");
+        const gi = path10.join(dir, ".gitignore");
         if (fs9.statSync(gi).isFile()) ig = (0, import_ignore.default)().add(fs9.readFileSync(gi, "utf-8"));
       } catch {
       }
@@ -67513,25 +68356,25 @@ function buildGitIgnore(dataRoot) {
     return cache.get(dir);
   };
   return (absPath) => {
-    const fromRoot = path9.relative(gitRoot, absPath);
-    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path9.sep)) return true;
+    const fromRoot = path10.relative(gitRoot, absPath);
+    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path10.sep)) return true;
     let isDir = false;
     try {
       isDir = fs9.statSync(absPath).isDirectory();
     } catch {
     }
-    const rel2 = path9.relative(gitRoot, path9.dirname(absPath));
-    const segs = rel2 === "" ? [] : rel2.split(path9.sep);
+    const rel2 = path10.relative(gitRoot, path10.dirname(absPath));
+    const segs = rel2 === "" ? [] : rel2.split(path10.sep);
     let dir = gitRoot;
     const dirs = [gitRoot];
     for (const s2 of segs) {
-      dir = path9.join(dir, s2);
+      dir = path10.join(dir, s2);
       dirs.push(dir);
     }
     for (const d2 of dirs) {
       const ig = matcherFor(d2);
       if (!ig) continue;
-      const relToDir = path9.relative(d2, absPath);
+      const relToDir = path10.relative(d2, absPath);
       if (!relToDir) continue;
       if (ig.ignores(relToDir) || isDir && ig.ignores(relToDir + "/")) return true;
     }
@@ -67539,15 +68382,15 @@ function buildGitIgnore(dataRoot) {
   };
 }
 function findGitRoot(start) {
-  let dir = path9.resolve(start);
+  let dir = path10.resolve(start);
   try {
-    if (!fs9.statSync(dir).isDirectory()) dir = path9.dirname(dir);
+    if (!fs9.statSync(dir).isDirectory()) dir = path10.dirname(dir);
   } catch {
     return null;
   }
   for (; ; ) {
-    if (fs9.existsSync(path9.join(dir, ".git"))) return dir;
-    const parent = path9.dirname(dir);
+    if (fs9.existsSync(path10.join(dir, ".git"))) return dir;
+    const parent = path10.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -67888,7 +68731,10 @@ var UNSAFE_SEG = /[\\/:*?"<>|]/;
 var hasControlChar = (s2) => [...s2].some((c3) => c3.charCodeAt(0) < 32);
 var ITEM_NAME = /^item\d+(?:-\d+)*$/;
 var TITLE_NAME = /^\d+(?:-\d+)*(?:-.*)?$/;
-var DEFAULT_SEVERITY = { "layout/off-scheme-name": "warning" };
+var DEFAULT_SEVERITY = {
+  "layout/off-scheme-name": "warning",
+  "link/dead-target": "warning"
+};
 var d = (code, message, where) => ({
   code,
   severity: DEFAULT_SEVERITY[code] ?? "error",
@@ -68195,12 +69041,21 @@ function displayKind(s2, p2, row) {
   if (anchored.size) return ents.some((e3) => !isOrdinalEntry(anchored, e3.label)) ? "mix" : "array";
   return ents.some((e3) => e3.label === null) ? "mix" : "object";
 }
+function cubeName(f2, empty) {
+  const v = f2.valueType !== null;
+  if (v && f2.hasKeyed && f2.hasOrdinal) return "omni";
+  if (v && f2.hasKeyed) return "vmap";
+  if (v && f2.hasOrdinal) return "vseq";
+  if (f2.hasKeyed && f2.hasOrdinal) return "kseq";
+  if (f2.hasKeyed) return "map";
+  if (f2.hasOrdinal) return "seq";
+  return empty;
+}
 function typeName(s2, p2, row) {
   const k = displayKind(s2, p2, row);
   if (k === "scalar") return scalarType(row.value);
-  if (k === "mix") return "mixed";
-  if (k === "omni") return "variant";
-  return k;
+  if (k === "binary") return "binary";
+  return cubeName(facetsOf(s2, p2, row), row.is_array ? "seq" : "map");
 }
 function scalarType(v) {
   if (v === null) return "null";
@@ -68285,10 +69140,10 @@ var REF_KEY = "$yamloverRef";
 var NUM_KEY = "$yamloverNum";
 var wireScalar = (v) => typeof v === "number" && !Number.isFinite(v) ? { [NUM_KEY]: String(v) } : v;
 function createHandlers(dataRoot, opts = {}) {
-  const rootName = path10.basename(path10.resolve(dataRoot)) || "/";
-  const dbPath = path10.join(dataRoot, ".yo", "index.db");
-  const settingsFile = path10.join(dataRoot, ".yo", "settings.yo");
-  const settingsRel = path10.relative(dataRoot, settingsFile).split(path10.sep).join("/");
+  const rootName = path11.basename(path11.resolve(dataRoot)) || "/";
+  const dbPath = path11.join(dataRoot, ".yo", "index.db");
+  const settingsFile = path11.join(dataRoot, ".yo", "settings.yo");
+  const settingsRel = path11.relative(dataRoot, settingsFile).split(path11.sep).join("/");
   if (opts.ensureSettings) {
     try {
       ensureSettingsFile(dataRoot);
@@ -68299,7 +69154,7 @@ function createHandlers(dataRoot, opts = {}) {
   }
   let settings = loadSettings(dataRoot);
   const ignore2 = opts.gitignore === false ? void 0 : buildGitIgnore(dataRoot);
-  mkdirInside(dataRoot, path10.dirname(dbPath), { recursive: true });
+  mkdirInside(dataRoot, path11.dirname(dbPath), { recursive: true });
   const store0 = new Store(dbPath);
   const store = () => store0;
   let cachedDoc = null;
@@ -68410,7 +69265,7 @@ function createHandlers(dataRoot, opts = {}) {
           const next = pending[0];
           const total = done + pending.length;
           h.progress(done, total, next.path);
-          const abs = path10.join(dataRoot, ...next.path.split("/"));
+          const abs = path11.join(dataRoot, ...next.path.split("/"));
           const big = next.size >= BIG_FILE_BYTES;
           if (big) log(`hashing ${next.path} (${gib(next.size)} GiB)\u2026`);
           const tFile = Date.now();
@@ -68451,7 +69306,7 @@ function createHandlers(dataRoot, opts = {}) {
   };
   const doReindexFile = async (absFile) => {
     if (cachedDoc) {
-      const rel2 = path10.relative(dataRoot, absFile).split(path10.sep).join("/");
+      const rel2 = path11.relative(dataRoot, absFile).split(path11.sep).join("/");
       try {
         const res = await reindexPathAsync(store0, dataRoot, cachedDoc, rel2, walkOpts);
         if (res) {
@@ -68481,6 +69336,7 @@ function createHandlers(dataRoot, opts = {}) {
       cachedDoc = doc;
       h.done();
       log(`${label}: +${diff2.added.length} ~${diff2.changed.length} \u2212${diff2.removed.length} \u2192${diff2.moved.length}`);
+      logDeadLinks(deadLinkDiagnostics(doc, store0, dataRoot), log);
       broadcast(diff2);
       scheduleHasher();
       return diff2;
@@ -68492,7 +69348,7 @@ function createHandlers(dataRoot, opts = {}) {
   const SELF_WRITE_TTL_MS = 5e3;
   const selfWrites = /* @__PURE__ */ new Map();
   const noteSelfWrite = (absFile) => {
-    selfWrites.set(path10.relative(dataRoot, absFile).split(path10.sep).join("/"), Date.now());
+    selfWrites.set(path11.relative(dataRoot, absFile).split(path11.sep).join("/"), Date.now());
     if (selfWrites.size > 1e3) {
       const cutoff = Date.now() - SELF_WRITE_TTL_MS;
       for (const [k, t3] of selfWrites) if (t3 < cutoff) selfWrites.delete(k);
@@ -68516,6 +69372,7 @@ function createHandlers(dataRoot, opts = {}) {
         }
         h.done();
         log(`reconcile: +${diff2.added.length} ~${diff2.changed.length} \u2212${diff2.removed.length} \u2192${diff2.moved.length}`);
+        if (cachedDoc) logDeadLinks(deadLinkDiagnostics(cachedDoc, store0, dataRoot), log);
         broadcast(diff2);
         scheduleHasher();
         return diff2;
@@ -68530,7 +69387,7 @@ function createHandlers(dataRoot, opts = {}) {
   const spuriousEvent = (rel2) => {
     const rec = store0.file(rel2);
     if (!rec) return false;
-    const st = fs10.statSync(path10.join(dataRoot, ...rel2.split("/")), { throwIfNoEntry: false });
+    const st = fs10.statSync(path11.join(dataRoot, ...rel2.split("/")), { throwIfNoEntry: false });
     if (!st || !st.isFile()) return false;
     return st.size === rec.size && st.mtimeMs === rec.mtimeMs;
   };
@@ -68573,7 +69430,17 @@ function createHandlers(dataRoot, opts = {}) {
       if (url.pathname === "/api/doctor") {
         try {
           const v = validateTree(scanTree(dataRoot, ignore2));
-          sendJson(res, 200, { allowed: v.allowed, diagnostics: v.diagnostics });
+          const doc = cachedDoc ?? walkTree(dataRoot, walkOpts).doc;
+          sendJson(res, 200, { allowed: v.allowed, diagnostics: [...v.diagnostics, ...deadLinkDiagnostics(doc, s2, dataRoot)] });
+        } catch (e3) {
+          sendJson(res, 500, { error: String(e3.message || e3) });
+        }
+        return;
+      }
+      if (url.pathname === "/api/dead-links") {
+        try {
+          const doc = cachedDoc ?? walkTree(dataRoot, walkOpts).doc;
+          sendJson(res, 200, { targets: deadLinkTargets(doc, s2) });
         } catch (e3) {
           sendJson(res, 500, { error: String(e3.message || e3) });
         }
@@ -68653,7 +69520,7 @@ function createHandlers(dataRoot, opts = {}) {
               throw new Error("annotation needs a `tag` naming an existing node");
             }
             if (tagSegs.length === 0) throw new Error("the root cannot be a tag");
-            const bodyFile = embedAnnotation(dataRoot, s2, a2);
+            const bodyFile = embedAnnotation(dataRoot, s2, settings.sidecars, a2);
             broadcast(await doReindexFile(bodyFile));
             scheduleHasher();
             return { ok: true };
@@ -68677,9 +69544,16 @@ function createHandlers(dataRoot, opts = {}) {
       if (req.method === "DELETE" && url.pathname === "/api/annotate") {
         const target = url.searchParams.get("target") ?? "";
         const tag = url.searchParams.get("tag") || "";
+        const selRaw = url.searchParams.get("selector");
+        let sel;
+        try {
+          sel = selRaw ? JSON.parse(selRaw) : void 0;
+        } catch {
+          sel = void 0;
+        }
         enqueue(async () => {
           if (!tag) throw new Error("delete needs a `tag`");
-          const bodyFile = unembedAnnotation(dataRoot, s2, target, tag);
+          const bodyFile = unembedAnnotation(dataRoot, s2, target, tag, sel);
           broadcast(await doReindexFile(bodyFile));
         }).then(() => sendJson(res, 200, { ok: true })).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
         return;
@@ -68689,17 +69563,17 @@ function createHandlers(dataRoot, opts = {}) {
           (data) => enqueue(async () => {
             const name = String(data?.name ?? "").trim();
             if (!name) throw new Error("tag needs a non-empty name");
-            const segs2 = [...strToSegs(settings.tags), name];
+            const segs2 = [...strToSegs(settings.ontos), name];
             const tagPath = segsToStr(segs2);
             const existing = s2.node(storePath(segs2));
             if (existing) {
-              if (existing.format !== TAG_FORMAT) throw new Error(`a node already exists at ${tagPath} and is not a tag`);
+              if (existing.format !== ONTO_FORMAT) throw new Error(`a node already exists at ${tagPath} and is not a tag`);
               const color = s2.node(storePath(segs2) + ":color")?.value;
               return { path: tagPath, name, color: typeof color === "string" ? color : null, created: false };
             }
-            const written = writeTag(dataRoot, s2, settings.tags, name);
-            s2.addTag(storePath(strToSegs(settings.tags)), name, written.pos, written.node);
-            if (s2.node(storePath(segs2))?.format !== TAG_FORMAT) throw new Error(`the created tag did not index as a tag: ${tagPath}`);
+            const written = writeOnto(dataRoot, s2, settings.ontos, name);
+            s2.addOnto(storePath(strToSegs(settings.ontos)), name, written.pos, written.node);
+            if (s2.node(storePath(segs2))?.format !== ONTO_FORMAT) throw new Error(`the created tag did not index as a tag: ${tagPath}`);
             await doReindexFile(written.file);
             announce(written.createdFile ? { added: [written.file] } : { changed: [written.file] });
             return { path: tagPath, name, color: null, created: true };
@@ -68713,7 +69587,7 @@ function createHandlers(dataRoot, opts = {}) {
             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, path10.dirname(bodyFile), { recursive: true });
+            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());
@@ -68867,7 +69741,7 @@ function createHandlers(dataRoot, opts = {}) {
             const oldKey = String(segs2[segs2.length - 1]);
             if (newKey === oldKey) return { path: reqPath, unchanged: true };
             if (s2.node(storePath([...parentSegs, newKey]))) throw new Error(`the key \`${newKey}\` already exists in the node`);
-            const abs = segs2.every((g) => typeof g === "string") ? path10.resolve(dataRoot, ...segs2.map(String)) : null;
+            const abs = segs2.every((g) => typeof g === "string") ? path11.resolve(dataRoot, ...segs2.map(String)) : null;
             if (abs && fs10.existsSync(abs)) {
               const from = segs2.map(String).join("/");
               const to2 = [...parentSegs.map(String), newKey].join("/");
@@ -68896,7 +69770,7 @@ function createHandlers(dataRoot, opts = {}) {
           const files = [];
           let wrote = false;
           for (const doc of loadAgentDocs()) {
-            const target = path10.resolve(dataRoot, doc.name);
+            const target = path11.resolve(dataRoot, doc.name);
             const existing = fs10.existsSync(target) ? fs10.readFileSync(target, "utf8") : null;
             const { text, status } = mergeAgentDoc(existing, doc.content);
             if (status !== "exists") {
@@ -68943,7 +69817,7 @@ function createHandlers(dataRoot, opts = {}) {
         return;
       }
       if (url.pathname === "/api/blob") {
-        const file = path10.join(dataRoot, ...segs.map(String));
+        const file = path11.join(dataRoot, ...segs.map(String));
         if (!fs10.existsSync(file) || fs10.statSync(file).isDirectory()) return notFound(res, url);
         res.statusCode = 200;
         res.setHeader("Content-Type", blobContentType(s2.node(p2)?.format ?? formatFromExt(file)));
@@ -68955,7 +69829,7 @@ function createHandlers(dataRoot, opts = {}) {
       }
       if (url.pathname === "/api/thumb") {
         const sourceRow = s2.node(p2);
-        const sourceAbs = path10.join(dataRoot, ...segs.map(String));
+        const sourceAbs = path11.join(dataRoot, ...segs.map(String));
         if (!sourceRow || !fs10.existsSync(sourceAbs) || fs10.statSync(sourceAbs).isDirectory()) return notFound(res, url);
         const w = clampThumbDim(url.searchParams.get("w"), 256);
         const h = clampThumbDim(url.searchParams.get("h"), w);
@@ -69033,17 +69907,17 @@ function dirNames(absDir) {
   }
 }
 function dirConcreteOf(absDir) {
-  return dirConcreteFor(dirNames(absDir), fs10.existsSync(path10.join(absDir, OVERLAY_DIR, BODY_FILE2)));
+  return dirConcreteFor(dirNames(absDir), fs10.existsSync(path11.join(absDir, OVERLAY_DIR, BODY_FILE2)));
 }
 function dirBodyFile(absDir) {
-  return path10.join(absDir, ...overlaySegs(dirConcreteOf(absDir)));
+  return path11.join(absDir, ...overlaySegs(dirConcreteOf(absDir)));
 }
 function memberFlavor(absDir) {
   return dirConcreteOf(absDir) === "dir/index.yo" ? "dir/index.yo" : "dir/.yo";
 }
 function concreteOf(s2, dataRoot, segs, row) {
   if (segs.every((g) => typeof g === "string")) {
-    const abs = path10.resolve(dataRoot, ...segs.map(String));
+    const abs = path11.resolve(dataRoot, ...segs.map(String));
     let st;
     try {
       st = fs10.statSync(abs);
@@ -69052,7 +69926,7 @@ function concreteOf(s2, dataRoot, segs, row) {
     if (st?.isDirectory()) return dirConcreteOf(abs);
     if (st?.isFile()) return dataFileConcrete(abs) ?? (row.type === "blob" ? "file/binary" : "file/yaml");
   }
-  const docAbs = path10.resolve(dataRoot, ...documentRootSegs(s2, segs).map(String));
+  const docAbs = path11.resolve(dataRoot, ...documentRootSegs(s2, segs).map(String));
   try {
     if (fs10.statSync(docAbs).isFile()) return interiorOf(dataFileConcrete(docAbs) ?? "file/yaml");
   } catch {
@@ -69159,7 +70033,7 @@ function linkMarker(dataRoot, s2, segs) {
   } else {
     info.count = ownedEntries(s2, p2).filter((e3) => !(e3.kind === "contain" && isHidden(s2, e3.to))).length;
   }
-  if (row.format === TAG_FORMAT) {
+  if (row.format === ONTO_FORMAT) {
     const c3 = s2.node(p2 + ":color")?.value;
     if (typeof c3 === "string") info.color = c3;
   }
@@ -69202,7 +70076,7 @@ function buildRelations(dataRoot, s2, segs) {
   for (const src of upstream.values()) {
     const segs2 = storePathToSegs(src);
     const key = scopedPath(s2, segs2, currentDoc);
-    put(key, s2.node(src)?.format === TAG_FORMAT ? linkMarker(dataRoot, s2, segs2) : refMarker(key, segsToStr(segs2)));
+    put(key, s2.node(src)?.format === ONTO_FORMAT ? linkMarker(dataRoot, s2, segs2) : refMarker(key, segsToStr(segs2)));
   }
   return out;
 }
@@ -69278,10 +70152,10 @@ function firstChunkText(s2, p2) {
   }
   return null;
 }
-var TAG_FORMAT = "x-yamlover-tag";
+var ONTO_FORMAT = "x-yamlover-onto";
 var FRAGMENT_FORMAT = "x-yamlover-fragment";
-var ANN_KEY = "yamlover-annotations";
-var FRAG_KEY = "yamlover-fragments";
+var YO_KEY2 = "yo";
+var FRAGS_SUBKEY = "fragments";
 var CROP_SUBDIR = "fragments";
 var THUMB_SUBDIR = "thumbnails";
 var childPath = (parent, key) => (parent === ":" ? "" : parent) + ":" + key;
@@ -69298,42 +70172,36 @@ function displayNameOf(s2, p2) {
   return titleOf(s2, p2);
 }
 function readAnnotations(s2, hostStore) {
-  const arr = childPath(hostStore, ANN_KEY);
-  if (!s2.node(arr)) return [];
   const out = [];
-  for (const e3 of s2.entries(arr)) {
-    if (e3.kind === "ref") {
-      const tag = projectTag(s2, e3.to);
-      if (tag) out.push({ tag });
-    } else if (e3.kind === "contain") {
-      const tagEdge = s2.relationships(e3.to).out.find((o2) => o2.kind === "ref" && o2.label === "tag");
-      const tag = tagEdge ? projectTag(s2, tagEdge.to) : null;
-      if (!tag) continue;
-      const params = {};
-      let description;
-      for (const c3 of s2.children(e3.to)) {
-        const v = s2.node(c3.to)?.value;
-        if (c3.label === "description") description = v == null ? void 0 : String(v);
-        else if (c3.label) params[c3.label] = v;
-      }
-      out.push({ tag, description, params: Object.keys(params).length ? params : void 0 });
-    }
+  for (const e3 of s2.relationships(hostStore).out) {
+    if (e3.kind !== "back" || e3.label != null) continue;
+    const tag = projectTag(s2, e3.to);
+    if (tag) out.push({ tag });
   }
   return out;
 }
 function readFragments(s2, hostStore) {
-  const frags = childPath(hostStore, FRAG_KEY);
+  const frags = childPath(childPath(hostStore, YO_KEY2), FRAGS_SUBKEY);
   if (!s2.node(frags)) return [];
   const out = [];
   for (const fc of s2.children(frags)) {
     if (!fc.label) continue;
     const selector = {};
+    let description;
+    const self2 = s2.node(fc.to)?.value;
+    if (self2 != null) selector.exact = String(self2);
     for (const c3 of s2.children(fc.to)) {
-      if (c3.label && c3.label !== ANN_KEY && c3.label !== "created") selector[c3.label] = s2.node(c3.to)?.value;
+      if (!c3.label || c3.label === "created") continue;
+      if (c3.label === "description") {
+        const v = s2.node(c3.to)?.value;
+        description = v == null ? void 0 : String(v);
+        continue;
+      }
+      selector[c3.label] = s2.node(c3.to)?.value;
     }
     const imgEdge = s2.relationships(fc.to).out.find((o2) => o2.kind === "ref" && o2.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 });
+    out.push({ slug: fc.label, node: fc.to, selector, description, imageUrl });
   }
   return out;
 }
@@ -69342,9 +70210,34 @@ function annotationsFor(dataRoot, s2, segs) {
   const out = [];
   const gather = (hostStore, nodeClient) => {
     for (const a2 of readAnnotations(s2, hostStore)) out.push({ ...a2, node: nodeClient });
+    const row = s2.node(hostStore);
+    if (row?.type === "scalar" && typeof row.value === "string" && row.value.includes("[")) {
+      const text = row.value;
+      for (const t3 of scanMarklower(text)) {
+        if (t3.kind !== "frag" || t3.bookmarks.length === 0) continue;
+        const selector = {
+          type: "text",
+          exact: t3.value,
+          prefix: text.slice(Math.max(0, t3.start - 24), t3.start).replace(/\n/g, " "),
+          suffix: text.slice(t3.end, t3.end + 24).replace(/\n/g, " ")
+        };
+        for (const b of t3.bookmarks) {
+          const bsegs = bookmarkSegs(b);
+          const tag = bsegs ? projectTag(s2, storePath(bsegs)) : null;
+          if (tag) out.push({ tag, node: nodeClient, selector, inline: true });
+        }
+      }
+    }
     for (const f2 of readFragments(s2, hostStore)) {
       for (const a2 of readAnnotations(s2, f2.node)) {
-        out.push({ ...a2, node: nodeClient, selector: f2.selector, fragmentSlug: f2.slug, ...f2.imageUrl ? { imageUrl: f2.imageUrl } : {} });
+        out.push({
+          ...a2,
+          node: nodeClient,
+          selector: f2.selector,
+          fragmentSlug: f2.slug,
+          ...f2.description ? { description: f2.description } : {},
+          ...f2.imageUrl ? { imageUrl: f2.imageUrl } : {}
+        });
       }
     }
   };
@@ -69356,14 +70249,14 @@ function annotationsFor(dataRoot, s2, segs) {
   return out;
 }
 function taggedMaterials(dataRoot, s2, tagStorePath) {
-  const legacyDirect = s2.node(tagStorePath)?.format === TAG_FORMAT;
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  const ins = s2.relationships(tagStorePath).in.filter((e3) => (e3.kind === "ref" || e3.kind === "back") && e3.from).sort((a2, b) => a2.from < b.from ? -1 : a2.from > b.from ? 1 : 0);
-  for (const e3 of ins) {
-    const arrOwner = e3.from.replace(/(?::\d+|\[\d+\])$/, "").match(/^(.*):yamlover-annotations$/);
-    if (!arrOwner && !legacyDirect) continue;
-    const owner = arrOwner ? arrOwner[1] || ":" : e3.from;
+  const rel2 = s2.relationships(tagStorePath);
+  const members = [
+    ...rel2.in.filter((e3) => e3.kind === "back" && e3.label == null && e3.from).map((e3) => e3.from),
+    ...rel2.out.filter((e3) => e3.kind === "ref" && e3.label == null).map((e3) => e3.to)
+  ].sort();
+  for (const owner of members) {
     if (owner === tagStorePath || seen.has(owner) || !s2.node(owner) || inHiddenSubtree(s2, owner)) continue;
     seen.add(owner);
     out.push(linkMarker(dataRoot, s2, storePathToSegs(owner)));
@@ -69395,15 +70288,15 @@ function writeBoardLanes(src, lanes) {
   return lines.join("\n") + "\n";
 }
 function overlaidDir(bodyFile) {
-  if (bodyFile.endsWith(path10.join(OVERLAY_DIR, BODY_FILE2))) return path10.dirname(path10.dirname(bodyFile));
-  return path10.basename(bodyFile) === INDEX_FILE2 ? path10.dirname(bodyFile) : null;
+  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;
 }
 function sidecarTarget(dataRoot, mode, subdir, bodyFile) {
   const hostDir = overlaidDir(bodyFile);
   if (mode === "per-directory" && hostDir !== null) {
-    return { dir: path10.join(hostDir, OVERLAY_DIR, subdir), scope: "document" };
+    return { dir: path11.join(hostDir, OVERLAY_DIR, subdir), scope: "document" };
   }
-  return { dir: path10.join(dataRoot, OVERLAY_DIR, subdir), scope: "project" };
+  return { dir: path11.join(dataRoot, OVERLAY_DIR, subdir), scope: "project" };
 }
 function sidecarPointerRaw(subdir, name, scope) {
   const body = [".yo", subdir, name].map(colonSegment).join(":");
@@ -69415,7 +70308,7 @@ function yScalar(v) {
 function hostFor(dataRoot, s2, segs) {
   for (let i2 = segs.length; i2 >= 0; i2--) {
     const sub = segs.slice(0, i2);
-    const abs = path10.resolve(dataRoot, ...sub.map(String));
+    const abs = path11.resolve(dataRoot, ...sub.map(String));
     let st;
     try {
       st = fs10.statSync(abs);
@@ -69428,31 +70321,107 @@ function hostFor(dataRoot, s2, segs) {
       if (node?.meta?.documentRoot && node.type === "mapping" && !node.is_array) {
         return { bodyFile: abs, within: segs.slice(i2).map(String) };
       }
-      const dir = path10.resolve(dataRoot, ...sub.slice(0, -1).map(String));
+      const dir = path11.resolve(dataRoot, ...sub.slice(0, -1).map(String));
       return { bodyFile: dirBodyFile(dir), within: segs.slice(i2 - 1).map(String) };
     }
   }
   return { bodyFile: dirBodyFile(dataRoot), within: segs.map(String) };
 }
-function annotationItemLines(a2, indent) {
-  const pad = " ".repeat(indent);
-  const ptr3 = pointerToken(pointerRaw(a2.tag));
-  const params = { ...a2.params ?? {} };
-  if (a2.description != null && a2.description !== "") params.description = a2.description;
-  const keys = Object.keys(params);
-  if (keys.length === 0) return [`${pad}- ${ptr3}`];
-  return [`${pad}- tag: ${ptr3}`, ...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)}`);
+  const { exact, ...fields } = selector;
+  const self2 = exact != null ? ` ${yScalar(exact)}` : "";
+  const lines = [`${pad}${keyToken(slug)}: !!<*::yamlover:$defs:fragment>${self2}`];
+  for (const [k, v] of Object.entries(fields)) 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, s2, a2) {
+var isFragmentSegs = (segs) => segs.length >= 3 && segs[segs.length - 3] === YO_KEY2 && segs[segs.length - 2] === FRAGS_SUBKEY;
+var labelToken = (v) => /[:\[\]()&'"\n]|^\s|\s$/.test(v) ? "'" + v.replace(/'/g, "''") + "'" : v;
+function locateExact(text, sel) {
+  const needle = String(sel.exact ?? "");
+  if (!needle) return null;
+  const norm = text.replace(/\n/g, " ");
+  const pre = String(sel.prefix ?? "").replace(/\n/g, " ");
+  const suf = String(sel.suffix ?? "").replace(/\n/g, " ");
+  let at = -1;
+  for (let f2 = norm.indexOf(needle); f2 >= 0; f2 = norm.indexOf(needle, f2 + 1)) {
+    if (pre && !norm.slice(0, f2).endsWith(pre)) continue;
+    if (suf && !norm.slice(f2 + needle.length).startsWith(suf)) continue;
+    at = f2;
+    break;
+  }
+  if (at < 0) at = norm.indexOf(needle);
+  if (at < 0) return null;
+  const b = at + needle.length;
+  if (text.slice(at, b).includes("\n")) return null;
+  for (const t3 of scanMarklower(text)) {
+    if (at < t3.end && b > t3.start) return null;
+  }
+  return { a: at, b };
+}
+var blockPayload = (text) => {
+  const strip = !text.endsWith("\n");
+  const body = (strip ? text : text.slice(0, -1)).split("\n").map((l2) => "  " + l2).join("\n");
+  return (strip ? "|-\n" : "|\n") + body;
+};
+function rewriteInlineFragment(dataRoot, s2, segs, sel, mutate) {
+  const row = s2.node(storePath(segs));
+  if (!row || row.type !== "scalar" || typeof row.value !== "string") return false;
+  const text = row.value;
+  const exact = String(sel.exact ?? "");
+  let existing = null;
+  for (const t3 of scanMarklower(text)) {
+    if (t3.kind === "frag" && t3.link === null && t3.value === exact) {
+      existing = t3;
+      break;
+    }
+  }
+  let next;
+  if (existing) {
+    const replacement = mutate(existing);
+    if (replacement === false) return false;
+    next = text.slice(0, existing.start) + (replacement ?? existing.value) + text.slice(existing.end);
+  } else {
+    const where = locateExact(text, sel);
+    if (!where) return false;
+    const replacement = mutate(null);
+    if (replacement === false || replacement === null) return false;
+    next = text.slice(0, where.a) + replacement + text.slice(where.b);
+  }
+  applyEdits2(dataRoot, s2, [{ path: segsToStr(segs), op: "emplace", yamlover: blockPayload(next) }]);
+  return true;
+}
+function fragTokenText(bookmarks, value, parens) {
+  const head = bookmarks.length ? bookmarks.join(": ") + ": " : "";
+  return `[${head}${labelToken(value)}](${parens})`;
+}
+function bookmarkSegs(body) {
+  try {
+    const p2 = parsePointer(body.replace(/^&/, "").replace(/:\s*-\s*$/, ""));
+    const segs = [p2.base?.authority, ...(p2.steps ?? []).map((st) => st.name)].filter((x2) => typeof x2 === "string");
+    return segs.length ? segs : null;
+  } catch {
+    return null;
+  }
+}
+function embedAnnotation(dataRoot, s2, mode, a2) {
   const segs = strToSegs(a2.target || ":");
+  const params = { ...a2.params ?? {} };
+  if (a2.description != null && a2.description !== "") params.description = a2.description;
+  const sel = a2.selector;
+  if (sel && typeof sel === "object" && sel.type === "text" && Object.keys(params).length === 0 && isChunkTarget(s2, segs)) {
+    const btoken = `&${pointerRaw(a2.tag)}:-`;
+    const ok = rewriteInlineFragment(dataRoot, s2, segs, sel, (t3) => t3 ? fragTokenText([...t3.bookmarks, btoken], t3.value, t3.parens) : fragTokenText([btoken], String(sel.exact ?? ""), ""));
+    if (ok) return chapterSource(dataRoot, s2, segs).bodyFile;
+    const made = embedFragment(dataRoot, s2, mode, { target: a2.target, selector: sel });
+    return embedAnnotation(dataRoot, s2, mode, { target: made.fragmentPath, tag: a2.tag });
+  }
+  if (Object.keys(params).length && !isFragmentSegs(segs)) {
+    throw new Error("annotation parameters live on a fragment (docs/annotations/applications)");
+  }
+  const tokens = [`&${pointerRaw(a2.tag)}:-`, ...Object.entries(params).map(([k, v]) => `${keyToken(k)}: ${yScalar(v)}`)];
   if (isChunkTarget(s2, segs)) {
     const { docSegs, bodyFile: bodyFile2 } = chapterSource(dataRoot, s2, segs);
     const { indices, keys } = splitChunkWithin(segs.slice(docSegs.length));
@@ -69463,14 +70432,14 @@ function embedAnnotation(dataRoot, s2, a2) {
       /*ensureOmni*/
       true
     ), keys);
-    appendAnnotationAt(lines, region, (indent) => annotationItemLines(a2, indent));
+    appendBookmarkAt(lines, region, tokens);
     writeBody(dataRoot, s2, bodyFile2, lines.join("\n") + "\n");
     return bodyFile2;
   }
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
-  mkdirInside(dataRoot, path10.dirname(bodyFile), { recursive: true });
+  mkdirInside(dataRoot, path11.dirname(bodyFile), { recursive: true });
   const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
-  writeBody(dataRoot, s2, bodyFile, appendAnnotation(src, within, (indent) => annotationItemLines(a2, indent)));
+  writeBody(dataRoot, s2, bodyFile, appendBookmark(src, within, tokens));
   return bodyFile;
 }
 function embedFragment(dataRoot, s2, mode, f2) {
@@ -69488,9 +70457,9 @@ function embedFragment(dataRoot, s2, mode, f2) {
       /*ensureOmni*/
       true
     );
-    upsertMapEntryAt(lines, region, FRAG_KEY, 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, FRAG_KEY, slug]) };
+    return { slug, fragmentPath: segsToStr([...segs, YO_KEY2, FRAGS_SUBKEY, slug]) };
   }
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
   let imagePtr = null;
@@ -69504,10 +70473,10 @@ function embedFragment(dataRoot, s2, mode, f2) {
       imagePtr = pointerToken(sidecarPointerRaw(CROP_SUBDIR, cropName, scope));
     }
   }
-  mkdirInside(dataRoot, path10.dirname(bodyFile), { recursive: true });
+  mkdirInside(dataRoot, path11.dirname(bodyFile), { recursive: true });
   const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
   writeBody(dataRoot, s2, bodyFile, upsertFragment(src, within, slug, (indent) => fragmentBlockLines(slug, f2.selector, imagePtr, indent)));
-  return { slug, fragmentPath: segsToStr([...segs, FRAG_KEY, slug]) };
+  return { slug, fragmentPath: segsToStr([...segs, YO_KEY2, FRAGS_SUBKEY, slug]) };
 }
 var thumbResKey = (w, h) => `[${w}, ${h}]`;
 var thumbName = (hash, w, h) => `${hash.replace(/:/g, "-")}-${w}x${h}.jpg`;
@@ -69515,13 +70484,13 @@ function existingThumb(dataRoot, s2, mode, segs, row, w, h) {
   if (!row.content_hash) return null;
   const { bodyFile } = hostFor(dataRoot, s2, segs);
   const { dir } = sidecarTarget(dataRoot, mode, THUMB_SUBDIR, bodyFile);
-  const abs = path10.join(dir, thumbName(row.content_hash, w, h));
+  const abs = path11.join(dir, thumbName(row.content_hash, w, h));
   return fs10.existsSync(abs) ? abs : null;
 }
 function embedThumbnail(dataRoot, s2, mode, segs, w, h, name, onWrite) {
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
   const { scope } = sidecarTarget(dataRoot, mode, THUMB_SUBDIR, bodyFile);
-  mkdirInside(dataRoot, path10.dirname(bodyFile), { recursive: true });
+  mkdirInside(dataRoot, path11.dirname(bodyFile), { recursive: true });
   const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
   const ptr3 = pointerToken(sidecarPointerRaw(THUMB_SUBDIR, name, scope));
   const key = thumbResKey(w, h);
@@ -69529,11 +70498,11 @@ function embedThumbnail(dataRoot, s2, mode, segs, w, h, name, onWrite) {
   onWrite?.(bodyFile);
 }
 async function ensureThumbnail(dataRoot, s2, mode, segs, row, w, h, hash, onWrite) {
-  const sourceAbs = path10.join(dataRoot, ...segs.map(String));
+  const sourceAbs = path11.join(dataRoot, ...segs.map(String));
   const name = thumbName(hash, w, h);
   const { bodyFile } = hostFor(dataRoot, s2, segs);
   const { dir } = sidecarTarget(dataRoot, mode, THUMB_SUBDIR, bodyFile);
-  const abs = path10.join(dir, name);
+  const abs = path11.join(dir, name);
   if (fs10.existsSync(abs)) return abs;
   const thumb = await renderThumbnail(fs10.readFileSync(sourceAbs), row.format ?? formatFromExt(sourceAbs), w, h);
   if (!thumb) return null;
@@ -69543,9 +70512,23 @@ async function ensureThumbnail(dataRoot, s2, mode, segs, row, w, h, hash, onWrit
   embedThumbnail(dataRoot, s2, mode, segs, w, h, name, onWrite);
   return abs;
 }
-function unembedAnnotation(dataRoot, s2, target, tag) {
+function unembedAnnotation(dataRoot, s2, target, tag, sel) {
   const segs = strToSegs(target || ":");
   const needle = (":" + pointerRaw(tag).replace(/^:+/, "")).replace(/\s+/g, "");
+  const pred = (line) => {
+    const t3 = line.replace(/\s+/g, "");
+    return t3.startsWith("&") && t3.includes(needle) && /:-$/.test(t3);
+  };
+  if (sel && sel.type === "text" && isChunkTarget(s2, segs)) {
+    const ok = rewriteInlineFragment(dataRoot, s2, segs, sel, (t3) => {
+      if (!t3) return false;
+      const kept = t3.bookmarks.filter((b) => !pred(b));
+      if (kept.length === t3.bookmarks.length) return false;
+      if (kept.length === 0 && t3.fields.length === 0 && t3.link === null) return null;
+      return fragTokenText(kept, t3.value, t3.parens);
+    });
+    if (ok) return chapterSource(dataRoot, s2, segs).bodyFile;
+  }
   if (isChunkTarget(s2, segs)) {
     const { docSegs, bodyFile: bodyFile2 } = chapterSource(dataRoot, s2, segs);
     if (!fs10.existsSync(bodyFile2)) return bodyFile2;
@@ -69557,12 +70540,12 @@ function unembedAnnotation(dataRoot, s2, target, tag) {
       /*ensureOmni*/
       false
     ), keys);
-    removeAnnotationAt(lines, fragRegion, (t3) => t3.replace(/\s+/g, "").includes(needle));
-    if (keys.length >= 2 && keys[keys.length - 2] === FRAG_KEY && !annotationsRemainAt(lines, fragRegion())) {
-      removeMapEntryAt(lines, reachBodyAt(lines, chunkFieldRegion(lines, indices, false), keys.slice(0, -2)), FRAG_KEY, keys[keys.length - 1]);
+    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]);
+      pruneEmptyKeyAt(lines, chunkFieldRegion(lines, indices, false), YO_KEY2);
       collapseChunkOmni(lines, indices);
-    } else if (keys.length === 0 && !annotationsRemainAt(lines, fragRegion())) {
-      pruneEmptyAnnotationsAt(lines, fragRegion());
+    } else if (keys.length === 0 && !bookmarksRemainAt(lines, fragRegion())) {
       collapseChunkOmni(lines, indices);
     }
     writeBody(dataRoot, s2, bodyFile2, lines.join("\n") + "\n");
@@ -69570,27 +70553,28 @@ function unembedAnnotation(dataRoot, s2, target, tag) {
   }
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
   if (!fs10.existsSync(bodyFile)) return bodyFile;
-  let src = removeAnnotation(fs10.readFileSync(bodyFile, "utf8"), within, (itemText) => itemText.replace(/\s+/g, "").includes(needle));
+  let src = removeBookmark(fs10.readFileSync(bodyFile, "utf8"), within, pred);
   const overlay2 = overlaidDir(bodyFile) !== null;
-  if (within.length >= 2 && within[within.length - 2] === FRAG_KEY && !annotationsRemain(src, within)) {
-    src = removeMapEntry(src, within.slice(0, -2), FRAG_KEY, within[within.length - 1]);
-    src = pruneEmptyAnnotations(src, within.slice(0, -2), overlay2);
+  if (isFragmentSegs(within) && !bookmarksRemain(src, within)) {
+    src = removeMapEntry(src, within.slice(0, -2), FRAGS_SUBKEY, within[within.length - 1]);
+    src = pruneEmptyYo(src, within.slice(0, -3));
+    src = pruneEmptyAnnotations(src, within.slice(0, -3), overlay2);
   } else {
     src = pruneEmptyAnnotations(src, within, overlay2);
   }
   writeBody(dataRoot, s2, bodyFile, src);
   return bodyFile;
 }
-function writeTag(dataRoot, s2, location, name) {
+function writeOnto(dataRoot, s2, location, name) {
   if (/[/\\\r\n:]/.test(name)) throw new Error("a tag name cannot contain '/', '\\', ':' or line breaks");
-  const root = path10.resolve(dataRoot);
-  const file = dirBodyFile(path10.resolve(dataRoot, ...strToSegs(location).map(String)));
-  if (!file.startsWith(root + path10.sep)) throw new Error("tags location escapes the data root");
-  const dir = path10.dirname(file);
+  const root = path11.resolve(dataRoot);
+  const file = dirBodyFile(path11.resolve(dataRoot, ...strToSegs(location).map(String)));
+  if (!file.startsWith(root + path11.sep)) throw new Error("tags location escapes the data root");
+  const dir = path11.dirname(file);
   const createdFile = !fs10.existsSync(file);
   const head = "# Named tags created from the annotation picker (settings.yo: tags.location).\n";
   const existing = createdFile ? head : fs10.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:onto>
 `;
   const entries = parseYamlover(body, file).root.entries ?? [];
   const pos = entries.findIndex((e3) => e3.key === name);
@@ -69632,7 +70616,7 @@ function handlePaste(dataRoot, s2, input) {
   if (intoChapter && !input.inline) return pasteIntoChapter(dataRoot, s2, segs, name, bytes);
   const dirSegs = nearestDirSegs(dataRoot, segs);
   if (!dirSegs) throw new Error("no enclosing directory to paste into");
-  const dir = path10.resolve(dataRoot, ...dirSegs.map(String));
+  const dir = path11.resolve(dataRoot, ...dirSegs.map(String));
   const final = uniqueName(dir, name);
   writeInside(dataRoot, dir, final, bytes);
   return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: !input.inline && dirSegs.length !== segs.length };
@@ -69640,7 +70624,7 @@ function handlePaste(dataRoot, s2, input) {
 function nearestDirSegs(dataRoot, segs) {
   for (let i2 = segs.length; i2 >= 0; i2--) {
     const sub = segs.slice(0, i2);
-    const abs = path10.resolve(dataRoot, ...sub.map(String));
+    const abs = path11.resolve(dataRoot, ...sub.map(String));
     if (fs10.existsSync(abs) && fs10.statSync(abs).isDirectory()) return sub;
   }
   return null;
@@ -69650,7 +70634,7 @@ var BLOCK_YAML = /\.(ya?ml|yo|yamlover)$/i;
 var JSON_FILE = /\.(json|json5|json5p)$/i;
 function resolveBacking(dataRoot, s2, segs) {
   const docSegs = documentRootSegs(s2, segs);
-  const docFs = path10.resolve(dataRoot, ...docSegs.map(String));
+  const docFs = path11.resolve(dataRoot, ...docSegs.map(String));
   const dirBacked = fs10.existsSync(docFs) && fs10.statSync(docFs).isDirectory();
   const bodyFile = dirBacked ? dirBodyFile(docFs) : docFs;
   return { docSegs, bodyFile, dirBacked };
@@ -69719,7 +70703,7 @@ function memberNeighbors(bodyFile, within, index) {
 function pasteIntoChapter(dataRoot, s2, segs, name, bytes) {
   const { docSegs, bodyFile, dirBacked } = chapterSource(dataRoot, s2, segs);
   const writeDirSegs = dirBacked ? docSegs : docSegs.slice(0, -1);
-  const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
+  const writeDir = path11.resolve(dataRoot, ...writeDirSegs.map(String));
   const final = uniqueName(writeDir, name);
   writeInside(dataRoot, writeDir, final, bytes);
   const fileSegs = [...writeDirSegs, final];
@@ -69739,7 +70723,7 @@ function pasteTextIntoChapter(dataRoot, s2, segs, text) {
 function pasteTextAsChapterFile(dataRoot, segs, text) {
   const dirSegs = nearestDirSegs(dataRoot, segs);
   if (!dirSegs) throw new Error("no enclosing directory to paste into");
-  const dir = path10.resolve(dataRoot, ...dirSegs.map(String));
+  const dir = path11.resolve(dataRoot, ...dirSegs.map(String));
   const title = titleFromText(text);
   const final = uniqueName(dir, chapterFileName(title));
   const src = ["!!<*::yamlover:$defs:chapter>", JSON.stringify(title), ...textChunkLines(text, 0), ""].join("\n");
@@ -69792,7 +70776,7 @@ function richBodyLines(rich, indent, pointerFor) {
 function pasteRichIntoChapter(dataRoot, s2, segs, rich) {
   const { docSegs, bodyFile, dirBacked } = chapterSource(dataRoot, s2, segs);
   const writeDirSegs = dirBacked ? docSegs : docSegs.slice(0, -1);
-  const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
+  const writeDir = path11.resolve(dataRoot, ...writeDirSegs.map(String));
   const files = [];
   const pointerFor = (name, bytes) => {
     const final = uniqueName(writeDir, name);
@@ -69809,7 +70793,7 @@ function pasteRichIntoChapter(dataRoot, s2, segs, rich) {
 function pasteRichAsChapter(dataRoot, segs, rich) {
   const dirSegs = nearestDirSegs(dataRoot, segs);
   if (!dirSegs) throw new Error("no enclosing directory to paste into");
-  const dir = path10.resolve(dataRoot, ...dirSegs.map(String));
+  const dir = path11.resolve(dataRoot, ...dirSegs.map(String));
   if (!rich.title && rich.chunks.length === 0 && rich.children.length === 1) rich = rich.children[0];
   const firstText = rich.chunks.find((c3) => "text" in c3);
   const title = rich.title ?? (firstText ? titleFromText(firstText.text) : rich.children[0]?.title ?? "Pasted content");
@@ -69822,10 +70806,10 @@ function pasteRichAsChapter(dataRoot, segs, rich) {
     return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
   }
   const name = uniqueName(dir, chapterFileName(title).replace(/\.yo$/, ""));
-  const chDir = path10.join(dir, name);
-  if (!path10.resolve(chDir).startsWith(path10.resolve(dataRoot) + path10.sep)) throw new Error("target escapes the data root");
+  const chDir = path11.join(dir, name);
+  if (!path11.resolve(chDir).startsWith(path11.resolve(dataRoot) + path11.sep)) throw new Error("target escapes the data root");
   const overlay2 = overlaySegs(memberFlavor(dir));
-  const overlayDir = path10.join(chDir, ...overlay2.slice(0, -1));
+  const overlayDir = path11.join(chDir, ...overlay2.slice(0, -1));
   mkdirInside(dataRoot, overlayDir, { recursive: true });
   const pointerFor = (fname, bytes) => {
     const final = uniqueName(chDir, fname);
@@ -69861,7 +70845,7 @@ function writeObject(dataRoot, dir, base, concrete, src) {
   if (isOverlayDirConcrete(concrete)) {
     const final2 = uniqueName(dir, base);
     const segs = overlaySegs(concrete);
-    const overlayDir = path10.join(dir, final2, ...segs.slice(0, -1));
+    const overlayDir = path11.join(dir, final2, ...segs.slice(0, -1));
     mkdirInside(dataRoot, overlayDir, { recursive: true });
     writeInside(dataRoot, overlayDir, segs[segs.length - 1], Buffer.from(src, "utf8"));
     return final2;
@@ -69873,9 +70857,9 @@ function writeObject(dataRoot, dir, base, concrete, src) {
 function ensureDirBody(dataRoot, absDir) {
   const body = dirBodyFile(absDir);
   if (!fs10.existsSync(body)) {
-    const overlayDir = path10.dirname(body);
+    const overlayDir = path11.dirname(body);
     mkdirInside(dataRoot, overlayDir, { recursive: true });
-    writeInside(dataRoot, overlayDir, path10.basename(body), Buffer.from("", "utf8"));
+    writeInside(dataRoot, overlayDir, path11.basename(body), Buffer.from("", "utf8"));
   }
   return body;
 }
@@ -69898,7 +70882,7 @@ function writeDirMemberTree(dataRoot, absDir, key, valueSrc, meta, flavor = memb
   if (!name || name === INDEX_FILE2 || name !== name.trim() || name.startsWith(".") || /[\\/:*?"<>|\u0000-\u001f]/.test(name)) {
     throw new Error(`\`${name}\` cannot name a directory member`);
   }
-  const dir = path10.join(absDir, name);
+  const dir = path11.join(absDir, name);
   if (fs10.existsSync(dir)) throw new Error(`member \`${name}\` already exists in the directory`);
   mkdirInside(dataRoot, dir);
   const f2 = payloadFacets(valueSrc);
@@ -69928,7 +70912,7 @@ function writeDirMemberTree(dataRoot, absDir, key, valueSrc, meta, flavor = memb
   if (selfAt >= 0 && !emittedSelf) emitSelf();
   if (bodyLines.length) {
     const segs = overlaySegs(flavor);
-    const overlayDir = path10.join(dir, ...segs.slice(0, -1));
+    const overlayDir = path11.join(dir, ...segs.slice(0, -1));
     mkdirInside(dataRoot, overlayDir, { recursive: true });
     writeInside(dataRoot, overlayDir, segs[segs.length - 1], Buffer.from(bodyLines.join("\n").replace(/\n*$/, "") + "\n", "utf8"));
   }
@@ -69938,20 +70922,20 @@ function chapterFileName(title) {
   return `${base || "pasted"}.yo`;
 }
 function sanitizeName(raw) {
-  const base = path10.basename(String(raw || "")).replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
+  const base = path11.basename(String(raw || "")).replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
   return base || "pasted";
 }
 function uniqueName(dir, name) {
-  if (!fs10.existsSync(path10.join(dir, name))) return name;
-  const ext = path10.extname(name);
+  if (!fs10.existsSync(path11.join(dir, name))) return name;
+  const ext = path11.extname(name);
   const stem = name.slice(0, name.length - ext.length);
   for (let i2 = 1; ; i2++) {
     const cand = `${stem}-${i2}${ext}`;
-    if (!fs10.existsSync(path10.join(dir, cand))) return cand;
+    if (!fs10.existsSync(path11.join(dir, cand))) return cand;
   }
 }
 function relPosix(dataRoot, abs) {
-  return path10.relative(dataRoot, abs).split(path10.sep).join("/");
+  return path11.relative(dataRoot, abs).split(path11.sep).join("/");
 }
 function scanTree(dataRoot, ignore2) {
   const nodes = [];
@@ -69965,12 +70949,12 @@ function scanTree(dataRoot, ignore2) {
     const names3 = entries.map((d2) => d2.name);
     nodes.push({
       path: segsToStr(segs),
-      concrete: dirConcreteFor(names3, fs10.existsSync(path10.join(abs, OVERLAY_DIR, BODY_FILE2))),
+      concrete: dirConcreteFor(names3, fs10.existsSync(path11.join(abs, OVERLAY_DIR, BODY_FILE2))),
       fsPath: segs.join("/"),
       names: names3
     });
     for (const d2 of entries) {
-      const childAbs = path10.join(abs, d2.name);
+      const childAbs = path11.join(abs, d2.name);
       if (ignore2?.(childAbs)) continue;
       if (d2.name.startsWith(".") && d2.name !== ".yo") continue;
       const childSegs = [...segs, d2.name];
@@ -69978,7 +70962,7 @@ function scanTree(dataRoot, ignore2) {
       else if (d2.isFile()) nodes.push({ path: segsToStr(childSegs), concrete: dataFileConcrete(childAbs), fsPath: childSegs.join("/") });
     }
   };
-  visit2(path10.resolve(dataRoot), []);
+  visit2(path11.resolve(dataRoot), []);
   return { nodes };
 }
 var validationLog = () => {
@@ -70001,9 +70985,9 @@ function guardPath(dataRoot, abs) {
 }
 function writeInside(dataRoot, dir, name, bytes) {
   if (readOnlyWrites) throw new Error("refused: server is read-only");
-  const root = path10.resolve(dataRoot);
-  const target = path10.resolve(dir, name);
-  if (target !== root && !target.startsWith(root + path10.sep)) throw new Error("target escapes the data root");
+  const root = path11.resolve(dataRoot);
+  const target = path11.resolve(dir, name);
+  if (target !== root && !target.startsWith(root + path11.sep)) throw new Error("target escapes the data root");
   guardPath(dataRoot, target);
   fs10.writeFileSync(target, bytes);
 }
@@ -70023,13 +71007,13 @@ function writeBody(dataRoot, s2, bodyFile, src) {
       throw new Error(`cannot edit ${segsToStr(owner)}: its source failed to parse and is shown degraded (${rel2}: ${pe.message ?? "syntax error"}) \u2014 fix the file on disk first`);
     }
   }
-  writeInside(dataRoot, path10.dirname(bodyFile), path10.basename(bodyFile), Buffer.from(src, "utf8"));
+  writeInside(dataRoot, path11.dirname(bodyFile), path11.basename(bodyFile), Buffer.from(src, "utf8"));
 }
 function mkdirInside(dataRoot, abs, opts) {
   guardPath(dataRoot, abs);
   fs10.mkdirSync(abs, opts);
 }
-var AGENT_DOCS_DIR = path10.join(path10.dirname(fileURLToPath3(import.meta.url)), "agent-docs");
+var AGENT_DOCS_DIR = path11.join(path11.dirname(fileURLToPath3(import.meta.url)), "agent-docs");
 function loadAgentDocs() {
   let names3;
   try {
@@ -70038,7 +71022,7 @@ function loadAgentDocs() {
     throw new Error(`agent-docs resources not found at ${AGENT_DOCS_DIR}`);
   }
   if (names3.length === 0) throw new Error(`no agent-docs resources at ${AGENT_DOCS_DIR}`);
-  return names3.map((name) => ({ name, content: fs10.readFileSync(path10.join(AGENT_DOCS_DIR, name), "utf8") }));
+  return names3.map((name) => ({ name, content: fs10.readFileSync(path11.join(AGENT_DOCS_DIR, name), "utf8") }));
 }
 var DOC_BEGIN = "<!-- BEGIN yamlover agent guide (auto-managed by `npx yamlover` \u2014 regenerated on reinstall) -->";
 var DOC_END = "<!-- END yamlover agent guide -->";
@@ -70050,8 +71034,8 @@ ${DOC_END}
   if (existing === null) return { text: block, status: "created" };
   const b = existing.indexOf(DOC_BEGIN);
   if (b === -1) {
-    const sep2 = existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
-    return { text: existing + sep2 + block, status: "appended" };
+    const sep3 = existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+    return { text: existing + sep3 + block, status: "appended" };
   }
   const e3 = existing.indexOf(DOC_END, b);
   const end = e3 === -1 ? existing.length : e3 + DOC_END.length;
@@ -70307,11 +71291,15 @@ function preferPlainScalar(src) {
   }
   return src;
 }
-function renderNode(f2, indent, marker, tag) {
+function renderNode(f2, indent, marker, tag, flat) {
   const pad = " ".repeat(indent);
   const childPad = " ".repeat(indent + 2);
   const groups = orderedGroups(f2);
   const child = (g) => g.map((l2) => l2.trim().length ? childPad + l2 : "");
+  if (flat === true && !marker.startsWith("-") && f2.scalar === void 0 && !tag && f2.keyed.length === 1 && (f2.ordinal ?? []).length === 0) {
+    const [g0] = groups;
+    return [`${pad}${marker}${g0[0]}`, ...child(g0.slice(1))];
+  }
   const selfAt = f2.scalar !== void 0 ? Math.min(f2.selfAt ?? 0, groups.length) : 0;
   if (f2.scalar !== void 0 && selfAt > 0) {
     const selfLines = child(preferPlainScalar(f2.scalar).split("\n"));
@@ -70378,14 +71366,14 @@ function trailingCommentOf(line) {
   }
   return null;
 }
-function assignAt(lines, r2, seg, op, valueSrc, meta, key, at) {
+function assignAt(lines, r2, seg, op, valueSrc, meta, key, at, flat) {
   const marker = (s2) => typeof s2 === "string" ? `${keyToken(s2)}: ` : s2 === null ? "~: " : "- ";
   if (op === "insert") {
     if (typeof seg !== "number" && seg !== void 0) throw new Error("`insert` needs a positional target (a path ending in a bare index, or the node itself)");
     const entries = chapterEntries(lines, r2);
     const entry2 = seg === void 0 ? void 0 : entries[seg];
     const at2 = entry2 ? entry2.start : seg !== void 0 && entries.length ? entries[entries.length - 1].end : bodyAppendPoint(lines, r2);
-    lines.splice(at2, 0, ...renderNode(payloadFacets(valueSrc), r2.indent, key !== void 0 ? `${keyToken(key)}: ` : "- ", metaTag(meta, void 0, false)));
+    lines.splice(at2, 0, ...renderNode(payloadFacets(valueSrc), r2.indent, key !== void 0 ? `${keyToken(key)}: ` : "- ", metaTag(meta, void 0, false), key !== void 0 && flat === true));
     return;
   }
   if (seg === void 0) throw new Error(`\`${op}\` needs a key or index target`);
@@ -70452,9 +71440,15 @@ function assignAt(lines, r2, seg, op, valueSrc, meta, key, at) {
     lines[entry.start] = (inlineKey ? `${pad}- ${tag ? tag + " " : ""}${inlineKey}: ${next.scalar ?? '""'}` : `${pad}- - ${tag ? tag + " " : ""}${next.scalar ?? '""'}`) + (headTrail ?? "");
     return;
   }
+  const anchorLines = op === "emplace" ? lines.slice(entry.start + 1, entry.end).filter((l2) => isContentLine2(l2) && indentOf2(l2) === r2.indent + 2 && l2.trim().startsWith("&")) : [];
   const rendered = renderNode(next, r2.indent, marker(seg), tag);
   if (headTrail !== null && rendered.length > 0 && trailingCommentOf(rendered[0]) === null) rendered[0] += headTrail;
-  lines.splice(entry.start, entry.end - entry.start, ...rendered);
+  const payloadHasAnchors = rendered.some((l2) => isContentLine2(l2) && l2.trim().startsWith("&"));
+  const carried = payloadHasAnchors ? [] : anchorLines;
+  if (carried.length && rendered.length > 1 && /[|>][+-]?\s*$/.test(rendered[0].replace(/\s+#.*$/, ""))) {
+    for (let i2 = 1; i2 < rendered.length; i2++) if (rendered[i2].trim()) rendered[i2] = "  " + rendered[i2];
+  }
+  lines.splice(entry.start, entry.end - entry.start, ...rendered, ...carried);
 }
 function reachChapterItem(lines, indices) {
   const parent = reachChapter(lines, indices.slice(0, -1));
@@ -70730,11 +71724,11 @@ function editFlowRowCell(lines, row, cellIdx, op, valueSrc) {
   lines[row.start] = raw.slice(0, cell.start) + lead + flowCellToken(text) + raw.slice(cell.end);
   return true;
 }
-function editChapterSource(src, within, op, valueSrc, meta, key, at) {
+function editChapterSource(src, within, op, valueSrc, meta, key, at, flat) {
   const lines = src.split("\n");
   if (within.length === 0) {
     if (op === "insert") {
-      assignAt(lines, reachChapter(lines, []), void 0, op, valueSrc, meta, key);
+      assignAt(lines, reachChapter(lines, []), void 0, op, valueSrc, meta, key, void 0, flat);
       return lines.join("\n");
     }
     if (op === "emplace") {
@@ -70781,7 +71775,7 @@ function editChapterSource(src, within, op, valueSrc, meta, key, at) {
       return lines.join("\n");
     }
   }
-  assignAt(lines, reachChapter(lines, within.slice(0, -1)), within[within.length - 1], op, valueSrc, meta, key, at);
+  assignAt(lines, reachChapter(lines, within.slice(0, -1)), within[within.length - 1], op, valueSrc, meta, key, at, flat);
   return lines.join("\n");
 }
 function jsonValueSpan(src, es, ee) {
@@ -70834,14 +71828,14 @@ function fsDocRootSegs(dataRoot, segs) {
   for (let i2 = segs.length; i2 >= 0; i2--) {
     const sub = segs.slice(0, i2);
     if (!sub.every((g) => typeof g === "string")) continue;
-    const body = dirBodyFile(path10.resolve(dataRoot, ...sub.map(String)));
+    const body = dirBodyFile(path11.resolve(dataRoot, ...sub.map(String)));
     if (fs10.existsSync(body)) return { docSegs: sub, bodyFile: body };
   }
   return null;
 }
 function isPlainDir(dataRoot, s2, segs) {
   if (!segs.every((g) => typeof g === "string")) return false;
-  const abs = path10.resolve(dataRoot, ...segs.map(String));
+  const abs = path11.resolve(dataRoot, ...segs.map(String));
   if (!fs10.existsSync(abs) || !fs10.statSync(abs).isDirectory()) return false;
   try {
     chapterSource(dataRoot, s2, segs);
@@ -70868,7 +71862,7 @@ function canonSegs(s2, segs, keepLast) {
 }
 function bornAsDocument(dataRoot, e3, tag, neighbors = {}) {
   const writeDirSegs = e3.dirBacked ? e3.docSegs : e3.docSegs.slice(0, -1);
-  const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
+  const writeDir = path11.resolve(dataRoot, ...writeDirSegs.map(String));
   const src = [...tag ? [tag] : [], e3.valueSrc, ""].join("\n");
   const title = String(e3.name || "object");
   const base = isOverlayDirConcrete(e3.concrete) ? nextMemberName(fs10.existsSync(writeDir) ? fs10.readdirSync(writeDir) : [], "title", { ...neighbors, title }) : pointerSafeName(title);
@@ -70905,7 +71899,7 @@ function applyEdits2(dataRoot, s2, edits) {
       return "";
     }
     try {
-      for (const o2 of byFile.get(bodyFile) ?? []) src = editChapterSource(src, o2.within, o2.op, o2.valueSrc, o2.meta, o2.key, o2.at);
+      for (const o2 of byFile.get(bodyFile) ?? []) src = editChapterSource(src, o2.within, o2.op, o2.valueSrc, o2.meta, o2.key, o2.at, o2.flat);
     } catch {
       return src;
     }
@@ -70915,7 +71909,7 @@ function applyEdits2(dataRoot, s2, edits) {
     const editSegs = applyRemap(canonSegs(s2, strToSegs(e3.path ?? ""), true));
     const op = String(e3.op ?? "");
     if (op === "insert" && (e3.concrete === "file/yamlover" || isOverlayDirConcrete(e3.concrete)) && isPlainDir(dataRoot, s2, editSegs)) {
-      const dir = path10.resolve(dataRoot, ...editSegs.map(String));
+      const dir = path11.resolve(dataRoot, ...editSegs.map(String));
       const src = [...metaTag(e3.meta, void 0, false) ? [metaTag(e3.meta, void 0, false)] : [], String(e3.yamlover ?? ""), ""].join("\n");
       if (e3.yamlover) parseYamlover(String(e3.yamlover), "<edit>");
       const final = writeObject(dataRoot, dir, objectBaseName(String(e3.name || "new")), String(e3.concrete), src);
@@ -70924,16 +71918,16 @@ function applyEdits2(dataRoot, s2, edits) {
     }
     if (op === "insert" && e3.concrete === "dir") {
       if (!editSegs.every((g) => typeof g === "string")) throw new Error("a folder needs a directory parent");
-      const abs = path10.resolve(dataRoot, ...editSegs.map(String));
+      const abs = path11.resolve(dataRoot, ...editSegs.map(String));
       if (!fs10.existsSync(abs) || !fs10.statSync(abs).isDirectory()) throw new Error("a folder can only be created inside a directory");
       const final = uniqueName(abs, objectBaseName(String(e3.name || "New Folder")));
-      mkdirInside(dataRoot, path10.join(abs, final));
+      mkdirInside(dataRoot, path11.join(abs, final));
       created.push(segsToStr([...editSegs, final]));
       continue;
     }
     {
       const stripped = op === "insert" && typeof editSegs[editSegs.length - 1] === "number" ? editSegs.slice(0, -1) : editSegs;
-      const absDir = stripped.every((g) => typeof g === "string") ? path10.resolve(dataRoot, ...stripped.map(String)) : null;
+      const absDir = stripped.every((g) => typeof g === "string") ? path11.resolve(dataRoot, ...stripped.map(String)) : null;
       const isDirTarget = absDir !== null && fs10.existsSync(absDir) && fs10.statSync(absDir).isDirectory();
       if (isDirTarget) {
         const bodyFile2 = dirBodyFile(absDir);
@@ -70974,7 +71968,7 @@ function applyEdits2(dataRoot, s2, edits) {
             route,
             explicitConcrete: e3.concrete ?? null,
             memberName,
-            writes: memberName ? [{ kind: "dir", fsPath: relPosix(dataRoot, path10.join(absDir, memberName)), concrete: memberConcrete }, ...route === "dir-seq" ? [bodySplice] : []] : [bodySplice]
+            writes: memberName ? [{ kind: "dir", fsPath: relPosix(dataRoot, path11.join(absDir, memberName)), concrete: memberConcrete }, ...route === "dir-seq" ? [bodySplice] : []] : [bodySplice]
           };
           logDiagnostics(enforce(validateWrite(snap), validationMode()));
           if (route === "dir") {
@@ -71016,7 +72010,7 @@ function applyEdits2(dataRoot, s2, edits) {
       const inlineKeyed = typeof nodeKey === "string" && nodeSegs.every((g) => typeof g === "string") && inlineHere;
       const inlineOrdinal = typeof nodeKey === "number" && inlineHere && nBack.docSegs.every((g) => typeof g === "string");
       const docRow = inlineKeyed || inlineOrdinal ? s2.node(storePath(nBack.docSegs)) : null;
-      const encConcrete = docRow ? concreteOf(s2, dataRoot, nBack.docSegs, docRow) : nBack.dirBacked ? dirConcreteOf(path10.resolve(dataRoot, ...nBack.docSegs.map(String))) : "yamlover";
+      const encConcrete = docRow ? concreteOf(s2, dataRoot, nBack.docSegs, docRow) : nBack.dirBacked ? dirConcreteOf(path11.resolve(dataRoot, ...nBack.docSegs.map(String))) : "yamlover";
       if ((inlineKeyed || inlineOrdinal) && subchapterMaterializes(encConcrete)) {
         let memberSrc = null;
         let memberMeta;
@@ -71077,7 +72071,7 @@ function applyEdits2(dataRoot, s2, edits) {
         const enc = memberSrc === null ? "body" : deriveMemberEncoding({ keyed: inlineKeyed, container: true, tagged: typeof memberMeta === "string" || rootIsYo(memberSrc), insideContent });
         if (enc !== "body") {
           if (memberSrc && !isPointerValue(memberSrc)) parseYamlover(memberSrc, "<edit>");
-          const docAbs = path10.resolve(dataRoot, ...nBack.docSegs.map(String));
+          const docAbs = path11.resolve(dataRoot, ...nBack.docSegs.map(String));
           const within = nodeSegs.slice(nBack.docSegs.length);
           const idx = within[within.length - 1];
           const names3 = fs10.readdirSync(docAbs);
@@ -71091,7 +72085,7 @@ function applyEdits2(dataRoot, s2, edits) {
                 route: enc,
                 memberName,
                 writes: [
-                  { kind: "dir", fsPath: relPosix(dataRoot, path10.join(docAbs, memberName)), concrete: memberConcrete },
+                  { kind: "dir", fsPath: relPosix(dataRoot, path11.join(docAbs, memberName)), concrete: memberConcrete },
                   { kind: "splice", fsPath: relPosix(dataRoot, nBack.bodyFile) }
                 ]
               }),
@@ -71147,11 +72141,11 @@ function applyEdits2(dataRoot, s2, edits) {
       } catch {
       }
       if (detach === null) {
-        const memberAbs2 = path10.resolve(dataRoot, ...editSegs.map(String));
-        const trashDir = path10.join(path10.dirname(memberAbs2), ".yo", ".trash");
+        const memberAbs2 = path11.resolve(dataRoot, ...editSegs.map(String));
+        const trashDir = path11.join(path11.dirname(memberAbs2), ".yo", ".trash");
         fs10.mkdirSync(trashDir, { recursive: true });
-        let dest = path10.join(trashDir, memberName);
-        for (let n2 = 2; fs10.existsSync(dest); n2++) dest = path10.join(trashDir, `${memberName}-${n2}`);
+        let dest = path11.join(trashDir, memberName);
+        for (let n2 = 2; fs10.existsSync(dest); n2++) dest = path11.join(trashDir, `${memberName}-${n2}`);
         console.warn(`[/api/edit] remove of ORPHANED member ${segsToStr(editSegs)}: archived ${memberAbs2} -> ${dest}`);
         fs10.renameSync(memberAbs2, dest);
         movedStorage = true;
@@ -71160,7 +72154,7 @@ function applyEdits2(dataRoot, s2, edits) {
       const list2 = byFile.get(detachFile) ?? [];
       list2.push(detach);
       byFile.set(detachFile, list2);
-      const memberAbs = path10.resolve(dataRoot, ...editSegs.map(String));
+      const memberAbs = path11.resolve(dataRoot, ...editSegs.map(String));
       if (fs10.existsSync(memberAbs)) pendingArchives.push({ abs: memberAbs, name: memberName });
       continue;
     }
@@ -71182,6 +72176,7 @@ function applyEdits2(dataRoot, s2, edits) {
       name: e3.name ? String(e3.name) : void 0,
       key: e3.key === void 0 ? void 0 : String(e3.key),
       at: typeof e3.at === "number" && Number.isFinite(e3.at) && e3.at >= 0 ? Math.floor(e3.at) : void 0,
+      flat: e3.flat === true ? true : void 0,
       docSegs,
       dirBacked
     };
@@ -71210,7 +72205,7 @@ function applyEdits2(dataRoot, s2, edits) {
     for (const o2 of ops) {
       const { valueSrc, meta } = o2;
       if (valueSrc && !isPointerValue(valueSrc)) parseYamlover(valueSrc, "<edit>");
-      src = editChapterSource(src, o2.within, o2.op, valueSrc, meta, o2.key, o2.at);
+      src = editChapterSource(src, o2.within, o2.op, valueSrc, meta, o2.key, o2.at, o2.flat);
     }
     parseYamlover(src, bodyFile);
     pendingWrites.push([bodyFile, src]);
@@ -71228,20 +72223,20 @@ function applyEdits2(dataRoot, s2, edits) {
   }
   for (const a2 of pendingArchives) {
     if (!fs10.existsSync(a2.abs)) continue;
-    const trashDir = path10.join(path10.dirname(a2.abs), ".yo", ".trash");
+    const trashDir = path11.join(path11.dirname(a2.abs), ".yo", ".trash");
     fs10.mkdirSync(trashDir, { recursive: true });
-    let dest = path10.join(trashDir, a2.name);
-    for (let n2 = 2; fs10.existsSync(dest); n2++) dest = path10.join(trashDir, `${a2.name}-${n2}`);
+    let dest = path11.join(trashDir, a2.name);
+    for (let n2 = 2; fs10.existsSync(dest); n2++) dest = path11.join(trashDir, `${a2.name}-${n2}`);
     console.warn(`[/api/edit] remove of member: archived ${a2.abs} -> ${dest}`);
     fs10.renameSync(a2.abs, dest);
     movedStorage = true;
   }
   return { touched, created, appended, movedStorage };
 }
-var PREVIEW_ROOT = path10.join(os.tmpdir(), ".yo-preview-nonexistent");
+var PREVIEW_ROOT = path11.join(os.tmpdir(), ".yo-preview-nonexistent");
 function envelopeDeps(s2, dataRoot, membersOnDisk) {
   return {
-    memberExists: (sg) => membersOnDisk && sg.every((x2) => typeof x2 === "string") && fs10.existsSync(path10.resolve(dataRoot, ...sg.map(String))),
+    memberExists: (sg) => membersOnDisk && sg.every((x2) => typeof x2 === "string") && fs10.existsSync(path11.resolve(dataRoot, ...sg.map(String))),
     formatAt: (sg) => s2.node(storePath(sg))?.format ?? null,
     stub: (sg) => s2.node(storePath(sg)) ? linkMarker(dataRoot, s2, sg) : null,
     refTargetAt: (holder, pos) => {
@@ -71424,7 +72419,7 @@ var EXT_CT = {
   ".epub": "application/epub+zip"
 };
 function formatFromExt(file) {
-  return EXT_CT[path10.extname(file).toLowerCase()] ?? null;
+  return EXT_CT[path11.extname(file).toLowerCase()] ?? null;
 }
 var UTF8_CT = /* @__PURE__ */ new Set([
   "text/html",
@@ -71449,8 +72444,8 @@ function defaultDepth(s2, dataRoot, segs, row, kind) {
   if (kind === "binary") return 1;
   return isDirConcrete(concreteOf(s2, dataRoot, segs, row)) ? 1 : Infinity;
 }
-function refMarker(text, path11) {
-  return { [REF_KEY]: { text, path: path11 } };
+function refMarker(text, path12) {
+  return { [REF_KEY]: { text, path: path12 } };
 }
 function clampThumbDim(raw, def) {
   const n2 = raw == null ? NaN : Math.round(Number(raw));