yamlover 0.3.7 → 0.3.10

package/dist/server.js

@@ -62441,13 +62441,13 @@ function resolve(doc, chains, fromChain, ptr, visited, anchorKeys) {
   let steps = ptr.steps;
   let chain;
   const linkAuthority = ptr.base.scope === "link" ? ptr.base.authority : "";
-  let isLink = false;
+  const isWorld = ptr.base.scope === "link" && ptr.base.world === true;
   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];
+      const selfImport = ptr.base.authority === "yamlover" && !root.entries?.some((e3) => e3.key === "yamlover");
+      steps = selfImport ? ptr.steps : [{ sel: "key", name: ptr.base.authority }, ...ptr.steps];
       break;
     }
     case "document": {
@@ -62470,7 +62470,7 @@ function resolve(doc, chains, fromChain, ptr, visited, anchorKeys) {
   }
   for (const st of steps) {
     if (st.sel === "parent") {
-      if (chain.length <= 1) return isLink ? external() : { kind: "unresolved", reason: '".." above the document root' };
+      if (chain.length <= 1) return isWorld ? external() : { kind: "unresolved", reason: '".." above the document root' };
       chain = chain.slice(0, -1);
       continue;
     }
@@ -62485,8 +62485,8 @@ function resolve(doc, chains, fromChain, ptr, visited, anchorKeys) {
           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 (!node.entries) return isWorld ? external() : { kind: "unresolved", reason: "step into a node with no fields" };
+      return isWorld ? 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" };
@@ -62631,6 +62631,71 @@ var Store = class {
       throw e3;
     }
   }
+  /** Patch the index for a SINGLE changed subtree instead of rebuilding the whole DB. `doc` is the
+   *  FULL, freshly-resolved document (the cached tree with the changed file's subtree spliced back
+   *  in and schemas re-applied) — correctness comes from resolving against the whole tree in
+   *  memory; speed comes from writing only the rows under `prefix` (the store path P of the changed
+   *  subtree). Every node/edge/dangling/file row whose owner lies under P is replaced; rows outside
+   *  P are left untouched (their resolution did not change). `files` is the re-walked manifest for
+   *  the subtree (POSIX paths under `relPrefix`).
+   *
+   *  Returns false WITHOUT writing when the patch is not provably equal to a full rebuild: if any
+   *  external `ref`/`back` edge pointing INTO the subtree changed (a referenced node added/removed/
+   *  re-resolved), the caller must fall back to a full reindex. The boundary `contain` edge into P
+   *  (from P's parent, outside the subtree) is stable and intentionally left in place. */
+  patchSubtree(doc, prefix, files, relPrefix) {
+    const colon = prefix + ":";
+    const brack = prefix + "[";
+    const underP = (p2) => p2 === prefix || p2.startsWith(colon) || p2.startsWith(brack);
+    const edges = resolveDocument(doc);
+    const edgeKey = (from, to2, label, kind, pos) => JSON.stringify([from, to2, label, kind, pos]);
+    const extInNew = edges.filter((r2) => r2.target.kind === "node" && underP(r2.target.path) && !underP(r2.holder)).map((r2) => edgeKey(r2.holder, r2.target.path, r2.label, r2.edge, r2.pos)).sort();
+    const extInOld = this.db.prepare("SELECT from_path, to_path, label, kind, pos FROM edge WHERE kind IN ('ref','back')").all().filter((r2) => underP(r2.to_path) && !underP(r2.from_path)).map((r2) => edgeKey(r2.from_path, r2.to_path, r2.label ?? null, r2.kind, r2.pos ?? null)).sort();
+    if (extInOld.length !== extInNew.length || extInOld.some((k, i2) => k !== extInNew[i2])) return false;
+    const insNode = this.db.prepare(
+      `INSERT 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 insDangling = this.db.prepare("INSERT INTO dangling (from_path, raw, reason) VALUES (?, ?, ?)");
+    const insFile = this.db.prepare("INSERT OR REPLACE INTO file (path, hash, size, mtime_ms) VALUES (?, ?, ?, ?)");
+    this.db.exec("BEGIN");
+    try {
+      const delUnder = (col, table) => {
+        this.db.prepare(`DELETE FROM ${table} WHERE ${col} = ? OR substr(${col},1,?) = ? OR substr(${col},1,?) = ?`).run(prefix, colon.length, colon, brack.length, brack);
+      };
+      delUnder("path", "node");
+      delUnder("from_path", "edge");
+      delUnder("from_path", "dangling");
+      if (relPrefix) this.db.prepare("DELETE FROM file WHERE substr(path,1,?) = ?").run(relPrefix.length, relPrefix);
+      walkNodes(doc.root, ":", (p2, node, parent, label, pos) => {
+        if (!underP(p2)) return;
+        const meta = node.meta ? JSON.stringify(node.meta) : null;
+        const owned = node.entries?.filter((e3) => e3.edge !== "back") ?? [];
+        const isArray = node.array || node.kind === "mapping" && owned.length > 0 && owned.every((e3) => e3.key === null);
+        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(p2, node.kind, format, value, hash, size, isArray ? 1 : 0, meta);
+        if (parent !== null && underP(parent)) insEdge.run(parent, p2, label, "contain", pos);
+      });
+      for (const r2 of edges) {
+        if (!underP(r2.holder)) continue;
+        if (r2.target.kind === "node") insEdge.run(r2.holder, r2.target.path, r2.label, r2.edge, r2.pos);
+        else if (r2.target.kind === "unresolved") insDangling.run(r2.from, r2.raw, r2.target.reason);
+      }
+      for (const f2 of files) insFile.run(f2.path, f2.hash, f2.size, f2.mtimeMs);
+      this.db.exec("COMMIT");
+      this._stale = false;
+      return true;
+    } catch (e3) {
+      this.db.exec("ROLLBACK");
+      throw e3;
+    }
+  }
   /** 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
@@ -64312,15 +64377,16 @@ function* walkTreeGen(absDir, opts = {}) {
   root.meta = { ...root.meta, documentRoot: true };
   const defsRoot = findDefsRoot(absDir);
   const defsDir = path.join(defsRoot, "$defs");
+  const selfRoot = path.resolve(absDir) === defsRoot;
   const arrayRoot = root.array || (root.entries?.length ? root.entries.every((e3) => e3.key === null) : false);
   let builtinDefs;
   if (!arrayRoot && root.entries && !root.entries.some((e3) => e3.key === "yamlover")) {
-    if (fs.existsSync(defsDir)) {
+    if (fs.existsSync(defsDir) && !selfRoot) {
       const shared = [{ key: "$defs", edge: "contain", value: yield* dirNode(defsDir, ctx) }];
       const tagsDir = path.join(defsRoot, "tags");
       if (fs.existsSync(tagsDir)) shared.push({ key: "tags", edge: "contain", value: yield* dirNode(tagsDir, ctx) });
       root.entries.push({ key: "yamlover", edge: "contain", value: { kind: "mapping", entries: shared, array: false } });
-    } else {
+    } else if (!fs.existsSync(defsDir)) {
       const built = builtinYamloverGraft();
       root.entries.push({ key: "yamlover", edge: "contain", value: built.node });
       builtinDefs = built.defs;
@@ -64338,7 +64404,7 @@ function reindex(store, absDir, opts = {}) {
   store.indexDocument(doc, files);
   return diffManifest(prev, files);
 }
-async function reindexAsync(store, absDir, opts = {}) {
+async function reindexAsyncDoc(store, absDir, opts = {}) {
   const prev = store.stale ? /* @__PURE__ */ new Map() : store.manifest();
   const onProgress = opts.onProgress;
   const total = onProgress ? await countChildren(path.resolve(absDir), opts) : void 0;
@@ -64350,7 +64416,49 @@ async function reindexAsync(store, absDir, opts = {}) {
   onProgress?.({ done: total ?? files.length, total, message: "writing index\u2026" });
   await yieldLoop();
   store.indexDocument(doc, files);
-  return diffManifest(prev, files);
+  return { diff: diffManifest(prev, files), doc, files };
+}
+async function reindexPathAsync(store, absDir, cachedDoc, changedRel, opts = {}) {
+  const root = path.resolve(absDir);
+  const parts = changedRel.split("/");
+  const yi = parts.indexOf(YAMLOVER_DIR);
+  const dirSegs = yi >= 0 ? parts.slice(0, yi) : parts.slice(0, -1);
+  if (dirSegs.length === 0) return null;
+  if (dirSegs[0] === "$defs" || dirSegs[0] === "tags") return null;
+  let entries = cachedDoc.root.entries;
+  let target = null;
+  for (let d = 0; d < dirSegs.length; d++) {
+    if (!entries) return null;
+    const i2 = entries.findIndex((e3) => e3.key === dirSegs[d] && !isPointer(e3.value));
+    if (i2 < 0) return null;
+    if (d === dirSegs.length - 1) target = { arr: entries, i: i2 };
+    else entries = entries[i2].value.entries;
+  }
+  if (!target) return null;
+  const absSpliceDir = path.join(root, ...dirSegs);
+  if (!fs.existsSync(absSpliceDir) || !fs.statSync(absSpliceDir).isDirectory()) return null;
+  const prev = store.stale ? /* @__PURE__ */ new Map() : store.manifest();
+  const ctx = { root, opts: { ...opts, cache: opts.cache ?? manifestCache(prev) }, files: /* @__PURE__ */ new Map(), count: 0 };
+  const gen = dirNode(absSpliceDir, ctx);
+  let r2 = gen.next();
+  while (!r2.done) r2 = gen.next();
+  target.arr[target.i].value = r2.value;
+  applySchemas(cachedDoc.root, findDefsRoot(absDir), graftDefs(cachedDoc.root));
+  const relPrefix = dirSegs.join("/") + "/";
+  const P = ":" + dirSegs.join(":");
+  const prevSub = new Map([...prev].filter(([k]) => k.startsWith(relPrefix)));
+  const files = [...ctx.files.values()];
+  const diff2 = diffManifest(prevSub, files);
+  if (!store.patchSubtree(cachedDoc, P, files, relPrefix)) return null;
+  return { diff: diff2, doc: cachedDoc };
+}
+function graftDefs(root) {
+  const yam = root.entries?.find((e3) => e3.key === "yamlover" && !isPointer(e3.value))?.value;
+  const defs = yam?.entries?.find((e3) => e3.key === "$defs" && !isPointer(e3.value))?.value;
+  if (!defs?.entries) return void 0;
+  const m = /* @__PURE__ */ new Map();
+  for (const e3 of defs.entries) if (e3.key && !isPointer(e3.value)) m.set(e3.key, e3.value);
+  return m.size ? m : void 0;
 }
 function manifestCache(prev) {
   return (rel, size, mtimeMs) => {
@@ -64629,6 +64737,7 @@ function applySchemas(root, defsRoot, builtinDefs) {
       const addl = field(s2, "additionalProperties");
       for (const e3 of inst.entries ?? []) {
         if (e3.key == null || isPointer(e3.value)) continue;
+        if (e3.value.meta?.schema && isPointer(e3.value.meta.schema)) continue;
         const declared = props && !isPointer(props) ? field(props, e3.key) : null;
         const sub = declared ?? addl;
         if (sub) apply(e3.value, sub, depth + 1);
@@ -65380,6 +65489,10 @@ function evalQuery(s2, text, from = ":") {
       binds = [docRootOf(s2, from)];
       break;
     case "link": {
+      if (q.base.authority === "yamlover" && childByKey(s2, ":", "yamlover") === null) {
+        binds = [":"];
+        break;
+      }
       const hit = childByKey(s2, ":", q.base.authority);
       binds = hit === null ? [] : [hit];
       break;
@@ -65994,6 +66107,7 @@ function createHandlers(dataRoot, opts = {}) {
   fs9.mkdirSync(path9.dirname(dbPath), { recursive: true });
   const store0 = new Store(dbPath);
   const store = () => store0;
+  let cachedDoc = null;
   const log = opts.log ?? (() => {
   });
   let closed = false;
@@ -66099,14 +66213,32 @@ function createHandlers(dataRoot, opts = {}) {
       }
     })();
   };
-  const doReindex = () => reindexAsync(store0, dataRoot, { ignore: ignore2 });
+  const doReindex = async () => {
+    const { diff: diff2, doc } = await reindexAsyncDoc(store0, dataRoot, { ignore: ignore2 });
+    cachedDoc = doc;
+    return diff2;
+  };
+  const doReindexFile = async (absFile) => {
+    if (cachedDoc) {
+      const rel = path9.relative(dataRoot, absFile).split(path9.sep).join("/");
+      try {
+        const res = await reindexPathAsync(store0, dataRoot, cachedDoc, rel, { ignore: ignore2 });
+        if (res) {
+          cachedDoc = res.doc;
+          return res.diff;
+        }
+      } catch {
+      }
+    }
+    return doReindex();
+  };
   const runIndexTask = (label) => enqueue(async () => {
     const h = tasks.start(label);
     const t0 = Date.now();
     let lastLog = 0;
     log(`${label}\u2026`);
     try {
-      const diff2 = await reindexAsync(store0, dataRoot, {
+      const { diff: diff2, doc } = await reindexAsyncDoc(store0, dataRoot, {
         ignore: ignore2,
         onProgress: (p2) => {
           h.progress(p2.done, p2.total, p2.message);
@@ -66117,6 +66249,7 @@ function createHandlers(dataRoot, opts = {}) {
           }
         }
       });
+      cachedDoc = doc;
       h.done();
       log(
         `${label} done in ${((Date.now() - t0) / 1e3).toFixed(1)}s (+${diff2.added.length} ~${diff2.changed.length} \u2212${diff2.removed.length} \u2192${diff2.moved.length})`
@@ -66139,6 +66272,7 @@ function createHandlers(dataRoot, opts = {}) {
         if (r2.editedFiles.length > 0) {
           const follow = reindex(store0, dataRoot, { ignore: ignore2 });
           diff2.changed = [.../* @__PURE__ */ new Set([...diff2.changed, ...follow.changed])];
+          cachedDoc = null;
         }
       }
       h.done();
@@ -66202,8 +66336,8 @@ function createHandlers(dataRoot, opts = {}) {
             if (!a2?.tag || s2.node(tagStore)?.format !== TAG_FORMAT) {
               throw new Error("annotation needs a `tag` that is an x-yamlover-tag node");
             }
-            embedAnnotation(dataRoot, s2, a2);
-            broadcast(await doReindex());
+            const bodyFile = embedAnnotation(dataRoot, s2, a2);
+            broadcast(await doReindexFile(bodyFile));
             scheduleHasher();
             return { ok: true };
           })
@@ -66228,8 +66362,8 @@ function createHandlers(dataRoot, opts = {}) {
         const tag = url.searchParams.get("tag") || "";
         enqueue(async () => {
           if (!tag) throw new Error("delete needs a `tag`");
-          unembedAnnotation(dataRoot, s2, target, tag);
-          broadcast(await doReindex());
+          const bodyFile = unembedAnnotation(dataRoot, s2, target, tag);
+          broadcast(await doReindexFile(bodyFile));
         }).then(() => sendJson(res, 200, { ok: true })).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
         return;
       }
@@ -66255,6 +66389,22 @@ function createHandlers(dataRoot, opts = {}) {
         ).then((body) => sendJson(res, 201, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
         return;
       }
+      if (req.method === "POST" && url.pathname === "/api/board") {
+        readBody(req).then(
+          (data) => enqueue(async () => {
+            const b = data;
+            const cols = Array.isArray(b?.columns) ? b.columns.map((lane) => Array.isArray(lane) ? lane.map((p3) => String(p3)) : []) : [];
+            const { bodyFile } = hostFor(dataRoot, s2, strToSegs(b?.path || ":"));
+            fs9.mkdirSync(path9.dirname(bodyFile), { recursive: true });
+            const src = fs9.existsSync(bodyFile) ? fs9.readFileSync(bodyFile, "utf8") : "";
+            fs9.writeFileSync(bodyFile, writeBoardColumns(src, cols));
+            broadcast(await doReindex());
+            scheduleHasher();
+            return { ok: true };
+          })
+        ).then((body) => sendJson(res, 201, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/api/paste") {
         readBody(req).then(
           (data) => enqueue(async () => {
@@ -66350,7 +66500,7 @@ function createHandlers(dataRoot, opts = {}) {
       const viewDepth = depth ?? 1;
       const kind = displayKind(s2, p2, row);
       if (url.pathname === "/api/json") {
-        const wantBytes = kind === "binary" && url.searchParams.get("binary") === "1";
+        const wantBytes = row.type === "blob" && url.searchParams.get("binary") === "1";
         sendJson(res, 200, {
           path: segsToStr(segs),
           type: tocType(s2, p2, row),
@@ -66389,7 +66539,19 @@ function createHandlers(dataRoot, opts = {}) {
 function tocType(s2, p2, row) {
   return typeName(s2, p2, row);
 }
+var JSON_EXT = { ".json": "json", ".json5": "json5", ".json5p": "json5p" };
 function concreteOf(dataRoot, segs, row) {
+  const last = segs[segs.length - 1];
+  if (typeof last === "string") {
+    const json = JSON_EXT[path9.extname(last).toLowerCase()];
+    if (json) {
+      const abs2 = path9.resolve(dataRoot, ...segs.map(String));
+      try {
+        if (fs9.statSync(abs2).isFile()) return json;
+      } catch {
+      }
+    }
+  }
   if (row.type !== "mapping") return null;
   if (segs.some((g) => typeof g === "number")) return null;
   const abs = path9.resolve(dataRoot, ...segs.map(String));
@@ -66645,6 +66807,21 @@ function pointerRaw(clientPath) {
   }
   return "::" + out;
 }
+function writeBoardColumns(src, cols) {
+  const laneLine = (lane) => `- [${lane.map((p2) => pointerToken(pointerRaw(p2))).join(", ")}]`;
+  const block = cols.length === 0 ? ["columns: []"] : ["columns:", ...cols.map(laneLine)];
+  let lines = src.replace(/\n+$/, "").split("\n");
+  if (src.trim() === "") lines = ["!!<*yamlover:$defs:board>"];
+  const start = lines.findIndex((l2) => /^columns:/.test(l2));
+  if (start >= 0) {
+    let end = start + 1;
+    while (end < lines.length && (lines[end] === "" || /^[ \t-]/.test(lines[end]))) end++;
+    lines.splice(start, end - start, ...block);
+  } else {
+    lines.push(...block);
+  }
+  return lines.join("\n") + "\n";
+}
 function sidecarTarget(dataRoot, mode, subdir, bodyFile) {
   const dirOverlay = bodyFile.endsWith(path9.join(".yamlover", "body.yamlover"));
   if (mode === "per-directory" && dirOverlay) {
@@ -66704,6 +66881,7 @@ function embedAnnotation(dataRoot, s2, a2) {
   fs9.mkdirSync(path9.dirname(bodyFile), { recursive: true });
   const src = fs9.existsSync(bodyFile) ? fs9.readFileSync(bodyFile, "utf8") : "";
   fs9.writeFileSync(bodyFile, appendAnnotation(src, within, (indent) => annotationItemLines(a2, indent)));
+  return bodyFile;
 }
 function embedFragment(dataRoot, s2, mode, f2) {
   const segs = strToSegs(f2.target || ":");
@@ -66760,10 +66938,11 @@ async function ensureThumbnail(dataRoot, s2, mode, segs, row, w, h) {
 }
 function unembedAnnotation(dataRoot, s2, target, tag) {
   const { bodyFile, within } = hostFor(dataRoot, s2, strToSegs(target || ":"));
-  if (!fs9.existsSync(bodyFile)) return;
-  const needle = pointerRaw(tag);
+  if (!fs9.existsSync(bodyFile)) return bodyFile;
+  const needlePath = ":" + pointerRaw(tag).replace(/^:+/, "");
   const src = fs9.readFileSync(bodyFile, "utf8");
-  fs9.writeFileSync(bodyFile, removeAnnotation(src, within, (itemText) => itemText.includes(needle)));
+  fs9.writeFileSync(bodyFile, removeAnnotation(src, within, (itemText) => itemText.replace(/\s+/g, "").includes(needlePath)));
+  return bodyFile;
 }
 function writeTag(dataRoot, location, name) {
   if (/[/\\\r\n:]/.test(name)) throw new Error("a tag name cannot contain '/', '\\', ':' or line breaks");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yamlover",
-  "version": "0.3.7",
+  "version": "0.3.10",
   "description": "Browse a yamlover tree in the web: npx yamlover <root> serves a React SPA over a directory.",
   "type": "module",
   "license": "MIT",