pmsec 2026.11.1 → 2026.11.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmsec",
-  "version": "2026.11.1",
+  "version": "2026.11.3",
   "publishConfig": {
     "access": "public"
   },

package/src/util/io.mjs

@@ -6,7 +6,8 @@ import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
 
 export async function readSafe(path) {
-  try { return await readFile(path, "utf8"); }
+  // Editors on Windows may prepend a BOM; it would hide the first header or key.
+  try { return (await readFile(path, "utf8")).replace(/^\uFEFF/, ""); }
   catch (e) { if (e.code === "ENOENT") return ""; throw e; }
 }
 

package/src/util/lines.mjs

@@ -1,9 +1,50 @@
-const SECTION = /^\s*\[[^\]]+\]\s*$/;
+// TOML tables may carry a trailing comment, inner whitespace, quoted names, or be [[arrays]].
+const SECTION = /^\s*\[\[?[^\[\]]+\]\]?\s*(#.*)?$/;
+const HEADER = /^\s*\[([^\[\]]+)\]\s*(#.*)?$/;
+const KEY = String.raw`("[^"]*"|'[^']*'|[A-Za-z0-9_.\-]+)`;
+
+function unquote(s) {
+  return /^(".*"|'.*')$/.test(s) ? s.slice(1, -1) : s;
+}
+
+function headerName(line) {
+  const m = line.match(HEADER);
+  return m ? m[1].split(".").map(p => unquote(p.trim())).join(".") : null;
+}
+
+// YAML nests by indentation, so only unindented `key:` lines are top-level.
+function indentRe(sep) { return sep === ":" ? "^" : String.raw`^\s*`; }
 
 function entryKey(line, sep) {
-  const re = sep === ":" ? /^\s*([A-Za-z0-9_.\-]+)\s*:/ : /^\s*([A-Za-z0-9_.\-]+)\s*=/;
-  const m = line.match(re);
-  return m ? m[1] : null;
+  const m = line.match(new RegExp(String.raw`${indentRe(sep)}${KEY}\s*${sep}`));
+  return m ? unquote(m[1]) : null;
+}
+
+// Value after the separator with any trailing comment removed.
+function entryValue(line, sep) {
+  const m = line.match(new RegExp(String.raw`${indentRe(sep)}${KEY}\s*${sep}\s*(.*?)\s*$`));
+  if (!m) return null;
+  const v = m[2];
+  const close = { '"': '"', "'": "'", "{": "}" }[v[0]];
+  if (close) {
+    const end = v.indexOf(close, 1);
+    if (end >= 0) return v.slice(0, end + 1);
+  }
+  return v.replace(/\s+#.*$/, "");
+}
+
+// Copy of `lines` with the body of TOML multi-line strings blanked, so text
+// inside them is never taken for a header or key. Indices stay aligned.
+function scanView(lines) {
+  let open = null;
+  return lines.map(line => {
+    const inside = open !== null;
+    for (const m of line.matchAll(/"""|'''/g)) {
+      if (open === null) open = m[0];
+      else if (open === m[0]) open = null;
+    }
+    return inside ? "" : line;
+  });
 }
 
 function rangeForSection(lines, section) {
@@ -11,10 +52,9 @@ function rangeForSection(lines, section) {
     for (let i = 0; i < lines.length; i++) if (SECTION.test(lines[i])) return [0, i];
     return [0, lines.length];
   }
-  const header = `[${section}]`;
   let start = -1;
   for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim() === header) { start = i + 1; break; }
+    if (headerName(lines[i]) === section) { start = i + 1; break; }
   }
   if (start < 0) return null;
   let end = lines.length;
@@ -29,6 +69,44 @@ function indexOfKey(lines, range, key, sep) {
   return -1;
 }
 
+// TOML forbids `a.b = x` under [s] when [s.a] exists or `a` is an inline table,
+// so target the subtable, or report the inline-table line to edit in place.
+// A table defined at the root through dotted keys (`s.k = v`) or an inline
+// table (`s = { ... }`) cannot also get a [s] header, so keep editing it there.
+function resolve(lines, key, sep, section) {
+  if (section && sep === "=" && rangeForSection(lines, section) === null) {
+    const [, end] = rangeForSection(lines, null);
+    for (let i = 0; i < end; i++) {
+      const k = entryKey(lines[i], sep) || "";
+      if (k.startsWith(`${section}.`)) return { key: `${section}.${key}`, section: null };
+      if (k === section && (entryValue(lines[i], sep) || "").startsWith("{")) return { key, section: null, inline: i, head: section };
+    }
+  }
+  if (section && sep === "=" && key.includes(".")) {
+    const dot = key.indexOf(".");
+    const head = key.slice(0, dot), rest = key.slice(dot + 1);
+    const sub = `${section}.${head}`;
+    if (rangeForSection(lines, sub) !== null) return { key: rest, section: sub };
+    const range = rangeForSection(lines, section);
+    if (range !== null) {
+      const i = indexOfKey(lines, range, head, sep);
+      if (i >= 0 && (entryValue(lines[i], sep) || "").startsWith("{")) return { key: rest, section, inline: i, head };
+    }
+  }
+  return { key, section };
+}
+
+function inlinePairs(line) {
+  const v = entryValue(line, "=");
+  const body = v.slice(1, v.endsWith("}") ? -1 : undefined).trim();
+  return body === "" ? [] : body.split(",").map(p => p.trim()).filter(Boolean);
+}
+
+function inlineLine(line, head, pairs) {
+  const indent = line.match(/^\s*/)[0];
+  return `${indent}${head} = {${pairs.length ? ` ${pairs.join(", ")} ` : ""}}`;
+}
+
 function indexOfFirstSection(lines) {
   for (let i = 0; i < lines.length; i++) if (SECTION.test(lines[i])) return i;
   return -1;
@@ -36,35 +114,49 @@ function indexOfFirstSection(lines) {
 
 export function readKey(text, key, opts = {}) {
   const sep = opts.sep || "=";
-  const section = opts.section || null;
-  const lines = text.split(/\r?\n/);
-  const range = rangeForSection(lines, section);
+  const lines = scanView(text.split(/\r?\n/));
+  const r = resolve(lines, key, sep, opts.section || null);
+  if (r.inline !== undefined) {
+    const pair = inlinePairs(lines[r.inline]).find(p => entryKey(p, sep) === r.key);
+    return pair ? entryValue(pair, sep) : null;
+  }
+  const range = rangeForSection(lines, r.section);
   if (range === null) return null;
-  const i = indexOfKey(lines, range, key, sep);
-  if (i < 0) return null;
-  const re = sep === ":" ? /^\s*[A-Za-z0-9_.\-]+\s*:\s*(.*?)\s*$/ : /^\s*[A-Za-z0-9_.\-]+\s*=\s*(.*?)\s*$/;
-  const m = lines[i].match(re);
-  return m ? m[1] : null;
+  const i = indexOfKey(lines, range, r.key, sep);
+  return i < 0 ? null : entryValue(lines[i], sep);
 }
 
 export function setKey(text, key, valueLine, opts = {}) {
   const sep = opts.sep || "=";
-  const section = opts.section || null;
   const trailing = text.endsWith("\n") || text === "";
   const lines = text === "" ? [] : text.replace(/\r?\n$/, "").split(/\r?\n/);
-  let range = rangeForSection(lines, section);
+  const scan = scanView(lines);
+  const r = resolve(scan, key, sep, opts.section || null);
+  const section = r.section;
+  if (r.key !== key) valueLine = r.key + valueLine.slice(key.length);
+  if (r.inline !== undefined) {
+    const pairs = inlinePairs(lines[r.inline]);
+    const at = pairs.findIndex(p => entryKey(p, sep) === r.key);
+    if (at >= 0) pairs[at] = valueLine; else pairs.push(valueLine);
+    lines[r.inline] = inlineLine(lines[r.inline], r.head, pairs);
+    return lines.join("\n") + "\n";
+  }
+  key = r.key;
+  let range = rangeForSection(scan, section);
   if (range === null) {
     if (lines.length && lines[lines.length - 1] !== "") lines.push("");
     lines.push(`[${section}]`, valueLine);
   } else {
-    const idx = indexOfKey(lines, range, key, sep);
+    const idx = indexOfKey(scan, range, key, sep);
     if (idx >= 0) {
       lines[idx] = valueLine;
     } else if (section) {
       lines.splice(range[0], 0, valueLine);
     } else {
-      const firstSec = indexOfFirstSection(lines);
+      const firstSec = indexOfFirstSection(scan);
+      // Reuse the blank line that already separates the root keys from the first table.
       if (firstSec < 0) lines.push(valueLine);
+      else if (firstSec > 0 && lines[firstSec - 1] === "") lines.splice(firstSec - 1, 0, valueLine);
       else lines.splice(firstSec, 0, valueLine, "");
     }
   }
@@ -73,12 +165,20 @@ export function setKey(text, key, valueLine, opts = {}) {
 
 export function removeKey(text, key, opts = {}) {
   const sep = opts.sep || "=";
-  const section = opts.section || null;
   const trailing = text.endsWith("\n");
   const lines = text === "" ? [] : text.replace(/\r?\n$/, "").split(/\r?\n/);
-  const range = rangeForSection(lines, section);
+  const scan = scanView(lines);
+  const r = resolve(scan, key, sep, opts.section || null);
+  if (r.inline !== undefined) {
+    const pairs = inlinePairs(lines[r.inline]);
+    const kept = pairs.filter(p => entryKey(p, sep) !== r.key);
+    if (kept.length === pairs.length) return { text, removed: false };
+    lines[r.inline] = inlineLine(lines[r.inline], r.head, kept);
+    return { text: lines.join("\n") + (trailing ? "\n" : ""), removed: true };
+  }
+  const range = rangeForSection(scan, r.section);
   if (range === null) return { text, removed: false };
-  const idx = indexOfKey(lines, range, key, sep);
+  const idx = indexOfKey(scan, range, r.key, sep);
   if (idx < 0) return { text, removed: false };
   lines.splice(idx, 1);
   if (idx < lines.length && lines[idx] === "") lines.splice(idx, 1);