yamlover 0.3.11 → 0.3.13

package/dist/server.js

@@ -5645,7 +5645,7 @@ var require_gifframe = __commonJS({
 var require_gifutil = __commonJS({
   "node_modules/gifwrap/src/gifutil.js"(exports) {
     "use strict";
-    var fs10 = __require("fs");
+    var fs11 = __require("fs");
     var ImageQ = require_image_q();
     var BitmapImage2 = require_bitmapimage();
     var { GifFrame: GifFrame2 } = require_gifframe();
@@ -5760,14 +5760,14 @@ var require_gifutil = __commonJS({
       jimpImage.bitmap.data = bitmapImageToShare.bitmap.data;
       return jimpImage;
     };
-    exports.write = function(path10, frames, spec, encoder) {
+    exports.write = function(path11, frames, spec, encoder) {
       encoder = encoder || defaultCodec;
-      const matches = path10.match(/\.[a-zA-Z]+$/);
+      const matches = path11.match(/\.[a-zA-Z]+$/);
       if (matches !== null && INVALID_SUFFIXES.includes(matches[0].toLowerCase())) {
-        throw new Error(`GIF '${path10}' has an unexpected suffix`);
+        throw new Error(`GIF '${path11}' has an unexpected suffix`);
       }
       return encoder.encodeGif(frames, spec).then((gif2) => {
-        return _writeBinary(path10, gif2.buffer).then(() => {
+        return _writeBinary(path11, gif2.buffer).then(() => {
           return gif2;
         });
       });
@@ -5839,9 +5839,9 @@ var require_gifutil = __commonJS({
         }
       }
     }
-    function _readBinary(path10) {
+    function _readBinary(path11) {
       return new Promise((resolve3, reject) => {
-        fs10.readFile(path10, (err, buffer) => {
+        fs11.readFile(path11, (err, buffer) => {
           if (err) {
             return reject(err);
           }
@@ -5849,9 +5849,9 @@ var require_gifutil = __commonJS({
         });
       });
     }
-    function _writeBinary(path10, buffer) {
+    function _writeBinary(path11, buffer) {
       return new Promise((resolve3, reject) => {
-        fs10.writeFile(path10, buffer, (err) => {
+        fs11.writeFile(path11, 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(path10) {
+        load: function load(path11) {
           var xhr = new XMLHttpRequest();
-          xhr.open("GET", path10, true);
+          xhr.open("GET", path11, 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: path10, errorMaps, issueData } = params;
-      const fullPath = [...path10, ...issueData.path || []];
+      const { data, path: path11, errorMaps, issueData } = params;
+      const fullPath = [...path11, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -19034,11 +19034,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path10, key) {
+      constructor(parent, value, path11, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path10;
+        this._path = path11;
         this._key = key;
       }
       get path() {
@@ -23988,13 +23988,13 @@ var require_await_to_js_umd = __commonJS({
 });
 
 // node_modules/@jimp/file-ops/dist/esm/index.js
-import { promises as fs5 } from "fs";
+import { promises as fs6 } from "fs";
 import { existsSync as existsSync2 } from "fs";
 var readFile, writeFile;
 var init_esm13 = __esm({
   "node_modules/@jimp/file-ops/dist/esm/index.js"() {
-    readFile = fs5.readFile;
-    writeFile = fs5.writeFile;
+    readFile = fs6.readFile;
+    writeFile = fs6.writeFile;
   }
 });
 
@@ -24036,11 +24036,11 @@ var require_Mime = __commonJS({
         }
       }
     };
-    Mime.prototype.getType = function(path10) {
-      path10 = String(path10);
-      let last = path10.replace(/^.*[/\\]/, "").toLowerCase();
+    Mime.prototype.getType = function(path11) {
+      path11 = String(path11);
+      let last = path11.replace(/^.*[/\\]/, "").toLowerCase();
       let ext = last.replace(/^.*\./, "").toLowerCase();
-      let hasPath = last.length < path10.length;
+      let hasPath = last.length < path11.length;
       let hasDot = ext.length < last.length - 1;
       return (hasDot || !hasPath) && this._types[ext] || null;
     };
@@ -30569,7 +30569,7 @@ __export(file_type_exports, {
 });
 import { ReadableStream as WebReadableStream } from "node:stream/web";
 import { pipeline, PassThrough, Readable } from "node:stream";
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import { constants as fileSystemConstants } from "node:fs";
 function isTokenizerStreamBoundsError(error) {
   if (!(error instanceof RangeError) || error.message !== "offset is out of bounds" || typeof error.stack !== "string") {
@@ -30577,8 +30577,8 @@ function isTokenizerStreamBoundsError(error) {
   }
   return /strtok3[/\\]lib[/\\]stream[/\\]/.test(error.stack);
 }
-async function fileTypeFromFile(path10, options) {
-  return new FileTypeParser2(options).fromFile(path10, options);
+async function fileTypeFromFile(path11, options) {
+  return new FileTypeParser2(options).fromFile(path11, options);
 }
 async function fileTypeFromStream(stream, options) {
   return new FileTypeParser2(options).fromStream(stream);
@@ -30609,9 +30609,9 @@ var init_file_type = __esm({
           }
         }
       }
-      async fromFile(path10) {
+      async fromFile(path11) {
         this.options.signal?.throwIfAborted();
-        const fileHandle = await fs6.open(path10, fileSystemConstants.O_RDONLY | fileSystemConstants.O_NONBLOCK);
+        const fileHandle = await fs7.open(path11, 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: path10,
+            path: path11,
             size: fileStat.size
           }
         });
@@ -30955,9 +30955,9 @@ function createJimp({ plugins: pluginsArg, formats: formatsArg } = {}) {
      * await image.write("test/output.png");
      * ```
      */
-    async write(path10, options) {
-      const mimeType = import_lite.default.getType(path10);
-      await writeFile(path10, await this.getBuffer(mimeType, options));
+    async write(path11, options) {
+      const mimeType = import_lite.default.getType(path11);
+      await writeFile(path11, 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 path6 from "path";
+import path7 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(path6.join(path6.dirname(file), page))))
+    pages: await Promise.all(font.pages.map(async (page) => CharacterJimp.read(path7.join(path7.dirname(file), page))))
   };
 }
 var import_parse_bmfont_ascii, import_parse_bmfont_xml, import_parse_bmfont_binary, convertXML, isWebWorker, CharacterJimp, HEADER;
@@ -42493,9 +42493,9 @@ var init_load_bitmap_font = __esm({
 async function loadFont(file) {
   let fileOrBuffer = file;
   if (typeof window === "undefined" && !isWebWorker) {
-    const { existsSync: existsSync3, promises: fs10 } = await import("fs");
+    const { existsSync: existsSync3, promises: fs11 } = await import("fs");
     if (existsSync3(file)) {
-      fileOrBuffer = await fs10.readFile(file);
+      fileOrBuffer = await fs11.readFile(file);
     }
   }
   const data = await loadBitmapFontData(fileOrBuffer);
@@ -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 path10 = (0, psdReader_1.readUnicodeStringWithLengthLE)(reader, charsCount);
-          return { sig, path: path10 };
+          var path11 = (0, psdReader_1.readUnicodeStringWithLengthLE)(reader, charsCount);
+          return { sig, path: path11 };
         }
         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 path10 = void 0;
+      var path11 = 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);
-            path10 = {
+            path11 = {
               open: selector === 3,
               knots: [],
               fillRule: flags === 2 ? "non-zero" : "even-odd"
             };
             if (boolOp !== -1)
-              path10.operation = exports.booleanOperations[boolOp];
-            paths.push(path10);
+              path11.operation = exports.booleanOperations[boolOp];
+            paths.push(path11);
             break;
           }
           case 1:
           case 2:
           case 4:
           case 5:
-            path10.knots.push({ linked: selector === 1 || selector === 4, points: readBezierKnot(reader, width, height) });
+            path11.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 path10 = _b[_i];
-        (0, psdWriter_1.writeUint16)(writer, path10.open ? 3 : 0);
-        (0, psdWriter_1.writeUint16)(writer, path10.knots.length);
-        (0, psdWriter_1.writeUint16)(writer, path10.operation ? exports.booleanOperations.indexOf(path10.operation) : -1);
-        (0, psdWriter_1.writeUint16)(writer, path10.fillRule === "non-zero" ? 2 : 1);
+        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);
         (0, psdWriter_1.writeZeros)(writer, 18);
-        var linkedKnot = path10.open ? 4 : 1;
-        var unlinkedKnot = path10.open ? 5 : 2;
-        for (var _c = 0, _d = path10.knots; _c < _d.length; _c++) {
+        var linkedKnot = path11.open ? 4 : 1;
+        var unlinkedKnot = path11.open ? 5 : 2;
+        for (var _c = 0, _d = path11.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(path10) {
+                      SbpL: c3.paths.map(function(path11) {
                         return {
                           _name: "",
                           _classID: "Sbpl",
-                          Clsp: path10.closed,
-                          "Pts ": path10.points.map(function(pt) {
+                          Clsp: path11.closed,
+                          "Pts ": path11.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(path10) {
+        function locateFile(path11) {
           if (Module3["locateFile"]) {
-            return Module3["locateFile"](path10, scriptDirectory);
+            return Module3["locateFile"](path11, scriptDirectory);
           }
-          return scriptDirectory + path10;
+          return scriptDirectory + path11;
         }
         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(path10) {
+        function locateFile(path11) {
           if (Module3["locateFile"]) {
-            return Module3["locateFile"](path10, scriptDirectory);
+            return Module3["locateFile"](path11, scriptDirectory);
           }
-          return scriptDirectory + path10;
+          return scriptDirectory + path11;
         }
         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 = (path10, originalPath, doThrow) => {
-      if (!isString(path10)) {
+    var checkPath = (path11, originalPath, doThrow) => {
+      if (!isString(path11)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path10) {
+      if (!path11) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path10)) {
+      if (checkPath.isNotRelative(path11)) {
         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 = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+    var isNotRelative = (path11) => REGEX_TEST_INVALID_PATH.test(path11);
     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(path10, checkUnignored) {
+      _testOne(path11, 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(path10);
+          const matched = rule.regex.test(path11);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -62270,24 +62270,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path10 = originalPath && checkPath.convert(originalPath);
+        const path11 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path10,
+          path11,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path10, cache, checkUnignored, slices);
+        return this._t(path11, cache, checkUnignored, slices);
       }
-      _t(path10, cache, checkUnignored, slices) {
-        if (path10 in cache) {
-          return cache[path10];
+      _t(path11, cache, checkUnignored, slices) {
+        if (path11 in cache) {
+          return cache[path11];
         }
         if (!slices) {
-          slices = path10.split(SLASH);
+          slices = path11.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path10] = this._testOne(path10, checkUnignored);
+          return cache[path11] = this._testOne(path11, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -62295,24 +62295,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path10] = parent.ignored ? parent : this._testOne(path10, checkUnignored);
+        return cache[path11] = parent.ignored ? parent : this._testOne(path11, checkUnignored);
       }
-      ignores(path10) {
-        return this._test(path10, this._ignoreCache, false).ignored;
+      ignores(path11) {
+        return this._test(path11, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path10) => !this.ignores(path10);
+        return (path11) => !this.ignores(path11);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path10) {
-        return this._test(path10, this._testCache, true);
+      test(path11) {
+        return this._test(path11, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+    var isPathValid = (path11) => checkPath(path11 && checkPath.convert(path11), path11, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -62323,15 +62323,15 @@ 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 = (path10) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+      checkPath.isNotRelative = (path11) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path11) || isNotRelative(path11);
     }
   }
 });
 
 // src/server/engine-api.ts
-import path9 from "node:path";
-import fs9 from "node:fs";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path10 from "node:path";
+import fs10 from "node:fs";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../parser/ts/src/ir.ts
 function isPointer(v) {
@@ -62360,6 +62360,7 @@ function entryPlain(e3) {
 }
 
 // ../engine/ts/src/resolve.ts
+var YAMLOVER_AUTHORITY = "yamlover.inthemoon.net";
 function resolveDocument(doc) {
   const chains = buildChains(doc.root);
   const { edges: anchorEdges, keys } = realizeAnchors(doc, chains);
@@ -62447,8 +62448,10 @@ function resolve(doc, chains, fromChain, ptr, visited, anchorKeys) {
   switch (ptr.base.scope) {
     case "link": {
       chain = chains.get(root) ?? [root];
-      const selfImport = ptr.base.authority === "yamlover" && !root.entries?.some((e3) => e3.key === "yamlover");
-      steps = selfImport ? ptr.steps : [{ sel: "key", name: ptr.base.authority }, ...ptr.steps];
+      let authority = ptr.base.authority;
+      if (isWorld && authority === YAMLOVER_AUTHORITY) authority = "yamlover";
+      const selfImport = authority === "yamlover" && !root.entries?.some((e3) => e3.key === "yamlover");
+      steps = selfImport ? ptr.steps : [{ sel: "key", name: authority }, ...ptr.steps];
       break;
     }
     case "document": {
@@ -62605,7 +62608,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, ":", (path10, node, parent, label, pos) => {
+      walkNodes(doc.root, ":", (path11, node, parent, label, pos) => {
         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);
@@ -62613,8 +62616,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(path10, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
-        if (parent !== null) insEdge.run(parent, path10, label, "contain", pos);
+        insNode.run(path11, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
+        if (parent !== null) insEdge.run(parent, path11, label, "contain", pos);
       });
       const insDangling = this.db.prepare("INSERT INTO dangling (from_path, raw, reason) VALUES (?, ?, ?)");
       for (const r2 of resolveDocument(doc)) {
@@ -62829,29 +62832,29 @@ var Store = class {
     }));
   }
   /** A node's attributes (null if no such path). */
-  node(path10) {
-    const row = this.db.prepare("SELECT * FROM node WHERE path = ?").get(path10);
+  node(path11) {
+    const row = this.db.prepare("SELECT * FROM node WHERE path = ?").get(path11);
     return row ? rowToNode(row) : null;
   }
   /** Direct containment children of a node, in source order (by `pos`). */
-  children(path10) {
-    return this.db.prepare("SELECT to_path, label, pos FROM edge WHERE from_path = ? AND kind = 'contain' ORDER BY pos").all(path10).map((r2) => ({ to: r2.to_path, label: r2.label ?? null, pos: r2.pos ?? null }));
+  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 }));
   }
   /** 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(path10) {
-    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(path10).map((r2) => ({ to: r2.to_path, label: r2.label ?? null, pos: r2.pos ?? null, kind: r2.kind }));
+  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 }));
   }
   /** Whether a node has any containment children (expandable in the TOC). */
-  hasChildren(path10) {
-    const r2 = this.db.prepare("SELECT 1 FROM edge WHERE from_path = ? AND kind = 'contain' LIMIT 1").get(path10);
+  hasChildren(path11) {
+    const r2 = this.db.prepare("SELECT 1 FROM edge WHERE from_path = ? AND kind = 'contain' LIMIT 1").get(path11);
     return r2 != null;
   }
   /** The containment subtree rooted at `path`, up to `depth` levels (TOC). A recursive CTE
    *  over `contain` edges — the acyclic spine; ordered by `pos` at each level. */
-  toc(path10 = ":", depth = Infinity) {
+  toc(path11 = ":", depth = Infinity) {
     const rows = this.db.prepare(
       `WITH RECURSIVE sub(from_path, to_path, label, pos, lvl) AS (
            SELECT from_path, to_path, label, pos, 1 FROM edge
@@ -62864,10 +62867,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(path10, depth === Infinity ? Number.MAX_SAFE_INTEGER : depth);
+    ).all(path11, depth === Infinity ? Number.MAX_SAFE_INTEGER : depth);
     const byPath = /* @__PURE__ */ new Map();
-    const root = { path: path10, label: null, type: this.node(path10)?.type ?? "mapping", format: null, children: [] };
-    byPath.set(path10, root);
+    const root = { path: path11, label: null, type: this.node(path11)?.type ?? "mapping", format: null, children: [] };
+    byPath.set(path11, root);
     for (const r2 of rows) {
       const tn = {
         path: r2.path,
@@ -62883,20 +62886,20 @@ 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(path10) {
-    const out = this.db.prepare("SELECT * FROM edge WHERE from_path = ? AND kind != 'contain'").all(path10).map(rowToEdge);
-    const inc = this.db.prepare("SELECT * FROM edge WHERE to_path = ? AND kind != 'contain'").all(path10).map(rowToEdge);
+  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);
     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] };
   }
 };
-function walkNodes(node, path10, visit2, parent = null, label = null, pos = null) {
-  visit2(path10, node, parent, label, pos);
+function walkNodes(node, path11, visit2, parent = null, label = null, pos = null) {
+  visit2(path11, node, parent, label, pos);
   if (!node.entries) return;
   node.entries.forEach((e3, i2) => {
     if (isPointer(e3.value)) return;
-    const childPath2 = (path10 === ":" ? "" : path10) + (e3.key != null ? ":" + e3.key : "[" + i2 + "]");
-    walkNodes(e3.value, childPath2, visit2, path10, e3.key, i2);
+    const childPath2 = (path11 === ":" ? "" : path11) + (e3.key != null ? ":" + e3.key : "[" + i2 + "]");
+    walkNodes(e3.value, childPath2, visit2, path11, e3.key, i2);
   });
 }
 function formatFromMeta(node) {
@@ -62934,8 +62937,8 @@ function rowToEdge(r2) {
 }
 
 // ../engine/ts/src/walk.ts
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { setImmediate as yieldLoop } from "node:timers/promises";
 
 // ../engine/ts/node_modules/xxhash-wasm/esm/xxhash-wasm.js
@@ -63179,8 +63182,8 @@ function colonSegment(name) {
   if (/[ \t]/.test(name) || /^['"]/.test(name)) return `'${name.replace(/'/g, "''")}'`;
   return name.replace(/[\\:[\]*&#~?!()<>=|]/g, (c3) => "\\" + c3);
 }
-function parsePath(path10) {
-  const segs = splitSlash(path10);
+function parsePath(path11) {
+  const segs = splitSlash(path11);
   const out = [];
   for (let i2 = 0; i2 < segs.length; i2++) {
     if (segs[i2] === "") continue;
@@ -63271,13 +63274,13 @@ function makeAnchor(body, fail) {
     ordinal = true;
     body = body.slice(0, -2);
   }
-  const path10 = parsePointer(body);
+  const path11 = parsePointer(body);
   if (!ordinal) {
-    const last = path10.steps[path10.steps.length - 1];
+    const last = path11.steps[path11.steps.length - 1];
     if (last === void 0) fail('an anchor path needs a key segment (or a trailing "[]" for ordinal membership)');
     if (last.sel !== "key") fail('an anchor may not claim a position \u2014 use a trailing "[]" for ordinal membership');
   }
-  return { path: path10, ...ordinal ? { ordinal: true } : {} };
+  return { path: path11, ...ordinal ? { ordinal: true } : {} };
 }
 function escapeSegment(name) {
   if (name === "..") return "\\.\\.";
@@ -64303,6 +64306,49 @@ function json5number(tok) {
   return void 0;
 }
 
+// ../engine/ts/src/mounts.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var YAMLOVER_AUTHORITY2 = "yamlover.inthemoon.net";
+var moduleDir = path.dirname(fileURLToPath(import.meta.url));
+function taxonomyDir() {
+  const candidates = [
+    path.join(moduleDir, "builtin-taxonomy"),
+    // published package: dist/builtin-taxonomy
+    path.resolve(moduleDir, "../../../../")
+    // dev/source run: the repo root
+  ];
+  for (const c3 of candidates) if (fs.existsSync(path.join(c3, "$defs"))) return c3;
+  return null;
+}
+var cached;
+function loadBundledTaxonomy() {
+  if (cached !== void 0) return cached;
+  const dir = taxonomyDir();
+  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 defs = defsMap(defsRoot);
+  return cached = { node: { kind: "mapping", array: false, entries }, defs };
+}
+function graftTaxonomy() {
+  const base = loadBundledTaxonomy();
+  if (!base) return null;
+  const node = structuredClone(base.node);
+  const defsNode = node.entries?.find((e3) => e3.key === "$defs")?.value;
+  return { node, defs: defsNode ? defsMap(defsNode) : /* @__PURE__ */ new Map() };
+}
+function defsMap(defsNode) {
+  const m = /* @__PURE__ */ new Map();
+  for (const e3 of defsNode.entries ?? []) if (e3.key && !isPointer(e3.value)) m.set(e3.key, e3.value);
+  return m;
+}
+
 // ../engine/ts/src/walk.ts
 var { h64Raw, create64 } = await e();
 var hashBytes = (bytes) => "xxh64:" + h64Raw(bytes).toString(16).padStart(16, "0");
@@ -64316,6 +64362,8 @@ var YAMLOVER_INTERNAL = /* @__PURE__ */ new Set([
   "index.db-shm",
   "index.db-journal"
 ]);
+var SETTINGS_FILE = "settings.yamlover";
+var skipInYamloverDir = (name) => YAMLOVER_INTERNAL.has(name) && name !== SETTINGS_FILE || name.startsWith(".");
 var MAX_TEXT_BYTES = 1 << 20;
 var MAX_DOC_BYTES = 64 << 20;
 var HASH_INLINE_MAX = 1 << 20;
@@ -64373,24 +64421,35 @@ function builtinYamloverGraft() {
   return { node, defs: /* @__PURE__ */ new Map([["tag", tagCopy], ["fragment", fragCopy], ["annotation", annCopy]]) };
 }
 function* walkTreeGen(absDir, opts = {}) {
-  const ctx = { root: path.resolve(absDir), opts, files: /* @__PURE__ */ new Map(), count: 0 };
+  const ctx = { root: path2.resolve(absDir), opts, files: /* @__PURE__ */ new Map(), count: 0 };
   const root = yield* dirNode(ctx.root, ctx);
   root.meta = { ...root.meta, documentRoot: true };
   const defsRoot = findDefsRoot(absDir);
-  const defsDir = path.join(defsRoot, "$defs");
-  const selfRoot = path.resolve(absDir) === defsRoot;
+  const defsDir = path2.join(defsRoot, "$defs");
+  const selfRoot = fs2.existsSync(defsDir) && path2.resolve(absDir) === defsRoot;
   const arrayRoot = root.array || (root.entries?.length ? root.entries.every((e3) => e3.key === null) : false);
   let builtinDefs;
-  if (!arrayRoot && root.entries && !root.entries.some((e3) => e3.key === "yamlover")) {
-    if (fs.existsSync(defsDir) && !selfRoot) {
-      const shared = [{ key: "$defs", edge: "contain", value: yield* dirNode(defsDir, ctx) }];
-      const tagsDir = path.join(defsRoot, "tags");
-      if (fs.existsSync(tagsDir)) shared.push({ key: "tags", edge: "contain", value: yield* dirNode(tagsDir, ctx) });
-      root.entries.push({ key: "yamlover", edge: "contain", value: { kind: "mapping", entries: shared, array: false } });
-    } else if (!fs.existsSync(defsDir)) {
-      const built = builtinYamloverGraft();
-      root.entries.push({ key: "yamlover", edge: "contain", value: built.node });
-      builtinDefs = built.defs;
+  if (!opts.noGraft && !arrayRoot && root.entries) {
+    const yEntry = root.entries.find((e3) => e3.key === "yamlover");
+    const yIsSelfImport = !yEntry || isPointer(yEntry.value) && isYamloverWorldPointer(yEntry.value);
+    if (selfRoot) {
+      if (yEntry && yIsSelfImport) root.entries = root.entries.filter((e3) => e3 !== yEntry);
+    } else if (yIsSelfImport) {
+      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) });
+        node = { kind: "mapping", entries: shared, array: false };
+      } else {
+        const built = graftTaxonomy() ?? builtinYamloverGraft();
+        node = built.node;
+        builtinDefs = built.defs;
+      }
+      if (yEntry) {
+        yEntry.value = node;
+        yEntry.edge = "contain";
+      } else root.entries.push({ key: "yamlover", edge: "contain", value: node });
     }
   }
   applySchemas(root, defsRoot, builtinDefs);
@@ -64408,7 +64467,7 @@ function reindex(store, absDir, opts = {}) {
 async function reindexAsyncDoc(store, absDir, opts = {}) {
   const prev = store.stale ? /* @__PURE__ */ new Map() : store.manifest();
   const onProgress = opts.onProgress;
-  const total = onProgress ? await countChildren(path.resolve(absDir), opts) : void 0;
+  const total = onProgress ? await countChildren(path2.resolve(absDir), opts) : void 0;
   const { doc, files } = await walkTreeAsync(absDir, {
     ...opts,
     cache: opts.cache ?? manifestCache(prev),
@@ -64420,7 +64479,7 @@ async function reindexAsyncDoc(store, absDir, opts = {}) {
   return { diff: diffManifest(prev, files), doc, files };
 }
 async function reindexPathAsync(store, absDir, cachedDoc, changedRel, opts = {}) {
-  const root = path.resolve(absDir);
+  const root = path2.resolve(absDir);
   const parts = changedRel.split("/");
   const yi = parts.indexOf(YAMLOVER_DIR);
   const dirSegs = yi >= 0 ? parts.slice(0, yi) : parts.slice(0, -1);
@@ -64436,8 +64495,8 @@ async function reindexPathAsync(store, absDir, cachedDoc, changedRel, opts = {})
     else entries = entries[i2].value.entries;
   }
   if (!target) return null;
-  const absSpliceDir = path.join(root, ...dirSegs);
-  if (!fs.existsSync(absSpliceDir) || !fs.statSync(absSpliceDir).isDirectory()) return null;
+  const absSpliceDir = path2.join(root, ...dirSegs);
+  if (!fs2.existsSync(absSpliceDir) || !fs2.statSync(absSpliceDir).isDirectory()) return null;
   const prev = store.stale ? /* @__PURE__ */ new Map() : store.manifest();
   const ctx = { root, opts: { ...opts, cache: opts.cache ?? manifestCache(prev) }, files: /* @__PURE__ */ new Map(), count: 0 };
   const gen = dirNode(absSpliceDir, ctx);
@@ -64472,18 +64531,18 @@ async function countChildren(absRoot, opts) {
   const visitYamlover = async (dir) => {
     let entries;
     try {
-      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return 0;
     }
     let top = 0;
     for (const e3 of entries) {
-      if (YAMLOVER_INTERNAL.has(e3.name) || e3.name.startsWith(".")) continue;
-      const abs = path.join(dir, e3.name);
+      if (skipInYamloverDir(e3.name)) continue;
+      const abs = path2.join(dir, e3.name);
       if (opts.ignore?.(abs)) continue;
       n2++;
       top++;
-      const isDir = e3.isDirectory() || e3.isSymbolicLink() && (await fs.promises.stat(abs).catch(() => null))?.isDirectory();
+      const isDir = e3.isDirectory() || e3.isSymbolicLink() && (await fs2.promises.stat(abs).catch(() => null))?.isDirectory();
       if (isDir) await visit2(abs);
     }
     return top;
@@ -64491,20 +64550,20 @@ async function countChildren(absRoot, opts) {
   const visit2 = async (dir) => {
     let entries;
     try {
-      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e3 of entries) {
       if (e3.name.startsWith(".") && e3.name !== YAMLOVER_DIR) continue;
-      const abs = path.join(dir, e3.name);
+      const abs = path2.join(dir, e3.name);
       if (opts.ignore?.(abs)) continue;
       if (e3.name === YAMLOVER_DIR) {
         if (await visitYamlover(abs) > 0) n2++;
         continue;
       }
       n2++;
-      const isDir = e3.isDirectory() || e3.isSymbolicLink() && (await fs.promises.stat(abs).catch(() => null))?.isDirectory();
+      const isDir = e3.isDirectory() || e3.isSymbolicLink() && (await fs2.promises.stat(abs).catch(() => null))?.isDirectory();
       if (isDir) await visit2(abs);
     }
   };
@@ -64554,7 +64613,7 @@ function groupBy(list, key) {
   return m;
 }
 async function hashFileAsync(abs, onChunk) {
-  const fh = await fs.promises.open(abs, "r");
+  const fh = await fs2.promises.open(abs, "r");
   try {
     const hasher = create64();
     const buf = Buffer.alloc(HASH_CHUNK);
@@ -64572,19 +64631,19 @@ async function hashFileAsync(abs, onChunk) {
   }
 }
 function record(ctx, abs, hash, size, mtimeMs) {
-  const rel = path.relative(ctx.root, abs).split(path.sep).join("/");
+  const rel = path2.relative(ctx.root, abs).split(path2.sep).join("/");
   if (rel.startsWith("..")) return;
   ctx.files.set(rel, { path: rel, hash, size, mtimeMs });
 }
 function readTracked(ctx, abs) {
-  const stat = fs.statSync(abs);
-  const bytes = fs.readFileSync(abs);
+  const stat = fs2.statSync(abs);
+  const bytes = fs2.readFileSync(abs);
   record(ctx, abs, hashBytes(bytes), stat.size, stat.mtimeMs);
   return bytes;
 }
 function loadMeta(dir, ctx) {
-  const file = path.join(dir, YAMLOVER_DIR, "meta.yamlover");
-  if (!fs.existsSync(file)) return {};
+  const file = path2.join(dir, YAMLOVER_DIR, "meta.yamlover");
+  if (!fs2.existsSync(file)) return {};
   try {
     const plain = toPlain(parseYamlover(readTracked(ctx, file).toString("utf8"), file).root);
     const props = plain?.properties ?? {};
@@ -64595,21 +64654,21 @@ function loadMeta(dir, ctx) {
 }
 function* dirNode(dir, ctx) {
   const meta = loadMeta(dir, ctx);
-  const names3 = fs.readdirSync(dir).filter((n2) => n2 === YAMLOVER_DIR || !n2.startsWith(".")).filter((n2) => !ctx.opts.ignore?.(path.join(dir, n2))).sort();
+  const names3 = fs2.readdirSync(dir).filter((n2) => n2 === YAMLOVER_DIR || !n2.startsWith(".")).filter((n2) => !ctx.opts.ignore?.(path2.join(dir, n2))).sort();
   const entries = [];
   for (const name of names3) {
-    const abs = path.join(dir, name);
+    const abs = path2.join(dir, name);
     if (name === YAMLOVER_DIR) {
       const hidden = yield* yamloverDirNode(abs, ctx);
       if (hidden) {
         entries.push({ key: name, edge: "contain", value: hidden });
-        yield { done: ++ctx.count, path: path.relative(ctx.root, abs).split(path.sep).join("/") };
+        yield { done: ++ctx.count, path: path2.relative(ctx.root, abs).split(path2.sep).join("/") };
       }
       continue;
     }
     const child = yield* childNode(abs, meta[name], ctx);
     entries.push({ key: name, edge: "contain", value: child });
-    yield { done: ++ctx.count, path: path.relative(ctx.root, abs).split(path.sep).join("/") };
+    yield { done: ++ctx.count, path: path2.relative(ctx.root, abs).split(path2.sep).join("/") };
   }
   const node = { kind: "mapping", entries, array: false };
   return applyMeta(applyBody(dir, node, ctx), meta);
@@ -64617,24 +64676,24 @@ function* dirNode(dir, ctx) {
 function* yamloverDirNode(absYamlover, ctx) {
   let names3;
   try {
-    names3 = fs.readdirSync(absYamlover).filter((n2) => !YAMLOVER_INTERNAL.has(n2) && !n2.startsWith(".")).filter((n2) => !ctx.opts.ignore?.(path.join(absYamlover, n2))).sort();
+    names3 = fs2.readdirSync(absYamlover).filter((n2) => !skipInYamloverDir(n2)).filter((n2) => !ctx.opts.ignore?.(path2.join(absYamlover, n2))).sort();
   } catch {
     return null;
   }
   const entries = [];
   for (const name of names3) {
-    const abs = path.join(absYamlover, name);
+    const abs = path2.join(absYamlover, name);
     const child = yield* childNode(abs, void 0, ctx);
     entries.push({ key: name, edge: "contain", value: child });
-    yield { done: ++ctx.count, path: path.relative(ctx.root, abs).split(path.sep).join("/") };
+    yield { done: ++ctx.count, path: path2.relative(ctx.root, abs).split(path2.sep).join("/") };
   }
   if (entries.length === 0) return null;
   return { kind: "mapping", entries, array: false, meta: { hidden: true } };
 }
 function* childNode(abs, m, ctx) {
-  const stat = fs.statSync(abs);
+  const stat = fs2.statSync(abs);
   if (stat.isDirectory()) return yield* dirNode(abs, ctx);
-  const ext = path.extname(abs).toLowerCase();
+  const ext = path2.extname(abs).toLowerCase();
   const fmt = m?.format ?? EXT_FORMAT[ext] ?? null;
   if (m?.type === "binary") return blob(abs, fmt ?? "application/octet-stream", ctx);
   if (fmt && (DOC_FORMATS[fmt] || TEXT_FORMATS.has(fmt))) {
@@ -64658,15 +64717,15 @@ function applyMeta(node, meta) {
   return node;
 }
 function blob(abs, format, ctx) {
-  const stat = fs.statSync(abs);
-  const rel = path.relative(ctx.root, abs).split(path.sep).join("/");
-  const cached = ctx.opts.cache?.(rel, stat.size, stat.mtimeMs) ?? null;
-  if (cached) {
-    record(ctx, abs, cached, stat.size, stat.mtimeMs);
-    return { kind: "blob", format, contentHash: cached, size: stat.size };
+  const stat = fs2.statSync(abs);
+  const rel = path2.relative(ctx.root, abs).split(path2.sep).join("/");
+  const cached2 = ctx.opts.cache?.(rel, stat.size, stat.mtimeMs) ?? null;
+  if (cached2) {
+    record(ctx, abs, cached2, stat.size, stat.mtimeMs);
+    return { kind: "blob", format, contentHash: cached2, size: stat.size };
   }
   const inlineMax = ctx.opts.hashInlineMax ?? HASH_INLINE_MAX;
-  const contentHash = stat.size <= inlineMax ? hashBytes(fs.readFileSync(abs)) : null;
+  const contentHash = stat.size <= inlineMax ? hashBytes(fs2.readFileSync(abs)) : null;
   record(ctx, abs, contentHash, stat.size, stat.mtimeMs);
   return { kind: "blob", format, contentHash, size: stat.size };
 }
@@ -64688,12 +64747,15 @@ function parsedDoc(abs, lang, ctx) {
     return { kind: "scalar", value: text, raw: text };
   }
 }
+function isYamloverWorldPointer(v) {
+  return isPointer(v) && v.base.scope === "link" && v.base.world === true && v.base.authority === YAMLOVER_AUTHORITY2;
+}
 function findDefsRoot(dir) {
-  let d = path.resolve(dir);
+  let d = path2.resolve(dir);
   for (; ; ) {
-    if (fs.existsSync(path.join(d, "$defs"))) return d;
-    const up = path.dirname(d);
-    if (up === d) return path.resolve(dir);
+    if (fs2.existsSync(path2.join(d, "$defs"))) return d;
+    const up = path2.dirname(d);
+    if (up === d) return path2.resolve(dir);
     d = up;
   }
 }
@@ -64701,9 +64763,9 @@ function applySchemas(root, defsRoot, builtinDefs) {
   const cache = /* @__PURE__ */ new Map();
   const loadDef = (name) => {
     if (!cache.has(name)) {
-      const defFile = path.join(defsRoot, "$defs", name);
+      const defFile = path2.join(defsRoot, "$defs", name);
       try {
-        cache.set(name, parseYamlover(fs.readFileSync(defFile, "utf8"), defFile).root);
+        cache.set(name, parseYamlover(fs2.readFileSync(defFile, "utf8"), defFile).root);
       } catch {
         cache.set(name, builtinDefs?.get(name) ?? null);
       }
@@ -64760,8 +64822,8 @@ function inlineFormat(format) {
   return { kind: "mapping", entries: [{ key: "format", edge: "contain", value: { kind: "scalar", value: format, raw: format } }], array: false };
 }
 function applyBody(dir, node, ctx) {
-  const file = path.join(dir, YAMLOVER_DIR, "body.yamlover");
-  if (!fs.existsSync(file)) return node;
+  const file = path2.join(dir, YAMLOVER_DIR, "body.yamlover");
+  if (!fs2.existsSync(file)) return node;
   const bodyDoc = parseYamlover(readTracked(ctx, file).toString("utf8"), file);
   const body = bodyDoc.root;
   if (body.kind !== "mapping" && body.kind !== "scalar" || !body.entries) return node;
@@ -64813,14 +64875,14 @@ function pointerLeafKey(v) {
 }
 function looksBinary(abs) {
   try {
-    if (fs.statSync(abs).size > MAX_TEXT_BYTES) return true;
-    const fd = fs.openSync(abs, "r");
+    if (fs2.statSync(abs).size > MAX_TEXT_BYTES) return true;
+    const fd = fs2.openSync(abs, "r");
     try {
       const buf = Buffer.alloc(4096);
-      const n2 = fs.readSync(fd, buf, 0, buf.length, 0);
+      const n2 = fs2.readSync(fd, buf, 0, buf.length, 0);
       return buf.subarray(0, n2).includes(0);
     } finally {
-      fs.closeSync(fd);
+      fs2.closeSync(fd);
     }
   } catch {
     return true;
@@ -64890,7 +64952,7 @@ var DOC_FORMATS = {
 };
 
 // ../engine/ts/src/rewrite.ts
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // ../parser/ts/src/serialize-yamlover.ts
 function pointerToken(raw) {
@@ -64941,7 +65003,7 @@ function planRewrites(doc, edges, oldStore, newStore, opts = {}) {
         miss("anchor has no source span");
         continue;
       }
-      if (opts.root !== void 0 && path2.relative(opts.root, span2.uri).startsWith("..")) {
+      if (opts.root !== void 0 && path3.relative(opts.root, span2.uri).startsWith("..")) {
         miss("source file is outside the served root (grafted)");
         continue;
       }
@@ -64993,7 +65055,7 @@ function planRewrites(doc, edges, oldStore, newStore, opts = {}) {
       miss("pointer has no source span");
       continue;
     }
-    if (opts.root !== void 0 && path2.relative(opts.root, span.uri).startsWith("..")) {
+    if (opts.root !== void 0 && path3.relative(opts.root, span.uri).startsWith("..")) {
       miss("source file is outside the served root (grafted)");
       continue;
     }
@@ -65127,12 +65189,12 @@ function json5pAnchorToken(body) {
 }
 
 // ../engine/ts/src/mv.ts
-import * as fs2 from "node:fs";
-import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
 function mv(absRoot, fromRel, toRel, opts = {}) {
-  const root = path3.resolve(absRoot);
-  const absFrom = path3.resolve(root, fromRel);
-  const absTo = path3.resolve(root, toRel);
+  const root = path4.resolve(absRoot);
+  const absFrom = path4.resolve(root, fromRel);
+  const absTo = path4.resolve(root, toRel);
   const relFrom = relInside(root, absFrom, "source");
   const relTo = relInside(root, absTo, "target");
   for (const rel of [relFrom, relTo]) {
@@ -65140,9 +65202,9 @@ function mv(absRoot, fromRel, toRel, opts = {}) {
       if (seg.startsWith(".")) throw new Error(`mv: hidden/overlay segments are not movable ("${seg}" in "${rel}")`);
     }
   }
-  if (!fs2.existsSync(absFrom)) throw new Error(`mv: source does not exist: ${relFrom}`);
-  if (fs2.existsSync(absTo)) throw new Error(`mv: target already exists: ${relTo}`);
-  if (absTo === absFrom || absTo.startsWith(absFrom + path3.sep)) {
+  if (!fs3.existsSync(absFrom)) throw new Error(`mv: source does not exist: ${relFrom}`);
+  if (fs3.existsSync(absTo)) throw new Error(`mv: target already exists: ${relTo}`);
+  if (absTo === absFrom || absTo.startsWith(absFrom + path4.sep)) {
     throw new Error(`mv: cannot move "${relFrom}" into itself`);
   }
   const { doc } = walkTree(root, opts);
@@ -65150,15 +65212,15 @@ function mv(absRoot, fromRel, toRel, opts = {}) {
   const plan = planRewrites(doc, edges, storeOf(relFrom), storeOf(relTo), { root });
   const editedFiles = [];
   for (const [uri, edits] of plan.edits) {
-    fs2.writeFileSync(uri, applyEdits(fs2.readFileSync(uri, "utf8"), edits));
-    editedFiles.push(path3.relative(root, uri).split(path3.sep).join("/"));
+    fs3.writeFileSync(uri, applyEdits(fs3.readFileSync(uri, "utf8"), edits));
+    editedFiles.push(path4.relative(root, uri).split(path4.sep).join("/"));
   }
-  fs2.mkdirSync(path3.dirname(absTo), { recursive: true });
-  fs2.renameSync(absFrom, absTo);
+  fs3.mkdirSync(path4.dirname(absTo), { recursive: true });
+  fs3.renameSync(absFrom, absTo);
   return { from: relFrom, to: relTo, rewritten: plan.rewritten, unrewritten: plan.unrewritten, editedFiles };
 }
 function relinkMoved(absRoot, moved, opts = {}) {
-  const root = path3.resolve(absRoot);
+  const root = path4.resolve(absRoot);
   const { doc } = walkTree(root, opts);
   const edges = resolveDocument(doc);
   const rewritten = [];
@@ -65179,36 +65241,36 @@ function relinkMoved(absRoot, moved, opts = {}) {
   }
   const editedFiles = [];
   for (const [uri, edits] of merged) {
-    fs2.writeFileSync(uri, applyEdits(fs2.readFileSync(uri, "utf8"), edits));
-    editedFiles.push(path3.relative(root, uri).split(path3.sep).join("/"));
+    fs3.writeFileSync(uri, applyEdits(fs3.readFileSync(uri, "utf8"), edits));
+    editedFiles.push(path4.relative(root, uri).split(path4.sep).join("/"));
   }
   return { rewritten, unrewritten, editedFiles };
 }
 function relInside(root, abs, what) {
-  const rel = path3.relative(root, abs);
-  if (rel === "" || rel.startsWith("..") || path3.isAbsolute(rel)) {
+  const rel = path4.relative(root, abs);
+  if (rel === "" || rel.startsWith("..") || path4.isAbsolute(rel)) {
     throw new Error(`mv: ${what} escapes the served root`);
   }
-  return rel.split(path3.sep).join("/");
+  return rel.split(path4.sep).join("/");
 }
 function storeOf(rel) {
   return ":" + rel.split("/").join(":");
 }
 
 // ../engine/ts/src/watch.ts
-import fs3 from "node:fs";
-import path4 from "node:path";
+import fs4 from "node:fs";
+import path5 from "node:path";
 var OVERLAY_FILES = /* @__PURE__ */ new Set(["body.yamlover", "meta.yamlover", "settings.yamlover"]);
 var YAMLOVER_SIDECAR_DIRS = /* @__PURE__ */ new Set(["thumbnails", "fragments"]);
 function watchTree(absRoot, onBatch, opts = {}) {
-  const root = path4.resolve(absRoot);
+  const root = path5.resolve(absRoot);
   const debounceMs = opts.debounceMs ?? 300;
   const pending = /* @__PURE__ */ new Set();
   let timer = null;
   let running = false;
   let closed = false;
   const relevant = (rel) => {
-    const segs = rel.split(path4.sep);
+    const segs = rel.split(path5.sep);
     for (let i2 = 0; i2 < segs.length; i2++) {
       if (!segs[i2].startsWith(".")) continue;
       const rest = segs.slice(i2 + 1);
@@ -65217,12 +65279,12 @@ function watchTree(absRoot, onBatch, opts = {}) {
       if (!isOverlay && !isSidecar) return false;
       break;
     }
-    return !opts.ignore?.(path4.join(root, rel));
+    return !opts.ignore?.(path5.join(root, rel));
   };
   const fire = () => {
     timer = null;
     if (running || closed || pending.size === 0) return;
-    const batch = [...pending].map((p2) => p2.split(path4.sep).join("/"));
+    const batch = [...pending].map((p2) => p2.split(path5.sep).join("/"));
     pending.clear();
     running = true;
     try {
@@ -65232,7 +65294,7 @@ function watchTree(absRoot, onBatch, opts = {}) {
       if (pending.size > 0) timer = setTimeout(fire, debounceMs);
     }
   };
-  const watcher = fs3.watch(root, { recursive: true }, (_event, filename) => {
+  const watcher = fs4.watch(root, { recursive: true }, (_event, filename) => {
     if (closed || filename == null) return;
     const rel = String(filename);
     if (!relevant(rel)) return;
@@ -65248,28 +65310,83 @@ function watchTree(absRoot, onBatch, opts = {}) {
 }
 
 // ../engine/ts/src/settings.ts
-import fs4 from "node:fs";
-import path5 from "node:path";
+import fs5 from "node:fs";
+import path6 from "node:path";
 var DEFAULT_SETTINGS = {
-  annotations: { location: ":annotations" },
-  tags: { location: ":tags" },
-  sidecars: { location: "per-directory" }
+  uri: void 0,
+  exports: [],
+  annotations: ":annotations",
+  tags: ":tags",
+  sidecars: "per-directory",
+  annotationTag: void 0
 };
+var DEFAULT_SETTINGS_SOURCE = `# .yamlover/settings.yamlover \u2014 project settings for this root (created with defaults).
+# Settings are DEFAULTS, never constraints: they only say where the server CREATES things when you
+# do not; reading is location-independent (a node is recognized by its schema, wherever it sits).
+# Locations are PROJECT-SCOPE pointers: \`*::x\` = project root, \`*:x\` = document root, \`*x\` =
+# parent/current scope (SEPARATOR.md \xA72). A missing field falls back to these same values. Edit me
+# here or via the gear button's settings editor.
+!!<*yamlover:$defs:config>
+
+annotations: *:: annotations   # create new annotations in :annotations
+tags: *:: tags                 # create new tags in :tags
+sidecars: per-directory        # where derived thumbnail/crop blobs go (enum, not a path)
+`;
+function ensureSettingsFile(absRoot) {
+  const file = path6.join(absRoot, ".yamlover", "settings.yamlover");
+  if (!fs5.existsSync(file)) {
+    fs5.mkdirSync(path6.dirname(file), { recursive: true });
+    fs5.writeFileSync(file, DEFAULT_SETTINGS_SOURCE);
+  }
+  return file;
+}
 function loadSettings(absRoot) {
-  const file = path5.join(absRoot, ".yamlover", "settings.yamlover");
-  if (!fs4.existsSync(file)) return DEFAULT_SETTINGS;
+  const file = path6.join(absRoot, ".yamlover", "settings.yamlover");
+  if (!fs5.existsSync(file)) return DEFAULT_SETTINGS;
   let root;
   try {
-    root = parseYamlover(fs4.readFileSync(file, "utf8"), file).root;
+    root = parseYamlover(fs5.readFileSync(file, "utf8"), file).root;
   } catch {
     return DEFAULT_SETTINGS;
   }
   return {
-    annotations: { location: locationSetting(valueAt(root, "annotations", "location"), DEFAULT_SETTINGS.annotations.location) },
-    tags: { location: locationSetting(valueAt(root, "tags", "location"), DEFAULT_SETTINGS.tags.location) },
-    sidecars: { location: sidecarLocation(valueAt(root, "sidecars", "location"), DEFAULT_SETTINGS.sidecars.location) }
+    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),
+    sidecars: sidecarLocation(valueAt(root, "sidecars"), DEFAULT_SETTINGS.sidecars),
+    annotationTag: locationSetting(valueAt(root, "annotation-tag"), void 0)
   };
 }
+function uriSetting(v) {
+  if (v === void 0) return void 0;
+  if (isPointer(v)) return v.base.scope === "link" ? v.base.authority : void 0;
+  if (v.kind === "scalar" && typeof v.value === "string") {
+    const a2 = v.value.replace(/^[:\s]+/, "").trim();
+    return a2 === "" ? void 0 : a2;
+  }
+  return void 0;
+}
+function exportsSetting(v) {
+  if (v === void 0 || isPointer(v) || !v.entries) return [];
+  const out = [];
+  for (const e3 of v.entries) {
+    if (isPointer(e3.value)) out.push("*" + e3.value.raw);
+    else if (e3.value.kind === "scalar" && typeof e3.value.value === "string" && e3.value.value.trim() !== "") out.push(e3.value.value.trim());
+  }
+  return out;
+}
+function writeSettingKey(absRoot, key, valueText) {
+  const file = path6.join(absRoot, ".yamlover", "settings.yamlover");
+  const src = fs5.existsSync(file) ? fs5.readFileSync(file, "utf8") : "";
+  const line = `${key}: ${valueText}`;
+  const re = new RegExp("^" + key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + ":.*$", "m");
+  let out = re.test(src) ? src.replace(re, line) : (src === "" || src.endsWith("\n") ? src : src + "\n") + line;
+  if (!out.endsWith("\n")) out += "\n";
+  fs5.mkdirSync(path6.dirname(file), { recursive: true });
+  fs5.writeFileSync(file, out);
+  return file;
+}
 function sidecarLocation(v, dflt) {
   const s2 = v !== void 0 && !isPointer(v) && v.kind === "scalar" && typeof v.value === "string" ? v.value.trim() : "";
   if (s2 === "per-directory" || s2 === "document") return "per-directory";
@@ -65291,10 +65408,14 @@ function locationSetting(v, dflt) {
   return dflt;
 }
 function pointerPath(p2) {
-  if (p2.base.scope !== "current" && p2.base.scope !== "document") return null;
-  if (p2.steps.length === 0 || !p2.steps.every((s2) => s2.sel === "key")) return null;
-  const segs = p2.steps.map((s2) => s2.name);
-  if (segs.some((seg) => seg === ".." || seg === "")) return null;
+  const segs = [];
+  if (p2.base.scope === "link") segs.push(p2.base.authority);
+  else if (p2.base.scope !== "current" && p2.base.scope !== "document") return null;
+  for (const s2 of p2.steps) {
+    if (s2.sel !== "key") return null;
+    segs.push(s2.name);
+  }
+  if (segs.length === 0 || segs.some((seg) => seg === ".." || seg === "")) return null;
   return ":" + segs.join(":");
 }
 function stringPath(v, dflt) {
@@ -65308,9 +65429,11 @@ function stringPath(v, dflt) {
 function parseQuery(text) {
   let rest = text.trim();
   let base = { scope: "current" };
+  let world = false;
   if (rest.startsWith(":::")) {
     rest = rest.slice(3);
     base = { scope: "link", authority: "" };
+    world = true;
   } else if (rest.startsWith("::")) {
     rest = rest.slice(2);
     base = { scope: "link", authority: "" };
@@ -65322,7 +65445,7 @@ function parseQuery(text) {
   if (base.scope === "link") {
     const auth = raws.shift();
     if (auth === void 0 || auth === "") throw new SyntaxError(`query: "::" needs an authority in "${text}"`);
-    base = { scope: "link", authority: keyName(auth) };
+    base = { scope: "link", authority: keyName(auth), world };
   } else if (base.scope === "current" && raws[0] === "..") {
     base = { scope: "parent" };
     raws.shift();
@@ -65476,6 +65599,7 @@ function keyName(portion) {
   if (steps.length !== 1 || steps[0].sel !== "key") throw new SyntaxError(`query: bad name portion "${portion}"`);
   return steps[0].name;
 }
+var YAMLOVER_AUTHORITY3 = "yamlover.inthemoon.net";
 function evalQuery(s2, text, from = ":") {
   const q = parseQuery(text);
   let binds;
@@ -65490,11 +65614,13 @@ function evalQuery(s2, text, from = ":") {
       binds = [docRootOf(s2, from)];
       break;
     case "link": {
-      if (q.base.authority === "yamlover" && childByKey(s2, ":", "yamlover") === null) {
+      let authority = q.base.authority;
+      if (q.base.world === true && authority === YAMLOVER_AUTHORITY3) authority = "yamlover";
+      if (authority === "yamlover" && childByKey(s2, ":", "yamlover") === null) {
         binds = [":"];
         break;
       }
-      const hit = childByKey(s2, ":", q.base.authority);
+      const hit = childByKey(s2, ":", authority);
       binds = hit === null ? [] : [hit];
       break;
     }
@@ -65874,17 +66000,17 @@ var psdExtractor = {
 };
 
 // src/server/extract/wasm.ts
-import fs7 from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath } from "node:url";
+import fs8 from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
 async function loadWasm(npmSpecifier, prodFile) {
   let bytes;
   try {
-    bytes = fs7.readFileSync(require2.resolve(npmSpecifier));
+    bytes = fs8.readFileSync(require2.resolve(npmSpecifier));
   } catch {
-    bytes = fs7.readFileSync(path7.join(path7.dirname(fileURLToPath(import.meta.url)), "wasm", prodFile));
+    bytes = fs8.readFileSync(path8.join(path8.dirname(fileURLToPath2(import.meta.url)), "wasm", prodFile));
   }
   return WebAssembly.compile(new Uint8Array(bytes));
 }
@@ -65952,8 +66078,8 @@ async function renderThumbnail(bytes, format, w, h) {
 
 // src/server/gitignore.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import fs8 from "node:fs";
-import path8 from "node:path";
+import fs9 from "node:fs";
+import path9 from "node:path";
 function buildGitIgnore(dataRoot) {
   const gitRoot = findGitRoot(dataRoot) ?? dataRoot;
   const cache = /* @__PURE__ */ new Map();
@@ -65961,8 +66087,8 @@ function buildGitIgnore(dataRoot) {
     if (!cache.has(dir)) {
       let ig = null;
       try {
-        const gi = path8.join(dir, ".gitignore");
-        if (fs8.statSync(gi).isFile()) ig = (0, import_ignore.default)().add(fs8.readFileSync(gi, "utf-8"));
+        const gi = path9.join(dir, ".gitignore");
+        if (fs9.statSync(gi).isFile()) ig = (0, import_ignore.default)().add(fs9.readFileSync(gi, "utf-8"));
       } catch {
       }
       cache.set(dir, ig);
@@ -65970,25 +66096,25 @@ function buildGitIgnore(dataRoot) {
     return cache.get(dir);
   };
   return (absPath) => {
-    const fromRoot = path8.relative(gitRoot, absPath);
-    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path8.sep)) return true;
+    const fromRoot = path9.relative(gitRoot, absPath);
+    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path9.sep)) return true;
     let isDir = false;
     try {
-      isDir = fs8.statSync(absPath).isDirectory();
+      isDir = fs9.statSync(absPath).isDirectory();
     } catch {
     }
-    const rel = path8.relative(gitRoot, path8.dirname(absPath));
-    const segs = rel === "" ? [] : rel.split(path8.sep);
+    const rel = path9.relative(gitRoot, path9.dirname(absPath));
+    const segs = rel === "" ? [] : rel.split(path9.sep);
     let dir = gitRoot;
     const dirs = [gitRoot];
     for (const s2 of segs) {
-      dir = path8.join(dir, s2);
+      dir = path9.join(dir, s2);
       dirs.push(dir);
     }
     for (const d of dirs) {
       const ig = matcherFor(d);
       if (!ig) continue;
-      const relToDir = path8.relative(d, absPath);
+      const relToDir = path9.relative(d, absPath);
       if (!relToDir) continue;
       if (ig.ignores(relToDir) || isDir && ig.ignores(relToDir + "/")) return true;
     }
@@ -65996,15 +66122,15 @@ function buildGitIgnore(dataRoot) {
   };
 }
 function findGitRoot(start) {
-  let dir = path8.resolve(start);
+  let dir = path9.resolve(start);
   try {
-    if (!fs8.statSync(dir).isDirectory()) dir = path8.dirname(dir);
+    if (!fs9.statSync(dir).isDirectory()) dir = path9.dirname(dir);
   } catch {
     return null;
   }
   for (; ; ) {
-    if (fs8.existsSync(path8.join(dir, ".git"))) return dir;
-    const parent = path8.dirname(dir);
+    if (fs9.existsSync(path9.join(dir, ".git"))) return dir;
+    const parent = path9.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -66101,11 +66227,20 @@ var LINK_KEY = "$yamloverLink";
 var BINARY_KEY = "$yamloverBinary";
 var MIXED_KEY = "$yamloverMixed";
 function createHandlers(dataRoot, opts = {}) {
-  const rootName = path9.basename(path9.resolve(dataRoot)) || "/";
-  const dbPath = path9.join(dataRoot, ".yamlover", "index.db");
-  const settings = loadSettings(dataRoot);
+  const rootName = path10.basename(path10.resolve(dataRoot)) || "/";
+  const dbPath = path10.join(dataRoot, ".yamlover", "index.db");
+  const settingsFile = path10.join(dataRoot, ".yamlover", "settings.yamlover");
+  if (opts.ensureSettings) {
+    try {
+      ensureSettingsFile(dataRoot);
+    } catch (e3) {
+      (opts.log ?? (() => {
+      }))(`could not create settings.yamlover: ${e3.message}`);
+    }
+  }
+  let settings = loadSettings(dataRoot);
   const ignore2 = opts.gitignore === false ? void 0 : buildGitIgnore(dataRoot);
-  fs9.mkdirSync(path9.dirname(dbPath), { recursive: true });
+  fs10.mkdirSync(path10.dirname(dbPath), { recursive: true });
   const store0 = new Store(dbPath);
   const store = () => store0;
   let cachedDoc = null;
@@ -66182,7 +66317,7 @@ function createHandlers(dataRoot, opts = {}) {
           const next = pending[0];
           const total = done + pending.length;
           h.progress(done, total, next.path);
-          const abs = path9.join(dataRoot, ...next.path.split("/"));
+          const abs = path10.join(dataRoot, ...next.path.split("/"));
           let hash = null;
           try {
             hash = await hashFileAsync(abs, (bytes) => {
@@ -66190,7 +66325,7 @@ function createHandlers(dataRoot, opts = {}) {
             });
           } catch {
           }
-          const st = hash !== null ? fs9.statSync(abs, { throwIfNoEntry: false }) : void 0;
+          const st = hash !== null ? fs10.statSync(abs, { throwIfNoEntry: false }) : void 0;
           const fresh = st !== void 0 && st.size === next.size && st.mtimeMs === next.mtimeMs;
           const ok = hash !== null && fresh && !closed ? await enqueue(() => store0.setFileHash(next.path, hash, next.size, next.mtimeMs)) : false;
           if (!ok) {
@@ -66221,7 +66356,7 @@ function createHandlers(dataRoot, opts = {}) {
   };
   const doReindexFile = async (absFile) => {
     if (cachedDoc) {
-      const rel = path9.relative(dataRoot, absFile).split(path9.sep).join("/");
+      const rel = path10.relative(dataRoot, absFile).split(path10.sep).join("/");
       try {
         const res = await reindexPathAsync(store0, dataRoot, cachedDoc, rel, { ignore: ignore2 });
         if (res) {
@@ -66350,7 +66485,7 @@ function createHandlers(dataRoot, opts = {}) {
           (data) => enqueue(async () => {
             const f2 = data;
             if (!f2?.selector || typeof f2.selector !== "object") throw new Error("a fragment needs a selector");
-            const made = embedFragment(dataRoot, s2, settings.sidecars.location, f2);
+            const made = embedFragment(dataRoot, s2, settings.sidecars, f2);
             broadcast(await doReindex());
             scheduleHasher();
             return made;
@@ -66373,7 +66508,7 @@ 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.location), name];
+            const segs2 = [...strToSegs(settings.tags), name];
             const tagPath = segsToStr(segs2);
             const existing = s2.node(storePath(segs2));
             if (existing) {
@@ -66381,8 +66516,8 @@ function createHandlers(dataRoot, opts = {}) {
               const color = s2.node(storePath(segs2) + ":color")?.value;
               return { path: tagPath, name, color: typeof color === "string" ? color : null, created: false };
             }
-            const written = writeTag(dataRoot, settings.tags.location, name);
-            s2.addTag(storePath(strToSegs(settings.tags.location)), name, written.pos, written.node);
+            const written = writeTag(dataRoot, 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}`);
             announce(written.createdFile ? { added: [written.file] } : { changed: [written.file] });
             return { path: tagPath, name, color: null, created: true };
@@ -66396,9 +66531,9 @@ function createHandlers(dataRoot, opts = {}) {
             const b = data;
             const cols = Array.isArray(b?.columns) ? b.columns.map((lane) => Array.isArray(lane) ? lane.map((p3) => String(p3)) : []) : [];
             const { bodyFile } = hostFor(dataRoot, s2, strToSegs(b?.path || ":"));
-            fs9.mkdirSync(path9.dirname(bodyFile), { recursive: true });
-            const src = fs9.existsSync(bodyFile) ? fs9.readFileSync(bodyFile, "utf8") : "";
-            fs9.writeFileSync(bodyFile, writeBoardColumns(src, cols));
+            fs10.mkdirSync(path10.dirname(bodyFile), { recursive: true });
+            const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
+            fs10.writeFileSync(bodyFile, writeBoardColumns(src, cols));
             broadcast(await doReindex());
             scheduleHasher();
             return { ok: true };
@@ -66442,7 +66577,7 @@ function createHandlers(dataRoot, opts = {}) {
             const files = [];
             let wrote = false;
             for (const doc of loadAgentDocs()) {
-              const exists = fs9.existsSync(path9.resolve(dataRoot, doc.name));
+              const exists = fs10.existsSync(path10.resolve(dataRoot, doc.name));
               if (exists && !overwrite) {
                 files.push({ name: doc.name, status: "exists" });
                 continue;
@@ -66460,6 +66595,40 @@ function createHandlers(dataRoot, opts = {}) {
         ).then((body) => sendJson(res, 201, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
         return;
       }
+      if (req.method !== "POST" && url.pathname === "/api/config") {
+        const source = fs10.existsSync(settingsFile) ? fs10.readFileSync(settingsFile, "utf8") : "";
+        sendJson(res, 200, { source, settings, path: ":.yamlover:settings.yamlover" });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/config") {
+        readBody(req).then(
+          (data) => enqueue(async () => {
+            const source = String(data?.source ?? "");
+            parseYamlover(source, settingsFile);
+            fs10.mkdirSync(path10.dirname(settingsFile), { recursive: true });
+            fs10.writeFileSync(settingsFile, source);
+            settings = loadSettings(dataRoot);
+            broadcast(await doReindexFile(settingsFile));
+            return { ok: true, settings };
+          })
+        ).then((body) => sendJson(res, 200, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/last-tag") {
+        readBody(req).then(
+          (data) => enqueue(async () => {
+            const tag = String(data?.tag ?? "").trim();
+            if (!tag) throw new Error("last-tag needs a `tag` path");
+            const segs2 = strToSegs(tag);
+            if (segs2.length === 0 || segs2.some((g) => typeof g === "number")) throw new Error(`not a tag node path: ${tag}`);
+            writeSettingKey(dataRoot, "annotation-tag", "*:: " + segs2.map((s3) => colonSegment(String(s3))).join(": "));
+            settings = loadSettings(dataRoot);
+            announce({ changed: [relFileOf(":.yamlover:settings.yamlover")] });
+            return { ok: true, annotationTag: settings.annotationTag };
+          })
+        ).then((body) => sendJson(res, 200, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
+        return;
+      }
       const segs = strToSegs(url.searchParams.get("path") || ":");
       const p2 = storePath(segs);
       const depth = parseDepth(url.searchParams.get("depth"));
@@ -66485,37 +66654,37 @@ function createHandlers(dataRoot, opts = {}) {
         return;
       }
       if (url.pathname === "/api/blob") {
-        const file = path9.join(dataRoot, ...segs.map(String));
-        if (!fs9.existsSync(file) || fs9.statSync(file).isDirectory()) return notFound(res, url);
+        const file = path10.join(dataRoot, ...segs.map(String));
+        if (!fs10.existsSync(file) || fs10.statSync(file).isDirectory()) return notFound(res, url);
         res.statusCode = 200;
         res.setHeader("Content-Type", s2.node(p2)?.format ?? formatFromExt(file) ?? "application/octet-stream");
-        res.setHeader("Content-Length", String(fs9.statSync(file).size));
-        const stream = fs9.createReadStream(file);
+        res.setHeader("Content-Length", String(fs10.statSync(file).size));
+        const stream = fs10.createReadStream(file);
         stream.on("error", () => res.destroy());
         stream.pipe(res);
         return;
       }
       if (url.pathname === "/api/thumb") {
         const sourceRow = s2.node(p2);
-        const sourceAbs = path9.join(dataRoot, ...segs.map(String));
-        if (!sourceRow || !fs9.existsSync(sourceAbs) || fs9.statSync(sourceAbs).isDirectory()) return notFound(res, url);
+        const sourceAbs = path10.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);
         const serve = (file) => {
           res.statusCode = 200;
           res.setHeader("Content-Type", "image/jpeg");
-          res.setHeader("Content-Length", String(fs9.statSync(file).size));
+          res.setHeader("Content-Length", String(fs10.statSync(file).size));
           res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-          const stream = fs9.createReadStream(file);
+          const stream = fs10.createReadStream(file);
           stream.on("error", () => res.destroy());
           stream.pipe(res);
         };
-        const ready2 = existingThumb(dataRoot, s2, settings.sidecars.location, segs, sourceRow, w, h);
+        const ready2 = existingThumb(dataRoot, s2, settings.sidecars, segs, sourceRow, w, h);
         if (ready2) return serve(ready2);
         thumbBegin();
         enqueue(async () => {
           thumbTask?.progress(thumbDone, thumbTotal, String(segs[segs.length - 1] ?? ""));
-          const made = await ensureThumbnail(dataRoot, s2, settings.sidecars.location, segs, sourceRow, w, h);
+          const made = await ensureThumbnail(dataRoot, s2, settings.sidecars, segs, sourceRow, w, h);
           if (made) broadcast(await doReindex());
           return made;
         }).then((made) => made ? serve(made) : sendJson(res, 415, { error: `no thumbnail for format: ${sourceRow.format ?? "unknown"}` })).catch((e3) => sendJson(res, 500, { error: String(e3.message || e3) })).finally(() => thumbEnd());
@@ -66569,26 +66738,26 @@ var JSON_EXT = { ".json": "json", ".json5": "json5", ".json5p": "json5p" };
 function concreteOf(dataRoot, segs, row) {
   const last = segs[segs.length - 1];
   if (typeof last === "string") {
-    const json = JSON_EXT[path9.extname(last).toLowerCase()];
+    const json = JSON_EXT[path10.extname(last).toLowerCase()];
     if (json) {
-      const abs2 = path9.resolve(dataRoot, ...segs.map(String));
+      const abs2 = path10.resolve(dataRoot, ...segs.map(String));
       try {
-        if (fs9.statSync(abs2).isFile()) return json;
+        if (fs10.statSync(abs2).isFile()) return json;
       } catch {
       }
     }
   }
   if (row.type !== "mapping") return null;
   if (segs.some((g) => typeof g === "number")) return null;
-  const abs = path9.resolve(dataRoot, ...segs.map(String));
+  const abs = path10.resolve(dataRoot, ...segs.map(String));
   let st;
   try {
-    st = fs9.statSync(abs);
+    st = fs10.statSync(abs);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
-  return fs9.existsSync(path9.join(abs, ".yamlover")) ? "yamlover" : "dir";
+  return fs10.existsSync(path10.join(abs, ".yamlover")) ? "yamlover" : "dir";
 }
 var relKey = (label, other) => `${label ?? ""}\0${other}`;
 var isHidden = (s2, to2) => !!s2.node(to2)?.meta?.hidden;
@@ -66719,8 +66888,8 @@ function buildRelations(dataRoot, s2, segs) {
   return out;
 }
 function binaryContent(dataRoot, segs, row) {
-  const file = path9.join(dataRoot, ...segs.map(String));
-  const bytes = fs9.existsSync(file) ? fs9.readFileSync(file) : Buffer.alloc(0);
+  const file = path10.join(dataRoot, ...segs.map(String));
+  const bytes = fs10.existsSync(file) ? fs10.readFileSync(file) : Buffer.alloc(0);
   return { [BINARY_KEY]: { format: row.format ?? null, size: row.size ?? bytes.length, base64: bytes.toString("base64") } };
 }
 function buildTree(dataRoot, s2, segs, label, depth) {
@@ -66849,12 +67018,12 @@ function writeBoardColumns(src, cols) {
   return lines.join("\n") + "\n";
 }
 function sidecarTarget(dataRoot, mode, subdir, bodyFile) {
-  const dirOverlay = bodyFile.endsWith(path9.join(".yamlover", "body.yamlover"));
+  const dirOverlay = bodyFile.endsWith(path10.join(".yamlover", "body.yamlover"));
   if (mode === "per-directory" && dirOverlay) {
-    const fileDir = path9.dirname(path9.dirname(bodyFile));
-    return { dir: path9.join(fileDir, ".yamlover", subdir), scope: "document" };
+    const fileDir = path10.dirname(path10.dirname(bodyFile));
+    return { dir: path10.join(fileDir, ".yamlover", subdir), scope: "document" };
   }
-  return { dir: path9.join(dataRoot, ".yamlover", subdir), scope: "project" };
+  return { dir: path10.join(dataRoot, ".yamlover", subdir), scope: "project" };
 }
 function sidecarPointerRaw(subdir, name, scope) {
   const body = [".yamlover", subdir, name].map(colonSegment).join(":");
@@ -66866,24 +67035,24 @@ function yScalar(v) {
 function hostFor(dataRoot, s2, segs) {
   for (let i2 = segs.length; i2 >= 0; i2--) {
     const sub = segs.slice(0, i2);
-    const abs = path9.resolve(dataRoot, ...sub.map(String));
+    const abs = path10.resolve(dataRoot, ...sub.map(String));
     let st;
     try {
-      st = fs9.statSync(abs);
+      st = fs10.statSync(abs);
     } catch {
       continue;
     }
-    if (st.isDirectory()) return { bodyFile: path9.join(abs, ".yamlover", "body.yamlover"), within: segs.slice(i2).map(String) };
+    if (st.isDirectory()) return { bodyFile: path10.join(abs, ".yamlover", "body.yamlover"), within: segs.slice(i2).map(String) };
     if (st.isFile()) {
       const node = s2.node(storePath(sub));
       if (node?.meta?.documentRoot && node.type === "mapping" && !node.is_array) {
         return { bodyFile: abs, within: segs.slice(i2).map(String) };
       }
-      const dir = path9.resolve(dataRoot, ...sub.slice(0, -1).map(String));
-      return { bodyFile: path9.join(dir, ".yamlover", "body.yamlover"), within: segs.slice(i2 - 1).map(String) };
+      const dir = path10.resolve(dataRoot, ...sub.slice(0, -1).map(String));
+      return { bodyFile: path10.join(dir, ".yamlover", "body.yamlover"), within: segs.slice(i2 - 1).map(String) };
     }
   }
-  return { bodyFile: path9.join(dataRoot, ".yamlover", "body.yamlover"), within: segs.map(String) };
+  return { bodyFile: path10.join(dataRoot, ".yamlover", "body.yamlover"), within: segs.map(String) };
 }
 function annotationItemLines(a2, indent) {
   const pad = " ".repeat(indent);
@@ -66904,9 +67073,9 @@ function fragmentBlockLines(slug, selector, imagePtr, indent) {
 }
 function embedAnnotation(dataRoot, s2, a2) {
   const { bodyFile, within } = hostFor(dataRoot, s2, strToSegs(a2.target || ":"));
-  fs9.mkdirSync(path9.dirname(bodyFile), { recursive: true });
-  const src = fs9.existsSync(bodyFile) ? fs9.readFileSync(bodyFile, "utf8") : "";
-  fs9.writeFileSync(bodyFile, appendAnnotation(src, within, (indent) => annotationItemLines(a2, indent)));
+  fs10.mkdirSync(path10.dirname(bodyFile), { recursive: true });
+  const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
+  fs10.writeFileSync(bodyFile, appendAnnotation(src, within, (indent) => annotationItemLines(a2, indent)));
   return bodyFile;
 }
 function embedFragment(dataRoot, s2, mode, f2) {
@@ -66918,15 +67087,15 @@ function embedFragment(dataRoot, s2, mode, f2) {
     const bytes = Buffer.from(String(f2.imageBase64).replace(/^data:[^,]*,/, ""), "base64");
     if (bytes.length > 0) {
       const { dir, scope } = sidecarTarget(dataRoot, mode, CROP_SUBDIR, bodyFile);
-      fs9.mkdirSync(dir, { recursive: true });
+      fs10.mkdirSync(dir, { recursive: true });
       const cropName = `${slug}.png`;
       writeInside(dataRoot, dir, cropName, bytes);
       imagePtr = pointerToken(sidecarPointerRaw(CROP_SUBDIR, cropName, scope));
     }
   }
-  fs9.mkdirSync(path9.dirname(bodyFile), { recursive: true });
-  const src = fs9.existsSync(bodyFile) ? fs9.readFileSync(bodyFile, "utf8") : "";
-  fs9.writeFileSync(bodyFile, upsertFragment(src, within, slug, (indent) => fragmentBlockLines(slug, f2.selector, imagePtr, indent)));
+  fs10.mkdirSync(path10.dirname(bodyFile), { recursive: true });
+  const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
+  fs10.writeFileSync(bodyFile, upsertFragment(src, within, slug, (indent) => fragmentBlockLines(slug, f2.selector, imagePtr, indent)));
   return { slug, fragmentPath: segsToStr([...segs, FRAG_KEY, slug]) };
 }
 var thumbResKey = (w, h) => `[${w}, ${h}]`;
@@ -66935,50 +67104,50 @@ 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 = path9.join(dir, thumbName(row.content_hash, w, h));
-  return fs9.existsSync(abs) ? abs : null;
+  const abs = path10.join(dir, thumbName(row.content_hash, w, h));
+  return fs10.existsSync(abs) ? abs : null;
 }
 function embedThumbnail(dataRoot, s2, mode, segs, w, h, name) {
   const { bodyFile, within } = hostFor(dataRoot, s2, segs);
   const { scope } = sidecarTarget(dataRoot, mode, THUMB_SUBDIR, bodyFile);
-  fs9.mkdirSync(path9.dirname(bodyFile), { recursive: true });
-  const src = fs9.existsSync(bodyFile) ? fs9.readFileSync(bodyFile, "utf8") : "";
+  fs10.mkdirSync(path10.dirname(bodyFile), { recursive: true });
+  const src = fs10.existsSync(bodyFile) ? fs10.readFileSync(bodyFile, "utf8") : "";
   const ptr = pointerToken(sidecarPointerRaw(THUMB_SUBDIR, name, scope));
   const key = thumbResKey(w, h);
-  fs9.writeFileSync(bodyFile, upsertThumbnail(src, within, key, (indent) => [`${" ".repeat(indent)}${key}: ${ptr}`]));
+  fs10.writeFileSync(bodyFile, upsertThumbnail(src, within, key, (indent) => [`${" ".repeat(indent)}${key}: ${ptr}`]));
 }
 async function ensureThumbnail(dataRoot, s2, mode, segs, row, w, h) {
-  const sourceAbs = path9.join(dataRoot, ...segs.map(String));
+  const sourceAbs = path10.join(dataRoot, ...segs.map(String));
   const hash = row.content_hash ?? await hashFileAsync(sourceAbs);
   const name = thumbName(hash, w, h);
   const { bodyFile } = hostFor(dataRoot, s2, segs);
   const { dir } = sidecarTarget(dataRoot, mode, THUMB_SUBDIR, bodyFile);
-  const abs = path9.join(dir, name);
-  if (fs9.existsSync(abs)) return abs;
-  const thumb = await renderThumbnail(fs9.readFileSync(sourceAbs), row.format ?? formatFromExt(sourceAbs), w, h);
+  const abs = path10.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;
-  fs9.mkdirSync(dir, { recursive: true });
+  fs10.mkdirSync(dir, { recursive: true });
   writeInside(dataRoot, dir, name, thumb.buf);
   embedThumbnail(dataRoot, s2, mode, segs, w, h, name);
   return abs;
 }
 function unembedAnnotation(dataRoot, s2, target, tag) {
   const { bodyFile, within } = hostFor(dataRoot, s2, strToSegs(target || ":"));
-  if (!fs9.existsSync(bodyFile)) return bodyFile;
+  if (!fs10.existsSync(bodyFile)) return bodyFile;
   const needlePath = ":" + pointerRaw(tag).replace(/^:+/, "");
-  const src = fs9.readFileSync(bodyFile, "utf8");
-  fs9.writeFileSync(bodyFile, removeAnnotation(src, within, (itemText) => itemText.replace(/\s+/g, "").includes(needlePath)));
+  const src = fs10.readFileSync(bodyFile, "utf8");
+  fs10.writeFileSync(bodyFile, removeAnnotation(src, within, (itemText) => itemText.replace(/\s+/g, "").includes(needlePath)));
   return bodyFile;
 }
 function writeTag(dataRoot, location, name) {
   if (/[/\\\r\n:]/.test(name)) throw new Error("a tag name cannot contain '/', '\\', ':' or line breaks");
-  const root = path9.resolve(dataRoot);
-  const dir = path9.resolve(dataRoot, ...strToSegs(location).map(String), ".yamlover");
-  if (!dir.startsWith(root + path9.sep)) throw new Error("tags location escapes the data root");
-  const file = path9.join(dir, "body.yamlover");
-  const createdFile = !fs9.existsSync(file);
+  const root = path10.resolve(dataRoot);
+  const dir = path10.resolve(dataRoot, ...strToSegs(location).map(String), ".yamlover");
+  if (!dir.startsWith(root + path10.sep)) throw new Error("tags location escapes the data root");
+  const file = path10.join(dir, "body.yamlover");
+  const createdFile = !fs10.existsSync(file);
   const head = "# Named tags created from the annotation picker (settings.yamlover: tags.location).\n";
-  const existing = createdFile ? head : fs9.readFileSync(file, "utf8");
+  const existing = createdFile ? head : fs10.readFileSync(file, "utf8");
   const body = (existing === "" || existing.endsWith("\n") ? existing : existing + "\n") + `${name}: !!<*::yamlover:$defs:tag>
 `;
   const entries = parseYamlover(body, file).root.entries ?? [];
@@ -66987,8 +67156,8 @@ function writeTag(dataRoot, location, name) {
   if (!entry || isPointer(entry.value) || entry.value.meta?.schema === void 0) {
     throw new Error(`cannot write a tag named ${JSON.stringify(name)}`);
   }
-  fs9.mkdirSync(dir, { recursive: true });
-  fs9.writeFileSync(file, body);
+  fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(file, body);
   return { node: entry.value, pos, file: [...strToSegs(location).map(String), ".yamlover", "body.yamlover"].join("/"), createdFile };
 }
 function handlePaste(dataRoot, s2, input) {
@@ -67012,7 +67181,7 @@ function handlePaste(dataRoot, s2, input) {
   if (row.format === "x-yamlover-chapter") 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 = path9.resolve(dataRoot, ...dirSegs.map(String));
+  const dir = path10.resolve(dataRoot, ...dirSegs.map(String));
   const final = uniqueName(dir, name);
   writeInside(dataRoot, dir, final, bytes);
   return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
@@ -67020,17 +67189,17 @@ 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 = path9.resolve(dataRoot, ...sub.map(String));
-    if (fs9.existsSync(abs) && fs9.statSync(abs).isDirectory()) return sub;
+    const abs = path10.resolve(dataRoot, ...sub.map(String));
+    if (fs10.existsSync(abs) && fs10.statSync(abs).isDirectory()) return sub;
   }
   return null;
 }
 function chapterSource(dataRoot, s2, segs) {
   const docSegs = documentRootSegs(s2, segs);
-  const docFs = path9.resolve(dataRoot, ...docSegs.map(String));
-  const dirBacked = fs9.existsSync(docFs) && fs9.statSync(docFs).isDirectory();
-  const bodyFile = dirBacked ? path9.join(docFs, ".yamlover", "body.yamlover") : docFs;
-  if (!bodyFile.endsWith(".yamlover") || !fs9.existsSync(bodyFile)) {
+  const docFs = path10.resolve(dataRoot, ...docSegs.map(String));
+  const dirBacked = fs10.existsSync(docFs) && fs10.statSync(docFs).isDirectory();
+  const bodyFile = dirBacked ? path10.join(docFs, ".yamlover", "body.yamlover") : docFs;
+  if (!bodyFile.endsWith(".yamlover") || !fs10.existsSync(bodyFile)) {
     throw new Error("unsupported chapter source (need a .yamlover body)");
   }
   return { docSegs, bodyFile, dirBacked };
@@ -67038,27 +67207,27 @@ function chapterSource(dataRoot, s2, segs) {
 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 = path9.resolve(dataRoot, ...writeDirSegs.map(String));
+  const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
   const final = uniqueName(writeDir, name);
   writeInside(dataRoot, writeDir, final, bytes);
   const fileSegs = [...writeDirSegs, final];
   const pointer = dirBacked ? `*/${final}` : `*/${segsToStr(fileSegs)}`;
   const within = segs.slice(docSegs.length);
-  const src = fs9.readFileSync(bodyFile, "utf8");
-  fs9.writeFileSync(bodyFile, appendToList(src, within, "chunks", (indent) => [`${" ".repeat(indent)}- ${pointer}`]));
+  const src = fs10.readFileSync(bodyFile, "utf8");
+  fs10.writeFileSync(bodyFile, appendToList(src, within, "chunks", (indent) => [`${" ".repeat(indent)}- ${pointer}`]));
   return { path: segsToStr(fileSegs), chapter: segsToStr(segs), pointer };
 }
 function pasteTextIntoChapter(dataRoot, s2, segs, text) {
   const { docSegs, bodyFile } = chapterSource(dataRoot, s2, segs);
   const within = segs.slice(docSegs.length);
-  const src = fs9.readFileSync(bodyFile, "utf8");
-  fs9.writeFileSync(bodyFile, appendToList(src, within, "chunks", (indent) => textChunkLines(text, indent)));
+  const src = fs10.readFileSync(bodyFile, "utf8");
+  fs10.writeFileSync(bodyFile, appendToList(src, within, "chunks", (indent) => textChunkLines(text, indent)));
   return { path: segsToStr(segs), chapter: segsToStr(segs) };
 }
 function pasteTextAsChapterFile(dataRoot, segs, text) {
   const dirSegs = nearestDirSegs(dataRoot, segs);
   if (!dirSegs) throw new Error("no enclosing directory to paste into");
-  const dir = path9.resolve(dataRoot, ...dirSegs.map(String));
+  const dir = path10.resolve(dataRoot, ...dirSegs.map(String));
   const title = titleFromText(text);
   const final = uniqueName(dir, chapterFileName(title));
   const src = ["!!<*::yamlover:$defs:chapter>", `title: ${JSON.stringify(title)}`, "chunks:", ...textChunkLines(text, 0), ""].join("\n");
@@ -67105,7 +67274,7 @@ function richChildLines(node, 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 = path9.resolve(dataRoot, ...writeDirSegs.map(String));
+  const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
   const files = [];
   const pointerFor = (name, bytes) => {
     const final = uniqueName(writeDir, name);
@@ -67114,16 +67283,16 @@ function pasteRichIntoChapter(dataRoot, s2, segs, rich) {
     return dirBacked ? `*/${final}` : `*/${segsToStr([...writeDirSegs, final])}`;
   };
   const within = segs.slice(docSegs.length);
-  let src = fs9.readFileSync(bodyFile, "utf8");
+  let src = fs10.readFileSync(bodyFile, "utf8");
   if (rich.chunks.length) src = appendToList(src, within, "chunks", (ind) => rich.chunks.flatMap((c3) => richItemLines(c3, ind, pointerFor)));
   if (rich.children.length) src = appendToList(src, within, "children", (ind) => rich.children.flatMap((k) => richChildLines(k, ind, pointerFor)));
-  fs9.writeFileSync(bodyFile, src);
+  fs10.writeFileSync(bodyFile, src);
   return { path: segsToStr(segs), chapter: segsToStr(segs), files };
 }
 function pasteRichAsChapter(dataRoot, segs, rich) {
   const dirSegs = nearestDirSegs(dataRoot, segs);
   if (!dirSegs) throw new Error("no enclosing directory to paste into");
-  const dir = path9.resolve(dataRoot, ...dirSegs.map(String));
+  const dir = path10.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");
@@ -67136,16 +67305,16 @@ 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(/\.yamlover$/, ""));
-  const chDir = path9.join(dir, name);
-  if (!path9.resolve(chDir).startsWith(path9.resolve(dataRoot) + path9.sep)) throw new Error("target escapes the data root");
-  fs9.mkdirSync(path9.join(chDir, ".yamlover"), { recursive: true });
+  const chDir = path10.join(dir, name);
+  if (!path10.resolve(chDir).startsWith(path10.resolve(dataRoot) + path10.sep)) throw new Error("target escapes the data root");
+  fs10.mkdirSync(path10.join(chDir, ".yamlover"), { recursive: true });
   const pointerFor = (fname, bytes) => {
     const final = uniqueName(chDir, fname);
     writeInside(dataRoot, chDir, final, bytes);
     return `*/${final}`;
   };
   const src = renderChapterSource(title, rich, pointerFor);
-  writeInside(dataRoot, path9.join(chDir, ".yamlover"), "body.yamlover", Buffer.from(src, "utf8"));
+  writeInside(dataRoot, path10.join(chDir, ".yamlover"), "body.yamlover", Buffer.from(src, "utf8"));
   return { path: segsToStr([...dirSegs, name]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
 }
 function renderChapterSource(title, rich, pointerFor) {
@@ -67167,34 +67336,34 @@ function chapterFileName(title) {
   return `${base || "pasted"}.yamlover`;
 }
 function sanitizeName(raw) {
-  const base = path9.basename(String(raw || "")).replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
+  const base = path10.basename(String(raw || "")).replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
   return base || "pasted";
 }
 function uniqueName(dir, name) {
-  if (!fs9.existsSync(path9.join(dir, name))) return name;
-  const ext = path9.extname(name);
+  if (!fs10.existsSync(path10.join(dir, name))) return name;
+  const ext = path10.extname(name);
   const stem = name.slice(0, name.length - ext.length);
   for (let i2 = 1; ; i2++) {
     const cand = `${stem}-${i2}${ext}`;
-    if (!fs9.existsSync(path9.join(dir, cand))) return cand;
+    if (!fs10.existsSync(path10.join(dir, cand))) return cand;
   }
 }
 function writeInside(dataRoot, dir, name, bytes) {
-  const root = path9.resolve(dataRoot);
-  const target = path9.resolve(dir, name);
-  if (target !== root && !target.startsWith(root + path9.sep)) throw new Error("target escapes the data root");
-  fs9.writeFileSync(target, bytes);
+  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");
+  fs10.writeFileSync(target, bytes);
 }
-var AGENT_DOCS_DIR = path9.join(path9.dirname(fileURLToPath2(import.meta.url)), "agent-docs");
+var AGENT_DOCS_DIR = path10.join(path10.dirname(fileURLToPath3(import.meta.url)), "agent-docs");
 function loadAgentDocs() {
   let names3;
   try {
-    names3 = fs9.readdirSync(AGENT_DOCS_DIR).filter((f2) => f2.endsWith(".md")).sort();
+    names3 = fs10.readdirSync(AGENT_DOCS_DIR).filter((f2) => f2.endsWith(".md")).sort();
   } catch {
     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: fs9.readFileSync(path9.join(AGENT_DOCS_DIR, name), "utf8") }));
+  return names3.map((name) => ({ name, content: fs10.readFileSync(path10.join(AGENT_DOCS_DIR, name), "utf8") }));
 }
 var indentOf2 = (line) => {
   let i2 = 0;
@@ -67361,7 +67530,7 @@ var EXT_CT = {
   ".epub": "application/epub+zip"
 };
 function formatFromExt(file) {
-  return EXT_CT[path9.extname(file).toLowerCase()] ?? null;
+  return EXT_CT[path10.extname(file).toLowerCase()] ?? null;
 }
 function parseDepth(raw) {
   if (raw == null || raw === "") return null;