skillwiki 0.9.63 → 0.10.0

package/dist/chunk-IZABIE44.js

@@ -0,0 +1,647 @@
+#!/usr/bin/env node
+import {
+  MetaSchema,
+  TypedKnowledgeSchema,
+  detectSchema,
+  err,
+  getErrorMessage,
+  ok
+} from "./chunk-C5OLZRRM.js";
+
+// src/utils/index-projection.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/utils/atomic-write.ts
+import { randomBytes } from "crypto";
+import { open, readFile, rename, unlink } from "fs/promises";
+import { basename, dirname, join } from "path";
+async function readExisting(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function atomicWriteText(path, text) {
+  let existing;
+  try {
+    existing = await readExisting(path);
+  } catch (error) {
+    return err("WRITE_FAILED", { path, phase: "read-existing", message: String(error) });
+  }
+  if (existing === text) return ok({ changed: false, existed: true });
+  const tmp = join(
+    dirname(path),
+    `.${basename(path)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`
+  );
+  try {
+    const handle = await open(tmp, "wx");
+    try {
+      await handle.writeFile(text, "utf8");
+      try {
+        await handle.sync();
+      } catch {
+      }
+    } finally {
+      await handle.close();
+    }
+    await rename(tmp, path);
+    return ok({ changed: true, existed: existing !== null });
+  } catch (error) {
+    try {
+      await unlink(tmp);
+    } catch {
+    }
+    return err("WRITE_FAILED", { path, phase: "atomic-write", message: String(error) });
+  }
+}
+
+// src/utils/typed-page.ts
+import { lstatSync, realpathSync } from "fs";
+import { dirname as dirname2, posix, relative, resolve, sep } from "path";
+
+// src/parsers/frontmatter.ts
+import yaml from "js-yaml";
+var FM_OPEN = /^---\r?\n/;
+function splitFrontmatter(text) {
+  if (!FM_OPEN.test(text)) return ok({ rawFrontmatter: "", body: text, bodyStart: 0 });
+  const afterOpen = text.replace(FM_OPEN, "");
+  const closeIdx = afterOpen.search(/\r?\n---\r?\n/);
+  if (closeIdx === -1) return err("MISSING_CLOSING_DELIMITER");
+  const rawFrontmatter = afterOpen.slice(0, closeIdx);
+  const closeMatch = afterOpen.slice(closeIdx).match(/\r?\n---\r?\n/);
+  const bodyStart = text.length - (afterOpen.length - closeIdx - closeMatch[0].length);
+  const body = text.slice(bodyStart);
+  return ok({ rawFrontmatter, body, bodyStart });
+}
+function extractFrontmatter(text) {
+  const split = splitFrontmatter(text);
+  if (!split.ok) return split;
+  if (!split.data.rawFrontmatter) return ok({});
+  try {
+    const parsed = yaml.load(split.data.rawFrontmatter, { schema: yaml.JSON_SCHEMA });
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return ok({});
+    return ok(parsed);
+  } catch (e) {
+    return err("INVALID_FRONTMATTER", { message: getErrorMessage(e) });
+  }
+}
+
+// src/utils/sensitive-content.ts
+import { createHash } from "crypto";
+var REDACTED_RE = /\[REDACTED:[^\]]+\]/i;
+var SYNTHETIC_RE = /^(?:<[^>]+>|\$\{[^}]+\}|REPLACE_WITH_[A-Z0-9_]+|YOUR_[A-Z0-9_]+|EXAMPLE_[A-Z0-9_]+)$/i;
+var MATCHERS = [
+  {
+    kind: "private_key",
+    re: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g
+  },
+  {
+    kind: "authorization_header",
+    re: /\bAuthorization["']?\s*:\s*["']?(Bearer\s+[A-Za-z0-9._~+/-]{20,})["']?/gi,
+    valueGroup: 1
+  },
+  {
+    kind: "cookie",
+    re: /\b(?:Cookie|Set-Cookie)\s*:\s*([^\n]{20,})/gi,
+    valueGroup: 1
+  },
+  {
+    kind: "jwt",
+    re: /\b([A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{12,}\.[A-Za-z0-9_-]{12,})\b/g,
+    valueGroup: 1
+  },
+  {
+    kind: "provider_key",
+    re: /\b(sk-[A-Za-z0-9_-]{20,}|xox[baprs]-[A-Za-z0-9-]{20,}|gh[pousr]_[A-Za-z0-9_=-]{20,})\b/g,
+    valueGroup: 1
+  },
+  {
+    kind: "access_key",
+    re: /\b((?:AKIA|ASIA)[A-Z0-9]{16})\b/g,
+    valueGroup: 1
+  },
+  {
+    kind: "access_key",
+    re: /\b(?:access[-_ ]?key|credential)["']?\s*[:=]\s*["']?([A-Za-z0-9._~+/-]{20,})["']?/gi,
+    valueGroup: 1
+  },
+  {
+    kind: "api_key",
+    re: /\b(?:api[-_ ]?key)["']?\s*[:=]\s*["']?([A-Za-z0-9._~+/-]{20,})["']?/gi,
+    valueGroup: 1
+  },
+  {
+    kind: "password",
+    re: /\b(?:pass(?:word|wd)?)["']?\s*[:=]\s*["']?([^\s`"']{8,})["']?/gi,
+    valueGroup: 1
+  },
+  {
+    kind: "secret",
+    re: /\b(?:secret|client[-_ ]?secret)["']?\s*[:=]\s*["']?([A-Za-z0-9._~+/-]{16,})["']?/gi,
+    valueGroup: 1
+  },
+  {
+    kind: "token",
+    re: /\b(?:token|session)["']?\s*[:=]\s*["']?([A-Za-z0-9._~+/-]{16,})["']?/gi,
+    valueGroup: 1
+  }
+];
+function fingerprint(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function lineFor(text, offset) {
+  return text.slice(0, offset).split(/\r?\n/).length;
+}
+function redactMarker(kind, value) {
+  return `[REDACTED:${kind}:${fingerprint(value)}]`;
+}
+function isSyntheticPlaceholder(value) {
+  return REDACTED_RE.test(value) || SYNTHETIC_RE.test(value.trim());
+}
+function collectMatches(text) {
+  const matches = [];
+  for (const matcher of MATCHERS) {
+    matcher.re.lastIndex = 0;
+    for (const m of text.matchAll(matcher.re)) {
+      const whole = m[0];
+      const start = m.index ?? 0;
+      if (REDACTED_RE.test(whole)) continue;
+      const value = matcher.valueGroup ? m[matcher.valueGroup] : whole;
+      if (isSyntheticPlaceholder(value)) continue;
+      const valueOffset = whole.lastIndexOf(value);
+      const valueStart = start + Math.max(0, valueOffset);
+      matches.push({
+        start,
+        end: start + whole.length,
+        valueStart,
+        valueEnd: valueStart + value.length,
+        kind: matcher.kind
+      });
+    }
+  }
+  return matches.sort((a, b) => {
+    if (a.valueStart !== b.valueStart) return a.valueStart - b.valueStart;
+    return b.valueEnd - b.valueStart - (a.valueEnd - a.valueStart);
+  });
+}
+function collapseOverlaps(matches) {
+  const kept = [];
+  for (const match of matches) {
+    const overlaps = kept.some((k) => match.valueStart < k.valueEnd && match.valueEnd > k.valueStart);
+    if (!overlaps) kept.push(match);
+  }
+  return kept;
+}
+function scanSensitiveContent(text, opts = {}) {
+  return collapseOverlaps(collectMatches(text)).map((match) => {
+    const value = text.slice(match.valueStart, match.valueEnd);
+    const marker = redactMarker(match.kind, value);
+    const rawPreview = text.slice(Math.max(0, match.start - 24), Math.min(text.length, match.end + 24));
+    const preview = rawPreview.replace(value, marker);
+    return {
+      file: opts.file,
+      line: lineFor(text, match.valueStart),
+      kind: match.kind,
+      preview,
+      fingerprint: fingerprint(value)
+    };
+  });
+}
+function redactSensitiveContent(text, opts = {}) {
+  const matches = collapseOverlaps(collectMatches(text));
+  if (matches.length === 0) return { text, changed: false, findings: [] };
+  let out = "";
+  let cursor = 0;
+  for (const match of matches) {
+    const value = text.slice(match.valueStart, match.valueEnd);
+    out += text.slice(cursor, match.valueStart);
+    out += redactMarker(match.kind, value);
+    cursor = match.valueEnd;
+  }
+  out += text.slice(cursor);
+  return {
+    text: out,
+    changed: out !== text,
+    findings: scanSensitiveContent(text, opts)
+  };
+}
+
+// src/utils/typed-page.ts
+var TYPE_DIRECTORY = {
+  entity: "entities",
+  concept: "concepts",
+  comparison: "comparisons",
+  query: "queries",
+  meta: "meta"
+};
+function validateTypedTarget(target) {
+  const segments = target.split("/");
+  if (target.length === 0 || posix.isAbsolute(target) || target.includes("\\") || posix.normalize(target) !== target || segments.some((segment) => segment === "" || segment === "." || segment === "..") || !/^(entities|concepts|comparisons|queries|meta)\/[a-z0-9][a-z0-9._/-]*\.md$/.test(target)) {
+    return err("VAULT_PATH_INVALID", { target, message: "unsafe typed-page target" });
+  }
+  return ok(target);
+}
+function assertTargetInsideVault(vault, target) {
+  const validated = validateTypedTarget(target);
+  if (!validated.ok) return validated;
+  let vaultReal;
+  try {
+    vaultReal = realpathSync(vault);
+  } catch {
+    return err("VAULT_PATH_INVALID", { target, message: "vault realpath failed" });
+  }
+  const absolutePath = resolve(vaultReal, target);
+  const parent = dirname2(absolutePath);
+  let parentReal;
+  try {
+    parentReal = realpathSync(parent);
+  } catch {
+    return err("VAULT_PATH_INVALID", { target, message: "target parent realpath failed" });
+  }
+  const parentRelative = relative(vaultReal, parentReal).split(sep).join("/");
+  if (parentRelative === ".." || parentRelative.startsWith("../")) {
+    return err("VAULT_PATH_INVALID", { target, message: "target parent escapes vault" });
+  }
+  if (parentReal !== parent) {
+    return err("VAULT_PATH_INVALID", { target, message: "target parent may not be a symlink alias" });
+  }
+  let existingRealPath;
+  try {
+    const targetStat = lstatSync(absolutePath);
+    if (targetStat.isSymbolicLink()) {
+      return err("VAULT_PATH_INVALID", { target, message: "target may not be a symlink" });
+    }
+    if (!targetStat.isFile()) {
+      return err("VAULT_PATH_INVALID", { target, message: "existing target must be a regular file" });
+    }
+    try {
+      existingRealPath = realpathSync(absolutePath);
+    } catch {
+      return err("VAULT_PATH_INVALID", { target, message: "target realpath failed" });
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      return err("VAULT_PATH_INVALID", { target, message: "target lstat failed" });
+    }
+  }
+  return ok({ absolutePath, existingRealPath });
+}
+function invalidFrontmatter(target, issues) {
+  return err("INVALID_FRONTMATTER", {
+    target,
+    errors: issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }))
+  });
+}
+function prepareTypedPage(content, target) {
+  const safeTarget = validateTypedTarget(target);
+  if (!safeTarget.ok) return safeTarget;
+  const sensitive = scanSensitiveContent(content, { file: target });
+  if (sensitive.length > 0) {
+    return err("SENSITIVE_CONTENT_DETECTED", { file: target, findings: sensitive });
+  }
+  const frontmatter = extractFrontmatter(content);
+  if (!frontmatter.ok) return frontmatter;
+  const detected = detectSchema(frontmatter.data);
+  if (detected.schema === "typed-knowledge") {
+    const parsed = TypedKnowledgeSchema.safeParse(frontmatter.data);
+    if (!parsed.success) return invalidFrontmatter(target, parsed.error.issues);
+    const expectedDirectory = TYPE_DIRECTORY[parsed.data.type];
+    if (!expectedDirectory || !target.startsWith(`${expectedDirectory}/`)) {
+      return err("SCHEME_REJECTED", { target, type: parsed.data.type, message: "frontmatter type does not match target directory" });
+    }
+    return ok({
+      target,
+      title: parsed.data.title,
+      type: parsed.data.type,
+      tags: [...parsed.data.tags],
+      content
+    });
+  }
+  if (detected.schema === "meta") {
+    const parsed = MetaSchema.safeParse(frontmatter.data);
+    if (!parsed.success) return invalidFrontmatter(target, parsed.error.issues);
+    if (!target.startsWith("meta/")) {
+      return err("SCHEME_REJECTED", { target, type: "meta", message: "frontmatter type does not match target directory" });
+    }
+    return ok({
+      target,
+      title: parsed.data.title,
+      type: "meta",
+      tags: [...parsed.data.tags],
+      content
+    });
+  }
+  return invalidFrontmatter(target, []);
+}
+
+// src/utils/vault.ts
+import { existsSync, readFileSync } from "fs";
+import { readFile as readFile2, readdir, stat } from "fs/promises";
+import { join as join2, relative as relative2, sep as sep2 } from "path";
+var TYPED_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+var DEFAULT_IO_CONCURRENCY = 1;
+function vaultIoConcurrency() {
+  const raw = Number.parseInt(process.env.SKILLWIKI_VAULT_IO_CONCURRENCY ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? Math.min(raw, 64) : DEFAULT_IO_CONCURRENCY;
+}
+function decodeProcMountPath(value) {
+  return value.replace(/\\040/g, " ");
+}
+function isRcloneFuseVaultFromMounts(root, mounts) {
+  return mounts.split(/\r?\n/).some((line) => {
+    const parts = line.split(" ");
+    if (parts.length < 3) return false;
+    const mountPoint = decodeProcMountPath(parts[1]);
+    const fsType = parts[2];
+    return fsType === "fuse.rclone" && (root === mountPoint || root.startsWith(`${mountPoint}/`));
+  });
+}
+function resolveReadOnlyVaultRootWithMounts(root, mounts) {
+  if (/^(1|true|yes)$/i.test(process.env.SKILLWIKI_DISABLE_VAULT_READ_MIRROR ?? "")) {
+    return { root, mirrored: false };
+  }
+  const explicitMirror = process.env.SKILLWIKI_VAULT_READ_MIRROR;
+  if (explicitMirror && existsSync(join2(explicitMirror, "SCHEMA.md"))) {
+    return { root: explicitMirror, mirrored: explicitMirror !== root };
+  }
+  const siblingMirror = `${root}-git`;
+  if (isRcloneFuseVaultFromMounts(root, mounts) && existsSync(join2(siblingMirror, "SCHEMA.md"))) {
+    return { root: siblingMirror, mirrored: true };
+  }
+  return { root, mirrored: false };
+}
+function resolveReadOnlyVaultRoot(root) {
+  let mounts = "";
+  try {
+    mounts = readFileSync("/proc/mounts", "utf8");
+  } catch {
+  }
+  return resolveReadOnlyVaultRootWithMounts(root, mounts);
+}
+async function mapWithConcurrency(items, limit, mapper) {
+  const out = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(Math.max(1, limit), items.length) }, async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      out[index] = await mapper(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+async function scanVault(root) {
+  try {
+    await stat(join2(root, "SCHEMA.md"));
+  } catch {
+    return err("VAULT_PATH_INVALID", { root, reason: "SCHEMA.md missing" });
+  }
+  const all = await walk(root);
+  const rels = all.map((p) => ({ absPath: p, relPath: relative2(root, p).split(sep2).join("/") }));
+  return ok({
+    root,
+    allMarkdown: rels,
+    typedKnowledge: rels.filter((p) => TYPED_DIRS.some((d) => p.relPath.startsWith(d + "/"))),
+    raw: rels.filter((p) => p.relPath.startsWith("raw/")),
+    workItems: rels.filter((p) => /^projects\/[^/]+\/work\/[^/]+\/(spec|plan|log)\.md$/.test(p.relPath)),
+    compound: rels.filter((p) => /^projects\/[^/]+\/compound\//.test(p.relPath))
+  });
+}
+async function walk(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const out = [];
+  const subdirs = [];
+  for (const e of entries) {
+    const p = join2(dir, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name)) continue;
+      subdirs.push(p);
+    } else if (e.isFile() && e.name.endsWith(".md")) out.push(p);
+  }
+  const nested = await mapWithConcurrency(subdirs, Math.min(8, vaultIoConcurrency()), walk);
+  for (const files of nested) out.push(...files);
+  return out;
+}
+async function readPage(p) {
+  return readFile2(p.absPath, "utf8");
+}
+async function readPageCached(p, cache) {
+  if (!cache) return readPage(p);
+  const existing = cache.get(p.absPath);
+  if (existing) return existing;
+  const pending = readPage(p);
+  cache.set(p.absPath, pending);
+  return pending;
+}
+
+// src/utils/index-projection.ts
+var SECTION_ORDER = ["Entities", "Concepts", "Comparisons", "Queries", "Meta", "Projects"];
+var TYPE_SECTION = {
+  entity: "Entities",
+  concept: "Concepts",
+  comparison: "Comparisons",
+  query: "Queries",
+  meta: "Meta"
+};
+var compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var UNMANAGED_START = "<!-- skillwiki:index-unmanaged:start -->";
+var UNMANAGED_END = "<!-- skillwiki:index-unmanaged:end -->";
+function extractUnmanaged(currentText) {
+  const startCount = currentText.split(UNMANAGED_START).length - 1;
+  const endCount = currentText.split(UNMANAGED_END).length - 1;
+  if (startCount === 0 && endCount === 0) return ok("");
+  if (startCount !== 1 || endCount !== 1) {
+    return err("SCHEME_REJECTED", {
+      message: "index.md must contain exactly one complete unmanaged marker pair"
+    });
+  }
+  const start = currentText.indexOf(UNMANAGED_START);
+  const end = currentText.indexOf(UNMANAGED_END);
+  if (start < 0 || end < 0 || end < start) {
+    return err("SCHEME_REJECTED", {
+      message: "unmanaged marker pair is reversed or incomplete"
+    });
+  }
+  const body = currentText.slice(start + UNMANAGED_START.length, end).replace(/^\n/, "").replace(/\n$/, "");
+  return ok(body);
+}
+function priorWikilinkTargets(text) {
+  const out = [];
+  const re = /\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    out.push(m[1].trim().replace(/\.md$/, ""));
+  }
+  return out;
+}
+function projectTitleFromReadme(text, slug) {
+  const m = text.match(/^#\s+Project:\s+(.+)$/m);
+  return m?.[1]?.trim() || slug;
+}
+async function renderRootIndex(input) {
+  const vault = input.vault;
+  let currentText = input.currentText;
+  if (currentText === void 0) {
+    try {
+      currentText = await readFile3(join3(vault, "index.md"), "utf8");
+    } catch {
+      currentText = "";
+    }
+  }
+  const unmanaged = extractUnmanaged(currentText);
+  if (!unmanaged.ok) return unmanaged;
+  const scan = await scanVault(vault);
+  if (!scan.ok) return scan;
+  const entries = [];
+  const seen = /* @__PURE__ */ new Map();
+  let duplicatesRemoved = 0;
+  for (const page of scan.data.typedKnowledge) {
+    let text;
+    try {
+      text = await readFile3(join3(vault, page.relPath), "utf8");
+    } catch {
+      continue;
+    }
+    const prepared = prepareTypedPage(text, page.relPath);
+    if (!prepared.ok) continue;
+    const section = TYPE_SECTION[prepared.data.type];
+    if (!section) continue;
+    const target = prepared.data.target.replace(/\.md$/, "");
+    const prev = seen.get(target);
+    if (prev !== void 0) {
+      if (prev !== prepared.data.title) {
+        return err("SCHEME_REJECTED", {
+          message: `duplicate index target ${target} with differing titles`,
+          titles: [prev, prepared.data.title]
+        });
+      }
+      duplicatesRemoved += 1;
+      continue;
+    }
+    seen.set(target, prepared.data.title);
+    entries.push({
+      section,
+      target,
+      title: prepared.data.title,
+      source: "typed"
+    });
+  }
+  try {
+    const projectsRoot = join3(vault, "projects");
+    for (const slug of readdirSync(projectsRoot, { withFileTypes: true })) {
+      if (!slug.isDirectory()) continue;
+      const readmePath = join3(projectsRoot, slug.name, "README.md");
+      let text;
+      try {
+        text = readFileSync2(readmePath, "utf8");
+      } catch {
+        continue;
+      }
+      const target = `projects/${slug.name}/README`;
+      const title = projectTitleFromReadme(text, slug.name);
+      const prev = seen.get(target);
+      if (prev !== void 0) {
+        if (prev !== title) {
+          return err("SCHEME_REJECTED", {
+            message: `duplicate index target ${target} with differing titles`
+          });
+        }
+        duplicatesRemoved += 1;
+        continue;
+      }
+      seen.set(target, title);
+      entries.push({ section: "Projects", target, title, source: "project" });
+    }
+  } catch {
+  }
+  entries.sort((a, b) => {
+    const sa = SECTION_ORDER.indexOf(a.section);
+    const sb = SECTION_ORDER.indexOf(b.section);
+    if (sa !== sb) return sa - sb;
+    return compareText(a.target, b.target);
+  });
+  const prior = priorWikilinkTargets(currentText);
+  const generatedTargets = new Set(entries.map((e) => e.target));
+  const priorLower = /* @__PURE__ */ new Map();
+  for (const t of prior) {
+    const k = t.toLowerCase();
+    priorLower.set(k, (priorLower.get(k) ?? 0) + 1);
+  }
+  for (const count of priorLower.values()) {
+    if (count > 1) duplicatesRemoved += count - 1;
+  }
+  const headingDupes = (currentText.match(/^##\s+(entities|concepts|comparisons|queries|meta|projects)\s*$/gim) ?? []).map((h) => h.replace(/^##\s+/i, "").trim().toLowerCase());
+  const headingCounts = /* @__PURE__ */ new Map();
+  for (const h of headingDupes) headingCounts.set(h, (headingCounts.get(h) ?? 0) + 1);
+  for (const c of headingCounts.values()) {
+    if (c > 1) duplicatesRemoved += c - 1;
+  }
+  const ghostsRemoved = [
+    ...new Set(
+      prior.filter((t) => {
+        const bare = t.includes("/") ? t : null;
+        if (bare && !generatedTargets.has(bare) && !generatedTargets.has(t)) {
+          if (!seen.has(t)) return true;
+        }
+        if (!t.includes("/")) {
+          const matches = [...generatedTargets].filter((g) => g.split("/").pop() === t);
+          return matches.length === 0;
+        }
+        return !generatedTargets.has(t);
+      })
+    )
+  ];
+  const lines = [
+    "# Vault Index",
+    "",
+    "Generated by `skillwiki index rebuild`. Generated sections are derived from typed-page frontmatter and project manifests.",
+    ""
+  ];
+  for (const section of SECTION_ORDER) {
+    lines.push(`## ${section}`, "");
+    const sectionEntries = entries.filter((e) => e.section === section);
+    for (const e of sectionEntries) {
+      lines.push(`- [[${e.target}]] \u2014 ${e.title}`);
+    }
+    if (sectionEntries.length > 0) lines.push("");
+  }
+  lines.push(UNMANAGED_START);
+  if (unmanaged.data) {
+    lines.push(unmanaged.data);
+  }
+  lines.push(UNMANAGED_END);
+  lines.push("");
+  return ok({
+    text: lines.join("\n"),
+    entries,
+    duplicates_removed: duplicatesRemoved,
+    ghosts_removed: ghostsRemoved
+  });
+}
+async function writeRootIndexProjection(vault, projection) {
+  return atomicWriteText(join3(vault, "index.md"), projection.text);
+}
+
+export {
+  splitFrontmatter,
+  extractFrontmatter,
+  scanSensitiveContent,
+  redactSensitiveContent,
+  atomicWriteText,
+  assertTargetInsideVault,
+  prepareTypedPage,
+  vaultIoConcurrency,
+  resolveReadOnlyVaultRoot,
+  mapWithConcurrency,
+  scanVault,
+  readPage,
+  readPageCached,
+  renderRootIndex,
+  writeRootIndexProjection
+};