yamlover 0.3.22 → 0.3.23

package/dist/server.js

@@ -66856,64 +66856,17 @@ function createHandlers(dataRoot, opts = {}) {
           (data) => enqueue(async () => {
             const d = data;
             const edits = Array.isArray(d.edits) ? d.edits : [d];
-            const touched = applyEdits2(dataRoot, s2, edits);
-            for (const f2 of touched) broadcast(await doReindexFile(f2));
+            const { touched, created, appended } = applyEdits2(dataRoot, s2, edits);
+            if (created.length) broadcast(await doReindex());
+            else for (const f2 of touched) broadcast(await doReindexFile(f2));
             scheduleHasher();
+            if (created.length) return { ok: true, path: created[created.length - 1] };
+            if (appended.length) return { ok: true, path: lastBodyChildPath(s2, appended[appended.length - 1]) };
             return { ok: true };
           })
         ).then((body) => sendJson(res, 200, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
         return;
       }
-      if (req.method === "POST" && url.pathname === "/api/create") {
-        readBody(req).then(
-          (data) => enqueue(async () => {
-            const b = data;
-            const reg = CREATABLE[String(b.schema ?? "")];
-            if (!reg) throw new Error(`unknown schema: ${b.schema}`);
-            const concrete = String(b.concrete ?? "");
-            const parentSegs = strToSegs(b.parent ?? ":");
-            const row2 = s2.node(storePath(parentSegs));
-            if (!row2) throw new Error(`no such node: ${b.parent}`);
-            const title = String(b.title ?? "").trim() || defaultTitle(String(b.schema));
-            const body = reg.body(title);
-            const objSrc = objectFileSource(reg.tag, body);
-            if (reg.childOf.includes(row2.format ?? "")) {
-              const { docSegs, bodyFile, dirBacked } = chapterSource(dataRoot, s2, parentSegs);
-              const within = parentSegs.slice(docSegs.length);
-              if (concrete === "yamlover") {
-                const src = fs10.readFileSync(bodyFile, "utf8");
-                fs10.writeFileSync(bodyFile, appendBody(src, within, (indent) => inlineChildLines(body, indent)));
-                broadcast(await doReindexFile(bodyFile));
-                scheduleHasher();
-                return { path: lastBodyChildPath(s2, parentSegs) };
-              }
-              if (concrete === "file/yamlover" || concrete === "dir/yamlover") {
-                const writeDirSegs = dirBacked ? docSegs : docSegs.slice(0, -1);
-                const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
-                const final = writeObject(dataRoot, writeDir, sanitizeName(title), concrete, objSrc);
-                const targetSegs = [...writeDirSegs, final];
-                const pointer = dirBacked ? `*/${final}` : `*/${segsToStr(targetSegs)}`;
-                const src = fs10.readFileSync(bodyFile, "utf8");
-                fs10.writeFileSync(bodyFile, appendBody(src, within, (indent) => [`${" ".repeat(indent)}- ${pointer}`]));
-                broadcast(await doReindex());
-                scheduleHasher();
-                return { path: segsToStr(targetSegs) };
-              }
-              throw new Error(`invalid concrete for a child: ${concrete}`);
-            }
-            const abs = path10.resolve(dataRoot, ...parentSegs.map(String));
-            if (parentSegs.every((g) => typeof g === "string") && fs10.existsSync(abs) && fs10.statSync(abs).isDirectory()) {
-              if (concrete !== "file/yamlover" && concrete !== "dir/yamlover") throw new Error(`invalid concrete for a directory member: ${concrete}`);
-              const final = writeObject(dataRoot, abs, objectBaseName(title), concrete, objSrc);
-              broadcast(await doReindex());
-              scheduleHasher();
-              return { path: segsToStr([...parentSegs, final]) };
-            }
-            throw new Error("this schema can be created only inside a directory or a compatible parent");
-          })
-        ).then((body) => sendJson(res, 201, body)).catch((e3) => sendJson(res, 400, { error: String(e3.message || e3) }));
-        return;
-      }
       if (req.method === "POST" && url.pathname === "/api/mv") {
         readBody(req).then(
           (data) => enqueue(async () => {
@@ -67694,13 +67647,13 @@ function handlePaste(dataRoot, s2, input) {
   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, s2, segs, name, bytes);
+  if (row.format === "x-yamlover-chapter" && !input.inline) return pasteIntoChapter(dataRoot, s2, segs, name, bytes);
   const dirSegs = nearestDirSegs(dataRoot, segs);
   if (!dirSegs) throw new Error("no enclosing directory to paste into");
   const dir = path10.resolve(dataRoot, ...dirSegs.map(String));
   const final = uniqueName(dir, name);
   writeInside(dataRoot, dir, final, bytes);
-  return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: dirSegs.length !== segs.length };
+  return { path: segsToStr([...dirSegs, final]), dir: segsToStr(dirSegs), open: !input.inline && dirSegs.length !== segs.length };
 }
 function nearestDirSegs(dataRoot, segs) {
   for (let i2 = segs.length; i2 >= 0; i2--) {
@@ -67850,32 +67803,11 @@ function titleFromText(text) {
   const t3 = first.replace(/^#{1,6}\s+/, "").trim();
   return (t3.length > 80 ? t3.slice(0, 79).trimEnd() + "\u2026" : t3) || "Pasted text";
 }
-var CREATABLE = {
-  "::yamlover:$defs:chapter": {
-    tag: "*::yamlover:$defs:chapter",
-    childOf: ["x-yamlover-chapter", "x-yamlover-task"],
-    // a chapter with one empty prose chunk (a positional body item), so it is immediately editable
-    body: (title) => [`title: ${JSON.stringify(title)}`, `- ""`]
-  }
-};
 function lastBodyChildPath(s2, parentSegs) {
   const positional = s2.entries(storePath(parentSegs)).filter((e3) => e3.kind === "contain" && e3.label == null);
   const last = positional[positional.length - 1];
   return last ? segsToStr(storePathToSegs(last.to)) : segsToStr([...parentSegs, 0]);
 }
-function defaultTitle(schema) {
-  const segs = strToSegs(schema);
-  return "New " + String(segs[segs.length - 1] ?? "object");
-}
-function objectFileSource(tag, body) {
-  return `!!<${tag}>
-${body.join("\n")}
-`;
-}
-function inlineChildLines(body, indent) {
-  const pad = " ".repeat(indent);
-  return body.map((line, i2) => i2 === 0 ? `${pad}- ${line}` : `${pad}  ${line}`);
-}
 function objectBaseName(title) {
   const base = title.replace(/[^\p{L}\p{N} ._-]+/gu, " ").replace(/\s+/g, " ").trim().slice(0, 60).trim().replace(/^\.+/, "");
   return base || "new";
@@ -67952,13 +67884,20 @@ var isContentLine2 = (line) => {
   const t3 = line.trim();
   return t3.length > 0 && !t3.startsWith("#");
 };
-function textChunkLines(text, indent) {
-  const pad = " ".repeat(indent);
+function escapeScalarSrc(text) {
   const first = text.split("\n").find((l2) => l2.trim().length > 0);
-  if (!first || /^\s/.test(first)) return [`${pad}- ${JSON.stringify(text)}`];
+  if (!first || /^\s/.test(first)) return 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((l2) => l2.trim().length ? `${pad}  ${l2}` : "")];
+  return [head, ...body.split("\n").map((l2) => l2.trim().length ? "  " + l2 : "")].join("\n");
+}
+function renderEntry(valueSrc, indent, marker, tag, deeper = false) {
+  const pad = " ".repeat(indent + (deeper ? 2 : 0));
+  const [first, ...rest] = valueSrc.split("\n");
+  return [`${" ".repeat(indent)}${marker}${tag ? tag + " " : ""}${first}`, ...rest.map((l2) => l2.trim().length ? pad + l2 : "")];
+}
+function textChunkLines(text, indent) {
+  return renderEntry(escapeScalarSrc(text), indent, "- ");
 }
 function chapterEntries(lines, r2) {
   const starts = [];
@@ -67983,16 +67922,36 @@ function chapterEntries(lines, r2) {
     inline: s2.inline
   }));
 }
-function bodyItems(lines, r2) {
-  return chapterEntries(lines, r2).filter((e3) => e3.key === null);
+function findEntry(lines, r2, seg) {
+  const entries = chapterEntries(lines, r2);
+  return typeof seg === "number" ? entries[seg] : entries.find((e3) => e3.key === seg);
+}
+function entryHead(lines, e3) {
+  let t3 = lines[e3.start].trim().replace(/^-\s*/, "").replace(/^!!<[^>]*>\s*/, "");
+  if (e3.key) t3 = t3.slice(t3.indexOf(":") + 1).trim();
+  return t3;
+}
+function isContainerEntry(lines, e3, childIndent) {
+  const head = entryHead(lines, e3);
+  if (/^[|>][+-]?\d*$/.test(head.trim())) return itemHasFields(lines, e3, childIndent);
+  if (/^[^\s"'*|>#-][^:]*:(\s|$)/.test(head)) return true;
+  for (let i2 = e3.start + 1; i2 < e3.end; i2++) {
+    if (!isContentLine2(lines[i2])) continue;
+    const ind = indentOf2(lines[i2]);
+    if (ind < childIndent) break;
+    if (ind === childIndent) return true;
+  }
+  return false;
 }
-function reachChapter(lines, chapterPath) {
+function reachChapter(lines, within) {
   let r2 = { lo: 0, hi: lines.length, indent: firstContentIndent2(lines), marker: -1 };
-  for (const seg of chapterPath) {
-    const idx = Number(seg);
-    const item = chapterEntries(lines, r2)[idx];
-    if (!item || item.key !== null) throw new Error(`no subchapter at [${idx}]`);
-    r2 = { lo: item.start + 1, hi: item.end, indent: r2.indent + 2, marker: item.start };
+  for (const seg of within) {
+    const entry = findEntry(lines, r2, seg);
+    if (!entry) throw new Error(`no entry at ${typeof seg === "number" ? `[${seg}]` : seg}`);
+    if (!isContainerEntry(lines, entry, r2.indent + 2)) {
+      throw new Error(`cannot descend into a scalar element at ${typeof seg === "number" ? `[${seg}]` : seg}`);
+    }
+    r2 = { lo: entry.start + 1, hi: entry.end, indent: r2.indent + 2, marker: entry.start };
   }
   return r2;
 }
@@ -68009,60 +67968,106 @@ function appendBody(text, chapterPath, renderItems) {
   lines.splice(bodyAppendPoint(lines, r2), 0, ...renderItems(r2.indent));
   return lines.join("\n");
 }
-function bodyItemHead(lines, r2, rank) {
-  const items = bodyItems(lines, r2);
-  if (!(rank >= 0 && rank < items.length)) throw new Error(`body[${rank}] out of range (${items.length})`);
-  return lines[items[rank].start].trim().replace(/^-\s*/, "");
+var opensEntry = (t3) => t3 === "-" || t3.startsWith("- ") || /^[^\s"'*|>#-][^:]*:(\s|$)/.test(t3);
+var isBlockHeader = (head) => /^[|>][+-]?\d*$/.test(head.trim());
+function groupEntries(lines, at) {
+  const starts = lines.map((l2, i2) => i2).filter((i2) => isContentLine2(lines[i2]) && indentOf2(lines[i2]) === at);
+  const keyed = [];
+  const ordinal = [];
+  starts.forEach((s2, k) => {
+    const group = lines.slice(s2, k + 1 < starts.length ? starts[k + 1] : lines.length).map((l2) => l2.slice(at));
+    (lines[s2].trim() === "-" || lines[s2].trim().startsWith("- ") ? ordinal : keyed).push(group);
+  });
+  return { keyed, ordinal };
+}
+function payloadFacets(src) {
+  const lines = src.split("\n");
+  const first = lines.find(isContentLine2);
+  if (first === void 0) return { keyed: [], ordinal: [] };
+  if (!opensEntry(first.trim())) return { scalar: src, keyed: [], ordinal: [] };
+  return { scalar: void 0, ...groupEntries(lines, 0) };
+}
+function entryFacets(lines, e3, indent) {
+  const marked = lines[e3.start].trim().replace(/^-\s*/, "");
+  const tag = marked.match(/^(!!<[^>]*>)/)?.[1];
+  const head = entryHead(lines, e3);
+  const childIndent = indent + 2;
+  const value = (from, to2, at) => [head, ...lines.slice(from, to2).map((l2) => l2.trim().length ? "  " + l2.slice(at) : "")].join("\n").replace(/\n+$/, "");
+  if (!isContainerEntry(lines, e3, childIndent)) {
+    return { tag, scalar: value(e3.start + 1, e3.end, childIndent), keyed: [], ordinal: [] };
+  }
+  const blockValue = isBlockHeader(head);
+  let firstChild = e3.end;
+  for (let i2 = e3.start + 1; i2 < e3.end; i2++) {
+    if (isContentLine2(lines[i2]) && indentOf2(lines[i2]) === childIndent) {
+      firstChild = i2;
+      break;
+    }
+  }
+  const scalar2 = blockValue ? value(e3.start + 1, firstChild, childIndent + 2) : void 0;
+  const groups = groupEntries(lines.slice(firstChild, e3.end), childIndent);
+  if (!blockValue && head) groups.keyed.unshift([head]);
+  return { tag, scalar: scalar2, ...groups };
 }
-function setScalarKey(lines, r2, key, value) {
-  const entry = chapterEntries(lines, r2).find((e3) => e3.key === key);
-  if (entry?.inline) {
-    const pad3 = " ".repeat(indentOf2(lines[entry.start]));
-    lines[entry.start] = `${pad3}- ${key}: ${JSON.stringify(value)}`;
+function renderNode(f2, indent, marker, tag) {
+  const pad = " ".repeat(indent);
+  const childPad = " ".repeat(indent + 2);
+  const groups = [...f2.keyed, ...f2.ordinal];
+  const child = (g) => g.map((l2) => l2.trim().length ? childPad + l2 : "");
+  if (f2.scalar !== void 0) {
+    return [...renderEntry(f2.scalar, indent, marker, tag, groups.length > 0), ...groups.flatMap(child)];
+  }
+  if (!groups.length) return [`${pad}${marker.trimEnd()}${tag ? " " + tag : ""}`];
+  if (marker.startsWith("-") && !tag) {
+    const [g0, ...rest] = groups;
+    return [`${pad}${marker}${g0[0]}`, ...child(g0.slice(1)), ...rest.flatMap(child)];
+  }
+  return [`${pad}${marker.trimEnd()}${tag ? " " + tag : ""}`, ...groups.flatMap(child)];
+}
+function metaTag(meta, existing, preserve) {
+  if (meta === null) return void 0;
+  if (meta !== void 0) return `!!<${meta}>`;
+  return preserve ? existing : void 0;
+}
+function assignAt(lines, r2, seg, op, valueSrc, meta) {
+  const marker = (s2) => typeof s2 === "string" ? `${s2}: ` : "- ";
+  if (op === "insert") {
+    if (typeof seg === "string") throw new Error("`insert` needs a positional target (a path ending `[i]`, or the node itself)");
+    const entry2 = seg === void 0 ? void 0 : findEntry(lines, r2, seg);
+    const at = entry2 ? entry2.start : bodyAppendPoint(lines, r2);
+    lines.splice(at, 0, ...renderNode(payloadFacets(valueSrc), r2.indent, "- ", metaTag(meta, void 0, false)));
     return;
   }
-  const pad = " ".repeat(r2.indent);
-  if (!value) {
-    if (entry) lines.splice(entry.start, 1);
+  if (seg === void 0) throw new Error(`\`${op}\` needs a key or index target`);
+  const entry = findEntry(lines, r2, seg);
+  if (op === "remove") {
+    if (!entry) throw new Error(`no entry at ${typeof seg === "number" ? `[${seg}]` : seg}`);
+    lines.splice(entry.start, entry.end - entry.start);
     return;
   }
-  const rendered = `${pad}${key}: ${JSON.stringify(value)}`;
-  if (entry) lines.splice(entry.start, 1, rendered);
-  else lines.splice(r2.marker >= 0 ? r2.marker + 1 : trimBack2(lines, r2.lo - 1, r2.hi), 0, rendered);
-}
-function replaceBodyItem(lines, r2, rank, text) {
-  const items = bodyItems(lines, r2);
-  if (!(rank >= 0 && rank < items.length)) throw new Error(`body[${rank}] out of range (${items.length})`);
-  const { start, end } = items[rank];
-  const head = lines[start].trim().replace(/^-\s*/, "");
-  const tag = head.match(/^(!!<[^>]*>)/)?.[1];
-  const rendered = tag ? taggedChunkLines(text, r2.indent, tag) : textChunkLines(text, r2.indent);
-  lines.splice(start, end - start, ...rendered);
-}
-function insertBodyItem(lines, r2, rank, text) {
-  const items = bodyItems(lines, r2);
-  const at = rank < items.length ? items[rank].start : bodyAppendPoint(lines, r2);
-  lines.splice(at, 0, ...textChunkLines(text, r2.indent));
-}
-function removeBodyItem(lines, r2, rank) {
-  const items = bodyItems(lines, r2);
-  if (!(rank >= 0 && rank < items.length)) throw new Error(`body[${rank}] out of range (${items.length})`);
-  const { start, end } = items[rank];
-  lines.splice(start, end - start);
-}
-function taggedChunkLines(text, indent, tag) {
-  const pad = " ".repeat(indent);
-  const first = text.split("\n").find((l2) => l2.trim().length > 0);
-  if (!first || /^\s/.test(first)) return [`${pad}- ${tag} ${JSON.stringify(text)}`];
-  const body = text.endsWith("\n") ? text.slice(0, -1) : text;
-  const head = text.endsWith("\n") ? "|" : "|-";
-  return [`${pad}- ${tag} ${head}`, ...body.split("\n").map((l2) => l2.trim().length ? `${pad}  ${l2}` : "")];
-}
-function assertProseBodyItem(lines, r2, rank) {
-  const head = bodyItemHead(lines, r2, rank);
-  if (head.startsWith("*")) throw new Error("cannot edit a file/pointer chunk as text");
-  const tag = head.match(/^!!<([^>]*)>/)?.[1];
-  if (tag && !/text\/(markdown|marklower|x-latex)/.test(tag)) throw new Error("cannot edit a non-text chunk as text");
+  if (op !== "emplace" && op !== "replace") throw new Error(`unknown edit op: ${op}`);
+  if (!entry) {
+    if (op === "replace") throw new Error(`no entry at ${typeof seg === "number" ? `[${seg}]` : seg}`);
+    const rendered = renderNode(payloadFacets(valueSrc), r2.indent, marker(seg), metaTag(meta, void 0, false));
+    const at = typeof seg === "string" ? r2.marker >= 0 ? r2.marker + 1 : trimBack2(lines, r2.lo - 1, r2.hi) : bodyAppendPoint(lines, r2);
+    lines.splice(at, 0, ...rendered);
+    return;
+  }
+  const had = entryFacets(lines, entry, r2.indent);
+  const payload = payloadFacets(valueSrc);
+  const inlineKey = entry.inline ? entry.key : null;
+  const next = op === "replace" ? payload : {
+    scalar: payload.scalar ?? had.scalar,
+    keyed: payload.keyed.length ? payload.keyed : had.keyed,
+    ordinal: payload.ordinal.length ? payload.ordinal : had.ordinal
+  };
+  const tag = metaTag(meta, had.tag, op === "emplace");
+  if (inlineKey) {
+    const pad = " ".repeat(indentOf2(lines[entry.start]));
+    lines[entry.start] = `${pad}- ${tag ? tag + " " : ""}${inlineKey}: ${next.scalar ?? '""'}`;
+    return;
+  }
+  lines.splice(entry.start, entry.end - entry.start, ...renderNode(next, r2.indent, marker(seg), tag));
 }
 function reachChapterItem(lines, indices) {
   const parent = reachChapter(lines, indices.slice(0, -1));
@@ -68125,49 +68130,109 @@ function splitChunkWithin(within) {
   while (i2 < within.length && typeof within[i2] === "number") i2++;
   return { indices: within.slice(0, i2).map(Number), keys: within.slice(i2).map(String) };
 }
-function editChapterSource(src, within, op, text, index) {
-  const lines = src.split("\n");
-  if (op === "set") {
-    const key = within[within.length - 1];
-    if (key !== "title" && key !== "description") throw new Error("`set` needs a title/description target");
-    setScalarKey(lines, reachChapter(lines, within.slice(0, -1)), key, text);
-    return lines.join("\n");
+function setRootTag(lines, meta) {
+  const at = lines.findIndex(isContentLine2);
+  const existing = at >= 0 && lines[at].trim().startsWith("!!<") ? at : -1;
+  if (meta === null) {
+    if (existing >= 0) lines.splice(existing, 1);
+    return;
   }
-  if (op === "insert") {
-    insertBodyItem(lines, reachChapter(lines, within), index ?? Number.MAX_SAFE_INTEGER, text);
-    return lines.join("\n");
-  }
-  const rank = within[within.length - 1];
-  if (typeof rank !== "number") throw new Error(`\`${op}\` needs a body-element target (path ends \`[rank]\`)`);
-  const region = reachChapter(lines, within.slice(0, -1));
-  if (op === "replace") {
-    assertProseBodyItem(lines, region, rank);
-    replaceBodyItem(lines, region, rank, text);
-  } else if (op === "remove") {
-    removeBodyItem(lines, region, rank);
-  } else {
-    throw new Error(`unknown edit op: ${op}`);
+  if (existing >= 0) lines[existing] = `!!<${meta}>`;
+  else lines.splice(Math.max(at, 0), 0, `!!<${meta}>`);
+}
+function editChapterSource(src, within, op, valueSrc, meta) {
+  const lines = src.split("\n");
+  if (within.length === 0) {
+    if (op === "insert") {
+      assignAt(lines, reachChapter(lines, []), void 0, op, valueSrc, meta);
+      return lines.join("\n");
+    }
+    if (op === "emplace" && meta !== void 0 && !valueSrc) {
+      setRootTag(lines, meta);
+      return lines.join("\n");
+    }
+    throw new Error(`\`${op}\` at a document root needs a key or index target`);
   }
+  assignAt(lines, reachChapter(lines, within.slice(0, -1)), within[within.length - 1], op, valueSrc, meta);
   return lines.join("\n");
 }
+var isPointerValue = (src) => /^\*\S*$/.test(src.trim()) && !src.includes("\n");
+function isPlainDir(dataRoot, s2, segs) {
+  if (!segs.every((g) => typeof g === "string")) return false;
+  const abs = path10.resolve(dataRoot, ...segs.map(String));
+  if (!fs10.existsSync(abs) || !fs10.statSync(abs).isDirectory()) return false;
+  try {
+    chapterSource(dataRoot, s2, segs);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function bornAsDocument(dataRoot, e3, tag) {
+  const writeDirSegs = e3.dirBacked ? e3.docSegs : e3.docSegs.slice(0, -1);
+  const writeDir = path10.resolve(dataRoot, ...writeDirSegs.map(String));
+  const src = [...tag ? [tag] : [], e3.valueSrc, ""].join("\n");
+  const final = writeObject(dataRoot, writeDir, sanitizeName(e3.name || "object"), e3.concrete, src);
+  const targetSegs = [...writeDirSegs, final];
+  return { pointer: e3.dirBacked ? `*/${final}` : `*/${segsToStr(targetSegs)}`, path: segsToStr(targetSegs) };
+}
 function applyEdits2(dataRoot, s2, edits) {
   const byFile = /* @__PURE__ */ new Map();
+  const appended = [];
+  const created = [];
   for (const e3 of edits) {
     const editSegs = strToSegs(e3.path ?? "");
-    const { docSegs, bodyFile } = chapterSource(dataRoot, s2, editSegs);
-    const within = editSegs.slice(docSegs.length);
+    const op = String(e3.op ?? "");
+    if (op === "insert" && (e3.concrete === "file/yamlover" || e3.concrete === "dir/yamlover") && isPlainDir(dataRoot, s2, editSegs)) {
+      const dir = path10.resolve(dataRoot, ...editSegs.map(String));
+      const src = [...metaTag(e3.meta, void 0, false) ? [metaTag(e3.meta, void 0, false)] : [], String(e3.yamlover ?? ""), ""].join("\n");
+      if (e3.yamlover) parseYamlover(String(e3.yamlover), "<edit>");
+      const final = writeObject(dataRoot, dir, objectBaseName(String(e3.name || "new")), String(e3.concrete), src);
+      created.push(segsToStr([...editSegs, final]));
+      continue;
+    }
+    const { docSegs, bodyFile, dirBacked } = chapterSource(dataRoot, s2, editSegs);
+    if (op === "insert" && !e3.concrete?.includes("/")) {
+      const last = editSegs[editSegs.length - 1];
+      if (typeof last !== "number") appended.push(editSegs);
+      else if (!s2.node(storePath(editSegs))) appended.push(editSegs.slice(0, -1));
+    }
+    const concrete = e3.concrete ? String(e3.concrete) : void 0;
+    if (concrete && concrete !== "yamlover" && op !== "insert" && !(op === "emplace" && !s2.node(storePath(editSegs)))) {
+      throw new Error("`concrete` is only for content being created \u2014 converting an existing node is a move, not an edit");
+    }
     const list = byFile.get(bodyFile) ?? [];
-    list.push({ within, op: String(e3.op ?? ""), text: String(e3.text ?? ""), index: typeof e3.index === "number" ? e3.index : void 0 });
+    list.push({
+      within: editSegs.slice(docSegs.length),
+      op,
+      valueSrc: String(e3.yamlover ?? ""),
+      meta: e3.meta === void 0 ? void 0 : e3.meta === null ? null : String(e3.meta),
+      concrete,
+      name: e3.name ? String(e3.name) : void 0,
+      docSegs,
+      dirBacked
+    });
     byFile.set(bodyFile, list);
   }
   const touched = [];
   for (const [bodyFile, ops] of byFile) {
     let src = fs10.readFileSync(bodyFile, "utf8");
-    for (const o2 of ops) src = editChapterSource(src, o2.within, o2.op, o2.text, o2.index);
+    for (const o2 of ops) {
+      let { valueSrc, meta } = o2;
+      const tag = metaTag(meta, void 0, false);
+      if (valueSrc && !isPointerValue(valueSrc)) parseYamlover(valueSrc, "<edit>");
+      if (o2.concrete === "file/yamlover" || o2.concrete === "dir/yamlover") {
+        const born = bornAsDocument(dataRoot, o2, tag);
+        created.push(born.path);
+        valueSrc = born.pointer;
+        meta = void 0;
+      }
+      src = editChapterSource(src, o2.within, o2.op, valueSrc, meta);
+    }
     fs10.writeFileSync(bodyFile, src);
     touched.push(bodyFile);
   }
-  return touched;
+  return { touched, created, appended };
 }
 function firstContentIndent2(lines) {
   for (const l2 of lines) if (isContentLine2(l2)) return indentOf2(l2);
@@ -68211,7 +68276,7 @@ function descriptionOf(s2, p2) {
 function scalarKeyOf(s2, p2, key) {
   const kp = (p2 === ":" ? "" : p2) + ":" + key;
   const t3 = s2.node(kp);
-  if (t3 && t3.type === "scalar" && !s2.hasChildren(kp) && t3.value != null) return String(t3.value);
+  if (t3 && t3.type === "scalar" && t3.value != null) return String(t3.value);
   return null;
 }
 var PATH_TOKEN = /\[\d+\]|[^:\[\]]+/g;

package/package.json

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