skillwiki 0.10.21 → 0.10.23

package/dist/chunk-QNTBNNEL.js

@@ -0,0 +1,616 @@
+#!/usr/bin/env node
+import {
+  extractFrontmatter,
+  readPage,
+  scanSensitiveContent,
+  splitFrontmatter
+} from "./chunk-6ZDKTNLA.js";
+import {
+  err,
+  ok
+} from "./chunk-C2DKFJFA.js";
+
+// src/utils/log-events.ts
+import { mkdir, open, readFile, readdir } from "fs/promises";
+import { join } from "path";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const key of Object.keys(value).sort()) {
+    out[key] = canonicalize(value[key]);
+  }
+  return out;
+}
+function eventPathFor(event) {
+  const day = event.occurred_at.slice(0, 10);
+  return `meta/log-events/${day}/${event.operation_id}.json`;
+}
+function validateLogEvent(event) {
+  if (event.schema !== "skillwiki-log-event/v1") {
+    return err("SCHEME_REJECTED", { message: "invalid event schema" });
+  }
+  if (!/^[0-9a-f]{64}$/.test(event.operation_id)) {
+    return err("SCHEME_REJECTED", { message: "operation_id must be 64 hex chars" });
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(event.occurred_at)) {
+    return err("SCHEME_REJECTED", { message: "occurred_at must be UTC ISO with milliseconds" });
+  }
+  for (const field of ["host_id", "actor", "kind", "target", "note"]) {
+    const v = event[field];
+    if (typeof v !== "string" || v.trim().length === 0 || v.length > 500) {
+      return err("SCHEME_REJECTED", { message: `invalid ${field}` });
+    }
+  }
+  if (!isPlainObject(event.metadata)) {
+    return err("SCHEME_REJECTED", { message: "metadata must be a plain object" });
+  }
+  const sensitive = scanSensitiveContent(JSON.stringify(event));
+  if (sensitive.length > 0) {
+    return err("SENSITIVE_CONTENT_DETECTED", { findings: sensitive });
+  }
+  return ok({
+    schema: "skillwiki-log-event/v1",
+    operation_id: event.operation_id,
+    occurred_at: event.occurred_at,
+    host_id: event.host_id,
+    actor: event.actor,
+    kind: event.kind,
+    target: event.target,
+    note: event.note,
+    metadata: canonicalize(event.metadata)
+  });
+}
+function canonicalEventJson(event) {
+  const ordered = {
+    schema: event.schema,
+    operation_id: event.operation_id,
+    occurred_at: event.occurred_at,
+    host_id: event.host_id,
+    actor: event.actor,
+    kind: event.kind,
+    target: event.target,
+    note: event.note,
+    metadata: event.metadata
+  };
+  return `${JSON.stringify(ordered, null, 2)}
+`;
+}
+async function writeLogEvent(vault, event) {
+  const validated = validateLogEvent(event);
+  if (!validated.ok) return validated;
+  const rel = eventPathFor(validated.data);
+  const abs = join(vault, rel);
+  await mkdir(join(vault, "meta", "log-events", validated.data.occurred_at.slice(0, 10)), {
+    recursive: true
+  });
+  const body = canonicalEventJson(validated.data);
+  try {
+    const handle = await open(abs, "wx");
+    try {
+      await handle.writeFile(body, "utf8");
+    } finally {
+      await handle.close();
+    }
+    return ok({ path: rel, created: true });
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      let existing;
+      try {
+        existing = await readFile(abs, "utf8");
+      } catch (readErr) {
+        return err("WRITE_FAILED", { path: rel, message: String(readErr) });
+      }
+      if (existing === body) return ok({ path: rel, created: false });
+      return err("EVENT_IDENTITY_COLLISION", { path: rel });
+    }
+    return err("WRITE_FAILED", { path: rel, message: String(error) });
+  }
+}
+async function readLogEvents(vault) {
+  const root = join(vault, "meta", "log-events");
+  let days;
+  try {
+    days = (await readdir(root, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    return ok([]);
+  }
+  const events = [];
+  for (const day of days) {
+    const files = (await readdir(join(root, day))).filter((f) => f.endsWith(".json")).sort();
+    for (const file of files) {
+      const text = await readFile(join(root, day, file), "utf8");
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        return err("SCHEME_REJECTED", { path: `meta/log-events/${day}/${file}`, message: "invalid JSON" });
+      }
+      const validated = validateLogEvent(parsed);
+      if (!validated.ok) return validated;
+      if (eventPathFor(validated.data) !== `meta/log-events/${day}/${file}`) {
+        return err("SCHEME_REJECTED", {
+          path: `meta/log-events/${day}/${file}`,
+          message: "path/identity mismatch"
+        });
+      }
+      events.push(validated.data);
+    }
+  }
+  events.sort((a, b) => {
+    if (a.occurred_at !== b.occurred_at) return a.occurred_at < b.occurred_at ? -1 : 1;
+    return a.operation_id < b.operation_id ? -1 : a.operation_id > b.operation_id ? 1 : 0;
+  });
+  return ok(events);
+}
+
+// src/parsers/citations.ts
+var FENCE = /```[\s\S]*?```/g;
+var INLINE_CODE = /``[^`\n]+``|`[^`\n]+`/g;
+var MARKER_RE = /\^\[(raw\/[^\]]+)\]/g;
+var FRONTMATTER = /^---\n[\s\S]*?\n---\n?/;
+function stripFences(body) {
+  return body.replace(FENCE, "").replace(INLINE_CODE, "");
+}
+var TILDE_FENCE = /~~~[\s\S]*?~~~/g;
+function stripFencedBlocks(body) {
+  return body.replace(FENCE, "").replace(TILDE_FENCE, "");
+}
+function extractCitationMarkers(body) {
+  const stripped = stripFences(body);
+  const out = [];
+  let m;
+  while ((m = MARKER_RE.exec(stripped)) !== null) {
+    if (m[1] === "raw/...") continue;
+    out.push({ marker: m[0], target: m[1] });
+  }
+  return out;
+}
+function hasSourcesFooter(body) {
+  return /^## Sources\s*$/m.test(stripFencedBlocks(body));
+}
+function isLegacyCitationStyle(body) {
+  const markers = extractCitationMarkers(body);
+  if (markers.length === 0) return false;
+  if (!hasSourcesFooter(body)) return true;
+  const lines = stripFences(body.replace(FRONTMATTER, "")).split("\n");
+  let inSources = false;
+  let lastNonBlankWasTable = false;
+  for (const line of lines) {
+    if (/^## Sources\b/.test(line.trim())) {
+      inSources = true;
+      continue;
+    }
+    if (inSources) continue;
+    const matches = [...line.matchAll(MARKER_RE)];
+    if (matches.length === 0) {
+      if (line.trim().length > 0) lastNonBlankWasTable = /^\|/.test(line.trim());
+      continue;
+    }
+    const markerOnly = line.replace(MARKER_RE, "").trim();
+    if (markerOnly.length === 0 && !lastNonBlankWasTable) return true;
+    lastNonBlankWasTable = false;
+    const lastMatch = matches[matches.length - 1];
+    const afterLast = line.slice(lastMatch.index + lastMatch[0].length).replace(MARKER_RE, "").trim();
+    if (afterLast.length > 0) return true;
+    const beforeFirst = line.slice(0, matches[0].index).trim();
+    if (beforeFirst.length > 0 && !/[.!?]["'"]*\s*$/.test(beforeFirst)) return true;
+  }
+  return false;
+}
+function hasOrphanedCitations(body) {
+  const noFm = body.replace(FRONTMATTER, "");
+  const stripped = stripFences(noFm);
+  const lines = stripped.split("\n");
+  const rawLines = noFm.split("\n");
+  let inSources = false;
+  let sourcesEnded = false;
+  let sourcesStartLine = -1;
+  let lastNonBlankInSources = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (/^## Sources\b/.test(trimmed)) {
+      inSources = true;
+      sourcesStartLine = i;
+      continue;
+    }
+    if (!inSources || sourcesEnded) continue;
+    if (trimmed.length === 0) {
+      if (lastNonBlankInSources >= 0) {
+        sourcesEnded = true;
+      }
+      continue;
+    }
+    const isListItem = /^\s*(?:[-*]|\d+\.)\s+/.test(line);
+    const hasMarker = /\^\[raw\//.test(line);
+    const hasBacktickRawPath = /`raw\/[^`]+`/.test(rawLines[i]);
+    if (isListItem && hasMarker) {
+      lastNonBlankInSources = i;
+    } else if (isListItem && hasBacktickRawPath) {
+      lastNonBlankInSources = i;
+    } else if (hasMarker && !isListItem) {
+      return true;
+    } else {
+      sourcesEnded = true;
+    }
+  }
+  if (sourcesStartLine === -1) return false;
+  if (sourcesEnded) {
+    const scanStart = Math.max(lastNonBlankInSources + 1, sourcesStartLine + 1);
+    for (let i = scanStart; i < lines.length; i++) {
+      if (/\^\[raw\//.test(lines[i])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasWikilinkCitations(body) {
+  const stripped = stripFences(body);
+  return /\[\[raw\/[^\]]+\]\]/.test(stripped);
+}
+
+// src/utils/source-relocations.ts
+function parse(event) {
+  if (event.kind !== "source-relocation") return ok(null);
+  const metadata = event.metadata;
+  const operation = metadata.operation;
+  const previous = metadata.previous_path;
+  const current = metadata.current_path;
+  const hash = metadata.source_sha256;
+  if (!["rename", "relocate", "archive", "deduplicate"].includes(operation)) {
+    return err("SOURCE_RELOCATION_INVALID", { operation_id: event.operation_id, field: "operation" });
+  }
+  if (typeof previous !== "string" || typeof current !== "string" || typeof hash !== "string" || !/^[0-9a-f]{64}$/.test(hash)) {
+    return err("SOURCE_RELOCATION_INVALID", { operation_id: event.operation_id, field: "metadata" });
+  }
+  return ok({
+    operation_id: event.operation_id,
+    operation,
+    previous_path: previous,
+    current_path: current,
+    source_sha256: hash,
+    occurred_at: event.occurred_at
+  });
+}
+function projectSourceRelocations(events) {
+  const out = [];
+  for (const event of events) {
+    const relocation = parse(event);
+    if (!relocation.ok) return relocation;
+    if (relocation.data) out.push(relocation.data);
+  }
+  return ok(out);
+}
+async function readSourceRelocations(vault) {
+  const events = await readLogEvents(vault);
+  if (!events.ok) return events;
+  return projectSourceRelocations(events.data);
+}
+function buildSourceRelocationProjection(relocations) {
+  const projection = /* @__PURE__ */ new Map();
+  for (const relocation of relocations) {
+    const current = projection.get(relocation.current_path) ?? relocation.current_path;
+    projection.set(relocation.previous_path, current);
+    for (const [historical, target] of projection) {
+      if (target === relocation.previous_path) projection.set(historical, current);
+    }
+  }
+  return projection;
+}
+function resolveRelocatedSource(target, projection) {
+  let current = target;
+  const seen = /* @__PURE__ */ new Set();
+  while (projection.has(current) && !seen.has(current)) {
+    seen.add(current);
+    current = projection.get(current);
+  }
+  return current;
+}
+
+// src/utils/raw-source.ts
+import { join as join2, posix, relative as relative2 } from "path";
+
+// src/utils/vault-path-safety.ts
+import { lstatSync, realpathSync } from "fs";
+import { lstat, realpath } from "fs/promises";
+import { dirname, relative, resolve, sep } from "path";
+function vaultRelative(vaultReal, candidate) {
+  return relative(vaultReal, candidate).split(sep).join("/");
+}
+function isInside(vaultReal, candidate) {
+  const rel = vaultRelative(vaultReal, candidate);
+  return rel === "" || rel !== ".." && !rel.startsWith("../");
+}
+function existingRegularFileInsideVaultSync(vault, target) {
+  try {
+    const vaultReal = realpathSync(vault);
+    const absolutePath = resolve(vaultReal, target);
+    const rel = vaultRelative(vaultReal, absolutePath);
+    if (!isInside(vaultReal, absolutePath) || rel === "") return false;
+    let current = vaultReal;
+    for (const part of rel.split("/").filter(Boolean)) {
+      current = resolve(current, part);
+      if (lstatSync(current).isSymbolicLink()) return false;
+    }
+    const info = lstatSync(absolutePath);
+    return info.isFile() && !info.isSymbolicLink() && realpathSync(absolutePath) === absolutePath;
+  } catch {
+    return false;
+  }
+}
+async function canonicalVault(vault, target) {
+  try {
+    return ok(await realpath(vault));
+  } catch (error) {
+    return err("VAULT_PATH_INVALID", { target, message: "vault realpath failed", cause: String(error) });
+  }
+}
+async function rejectSymlinkedComponents(vaultReal, absolutePath, target) {
+  const rel = vaultRelative(vaultReal, absolutePath);
+  if (!isInside(vaultReal, absolutePath) || rel === "") {
+    return err("VAULT_PATH_INVALID", { target, message: "target escapes vault" });
+  }
+  const parts = rel.split("/").filter(Boolean);
+  let current = vaultReal;
+  for (const part of parts) {
+    current = resolve(current, part);
+    try {
+      const info = await lstat(current);
+      if (info.isSymbolicLink()) {
+        return err("VAULT_PATH_INVALID", { target, message: "target path may not contain symlink aliases" });
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") break;
+      return err("VAULT_PATH_INVALID", { target, message: "target lstat failed", cause: String(error) });
+    }
+  }
+  return ok(true);
+}
+async function resolveExistingRegularFileInsideVault(vault, target) {
+  const vaultResult = await canonicalVault(vault, target);
+  if (!vaultResult.ok) return vaultResult;
+  const vaultReal = vaultResult.data;
+  const absolutePath = resolve(vaultReal, target);
+  const components = await rejectSymlinkedComponents(vaultReal, absolutePath, target);
+  if (!components.ok) return components;
+  try {
+    const info = await lstat(absolutePath);
+    if (!info.isFile() || info.isSymbolicLink()) {
+      return err("VAULT_PATH_INVALID", { target, message: "target must be a regular non-symlink file" });
+    }
+    const targetReal = await realpath(absolutePath);
+    if (!isInside(vaultReal, targetReal) || targetReal !== absolutePath) {
+      return err("VAULT_PATH_INVALID", { target, message: "target realpath escapes vault or uses an alias" });
+    }
+    return ok(absolutePath);
+  } catch (error) {
+    return err("FILE_NOT_FOUND", { path: target, message: String(error) });
+  }
+}
+async function resolveAbsentTargetInsideVault(vault, target) {
+  const vaultResult = await canonicalVault(vault, target);
+  if (!vaultResult.ok) return vaultResult;
+  const vaultReal = vaultResult.data;
+  const absolutePath = resolve(vaultReal, target);
+  const components = await rejectSymlinkedComponents(vaultReal, dirname(absolutePath), target);
+  if (!components.ok) return components;
+  try {
+    await lstat(absolutePath);
+    return err("RAW_DESTINATION_EXISTS", { path: target });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      return err("VAULT_PATH_INVALID", { target, message: "destination lstat failed", cause: String(error) });
+    }
+  }
+  return ok(absolutePath);
+}
+
+// src/utils/raw-source.ts
+function normalizeRawSourceTarget(entry) {
+  let target = entry.trim().replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
+  target = target.replace(/^\^\[/, "").replace(/\]$/, "");
+  if (!target || target.includes("\0") || target.includes("\\") || posix.isAbsolute(target)) return null;
+  if (posix.normalize(target) !== target || target.split("/").some((part) => part === "" || part === "." || part === "..")) return null;
+  if (!target.startsWith("raw/") && !target.startsWith("_archive/raw/")) return null;
+  return target;
+}
+function rawSourceTargetCandidates(vault, target) {
+  const normalized = normalizeRawSourceTarget(target);
+  if (!normalized) return [];
+  const candidates = [join2(vault, normalized)];
+  if (!normalized.endsWith(".md")) candidates.push(join2(vault, `${normalized}.md`));
+  if (normalized.startsWith("raw/")) {
+    const active = normalized.match(/^raw\/(articles|papers|transcripts)\/(.+)$/);
+    if (active) {
+      for (const lifecycle of ["archived", "duplicates"]) {
+        candidates.push(join2(vault, "raw", lifecycle, active[1], active[2]));
+        if (!normalized.endsWith(".md")) candidates.push(join2(vault, "raw", lifecycle, active[1], `${active[2]}.md`));
+      }
+      candidates.push(join2(vault, "_archive", normalized));
+      if (!normalized.endsWith(".md")) candidates.push(join2(vault, "_archive", `${normalized}.md`));
+    }
+  }
+  return [...new Set(candidates)];
+}
+function rawSourceTargetExistsSync(vault, target) {
+  return rawSourceTargetCandidates(vault, target).some(
+    (candidate) => existingRegularFileInsideVaultSync(vault, relative2(vault, candidate))
+  );
+}
+async function rawSourceTargetExists(vault, target) {
+  for (const candidate of rawSourceTargetCandidates(vault, target)) {
+    if ((await resolveExistingRegularFileInsideVault(vault, relative2(vault, candidate))).ok) return true;
+  }
+  const relocations = await readSourceRelocations(vault);
+  if (relocations.ok) {
+    const normalized = normalizeRawSourceTarget(target);
+    if (normalized) {
+      const resolved = resolveRelocatedSource(normalized.endsWith(".md") ? normalized : `${normalized}.md`, buildSourceRelocationProjection(relocations.data));
+      if (resolved !== normalized) {
+        if ((await resolveExistingRegularFileInsideVault(vault, resolved)).ok) return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/utils/operation-id.ts
+import { createHash } from "crypto";
+function operationId(namespace, parts) {
+  const hash = createHash("sha256").update(namespace).update("\0");
+  for (const part of parts) hash.update(part).update("\0");
+  return hash.digest("hex");
+}
+
+// src/utils/raw-operation-policy.ts
+import { posix as posix2 } from "path";
+var SOURCE_CATEGORIES = /* @__PURE__ */ new Set(["articles", "papers", "transcripts"]);
+function classifyRawPath(value) {
+  const path = value.replaceAll("\\", "/");
+  if (path !== posix2.normalize(path) || path.startsWith("/") || path.includes("\0") || path.split("/").includes("..")) {
+    return err("RAW_PATH_INVALID", { path: value });
+  }
+  const parts = path.split("/");
+  if (parts[0] !== "raw") return err("RAW_PATH_OUTSIDE_LAYER", { path });
+  if (parts[1] === "assets" && parts.length > 2) {
+    return ok({ path, category: "assets", storage: "asset", relativeWithinCategory: parts.slice(2).join("/") });
+  }
+  if ((parts[1] === "archived" || parts[1] === "duplicates") && SOURCE_CATEGORIES.has(parts[2] ?? "") && parts.length > 3) {
+    return ok({
+      path,
+      category: parts[2],
+      storage: parts[1] === "archived" ? "archived" : "duplicate",
+      relativeWithinCategory: parts.slice(3).join("/")
+    });
+  }
+  if (SOURCE_CATEGORIES.has(parts[1] ?? "") && parts.length > 2) {
+    return ok({
+      path,
+      category: parts[1],
+      storage: "active",
+      relativeWithinCategory: parts.slice(2).join("/")
+    });
+  }
+  return err("RAW_PATH_UNSUPPORTED", { path });
+}
+function lifecycleDestination(source, operation) {
+  const parsed = classifyRawPath(source);
+  if (!parsed.ok) return parsed;
+  if (parsed.data.category === "assets") {
+    return err("RAW_ASSET_PATH_FROZEN", { path: source, message: "asset lifecycle is logical by default" });
+  }
+  if (parsed.data.storage !== "active") return err("RAW_SOURCE_NOT_ACTIVE", { path: source, storage: parsed.data.storage });
+  if (operation === "archive") return ok(`raw/archived/${parsed.data.category}/${parsed.data.relativeWithinCategory}`);
+  if (operation === "deduplicate") return ok(`raw/duplicates/${parsed.data.category}/${parsed.data.relativeWithinCategory}`);
+  return ok(source);
+}
+function authorizeRawOperation(input) {
+  if (input.operationClass === "read") return ok(true);
+  if (input.operationClass === "rewrite") return err("RAW_REWRITE_FORBIDDEN", { source: input.source });
+  if (input.operationClass === "destructive-remove") {
+    return input.trigger === "attended-apply" && input.explicitExactTarget === true ? ok(true) : err("RAW_DISPOSAL_REQUIRES_EXACT_TARGET_APPROVAL", { source: input.source });
+  }
+  if (input.operationClass === "preserve-move") {
+    if (input.trigger === "report-only") return err("RAW_STRUCTURAL_REPORT_ONLY", { source: input.source, destination: input.destination });
+    if (!input.source || !input.destination) return err("RAW_PATH_INVALID", { source: input.source, destination: input.destination });
+    const source = classifyRawPath(input.source);
+    if (!source.ok) return source;
+    const destination = classifyRawPath(input.destination);
+    if (!destination.ok) return destination;
+    return ok(true);
+  }
+  return ok(true);
+}
+
+// src/utils/source-reference-index.ts
+function canonicalTarget(value) {
+  const normalized = normalizeRawSourceTarget(value);
+  if (!normalized) return null;
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+function referencesFromText(text) {
+  const references = /* @__PURE__ */ new Set();
+  const fm = extractFrontmatter(text);
+  if (fm.ok && Array.isArray(fm.data.sources)) {
+    for (const entry of fm.data.sources) {
+      const target = canonicalTarget(String(entry));
+      if (target) references.add(target);
+    }
+  }
+  const split = splitFrontmatter(text);
+  const body = split.ok ? split.data.body : text;
+  for (const marker of extractCitationMarkers(body)) {
+    const target = canonicalTarget(marker.target);
+    if (target) references.add(target);
+  }
+  return [...references];
+}
+async function addPages(pages, kind, available, targetMap, unresolved, relocationProjection) {
+  for (const page of pages) {
+    let text;
+    try {
+      text = await readPage(page);
+    } catch {
+      continue;
+    }
+    for (const historicalTarget of referencesFromText(text)) {
+      const target = available.has(historicalTarget) ? historicalTarget : relocationProjection?.get(historicalTarget) ?? historicalTarget;
+      if (!available.has(target)) unresolved.push({ sourcePath: page.relPath, target, kind });
+      const refs = targetMap.get(target) ?? /* @__PURE__ */ new Set();
+      refs.add(page.relPath);
+      targetMap.set(target, refs);
+    }
+  }
+}
+function freezeMap(input) {
+  return new Map(
+    [...input.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([target, refs]) => [target, [...refs].sort((a, b) => a.localeCompare(b))])
+  );
+}
+async function buildSourceReferenceIndex(input) {
+  const available = new Set(
+    [...input.availableRawPaths].map(canonicalTarget).filter((value) => value !== null)
+  );
+  const integrated = /* @__PURE__ */ new Map();
+  const elsewhere = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  await addPages(input.typedPages, "typed", available, integrated, unresolved, input.relocationProjection);
+  await addPages(input.otherPages ?? [], "other", available, elsewhere, unresolved, input.relocationProjection);
+  unresolved.sort((a, b) => a.target.localeCompare(b.target) || a.sourcePath.localeCompare(b.sourcePath));
+  return {
+    integratedBy: freezeMap(integrated),
+    referencedElsewhereBy: freezeMap(elsewhere),
+    unresolved
+  };
+}
+
+export {
+  eventPathFor,
+  validateLogEvent,
+  canonicalEventJson,
+  writeLogEvent,
+  readLogEvents,
+  stripFencedBlocks,
+  extractCitationMarkers,
+  isLegacyCitationStyle,
+  hasOrphanedCitations,
+  hasWikilinkCitations,
+  projectSourceRelocations,
+  readSourceRelocations,
+  buildSourceRelocationProjection,
+  resolveExistingRegularFileInsideVault,
+  resolveAbsentTargetInsideVault,
+  normalizeRawSourceTarget,
+  rawSourceTargetExistsSync,
+  rawSourceTargetExists,
+  operationId,
+  classifyRawPath,
+  lifecycleDestination,
+  authorizeRawOperation,
+  buildSourceReferenceIndex
+};