yamlover 0.3.0

package/dist/server.js

@@ -0,0 +1,4681 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "node_modules/ignore/index.js"(exports, module) {
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => Object.defineProperty(object, key, { value });
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ],
+      // trailing wildcard
+      [
+        /(\^|\\\/)?\\\*$/,
+        (_, p1) => {
+          const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+          return `${prefix}(?=$|\\/$)`;
+        }
+      ]
+    ];
+    var regexCache = /* @__PURE__ */ Object.create(null);
+    var makeRegex = (pattern, ignoreCase) => {
+      let source = regexCache[pattern];
+      if (!source) {
+        source = REPLACERS.reduce(
+          (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+          pattern
+        );
+        regexCache[pattern] = source;
+      }
+      return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+    };
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+    var IgnoreRule = class {
+      constructor(origin, pattern, negative, regex) {
+        this.origin = origin;
+        this.pattern = pattern;
+        this.negative = negative;
+        this.regex = regex;
+      }
+    };
+    var createRule = (pattern, ignoreCase) => {
+      const origin = pattern;
+      let negative = false;
+      if (pattern.indexOf("!") === 0) {
+        negative = true;
+        pattern = pattern.substr(1);
+      }
+      pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regex = makeRegex(pattern, ignoreCase);
+      return new IgnoreRule(
+        origin,
+        pattern,
+        negative,
+        regex
+      );
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path8, originalPath, doThrow) => {
+      if (!isString(path8)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path8) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path8)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = [];
+        this._ignoreCase = ignoreCase;
+        this._allowRelativePaths = allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      _addPattern(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules);
+          this._added = true;
+          return;
+        }
+        if (checkPattern(pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._addPattern, this);
+        if (this._added) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      //          |           ignored : unignored
+      // negative |   0:0   |   0:1   |   1:0   |   1:1
+      // -------- | ------- | ------- | ------- | --------
+      //     0    |  TEST   |  TEST   |  SKIP   |    X
+      //     1    |  TESTIF |  SKIP   |  TEST   |    X
+      // - SKIP: always skip
+      // - TEST: always test
+      // - TESTIF: only test if checkUnignored
+      // - X: that never happen
+      // @param {boolean} whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // @returns {TestResult} true if a file is ignored
+      _testOne(path8, checkUnignored) {
+        let ignored = false;
+        let unignored = false;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule.regex.test(path8);
+          if (matched) {
+            ignored = !negative;
+            unignored = negative;
+          }
+        });
+        return {
+          ignored,
+          unignored
+        };
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path8 = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path8,
+          originalPath,
+          this._allowRelativePaths ? RETURN_FALSE : throwError
+        );
+        return this._t(path8, cache, checkUnignored, slices);
+      }
+      _t(path8, cache, checkUnignored, slices) {
+        if (path8 in cache) {
+          return cache[path8];
+        }
+        if (!slices) {
+          slices = path8.split(SLASH);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path8] = this._testOne(path8, checkUnignored);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
+      }
+      ignores(path8) {
+        return this._test(path8, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path8) => !this.ignores(path8);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path8) {
+        return this._test(path8, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
+    factory.isPathValid = isPathValid;
+    factory.default = factory;
+    module.exports = factory;
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+    ) {
+      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 = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
+    }
+  }
+});
+
+// src/server/engine-api.ts
+import path7 from "node:path";
+import fs6 from "node:fs";
+
+// ../parser/ts/src/ir.ts
+function isPointer(v) {
+  return v.kind === "pointer";
+}
+function toPlain(node) {
+  const ents = node.entries ?? [];
+  if (ents.length === 0) {
+    if (node.kind === "scalar") return node.value;
+    if (node.kind === "blob") throw new Error("toPlain: a blob has no plain JSON form");
+    return node.array ? [] : {};
+  }
+  if (node.kind === "mapping" && (node.array ?? ents.every((e2) => e2.key === null))) {
+    return ents.map(entryPlain);
+  }
+  const o = {};
+  if (node.kind === "scalar") o.$value = node.value;
+  ents.forEach((e2, i) => {
+    o[e2.key ?? String(i)] = entryPlain(e2);
+  });
+  return o;
+}
+function entryPlain(e2) {
+  if (isPointer(e2.value)) throw new Error("toPlain: unresolved pointer has no plain form");
+  return toPlain(e2.value);
+}
+
+// ../engine/ts/src/resolve.ts
+function resolveDocument(doc) {
+  const chains = buildChains(doc.root);
+  const { edges: anchorEdges, keys } = realizeAnchors(doc, chains);
+  const out = [];
+  const walk = (node, docRoot) => {
+    if (!node.entries && !node.meta?.anchors) return;
+    const chain = chains.get(node);
+    const base = pathOf(chain);
+    const dr = node.meta?.documentRoot ? base : docRoot;
+    const prefix = base === ":" ? "" : base;
+    node.entries?.forEach((e2, i) => {
+      const seg = e2.key != null ? ":" + e2.key : "[" + i + "]";
+      if (isPointer(e2.value)) {
+        const target = resolve(doc, chains, chain, e2.value, /* @__PURE__ */ new Set([e2.value]), keys);
+        out.push({ from: prefix + seg, holder: base, label: e2.key, pos: i, raw: e2.value.raw, edge: e2.edge, target, ptr: e2.value, docRoot: dr });
+      } else {
+        walk(e2.value, dr);
+      }
+    });
+    for (const ae of anchorEdges) {
+      if (ae.node !== node) continue;
+      const raw = "&" + ae.anchor.path.raw + (ae.anchor.ordinal ? "[]" : "");
+      out.push({
+        from: base,
+        holder: base,
+        label: anchorKeyOf(ae.anchor),
+        pos: (node.entries?.length ?? 0) + ae.idx,
+        raw,
+        edge: "back",
+        target: ae.target,
+        ptr: ae.anchor.path,
+        docRoot: dr,
+        anchor: true
+      });
+    }
+  };
+  walk(doc.root, ":");
+  return out;
+}
+function anchorKeyOf(a) {
+  return a.ordinal ? null : lastKey(a.path);
+}
+function lastKey(p) {
+  const last = p.steps[p.steps.length - 1];
+  return last && last.sel === "key" ? last.name : null;
+}
+function realizeAnchors(doc, chains) {
+  const edges = [];
+  const keys = /* @__PURE__ */ new Map();
+  for (const [node, chain] of chains) {
+    const anchors = node.meta?.anchors;
+    if (!anchors) continue;
+    anchors.forEach((a, idx) => {
+      const fromChain = chain.slice(0, -1);
+      const containerPtr = a.ordinal ? a.path : { ...a.path, steps: a.path.steps.slice(0, -1) };
+      let target;
+      if (fromChain.length === 0 && (containerPtr.base.scope === "current" || containerPtr.base.scope === "parent")) {
+        target = { kind: "unresolved", reason: "a relative anchor on the document root has no container" };
+      } else {
+        target = resolve(doc, chains, fromChain.length > 0 ? fromChain : [doc.root], containerPtr, /* @__PURE__ */ new Set([containerPtr]));
+      }
+      edges.push({ node, chain, anchor: a, idx, target });
+      if (!a.ordinal && target.kind === "node") {
+        const k = lastKey(a.path);
+        if (k !== null) {
+          let m = keys.get(target.node);
+          if (!m) {
+            m = /* @__PURE__ */ new Map();
+            keys.set(target.node, m);
+          }
+          if (!m.has(k)) m.set(k, node);
+        }
+      }
+    });
+  }
+  return { edges, keys };
+}
+function resolve(doc, chains, fromChain, ptr, visited, anchorKeys) {
+  const root = doc.root;
+  let steps = ptr.steps;
+  let chain;
+  const linkAuthority = ptr.base.scope === "link" ? ptr.base.authority : "";
+  let isLink = false;
+  const external = () => ({ kind: "external", authority: linkAuthority, steps: ptr.steps });
+  switch (ptr.base.scope) {
+    case "link": {
+      isLink = true;
+      chain = chains.get(root) ?? [root];
+      steps = [{ sel: "key", name: ptr.base.authority }, ...ptr.steps];
+      break;
+    }
+    case "document": {
+      let docRoot = root;
+      for (let k = fromChain.length - 1; k >= 0; k--) {
+        if (fromChain[k].meta?.documentRoot) {
+          docRoot = fromChain[k];
+          break;
+        }
+      }
+      chain = chains.get(docRoot) ?? [docRoot];
+      break;
+    }
+    case "parent":
+      chain = fromChain.slice(0, -1);
+      break;
+    case "current":
+      chain = fromChain;
+      break;
+  }
+  for (const st of steps) {
+    if (st.sel === "parent") {
+      if (chain.length <= 1) return isLink ? external() : { kind: "unresolved", reason: '".." above the document root' };
+      chain = chain.slice(0, -1);
+      continue;
+    }
+    const node = chain[chain.length - 1];
+    if (node === void 0) return { kind: "unresolved", reason: "empty resolution scope" };
+    const entry = st.sel === "key" ? node.entries?.find((e2) => e2.key === st.name) : node.entries?.[st.n];
+    if (!entry) {
+      if (st.sel === "key") {
+        const via = anchorKeys?.get(node)?.get(st.name);
+        if (via) {
+          chain = chains.get(via) ?? [via];
+          continue;
+        }
+      }
+      if (!node.entries) return isLink ? external() : { kind: "unresolved", reason: "step into a node with no fields" };
+      return isLink ? external() : { kind: "unresolved", reason: `no ${st.sel === "key" ? `key "${st.name}"` : `index [${st.n}]`}` };
+    }
+    if (isPointer(entry.value)) {
+      if (visited.has(entry.value)) return { kind: "unresolved", reason: "pointer cycle" };
+      const next = new Set(visited);
+      next.add(entry.value);
+      const r = resolve(doc, chains, chain, entry.value, next, anchorKeys);
+      if (r.kind !== "node") return r;
+      chain = chains.get(r.node) ?? [r.node];
+    } else {
+      chain = chains.get(entry.value) ?? [...chain, entry.value];
+    }
+  }
+  const target = chain[chain.length - 1];
+  return { kind: "node", node: target, path: pathOf(chain) };
+}
+function buildChains(root) {
+  const m = /* @__PURE__ */ new Map();
+  const walk = (node, chain) => {
+    const c = [...chain, node];
+    m.set(node, c);
+    if (node.entries) {
+      for (const e2 of node.entries) if (!isPointer(e2.value)) walk(e2.value, c);
+    }
+  };
+  walk(root, []);
+  return m;
+}
+function pathOf(chain) {
+  let s = "";
+  for (let i = 1; i < chain.length; i++) {
+    const parent = chain[i - 1];
+    if (!parent.entries) {
+      s += ":?";
+      continue;
+    }
+    const idx = parent.entries.findIndex((e3) => e3.value === chain[i]);
+    const e2 = parent.entries[idx];
+    s += e2 && e2.key != null ? ":" + e2.key : "[" + idx + "]";
+  }
+  return s === "" ? ":" : s;
+}
+
+// ../engine/ts/src/store.ts
+import { DatabaseSync } from "node:sqlite";
+var SCHEMA_VERSION = 4;
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS node (
+  path         TEXT PRIMARY KEY,
+  type         TEXT NOT NULL,            -- mapping | scalar | blob
+  format       TEXT,                     -- blob/meta format (e.g. image/png, text/markdown)
+  value        TEXT,                     -- scalar self-value, JSON-encoded (scalar/omni only)
+  content_hash TEXT,                     -- blob bytes hash (xxh3/BLAKE3 later)
+  size         INTEGER,                  -- blob byte size
+  is_array     INTEGER NOT NULL DEFAULT 0, -- projection hint: 1 \u21D2 all-keyless (pure sequence)
+  meta         TEXT                      -- JSON: schema ref, span, \u2026
+);
+CREATE TABLE IF NOT EXISTS edge (
+  from_path TEXT NOT NULL,
+  to_path   TEXT NOT NULL,
+  label     TEXT,                        -- relation name (entry key); null for keyless
+  kind      TEXT NOT NULL,               -- contain | ref | back | derived
+  pos       INTEGER                      -- order within parent (contain) for stable TOC order
+);
+CREATE INDEX IF NOT EXISTS edge_from ON edge (from_path);
+CREATE INDEX IF NOT EXISTS edge_to   ON edge (to_path);
+CREATE TABLE IF NOT EXISTS file (
+  path     TEXT PRIMARY KEY,             -- filesystem path relative to the indexed root (POSIX)
+  hash     TEXT,                         -- xxh64:\u2026 of the bytes; NULL until the hasher reaches a large blob
+  size     INTEGER NOT NULL,
+  mtime_ms REAL NOT NULL                 -- (size, mtime) match \u21D2 reuse hash without re-reading
+);
+CREATE TABLE IF NOT EXISTS dangling (
+  from_path TEXT NOT NULL,               -- the entry holding the pointer
+  raw       TEXT NOT NULL,               -- the pointer text as authored
+  reason    TEXT NOT NULL                -- why it did not resolve
+);
+`;
+var Store = class {
+  db;
+  /** True while the DB holds no usable index (a new file, or a schema-version mismatch dropped
+   *  it) — the caller must run a full re-index before serving from it. Cleared by the first
+   *  successful {@link indexDocument}. */
+  _stale;
+  get stale() {
+    return this._stale;
+  }
+  constructor(dbPath) {
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    const ver = this.db.prepare("PRAGMA user_version").get().user_version;
+    if (ver !== SCHEMA_VERSION) {
+      this.db.exec("DROP TABLE IF EXISTS node; DROP TABLE IF EXISTS edge; DROP TABLE IF EXISTS file; DROP TABLE IF EXISTS dangling;");
+      this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION};`);
+    }
+    this.db.exec(SCHEMA);
+    this._stale = ver !== SCHEMA_VERSION;
+  }
+  close() {
+    this.db.close();
+  }
+  /** Rebuild the whole index from one resolved document: clear, then insert nodes + edges in
+   *  a single transaction. (v1 = one document per DB; the directory walker feeds it; ENGINE.md
+   *  derived/cache contract — re-runnable from scratch at any time.) `files` is the walk's file
+   *  manifest (hash cache + diff base — replaced wholesale); pointers that fail to resolve are
+   *  recorded in `dangling` instead of being silently dropped. */
+  indexDocument(doc, files) {
+    const insNode = this.db.prepare(
+      `INSERT OR REPLACE INTO node (path, type, format, value, content_hash, size, is_array, meta)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insEdge = this.db.prepare(
+      `INSERT INTO edge (from_path, to_path, label, kind, pos) VALUES (?, ?, ?, ?, ?)`
+    );
+    this.db.exec("BEGIN");
+    try {
+      this.db.exec("DELETE FROM node; DELETE FROM edge; DELETE FROM dangling;");
+      if (files) this.db.exec("DELETE FROM file;");
+      walkNodes(doc.root, ":", (path8, node, parent, label, pos) => {
+        const meta = node.meta ? JSON.stringify(node.meta) : null;
+        const owned = node.entries?.filter((e2) => e2.edge !== "back") ?? [];
+        const isArray = node.array || node.kind === "mapping" && owned.length > 0 && owned.every((e2) => e2.key === null);
+        const value = node.kind === "scalar" ? JSON.stringify(node.value) : null;
+        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(path8, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
+        if (parent !== null) insEdge.run(parent, path8, label, "contain", pos);
+      });
+      const insDangling = this.db.prepare("INSERT INTO dangling (from_path, raw, reason) VALUES (?, ?, ?)");
+      for (const r of resolveDocument(doc)) {
+        if (r.target.kind === "node") insEdge.run(r.holder, r.target.path, r.label, r.edge, r.pos);
+        else if (r.target.kind === "unresolved") insDangling.run(r.from, r.raw, r.target.reason);
+      }
+      if (files) {
+        const insFile = this.db.prepare("INSERT OR REPLACE INTO file (path, hash, size, mtime_ms) VALUES (?, ?, ?, ?)");
+        for (const f of files) insFile.run(f.path, f.hash, f.size, f.mtimeMs);
+      }
+      this.db.exec("COMMIT");
+      this._stale = false;
+    } catch (e2) {
+      this.db.exec("ROLLBACK");
+      throw e2;
+    }
+  }
+  /** Incrementally add ONE annotation document at `annStorePath`, with a forward `target` ref edge
+   *  to `targetStorePath` and (when given) a keyless `back` edge to `tagStorePath` — the applied
+   *  tag's `~-` membership. This avoids a full re-walk/rebuild (which re-reads and re-hashes every
+   *  blob in the served tree, blocking the server) on every save. The root is FORCED to the
+   *  annotation format so the material's backlink lookup ({@link relationships} `.in`) finds it; the
+   *  `target`/`~-` pointers can't resolve in isolation (they are project-scoped `//…`), so their
+   *  edges are added directly from the known targets. */
+  addAnnotation(annStorePath, targetStorePath, doc, tagStorePath) {
+    const insNode = this.db.prepare(
+      `INSERT OR REPLACE INTO node (path, type, format, value, content_hash, size, is_array, meta)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insEdge = this.db.prepare(
+      `INSERT INTO edge (from_path, to_path, label, kind, pos) VALUES (?, ?, ?, ?, ?)`
+    );
+    this.db.exec("BEGIN");
+    try {
+      walkNodes(doc.root, annStorePath, (p, node, parent, label, pos) => {
+        const meta = node.meta ? JSON.stringify(node.meta) : null;
+        const isArray = node.array || node.kind === "mapping" && (node.entries?.every((e2) => e2.key === null) ?? false);
+        const value = node.kind === "scalar" ? JSON.stringify(node.value) : null;
+        const format = p === annStorePath ? "x-yamlover-annotation" : 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(p, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
+        if (parent !== null) insEdge.run(parent, p, label, "contain", pos);
+      });
+      insEdge.run(annStorePath, targetStorePath, "target", "ref", 0);
+      if (tagStorePath) {
+        const pos = (doc.root.entries ?? []).findIndex((e2) => e2.edge === "back" && e2.key === null);
+        insEdge.run(annStorePath, tagStorePath, null, "back", pos >= 0 ? pos : 0);
+      }
+      this.db.exec("COMMIT");
+    } catch (e2) {
+      this.db.exec("ROLLBACK");
+      throw e2;
+    }
+  }
+  /** Incrementally remove one annotation: its node subtree and every edge touching it. */
+  removeAnnotation(annStorePath) {
+    const like = annStorePath + ":%";
+    this.db.exec("BEGIN");
+    try {
+      this.db.prepare("DELETE FROM node WHERE path = ? OR path LIKE ?").run(annStorePath, like);
+      this.db.prepare("DELETE FROM edge WHERE from_path = ? OR from_path LIKE ? OR to_path = ? OR to_path LIKE ?").run(annStorePath, like, annStorePath, like);
+      this.db.exec("COMMIT");
+    } catch (e2) {
+      this.db.exec("ROLLBACK");
+      throw e2;
+    }
+  }
+  /** Incrementally add ONE named tag under a taxonomy node (tag creation's write path — the
+   *  {@link addAnnotation} of tags): upsert any missing taxonomy ancestors as plain mappings (a
+   *  fresh `/tags` has no rows yet), then the tag's subtree and its containment edge. Approximate
+   *  by design — the next reconcile re-walks the edited taxonomy body and trues everything up;
+   *  these rows only have to answer queries until then. */
+  addTag(taxonomyStorePath, name, pos, node) {
+    const insNode = this.db.prepare(
+      `INSERT OR REPLACE INTO node (path, type, format, value, content_hash, size, is_array, meta)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const insEdge = this.db.prepare(
+      `INSERT INTO edge (from_path, to_path, label, kind, pos) VALUES (?, ?, ?, ?, ?)`
+    );
+    const hasNode = this.db.prepare("SELECT 1 FROM node WHERE path = ?");
+    this.db.exec("BEGIN");
+    try {
+      const segs = taxonomyStorePath === ":" ? [] : taxonomyStorePath.slice(1).split(":");
+      for (let i = 1; i <= segs.length; i++) {
+        const p = ":" + segs.slice(0, i).join(":");
+        if (hasNode.get(p)) continue;
+        insNode.run(p, "mapping", null, null, null, null, 0, null);
+        insEdge.run(i === 1 ? ":" : ":" + segs.slice(0, i - 1).join(":"), p, segs[i - 1], "contain", null);
+      }
+      const tagPath = (taxonomyStorePath === ":" ? "" : taxonomyStorePath) + ":" + name;
+      walkNodes(node, tagPath, (p, n, parent, label, ps) => {
+        const meta = n.meta ? JSON.stringify(n.meta) : null;
+        const isArray = n.array || n.kind === "mapping" && (n.entries?.every((e2) => e2.key === null) ?? false);
+        const value = n.kind === "scalar" ? JSON.stringify(n.value) : null;
+        const format = n.kind === "blob" ? n.format : formatFromMeta(n);
+        insNode.run(p, n.kind, format, value, n.kind === "blob" ? n.contentHash : null, n.kind === "blob" ? n.size : null, isArray ? 1 : 0, meta);
+        if (parent !== null) insEdge.run(parent, p, label, "contain", ps);
+      });
+      insEdge.run(taxonomyStorePath, tagPath, name, "contain", pos);
+      this.db.exec("COMMIT");
+    } catch (e2) {
+      this.db.exec("ROLLBACK");
+      throw e2;
+    }
+  }
+  /** The persisted file manifest, keyed by root-relative path — the previous walk's view of the
+   *  filesystem. Feeds the walker's hash cache and the change diff. */
+  manifest() {
+    const out = /* @__PURE__ */ new Map();
+    for (const r of this.db.prepare("SELECT * FROM file").all()) {
+      out.set(r.path, { path: r.path, hash: r.hash ?? null, size: r.size, mtimeMs: r.mtime_ms });
+    }
+    return out;
+  }
+  /** Manifest entries still lacking a content hash (large blobs the walk never read), smallest
+   *  first so the background hasher shows progress early. */
+  unhashedFiles(limit = -1) {
+    return this.db.prepare("SELECT * FROM file WHERE hash IS NULL ORDER BY size ASC, path ASC LIMIT ?").all(limit).map((r) => ({ path: r.path, hash: null, size: r.size, mtimeMs: r.mtime_ms }));
+  }
+  /** Fill in one file's content hash after the fact (the background hasher): updates the
+   *  manifest row and the matching blob node, guarded by (size, mtimeMs) — returns false
+   *  (writing nothing) when the file changed since it was queued. */
+  setFileHash(relPath, hash, size, mtimeMs) {
+    this.db.exec("BEGIN");
+    try {
+      const r = this.db.prepare("UPDATE file SET hash = ? WHERE path = ? AND size = ? AND mtime_ms = ?").run(hash, relPath, size, mtimeMs);
+      if (Number(r.changes) === 0) {
+        this.db.exec("ROLLBACK");
+        return false;
+      }
+      this.db.prepare("UPDATE node SET content_hash = ? WHERE path = ? AND type = 'blob'").run(hash, ":" + relPath.split("/").join(":"));
+      this.db.exec("COMMIT");
+      return true;
+    } catch (e2) {
+      this.db.exec("ROLLBACK");
+      throw e2;
+    }
+  }
+  /** The pointers that failed to resolve at index time (ENGINE.md: reported, never dropped). */
+  dangling() {
+    return this.db.prepare("SELECT * FROM dangling").all().map((r) => ({
+      from: r.from_path,
+      raw: r.raw,
+      reason: r.reason
+    }));
+  }
+  /** A node's attributes (null if no such path). */
+  node(path8) {
+    const row = this.db.prepare("SELECT * FROM node WHERE path = ?").get(path8);
+    return row ? rowToNode(row) : null;
+  }
+  /** Direct containment children of a node, in source order (by `pos`). */
+  children(path8) {
+    return this.db.prepare("SELECT to_path, label, pos FROM edge WHERE from_path = ? AND kind = 'contain' ORDER BY pos").all(path8).map((r) => ({ to: r.to_path, label: r.label ?? null, pos: r.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(path8) {
+    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(path8).map((r) => ({ to: r.to_path, label: r.label ?? null, pos: r.pos ?? null, kind: r.kind }));
+  }
+  /** Whether a node has any containment children (expandable in the TOC). */
+  hasChildren(path8) {
+    const r = this.db.prepare("SELECT 1 FROM edge WHERE from_path = ? AND kind = 'contain' LIMIT 1").get(path8);
+    return r != 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(path8 = ":", 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
+             WHERE kind = 'contain' AND from_path = ?
+           UNION ALL
+           SELECT e.from_path, e.to_path, e.label, e.pos, sub.lvl + 1 FROM edge e
+             JOIN sub ON e.from_path = sub.to_path
+             WHERE e.kind = 'contain' AND sub.lvl < ?
+         )
+         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(path8, depth === Infinity ? Number.MAX_SAFE_INTEGER : depth);
+    const byPath = /* @__PURE__ */ new Map();
+    const root = { path: path8, label: null, type: this.node(path8)?.type ?? "mapping", format: null, children: [] };
+    byPath.set(path8, root);
+    for (const r of rows) {
+      const tn = {
+        path: r.path,
+        label: r.label ?? null,
+        type: r.type,
+        format: r.format ?? null,
+        children: []
+      };
+      byPath.set(tn.path, tn);
+      (byPath.get(r.parent) ?? root).children.push(tn);
+    }
+    return root.children;
+  }
+  /** 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(path8) {
+    const out = this.db.prepare("SELECT * FROM edge WHERE from_path = ? AND kind != 'contain'").all(path8).map(rowToEdge);
+    const inc = this.db.prepare("SELECT * FROM edge WHERE to_path = ? AND kind != 'contain'").all(path8).map(rowToEdge);
+    const derivedIn = inc.filter((e2) => e2.kind === "ref" || e2.kind === "back").map((e2) => ({ from: e2.to, to: e2.from, label: e2.label, kind: "derived", pos: null }));
+    return { out, in: [...inc, ...derivedIn] };
+  }
+};
+function walkNodes(node, path8, visit, parent = null, label = null, pos = null) {
+  visit(path8, node, parent, label, pos);
+  if (!node.entries) return;
+  node.entries.forEach((e2, i) => {
+    if (isPointer(e2.value)) return;
+    const childPath = (path8 === ":" ? "" : path8) + (e2.key != null ? ":" + e2.key : "[" + i + "]");
+    walkNodes(e2.value, childPath, visit, path8, e2.key, i);
+  });
+}
+function formatFromMeta(node) {
+  const s = node.meta?.schema;
+  if (!s) return null;
+  if (isPointer(s)) {
+    const last = s.steps[s.steps.length - 1];
+    return last?.sel === "key" ? `x-yamlover-${last.name}` : null;
+  }
+  if (s.kind !== "mapping") return null;
+  const f = s.entries?.find((e2) => e2.key === "format");
+  if (f && !isPointer(f.value) && f.value.kind === "scalar") return String(f.value.value);
+  return null;
+}
+function rowToNode(r) {
+  return {
+    path: r.path,
+    type: r.type,
+    format: r.format ?? null,
+    value: r.value != null ? JSON.parse(r.value) : null,
+    content_hash: r.content_hash ?? null,
+    size: r.size ?? null,
+    is_array: !!r.is_array,
+    meta: r.meta != null ? JSON.parse(r.meta) : null
+  };
+}
+function rowToEdge(r) {
+  return {
+    from: r.from_path,
+    to: r.to_path,
+    label: r.label ?? null,
+    kind: r.kind,
+    pos: r.pos ?? null
+  };
+}
+
+// ../engine/ts/src/walk.ts
+import fs from "node:fs";
+import path from "node:path";
+import { setImmediate as yieldLoop } from "node:timers/promises";
+
+// ../engine/ts/node_modules/xxhash-wasm/esm/xxhash-wasm.js
+var t = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 48, 8, 96, 3, 127, 127, 127, 1, 127, 96, 3, 127, 127, 127, 0, 96, 2, 127, 127, 0, 96, 1, 127, 1, 127, 96, 3, 127, 127, 126, 1, 126, 96, 3, 126, 127, 127, 1, 126, 96, 2, 127, 126, 0, 96, 1, 127, 1, 126, 3, 11, 10, 0, 0, 2, 1, 3, 4, 5, 6, 1, 7, 5, 3, 1, 0, 1, 7, 85, 9, 3, 109, 101, 109, 2, 0, 5, 120, 120, 104, 51, 50, 0, 0, 6, 105, 110, 105, 116, 51, 50, 0, 2, 8, 117, 112, 100, 97, 116, 101, 51, 50, 0, 3, 8, 100, 105, 103, 101, 115, 116, 51, 50, 0, 4, 5, 120, 120, 104, 54, 52, 0, 5, 6, 105, 110, 105, 116, 54, 52, 0, 7, 8, 117, 112, 100, 97, 116, 101, 54, 52, 0, 8, 8, 100, 105, 103, 101, 115, 116, 54, 52, 0, 9, 10, 251, 22, 10, 242, 1, 1, 4, 127, 32, 0, 32, 1, 106, 33, 3, 32, 1, 65, 16, 79, 4, 127, 32, 3, 65, 16, 107, 33, 6, 32, 2, 65, 168, 136, 141, 161, 2, 106, 33, 3, 32, 2, 65, 137, 235, 208, 208, 7, 107, 33, 4, 32, 2, 65, 207, 140, 162, 142, 6, 106, 33, 5, 3, 64, 32, 3, 32, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 3, 32, 4, 32, 0, 65, 4, 106, 34, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 4, 32, 2, 32, 0, 65, 4, 106, 34, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 2, 32, 5, 32, 0, 65, 4, 106, 34, 0, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 5, 32, 6, 32, 0, 65, 4, 106, 34, 0, 79, 13, 0, 11, 32, 2, 65, 12, 119, 32, 5, 65, 18, 119, 106, 32, 4, 65, 7, 119, 106, 32, 3, 65, 1, 119, 106, 5, 32, 2, 65, 177, 207, 217, 178, 1, 106, 11, 32, 1, 106, 32, 0, 32, 1, 65, 15, 113, 16, 1, 11, 146, 1, 0, 32, 1, 32, 2, 106, 33, 2, 3, 64, 32, 1, 65, 4, 106, 32, 2, 75, 69, 4, 64, 32, 0, 32, 1, 40, 2, 0, 65, 189, 220, 202, 149, 124, 108, 106, 65, 17, 119, 65, 175, 214, 211, 190, 2, 108, 33, 0, 32, 1, 65, 4, 106, 33, 1, 12, 1, 11, 11, 3, 64, 32, 1, 32, 2, 79, 69, 4, 64, 32, 0, 32, 1, 45, 0, 0, 65, 177, 207, 217, 178, 1, 108, 106, 65, 11, 119, 65, 177, 243, 221, 241, 121, 108, 33, 0, 32, 1, 65, 1, 106, 33, 1, 12, 1, 11, 11, 32, 0, 32, 0, 65, 15, 118, 115, 65, 247, 148, 175, 175, 120, 108, 34, 0, 65, 13, 118, 32, 0, 115, 65, 189, 220, 202, 149, 124, 108, 34, 0, 65, 16, 118, 32, 0, 115, 11, 63, 0, 32, 0, 65, 8, 106, 32, 1, 65, 168, 136, 141, 161, 2, 106, 54, 2, 0, 32, 0, 65, 12, 106, 32, 1, 65, 137, 235, 208, 208, 7, 107, 54, 2, 0, 32, 0, 65, 16, 106, 32, 1, 54, 2, 0, 32, 0, 65, 20, 106, 32, 1, 65, 207, 140, 162, 142, 6, 106, 54, 2, 0, 11, 195, 4, 1, 6, 127, 32, 1, 32, 2, 106, 33, 6, 32, 0, 65, 24, 106, 33, 4, 32, 0, 65, 40, 106, 40, 2, 0, 33, 3, 32, 0, 32, 0, 40, 2, 0, 32, 2, 106, 54, 2, 0, 32, 0, 65, 4, 106, 34, 5, 32, 5, 40, 2, 0, 32, 2, 65, 16, 79, 32, 0, 40, 2, 0, 65, 16, 79, 114, 114, 54, 2, 0, 32, 2, 32, 3, 106, 65, 16, 73, 4, 64, 32, 3, 32, 4, 106, 32, 1, 32, 2, 252, 10, 0, 0, 32, 0, 65, 40, 106, 32, 2, 32, 3, 106, 54, 2, 0, 15, 11, 32, 3, 4, 64, 32, 3, 32, 4, 106, 32, 1, 65, 16, 32, 3, 107, 34, 2, 252, 10, 0, 0, 32, 0, 65, 8, 106, 34, 3, 32, 3, 40, 2, 0, 32, 4, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 54, 2, 0, 32, 0, 65, 12, 106, 34, 3, 32, 3, 40, 2, 0, 32, 4, 65, 4, 106, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 54, 2, 0, 32, 0, 65, 16, 106, 34, 3, 32, 3, 40, 2, 0, 32, 4, 65, 8, 106, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 54, 2, 0, 32, 0, 65, 20, 106, 34, 3, 32, 3, 40, 2, 0, 32, 4, 65, 12, 106, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 54, 2, 0, 32, 0, 65, 40, 106, 65, 0, 54, 2, 0, 32, 1, 32, 2, 106, 33, 1, 11, 32, 1, 32, 6, 65, 16, 107, 77, 4, 64, 32, 6, 65, 16, 107, 33, 8, 32, 0, 65, 8, 106, 40, 2, 0, 33, 2, 32, 0, 65, 12, 106, 40, 2, 0, 33, 3, 32, 0, 65, 16, 106, 40, 2, 0, 33, 5, 32, 0, 65, 20, 106, 40, 2, 0, 33, 7, 3, 64, 32, 2, 32, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 2, 32, 3, 32, 1, 65, 4, 106, 34, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 3, 32, 5, 32, 1, 65, 4, 106, 34, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 5, 32, 7, 32, 1, 65, 4, 106, 34, 1, 40, 2, 0, 65, 247, 148, 175, 175, 120, 108, 106, 65, 13, 119, 65, 177, 243, 221, 241, 121, 108, 33, 7, 32, 8, 32, 1, 65, 4, 106, 34, 1, 79, 13, 0, 11, 32, 0, 65, 8, 106, 32, 2, 54, 2, 0, 32, 0, 65, 12, 106, 32, 3, 54, 2, 0, 32, 0, 65, 16, 106, 32, 5, 54, 2, 0, 32, 0, 65, 20, 106, 32, 7, 54, 2, 0, 11, 32, 1, 32, 6, 73, 4, 64, 32, 4, 32, 1, 32, 6, 32, 1, 107, 34, 1, 252, 10, 0, 0, 32, 0, 65, 40, 106, 32, 1, 54, 2, 0, 11, 11, 97, 1, 1, 127, 32, 0, 65, 16, 106, 40, 2, 0, 33, 1, 32, 0, 65, 4, 106, 40, 2, 0, 4, 127, 32, 1, 65, 12, 119, 32, 0, 65, 20, 106, 40, 2, 0, 65, 18, 119, 106, 32, 0, 65, 12, 106, 40, 2, 0, 65, 7, 119, 106, 32, 0, 65, 8, 106, 40, 2, 0, 65, 1, 119, 106, 5, 32, 1, 65, 177, 207, 217, 178, 1, 106, 11, 32, 0, 40, 2, 0, 106, 32, 0, 65, 24, 106, 32, 0, 65, 40, 106, 40, 2, 0, 16, 1, 11, 255, 3, 2, 3, 126, 1, 127, 32, 0, 32, 1, 106, 33, 6, 32, 1, 65, 32, 79, 4, 126, 32, 6, 65, 32, 107, 33, 6, 32, 2, 66, 214, 235, 130, 238, 234, 253, 137, 245, 224, 0, 124, 33, 3, 32, 2, 66, 177, 169, 172, 193, 173, 184, 212, 166, 61, 125, 33, 4, 32, 2, 66, 249, 234, 208, 208, 231, 201, 161, 228, 225, 0, 124, 33, 5, 3, 64, 32, 3, 32, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 3, 32, 4, 32, 0, 65, 8, 106, 34, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 4, 32, 2, 32, 0, 65, 8, 106, 34, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 2, 32, 5, 32, 0, 65, 8, 106, 34, 0, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 5, 32, 6, 32, 0, 65, 8, 106, 34, 0, 79, 13, 0, 11, 32, 2, 66, 12, 137, 32, 5, 66, 18, 137, 124, 32, 4, 66, 7, 137, 124, 32, 3, 66, 1, 137, 124, 32, 3, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 32, 4, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 32, 2, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 32, 5, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 5, 32, 2, 66, 197, 207, 217, 178, 241, 229, 186, 234, 39, 124, 11, 32, 1, 173, 124, 32, 0, 32, 1, 65, 31, 113, 16, 6, 11, 134, 2, 0, 32, 1, 32, 2, 106, 33, 2, 3, 64, 32, 2, 32, 1, 65, 8, 106, 79, 4, 64, 32, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 32, 0, 133, 66, 27, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 33, 0, 32, 1, 65, 8, 106, 33, 1, 12, 1, 11, 11, 32, 1, 65, 4, 106, 32, 2, 77, 4, 64, 32, 0, 32, 1, 53, 2, 0, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 23, 137, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 249, 243, 221, 241, 153, 246, 153, 171, 22, 124, 33, 0, 32, 1, 65, 4, 106, 33, 1, 11, 3, 64, 32, 1, 32, 2, 73, 4, 64, 32, 0, 32, 1, 49, 0, 0, 66, 197, 207, 217, 178, 241, 229, 186, 234, 39, 126, 133, 66, 11, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 0, 32, 1, 65, 1, 106, 33, 1, 12, 1, 11, 11, 32, 0, 32, 0, 66, 33, 136, 133, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 34, 0, 32, 0, 66, 29, 136, 133, 66, 249, 243, 221, 241, 153, 246, 153, 171, 22, 126, 34, 0, 32, 0, 66, 32, 136, 133, 11, 77, 0, 32, 0, 65, 8, 106, 32, 1, 66, 214, 235, 130, 238, 234, 253, 137, 245, 224, 0, 124, 55, 3, 0, 32, 0, 65, 16, 106, 32, 1, 66, 177, 169, 172, 193, 173, 184, 212, 166, 61, 125, 55, 3, 0, 32, 0, 65, 24, 106, 32, 1, 55, 3, 0, 32, 0, 65, 32, 106, 32, 1, 66, 249, 234, 208, 208, 231, 201, 161, 228, 225, 0, 124, 55, 3, 0, 11, 244, 4, 2, 3, 127, 4, 126, 32, 1, 32, 2, 106, 33, 5, 32, 0, 65, 40, 106, 33, 4, 32, 0, 65, 200, 0, 106, 40, 2, 0, 33, 3, 32, 0, 32, 0, 41, 3, 0, 32, 2, 173, 124, 55, 3, 0, 32, 2, 32, 3, 106, 65, 32, 73, 4, 64, 32, 3, 32, 4, 106, 32, 1, 32, 2, 252, 10, 0, 0, 32, 0, 65, 200, 0, 106, 32, 2, 32, 3, 106, 54, 2, 0, 15, 11, 32, 3, 4, 64, 32, 3, 32, 4, 106, 32, 1, 65, 32, 32, 3, 107, 34, 2, 252, 10, 0, 0, 32, 0, 65, 8, 106, 34, 3, 32, 3, 41, 3, 0, 32, 4, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 55, 3, 0, 32, 0, 65, 16, 106, 34, 3, 32, 3, 41, 3, 0, 32, 4, 65, 8, 106, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 55, 3, 0, 32, 0, 65, 24, 106, 34, 3, 32, 3, 41, 3, 0, 32, 4, 65, 16, 106, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 55, 3, 0, 32, 0, 65, 32, 106, 34, 3, 32, 3, 41, 3, 0, 32, 4, 65, 24, 106, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 55, 3, 0, 32, 0, 65, 200, 0, 106, 65, 0, 54, 2, 0, 32, 1, 32, 2, 106, 33, 1, 11, 32, 1, 65, 32, 106, 32, 5, 77, 4, 64, 32, 5, 65, 32, 107, 33, 2, 32, 0, 65, 8, 106, 41, 3, 0, 33, 6, 32, 0, 65, 16, 106, 41, 3, 0, 33, 7, 32, 0, 65, 24, 106, 41, 3, 0, 33, 8, 32, 0, 65, 32, 106, 41, 3, 0, 33, 9, 3, 64, 32, 6, 32, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 6, 32, 7, 32, 1, 65, 8, 106, 34, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 7, 32, 8, 32, 1, 65, 8, 106, 34, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 8, 32, 9, 32, 1, 65, 8, 106, 34, 1, 41, 3, 0, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 124, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 33, 9, 32, 2, 32, 1, 65, 8, 106, 34, 1, 79, 13, 0, 11, 32, 0, 65, 8, 106, 32, 6, 55, 3, 0, 32, 0, 65, 16, 106, 32, 7, 55, 3, 0, 32, 0, 65, 24, 106, 32, 8, 55, 3, 0, 32, 0, 65, 32, 106, 32, 9, 55, 3, 0, 11, 32, 1, 32, 5, 73, 4, 64, 32, 4, 32, 1, 32, 5, 32, 1, 107, 34, 1, 252, 10, 0, 0, 32, 0, 65, 200, 0, 106, 32, 1, 54, 2, 0, 11, 11, 188, 2, 1, 5, 126, 32, 0, 65, 24, 106, 41, 3, 0, 33, 1, 32, 0, 41, 3, 0, 34, 2, 66, 32, 90, 4, 126, 32, 0, 65, 8, 106, 41, 3, 0, 34, 3, 66, 1, 137, 32, 0, 65, 16, 106, 41, 3, 0, 34, 4, 66, 7, 137, 124, 32, 1, 66, 12, 137, 32, 0, 65, 32, 106, 41, 3, 0, 34, 5, 66, 18, 137, 124, 124, 32, 3, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 32, 4, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 32, 1, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 32, 5, 66, 207, 214, 211, 190, 210, 199, 171, 217, 66, 126, 66, 31, 137, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 133, 66, 135, 149, 175, 175, 152, 182, 222, 155, 158, 127, 126, 66, 157, 163, 181, 234, 131, 177, 141, 138, 250, 0, 125, 5, 32, 1, 66, 197, 207, 217, 178, 241, 229, 186, 234, 39, 124, 11, 32, 2, 124, 32, 0, 65, 40, 106, 32, 2, 66, 31, 131, 167, 16, 6, 11]);
+async function e() {
+  return function(t2) {
+    const { exports: { mem: e2, xxh32: n, xxh64: r, init32: i, update32: a, digest32: o, init64: s, update64: u, digest64: c } } = t2;
+    let h = new Uint8Array(e2.buffer);
+    function g(t3, n2) {
+      if (e2.buffer.byteLength < t3 + n2) {
+        const r2 = Math.ceil((t3 + n2 - e2.buffer.byteLength) / 65536);
+        e2.grow(r2), h = new Uint8Array(e2.buffer);
+      }
+    }
+    function f(t3, e3, n2, r2, i2, a2) {
+      g(t3);
+      const o2 = new Uint8Array(t3);
+      return h.set(o2), n2(0, e3), o2.set(h.subarray(0, t3)), { update(e4) {
+        let n3;
+        return h.set(o2), "string" == typeof e4 ? (g(3 * e4.length, t3), n3 = w.encodeInto(e4, h.subarray(t3)).written) : (g(e4.byteLength, t3), h.set(e4, t3), n3 = e4.byteLength), r2(0, t3, n3), o2.set(h.subarray(0, t3)), this;
+      }, digest: () => (h.set(o2), a2(i2(0))) };
+    }
+    function y(t3) {
+      return t3 >>> 0;
+    }
+    const b = 2n ** 64n - 1n;
+    function d(t3) {
+      return t3 & b;
+    }
+    const w = new TextEncoder(), l = 0, p = 0n;
+    function x(t3, e3 = l) {
+      return g(3 * t3.length, 0), y(n(0, w.encodeInto(t3, h).written, e3));
+    }
+    function L(t3, e3 = p) {
+      return g(3 * t3.length, 0), d(r(0, w.encodeInto(t3, h).written, e3));
+    }
+    return { h32: x, h32ToString: (t3, e3 = l) => x(t3, e3).toString(16).padStart(8, "0"), h32Raw: (t3, e3 = l) => (g(t3.byteLength, 0), h.set(t3), y(n(0, t3.byteLength, e3))), create32: (t3 = l) => f(48, t3, i, a, o, y), h64: L, h64ToString: (t3, e3 = p) => L(t3, e3).toString(16).padStart(16, "0"), h64Raw: (t3, e3 = p) => (g(t3.byteLength, 0), h.set(t3), d(r(0, t3.byteLength, e3))), create64: (t3 = p) => f(88, t3, s, u, c, d) };
+  }((await WebAssembly.instantiate(t)).instance);
+}
+
+// ../parser/ts/src/pointer.ts
+var LINK_RE = /^(?:[A-Za-z][A-Za-z0-9+.-]*:)?\/\//;
+function parsePointer(raw) {
+  if (looksColon(raw)) return parseColon(raw);
+  const lm = LINK_RE.exec(raw);
+  if (lm) {
+    const after = raw.slice(lm[0].length);
+    const { seg, rest } = readUntilSlash(after);
+    const base2 = { scope: "link", authority: unescape(seg) };
+    return { kind: "pointer", base: base2, steps: parsePath(rest), raw };
+  }
+  if (raw[0] === "/") {
+    return { kind: "pointer", base: { scope: "document" }, steps: parsePath(raw), raw };
+  }
+  const segs = splitSlash(raw);
+  let base = { scope: "current" };
+  if (segs.length > 0 && segs[0] === "..") {
+    base = { scope: "parent" };
+    segs.shift();
+  }
+  const steps = [];
+  for (const s of segs) {
+    if (s === "") continue;
+    steps.push(...segToSteps(s));
+  }
+  return { kind: "pointer", base, steps, raw };
+}
+function looksColon(raw) {
+  if (raw.startsWith(":")) return true;
+  if (LINK_RE.test(raw)) return false;
+  let q = null;
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (c === "\\" && q === null) {
+      i++;
+      continue;
+    }
+    if (q !== null) {
+      if (c === q) q = null;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      continue;
+    }
+    if (c === ":") return true;
+  }
+  return false;
+}
+function parseColon(raw) {
+  let rest = raw;
+  let base;
+  if (rest.startsWith(":::")) {
+    rest = rest.slice(3);
+    const portions2 = splitColon(rest);
+    const auth = portions2.shift();
+    if (auth === void 0 || auth === "") throw new SyntaxError(`pointer: ":::" needs an authority in "${raw}"`);
+    base = { scope: "link", authority: portionName(auth), world: true };
+    return { kind: "pointer", base, steps: portionsToSteps(portions2), raw };
+  }
+  if (rest.startsWith("::")) {
+    rest = rest.slice(2);
+    const portions2 = splitColon(rest);
+    const auth = portions2.shift();
+    if (auth === void 0 || auth === "") throw new SyntaxError(`pointer: "::" needs a first portion in "${raw}"`);
+    base = { scope: "link", authority: portionName(auth) };
+    return { kind: "pointer", base, steps: portionsToSteps(portions2), raw };
+  }
+  if (rest.startsWith(":")) {
+    return { kind: "pointer", base: { scope: "document" }, steps: portionsToSteps(splitColon(rest.slice(1))), raw };
+  }
+  const portions = splitColon(rest);
+  base = { scope: "current" };
+  if (portions.length > 0 && portions[0] === "..") {
+    base = { scope: "parent" };
+    portions.shift();
+  }
+  return { kind: "pointer", base, steps: portionsToSteps(portions), raw };
+}
+function splitColon(s) {
+  const out = [];
+  let cur = "";
+  let q = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q !== null) {
+      cur += c;
+      if (c === q) q = null;
+      continue;
+    }
+    if (c === "\\" && i + 1 < s.length) {
+      cur += c + s[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      cur += c;
+      continue;
+    }
+    if (c === ":") {
+      out.push(cur.trim());
+      cur = "";
+      continue;
+    }
+    cur += c;
+  }
+  out.push(cur.trim());
+  return out.filter((p) => p !== "");
+}
+function portionsToSteps(portions) {
+  const out = [];
+  for (const p of portions) out.push(...portionToSteps(p));
+  return out;
+}
+function portionToSteps(p) {
+  if (p === "..") return [{ sel: "parent" }];
+  let name = "";
+  let i = 0;
+  if (p[0] === "'" || p[0] === '"') {
+    const q = p[0];
+    i = 1;
+    for (; i < p.length; i++) {
+      if (p[i] === q) {
+        if (q === "'" && p[i + 1] === "'") {
+          name += q;
+          i++;
+          continue;
+        }
+        i++;
+        break;
+      }
+      if (q === '"' && p[i] === "\\" && i + 1 < p.length) {
+        name += p[i + 1];
+        i++;
+        continue;
+      }
+      name += p[i];
+    }
+  } else {
+    for (; i < p.length; i++) {
+      const c = p[i];
+      if (c === "\\" && i + 1 < p.length) {
+        name += p[i + 1];
+        i++;
+        continue;
+      }
+      if (c === "[") break;
+      if (c === " " || c === "	") throw new SyntaxError(`pointer: a key containing a space must be quoted ("${p}")`);
+      name += c;
+    }
+  }
+  const steps = [];
+  if (name !== "") steps.push({ sel: "key", name });
+  while (i < p.length) {
+    if (p[i] !== "[") throw new SyntaxError(`pointer: malformed portion "${p}"`);
+    let j = i + 1;
+    let digits = "";
+    while (j < p.length && p[j] >= "0" && p[j] <= "9") {
+      digits += p[j];
+      j++;
+    }
+    if (digits === "" || p[j] !== "]") throw new SyntaxError(`pointer: malformed index in "${p}"`);
+    steps.push({ sel: "index", n: Number.parseInt(digits, 10) });
+    i = j + 1;
+  }
+  return steps;
+}
+function portionName(p) {
+  const steps = portionToSteps(p);
+  if (steps.length !== 1 || steps[0].sel !== "key") throw new SyntaxError(`pointer: bad authority portion "${p}"`);
+  return steps[0].name;
+}
+function renderPointer(p, opts = {}) {
+  const spaced = opts.spaced !== false;
+  const sep2 = spaced ? ": " : ":";
+  const toks = [];
+  for (const st of p.steps) {
+    if (st.sel === "parent") toks.push("..");
+    else if (st.sel === "key") toks.push(colonSegment(st.name));
+    else if (toks.length > 0 && !toks[toks.length - 1].endsWith("..")) toks[toks.length - 1] += `[${st.n}]`;
+    else toks.push(`[${st.n}]`);
+  }
+  const body = toks.join(sep2);
+  switch (p.base.scope) {
+    case "current":
+      return body;
+    case "parent":
+      return body === "" ? ".." : ".." + sep2 + body;
+    case "document":
+      return ":" + (body === "" ? "" : (spaced ? " " : "") + body);
+    case "link": {
+      const ladder = p.base.world === true ? ":::" : "::";
+      const auth = colonSegment(p.base.authority);
+      return ladder + (spaced ? " " : "") + auth + (body === "" ? "" : sep2 + body);
+    }
+  }
+}
+function colonSegment(name) {
+  if (name === "..") return "\\.\\.";
+  if (/[ \t]/.test(name) || /^['"]/.test(name)) return `'${name.replace(/'/g, "''")}'`;
+  return name.replace(/[\\:[\]*&#~?!()<>=|]/g, (c) => "\\" + c);
+}
+function parsePath(path8) {
+  const segs = splitSlash(path8);
+  const out = [];
+  for (let i = 0; i < segs.length; i++) {
+    if (segs[i] === "") continue;
+    out.push(...segToSteps(segs[i]));
+  }
+  return out;
+}
+function splitSlash(s) {
+  const out = [];
+  let cur = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\" && i + 1 < s.length) {
+      cur += c + s[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "/") {
+      out.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += c;
+  }
+  out.push(cur);
+  return out;
+}
+function readUntilSlash(s) {
+  let i = 0;
+  let seg = "";
+  for (; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\" && i + 1 < s.length) {
+      seg += c + s[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "/") break;
+    seg += c;
+  }
+  return { seg, rest: s.slice(i) };
+}
+function segToSteps(seg) {
+  if (seg === "..") return [{ sel: "parent" }];
+  let i = 0;
+  let name = "";
+  for (; i < seg.length; i++) {
+    const c = seg[i];
+    if (c === "\\" && i + 1 < seg.length) {
+      name += c + seg[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "[") break;
+    name += c;
+  }
+  const steps = [];
+  if (name !== "") steps.push({ sel: "key", name: unescape(name) });
+  while (i < seg.length) {
+    if (seg[i] !== "[") throw new SyntaxError(`pointer: malformed segment "${seg}"`);
+    let j = i + 1;
+    let digits = "";
+    while (j < seg.length && seg[j] >= "0" && seg[j] <= "9") {
+      digits += seg[j];
+      j++;
+    }
+    if (digits === "" || seg[j] !== "]") throw new SyntaxError(`pointer: malformed index in "${seg}"`);
+    steps.push({ sel: "index", n: Number.parseInt(digits, 10) });
+    i = j + 1;
+  }
+  return steps;
+}
+function unescape(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\" && i + 1 < s.length) {
+      out += s[i + 1];
+      i++;
+      continue;
+    }
+    out += s[i];
+  }
+  return out;
+}
+function makeAnchor(body, fail) {
+  let ordinal = false;
+  if (body.endsWith("[]") && !body.endsWith("\\[]")) {
+    ordinal = true;
+    body = body.slice(0, -2);
+  }
+  const path8 = parsePointer(body);
+  if (!ordinal) {
+    const last = path8.steps[path8.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: path8, ...ordinal ? { ordinal: true } : {} };
+}
+function escapeSegment(name) {
+  if (name === "..") return "\\.\\.";
+  return name.replace(/[\\/:[\]*&#~?!()<>=|]/g, (c) => "\\" + c);
+}
+
+// ../parser/ts/src/yamlover.ts
+function parseYamlover(src, uri = "<yamlover>") {
+  const raw = [];
+  const lineStarts = [];
+  const sep2 = /\r\n|\r|\n/g;
+  let at = 0;
+  for (let m = sep2.exec(src); m !== null; m = sep2.exec(src)) {
+    raw.push(src.slice(at, m.index));
+    lineStarts.push(at);
+    at = m.index + m[0].length;
+  }
+  raw.push(src.slice(at));
+  lineStarts.push(at);
+  const p = new Block(lex(raw), raw, uri, lineStarts);
+  for (let k = 0; k < p.lines.length; k++) {
+    const l = p.lines[k];
+    if (l.indent === 0 && (l.text === "---" || l.text.startsWith("--- ") || l.text === "...")) {
+      p.i = k;
+      p.fail('multi-document streams ("---" / "...") are not yet supported (Phase 2c)');
+    }
+  }
+  let rootSchema;
+  const first = p.peek();
+  if (first && /^!!<[^>]*>$/.test(first.text.trim())) {
+    rootSchema = parseSchemaRef(first.text.trim().slice(3, -1), { block: p, lineN: first.n, col: first.indent + 3 });
+    p.i++;
+  }
+  let root = p.node(0) ?? nul();
+  if (isPointer(root)) throw new SyntaxError(`yamlover: a top-level pointer is not allowed in ${uri}`);
+  if (p.i < p.lines.length && p.peek().indent === 0) {
+    root = p.mergeCont(root, p.container(0));
+  }
+  if (p.i < p.lines.length) p.fail("unexpected content");
+  if (rootSchema !== void 0) root.meta = { ...root.meta, schema: rootSchema };
+  return { root, source: { concrete: "yamlover", uri } };
+}
+function lex(raw) {
+  const out = [];
+  for (let n = 0; n < raw.length; n++) {
+    const line = raw[n];
+    let indent = 0;
+    while (indent < line.length && line[indent] === " ") indent++;
+    const content = stripComment(line.slice(indent)).replace(/\s+$/, "");
+    if (content === "") continue;
+    out.push({ indent, text: content, n });
+  }
+  return out;
+}
+function stripComment(s) {
+  let inS = false;
+  let inD = false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (inD && c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "'" && !inD) inS = !inS;
+    else if (c === '"' && !inS) inD = !inD;
+    else if (c === "#" && !inS && !inD && (i === 0 || s[i - 1] === " " || s[i - 1] === "	")) {
+      return s.slice(0, i);
+    }
+  }
+  return s;
+}
+var Block = class {
+  lines;
+  raw;
+  // all source lines (for block scalars, which keep blanks and `#`)
+  uri;
+  // source path/id, surfaced in parse-error messages
+  lineStarts;
+  // absolute offset of each raw line's first character
+  i = 0;
+  constructor(lines, raw, uri = "<yamlover>", lineStarts = []) {
+    this.lines = lines;
+    this.raw = raw;
+    this.uri = uri;
+    this.lineStarts = lineStarts;
+  }
+  /** Absolute span of `len` chars starting at column `col` of raw line `lineN`. Valid
+   *  because every Line.text is a prefix-aligned slice of its raw line (lex strips only
+   *  the comment/trailing-ws SUFFIX), so tracked columns are raw-line columns. */
+  spanAt(lineN, col, len) {
+    const start = (this.lineStarts[lineN] ?? 0) + col;
+    return { uri: this.uri, start, end: start + len };
+  }
+  peek() {
+    return this.lines[this.i];
+  }
+  /** Read ONE `&` anchor token at the head of `text` (URIs.md §`&`): `&path`, `&path[]`,
+   *  or the quoted form `&'path with spaces'`. Plain tokens run to unescaped whitespace.
+   *  Returns the Anchor plus the remaining text/column. */
+  anchorToken(text, lineN, col) {
+    let body;
+    let tokenLen;
+    if (text[1] === "'" || text[1] === '"') {
+      const q = text[1];
+      let j = 2;
+      while (j < text.length) {
+        if (q === '"' && text[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (text[j] === q) {
+          if (q === "'" && text[j + 1] === "'") {
+            j += 2;
+            continue;
+          }
+          break;
+        }
+        j++;
+      }
+      if (j >= text.length) this.fail("unterminated quoted anchor path");
+      body = quotedScalar(text.slice(1, j + 1)).value;
+      tokenLen = j + 1;
+    } else if (hasSeparatorColon(text.slice(1))) {
+      body = text.slice(1).trim();
+      tokenLen = text.length;
+    } else {
+      let j = 1;
+      while (j < text.length && text[j] !== " " && text[j] !== "	") {
+        if (text[j] === "\\" && j + 1 < text.length) j++;
+        j++;
+      }
+      body = text.slice(1, j);
+      tokenLen = j;
+    }
+    const anchor = makeAnchor(body, (m) => this.fail(m));
+    anchor.path.span = this.spanAt(lineN, col, tokenLen);
+    const a = adv(text, tokenLen, col);
+    return { anchor, rest: a.rest, col: a.col };
+  }
+  /** Attach anchors to a (non-pointer) node's meta, appending to any it already has. */
+  attachAnchors(value, anchors) {
+    if (anchors.length === 0) return;
+    if (isPointer(value)) this.fail("cannot anchor a pointer");
+    value.meta = { ...value.meta, anchors: [...value.meta?.anchors ?? [], ...anchors] };
+  }
+  /** Merge a container() CONTINUATION into a node that already holds its value: entries
+   *  and anchors append. A continuation carrying its own value line is a second value —
+   *  an error — except the bare anchors-only case (a synthesized null with no raw). */
+  mergeCont(v, cont) {
+    const bare = cont.kind === "scalar" && cont.value === null && cont.raw === "" && (cont.entries?.length ?? 0) === 0;
+    if (cont.kind === "scalar" && !bare) this.fail("a node may carry at most one scalar value line");
+    const entries = [...v.entries ?? [], ...cont.entries ?? []];
+    const out = {
+      ...v,
+      ...entries.length > 0 ? { entries, array: cont.kind === "mapping" ? cont.array : v.array } : {}
+    };
+    this.attachAnchors(out, cont.meta?.anchors ?? []);
+    return out;
+  }
+  fail(msg) {
+    const l = this.lines[this.i] ?? this.lines[this.i - 1];
+    const where = l ? `${this.uri}:${l.n + 1}` : this.uri;
+    const ctx = l ? `
+  ${l.n + 1} | ${this.raw[l.n]}` : "";
+    throw new SyntaxError(`yamlover: ${msg} at ${where}${ctx}`);
+  }
+  /** Parse a block node whose content lives at a column >= minIndent (null if none). */
+  node(minIndent) {
+    const l = this.peek();
+    if (!l || l.indent < minIndent) return null;
+    if (/^!!(mix|omni|set)(?=\s|$)/.test(l.text)) {
+      this.i++;
+      return this.valueAfter(l.text, l.indent - 1, l.n, l.indent);
+    }
+    if (isSeqLine(l.text) || isBackSeqLine(l.text) || l.text.startsWith("&") || splitKV(l.text)) {
+      return this.container(l.indent);
+    }
+    this.i++;
+    let v = this.valueInline(
+      l.text,
+      l.indent,
+      /*allowBlock*/
+      true,
+      l.n,
+      l.indent
+    );
+    const nxt = this.peek();
+    if (nxt && nxt.indent === l.indent && nxt.indent >= minIndent && !isPointer(v) && v.kind === "scalar") {
+      v = this.mergeCont(v, this.container(l.indent));
+    }
+    return v;
+  }
+  /**
+   * One ordered container at `indent` — yamlover's single container model. Entries keep
+   * their order (→ integer keys [0],[1],…); each MAY also carry a string key. So keyless
+   * (`- value`) and keyed (`key: value`) entries can be MIXED in one node ("partially
+   * ordered, partially keyed"). `array` is just a projection hint: true iff all-keyless.
+   *
+   * `keylessOnly` is for the same-indent sequence-under-a-key case, where a keyed line at
+   * this indent is a SIBLING of the outer key, not a member — so we stop at it.
+   */
+  container(indent, keylessOnly = false) {
+    const entries = [];
+    const anchors = [];
+    let self;
+    for (; ; ) {
+      const l = this.peek();
+      if (!l || l.indent !== indent) break;
+      let value;
+      let entry;
+      if (l.text.startsWith("&")) {
+        if (keylessOnly) break;
+        this.i++;
+        let { rest, col } = { rest: l.text, col: l.indent };
+        while (rest.startsWith("&")) {
+          const r = this.anchorToken(rest, l.n, col);
+          anchors.push(r.anchor);
+          ({ rest, col } = r);
+        }
+        if (rest !== "") {
+          const v = this.valueInline(
+            rest,
+            indent,
+            /*allowBlock*/
+            false,
+            l.n,
+            col
+          );
+          if (isPointer(v) || v.kind !== "scalar") this.fail("only a scalar value may share a line with an own-line anchor");
+          if (self !== void 0) this.fail("a node may carry at most one scalar value line");
+          self = v;
+        }
+        continue;
+      }
+      if (isSeqLine(l.text)) {
+        this.i++;
+        const afterDash = l.text.slice(1);
+        const lead = afterDash.length - afterDash.trimStart().length;
+        const contentCol = l.indent + 1 + lead;
+        const rest = afterDash.trim();
+        if (rest === "") {
+          value = this.node(indent + 1) ?? nul();
+        } else if (!/^(!!<|\*|&)/.test(rest) && splitKV(rest)) {
+          this.i--;
+          this.lines[this.i] = { indent: contentCol, text: rest, n: l.n };
+          value = this.container(contentCol);
+        } else {
+          value = this.valueAfter(rest, indent, l.n, contentCol);
+        }
+        entry = { key: null, edge: isPointer(value) ? "ref" : "contain", value };
+      } else if (isBackSeqLine(l.text)) {
+        if (keylessOnly) break;
+        this.i++;
+        const a = adv(l.text, 2, l.indent);
+        const rest = a.rest;
+        if (!rest.startsWith("*")) this.fail('a "~-" entry needs a pointer value (the container that holds this node)');
+        const ptr = parsePointer(unquoteIfQuoted(rest.slice(1)));
+        ptr.span = this.spanAt(l.n, a.col, rest.length);
+        value = ptr;
+        entry = { key: null, edge: "back", value };
+      } else {
+        if (keylessOnly) break;
+        if (/^~[ \t]/.test(l.text)) this.fail('the "~" sigil must sit tight against the key or "-" marker (write "~key:" or "~-")');
+        const kv = splitKV(l.text);
+        if (!kv) {
+          this.i++;
+          const v = this.valueInline(
+            l.text,
+            indent,
+            /*allowBlock*/
+            false,
+            l.n,
+            l.indent
+          );
+          if (isPointer(v) || v.kind !== "scalar") this.fail("unexpected content (expected an entry, an anchor, or a scalar value line)");
+          if (self !== void 0) this.fail("a node may carry at most one scalar value line");
+          self = v;
+          continue;
+        }
+        this.i++;
+        let key = kv.key;
+        let back = false;
+        if (key.startsWith("~")) {
+          back = true;
+          key = key.slice(1);
+        }
+        value = this.valueAfter(kv.rest, indent, l.n, l.indent + kv.restCol);
+        entry = { key: unquoteKey(key), edge: back ? "back" : isPointer(value) ? "ref" : "contain", value };
+      }
+      entries.push(entry);
+    }
+    const owned = entries.filter((e2) => e2.edge !== "back");
+    const array = owned.length > 0 && owned.every((e2) => e2.key === null);
+    const node = self !== void 0 ? { ...self, entries, array } : entries.length === 0 ? nul() : { kind: "mapping", entries, array };
+    this.attachAnchors(node, anchors);
+    return node;
+  }
+  /** The value after `key:` or `- ` (inline `rest`, with a possible deeper block).
+   *  `col` = the column of `rest` in raw line `srcLineN` (span tracking). */
+  valueAfter(rest, parentIndent, srcLineN, col) {
+    ({ rest, col } = adv(rest, 0, col));
+    let schema;
+    if (rest.startsWith("!!<")) {
+      const close = rest.indexOf(">");
+      if (close < 0) this.fail('unterminated "!!<\u2026>" schema tag');
+      schema = parseSchemaRef(rest.slice(3, close), { block: this, lineN: srcLineN, col: col + 3 });
+      ({ rest, col } = adv(rest, close + 1, col));
+    }
+    let typeTag;
+    const tag = /^!!(mix|omni|set)(?=\s|$)/.exec(rest);
+    if (tag) {
+      typeTag = tag[1];
+      ({ rest, col } = adv(rest, tag[0].length, col));
+    }
+    const anchors = [];
+    while (rest.startsWith("&")) {
+      const r = this.anchorToken(rest, srcLineN, col);
+      anchors.push(r.anchor);
+      ({ rest, col } = r);
+    }
+    let value;
+    if (/^[|>][+-]?\d*$/.test(rest)) {
+      value = this.blockScalar(rest, parentIndent, srcLineN);
+      value = this.attachFields(value, parentIndent);
+    } else if (rest === "") {
+      const nxt = this.peek();
+      if (nxt && nxt.indent === parentIndent && isSeqLine(nxt.text)) {
+        value = this.container(
+          parentIndent,
+          /*keylessOnly*/
+          true
+        );
+      } else {
+        value = this.node(parentIndent + 1) ?? nul();
+      }
+    } else {
+      value = this.valueInline(
+        rest,
+        parentIndent,
+        /*allowBlock*/
+        false,
+        srcLineN,
+        col
+      );
+      value = this.attachFields(value, parentIndent);
+    }
+    this.attachAnchors(value, anchors);
+    if (typeTag === "set" && !isPointer(value)) value.meta = { ...value.meta, set: true };
+    if (schema !== void 0 && !isPointer(value)) value.meta = { ...value.meta, schema };
+    return value;
+  }
+  /** A node = value + fields: a scalar value (inline OR a block scalar) followed by a DEEPER
+   *  block attaches that block's (positional and/or keyed) entries onto the scalar — one node
+   *  carrying its value and its fields (the `!!omni` shape). Non-scalars/pointers pass through. */
+  attachFields(value, parentIndent) {
+    const nxt = this.peek();
+    if (nxt && nxt.indent > parentIndent && !isPointer(value) && value.kind !== "blob") {
+      return this.mergeCont(value, this.container(nxt.indent));
+    }
+    return value;
+  }
+  /** A block scalar (`|` literal / `>` folded, with `-`/`+` chomping) introduced by the
+   *  indicator on line `srcLineN`. Reads RAW lines (blanks + `#` are significant), de-indents
+   *  by the block's own indent, and advances past the consumed lines. */
+  blockScalar(indicator, parentIndent, srcLineN) {
+    const folded = indicator[0] === ">";
+    let chomp = "clip";
+    for (const ch of indicator.slice(1)) {
+      if (ch === "-") chomp = "strip";
+      else if (ch === "+") chomp = "keep";
+    }
+    const lines = [];
+    let blockIndent = -1;
+    let lastN = srcLineN;
+    for (let n = srcLineN + 1; n < this.raw.length; n++) {
+      const r = this.raw[n];
+      let ind = 0;
+      while (ind < r.length && r[ind] === " ") ind++;
+      if (ind >= r.length) {
+        lines.push("");
+        lastN = n;
+        continue;
+      }
+      if (ind <= parentIndent) break;
+      if (blockIndent >= 0 && ind < blockIndent) break;
+      if (blockIndent < 0) blockIndent = ind;
+      lines.push(r.slice(blockIndent));
+      lastN = n;
+    }
+    while (this.peek() && this.peek().n <= lastN) this.i++;
+    let last = -1;
+    for (let i = 0; i < lines.length; i++) if (lines[i] !== "") last = i;
+    const core = lines.slice(0, last + 1);
+    let body = folded ? foldLines(core) : core.join("\n");
+    if (chomp === "keep") body += "\n".repeat(lines.length - (last + 1) + (last >= 0 ? 1 : 0));
+    else if (chomp === "clip" && last >= 0) body += "\n";
+    return { kind: "scalar", value: body, raw: body };
+  }
+  /** Parse a single-line inline value: flow, pointer, anchor, quoted or plain scalar.
+   *  `col` = the column of `text` in raw line `lineN` (span tracking). */
+  valueInline(text, parentIndent, allowBlock, lineN, col) {
+    ({ rest: text, col } = adv(text, 0, col));
+    const c = text[0];
+    if (c === "{" || c === "[") {
+      return new Flow(text, this.uri, (this.lineStarts[lineN] ?? 0) + col).parse();
+    }
+    if (c === "*") {
+      const p = parsePointer(unquoteIfQuoted(text.slice(1)));
+      p.span = this.spanAt(lineN, col, text.length);
+      return p;
+    }
+    if (c === "&") {
+      const anchors = [];
+      let rest = text;
+      let acol = col;
+      while (rest.startsWith("&")) {
+        const r = this.anchorToken(rest, lineN, acol);
+        anchors.push(r.anchor);
+        ({ rest, col: acol } = r);
+      }
+      const v = rest === "" ? allowBlock ? this.node(parentIndent + 1) ?? nul() : nul() : this.valueInline(rest, parentIndent, allowBlock, lineN, acol);
+      this.attachAnchors(v, anchors);
+      return v;
+    }
+    if (c === "'" || c === '"') return quotedScalar(text);
+    return plainScalar(text);
+  }
+};
+var Flow = class {
+  s;
+  i = 0;
+  uri;
+  base;
+  // absolute offset of s[0] in the source (span tracking)
+  constructor(s, uri = "<flow>", base = 0) {
+    this.s = s;
+    this.uri = uri;
+    this.base = base;
+  }
+  fail(msg) {
+    throw new SyntaxError(`yamlover (flow): ${msg} at offset ${this.i}`);
+  }
+  parse() {
+    this.ws();
+    const v = this.value();
+    this.ws();
+    if (this.i < this.s.length) this.fail("trailing characters in flow value");
+    return v;
+  }
+  ws() {
+    while (this.i < this.s.length && " 	".includes(this.s[this.i])) this.i++;
+  }
+  value() {
+    const c = this.s[this.i];
+    if (c === "{") return this.map();
+    if (c === "[") return this.seq();
+    if (c === "*") {
+      const start = this.i;
+      this.i++;
+      let txt;
+      if (this.s[this.i] === "'" || this.s[this.i] === '"') {
+        txt = this.quoted().value;
+      } else {
+        const st = this.i;
+        let depth = 0;
+        while (this.i < this.s.length) {
+          const ch = this.s[this.i];
+          if (ch === "\\" && this.i + 1 < this.s.length) {
+            this.i += 2;
+            continue;
+          }
+          if (ch === "[") depth++;
+          else if (ch === "]") {
+            if (depth === 0) break;
+            depth--;
+          } else if (ch === "," || ch === "}") break;
+          this.i++;
+        }
+        txt = this.s.slice(st, this.i).trim();
+      }
+      const p = parsePointer(txt);
+      p.span = { uri: this.uri, start: this.base + start, end: this.base + this.i };
+      return p;
+    }
+    if (c === "&") {
+      const start = this.i;
+      this.i++;
+      let body;
+      if (this.s[this.i] === "'" || this.s[this.i] === '"') {
+        body = this.quoted().value;
+      } else {
+        const st = this.i;
+        while (this.i < this.s.length && !" 	,]}".includes(this.s[this.i])) {
+          if (this.s[this.i] === "\\" && this.i + 1 < this.s.length) this.i++;
+          this.i++;
+        }
+        body = this.s.slice(st, this.i);
+      }
+      const anchor = makeAnchor(body, (m) => this.fail(m));
+      anchor.path.span = { uri: this.uri, start: this.base + start, end: this.base + this.i };
+      this.ws();
+      const v = this.value();
+      if (isPointer(v)) this.fail("cannot anchor a pointer");
+      v.meta = { ...v.meta, anchors: [...v.meta?.anchors ?? [], anchor] };
+      return v;
+    }
+    if (c === "'" || c === '"') return this.quoted();
+    const tok = this.readPlain();
+    if (tok === "") this.fail("expected a value");
+    return plainScalar(tok);
+  }
+  map() {
+    this.i++;
+    const entries = [];
+    for (; ; ) {
+      this.ws();
+      if (this.s[this.i] === "}") {
+        this.i++;
+        break;
+      }
+      if (this.i >= this.s.length) this.fail("unterminated flow map");
+      let back = false;
+      if (this.s[this.i] === "~") {
+        back = true;
+        this.i++;
+      }
+      const key = this.s[this.i] === "'" || this.s[this.i] === '"' ? this.quoted().value : unquoteKey(this.readPlain(":,}"));
+      this.ws();
+      if (this.s[this.i] !== ":") this.fail('expected ":" in flow map');
+      this.i++;
+      this.ws();
+      const v = this.value();
+      entries.push({ key, edge: back ? "back" : isPointer(v) ? "ref" : "contain", value: v });
+      this.ws();
+      if (this.s[this.i] === ",") {
+        this.i++;
+        continue;
+      }
+      if (this.s[this.i] === "}") {
+        this.i++;
+        break;
+      }
+      this.fail('expected "," or "}"');
+    }
+    return { kind: "mapping", entries, array: false };
+  }
+  seq() {
+    this.i++;
+    const entries = [];
+    for (; ; ) {
+      this.ws();
+      if (this.s[this.i] === "]") {
+        this.i++;
+        break;
+      }
+      if (this.i >= this.s.length) this.fail("unterminated flow seq");
+      const v = this.value();
+      entries.push({ key: null, edge: isPointer(v) ? "ref" : "contain", value: v });
+      this.ws();
+      if (this.s[this.i] === ",") {
+        this.i++;
+        continue;
+      }
+      if (this.s[this.i] === "]") {
+        this.i++;
+        break;
+      }
+      this.fail('expected "," or "]"');
+    }
+    return { kind: "mapping", entries, array: true };
+  }
+  quoted() {
+    const start = this.i;
+    const q = this.s[this.i];
+    this.i++;
+    while (this.i < this.s.length) {
+      const c = this.s[this.i];
+      if (q === '"' && c === "\\") {
+        this.i += 2;
+        continue;
+      }
+      if (q === "'" && c === "'" && this.s[this.i + 1] === "'") {
+        this.i += 2;
+        continue;
+      }
+      this.i++;
+      if (c === q) break;
+    }
+    return quotedScalar(this.s.slice(start, this.i));
+  }
+  /** Read a plain scalar up to a stop char (default flow stops). */
+  readPlain(stop = ",:[]{} ") {
+    const start = this.i;
+    while (this.i < this.s.length && !stop.includes(this.s[this.i])) this.i++;
+    return this.s.slice(start, this.i).trim();
+  }
+};
+function isSeqLine(text) {
+  return text === "-" || text.startsWith("- ");
+}
+function isBackSeqLine(text) {
+  return text === "~-" || text.startsWith("~- ");
+}
+function splitKV(text) {
+  let inS = false;
+  let inD = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === "'" && !inD) inS = !inS;
+    else if (c === '"' && !inS) inD = !inD;
+    else if (c === ":" && !inS && !inD) {
+      const next = text[i + 1];
+      if (next === void 0 || next === " " || next === "	") {
+        const after = text.slice(i + 1);
+        const lead = after.length - after.trimStart().length;
+        return { key: text.slice(0, i).trim(), rest: after.trim(), restCol: i + 1 + lead };
+      }
+    }
+  }
+  return null;
+}
+function adv(s, k, col) {
+  const sliced = s.slice(k);
+  const lead = sliced.length - sliced.trimStart().length;
+  return { rest: sliced.trim(), col: col + k + lead };
+}
+function parseSchemaRef(src, at) {
+  const lead = src.length - src.trimStart().length;
+  src = src.trim();
+  if (src.startsWith("*")) {
+    const p = parsePointer(src.slice(1));
+    if (at !== void 0) p.span = at.block.spanAt(at.lineN, at.col + lead, src.length);
+    return p;
+  }
+  return parseYamlover(src).root;
+}
+function foldLines(lines) {
+  let out = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) out += lines[i] === "" || lines[i - 1] === "" ? "\n" : " ";
+    out += lines[i];
+  }
+  return out;
+}
+function unquoteIfQuoted(s) {
+  s = s.trim();
+  if ((s[0] === "'" || s[0] === '"') && s[s.length - 1] === s[0]) return quotedScalar(s).value;
+  return s;
+}
+function hasSeparatorColon(s) {
+  let q = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q !== null) {
+      if (c === q) q = null;
+      continue;
+    }
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      continue;
+    }
+    if (c === ":") return true;
+  }
+  return false;
+}
+function unquoteKey(key) {
+  key = key.trim();
+  if ((key[0] === "'" || key[0] === '"') && key[key.length - 1] === key[0]) return quotedScalar(key).value;
+  return backslashUnescape(key);
+}
+function quotedScalar(text) {
+  const q = text[0];
+  const body = text.slice(1, text.length - 1);
+  if (q === "'") return { kind: "scalar", value: body.replace(/''/g, "'"), raw: text };
+  let out = "";
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] === "\\") {
+      const c = body[++i];
+      switch (c) {
+        case "n":
+          out += "\n";
+          break;
+        case "t":
+          out += "	";
+          break;
+        case "r":
+          out += "\r";
+          break;
+        case '"':
+          out += '"';
+          break;
+        case "\\":
+          out += "\\";
+          break;
+        case "/":
+          out += "/";
+          break;
+        case "b":
+          out += "\b";
+          break;
+        case "f":
+          out += "\f";
+          break;
+        case "0":
+          out += "\0";
+          break;
+        case "u":
+          out += String.fromCharCode(parseInt(body.slice(i + 1, i + 5), 16));
+          i += 4;
+          break;
+        case "x":
+          out += String.fromCharCode(parseInt(body.slice(i + 1, i + 3), 16));
+          i += 2;
+          break;
+        default:
+          out += c ?? "";
+      }
+    } else out += body[i];
+  }
+  return { kind: "scalar", value: out, raw: text };
+}
+function plainScalar(text) {
+  const t2 = text.trim();
+  if (t2 === "" || t2 === "~" || t2 === "null" || t2 === "Null" || t2 === "NULL") return { kind: "scalar", value: null, raw: text };
+  if (t2 === "true" || t2 === "True" || t2 === "TRUE") return { kind: "scalar", value: true, raw: text };
+  if (t2 === "false" || t2 === "False" || t2 === "FALSE") return { kind: "scalar", value: false, raw: text };
+  if (/^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(t2)) return { kind: "scalar", value: Number(t2), raw: text };
+  if (/^[-+]?0x[0-9a-fA-F]+$/.test(t2)) return { kind: "scalar", value: Number(t2), raw: text };
+  return { kind: "scalar", value: t2, raw: text };
+}
+function backslashUnescape(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\" && i + 1 < s.length) {
+      out += s[i + 1];
+      i++;
+      continue;
+    }
+    out += s[i];
+  }
+  return out;
+}
+function nul() {
+  return { kind: "scalar", value: null, raw: "" };
+}
+
+// ../parser/ts/src/json5p.ts
+var WS = /* @__PURE__ */ new Set([" ", "	", "\n", "\r", "\v", "\f", "\xA0", "\uFEFF"]);
+function parseJson5p(src, uri = "<json5p>") {
+  const p = new Parser(src, uri);
+  p.ws();
+  const root = p.value();
+  p.ws();
+  if (p.i < src.length) p.fail("trailing characters");
+  if (isPointer(root)) return p.fail("a top-level pointer is not allowed");
+  return { root, source: { concrete: "json5p", uri } };
+}
+var Parser = class {
+  src;
+  uri;
+  i = 0;
+  constructor(src, uri) {
+    this.src = src;
+    this.uri = uri;
+  }
+  fail(msg) {
+    throw new SyntaxError(`json5p: ${msg} at offset ${this.i}`);
+  }
+  peek() {
+    return this.src[this.i];
+  }
+  eof() {
+    return this.i >= this.src.length;
+  }
+  ws() {
+    for (; ; ) {
+      const c = this.src[this.i];
+      if (c === void 0) return;
+      if (WS.has(c)) {
+        this.i++;
+        continue;
+      }
+      if (c === "/" && this.src[this.i + 1] === "/") {
+        this.i += 2;
+        while (this.i < this.src.length && this.src[this.i] !== "\n" && this.src[this.i] !== "\r") this.i++;
+        continue;
+      }
+      if (c === "/" && this.src[this.i + 1] === "*") {
+        this.i += 2;
+        while (this.i < this.src.length && !(this.src[this.i] === "*" && this.src[this.i + 1] === "/")) this.i++;
+        if (this.i >= this.src.length) this.fail("unterminated block comment");
+        this.i += 2;
+        continue;
+      }
+      return;
+    }
+  }
+  value() {
+    const c = this.peek();
+    if (c === void 0) this.fail("unexpected end of input");
+    if (c === "{") return this.object();
+    if (c === "[") return this.array();
+    if (c === "*") return this.pointer();
+    if (c === "&") return this.anchored();
+    if (c === '"' || c === "'") return this.string();
+    return this.numberOrKeyword();
+  }
+  object() {
+    this.i++;
+    const entries = [];
+    for (; ; ) {
+      this.ws();
+      const c = this.peek();
+      if (c === "}") {
+        this.i++;
+        break;
+      }
+      if (c === void 0) this.fail("unterminated object");
+      let back = false;
+      if (this.peek() === "~") {
+        back = true;
+        this.i++;
+      }
+      if (back && this.peek() === "*") {
+        entries.push({ key: null, edge: "back", value: this.pointer() });
+      } else {
+        const key = this.key();
+        this.ws();
+        if (this.peek() !== ":") this.fail('expected ":" after key');
+        this.i++;
+        this.ws();
+        const v = this.value();
+        entries.push(makeEntry(key, back, v));
+      }
+      this.ws();
+      const n = this.peek();
+      if (n === ",") {
+        this.i++;
+        continue;
+      }
+      if (n === "}") {
+        this.i++;
+        break;
+      }
+      this.fail('expected "," or "}"');
+    }
+    return { kind: "mapping", entries, array: false };
+  }
+  array() {
+    this.i++;
+    const entries = [];
+    for (; ; ) {
+      this.ws();
+      const c = this.peek();
+      if (c === "]") {
+        this.i++;
+        break;
+      }
+      if (c === void 0) this.fail("unterminated array");
+      if (c === "~") {
+        this.i++;
+        if (this.peek() !== "*") this.fail('expected a pointer after "~" (keyless back member)');
+        entries.push({ key: null, edge: "back", value: this.pointer() });
+      } else {
+        entries.push(makeEntry(null, false, this.value()));
+      }
+      this.ws();
+      const n = this.peek();
+      if (n === ",") {
+        this.i++;
+        continue;
+      }
+      if (n === "]") {
+        this.i++;
+        break;
+      }
+      this.fail('expected "," or "]"');
+    }
+    return { kind: "mapping", entries, array: true };
+  }
+  key() {
+    const c = this.peek();
+    if (c === '"' || c === "'") return this.string().value;
+    return this.identifier();
+  }
+  identifier() {
+    const start = this.i;
+    const c = this.peek();
+    if (c === void 0 || !isIdStart(c)) this.fail("expected an identifier key");
+    this.i++;
+    while (!this.eof() && isIdPart(this.src[this.i])) this.i++;
+    return this.src.slice(start, this.i);
+  }
+  pointer() {
+    const start = this.i;
+    this.i++;
+    const c = this.peek();
+    if (c !== '"' && c !== "'") this.fail('a json5p pointer must be a quoted string after "*"');
+    const s = this.string();
+    const p = parsePointer(s.value);
+    p.span = { uri: this.uri, start, end: this.i };
+    return p;
+  }
+  anchored() {
+    const start = this.i;
+    this.i++;
+    const c = this.peek();
+    const body = c === '"' || c === "'" ? this.string().value : this.identifier();
+    const anchor = makeAnchor(body, (m) => this.fail(m));
+    anchor.path.span = { uri: this.uri, start, end: this.i };
+    this.ws();
+    const v = this.value();
+    if (isPointer(v)) this.fail("cannot anchor a pointer");
+    v.meta = { ...v.meta, anchors: [anchor, ...v.meta?.anchors ?? []] };
+    return v;
+  }
+  string() {
+    const quote = this.src[this.i];
+    const start = this.i;
+    this.i++;
+    let out = "";
+    for (; ; ) {
+      if (this.eof()) this.fail("unterminated string");
+      const c = this.src[this.i];
+      if (c === quote) {
+        this.i++;
+        break;
+      }
+      if (c === "\\") {
+        out += this.escape();
+        continue;
+      }
+      out += c;
+      this.i++;
+    }
+    return { kind: "scalar", value: out, raw: this.src.slice(start, this.i) };
+  }
+  escape() {
+    this.i++;
+    const c = this.src[this.i];
+    if (c === void 0) this.fail("bad escape sequence");
+    this.i++;
+    switch (c) {
+      case '"':
+        return '"';
+      case "'":
+        return "'";
+      case "\\":
+        return "\\";
+      case "/":
+        return "/";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "v":
+        return "\v";
+      case "0":
+        return "\0";
+      case "x": {
+        const h = this.src.slice(this.i, this.i + 2);
+        this.i += 2;
+        return String.fromCharCode(parseInt(h, 16));
+      }
+      case "u": {
+        const h = this.src.slice(this.i, this.i + 4);
+        this.i += 4;
+        return String.fromCharCode(parseInt(h, 16));
+      }
+      case "\n":
+        return "";
+      case "\r":
+        if (this.src[this.i] === "\n") this.i++;
+        return "";
+      default:
+        return c;
+    }
+  }
+  numberOrKeyword() {
+    const start = this.i;
+    while (!this.eof() && !isDelim(this.src[this.i])) this.i++;
+    const tok = this.src.slice(start, this.i);
+    if (tok === "") this.fail(`unexpected character ${JSON.stringify(this.src[this.i])}`);
+    if (tok === "true") return scalar(true, tok);
+    if (tok === "false") return scalar(false, tok);
+    if (tok === "null") return scalar(null, tok);
+    const n = json5number(tok);
+    if (n === void 0) this.fail(`invalid token "${tok}"`);
+    return scalar(n, tok);
+  }
+};
+function makeEntry(key, back, v) {
+  const edge = back ? "back" : isPointer(v) ? "ref" : "contain";
+  return { key, edge, value: v };
+}
+function scalar(value, raw) {
+  return { kind: "scalar", value, raw };
+}
+function isIdStart(c) {
+  return /[A-Za-z_$]/.test(c) || c.charCodeAt(0) > 127;
+}
+function isIdPart(c) {
+  return /[A-Za-z0-9_$]/.test(c) || c.charCodeAt(0) > 127;
+}
+function isDelim(c) {
+  return WS.has(c) || c === "," || c === ":" || c === "{" || c === "}" || c === "[" || c === "]" || c === '"' || c === "'" || c === "/";
+}
+function json5number(tok) {
+  if (/^[+-]?0[xX][0-9a-fA-F]+$/.test(tok)) return Number(tok);
+  if (/^[+-]?Infinity$/.test(tok)) return tok[0] === "-" ? -Infinity : Infinity;
+  if (/^[+-]?NaN$/.test(tok)) return NaN;
+  if (/^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(tok)) return Number(tok);
+  return void 0;
+}
+
+// ../engine/ts/src/walk.ts
+var { h64Raw, create64 } = await e();
+var hashBytes = (bytes) => "xxh64:" + h64Raw(bytes).toString(16).padStart(16, "0");
+var YAMLOVER_DIR = ".yamlover";
+var MAX_TEXT_BYTES = 1 << 20;
+var MAX_DOC_BYTES = 64 << 20;
+var HASH_INLINE_MAX = 1 << 20;
+var HASH_CHUNK = 8 << 20;
+function walkTree(absDir, opts = {}) {
+  const g = walkTreeGen(absDir, opts);
+  let r = g.next();
+  while (!r.done) r = g.next();
+  return r.value;
+}
+async function walkTreeAsync(absDir, opts = {}) {
+  const g = walkTreeGen(absDir, opts);
+  const every = Math.max(1, opts.yieldEvery ?? 50);
+  let r = g.next();
+  while (!r.done) {
+    opts.onProgress?.({ done: r.value.done, message: r.value.path });
+    if (r.value.done % every === 0) await yieldLoop();
+    r = g.next();
+  }
+  return r.value;
+}
+function* walkTreeGen(absDir, opts = {}) {
+  const ctx = { root: path.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 arrayRoot = root.array || (root.entries?.length ? root.entries.every((e2) => e2.key === null) : false);
+  if (!arrayRoot && fs.existsSync(defsDir) && root.entries && !root.entries.some((e2) => e2.key === "yamlover")) {
+    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 } });
+  }
+  applySchemas(root, defsRoot);
+  return {
+    doc: { root, source: { concrete: "directory", uri: absDir } },
+    files: [...ctx.files.values()]
+  };
+}
+function reindex(store, absDir, opts = {}) {
+  const prev = store.stale ? /* @__PURE__ */ new Map() : store.manifest();
+  const { doc, files } = walkTree(absDir, { ...opts, cache: opts.cache ?? manifestCache(prev) });
+  store.indexDocument(doc, files);
+  return diffManifest(prev, files);
+}
+async function reindexAsync(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 { doc, files } = await walkTreeAsync(absDir, {
+    ...opts,
+    cache: opts.cache ?? manifestCache(prev),
+    onProgress: onProgress && ((p) => onProgress({ ...p, total }))
+  });
+  onProgress?.({ done: total ?? files.length, total, message: "writing index\u2026" });
+  await yieldLoop();
+  store.indexDocument(doc, files);
+  return diffManifest(prev, files);
+}
+function manifestCache(prev) {
+  return (rel, size, mtimeMs) => {
+    const r = prev.get(rel);
+    return r && r.size === size && r.mtimeMs === mtimeMs ? r.hash : null;
+  };
+}
+async function countChildren(absRoot, opts) {
+  let n = 0;
+  const visit = async (dir) => {
+    let entries;
+    try {
+      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e2 of entries) {
+      if (e2.name === YAMLOVER_DIR || e2.name.startsWith(".")) continue;
+      const abs = path.join(dir, e2.name);
+      if (opts.ignore?.(abs)) continue;
+      n++;
+      const isDir = e2.isDirectory() || e2.isSymbolicLink() && (await fs.promises.stat(abs).catch(() => null))?.isDirectory();
+      if (isDir) await visit(abs);
+    }
+  };
+  await visit(absRoot);
+  return n;
+}
+function diffManifest(prev, files) {
+  let added = [], removed = [];
+  const changed = [];
+  const current = new Map(files.map((f) => [f.path, f]));
+  for (const f of files) {
+    const old = prev.get(f.path);
+    if (!old) added.push(f.path);
+    else if (old.size !== f.size || old.mtimeMs !== f.mtimeMs) changed.push(f.path);
+  }
+  for (const p of prev.keys()) if (!current.has(p)) removed.push(p);
+  const moved = [];
+  if (removed.length > 0 && added.length > 0) {
+    const matched = /* @__PURE__ */ new Set();
+    const tiers = [(f) => f.hash, (f) => `${f.size}:${f.mtimeMs}`];
+    for (const key of tiers) {
+      const outs = groupBy(removed.filter((p) => !matched.has(p)).map((p) => prev.get(p)), key);
+      const ins = groupBy(added.filter((p) => !matched.has(p)).map((p) => current.get(p)), key);
+      for (const [k, o] of outs) {
+        const i = ins.get(k);
+        if (o.length !== 1 || i?.length !== 1) continue;
+        const [from, to] = [o[0], i[0]];
+        if (from.hash && to.hash && from.hash !== to.hash) continue;
+        moved.push({ from: from.path, to: to.path });
+        matched.add(from.path);
+        matched.add(to.path);
+      }
+    }
+    if (matched.size > 0) {
+      added = added.filter((p) => !matched.has(p));
+      removed = removed.filter((p) => !matched.has(p));
+    }
+  }
+  return { added, changed, removed, moved };
+}
+function groupBy(list, key) {
+  const m = /* @__PURE__ */ new Map();
+  for (const f of list) {
+    const k = key(f);
+    if (k != null) m.set(k, [...m.get(k) ?? [], f]);
+  }
+  return m;
+}
+async function hashFileAsync(abs, onChunk) {
+  const fh = await fs.promises.open(abs, "r");
+  try {
+    const hasher = create64();
+    const buf = Buffer.alloc(HASH_CHUNK);
+    let done = 0;
+    for (; ; ) {
+      const { bytesRead } = await fh.read(buf, 0, buf.length);
+      if (bytesRead === 0) break;
+      hasher.update(bytesRead === buf.length ? buf : buf.subarray(0, bytesRead));
+      done += bytesRead;
+      onChunk?.(done);
+    }
+    return "xxh64:" + hasher.digest().toString(16).padStart(16, "0");
+  } finally {
+    await fh.close();
+  }
+}
+function record(ctx, abs, hash, size, mtimeMs) {
+  const rel = path.relative(ctx.root, abs).split(path.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);
+  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 {};
+  try {
+    const plain = toPlain(parseYamlover(readTracked(ctx, file).toString("utf8"), file).root);
+    const props = plain?.properties ?? {};
+    return props && typeof props === "object" ? props : {};
+  } catch {
+    return {};
+  }
+}
+function* dirNode(dir, ctx) {
+  const meta = loadMeta(dir, ctx);
+  const names = fs.readdirSync(dir).filter((n) => n !== YAMLOVER_DIR && !n.startsWith(".")).filter((n) => !ctx.opts.ignore?.(path.join(dir, n))).sort();
+  const entries = [];
+  for (const name of names) {
+    const abs = path.join(dir, name);
+    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("/") };
+  }
+  const node = { kind: "mapping", entries, array: false };
+  return applyMeta(applyBody(dir, node, ctx), meta);
+}
+function* childNode(abs, m, ctx) {
+  const stat = fs.statSync(abs);
+  if (stat.isDirectory()) return yield* dirNode(abs, ctx);
+  const ext = path.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))) {
+    if (stat.size > MAX_DOC_BYTES) return blob(abs, fmt, ctx);
+    if (DOC_FORMATS[fmt]) return parsedDoc(abs, DOC_FORMATS[fmt], ctx);
+    return textScalar(abs, fmt, ctx);
+  }
+  if (fmt) return blob(abs, fmt, ctx);
+  if (looksBinary(abs)) return blob(abs, "application/octet-stream", ctx);
+  return parsedScalar(abs, ext, ctx);
+}
+function applyMeta(node, meta) {
+  for (const e2 of node.entries ?? []) {
+    if (e2.key == null || isPointer(e2.value)) continue;
+    const m = meta[e2.key];
+    if (!m) continue;
+    if (m.uniqueItems) e2.value = { ...e2.value, meta: { ...e2.value.meta, set: true } };
+    if (e2.value.kind === "blob") continue;
+    if (m.format && !e2.value.meta?.schema) e2.value = { ...e2.value, meta: { ...e2.value.meta, schema: inlineFormat(m.format) } };
+  }
+  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 inlineMax = ctx.opts.hashInlineMax ?? HASH_INLINE_MAX;
+  const contentHash = stat.size <= inlineMax ? hashBytes(fs.readFileSync(abs)) : null;
+  record(ctx, abs, contentHash, stat.size, stat.mtimeMs);
+  return { kind: "blob", format, contentHash, size: stat.size };
+}
+function textScalar(abs, format, ctx) {
+  const text = readTracked(ctx, abs).toString("utf8");
+  return { kind: "scalar", value: text, raw: text, meta: { schema: inlineFormat(format) } };
+}
+function parsedScalar(abs, ext, ctx) {
+  return parsedDoc(abs, ext === ".json" || ext === ".json5" || ext === ".json5p" ? "json5p" : "yamlover", ctx);
+}
+function parsedDoc(abs, lang, ctx) {
+  const text = readTracked(ctx, abs).toString("utf8");
+  try {
+    const doc = lang === "json5p" ? parseJson5p(text, abs) : parseYamlover(text, abs);
+    const root = doc.root;
+    root.meta = { ...root.meta, documentRoot: true };
+    return root;
+  } catch {
+    return { kind: "scalar", value: text, raw: text };
+  }
+}
+function findDefsRoot(dir) {
+  let d = path.resolve(dir);
+  for (; ; ) {
+    if (fs.existsSync(path.join(d, "$defs"))) return d;
+    const up = path.dirname(d);
+    if (up === d) return path.resolve(dir);
+    d = up;
+  }
+}
+function applySchemas(root, defsRoot) {
+  const cache = /* @__PURE__ */ new Map();
+  const loadDef = (name) => {
+    if (!cache.has(name)) {
+      const defFile = path.join(defsRoot, "$defs", name);
+      try {
+        cache.set(name, parseYamlover(fs.readFileSync(defFile, "utf8"), defFile).root);
+      } catch {
+        cache.set(name, null);
+      }
+    }
+    return cache.get(name);
+  };
+  const field = (n, key) => n.entries?.find((e2) => e2.key === key)?.value ?? null;
+  const str = (n, key) => {
+    const v = field(n, key);
+    return v && !isPointer(v) && v.kind === "scalar" && v.value != null ? String(v.value) : null;
+  };
+  const hasFormat = (inst) => {
+    if (inst.kind === "blob") return true;
+    const s = inst.meta?.schema;
+    return !!s && !isPointer(s) && s.kind === "mapping" && !!field(s, "format");
+  };
+  const apply = (inst, schema, depth) => {
+    if (depth > 64 || isPointer(inst)) return;
+    let name = null;
+    let s;
+    if (isPointer(schema)) {
+      const last = schema.steps[schema.steps.length - 1];
+      name = last?.sel === "key" ? last.name : null;
+      s = name ? loadDef(name) : null;
+    } else s = schema;
+    if (!s || isPointer(s)) return;
+    const fmt = str(s, "format") ?? (name && str(s, "type") === "object" ? `x-yamlover-${name}` : null);
+    if (fmt && !hasFormat(inst)) inst.meta = { ...inst.meta, schema: inlineFormat(fmt) };
+    const stype = str(s, "type");
+    if (stype === "object" || stype === "variant" || stype === "mixed") {
+      const props = field(s, "properties");
+      const addl = field(s, "additionalProperties");
+      for (const e2 of inst.entries ?? []) {
+        if (e2.key == null || isPointer(e2.value)) continue;
+        const declared = props && !isPointer(props) ? field(props, e2.key) : null;
+        const sub = declared ?? addl;
+        if (sub) apply(e2.value, sub, depth + 1);
+      }
+    } else if (stype === "array") {
+      const items = field(s, "items");
+      if (items) {
+        for (const e2 of inst.entries ?? []) if (!isPointer(e2.value)) apply(e2.value, items, depth + 1);
+      }
+    }
+  };
+  const walk = (node) => {
+    if (node.meta?.schema) apply(node, node.meta.schema, 0);
+    for (const e2 of node.entries ?? []) if (!isPointer(e2.value)) walk(e2.value);
+  };
+  walk(root);
+}
+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 bodyDoc = parseYamlover(readTracked(ctx, file).toString("utf8"), file);
+  const body = bodyDoc.root;
+  if (body.kind !== "mapping" && body.kind !== "scalar" || !body.entries) return node;
+  const meta = { ...node.meta, ...body.meta, documentRoot: true };
+  if (body.kind === "mapping" && (body.array || body.entries.length > 0 && body.entries.every((e2) => e2.key === null))) {
+    const byKey = new Map(node.entries.map((e2) => [e2.key, e2]));
+    const ordered = [];
+    for (const e2 of body.entries) {
+      const targetKey = isPointer(e2.value) ? pointerLeafKey(e2.value) : null;
+      const hit = targetKey != null ? byKey.get(targetKey) : null;
+      if (hit) {
+        ordered.push(hit);
+        byKey.delete(targetKey);
+      } else ordered.push(e2);
+    }
+    for (const e2 of node.entries) if (e2.key != null && byKey.has(e2.key)) ordered.push(e2);
+    return { kind: "mapping", entries: ordered, array: true, meta };
+  }
+  const merged = new Map(node.entries.map((e2) => [e2.key, e2]));
+  const order = node.entries.map((e2) => e2.key);
+  for (const e2 of body.entries) {
+    const existing = merged.get(e2.key);
+    if (!existing) {
+      order.push(e2.key);
+      merged.set(e2.key, e2);
+    } else merged.set(e2.key, augmentEntry(existing, e2));
+  }
+  const entries = order.map((k) => merged.get(k));
+  if (body.kind === "scalar") return { kind: "scalar", value: body.value, raw: body.raw, entries, array: false, meta };
+  return { kind: "mapping", entries, array: false, meta };
+}
+function augmentEntry(base, overlay) {
+  if (isPointer(base.value) || isPointer(overlay.value)) return overlay;
+  const b = base.value, o = overlay.value;
+  const value = {
+    ...b,
+    entries: o.entries ?? b.entries,
+    array: o.entries ? o.array : b.array,
+    meta: b.meta || o.meta ? { ...b.meta, ...o.meta } : void 0
+  };
+  return { key: base.key, edge: "contain", value };
+}
+function pointerLeafKey(v) {
+  if (!isPointer(v)) return null;
+  const last = v.steps[v.steps.length - 1];
+  if (last?.sel === "key") return last.name;
+  if (v.steps.length === 0 && v.base.scope === "current") return v.raw;
+  return null;
+}
+function looksBinary(abs) {
+  try {
+    if (fs.statSync(abs).size > MAX_TEXT_BYTES) return true;
+    const fd = fs.openSync(abs, "r");
+    try {
+      const buf = Buffer.alloc(4096);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      return buf.subarray(0, n).includes(0);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return true;
+  }
+}
+var EXT_FORMAT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".djvu": "image/vnd.djvu",
+  ".djv": "image/vnd.djvu",
+  ".psd": "image/vnd.adobe.photoshop",
+  ".psb": "image/vnd.adobe.photoshop",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".heic": "image/heic",
+  ".heif": "image/heic",
+  ".fb2": "application/x-fictionbook+xml",
+  ".epub": "application/epub+zip",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".md": "text/markdown",
+  ".markdown": "text/markdown",
+  ".adoc": "text/asciidoc",
+  ".asciidoc": "text/asciidoc",
+  ".asc": "text/asciidoc",
+  ".csv": "text/csv",
+  ".tsv": "text/tab-separated-values",
+  ".rtf": "application/rtf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".kml": "application/vnd.google-earth.kml+xml",
+  ".kmz": "application/vnd.google-earth.kmz",
+  ".puml": "text/x-plantuml",
+  ".plantuml": "text/x-plantuml",
+  ".iuml": "text/x-plantuml",
+  ".pu": "text/x-plantuml",
+  // Plain text kept as RAW BYTES (text/plain is deliberately NOT in TEXT_FORMATS), so the
+  // client decodes it under a chosen encoding (CP866/Win-1251/KOI8-R/UTF-8) — legacy
+  // Cyrillic .txt files are common — rather than the server fixing UTF-8.
+  ".txt": "text/plain",
+  ".text": "text/plain",
+  ".log": "text/plain",
+  ".ini": "text/plain"
+};
+var TEXT_FORMATS = /* @__PURE__ */ new Set(["text/markdown", "text/asciidoc", "text/x-plantuml", "text/csv", "text/tab-separated-values"]);
+var DOC_FORMATS = {
+  "yamlover": "yamlover",
+  "yaml": "yamlover",
+  "yamlover/meta": "yamlover",
+  "yaml/meta": "yamlover",
+  "json": "json5p",
+  "json5": "json5p",
+  "json5p": "json5p",
+  "json/meta": "json5p",
+  "json5p/meta": "json5p",
+  "json/schema": "json5p"
+};
+
+// ../engine/ts/src/rewrite.ts
+import * as path2 from "node:path";
+
+// ../parser/ts/src/serialize-yamlover.ts
+function pointerToken(raw) {
+  if (raw !== raw.trim()) return `*'${raw.replace(/'/g, "''")}'`;
+  return "*" + raw;
+}
+function anchorToken(body) {
+  if (/^['"]/.test(body) || hasUnquotedSpace(body)) return `&'${body.replace(/'/g, "''")}'`;
+  return "&" + body;
+}
+function hasUnquotedSpace(s) {
+  let q = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q !== null) {
+      if (c === q) q = null;
+      continue;
+    }
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      continue;
+    }
+    if (c === " " || c === "	") return true;
+  }
+  return false;
+}
+
+// ../engine/ts/src/rewrite.ts
+function under(p, x) {
+  if (x === ":") return true;
+  return p === x || p.startsWith(x + ":") || p.startsWith(x + "[");
+}
+function planRewrites(doc, edges, oldStore, newStore, opts = {}) {
+  const mapPath = (p) => under(p, oldStore) ? newStore + p.slice(oldStore.length) : p;
+  const plan = { edits: /* @__PURE__ */ new Map(), rewritten: [], unrewritten: [] };
+  for (const e2 of edges) {
+    if (e2.target.kind !== "node" || !under(e2.target.path, oldStore)) continue;
+    const miss = (reason) => {
+      plan.unrewritten.push({ file: e2.ptr.span?.uri ?? "<unknown>", from: e2.from, raw: e2.raw, reason });
+    };
+    if (e2.anchor) {
+      const span2 = e2.ptr.span;
+      if (!span2) {
+        miss("anchor has no source span");
+        continue;
+      }
+      if (opts.root !== void 0 && path2.relative(opts.root, span2.uri).startsWith("..")) {
+        miss("source file is outside the served root (grafted)");
+        continue;
+      }
+      const holder2 = mapPath(e2.holder);
+      const docRoot2 = mapPath(e2.docRoot);
+      const container = mapPath(e2.target.path);
+      let cRaw = null;
+      switch (e2.ptr.base.scope) {
+        case "link":
+          cRaw = "//" + renderSuffix("/", container).replace(/^\//, "");
+          break;
+        case "document":
+          cRaw = under(container, docRoot2) ? docForm(docRoot2, container) : null;
+          break;
+        case "current": {
+          const p = parentOf(holder2);
+          if (p !== null && under(container, p)) cRaw = renderSuffix(p, container).replace(/^\//, "");
+          else if (under(container, docRoot2)) cRaw = docForm(docRoot2, container);
+          break;
+        }
+        case "parent": {
+          const p1 = parentOf(holder2);
+          const p2 = p1 === null ? null : parentOf(p1);
+          if (p2 !== null && under(container, p2)) cRaw = ".." + suffixAfter(p2, container);
+          else if (under(container, docRoot2)) cRaw = docForm(docRoot2, container);
+          break;
+        }
+      }
+      if (cRaw === null) {
+        miss("anchor container left the holder's document");
+        continue;
+      }
+      let newBody = e2.label != null ? (cRaw === "" ? "" : cRaw === "/" ? "/" : cRaw + "/") + escapeSegment(e2.label) : cRaw + "[]";
+      const tail = newBody.endsWith("[]") ? "[]" : "";
+      newBody = matchStyle(newBody.slice(0, newBody.length - tail.length), e2.raw) + tail;
+      if (newBody === e2.raw.slice(1)) continue;
+      const tok = isJson5pUri(span2.uri) ? json5pAnchorToken(newBody) : anchorToken(newBody);
+      const list2 = plan.edits.get(span2.uri) ?? [];
+      list2.push({ start: span2.start, end: span2.end, text: tok });
+      plan.edits.set(span2.uri, list2);
+      plan.rewritten.push({ file: span2.uri, from: e2.from, oldRaw: e2.raw, newRaw: "&" + newBody });
+      continue;
+    }
+    if (under(e2.holder, oldStore) && (e2.ptr.base.scope === "current" || e2.ptr.base.scope === "document" && under(e2.docRoot, oldStore))) {
+      continue;
+    }
+    const span = e2.ptr.span;
+    if (!span) {
+      miss("pointer has no source span");
+      continue;
+    }
+    if (opts.root !== void 0 && path2.relative(opts.root, span.uri).startsWith("..")) {
+      miss("source file is outside the served root (grafted)");
+      continue;
+    }
+    const holder = mapPath(e2.holder);
+    const docRoot = mapPath(e2.docRoot);
+    const target = mapPath(e2.target.path);
+    let newRaw = null;
+    switch (e2.ptr.base.scope) {
+      case "link":
+        newRaw = "//" + renderSuffix("/", target).replace(/^\//, "");
+        break;
+      case "document":
+        newRaw = under(target, docRoot) ? docForm(docRoot, target) : null;
+        break;
+      case "current":
+        if (under(target, holder) && target !== holder) newRaw = relForm(holder, target);
+        else if (under(target, docRoot)) newRaw = docForm(docRoot, target);
+        break;
+      case "parent": {
+        const p = parentOf(holder);
+        if (p !== null && under(target, p)) newRaw = ".." + suffixAfter(p, target);
+        else if (under(target, docRoot)) newRaw = docForm(docRoot, target);
+        break;
+      }
+    }
+    if (newRaw === null) {
+      miss("target left the holder's document");
+      continue;
+    }
+    newRaw = matchStyle(newRaw, e2.raw);
+    if (newRaw === e2.raw) continue;
+    const token = isJson5pUri(span.uri) ? json5pToken(newRaw) : pointerToken(newRaw);
+    const list = plan.edits.get(span.uri) ?? [];
+    list.push({ start: span.start, end: span.end, text: token });
+    plan.edits.set(span.uri, list);
+    plan.rewritten.push({ file: span.uri, from: e2.from, oldRaw: e2.raw, newRaw });
+  }
+  return plan;
+}
+function applyEdits(text, edits) {
+  const sorted = [...edits].sort((a, b) => b.start - a.start);
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].end > sorted[i - 1].start) {
+      throw new Error(`overlapping edits at ${sorted[i].start}..${sorted[i].end} and ${sorted[i - 1].start}..`);
+    }
+  }
+  let out = text;
+  for (const e2 of sorted) out = out.slice(0, e2.start) + e2.text + out.slice(e2.end);
+  return out;
+}
+function nominalPath(doc, e2) {
+  if (e2.anchor) return null;
+  let base;
+  switch (e2.ptr.base.scope) {
+    case "link":
+      base = ":" + e2.ptr.base.authority;
+      break;
+    case "document":
+      base = e2.docRoot;
+      break;
+    case "current":
+      base = e2.holder;
+      break;
+    case "parent":
+      base = parentOf(e2.holder) ?? "/";
+      break;
+  }
+  let p = base === ":" ? "" : base;
+  for (const st of e2.ptr.steps) {
+    if (st.sel === "parent") {
+      const up = parentOf(p === "" ? ":" : p);
+      if (up === null) return null;
+      p = up === ":" ? "" : up;
+    } else if (st.sel === "key") p += ":" + st.name;
+    else p += "[" + st.n + "]";
+  }
+  return p === "" ? ":" : p;
+}
+function tokensOf(p) {
+  const out = [];
+  const re = /\[(\d+)\]|:([^:[]*)/g;
+  for (let m = re.exec(p); m !== null; m = re.exec(p)) {
+    if (m[1] !== void 0) out.push({ n: Number(m[1]) });
+    else if (m[2] !== "") out.push({ key: m[2] });
+  }
+  return out;
+}
+function parentOf(p) {
+  if (p === ":" || p === "") return null;
+  const toks = tokensOf(p).slice(0, -1);
+  if (toks.length === 0) return ":";
+  return renderPath(toks);
+}
+function renderPath(toks) {
+  let s = "";
+  for (const t2 of toks) s += t2.key !== void 0 ? ":" + t2.key : "[" + t2.n + "]";
+  return s === "" ? ":" : s;
+}
+function renderSuffix(base, p) {
+  const toks = tokensOf(p).slice(base === ":" ? 0 : tokensOf(base).length);
+  let s = "";
+  for (const t2 of toks) s += t2.key !== void 0 ? "/" + escapeSegment(t2.key) : "[" + t2.n + "]";
+  return s;
+}
+function docForm(docRoot, target) {
+  const s = renderSuffix(docRoot, target);
+  return s === "" ? "/" : s.startsWith("/") ? s : "/" + s;
+}
+function relForm(holder, target) {
+  return renderSuffix(holder, target).replace(/^\//, "");
+}
+function suffixAfter(base, target) {
+  return renderSuffix(base, target);
+}
+function isJson5pUri(uri) {
+  return /\.(json|json5|json5p)$/i.test(uri);
+}
+function json5pToken(raw) {
+  return `*'${raw.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function matchStyle(slashRaw, originalRaw) {
+  if (!originalRaw.includes(":")) return slashRaw;
+  try {
+    return renderPointer(parsePointer(slashRaw));
+  } catch {
+    return slashRaw;
+  }
+}
+function json5pAnchorToken(body) {
+  return `&'${body.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+
+// ../engine/ts/src/mv.ts
+import * as fs2 from "node:fs";
+import * as path3 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 relFrom = relInside(root, absFrom, "source");
+  const relTo = relInside(root, absTo, "target");
+  for (const rel of [relFrom, relTo]) {
+    for (const seg of rel.split("/")) {
+      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)) {
+    throw new Error(`mv: cannot move "${relFrom}" into itself`);
+  }
+  const { doc } = walkTree(root, opts);
+  const edges = resolveDocument(doc);
+  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("/"));
+  }
+  fs2.mkdirSync(path3.dirname(absTo), { recursive: true });
+  fs2.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 { doc } = walkTree(root, opts);
+  const edges = resolveDocument(doc);
+  const rewritten = [];
+  const unrewritten = [];
+  const merged = /* @__PURE__ */ new Map();
+  for (const m of moved) {
+    const oldStore = storeOf(m.from);
+    const stale = edges.filter((e2) => {
+      if (e2.target.kind === "node" && !under(e2.target.path, oldStore)) return false;
+      const nom = nominalPath(doc, e2);
+      return nom !== null && under(nom, oldStore);
+    });
+    const shimmed = stale.map((e2) => ({ ...e2, target: { kind: "node", node: doc.root, path: nominalPath(doc, e2) } }));
+    const plan = planRewrites(doc, shimmed, oldStore, storeOf(m.to), { root });
+    for (const [uri, edits] of plan.edits) merged.set(uri, [...merged.get(uri) ?? [], ...edits]);
+    rewritten.push(...plan.rewritten);
+    unrewritten.push(...plan.unrewritten);
+  }
+  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("/"));
+  }
+  return { rewritten, unrewritten, editedFiles };
+}
+function relInside(root, abs, what) {
+  const rel = path3.relative(root, abs);
+  if (rel === "" || rel.startsWith("..") || path3.isAbsolute(rel)) {
+    throw new Error(`mv: ${what} escapes the served root`);
+  }
+  return rel.split(path3.sep).join("/");
+}
+function storeOf(rel) {
+  return ":" + rel.split("/").join(":");
+}
+
+// ../engine/ts/src/watch.ts
+import fs3 from "node:fs";
+import path4 from "node:path";
+var OVERLAY_FILES = /* @__PURE__ */ new Set(["body.yamlover", "meta.yamlover", "settings.yamlover"]);
+function watchTree(absRoot, onBatch, opts = {}) {
+  const root = path4.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);
+    for (let i = 0; i < segs.length; i++) {
+      if (!segs[i].startsWith(".")) continue;
+      const isOverlay = segs[i] === ".yamlover" && i === segs.length - 2 && OVERLAY_FILES.has(segs[i + 1]);
+      if (!isOverlay) return false;
+    }
+    return !opts.ignore?.(path4.join(root, rel));
+  };
+  const fire = () => {
+    timer = null;
+    if (running || closed || pending.size === 0) return;
+    const batch = [...pending].map((p) => p.split(path4.sep).join("/"));
+    pending.clear();
+    running = true;
+    try {
+      onBatch(batch);
+    } finally {
+      running = false;
+      if (pending.size > 0) timer = setTimeout(fire, debounceMs);
+    }
+  };
+  const watcher = fs3.watch(root, { recursive: true }, (_event, filename) => {
+    if (closed || filename == null) return;
+    const rel = String(filename);
+    if (!relevant(rel)) return;
+    pending.add(rel);
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(fire, debounceMs);
+  });
+  return () => {
+    closed = true;
+    if (timer) clearTimeout(timer);
+    watcher.close();
+  };
+}
+
+// ../engine/ts/src/settings.ts
+import fs4 from "node:fs";
+import path5 from "node:path";
+var DEFAULT_SETTINGS = {
+  annotations: { location: ":annotations" },
+  tags: { location: ":tags" }
+};
+function loadSettings(absRoot) {
+  const file = path5.join(absRoot, ".yamlover", "settings.yamlover");
+  if (!fs4.existsSync(file)) return DEFAULT_SETTINGS;
+  let root;
+  try {
+    root = parseYamlover(fs4.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) }
+  };
+}
+function valueAt(node, ...keys) {
+  let v = node;
+  for (const key of keys) {
+    if (v === void 0 || isPointer(v)) return void 0;
+    v = v.entries?.find((e2) => e2.key === key)?.value;
+  }
+  return v;
+}
+function locationSetting(v, dflt) {
+  if (v === void 0) return dflt;
+  if (isPointer(v)) return pointerPath(v) ?? dflt;
+  if (v.kind === "scalar" && typeof v.value === "string") return stringPath(v.value, dflt);
+  return dflt;
+}
+function pointerPath(p) {
+  if (p.base.scope !== "current" && p.base.scope !== "document") return null;
+  if (p.steps.length === 0 || !p.steps.every((s) => s.sel === "key")) return null;
+  const segs = p.steps.map((s) => s.name);
+  if (segs.some((seg) => seg === ".." || seg === "")) return null;
+  return ":" + segs.join(":");
+}
+function stringPath(v, dflt) {
+  if (v.trim() === "") return dflt;
+  const segs = v.trim().split(/[/:]/).filter((seg) => seg !== "");
+  if (segs.length === 0 || segs.some((seg) => seg === "..")) return dflt;
+  return ":" + segs.join(":");
+}
+
+// ../engine/ts/src/query.ts
+function parseQuery(text) {
+  let rest = text.trim();
+  let base = { scope: "current" };
+  if (rest.startsWith(":::")) {
+    rest = rest.slice(3);
+    base = { scope: "link", authority: "" };
+  } else if (rest.startsWith("::")) {
+    rest = rest.slice(2);
+    base = { scope: "link", authority: "" };
+  } else if (rest.startsWith(":")) {
+    rest = rest.slice(1);
+    base = { scope: "document" };
+  }
+  const raws = splitPortions(rest);
+  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) };
+  } else if (base.scope === "current" && raws[0] === "..") {
+    base = { scope: "parent" };
+    raws.shift();
+  }
+  const portions = [];
+  for (const r of raws) portions.push(...parsePortion(r));
+  return { base, portions };
+}
+function splitPortions(s) {
+  const out = [];
+  let cur = "";
+  let q = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q !== null) {
+      cur += c;
+      if (c === q) q = null;
+      continue;
+    }
+    if (c === "\\" && i + 1 < s.length) {
+      cur += c + s[i + 1];
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      cur += c;
+      continue;
+    }
+    if (c === "!" && s.startsWith("!!<", i)) {
+      const close = s.indexOf(">", i);
+      if (close < 0) throw new SyntaxError(`query: unterminated "!!<\u2026>" in "${s}"`);
+      cur += s.slice(i, close + 1);
+      i = close;
+      continue;
+    }
+    if (c === ":") {
+      out.push(cur.trim());
+      cur = "";
+      continue;
+    }
+    cur += c;
+  }
+  out.push(cur.trim());
+  return out.filter((p) => p !== "");
+}
+var CMP = /^(>=|<=|!=|=|>|<)/;
+function parsePortion(r) {
+  if (r === "...") return [{ kind: "descend" }];
+  if (r === "..") return [{ kind: "spine" }];
+  if (r === "?..") return [{ kind: "up", sel: "any" }];
+  if (r === "[]..") return [{ kind: "up", sel: "keyless" }];
+  if (r.startsWith("!!<") && r.endsWith(">")) return [parseMeta(r.slice(3, -1))];
+  {
+    const sp = unquotedSpace(r);
+    if (sp > 0) {
+      const head = parseValTest(r.slice(0, sp));
+      if (head !== null) return [{ kind: "combo", test: head, then: parsePortion(r.slice(sp + 1).trim()) }];
+      throw new SyntaxError(`query: a key containing a space must be quoted ("${r}")`);
+    }
+  }
+  if (r.endsWith("..") && !r.endsWith("\\..") && r.length > 2) {
+    return [{ kind: "up", sel: keyName(r.slice(0, -2)) }];
+  }
+  if (r === "?") return [{ kind: "anykey" }];
+  if (r === "[?]") return [{ kind: "anypos" }];
+  if (r.endsWith("[?]") && !r.endsWith("\\[?]")) {
+    return [...parsePortion(r.slice(0, -3)), { kind: "anypos" }];
+  }
+  const test = parseValTest(r);
+  if (test !== null) return [test];
+  const steps = parsePointer(r).steps;
+  return steps.map((st) => st.sel === "key" ? { kind: "key", name: st.name } : st.sel === "index" ? { kind: "index", n: st.n } : { kind: "spine" });
+}
+function parseValTest(r) {
+  const m = CMP.exec(r);
+  if (m) {
+    const lit = literal(
+      r.slice(m[0].length).trim(),
+      /*bareWordsOk*/
+      true
+    );
+    return { kind: "valtest", op: m[0], value: lit };
+  }
+  const t2 = r.trim();
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(t2)) return { kind: "valtest", op: "=", value: Number(t2) };
+  if (t2 === "true") return { kind: "valtest", op: "=", value: true };
+  if (t2 === "false") return { kind: "valtest", op: "=", value: false };
+  if (t2 === "null") return { kind: "valtest", op: "=", value: null };
+  return null;
+}
+function literal(t2, bareWordsOk) {
+  if ((t2[0] === "'" || t2[0] === '"') && t2[t2.length - 1] === t2[0]) {
+    return t2.slice(1, -1).replace(t2[0] === "'" ? /''/g : /\\"/g, t2[0]);
+  }
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(t2)) return Number(t2);
+  if (t2 === "true") return true;
+  if (t2 === "false") return false;
+  if (t2 === "null") return null;
+  if (bareWordsOk) return t2;
+  throw new SyntaxError(`query: bad literal "${t2}"`);
+}
+function parseMeta(inner) {
+  const t2 = inner.trim();
+  if (t2.startsWith("*")) {
+    const p = parsePointer(t2.slice(1).trim());
+    const last = p.steps[p.steps.length - 1];
+    if (!last || last.sel !== "key") throw new SyntaxError(`query: bad schema matcher "!!<${inner}>"`);
+    return { kind: "meta", schema: last.name };
+  }
+  const root = parseYamlover(t2).root;
+  const out = { kind: "meta" };
+  for (const e2 of root.entries ?? []) {
+    if (isPointer(e2.value) || e2.value.kind !== "scalar") continue;
+    if (e2.key === "type") out.type = String(e2.value.value);
+    if (e2.key === "format") out.format = String(e2.value.value);
+  }
+  if (out.type === void 0 && out.format === void 0) {
+    throw new SyntaxError(`query: a "!!<\u2026>" matcher needs type:/format: or a schema pointer ("${inner}")`);
+  }
+  return out;
+}
+function unquotedSpace(s) {
+  let q = null;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (q !== null) {
+      if (c === q) q = null;
+      continue;
+    }
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      q = c;
+      continue;
+    }
+    if (c === "!" && s.startsWith("!!<", i)) {
+      const close = s.indexOf(">", i);
+      if (close < 0) return -1;
+      i = close;
+      continue;
+    }
+    if (c === " ") return i;
+  }
+  return -1;
+}
+function keyName(portion) {
+  const steps = parsePointer(portion).steps;
+  if (steps.length !== 1 || steps[0].sel !== "key") throw new SyntaxError(`query: bad name portion "${portion}"`);
+  return steps[0].name;
+}
+function evalQuery(s, text, from = ":") {
+  const q = parseQuery(text);
+  let binds;
+  switch (q.base.scope) {
+    case "current":
+      binds = [from];
+      break;
+    case "parent":
+      binds = compact(spineParent(s, from) === null ? [] : [spineParent(s, from)]);
+      break;
+    case "document":
+      binds = [docRootOf(s, from)];
+      break;
+    case "link": {
+      const hit = childByKey(s, ":", q.base.authority);
+      binds = hit === null ? [] : [hit];
+      break;
+    }
+  }
+  for (const p of q.portions) {
+    binds = dedup(step(s, binds, p));
+    if (binds.length === 0) break;
+  }
+  return dedup(binds);
+}
+function step(s, binds, p) {
+  const out = [];
+  for (const b of binds) {
+    switch (p.kind) {
+      case "key": {
+        const hit = childByKey(s, b, p.name);
+        if (hit !== null) out.push(hit);
+        break;
+      }
+      case "index": {
+        const row = s.db.prepare(
+          "SELECT to_path AS t FROM edge WHERE from_path = ? AND kind IN ('contain','ref') AND pos = ? LIMIT 1"
+        ).get(b, p.n);
+        if (row) out.push(row.t);
+        break;
+      }
+      case "anykey": {
+        for (const r of ownEntries(s, b)) if (r.label !== null) out.push(r.to);
+        for (const r of anchorEntries(s, b)) if (r.label !== null) out.push(r.member);
+        break;
+      }
+      case "anypos": {
+        for (const r of ownEntries(s, b)) out.push(r.to);
+        for (const r of anchorEntries(s, b)) out.push(r.member);
+        break;
+      }
+      case "descend":
+        out.push(...descend(s, b));
+        break;
+      case "spine": {
+        const up = spineParent(s, b);
+        if (up !== null) out.push(up);
+        break;
+      }
+      case "up":
+        out.push(...uplinks(s, b, p.sel));
+        break;
+      case "valtest":
+        if (valOk(s.node(b), p)) out.push(b);
+        break;
+      case "meta":
+        if (metaOk(s, b, p)) out.push(b);
+        break;
+      case "combo": {
+        if (!valOk(s.node(b), p.test)) break;
+        let inner = [b];
+        for (const t2 of p.then) inner = step(s, inner, t2);
+        out.push(...inner);
+        break;
+      }
+    }
+  }
+  return out;
+}
+function ownEntries(s, p) {
+  return s.db.prepare(
+    "SELECT to_path AS t, label FROM edge WHERE from_path = ? AND kind IN ('contain','ref') ORDER BY pos"
+  ).all(p).map((r) => ({ to: r.t, label: r.label }));
+}
+function anchorEntries(s, p) {
+  return s.db.prepare(
+    "SELECT from_path AS f, label FROM edge WHERE to_path = ? AND kind = 'back' ORDER BY from_path"
+  ).all(p).map((r) => ({ member: r.f, label: r.label }));
+}
+function childByKey(s, p, name) {
+  const own = s.db.prepare(
+    "SELECT to_path AS t FROM edge WHERE from_path = ? AND kind IN ('contain','ref') AND label = ? LIMIT 1"
+  ).get(p, name);
+  if (own) return own.t;
+  const anchored = s.db.prepare(
+    "SELECT from_path AS f FROM edge WHERE to_path = ? AND kind = 'back' AND label = ? ORDER BY from_path LIMIT 1"
+  ).get(p, name);
+  return anchored ? anchored.f : null;
+}
+function spineParent(s, p) {
+  const row = s.db.prepare(
+    "SELECT from_path AS f FROM edge WHERE to_path = ? AND kind = 'contain' LIMIT 1"
+  ).get(p);
+  return row ? row.f : null;
+}
+function uplinks(s, p, sel) {
+  const out = [];
+  const label = sel === "any" || sel === "keyless" ? null : sel;
+  const contains = s.db.prepare(
+    sel === "any" ? "SELECT from_path AS x FROM edge WHERE to_path = ? AND kind = 'contain'" : "SELECT from_path AS x FROM edge WHERE to_path = ? AND kind = 'contain' AND label " + (sel === "keyless" ? "IS NULL" : "= ?")
+  );
+  const backs = s.db.prepare(
+    sel === "any" ? "SELECT to_path AS x FROM edge WHERE from_path = ? AND kind = 'back'" : "SELECT to_path AS x FROM edge WHERE from_path = ? AND kind = 'back' AND label " + (sel === "keyless" ? "IS NULL" : "= ?")
+  );
+  const refs = s.db.prepare(
+    sel === "any" ? "SELECT from_path AS x FROM edge WHERE to_path = ? AND kind = 'ref'" : "SELECT from_path AS x FROM edge WHERE to_path = ? AND kind = 'ref' AND label " + (sel === "keyless" ? "IS NULL" : "= ?")
+  );
+  const args = (q) => label === null ? q.all(p) : q.all(p, label);
+  for (const r of args(contains)) out.push(r.x);
+  for (const r of args(backs)) out.push(r.x);
+  for (const r of args(refs)) out.push(r.x);
+  return out;
+}
+function descend(s, p) {
+  const out = [p];
+  const kids = s.db.prepare(
+    "SELECT to_path AS t FROM edge WHERE from_path = ? AND kind = 'contain' ORDER BY pos"
+  ).all(p);
+  for (const k of kids) out.push(...descend(s, k.t));
+  return out;
+}
+function docRootOf(s, p) {
+  let cur = p;
+  while (cur !== null && cur !== ":") {
+    const row = s.node(cur);
+    if (row?.meta && row.meta.documentRoot === true) return cur;
+    cur = spineParent(s, cur);
+  }
+  return ":";
+}
+function valOk(row, t2) {
+  if (!row || row.type !== "scalar") return false;
+  const v = row.value;
+  switch (t2.op) {
+    case "=":
+      return v === t2.value;
+    case "!=":
+      return v !== t2.value;
+    case ">":
+      return typeof v === "number" && typeof t2.value === "number" && v > t2.value;
+    case ">=":
+      return typeof v === "number" && typeof t2.value === "number" && v >= t2.value;
+    case "<":
+      return typeof v === "number" && typeof t2.value === "number" && v < t2.value;
+    case "<=":
+      return typeof v === "number" && typeof t2.value === "number" && v <= t2.value;
+  }
+}
+function metaOk(s, p, t2) {
+  const row = s.node(p);
+  if (!row) return false;
+  if (t2.schema !== void 0) return row.format === `x-yamlover-${t2.schema}`;
+  if (t2.format !== void 0 && row.format !== t2.format) return false;
+  if (t2.type !== void 0) {
+    switch (t2.type) {
+      case "binary":
+        return row.type === "blob";
+      case "array":
+        return row.is_array;
+      case "object":
+        return row.type === "mapping" && !row.is_array;
+      case "string":
+        return row.type === "scalar" && typeof row.value === "string";
+      case "integer":
+        return row.type === "scalar" && typeof row.value === "number" && Number.isInteger(row.value);
+      case "number":
+        return row.type === "scalar" && typeof row.value === "number";
+      case "boolean":
+        return row.type === "scalar" && typeof row.value === "boolean";
+      case "variant":
+        return row.type === "scalar" && hasOwnChild(s, p);
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+function hasOwnChild(s, p) {
+  return s.db.prepare("SELECT 1 FROM edge WHERE from_path = ? AND kind IN ('contain','ref') LIMIT 1").get(p) !== void 0;
+}
+function dedup(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of paths) if (!seen.has(p)) {
+    seen.add(p);
+    out.push(p);
+  }
+  return out;
+}
+function compact(xs) {
+  return xs.filter((x) => x !== null);
+}
+
+// src/server/gitignore.ts
+var import_ignore = __toESM(require_ignore(), 1);
+import fs5 from "node:fs";
+import path6 from "node:path";
+function buildGitIgnore(dataRoot) {
+  const gitRoot = findGitRoot(dataRoot) ?? dataRoot;
+  const cache = /* @__PURE__ */ new Map();
+  const matcherFor = (dir) => {
+    if (!cache.has(dir)) {
+      let ig = null;
+      try {
+        const gi = path6.join(dir, ".gitignore");
+        if (fs5.statSync(gi).isFile()) ig = (0, import_ignore.default)().add(fs5.readFileSync(gi, "utf-8"));
+      } catch {
+      }
+      cache.set(dir, ig);
+    }
+    return cache.get(dir);
+  };
+  return (absPath) => {
+    const fromRoot = path6.relative(gitRoot, absPath);
+    if (fromRoot === ".git" || fromRoot.startsWith(".git" + path6.sep)) return true;
+    let isDir = false;
+    try {
+      isDir = fs5.statSync(absPath).isDirectory();
+    } catch {
+    }
+    const rel = path6.relative(gitRoot, path6.dirname(absPath));
+    const segs = rel === "" ? [] : rel.split(path6.sep);
+    let dir = gitRoot;
+    const dirs = [gitRoot];
+    for (const s of segs) {
+      dir = path6.join(dir, s);
+      dirs.push(dir);
+    }
+    for (const d of dirs) {
+      const ig = matcherFor(d);
+      if (!ig) continue;
+      const relToDir = path6.relative(d, absPath);
+      if (!relToDir) continue;
+      if (ig.ignores(relToDir) || isDir && ig.ignores(relToDir + "/")) return true;
+    }
+    return false;
+  };
+}
+function findGitRoot(start) {
+  let dir = path6.resolve(start);
+  try {
+    if (!fs5.statSync(dir).isDirectory()) dir = path6.dirname(dir);
+  } catch {
+    return null;
+  }
+  for (; ; ) {
+    if (fs5.existsSync(path6.join(dir, ".git"))) return dir;
+    const parent = path6.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+// src/server/node-kind.ts
+function ownedEntries(s, p) {
+  return s.entries(p).filter((e2) => e2.kind !== "back");
+}
+function displayKind(s, p, row) {
+  const ents = ownedEntries(s, p);
+  if (row.type === "blob") return ents.length ? "omni" : "binary";
+  if (row.type === "scalar") return ents.length ? "omni" : "scalar";
+  if (!ents.length) return row.is_array ? "array" : "object";
+  if (row.is_array) return "array";
+  return ents.some((e2) => e2.label === null) ? "mix" : "object";
+}
+function typeName(s, p, row) {
+  const k = displayKind(s, p, row);
+  if (k === "scalar") return scalarType(row.value);
+  if (k === "mix") return "mixed";
+  if (k === "omni") return "variant";
+  return k;
+}
+function scalarType(v) {
+  if (v === null) return "null";
+  if (typeof v === "boolean") return "boolean";
+  if (typeof v === "number") return Number.isInteger(v) ? "integer" : "number";
+  return "string";
+}
+
+// src/server/tasks.ts
+var PROGRESS_EMIT_MS = 150;
+var KEEP_FINISHED_MS = 5e3;
+var TaskRegistry = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  seq = 0;
+  tasks = /* @__PURE__ */ new Map();
+  lastEmit = /* @__PURE__ */ new Map();
+  start(label) {
+    const id = "t" + ++this.seq;
+    const info = { id, label, state: "running", progress: { done: 0 }, startedAt: Date.now() };
+    this.tasks.set(id, info);
+    this.send(info, true);
+    const finish = (state, error) => {
+      if (info.state !== "running") return;
+      info.state = state;
+      info.finishedAt = Date.now();
+      if (error !== void 0) info.error = error;
+      this.send(info, true);
+    };
+    return {
+      id,
+      progress: (done, total, message) => {
+        if (info.state !== "running") return;
+        info.progress = { done, ...total !== void 0 && { total }, ...message !== void 0 && { message } };
+        this.send(info, false);
+      },
+      done: () => finish("done"),
+      fail: (err) => finish("error", String(err?.message ?? err))
+    };
+  }
+  /** Running tasks + ones finished within the last few seconds (pruning the rest). */
+  list() {
+    const now = Date.now();
+    for (const [id, t2] of this.tasks) {
+      if (t2.state !== "running" && now - (t2.finishedAt ?? 0) > KEEP_FINISHED_MS) {
+        this.tasks.delete(id);
+        this.lastEmit.delete(id);
+      }
+    }
+    return [...this.tasks.values()].map((t2) => ({ ...t2, progress: { ...t2.progress } }));
+  }
+  send(t2, always) {
+    const now = Date.now();
+    if (!always && now - (this.lastEmit.get(t2.id) ?? 0) < PROGRESS_EMIT_MS) return;
+    this.lastEmit.set(t2.id, now);
+    this.emit({ ...t2, progress: { ...t2.progress } });
+  }
+};
+
+// src/server/engine-api.ts
+var LINK_KEY = "$yamloverLink";
+var BINARY_KEY = "$yamloverBinary";
+var MIXED_KEY = "$yamloverMixed";
+function createHandlers(dataRoot, opts = {}) {
+  const rootName = path7.basename(path7.resolve(dataRoot)) || "/";
+  const dbPath = path7.join(dataRoot, ".yamlover", "index.db");
+  const settings = loadSettings(dataRoot);
+  const ignore2 = opts.gitignore === false ? void 0 : buildGitIgnore(dataRoot);
+  fs6.mkdirSync(path7.dirname(dbPath), { recursive: true });
+  const store0 = new Store(dbPath);
+  const store = () => store0;
+  const log = opts.log ?? (() => {
+  });
+  let closed = false;
+  const sseClients = /* @__PURE__ */ new Set();
+  const sseWrite = (frame) => {
+    const payload = JSON.stringify(frame);
+    for (const res of sseClients) res.write(`data: ${payload}
+
+`);
+  };
+  const broadcast = (diff) => {
+    if (diff.added.length + diff.changed.length + diff.removed.length + diff.moved.length === 0) return;
+    const toClient = (rel) => segsToStr(rel.split("/"));
+    sseWrite({
+      type: "diff",
+      added: diff.added.map(toClient),
+      changed: diff.changed.map(toClient),
+      removed: diff.removed.map(toClient),
+      moved: diff.moved.map((m) => ({ from: toClient(m.from), to: toClient(m.to) }))
+    });
+  };
+  const announce = (d) => broadcast({ added: [], changed: [], removed: [], moved: [], ...d });
+  const relFileOf = (clientPath) => strToSegs(clientPath).map(String).join("/");
+  const tasks = new TaskRegistry((t2) => sseWrite({ type: "task", task: t2 }));
+  let chain = Promise.resolve();
+  const enqueue = (fn) => {
+    const p = chain.then(fn);
+    chain = p.catch(() => {
+    });
+    return p;
+  };
+  const gib = (b) => (b / 2 ** 30).toFixed(1);
+  const BIG_FILE_BYTES = 256 * 2 ** 20;
+  let hashing = false;
+  const scheduleHasher = () => {
+    if (hashing || closed) return;
+    if (store0.unhashedFiles(1).length === 0) return;
+    hashing = true;
+    void (async () => {
+      const skip = /* @__PURE__ */ new Set();
+      let done = 0;
+      let lastLog = 0;
+      const t0 = Date.now();
+      let h = null;
+      try {
+        for (; ; ) {
+          if (closed) break;
+          const pending = store0.unhashedFiles().filter((f) => !skip.has(f.path));
+          if (pending.length === 0) break;
+          h ??= tasks.start("hashing large files");
+          const next = pending[0];
+          const total = done + pending.length;
+          h.progress(done, total, next.path);
+          const abs = path7.join(dataRoot, ...next.path.split("/"));
+          let hash = null;
+          try {
+            hash = await hashFileAsync(abs, (bytes) => {
+              if (next.size >= BIG_FILE_BYTES) h?.progress(done, total, `${next.path} \u2014 ${gib(bytes)}/${gib(next.size)} GiB`);
+            });
+          } catch {
+          }
+          const st = hash !== null ? fs6.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) {
+            skip.add(next.path);
+            continue;
+          }
+          done++;
+          const now = Date.now();
+          if (now - lastLog >= 500) {
+            lastLog = now;
+            log(`hashing ${done}/${total} \u2014 ${next.path}`);
+          }
+        }
+        h?.done();
+        if (h) log(`hashing done \u2014 ${done} file(s) in ${((Date.now() - t0) / 1e3).toFixed(1)}s`);
+      } catch (e2) {
+        h?.fail(e2);
+        log(`hashing FAILED \u2014 ${String(e2?.message ?? e2)}`);
+      } finally {
+        hashing = false;
+      }
+    })();
+  };
+  const doReindex = () => reindexAsync(store0, dataRoot, { ignore: ignore2 });
+  const runIndexTask = (label) => enqueue(async () => {
+    const h = tasks.start(label);
+    const t0 = Date.now();
+    let lastLog = 0;
+    log(`${label}\u2026`);
+    try {
+      const diff = await reindexAsync(store0, dataRoot, {
+        ignore: ignore2,
+        onProgress: (p) => {
+          h.progress(p.done, p.total, p.message);
+          const now = Date.now();
+          if (now - lastLog >= 500) {
+            lastLog = now;
+            log(`${label} ${p.done}/${p.total ?? "?"}${p.message ? ` \u2014 ${p.message}` : ""}`);
+          }
+        }
+      });
+      h.done();
+      log(
+        `${label} done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (+${diff.added.length} ~${diff.changed.length} \u2212${diff.removed.length} \u2192${diff.moved.length})`
+      );
+      broadcast(diff);
+      scheduleHasher();
+      return diff;
+    } catch (e2) {
+      h.fail(e2);
+      log(`${label} FAILED \u2014 ${String(e2?.message ?? e2)}`);
+      throw e2;
+    }
+  });
+  const reconcile = () => enqueue(async () => {
+    const h = tasks.start("reconciling");
+    try {
+      const diff = await doReindex();
+      if (diff.moved.length > 0) {
+        const r = relinkMoved(dataRoot, diff.moved, { ignore: ignore2 });
+        if (r.editedFiles.length > 0) {
+          const follow = reindex(store0, dataRoot, { ignore: ignore2 });
+          diff.changed = [.../* @__PURE__ */ new Set([...diff.changed, ...follow.changed])];
+        }
+      }
+      h.done();
+      broadcast(diff);
+      scheduleHasher();
+      return diff;
+    } catch (e2) {
+      h.fail(e2);
+      throw e2;
+    }
+  });
+  const ready = runIndexTask(`indexing ${rootName}`);
+  const stopWatch = opts.watch ? watchTree(dataRoot, () => {
+    reconcile().catch((e2) => log(`reconcile FAILED \u2014 ${String(e2?.message ?? e2)}`));
+  }, { ignore: ignore2 }) : null;
+  const handler = (req, res, url) => {
+    try {
+      const s = store();
+      if (req.method === "GET" && url.pathname === "/api/events") {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.write(": connected\n\n");
+        sseClients.add(res);
+        const ping = setInterval(() => res.write(": ping\n\n"), 3e4);
+        req.on("close", () => {
+          clearInterval(ping);
+          sseClients.delete(res);
+        });
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/reindex") {
+        reconcile().then((diff) => sendJson(res, 200, diff)).catch((e2) => sendJson(res, 500, { error: String(e2.message || e2) }));
+        return;
+      }
+      if (url.pathname === "/api/tasks") {
+        sendJson(res, 200, tasks.list());
+        return;
+      }
+      if (url.pathname === "/api/query") {
+        const q = url.searchParams.get("q") || "";
+        const at = storePath(strToSegs(url.searchParams.get("path") || ":"));
+        try {
+          const results = evalQuery(s, q, at).map((p2) => segsToStr(storePathToSegs(p2)));
+          sendJson(res, 200, { results });
+        } catch (e2) {
+          sendJson(res, 400, { error: String(e2.message || e2) });
+        }
+        return;
+      }
+      if (url.pathname === "/api/dangling") {
+        sendJson(res, 200, s.dangling().map((d) => ({ from: segsToStr(storePathToSegs(d.from)), raw: d.raw, reason: d.reason })));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/annotate") {
+        readBody(req).then(
+          (data) => (
+            // Queued: an incremental row added while a full walk (whose disk snapshot predates
+            // this annotation) is committing would be silently swapped away.
+            enqueue(() => {
+              const a = data;
+              const tagStore = storePath(strToSegs(a.tag ?? ""));
+              if (!a?.tag || s.node(tagStore)?.format !== TAG_FORMAT) {
+                throw new Error("annotation needs a `tag` that is an x-yamlover-tag node");
+              }
+              const annPath = writeAnnotation(dataRoot, settings.annotations.location, a);
+              const doc = parseYamlover(fs6.readFileSync(path7.join(dataRoot, ...strToSegs(annPath).map(String)), "utf8"), annPath);
+              s.addAnnotation(storePath(strToSegs(annPath)), storePath(strToSegs(a.target)), doc, tagStore);
+              announce({ added: [relFileOf(annPath)] });
+              return { path: annPath };
+            })
+          )
+        ).then((body) => sendJson(res, 201, body)).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
+        return;
+      }
+      if (req.method === "DELETE" && url.pathname === "/api/annotate") {
+        const annPath = url.searchParams.get("path") || "";
+        enqueue(() => {
+          deleteAnnotation(dataRoot, s, annPath);
+          s.removeAnnotation(storePath(strToSegs(annPath)));
+          announce({ removed: [relFileOf(annPath)] });
+        }).then(() => sendJson(res, 200, { ok: true })).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/tag") {
+        readBody(req).then(
+          (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 tagPath = segsToStr(segs2);
+            const existing = s.node(storePath(segs2));
+            if (existing) {
+              if (existing.format !== TAG_FORMAT) throw new Error(`a node already exists at ${tagPath} and is not a tag`);
+              const color = s.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);
+            s.addTag(storePath(strToSegs(settings.tags.location)), name, written.pos, written.node);
+            if (s.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 };
+          })
+        ).then((body) => sendJson(res, 201, body)).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/paste") {
+        readBody(req).then(
+          (data) => enqueue(async () => {
+            const result = handlePaste(dataRoot, s, data);
+            broadcast(await doReindex());
+            scheduleHasher();
+            return result;
+          })
+        ).then((result) => sendJson(res, 201, result)).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/api/mv") {
+        readBody(req).then(
+          (data) => enqueue(async () => {
+            const { from, to } = data;
+            const rel = (p2, what) => {
+              const segs2 = strToSegs(p2);
+              if (segs2.length === 0) throw new Error(`mv: ${what} must name a file or directory`);
+              if (segs2.some((g) => typeof g === "number")) throw new Error(`mv: ${what} must be a file/directory path (no positions)`);
+              return segs2.join("/");
+            };
+            const report = mv(dataRoot, rel(from ?? "", "from"), rel(to ?? "", "to"), { ignore: ignore2 });
+            const diff = await doReindex();
+            broadcast(diff);
+            return { ...report, diff };
+          })
+        ).then((body) => sendJson(res, 200, body)).catch((e2) => sendJson(res, 400, { error: String(e2.message || e2) }));
+        return;
+      }
+      const segs = strToSegs(url.searchParams.get("path") || ":");
+      const p = storePath(segs);
+      const depth = parseDepth(url.searchParams.get("depth"));
+      if (url.pathname === "/api/info") {
+        sendJson(res, 200, { root: rootName });
+        return;
+      }
+      if (url.pathname === "/api/annotations") {
+        sendJson(res, 200, annotationsFor(dataRoot, s, segs));
+        return;
+      }
+      if (url.pathname === "/api/tagged") {
+        const row2 = s.node(p);
+        if (!row2 || row2.format !== TAG_FORMAT) return notFound(res, url);
+        sendJson(res, 200, taggedMaterials(dataRoot, s, p));
+        return;
+      }
+      if (url.pathname === "/api/tree") {
+        const row2 = s.node(p);
+        if (!row2) return notFound(res, url);
+        const label = segs.length === 0 ? rootName : labelFor(s, p, segs[segs.length - 1]);
+        sendJson(res, 200, buildTree(dataRoot, s, segs, label, depth ?? 3));
+        return;
+      }
+      if (url.pathname === "/api/blob") {
+        const file = path7.join(dataRoot, ...segs.map(String));
+        if (!fs6.existsSync(file) || fs6.statSync(file).isDirectory()) return notFound(res, url);
+        res.statusCode = 200;
+        res.setHeader("Content-Type", s.node(p)?.format ?? formatFromExt(file) ?? "application/octet-stream");
+        res.setHeader("Content-Length", String(fs6.statSync(file).size));
+        const stream = fs6.createReadStream(file);
+        stream.on("error", () => res.destroy());
+        stream.pipe(res);
+        return;
+      }
+      const row = s.node(p);
+      if (!row) return notFound(res, url);
+      const viewDepth = depth ?? 1;
+      const kind = displayKind(s, p, row);
+      if (url.pathname === "/api/json") {
+        const wantBytes = kind === "binary" && url.searchParams.get("binary") === "1";
+        sendJson(res, 200, {
+          path: segsToStr(segs),
+          type: tocType(s, p, row),
+          format: row.format ?? null,
+          concrete: concreteOf(dataRoot, segs, row),
+          // dir | yamlover | null (stat-derived; engine tracks no per-node concrete yet)
+          documentPath: documentPath(s, segs),
+          // nearest enclosing document root (for `/…` links)
+          title: titleOf(s, p),
+          description: null,
+          value: wantBytes ? binaryContent(dataRoot, segs, row) : projectValue(dataRoot, s, segs, viewDepth, true),
+          relations: buildRelations(dataRoot, s, segs)
+        });
+      } else if (url.pathname === "/api/schema") {
+        sendJson(res, 200, projectSchema(dataRoot, s, segs, viewDepth, true));
+      } else {
+        notFound(res, url);
+      }
+    } catch (exc) {
+      sendJson(res, 400, { error: exc.message || String(exc) });
+    }
+  };
+  return Object.assign(handler, {
+    ready,
+    close: () => {
+      closed = true;
+      stopWatch?.();
+      for (const r of sseClients) r.end();
+      sseClients.clear();
+      store0.close();
+    }
+  });
+}
+function tocType(s, p, row) {
+  return typeName(s, p, row);
+}
+function concreteOf(dataRoot, segs, row) {
+  if (row.type !== "mapping") return null;
+  if (segs.some((g) => typeof g === "number")) return null;
+  const abs = path7.resolve(dataRoot, ...segs.map(String));
+  let st;
+  try {
+    st = fs6.statSync(abs);
+  } catch {
+    return null;
+  }
+  if (!st.isDirectory()) return null;
+  return fs6.existsSync(path7.join(abs, ".yamlover")) ? "yamlover" : "dir";
+}
+var relKey = (label, other) => `${label ?? ""}\0${other}`;
+function downstreamEntries(s, p) {
+  const isSet = !!s.node(p)?.meta?.set;
+  let own = s.entries(p).filter((e2) => e2.kind !== "back");
+  const seen = new Set(own.map((e2) => relKey(e2.label, e2.to)));
+  if (isSet) {
+    const kept = /* @__PURE__ */ new Set();
+    own = own.filter((e2) => {
+      const k = relKey(e2.label, e2.to);
+      if (kept.has(k)) return false;
+      kept.add(k);
+      return true;
+    });
+  }
+  const out = [...own];
+  const backs = s.relationships(p).in.filter((e2) => e2.kind === "back" && e2.from).sort((a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : 0);
+  for (const e2 of backs) {
+    const k = relKey(e2.label, e2.from);
+    if (e2.label != null || isSet) {
+      if (seen.has(k)) continue;
+      seen.add(k);
+    }
+    out.push({ to: e2.from, label: e2.label, pos: null, kind: "ref" });
+  }
+  return out;
+}
+function projectValue(dataRoot, s, segs, depth, top) {
+  const p = storePath(segs);
+  const row = s.node(p);
+  const k = displayKind(s, p, row);
+  if (!top && depth <= 0) return linkMarker(dataRoot, s, segs);
+  if (k === "binary" && !top) return linkMarker(dataRoot, s, segs);
+  if (k === "binary") return { size: row.size, format: row.format };
+  const kids = downstreamEntries(s, p);
+  const project = (c) => c.kind === "contain" ? projectValue(dataRoot, s, [...segs, c.label ?? c.pos ?? 0], depth - 1, false) : linkMarker(dataRoot, s, storePathToSegs(c.to));
+  if (k === "array") return kids.map(project);
+  if (k === "omni" || k === "mix") {
+    const entries = kids.map((c) => ({ key: c.label, value: project(c) }));
+    const marker = { kind: k, entries };
+    if (k === "omni") marker.value = row.value;
+    return { [MIXED_KEY]: marker };
+  }
+  if (k === "object") {
+    const out = {};
+    for (const c of kids) out[c.label ?? String(c.pos)] = project(c);
+    return out;
+  }
+  return row.value;
+}
+function projectSchema(dataRoot, s, segs, depth, top) {
+  const p = storePath(segs);
+  const row = s.node(p);
+  const k = displayKind(s, p, row);
+  if ((k === "object" || k === "array" || k === "mix" || k === "omni") && depth <= 0) return linkMarker(dataRoot, s, segs);
+  if (k === "binary" && !top) return linkMarker(dataRoot, s, segs);
+  const schema = { type: typeName(s, p, row) };
+  if (row.format) schema.format = row.format;
+  const kids = downstreamEntries(s, p);
+  const sub = (c) => c.kind === "contain" ? projectSchema(dataRoot, s, [...segs, c.label ?? c.pos ?? 0], depth - 1, false) : linkMarker(dataRoot, s, storePathToSegs(c.to));
+  if (k === "object" || k === "mix" || k === "omni") {
+    const props = {};
+    for (const c of kids) props[c.label ?? `[${c.pos}]`] = sub(c);
+    schema.properties = props;
+    if (k === "omni") schema.value = row.value;
+  } else if (k === "array") {
+    schema.prefixItems = kids.map(sub);
+    schema.items = false;
+  } else if (k === "binary") {
+    schema.const = { size: row.size, format: row.format };
+  } else {
+    schema.const = row.value;
+  }
+  const t2 = titleOf(s, p);
+  if (t2) schema.title = t2;
+  return schema;
+}
+function linkMarker(dataRoot, s, segs) {
+  const p = storePath(segs);
+  const row = s.node(p);
+  const k = displayKind(s, p, row);
+  const info = { kind: k, type: tocType(s, p, row), path: segsToStr(segs) };
+  if (row.format) info.format = row.format;
+  const concrete = concreteOf(dataRoot, segs, row);
+  if (concrete) info.concrete = concrete;
+  const title = titleOf(s, p);
+  if (title) info.title = title;
+  if (k === "binary") info.size = row.size;
+  else if (k === "scalar") info.value = row.value;
+  else if (k === "omni" || k === "mix") {
+    info.count = ownedEntries(s, p).length;
+    if (k === "omni") info.value = row.value;
+  } else info.count = s.children(p).length;
+  if (row.format === TAG_FORMAT) {
+    const c = s.node(p + ":color")?.value;
+    if (typeof c === "string") info.color = c;
+  }
+  return { [LINK_KEY]: info };
+}
+var segsEqual = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+function scopedPath(s, src, currentDoc) {
+  if (segsEqual(documentRootSegs(s, src), currentDoc)) return segsToStr(src.slice(currentDoc.length));
+  return "::" + segsToStr(src).slice(1);
+}
+function buildRelations(dataRoot, s, segs) {
+  const p = storePath(segs);
+  const out = {};
+  const put = (label, marker) => {
+    let k = label;
+    for (let i = 2; k in out; i++) k = `${label} (${i})`;
+    out[k] = marker;
+  };
+  if (segs.length > 0) put("..", linkMarker(dataRoot, s, segs.slice(0, -1)));
+  const currentDoc = documentRootSegs(s, segs);
+  const { out: outEdges, in: inEdges } = s.relationships(p);
+  const upstream = /* @__PURE__ */ new Map();
+  const addUp = (src, label) => {
+    if (src) upstream.set(relKey(label, src), src);
+  };
+  for (const e2 of inEdges) if (e2.kind === "ref") addUp(e2.from, e2.label);
+  for (const e2 of outEdges) if (e2.kind === "back") addUp(e2.to, e2.label);
+  for (const src of upstream.values()) {
+    const segs2 = storePathToSegs(src);
+    put(scopedPath(s, segs2, currentDoc), linkMarker(dataRoot, s, segs2));
+  }
+  return out;
+}
+function binaryContent(dataRoot, segs, row) {
+  const file = path7.join(dataRoot, ...segs.map(String));
+  const bytes = fs6.existsSync(file) ? fs6.readFileSync(file) : Buffer.alloc(0);
+  return { [BINARY_KEY]: { format: row.format ?? null, size: row.size ?? bytes.length, base64: bytes.toString("base64") } };
+}
+function buildTree(dataRoot, s, segs, label, depth) {
+  const p = storePath(segs);
+  const row = s.node(p);
+  const node = {
+    path: segsToStr(segs),
+    label,
+    type: tocType(s, p, row),
+    format: row.format ?? null,
+    concrete: concreteOf(dataRoot, segs, row),
+    hasChildren: s.hasChildren(p),
+    children: []
+  };
+  if (s.hasChildren(p) && depth > 0) {
+    for (const c of s.children(p)) {
+      const seg = c.label ?? c.pos ?? 0;
+      node.children.push(buildTree(dataRoot, s, [...segs, seg], labelFor(s, c.to, seg), depth - 1));
+    }
+  }
+  return node;
+}
+function labelFor(s, p, keyOrIdx) {
+  const t2 = titleOf(s, p);
+  if (t2) return t2;
+  return typeof keyOrIdx === "number" ? `[${keyOrIdx}]` : keyOrIdx;
+}
+var TAG_FORMAT = "x-yamlover-tag";
+function appliedTag(s, annStorePath) {
+  const e2 = s.relationships(annStorePath).out.find(
+    (t2) => t2.kind === "back" && t2.label === null && s.node(t2.to)?.format === TAG_FORMAT
+  );
+  if (!e2) return null;
+  const segs = storePathToSegs(e2.to);
+  const color = s.node(e2.to + ":color")?.value;
+  return { path: segsToStr(segs), name: String(segs[segs.length - 1] ?? ""), color: typeof color === "string" ? color : null };
+}
+function annotationsFor(dataRoot, s, segs) {
+  const p = storePath(segs);
+  const out = [];
+  for (const e2 of s.relationships(p).in) {
+    if (e2.kind !== "ref") continue;
+    const src = s.node(e2.from);
+    if (src?.format !== "x-yamlover-annotation") continue;
+    const aSegs = storePathToSegs(e2.from);
+    out.push({
+      path: segsToStr(aSegs),
+      tag: appliedTag(s, e2.from),
+      ...projectValue(dataRoot, s, aSegs, 6, true)
+    });
+  }
+  return out;
+}
+function taggedMaterials(dataRoot, s, tagStorePath) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const backs = s.relationships(tagStorePath).in.filter((e2) => e2.kind === "back" && e2.from).sort((a, b) => a.from < b.from ? -1 : a.from > b.from ? 1 : 0);
+  for (const e2 of backs) {
+    let material = e2.from;
+    if (s.node(e2.from)?.format === "x-yamlover-annotation") {
+      const t2 = s.relationships(e2.from).out.find((o) => o.kind === "ref" && o.label === "target");
+      if (!t2) continue;
+      material = t2.to;
+    }
+    if (seen.has(material) || !s.node(material)) continue;
+    seen.add(material);
+    out.push(linkMarker(dataRoot, s, storePathToSegs(material)));
+  }
+  return out;
+}
+function pointerRaw(clientPath) {
+  let out = "";
+  for (const seg of strToSegs(clientPath)) {
+    out += typeof seg === "number" ? `[${seg}]` : (out === "" ? "" : ":") + colonSegment(seg);
+  }
+  return "::" + out;
+}
+function yScalar(v) {
+  return typeof v === "number" || typeof v === "boolean" ? String(v) : JSON.stringify(String(v ?? ""));
+}
+function writeAnnotation(dataRoot, location, a) {
+  if (!a?.target || !a?.tag) throw new Error("annotation needs a target and a tag");
+  const dir = path7.resolve(dataRoot, ...strToSegs(location).map(String));
+  const root = path7.resolve(dataRoot);
+  if (dir !== root && !dir.startsWith(root + path7.sep)) throw new Error("annotation location escapes the data root");
+  fs6.mkdirSync(dir, { recursive: true });
+  const id = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const file = `${id}.yamlover`;
+  const lines = [
+    "!!<*yamlover/$defs/annotation>",
+    `target: ${pointerToken(pointerRaw(a.target))}`,
+    anchorToken(`${pointerRaw(a.tag)}[]`)
+    // the applied tag holds me (ordinal path anchor)
+  ];
+  if (a.selector) lines.push("selector:", ...Object.entries(a.selector).map(([k, v]) => `  ${k}: ${yScalar(v)}`));
+  if (a.description) lines.push(`description: ${yScalar(a.description)}`);
+  lines.push(`created: ${(/* @__PURE__ */ new Date()).toISOString()}`, "");
+  fs6.writeFileSync(path7.join(dir, file), lines.join("\n"));
+  return `${location}:${file}`;
+}
+function writeTag(dataRoot, location, name) {
+  if (/[/\\\r\n:]/.test(name)) throw new Error("a tag name cannot contain '/', '\\', ':' or line breaks");
+  const root = path7.resolve(dataRoot);
+  const dir = path7.resolve(dataRoot, ...strToSegs(location).map(String), ".yamlover");
+  if (!dir.startsWith(root + path7.sep)) throw new Error("tags location escapes the data root");
+  const file = path7.join(dir, "body.yamlover");
+  const createdFile = !fs6.existsSync(file);
+  const head = "# Named tags created from the annotation picker (settings.yamlover: tags.location).\n";
+  const existing = createdFile ? head : fs6.readFileSync(file, "utf8");
+  const body = (existing === "" || existing.endsWith("\n") ? existing : existing + "\n") + `${name}: !!<*yamlover/$defs/tag>
+`;
+  const entries = parseYamlover(body, file).root.entries ?? [];
+  const pos = entries.findIndex((e2) => e2.key === name);
+  const entry = pos >= 0 ? entries[pos] : void 0;
+  if (!entry || isPointer(entry.value) || entry.value.meta?.schema === void 0) {
+    throw new Error(`cannot write a tag named ${JSON.stringify(name)}`);
+  }
+  fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(file, body);
+  return { node: entry.value, pos, file: [...strToSegs(location).map(String), ".yamlover", "body.yamlover"].join("/"), createdFile };
+}
+function deleteAnnotation(dataRoot, s, annPath) {
+  const segs = strToSegs(annPath);
+  if (!String(segs[segs.length - 1] ?? "").endsWith(".yamlover")) throw new Error("not an annotation file");
+  if (s.node(storePath(segs))?.format !== "x-yamlover-annotation") throw new Error("not an annotation node");
+  const root = path7.resolve(dataRoot);
+  const file = path7.resolve(dataRoot, ...segs.map(String));
+  if (!file.startsWith(root + path7.sep)) throw new Error("outside the served root");
+  if (!fs6.existsSync(file) || fs6.statSync(file).isDirectory()) throw new Error("not an annotation file");
+  fs6.rmSync(file, { force: true });
+}
+function handlePaste(dataRoot, s, input) {
+  const segs = strToSegs(input.path || ":");
+  const row = s.node(storePath(segs));
+  if (!row) throw new Error(`no such node: ${input.path}`);
+  if (input.rich != null) {
+    const rich = parseRich(input.rich);
+    if (row.format === "x-yamlover-chapter") return pasteRichIntoChapter(dataRoot, s, segs, rich);
+    return pasteRichAsChapter(dataRoot, segs, rich);
+  }
+  if (typeof input.text === "string") {
+    const text = input.text.replace(/\r\n?/g, "\n");
+    if (text.trim().length === 0) throw new Error("empty paste (no text)");
+    if (row.format === "x-yamlover-chapter") return pasteTextIntoChapter(dataRoot, s, segs, text);
+    return pasteTextAsChapterFile(dataRoot, segs, text);
+  }
+  const bytes = Buffer.from(input.contentBase64 || "", "base64");
+  if (bytes.length === 0) throw new Error("empty paste (no file bytes)");
+  const name = sanitizeName(input.filename ?? "");
+  if (row.format === "x-yamlover-chapter") return pasteIntoChapter(dataRoot, s, segs, name, bytes);
+  const dirSegs = nearestDirSegs(dataRoot, segs);
+  if (!dirSegs) throw new Error("no enclosing directory to paste into");
+  const dir = path7.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 };
+}
+function nearestDirSegs(dataRoot, segs) {
+  for (let i = segs.length; i >= 0; i--) {
+    const sub = segs.slice(0, i);
+    const abs = path7.resolve(dataRoot, ...sub.map(String));
+    if (fs6.existsSync(abs) && fs6.statSync(abs).isDirectory()) return sub;
+  }
+  return null;
+}
+function chapterSource(dataRoot, s, segs) {
+  const docSegs = documentRootSegs(s, segs);
+  const docFs = path7.resolve(dataRoot, ...docSegs.map(String));
+  const dirBacked = fs6.existsSync(docFs) && fs6.statSync(docFs).isDirectory();
+  const bodyFile = dirBacked ? path7.join(docFs, ".yamlover", "body.yamlover") : docFs;
+  if (!bodyFile.endsWith(".yamlover") || !fs6.existsSync(bodyFile)) {
+    throw new Error("unsupported chapter source (need a .yamlover body)");
+  }
+  return { docSegs, bodyFile, dirBacked };
+}
+function pasteIntoChapter(dataRoot, s, segs, name, bytes) {
+  const { docSegs, bodyFile, dirBacked } = chapterSource(dataRoot, s, segs);
+  const writeDirSegs = dirBacked ? docSegs : docSegs.slice(0, -1);
+  const writeDir = path7.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 = fs6.readFileSync(bodyFile, "utf8");
+  fs6.writeFileSync(bodyFile, appendToList(src, within, "chunks", (indent) => [`${" ".repeat(indent)}- ${pointer}`]));
+  return { path: segsToStr(fileSegs), chapter: segsToStr(segs), pointer };
+}
+function pasteTextIntoChapter(dataRoot, s, segs, text) {
+  const { docSegs, bodyFile } = chapterSource(dataRoot, s, segs);
+  const within = segs.slice(docSegs.length);
+  const src = fs6.readFileSync(bodyFile, "utf8");
+  fs6.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 = path7.resolve(dataRoot, ...dirSegs.map(String));
+  const title = titleFromText(text);
+  const final = uniqueName(dir, chapterFileName(title));
+  const src = ["!!<*yamlover/$defs/chapter>", `title: ${JSON.stringify(title)}`, "chunks:", ...textChunkLines(text, 0), ""].join("\n");
+  writeInside(dataRoot, dir, final, Buffer.from(src, "utf8"));
+  return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
+}
+function parseRich(raw, depth = 0) {
+  if (depth > 8) throw new Error("rich paste: nesting too deep");
+  const r = raw ?? {};
+  const chunks = [];
+  for (const c of Array.isArray(r.chunks) ? r.chunks : []) {
+    if (typeof c?.text === "string") {
+      if (c.text.trim()) chunks.push({ text: c.text.replace(/\r\n?/g, "\n") });
+      continue;
+    }
+    const f = c?.file;
+    if (f && typeof f.name === "string") {
+      const bytes = Buffer.from(String(f.contentBase64 ?? ""), "base64");
+      if (bytes.length === 0) throw new Error("rich paste: empty file chunk");
+      chunks.push({ name: sanitizeName(f.name), bytes });
+      continue;
+    }
+    throw new Error("rich paste: a chunk must be {text} or {file}");
+  }
+  const children = (Array.isArray(r.children) ? r.children : []).map((k) => {
+    const sub = parseRich(k, depth + 1);
+    const title = typeof k?.title === "string" ? String(k.title).trim() : "";
+    return { ...sub, title: title || "Untitled" };
+  });
+  if (depth === 0 && chunks.length === 0 && children.length === 0) throw new Error("empty rich paste");
+  return { title: typeof r.title === "string" && r.title.trim() ? r.title.trim() : null, chunks, children };
+}
+function richItemLines(item, indent, pointerFor) {
+  if ("text" in item) return textChunkLines(item.text, indent);
+  return [`${" ".repeat(indent)}- ${pointerFor(item.name, item.bytes)}`];
+}
+function richChildLines(node, indent, pointerFor) {
+  const pad = " ".repeat(indent);
+  const lines = [`${pad}- title: ${JSON.stringify(node.title)}`];
+  if (node.chunks.length) lines.push(`${pad}  chunks:`, ...node.chunks.flatMap((c) => richItemLines(c, indent + 2, pointerFor)));
+  if (node.children.length) lines.push(`${pad}  children:`, ...node.children.flatMap((k) => richChildLines(k, indent + 2, pointerFor)));
+  return lines;
+}
+function pasteRichIntoChapter(dataRoot, s, segs, rich) {
+  const { docSegs, bodyFile, dirBacked } = chapterSource(dataRoot, s, segs);
+  const writeDirSegs = dirBacked ? docSegs : docSegs.slice(0, -1);
+  const writeDir = path7.resolve(dataRoot, ...writeDirSegs.map(String));
+  const files = [];
+  const pointerFor = (name, bytes) => {
+    const final = uniqueName(writeDir, name);
+    writeInside(dataRoot, writeDir, final, bytes);
+    files.push(segsToStr([...writeDirSegs, final]));
+    return dirBacked ? `*/${final}` : `*/${segsToStr([...writeDirSegs, final])}`;
+  };
+  const within = segs.slice(docSegs.length);
+  let src = fs6.readFileSync(bodyFile, "utf8");
+  if (rich.chunks.length) src = appendToList(src, within, "chunks", (ind) => rich.chunks.flatMap((c) => richItemLines(c, ind, pointerFor)));
+  if (rich.children.length) src = appendToList(src, within, "children", (ind) => rich.children.flatMap((k) => richChildLines(k, ind, pointerFor)));
+  fs6.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 = path7.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((c) => "text" in c);
+  const title = rich.title ?? (firstText ? titleFromText(firstText.text) : rich.children[0]?.title ?? "Pasted content");
+  if (!richHasFiles(rich)) {
+    const final = uniqueName(dir, chapterFileName(title));
+    const src2 = renderChapterSource(title, rich, () => {
+      throw new Error("unreachable: no files");
+    });
+    writeInside(dataRoot, dir, final, Buffer.from(src2, "utf8"));
+    return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
+  }
+  const name = uniqueName(dir, chapterFileName(title).replace(/\.yamlover$/, ""));
+  const chDir = path7.join(dir, name);
+  if (!path7.resolve(chDir).startsWith(path7.resolve(dataRoot) + path7.sep)) throw new Error("target escapes the data root");
+  fs6.mkdirSync(path7.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, path7.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) {
+  const lines = ["!!<*yamlover/$defs/chapter>", `title: ${JSON.stringify(title)}`];
+  if (rich.chunks.length) lines.push("chunks:", ...rich.chunks.flatMap((c) => richItemLines(c, 0, pointerFor)));
+  if (rich.children.length) lines.push("children:", ...rich.children.flatMap((k) => richChildLines(k, 0, pointerFor)));
+  return lines.join("\n") + "\n";
+}
+function richHasFiles(rich) {
+  return rich.chunks.some((c) => "bytes" in c) || rich.children.some(richHasFiles);
+}
+function titleFromText(text) {
+  const first = text.split("\n").find((l) => l.trim().length > 0)?.trim() ?? "";
+  const t2 = first.replace(/^#{1,6}\s+/, "").trim();
+  return (t2.length > 80 ? t2.slice(0, 79).trimEnd() + "\u2026" : t2) || "Pasted text";
+}
+function chapterFileName(title) {
+  const base = title.replace(/[^\p{L}\p{N} ._-]+/gu, " ").replace(/\s+/g, " ").trim().slice(0, 60).trim().replace(/^\.+/, "");
+  return `${base || "pasted"}.yamlover`;
+}
+function sanitizeName(raw) {
+  const base = path7.basename(String(raw || "")).replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
+  return base || "pasted";
+}
+function uniqueName(dir, name) {
+  if (!fs6.existsSync(path7.join(dir, name))) return name;
+  const ext = path7.extname(name);
+  const stem = name.slice(0, name.length - ext.length);
+  for (let i = 1; ; i++) {
+    const cand = `${stem}-${i}${ext}`;
+    if (!fs6.existsSync(path7.join(dir, cand))) return cand;
+  }
+}
+function writeInside(dataRoot, dir, name, bytes) {
+  const root = path7.resolve(dataRoot);
+  const target = path7.resolve(dir, name);
+  if (target !== root && !target.startsWith(root + path7.sep)) throw new Error("target escapes the data root");
+  fs6.writeFileSync(target, bytes);
+}
+var indentOf = (line) => {
+  let i = 0;
+  while (line[i] === " ") i++;
+  return i;
+};
+var isContentLine = (line) => {
+  const t2 = line.trim();
+  return t2.length > 0 && !t2.startsWith("#");
+};
+function textChunkLines(text, indent) {
+  const pad = " ".repeat(indent);
+  const first = text.split("\n").find((l) => l.trim().length > 0);
+  if (!first || /^\s/.test(first)) return [`${pad}- ${JSON.stringify(text)}`];
+  const body = text.endsWith("\n") ? text.slice(0, -1) : text;
+  const head = text.endsWith("\n") ? "|" : "|-";
+  return [`${pad}- ${head}`, ...body.split("\n").map((l) => l.trim().length ? `${pad}  ${l}` : "")];
+}
+function appendToList(text, chapterPath, key, renderItems) {
+  const lines = text.split("\n");
+  let lo = 0;
+  let hi = lines.length;
+  let indent = firstContentIndent(lines);
+  for (let i = 0; i < chapterPath.length; i += 2) {
+    const idx = Number(chapterPath[i + 1]);
+    const kids = findKeyLine(lines, lo, hi, indent, "children");
+    if (kids < 0) throw new Error(`no 'children:' at indent ${indent}`);
+    const items = seqItems(lines, kids + 1, hi, indent);
+    if (!(idx >= 0 && idx < items.length)) throw new Error(`children[${idx}] out of range (${items.length})`);
+    hi = idx + 1 < items.length ? items[idx + 1] : seqEnd(lines, kids + 1, hi, indent);
+    lo = items[idx] + 1;
+    indent += 2;
+  }
+  const keyLine = findKeyLine(lines, lo, hi, indent, key);
+  if (keyLine < 0) {
+    const end = trimBack(lines, lo - 1, hi);
+    lines.splice(end, 0, `${" ".repeat(indent)}${key}:`, ...renderItems(indent));
+  } else {
+    const end = seqEnd(lines, keyLine + 1, hi, indent);
+    lines.splice(end, 0, ...renderItems(indent));
+  }
+  return lines.join("\n");
+}
+function firstContentIndent(lines) {
+  for (const l of lines) if (isContentLine(l)) return indentOf(l);
+  return 0;
+}
+function findKeyLine(lines, lo, hi, indent, key) {
+  for (let i = lo; i < hi; i++) {
+    if (!isContentLine(lines[i])) continue;
+    const ind = indentOf(lines[i]);
+    if (ind < indent) return -1;
+    if (ind !== indent) continue;
+    const t2 = lines[i].trim();
+    if (t2 === `${key}:` || t2.startsWith(`${key}:`)) return i;
+  }
+  return -1;
+}
+function seqItems(lines, from, hi, indent) {
+  const out = [];
+  for (let i = from; i < hi; i++) {
+    if (!isContentLine(lines[i])) continue;
+    const ind = indentOf(lines[i]);
+    if (ind < indent) break;
+    if (ind !== indent) continue;
+    const t2 = lines[i].trim();
+    if (t2 === "-" || t2.startsWith("- ")) out.push(i);
+    else break;
+  }
+  return out;
+}
+function seqEnd(lines, from, hi, indent) {
+  let last = from;
+  for (let i = from; i < hi; i++) {
+    if (!isContentLine(lines[i])) continue;
+    const ind = indentOf(lines[i]);
+    if (ind < indent) return trimBack(lines, last, i);
+    if (ind === indent) {
+      const t2 = lines[i].trim();
+      if (t2 === "-" || t2.startsWith("- ")) {
+        last = i;
+        continue;
+      }
+      return trimBack(lines, last, i);
+    }
+    last = i;
+  }
+  return trimBack(lines, last, hi);
+}
+function trimBack(lines, lastItemLine, end) {
+  let e2 = end;
+  while (e2 > lastItemLine + 1 && !isContentLine(lines[e2 - 1])) e2--;
+  return e2;
+}
+function readBody(req) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      try {
+        resolve3(JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"));
+      } catch (e2) {
+        reject(e2);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function documentRootSegs(s, segs) {
+  for (let i = segs.length; i >= 0; i--) {
+    const anc = segs.slice(0, i);
+    if (s.node(storePath(anc))?.meta?.documentRoot) return anc;
+  }
+  return [];
+}
+function documentPath(s, segs) {
+  return segsToStr(documentRootSegs(s, segs));
+}
+function titleOf(s, p) {
+  const titlePath = (p === ":" ? "" : p) + ":title";
+  const t2 = s.node(titlePath);
+  if (t2 && t2.type === "scalar" && !s.hasChildren(titlePath) && t2.value != null) return String(t2.value);
+  return null;
+}
+var PATH_TOKEN = /\[\d+\]|[^:\[\]]+/g;
+function segsToStr(segs) {
+  return segs.map((seg) => typeof seg === "number" ? `[${seg}]` : `:${encodeURIComponent(seg)}`).join("") || ":";
+}
+function strToSegs(str) {
+  const out = [];
+  for (const tok of str.match(PATH_TOKEN) || []) out.push(/^\[\d+\]$/.test(tok) ? Number(tok.slice(1, -1)) : safeDecode(tok));
+  return out;
+}
+function storePath(segs) {
+  return segs.map((seg) => typeof seg === "number" ? `[${seg}]` : `:${seg}`).join("") || ":";
+}
+function storePathToSegs(p) {
+  const out = [];
+  for (const tok of p.match(PATH_TOKEN) || []) out.push(/^\[\d+\]$/.test(tok) ? Number(tok.slice(1, -1)) : tok);
+  return out;
+}
+function safeDecode(s) {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+}
+var EXT_CT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".pdf": "application/pdf",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".html": "text/html",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".epub": "application/epub+zip"
+};
+function formatFromExt(file) {
+  return EXT_CT[path7.extname(file).toLowerCase()] ?? null;
+}
+function parseDepth(raw) {
+  if (raw == null || raw === "") return null;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 0 ? n : null;
+}
+function sendJson(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(body, null, 2));
+}
+function notFound(res, url) {
+  sendJson(res, 404, { error: `no such node/endpoint: ${url.pathname}?${url.searchParams}` });
+}
+export {
+  createHandlers
+};