@riebeckite/node 0.0.34 → 0.0.36

package/dist/index.js

@@ -117,8 +117,8 @@ var FileSystemContentSource = class {
     return entries;
   }
   resolveFilePath(logicalPath) {
-    const normalizedPath = normalizeLogicalPath(logicalPath);
-    const filePath = path.resolve(this.contentDirectory, normalizedPath);
+    const normalizedPath2 = normalizeLogicalPath(logicalPath);
+    const filePath = path.resolve(this.contentDirectory, normalizedPath2);
     const relativePath = path.relative(this.contentDirectory, filePath);
     if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
       throw new Error(`Invalid content path: ${logicalPath}`);
@@ -171,11 +171,11 @@ function normalizeTemplaterTemplateFolder(value) {
   return normalized;
 }
 function normalizeLogicalPath(logicalPath) {
-  const normalizedPath = normalizeContentPath(logicalPath);
-  if (normalizedPath.length === 0 || normalizedPath.startsWith("/") || path.isAbsolute(normalizedPath) || path.win32.isAbsolute(normalizedPath) || normalizedPath.split("/").some((segment) => segment === "..")) {
+  const normalizedPath2 = normalizeContentPath(logicalPath);
+  if (normalizedPath2.length === 0 || normalizedPath2.startsWith("/") || path.isAbsolute(normalizedPath2) || path.win32.isAbsolute(normalizedPath2) || normalizedPath2.split("/").some((segment) => segment === "..")) {
     throw new Error(`Invalid content path: ${logicalPath}`);
   }
-  return normalizedPath;
+  return normalizedPath2;
 }
 function isMissingDirectoryError(error, directory) {
   return error instanceof Error && "code" in error && error.code === "ENOENT" && "path" in error && error.path === directory;
@@ -202,9 +202,2717 @@ function missingContentDirectoryError(directory) {
   error.hint = "Check `content.directory` in your Riebeckite configuration.";
   return error;
 }
+
+// src/content_source_factory.ts
+function createContentSource(config, directory = config.directory) {
+  return config.source ?? new FileSystemContentSource(directory, config.exclude ?? []);
+}
+
+// src/file_system_content_migration.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import fs5 from "node:fs/promises";
+import path5 from "node:path";
+import {
+  appendContentMigrationHistory,
+  ContentManager,
+  findContentMigrationRecord,
+  listContentMigrationEntries,
+  planContentMigrationBatch,
+  publicationEntriesFromManifest,
+  publicationFingerprint,
+  publicationOutputsFromManifest,
+  publicationRedirectsFromManifest,
+  sanitizeContentMigrationPath,
+  upsertContentMigrationRecord
+} from "@riebeckite/core";
+
+// src/file_system_content_migration_helpers.ts
+import { createHash } from "node:crypto";
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+function redirectFieldFromConfig(config) {
+  const options = config?.plugins.find((plugin) => plugin.name === "permalink")?.options;
+  const field = options?.redirects?.frontmatter;
+  if (field === void 0) return "redirect_from";
+  if (typeof field !== "string" || field.trim() === "")
+    throw new Error(
+      "The permalink redirects.frontmatter option must be a non-empty string."
+    );
+  return field;
+}
+function fingerprintFiles(files) {
+  const hash = createHash("sha256");
+  for (const file of [...files].sort(
+    (left, right) => left.path.localeCompare(right.path)
+  )) {
+    hash.update(file.path);
+    hash.update("\0");
+    hash.update(createHash("sha256").update(file.content).digest("hex"));
+    hash.update("\n");
+  }
+  return hash.digest("hex");
+}
+function fingerprintMutationPlan(operations, changes) {
+  return createHash("sha256").update(
+    canonicalJson({
+      operations,
+      changes: changes.map((change) => ({
+        path: change.path,
+        beforeFingerprint: change.beforeFingerprint,
+        afterFingerprint: change.afterFingerprint
+      }))
+    })
+  ).digest("hex");
+}
+function fingerprintPlan(input) {
+  return createHash("sha256").update(
+    canonicalJson({
+      migrations: input.migrations.map((migration) => ({
+        id: migration.id,
+        version: migration.version,
+        fingerprint: migration.fingerprint
+      })),
+      baseContentFingerprint: input.baseContentFingerprint,
+      mutationPlanFingerprint: input.mutationPlanFingerprint,
+      operations: input.operations,
+      diagnostics: input.diagnostics.map((diagnostic) => ({
+        severity: diagnostic.severity,
+        code: diagnostic.code,
+        path: diagnostic.path
+      })),
+      conflicts: input.conflicts.map((conflict) => ({
+        code: conflict.code,
+        path: conflict.path
+      }))
+    })
+  ).digest("hex");
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (isRecord(value)) {
+    const sorted = {};
+    for (const key of Object.keys(value).sort())
+      sorted[key] = sortValue(value[key]);
+    return sorted;
+  }
+  return value;
+}
+function findEntry(manifest, contentPath) {
+  const base = contentPath.replace(/\.md$/i, "");
+  return manifest.bySlug.get(base) ?? manifest.bySlug.get(`${base}/index`) ?? manifest.bySlug.get(base.replace(/\/index$/i, ""));
+}
+function changedFrontmatterKeys(file) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const key of /* @__PURE__ */ new Set([
+    ...Object.keys(file.frontmatter),
+    ...Object.keys(file.originalFrontmatter)
+  ])) {
+    if (canonicalJson(file.frontmatter[key]) !== canonicalJson(file.originalFrontmatter[key]))
+      keys.add(key);
+  }
+  return keys;
+}
+function diagnosticKey(diagnostic) {
+  return `${diagnostic.code}\0${diagnostic.filePath ?? ""}\0${diagnostic.target ?? ""}`;
+}
+function mutationIssue(issue, severity) {
+  return {
+    severity,
+    code: issue.code,
+    message: issue.message,
+    path: issue.path
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameMigrationPlan(left, right) {
+  if (left.baseContentFingerprint !== right.baseContentFingerprint || left.mutationPlanFingerprint !== right.mutationPlanFingerprint || left.planFingerprint !== right.planFingerprint || canonicalJson(left.operations) !== canonicalJson(right.operations) || canonicalJson(left.changes) !== canonicalJson(right.changes) || left.migrations.length !== right.migrations.length)
+    return false;
+  return left.migrations.every(
+    (migration, index) => migration.id === right.migrations[index]?.id && migration.version === right.migrations[index]?.version && migration.fingerprint === right.migrations[index]?.fingerprint
+  );
+}
+function isAppliedRecord(record, fingerprint2) {
+  return record?.status === "applied" && record.definitionFingerprint === fingerprint2;
+}
+async function readJournalSnapshot(journalPath) {
+  try {
+    const value = JSON.parse(await fs2.readFile(journalPath, "utf8"));
+    if (!isRecord(value) || typeof value.state !== "string" || !Array.isArray(value.changes))
+      return void 0;
+    const changes = [];
+    for (const change of value.changes) {
+      if (!isRecord(change) || typeof change.path !== "string" || !(change.afterFingerprint === null || typeof change.afterFingerprint === "string"))
+        return void 0;
+      changes.push({
+        path: change.path,
+        afterFingerprint: change.afterFingerprint
+      });
+    }
+    return { state: value.state, changes };
+  } catch {
+    return void 0;
+  }
+}
+async function journalMatchesApplied(contentDirectory, journal) {
+  for (const change of journal.changes) {
+    const target = path2.resolve(contentDirectory, change.path);
+    if (!isWithin(contentDirectory, target)) return false;
+    let actual = null;
+    try {
+      actual = createHash("sha256").update(await fs2.readFile(target)).digest("hex");
+    } catch (error) {
+      if (error.code !== "ENOENT") return false;
+    }
+    if (actual !== change.afterFingerprint) return false;
+  }
+  return true;
+}
+function isWithin(root, target) {
+  const relative = path2.relative(path2.resolve(root), path2.resolve(target));
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+}
+async function exists(file) {
+  try {
+    await fs2.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function staleLockContent(lockPath) {
+  let content;
+  try {
+    content = await fs2.readFile(lockPath, "utf8");
+  } catch {
+    return null;
+  }
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    return await lockFileIsOld(lockPath) ? content : null;
+  }
+  const pid = isRecord(value) ? value.pid : void 0;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+    return await lockFileIsOld(lockPath) ? content : null;
+  try {
+    process.kill(pid, 0);
+    return null;
+  } catch (error) {
+    return error.code === "ESRCH" ? content : null;
+  }
+}
+async function lockFileIsOld(lockPath) {
+  try {
+    return Date.now() - (await fs2.stat(lockPath)).mtimeMs > 5e3;
+  } catch {
+    return false;
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function sanitizeErrorMessage(error, contentDirectory) {
+  return errorMessage(error).split(contentDirectory).join("<content>").replace(/[A-Za-z]:[\\/][^\s'"]+/gu, "<path>");
+}
+function errorPath(error) {
+  if (!isRecord(error) || typeof error.path !== "string") return void 0;
+  const value = error.path.replace(/\\/gu, "/");
+  if (value.startsWith("/") || /^[A-Za-z]:\//u.test(value)) return void 0;
+  return value;
+}
+
+// src/file_system_content_mutation.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+import {
+  ContentIndexBuilder,
+  extractFrontmatterAliases,
+  flattenContentMutationOperations,
+  planContentLinkUpdates
+} from "@riebeckite/core";
+import { parseDocument } from "yaml";
+
+// src/mutation_journal.ts
+function markApplied(journal, filePath) {
+  const change = journal.changes.find(
+    (candidate) => candidate.path === filePath
+  );
+  if (!change) throw new Error(`Journal change is missing: ${filePath}`);
+  change.status = "applied";
+}
+function parseJournal(value) {
+  const journal = JSON.parse(value);
+  if (journal.version !== 1 || typeof journal.id !== "string" || !Array.isArray(journal.changes) || ![
+    "prepared",
+    "applying",
+    "failed",
+    "complete",
+    "recovered",
+    "rolled-back"
+  ].includes(journal.state ?? ""))
+    throw new Error("Journal is missing or corrupt.");
+  return journal;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function serializePlan(plan) {
+  return {
+    ...plan,
+    operations: serializeOperations(plan.operations),
+    changes: plan.changes.map((change) => ({
+      ...change,
+      content: change.content === null ? null : Buffer.from(change.content).toString("base64")
+    }))
+  };
+}
+function parsePlan(value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("Mutation plan is missing or corrupt.");
+  }
+  if (!isRecord2(parsed) || parsed.schemaVersion !== 1 || typeof parsed.id !== "string")
+    throw new Error("Mutation plan is missing or corrupt.");
+  if (!Array.isArray(parsed.operations) || !Array.isArray(parsed.changes) || !Array.isArray(parsed.preconditions) || !Array.isArray(parsed.warnings) || !Array.isArray(parsed.conflicts))
+    throw new Error("Mutation plan is missing or corrupt.");
+  const changes = parsed.changes.map((change) => {
+    const serializedContent = isRecord2(change) ? change.content : void 0;
+    if (!isRecord2(change) || typeof change.path !== "string" || !isFingerprint(change.beforeFingerprint) || !isFingerprint(change.afterFingerprint))
+      throw new Error("Mutation plan is missing or corrupt.");
+    if (serializedContent !== null && typeof serializedContent !== "string")
+      throw new Error("Mutation plan is missing or corrupt.");
+    const content = serializedContent === null ? null : new Uint8Array(Buffer.from(serializedContent, "base64"));
+    if (content === null !== (change.afterFingerprint === null))
+      throw new Error("Mutation plan is missing or corrupt.");
+    return {
+      path: change.path,
+      beforeFingerprint: change.beforeFingerprint,
+      afterFingerprint: change.afterFingerprint,
+      content
+    };
+  });
+  return {
+    schemaVersion: 1,
+    id: parsed.id,
+    operations: parseOperations(parsed.operations),
+    changes,
+    preconditions: parsed.preconditions,
+    warnings: parsed.warnings,
+    conflicts: parsed.conflicts
+  };
+}
+function samePlan(expected, actual) {
+  return canonicalPlan(expected) === canonicalPlan(actual) && expected.conflicts.length === actual.conflicts.length;
+}
+function canonicalPlan(plan) {
+  return JSON.stringify({
+    operations: serializeOperations(plan.operations),
+    changes: serializePlan(plan).changes,
+    preconditions: plan.preconditions,
+    conflicts: plan.conflicts
+  });
+}
+function serializeOperations(operations) {
+  return operations.map((operation) => {
+    if (operation.kind === "batch")
+      return {
+        ...operation,
+        operations: serializeOperations(operation.operations)
+      };
+    if ("content" in operation)
+      return {
+        ...operation,
+        content: typeof operation.content === "string" ? { encoding: "utf8", value: operation.content } : {
+          encoding: "base64",
+          value: Buffer.from(operation.content).toString("base64")
+        }
+      };
+    return operation;
+  });
+}
+function parseOperations(value) {
+  if (!Array.isArray(value))
+    throw new Error("Mutation plan is missing or corrupt.");
+  return value.map((operation) => {
+    if (!isRecord2(operation) || typeof operation.kind !== "string")
+      throw new Error("Mutation plan is missing or corrupt.");
+    if (operation.kind === "batch")
+      return {
+        kind: "batch",
+        operations: parseOperations(operation.operations)
+      };
+    if (operation.kind === "create" || operation.kind === "asset-create" || operation.kind === "update" || operation.kind === "asset-update") {
+      if (typeof operation.path !== "string" || !isRecord2(operation.content) || typeof operation.content.value !== "string")
+        throw new Error("Mutation plan is missing or corrupt.");
+      if (operation.content.encoding === "utf8")
+        return {
+          kind: operation.kind,
+          path: operation.path,
+          content: operation.content.value
+        };
+      if (operation.content.encoding === "base64")
+        return {
+          kind: operation.kind,
+          path: operation.path,
+          content: new Uint8Array(
+            Buffer.from(operation.content.value, "base64")
+          )
+        };
+      throw new Error("Mutation plan is missing or corrupt.");
+    }
+    if (operation.kind === "delete" || operation.kind === "asset-delete") {
+      if (typeof operation.path !== "string")
+        throw new Error("Mutation plan is missing or corrupt.");
+      return { kind: operation.kind, path: operation.path };
+    }
+    if (operation.kind === "move" || operation.kind === "rename" || operation.kind === "asset-move") {
+      if (typeof operation.from !== "string" || typeof operation.to !== "string")
+        throw new Error("Mutation plan is missing or corrupt.");
+      return { kind: operation.kind, from: operation.from, to: operation.to };
+    }
+    if (operation.kind === "frontmatter") {
+      if (typeof operation.path !== "string")
+        throw new Error("Mutation plan is missing or corrupt.");
+      return {
+        kind: "frontmatter",
+        path: operation.path,
+        ...isRecord2(operation.set) ? { set: operation.set } : {},
+        ...Array.isArray(operation.remove) && operation.remove.every((item) => typeof item === "string") ? { remove: operation.remove } : {}
+      };
+    }
+    throw new Error("Mutation plan is missing or corrupt.");
+  });
+}
+function isFingerprint(value) {
+  return value === null || typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+
+// src/file_system_content_mutation.ts
+var FileSystemContentMutation = class {
+  constructor(contentDirectory, options = {}) {
+    this.contentDirectory = contentDirectory;
+    this.options = options;
+  }
+  contentDirectory;
+  options;
+  async plan(operations) {
+    const root = await this.root();
+    const conflicts = [];
+    const warnings = [];
+    const files = /* @__PURE__ */ new Map();
+    await this.loadFiles(root, "", files);
+    const initial = new Map(files);
+    const touched = /* @__PURE__ */ new Set();
+    const retargets = [];
+    for (const operation of flattenContentMutationOperations(operations)) {
+      try {
+        if (operation.kind === "create" || operation.kind === "asset-create") {
+          const target2 = validateLogicalPath(operation.path);
+          touched.add(target2);
+          if (files.has(target2))
+            throw new Error("A file already exists at this path.");
+          files.set(target2, stateOf(operation.content));
+          continue;
+        }
+        if (operation.kind === "update" || operation.kind === "asset-update") {
+          const target2 = validateLogicalPath(operation.path);
+          touched.add(target2);
+          if (!files.has(target2)) throw new Error("The file does not exist.");
+          files.set(target2, stateOf(operation.content));
+          continue;
+        }
+        if (operation.kind === "delete" || operation.kind === "asset-delete") {
+          const target2 = validateLogicalPath(operation.path);
+          touched.add(target2);
+          if (!files.delete(target2))
+            throw new Error("The file does not exist.");
+          retargets.push({ from: target2 });
+          continue;
+        }
+        if (operation.kind === "move" || operation.kind === "rename" || operation.kind === "asset-move") {
+          const from = validateLogicalPath(operation.from);
+          const to = validateLogicalPath(operation.to);
+          touched.add(from);
+          touched.add(to);
+          const source2 = files.get(from);
+          if (!source2) throw new Error("The source file does not exist.");
+          if (files.has(to))
+            throw new Error("The destination file already exists.");
+          files.delete(from);
+          files.set(to, source2);
+          retargets.push({ from, to });
+          continue;
+        }
+        if (operation.kind !== "frontmatter")
+          throw new Error("Unsupported content mutation operation.");
+        const target = validateLogicalPath(operation.path);
+        touched.add(target);
+        const source = files.get(target);
+        if (!source) throw new Error("The file does not exist.");
+        if (!target.toLowerCase().endsWith(".md"))
+          throw new Error("Frontmatter can only be updated in Markdown files.");
+        files.set(
+          target,
+          updateFrontmatter(source, operation.set, operation.remove)
+        );
+        warnings.push({
+          severity: "warning",
+          code: "frontmatter-formatting",
+          path: target,
+          message: "The frontmatter document was serialized; comments and key order are retained where YAML permits."
+        });
+      } catch (error) {
+        conflicts.push({
+          severity: "error",
+          code: "invalid-operation",
+          path: operationPath(operation),
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    for (const filePath of touched) {
+      try {
+        await assertSafeExistingParents(root, filePath);
+      } catch (error) {
+        conflicts.push({
+          severity: "error",
+          code: "unsafe-path",
+          path: filePath,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    addCaseConflicts(files, conflicts);
+    const beforeBuild = buildContentIndex(initial);
+    const afterBuild = buildContentIndex(files);
+    const beforeIndex = beforeBuild.index;
+    const afterIndex = afterBuild.index;
+    if (retargets.length > 0 || !sameContentIndex(beforeIndex, afterIndex)) {
+      const markdownFiles = /* @__PURE__ */ new Map();
+      for (const [filePath, state] of files) {
+        if (!filePath.toLowerCase().endsWith(".md")) continue;
+        try {
+          markdownFiles.set(
+            filePath,
+            new TextDecoder("utf-8", {
+              fatal: true,
+              ignoreBOM: true
+            }).decode(state.content)
+          );
+        } catch {
+          conflicts.push({
+            severity: "error",
+            code: "invalid-markdown-encoding",
+            path: filePath,
+            message: "The Markdown file is not valid UTF-8."
+          });
+        }
+      }
+      const linkPlan = planContentLinkUpdates({
+        files: markdownFiles,
+        retargets: foldRetargets(retargets, files),
+        beforeIndex,
+        afterIndex,
+        beforeAmbiguities: beforeBuild.ambiguities,
+        afterAmbiguities: afterBuild.ambiguities
+      });
+      for (const [filePath, content] of linkPlan.updates) {
+        const existing = files.get(filePath);
+        if (!existing) continue;
+        files.set(filePath, stateOf(content));
+      }
+      warnings.push(...linkPlan.warnings);
+      conflicts.push(...linkPlan.conflicts);
+    }
+    const paths = /* @__PURE__ */ new Set([...initial.keys(), ...files.keys()]);
+    const changes = [...paths].filter(
+      (filePath) => initial.get(filePath)?.fingerprint !== files.get(filePath)?.fingerprint
+    ).map((filePath) => ({
+      path: filePath,
+      beforeFingerprint: initial.get(filePath)?.fingerprint ?? null,
+      afterFingerprint: files.get(filePath)?.fingerprint ?? null,
+      content: files.get(filePath)?.content ?? null
+    })).toSorted((left, right) => left.path.localeCompare(right.path));
+    return {
+      schemaVersion: 1,
+      id: randomUUID(),
+      operations,
+      changes,
+      preconditions: changes.map((change) => ({
+        path: change.path,
+        fingerprint: change.beforeFingerprint
+      })),
+      warnings,
+      conflicts
+    };
+  }
+  async apply(plan) {
+    const root = await this.root();
+    const preconditionConflicts = await this.verifyPreconditions(
+      root,
+      plan.changes
+    );
+    if (preconditionConflicts.length > 0)
+      return {
+        planId: plan.id,
+        applied: false,
+        appliedPaths: [],
+        conflicts: preconditionConflicts
+      };
+    const revalidated = await this.revalidatePlan(plan);
+    if (revalidated.length > 0)
+      return {
+        planId: plan.id,
+        applied: false,
+        appliedPaths: [],
+        conflicts: revalidated
+      };
+    if (plan.conflicts.length > 0)
+      return {
+        planId: plan.id,
+        applied: false,
+        appliedPaths: [],
+        conflicts: plan.conflicts
+      };
+    const release = await this.acquireLock(root);
+    try {
+      const conflicts = await this.verifyPreconditions(root, plan.changes);
+      if (conflicts.length > 0)
+        return { planId: plan.id, applied: false, appliedPaths: [], conflicts };
+      const journalDirectory = path3.join(
+        root,
+        ".riebeckite",
+        "mutations",
+        plan.id
+      );
+      await fs3.mkdir(path3.join(journalDirectory, "backups"), {
+        recursive: true
+      });
+      const journalPath = path3.join(journalDirectory, "journal.json");
+      const journal = {
+        version: 1,
+        id: plan.id,
+        state: "prepared",
+        changes: await Promise.all(
+          plan.changes.map(
+            (change) => this.backup(root, journalDirectory, change)
+          )
+        )
+      };
+      await writeJsonAtomically(journalPath, journal);
+      journal.state = "applying";
+      await writeJsonAtomically(journalPath, journal);
+      const appliedPaths = [];
+      try {
+        for (const change of plan.changes.filter(
+          (change2) => change2.content !== null
+        )) {
+          await this.options.beforeWrite?.(change.path);
+          if (change.content === null)
+            throw new Error("Mutation content is missing.");
+          await writeFileAtomically(
+            await safeFilePath(root, change.path, true),
+            change.content,
+            change.beforeFingerprint
+          );
+          markApplied(journal, change.path);
+          await writeJsonAtomically(journalPath, journal);
+          appliedPaths.push(change.path);
+        }
+        for (const change of plan.changes.filter(
+          (change2) => change2.content === null
+        )) {
+          await this.options.beforeWrite?.(change.path);
+          const target = await safeFilePath(root, change.path, false);
+          if (await fingerprintAt(target) !== change.beforeFingerprint)
+            throw new Error(`Content changed during apply: ${change.path}`);
+          await fs3.rm(target);
+          markApplied(journal, change.path);
+          await writeJsonAtomically(journalPath, journal);
+          appliedPaths.push(change.path);
+        }
+      } catch (error) {
+        journal.state = "failed";
+        await writeJsonAtomically(journalPath, journal);
+        throw error;
+      }
+      journal.state = "complete";
+      await writeJsonAtomically(journalPath, journal);
+      return {
+        planId: plan.id,
+        applied: true,
+        journalPath,
+        appliedPaths,
+        conflicts: []
+      };
+    } finally {
+      await release();
+    }
+  }
+  async recover(journalPath) {
+    const root = await this.root();
+    const absoluteJournal = path3.resolve(journalPath);
+    const mutationRoot = path3.join(root, ".riebeckite", "mutations");
+    if (!isWithin2(mutationRoot, absoluteJournal))
+      throw new Error("Journal path is outside the mutation directory.");
+    const journalDirectory = path3.dirname(absoluteJournal);
+    const release = await this.acquireLock(root);
+    try {
+      const journal = parseJournal(await fs3.readFile(absoluteJournal, "utf8"));
+      if (path3.basename(absoluteJournal) !== "journal.json" || path3.basename(journalDirectory) !== journal.id || path3.basename(journalDirectory) === "plans")
+        throw new Error("Journal path does not belong to its mutation.");
+      if (journal.state === "complete" || journal.state === "recovered")
+        return {
+          journalPath: absoluteJournal,
+          recovered: false,
+          restoredPaths: [],
+          conflicts: []
+        };
+      const conflicts = [];
+      const rollback = [];
+      for (const change of journal.changes) {
+        let current;
+        try {
+          current = (await readState(root, change.path))?.fingerprint ?? null;
+        } catch (error) {
+          conflicts.push({
+            severity: "error",
+            code: "recovery-conflict",
+            path: change.path,
+            message: error instanceof Error ? error.message : String(error)
+          });
+          continue;
+        }
+        if (current === change.beforeFingerprint) continue;
+        if (current !== change.afterFingerprint) {
+          conflicts.push({
+            severity: "error",
+            code: "recovery-conflict",
+            path: change.path,
+            message: "The file changed after the interrupted mutation."
+          });
+          continue;
+        }
+        rollback.push(change);
+      }
+      if (conflicts.length > 0)
+        return {
+          journalPath: absoluteJournal,
+          recovered: false,
+          restoredPaths: [],
+          conflicts
+        };
+      const backups = /* @__PURE__ */ new Map();
+      for (const change of rollback) {
+        if (change.beforeFingerprint === null) continue;
+        if (!change.backupPath) {
+          conflicts.push({
+            severity: "error",
+            code: "recovery-backup-invalid",
+            path: change.path,
+            message: "The journal does not reference a backup."
+          });
+          continue;
+        }
+        const backup = path3.resolve(journalDirectory, change.backupPath);
+        if (!isWithin2(journalDirectory, backup)) {
+          conflicts.push({
+            severity: "error",
+            code: "recovery-backup-invalid",
+            path: change.path,
+            message: "The backup path is outside the mutation journal."
+          });
+          continue;
+        }
+        try {
+          const content = await fs3.readFile(backup);
+          if (fingerprint(content) !== change.beforeFingerprint)
+            throw new Error("The backup fingerprint does not match.");
+          backups.set(change.path, content);
+        } catch (error) {
+          conflicts.push({
+            severity: "error",
+            code: "recovery-backup-invalid",
+            path: change.path,
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      if (conflicts.length > 0)
+        return {
+          journalPath: absoluteJournal,
+          recovered: false,
+          restoredPaths: [],
+          conflicts
+        };
+      const restoredPaths = [];
+      for (const change of rollback) {
+        const conflict = await this.restoreChange(
+          root,
+          journalDirectory,
+          change,
+          backups.get(change.path)
+        );
+        if (conflict) {
+          conflicts.push(conflict);
+          break;
+        }
+        restoredPaths.push(change.path);
+      }
+      if (conflicts.length > 0)
+        return {
+          journalPath: absoluteJournal,
+          recovered: false,
+          restoredPaths,
+          conflicts
+        };
+      journal.state = "recovered";
+      await writeJsonAtomically(absoluteJournal, journal);
+      return {
+        journalPath: absoluteJournal,
+        recovered: true,
+        restoredPaths,
+        conflicts: []
+      };
+    } finally {
+      await release();
+    }
+  }
+  async rollback(journalPath) {
+    const root = await this.root();
+    const absoluteJournal = path3.resolve(journalPath);
+    const mutationRoot = path3.join(root, ".riebeckite", "mutations");
+    const journalDirectory = path3.dirname(absoluteJournal);
+    const release = await this.acquireLock(root);
+    try {
+      if (!isWithin2(mutationRoot, absoluteJournal))
+        throw new Error("Journal path is outside the mutation directory.");
+      const journal = parseJournal(await fs3.readFile(absoluteJournal, "utf8"));
+      if (path3.basename(absoluteJournal) !== "journal.json" || path3.basename(journalDirectory) !== journal.id || path3.basename(journalDirectory) === "plans")
+        throw new Error("Journal path does not belong to its mutation.");
+      if (journal.state === "rolled-back")
+        return {
+          journalPath: absoluteJournal,
+          rolledBack: false,
+          skipped: true,
+          restoredPaths: [],
+          conflicts: []
+        };
+      if (journal.state !== "complete")
+        return {
+          journalPath: absoluteJournal,
+          rolledBack: false,
+          skipped: false,
+          restoredPaths: [],
+          conflicts: [
+            {
+              severity: "error",
+              code: "rollback-journal-incomplete",
+              message: "Only a completed mutation can be rolled back."
+            }
+          ]
+        };
+      const conflicts = [];
+      const backups = /* @__PURE__ */ new Map();
+      for (const change of journal.changes) {
+        let current = null;
+        try {
+          current = (await readState(root, change.path))?.fingerprint ?? null;
+        } catch (error) {
+          conflicts.push({
+            severity: "error",
+            code: "rollback-conflict",
+            path: change.path,
+            message: error instanceof Error ? error.message : String(error)
+          });
+          continue;
+        }
+        if (current !== change.afterFingerprint) {
+          conflicts.push({
+            severity: "error",
+            code: "rollback-conflict",
+            path: change.path,
+            message: "The file changed after the mutation was applied."
+          });
+          continue;
+        }
+        if (change.beforeFingerprint === null) continue;
+        if (!change.backupPath) {
+          conflicts.push({
+            severity: "error",
+            code: "rollback-backup-invalid",
+            path: change.path,
+            message: "The journal does not reference a backup."
+          });
+          continue;
+        }
+        const backup = path3.resolve(journalDirectory, change.backupPath);
+        if (!isWithin2(journalDirectory, backup)) {
+          conflicts.push({
+            severity: "error",
+            code: "rollback-backup-invalid",
+            path: change.path,
+            message: "The backup path is outside the mutation journal."
+          });
+          continue;
+        }
+        try {
+          const content = await fs3.readFile(backup);
+          if (fingerprint(content) !== change.beforeFingerprint)
+            throw new Error("The backup fingerprint does not match.");
+          backups.set(change.path, content);
+        } catch (error) {
+          conflicts.push({
+            severity: "error",
+            code: "rollback-backup-invalid",
+            path: change.path,
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      if (conflicts.length > 0)
+        return {
+          journalPath: absoluteJournal,
+          rolledBack: false,
+          skipped: false,
+          restoredPaths: [],
+          conflicts
+        };
+      const restoredPaths = [];
+      for (const change of journal.changes) {
+        const conflict = await this.restoreChange(
+          root,
+          journalDirectory,
+          change,
+          backups.get(change.path)
+        );
+        if (conflict) {
+          conflicts.push(conflict);
+          break;
+        }
+        restoredPaths.push(change.path);
+      }
+      if (conflicts.length > 0)
+        return {
+          journalPath: absoluteJournal,
+          rolledBack: false,
+          skipped: false,
+          restoredPaths,
+          conflicts
+        };
+      journal.state = "rolled-back";
+      await writeJsonAtomically(absoluteJournal, journal);
+      return {
+        journalPath: absoluteJournal,
+        rolledBack: true,
+        skipped: false,
+        restoredPaths,
+        conflicts: []
+      };
+    } finally {
+      await release();
+    }
+  }
+  async restoreChange(root, journalDirectory, change, backup) {
+    if (change.afterFingerprint === null) {
+      if (change.beforeFingerprint === null || !backup)
+        return recoveryConflict(
+          change.path,
+          "The deletion cannot be rolled back safely."
+        );
+      const target2 = await safeFilePath(root, change.path, true);
+      try {
+        await writeFileExclusive(target2, backup);
+        return null;
+      } catch (error) {
+        if (error.code === "EEXIST")
+          return recoveryConflict(
+            change.path,
+            "A file appeared during recovery; it was not overwritten."
+          );
+        throw error;
+      }
+    }
+    await this.options.beforeRecoveryRestore?.(change.path);
+    const target = await safeFilePath(root, change.path, false);
+    const captureDirectory = path3.join(journalDirectory, "quarantine");
+    await fs3.mkdir(captureDirectory, { recursive: true });
+    const captured = path3.join(captureDirectory, `${randomUUID()}.capture`);
+    try {
+      await fs3.rename(target, captured);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return recoveryConflict(
+          change.path,
+          "The file disappeared before it could be verified."
+        );
+      throw error;
+    }
+    const content = await fs3.readFile(captured);
+    if (fingerprint(content) !== change.afterFingerprint) {
+      await restoreCapturedFile(target, captured);
+      return recoveryConflict(
+        change.path,
+        "The file changed after verification; its content was preserved and not overwritten."
+      );
+    }
+    await this.options.afterRecoveryCapture?.(change.path);
+    if (change.beforeFingerprint === null) {
+      try {
+        await fs3.lstat(target);
+      } catch (error) {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+      return recoveryConflict(
+        change.path,
+        "A file appeared during recovery; it was not deleted."
+      );
+    }
+    try {
+      await writeFileExclusive(target, backup);
+      return null;
+    } catch (error) {
+      if (error.code === "EEXIST")
+        return recoveryConflict(
+          change.path,
+          "A file appeared during recovery; it was not overwritten."
+        );
+      throw error;
+    }
+  }
+  async savePlan(plan, planPath) {
+    const root = await this.root();
+    const target = await this.planPath(root, plan.id, planPath);
+    await writeJsonAtomically(target, serializePlan(plan));
+    return target;
+  }
+  async loadPlan(planPath) {
+    const root = await this.root();
+    const absolute = await this.planPath(root, void 0, planPath);
+    return parsePlan(await fs3.readFile(absolute, "utf8"));
+  }
+  async revalidatePlan(plan) {
+    if (plan.schemaVersion !== 1)
+      return [
+        {
+          severity: "error",
+          code: "unsupported-plan",
+          message: "The mutation plan has an unsupported schema version."
+        }
+      ];
+    const refreshed = await this.plan(plan.operations);
+    if (!samePlan(plan, refreshed))
+      return [
+        {
+          severity: "error",
+          code: "stale-plan",
+          message: "The saved plan no longer matches a fresh validation of its operations."
+        }
+      ];
+    return [];
+  }
+  async planPath(root, id, requested) {
+    const plansRoot = path3.join(root, ".riebeckite", "mutations", "plans");
+    const target = requested ? path3.resolve(plansRoot, requested) : path3.join(plansRoot, `${id ?? ""}.json`);
+    if (!isWithin2(plansRoot, target))
+      throw new Error("Plan path is outside the mutation plan directory.");
+    if (requested) {
+      const extension = path3.extname(target).toLowerCase();
+      if (extension !== ".json")
+        throw new Error("Mutation plan must be a JSON file.");
+    }
+    await fs3.mkdir(path3.dirname(target), { recursive: true });
+    return target;
+  }
+  async root() {
+    const root = await fs3.realpath(this.contentDirectory);
+    if (!(await fs3.stat(root)).isDirectory())
+      throw new Error("Content directory is not a directory.");
+    return root;
+  }
+  async loadFiles(root, relative, files) {
+    for (const entry of await fs3.readdir(path3.join(root, relative), {
+      withFileTypes: true
+    })) {
+      if (entry.name === ".riebeckite" && relative === "") continue;
+      const child = relative ? `${relative}/${entry.name}` : entry.name;
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) await this.loadFiles(root, child, files);
+      if (entry.isFile())
+        files.set(child, stateOf(await fs3.readFile(path3.join(root, child))));
+    }
+  }
+  async verifyPreconditions(root, changes) {
+    const conflicts = [];
+    for (const change of changes) {
+      try {
+        const current = await readState(root, change.path);
+        if ((current?.fingerprint ?? null) !== change.beforeFingerprint)
+          conflicts.push({
+            severity: "error",
+            code: "concurrent-modification",
+            path: change.path,
+            message: "The file no longer matches the planned fingerprint."
+          });
+      } catch (error) {
+        conflicts.push({
+          severity: "error",
+          code: "unsafe-path",
+          path: change.path,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return conflicts;
+  }
+  async backup(root, journalDirectory, change) {
+    if (change.beforeFingerprint === null)
+      return {
+        path: change.path,
+        beforeFingerprint: null,
+        afterFingerprint: change.afterFingerprint,
+        status: "pending"
+      };
+    const state = await readState(root, change.path);
+    if (!state || state.fingerprint !== change.beforeFingerprint)
+      throw new Error(`Could not back up ${change.path}.`);
+    const backupPath = `backups/${Buffer.from(change.path).toString("base64url")}`;
+    await writeFileAtomically(
+      path3.join(journalDirectory, backupPath),
+      state.content
+    );
+    return {
+      path: change.path,
+      beforeFingerprint: change.beforeFingerprint,
+      afterFingerprint: change.afterFingerprint,
+      backupPath,
+      status: "pending"
+    };
+  }
+  async acquireLock(root) {
+    const lockPath = path3.join(root, ".riebeckite", "mutations", "lock");
+    await fs3.mkdir(path3.dirname(lockPath), { recursive: true });
+    let handle;
+    try {
+      handle = await fs3.open(lockPath, "wx");
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        const stale = await staleLockContent2(lockPath);
+        if (stale !== null) {
+          const quarantine = `${lockPath}.stale-${randomUUID()}`;
+          try {
+            await fs3.rename(lockPath, quarantine);
+          } catch (renameError) {
+            if (renameError.code === "ENOENT")
+              return await this.acquireLock(root);
+            throw renameError;
+          }
+          const quarantined = await fs3.readFile(quarantine, "utf8");
+          if (quarantined !== stale) {
+            const restored = await fs3.writeFile(lockPath, quarantined, { flag: "wx" }).then(
+              () => true,
+              () => false
+            );
+            if (restored) await fs3.rm(quarantine, { force: true });
+            throw new Error(
+              "Another content mutation is already applying or requires recovery."
+            );
+          }
+          await fs3.rm(quarantine, { force: true });
+          return await this.acquireLock(root);
+        }
+      }
+      throw new Error(
+        "Another content mutation is already applying or requires recovery."
+      );
+    }
+    const token = randomUUID();
+    await handle.writeFile(
+      JSON.stringify({
+        pid: process.pid,
+        token,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return async () => {
+      await handle.close();
+      try {
+        const current = JSON.parse(await fs3.readFile(lockPath, "utf8"));
+        if (isRecord2(current) && current.token === token)
+          await fs3.rm(lockPath, { force: true });
+      } catch {
+      }
+    };
+  }
+};
+function validateLogicalPath(value) {
+  const normalized = value.replaceAll("\\", "/").normalize("NFC");
+  if (!normalized || normalized.startsWith("/") || path3.isAbsolute(normalized) || path3.win32.isAbsolute(normalized) || normalized.split("/").some(
+    (part) => !part || part === "." || part === ".." || hasForbiddenPathCharacter(part) || /[. ]$/.test(part) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i.test(part)
+  ))
+    throw new Error("Invalid content path.");
+  return normalized;
+}
+function hasForbiddenPathCharacter(value) {
+  return [...value].some((character) => {
+    const code = character.codePointAt(0) ?? 0;
+    return code <= 31 || '<>:"|?*'.includes(character);
+  });
+}
+async function safeFilePath(root, logicalPath, createParents) {
+  const normalized = validateLogicalPath(logicalPath);
+  const filePath = path3.resolve(root, ...normalized.split("/"));
+  if (!isWithin2(root, filePath))
+    throw new Error("Content path escapes the workspace.");
+  const parent = path3.dirname(filePath);
+  if (createParents) await fs3.mkdir(parent, { recursive: true });
+  let current = root;
+  for (const part of path3.relative(root, parent).split(path3.sep).filter(Boolean)) {
+    current = path3.join(current, part);
+    const stats = await fs3.lstat(current);
+    if (stats.isSymbolicLink() || !stats.isDirectory())
+      throw new Error(
+        "Content path traverses a symbolic link or non-directory."
+      );
+  }
+  try {
+    if ((await fs3.lstat(filePath)).isSymbolicLink())
+      throw new Error("Content path is a symbolic link.");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return filePath;
+}
+async function assertSafeExistingParents(root, logicalPath) {
+  const normalized = validateLogicalPath(logicalPath);
+  let current = root;
+  for (const part of normalized.split("/").slice(0, -1)) {
+    current = path3.join(current, part);
+    try {
+      const stats = await fs3.lstat(current);
+      if (stats.isSymbolicLink() || !stats.isDirectory())
+        throw new Error(
+          "Content path traverses a symbolic link or non-directory."
+        );
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+  }
+}
+async function readState(root, logicalPath) {
+  try {
+    const filePath = await safeFilePath(root, logicalPath, false);
+    const stats = await fs3.lstat(filePath);
+    if (!stats.isFile() || stats.isSymbolicLink())
+      throw new Error("Content path is not a regular file.");
+    return stateOf(await fs3.readFile(filePath));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function stateOf(content) {
+  const bytes = typeof content === "string" ? Buffer.from(content) : new Uint8Array(content);
+  return { content: bytes, fingerprint: fingerprint(bytes) };
+}
+function fingerprint(content) {
+  return createHash2("sha256").update(content).digest("hex");
+}
+function foldRetargets(retargets, files) {
+  const byFrom = new Map(
+    retargets.map((retarget) => [normalizedPath(retarget.from), retarget])
+  );
+  const existing = new Set([...files.keys()].map(normalizedPath));
+  return retargets.filter((retarget) => !existing.has(normalizedPath(retarget.from))).map((retarget) => {
+    if (!retarget.to) return retarget;
+    let to = retarget.to;
+    const seen = /* @__PURE__ */ new Set([normalizedPath(retarget.from)]);
+    for (; ; ) {
+      const key = normalizedPath(to);
+      const next = byFrom.get(key);
+      if (!next?.to || seen.has(key)) break;
+      seen.add(key);
+      to = next.to;
+    }
+    return to === retarget.to ? retarget : { from: retarget.from, to };
+  });
+}
+function normalizedPath(value) {
+  return value.replaceAll("\\", "/").toLowerCase();
+}
+function buildContentIndex(files) {
+  const decoder = new TextDecoder();
+  const entries = [];
+  const aliasesByPath = /* @__PURE__ */ new Map();
+  for (const [filePath, state] of files) {
+    entries.push({ path: filePath });
+    if (filePath.toLowerCase().endsWith(".md"))
+      aliasesByPath.set(
+        filePath,
+        extractFrontmatterAliases(decoder.decode(state.content))
+      );
+  }
+  return ContentIndexBuilder.buildFromAliases(entries, aliasesByPath);
+}
+function sameContentIndex(left, right) {
+  if (left.size !== right.size) return false;
+  for (const [key, value] of left) {
+    if (right.get(key) !== value) return false;
+  }
+  return true;
+}
+function isWithin2(parent, child) {
+  const relative = path3.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
+}
+function operationPath(operation) {
+  return "path" in operation ? operation.path : operation.to;
+}
+function addCaseConflicts(files, conflicts) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const filePath of files.keys()) {
+    const folded = filePath.toLocaleLowerCase("en-US");
+    const previous = seen.get(folded);
+    if (previous && previous !== filePath)
+      conflicts.push({
+        severity: "error",
+        code: "case-collision",
+        path: filePath,
+        message: `Path conflicts with ${previous} on a case-insensitive filesystem.`
+      });
+    else seen.set(folded, filePath);
+  }
+}
+function recoveryConflict(filePath, message) {
+  return {
+    severity: "error",
+    code: "recovery-conflict",
+    path: filePath,
+    message
+  };
+}
+async function writeFileExclusive(filePath, content) {
+  await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+  const handle = await fs3.open(filePath, "wx");
+  try {
+    await handle.writeFile(content);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function restoreCapturedFile(target, captured) {
+  try {
+    await writeFileExclusive(target, await fs3.readFile(captured));
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+}
+async function writeFileAtomically(filePath, content, expectedFingerprint) {
+  await fs3.mkdir(path3.dirname(filePath), { recursive: true });
+  const temporary = path3.join(
+    path3.dirname(filePath),
+    `.${path3.basename(filePath)}.${randomUUID()}.tmp`
+  );
+  try {
+    const handle = await fs3.open(temporary, "wx");
+    try {
+      await handle.writeFile(content);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    if (expectedFingerprint !== void 0 && await fingerprintAt(filePath) !== expectedFingerprint)
+      throw new Error(`Content changed during apply: ${filePath}`);
+    await fs3.rename(temporary, filePath);
+  } finally {
+    await fs3.rm(temporary, { force: true });
+  }
+}
+async function fingerprintAt(filePath) {
+  try {
+    const stats = await fs3.lstat(filePath);
+    if (!stats.isFile() || stats.isSymbolicLink())
+      throw new Error("Content path is not a regular file.");
+    return fingerprint(await fs3.readFile(filePath));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeJsonAtomically(filePath, value) {
+  await writeFileAtomically(
+    filePath,
+    Buffer.from(`${JSON.stringify(value, null, 2)}
+`)
+  );
+}
+async function staleLockContent2(lockPath) {
+  let content;
+  try {
+    content = await fs3.readFile(lockPath, "utf8");
+  } catch {
+    return null;
+  }
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    return await lockFileIsOld2(lockPath) ? content : null;
+  }
+  const pid = isRecord2(value) ? value.pid : void 0;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+    return await lockFileIsOld2(lockPath) ? content : null;
+  try {
+    process.kill(pid, 0);
+    return null;
+  } catch (error) {
+    return error.code === "ESRCH" ? content : null;
+  }
+}
+async function lockFileIsOld2(lockPath) {
+  try {
+    return Date.now() - (await fs3.stat(lockPath)).mtimeMs > 5e3;
+  } catch {
+    return false;
+  }
+}
+function updateFrontmatter(source, set, remove) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8", {
+      fatal: true,
+      ignoreBOM: true
+    }).decode(source.content);
+  } catch {
+    throw new Error("The Markdown file is not valid UTF-8.");
+  }
+  const bom = text.startsWith("\uFEFF") ? "\uFEFF" : "";
+  const body = bom ? text.slice(1) : text;
+  const match = /^(---\r?\n)([\s\S]*?)(\r?\n---(?:\r?\n|$))/.exec(body);
+  if (!match) throw new Error("The Markdown file has no YAML frontmatter.");
+  const document = parseDocument(match[2]);
+  if (document.errors.length > 0)
+    throw new Error(`Invalid YAML frontmatter: ${document.errors[0]?.message}`);
+  for (const [key, value] of Object.entries(set ?? {}))
+    document.setIn(key.split("."), value);
+  for (const key of remove ?? []) document.deleteIn(key.split("."));
+  return stateOf(
+    `${bom}${match[1]}${document.toString().trimEnd()}${match[3]}${body.slice(match[0].length)}`
+  );
+}
+
+// src/migration_state_store.ts
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
+import {
+  emptyContentMigrationHistory,
+  emptyContentMigrationState,
+  parseContentMigrationHistory,
+  parseContentMigrationState
+} from "@riebeckite/core";
+function migrationStateDirectory(contentDirectory) {
+  return path4.join(contentDirectory, ".riebeckite", "migrations");
+}
+function migrationStatePath(contentDirectory) {
+  return path4.join(migrationStateDirectory(contentDirectory), "state.json");
+}
+function migrationHistoryPath(contentDirectory) {
+  return path4.join(migrationStateDirectory(contentDirectory), "history.json");
+}
+function migrationLockPath(contentDirectory) {
+  return path4.join(migrationStateDirectory(contentDirectory), "lock");
+}
+async function readMigrationState(contentDirectory) {
+  try {
+    return parseContentMigrationState(
+      JSON.parse(
+        await fs4.readFile(migrationStatePath(contentDirectory), "utf8")
+      )
+    );
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyContentMigrationState();
+    throw error;
+  }
+}
+async function writeMigrationState(contentDirectory, state) {
+  const target = migrationStatePath(contentDirectory);
+  await fs4.mkdir(path4.dirname(target), { recursive: true });
+  await fs4.writeFile(target, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function readMigrationHistory(contentDirectory) {
+  try {
+    return parseContentMigrationHistory(
+      JSON.parse(
+        await fs4.readFile(migrationHistoryPath(contentDirectory), "utf8")
+      )
+    );
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return emptyContentMigrationHistory();
+    throw error;
+  }
+}
+async function writeMigrationHistory(contentDirectory, history) {
+  const target = migrationHistoryPath(contentDirectory);
+  await fs4.mkdir(path4.dirname(target), { recursive: true });
+  await fs4.writeFile(target, `${JSON.stringify(history, null, 2)}
+`, "utf8");
+}
+
+// src/file_system_content_migration.ts
+var FileSystemContentMigration = class {
+  constructor(options) {
+    this.options = options;
+    this.mutation = new FileSystemContentMutation(options.contentDirectory);
+    this.source = new FileSystemContentSource(options.contentDirectory, [
+      ...options.config?.content.exclude ?? [],
+      ...options.exclude ?? []
+    ]);
+  }
+  options;
+  mutation;
+  source;
+  get contentDirectory() {
+    return this.options.contentDirectory;
+  }
+  async plan(options = {}) {
+    const migrations = this.options.registry.resolve(options.ids);
+    const entries = (await this.source.scan()).filter(
+      (entry) => entry.path.toLowerCase().endsWith(".md")
+    );
+    const files = await Promise.all(
+      entries.map(async (entry) => ({
+        path: entry.path,
+        content: await this.source.read(entry)
+      }))
+    );
+    const baseContentFingerprint = fingerprintFiles(files);
+    const redirectField = this.options.redirectField ?? redirectFieldFromConfig(this.options.config);
+    const batch = planContentMigrationBatch({
+      migrations,
+      files,
+      preserveMovedPermalinks: false,
+      redirectField
+    });
+    const beforeOutcome = await this.tryAnalyze(this.source);
+    let mutationPlan = await this.mutation.plan(batch.operations);
+    let afterOutcome = beforeOutcome.analysis ? await this.tryAnalyze(
+      createFutureContentSource(this.source, mutationPlan.changes)
+    ) : { analysis: void 0, diagnostics: [] };
+    const diagnosticList = [
+      ...beforeOutcome.diagnostics,
+      ...afterOutcome.diagnostics
+    ];
+    if (beforeOutcome.analysis && afterOutcome.analysis) {
+      const redirectOperations = this.redirectOperations(
+        batch,
+        beforeOutcome.analysis.manifest,
+        afterOutcome.analysis.manifest,
+        redirectField
+      );
+      if (redirectOperations.length > 0) {
+        mutationPlan = await this.mutation.plan([
+          ...batch.operations,
+          ...redirectOperations
+        ]);
+        afterOutcome = await this.tryAnalyze(
+          createFutureContentSource(this.source, mutationPlan.changes)
+        );
+        diagnosticList.push(...afterOutcome.diagnostics);
+      }
+    }
+    const verification = beforeOutcome.analysis && afterOutcome.analysis ? this.verify({
+      batch,
+      before: beforeOutcome.analysis,
+      after: afterOutcome.analysis,
+      mutationPlan
+    }).diagnostics : [];
+    const diagnostics = [
+      ...batch.diagnostics,
+      ...mutationPlan.warnings.map((issue) => mutationIssue(issue, "warning")),
+      ...diagnosticList,
+      ...verification
+    ];
+    const conflicts = [
+      ...mutationPlan.conflicts.map((issue) => mutationIssue(issue, "error")),
+      ...diagnostics.filter((diagnostic) => diagnostic.severity === "error")
+    ];
+    const mutationChanges = mutationPlan.changes.map((change) => ({
+      path: change.path,
+      beforeFingerprint: change.beforeFingerprint,
+      afterFingerprint: change.afterFingerprint
+    }));
+    const mutationPlanFingerprint = fingerprintMutationPlan(
+      mutationPlan.operations,
+      mutationPlan.changes
+    );
+    const planFingerprint = fingerprintPlan({
+      migrations,
+      baseContentFingerprint,
+      mutationPlanFingerprint,
+      operations: mutationPlan.operations,
+      diagnostics,
+      conflicts
+    });
+    return {
+      schemaVersion: 1,
+      id: randomUUID2(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      migrations: migrations.map((migration) => ({
+        id: migration.id,
+        version: migration.version,
+        fingerprint: migration.fingerprint
+      })),
+      baseContentFingerprint,
+      mutationPlanId: mutationPlan.id,
+      mutationPlanFingerprint,
+      planFingerprint,
+      operations: mutationPlan.operations,
+      changes: mutationChanges,
+      diagnostics,
+      conflicts,
+      selections: batch.selections,
+      skipped: batch.skipped,
+      impact: batch.impact,
+      verification: {
+        beforeFiles: beforeOutcome.analysis?.manifest.entries.length ?? 0,
+        afterFiles: afterOutcome.analysis?.manifest.entries.length ?? 0,
+        beforePublicationFingerprint: beforeOutcome.analysis?.publicationFingerprint ?? "",
+        afterPublicationFingerprint: afterOutcome.analysis?.publicationFingerprint ?? "",
+        derivedViews: afterOutcome.analysis?.derivedViews ?? 0
+      }
+    };
+  }
+  async savePlan(plan, outputPath) {
+    const target = outputPath ?? path5.join(
+      this.options.contentDirectory,
+      ".riebeckite",
+      "migrations",
+      "plans",
+      `${plan.id}.json`
+    );
+    await fs5.mkdir(path5.dirname(target), { recursive: true });
+    await fs5.writeFile(target, `${JSON.stringify(plan, null, 2)}
+`, "utf8");
+    return target;
+  }
+  async loadPlan(planPath) {
+    const content = await fs5.readFile(planPath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed) || parsed.schemaVersion !== 1)
+      throw new Error("The migration plan has an unsupported schema.");
+    return parsed;
+  }
+  async history(options = {}) {
+    const history = await this.readHistory();
+    if (options.limit === void 0) return history;
+    if (!Number.isInteger(options.limit) || options.limit < 0)
+      throw new Error("The history limit must be a non-negative integer.");
+    return {
+      ...history,
+      runs: history.runs.slice(-options.limit)
+    };
+  }
+  async list() {
+    return listContentMigrationEntries(
+      this.options.registry.migrations,
+      await this.readState()
+    );
+  }
+  async apply(options = {}) {
+    const stored = options.planPath ? await this.loadPlan(options.planPath) : void 0;
+    const requested = stored ? [...new Set(stored.migrations.map((migration) => migration.id))] : options.ids;
+    const fresh = await this.plan({ ids: requested });
+    if (stored && !sameMigrationPlan(stored, fresh))
+      return {
+        applied: false,
+        skipped: false,
+        plan: fresh,
+        changedPaths: [],
+        conflicts: [
+          {
+            severity: "error",
+            code: "stale-plan",
+            message: "The stored migration plan no longer matches the current content or migration definitions."
+          }
+        ]
+      };
+    if (fresh.conflicts.length > 0)
+      return {
+        applied: false,
+        skipped: false,
+        plan: fresh,
+        changedPaths: [],
+        conflicts: fresh.conflicts
+      };
+    let release;
+    try {
+      release = await this.acquireLock();
+    } catch (error) {
+      return {
+        applied: false,
+        skipped: false,
+        plan: fresh,
+        changedPaths: [],
+        conflicts: [
+          {
+            severity: "error",
+            code: "migration-locked",
+            message: errorMessage(error)
+          }
+        ]
+      };
+    }
+    try {
+      const state = await this.readState();
+      const conflicts = this.preflight(fresh, state);
+      const currentContent = await this.currentContentFingerprint();
+      if (currentContent !== fresh.baseContentFingerprint)
+        conflicts.push({
+          severity: "error",
+          code: "stale-plan",
+          message: "Content changed after the migration plan was created."
+        });
+      if (conflicts.length > 0)
+        return {
+          applied: false,
+          skipped: false,
+          plan: fresh,
+          changedPaths: [],
+          conflicts
+        };
+      const actionable = fresh.migrations.filter(
+        (migration) => !isAppliedRecord(
+          findContentMigrationRecord(state, migration.id, migration.version),
+          migration.fingerprint
+        )
+      );
+      if (actionable.length === 0)
+        return {
+          applied: false,
+          skipped: true,
+          plan: fresh,
+          changedPaths: [],
+          conflicts: []
+        };
+      const mutationPlan = await this.mutation.plan(fresh.operations);
+      if (fingerprintMutationPlan(
+        mutationPlan.operations,
+        mutationPlan.changes
+      ) !== fresh.mutationPlanFingerprint)
+        return {
+          applied: false,
+          skipped: false,
+          plan: fresh,
+          changedPaths: [],
+          conflicts: [
+            {
+              severity: "error",
+              code: "stale-plan",
+              message: "The content mutation plan changed after the migration plan was created."
+            }
+          ]
+        };
+      const now = /* @__PURE__ */ new Date();
+      let nextState = this.stateWith(fresh, actionable, state, "applying", now);
+      await this.writeState(nextState);
+      try {
+        const result = await this.mutation.apply({
+          ...mutationPlan,
+          id: fresh.mutationPlanId
+        });
+        if (!result.applied) {
+          nextState = this.stateWith(
+            fresh,
+            actionable,
+            nextState,
+            "failed",
+            /* @__PURE__ */ new Date(),
+            {
+              error: result.conflicts.map((conflict) => conflict.message).join(" "),
+              journalPath: void 0
+            }
+          );
+          await this.writeState(nextState);
+          await this.appendHistory(
+            fresh,
+            actionable,
+            "failure",
+            "required",
+            void 0
+          );
+          return {
+            applied: false,
+            skipped: false,
+            plan: fresh,
+            changedPaths: [],
+            conflicts: result.conflicts.map(
+              (issue) => mutationIssue(issue, "error")
+            )
+          };
+        }
+        const journalPath = result.journalPath ? this.relativeToContent(result.journalPath) : void 0;
+        const appliedState = this.stateWith(
+          fresh,
+          actionable,
+          nextState,
+          "applied",
+          /* @__PURE__ */ new Date(),
+          { journalPath, rolledBackAt: void 0 }
+        );
+        nextState = this.supersede(actionable, appliedState, /* @__PURE__ */ new Date());
+        await this.writeState(nextState);
+        await this.appendHistory(
+          fresh,
+          actionable,
+          "success",
+          "none",
+          journalPath
+        );
+        return {
+          applied: true,
+          skipped: false,
+          plan: fresh,
+          journalPath: result.journalPath,
+          changedPaths: result.appliedPaths,
+          conflicts: []
+        };
+      } catch (error) {
+        const journal = await this.failedJournal(fresh);
+        const message = sanitizeErrorMessage(error, this.contentDirectory);
+        nextState = this.stateWith(
+          fresh,
+          actionable,
+          nextState,
+          journal ? "recovery-required" : "failed",
+          /* @__PURE__ */ new Date(),
+          { journalPath: journal, error: message }
+        );
+        await this.writeState(nextState);
+        await this.appendHistory(
+          fresh,
+          actionable,
+          "failure",
+          journal ? "required" : "none",
+          journal
+        );
+        return {
+          applied: false,
+          skipped: false,
+          plan: fresh,
+          changedPaths: [],
+          conflicts: [
+            {
+              severity: "error",
+              code: journal ? "recovery-required" : "apply-failed",
+              message
+            }
+          ]
+        };
+      }
+    } finally {
+      await release();
+    }
+  }
+  async status() {
+    const state = await this.readState();
+    const history = await this.readHistory();
+    const reconciled = /* @__PURE__ */ new Map();
+    for (const record of state.migrations) {
+      const resolved = await this.reconcile(record);
+      if (resolved !== record)
+        reconciled.set(`${record.id}@${record.version}`, resolved);
+    }
+    let nextState = state;
+    if (reconciled.size > 0) {
+      try {
+        const release = await this.acquireLock();
+        try {
+          const current = await this.readState();
+          let merged = current;
+          for (const record of current.migrations) {
+            const resolved = reconciled.get(`${record.id}@${record.version}`);
+            const original = state.migrations.find(
+              (entry) => entry.id === record.id && entry.version === record.version
+            );
+            if (resolved && original && record.status === original.status && record.updatedAt === original.updatedAt)
+              merged = upsertContentMigrationRecord(merged, resolved);
+          }
+          if (merged !== current) await this.writeState(merged);
+          nextState = merged;
+        } finally {
+          await release();
+        }
+      } catch {
+      }
+    }
+    const entries = nextState.migrations.map((record) => {
+      const definition = this.options.registry.versions(record.id).find((migration) => migration.version === record.version);
+      const latest = this.options.registry.latest(record.id);
+      return {
+        id: record.id,
+        version: record.version,
+        latestVersion: latest?.version,
+        status: record.status,
+        definitionMatches: definition !== void 0 && definition.fingerprint === record.definitionFingerprint,
+        planId: record.planId,
+        appliedAt: record.appliedAt,
+        updatedAt: record.updatedAt,
+        journal: record.journalPath,
+        error: record.error
+      };
+    }).toSorted(
+      (left, right) => left.id.localeCompare(right.id) || left.version - right.version
+    );
+    return {
+      schemaVersion: 1,
+      updatedAt: nextState.updatedAt,
+      entries,
+      migrations: listContentMigrationEntries(
+        this.options.registry.migrations,
+        nextState
+      ),
+      historyCount: history.runs.length
+    };
+  }
+  async recover(options = {}) {
+    const release = await this.acquireLock();
+    try {
+      const state = await this.readState();
+      const journalPath = options.journal !== void 0 ? this.absoluteFromContent(options.journal) : void 0;
+      if (journalPath !== void 0 && !isWithin(this.contentDirectory, journalPath))
+        throw new Error(
+          `The migration journal "${options.journal}" is outside the content directory.`
+        );
+      const targets = state.migrations.filter((record) => {
+        if (options.journal !== void 0)
+          return record.journalPath === options.journal || record.mutationPlanId !== void 0 && journalPath !== void 0 && path5.basename(path5.dirname(journalPath)) === record.mutationPlanId;
+        if (options.migrationId !== void 0)
+          return record.id === options.migrationId && ["applying", "recovery-required", "failed"].includes(record.status);
+        return ["applying", "recovery-required", "failed"].includes(
+          record.status
+        );
+      });
+      const journals = /* @__PURE__ */ new Map();
+      for (const record of targets) {
+        const resolved = record.journalPath !== void 0 ? this.absoluteFromContent(record.journalPath) : record.mutationPlanId !== void 0 ? path5.join(
+          this.contentDirectory,
+          ".riebeckite",
+          "mutations",
+          record.mutationPlanId,
+          "journal.json"
+        ) : void 0;
+        if (!resolved || !await exists(resolved)) continue;
+        const records = journals.get(resolved) ?? [];
+        records.push(record);
+        journals.set(resolved, records);
+      }
+      if (journalPath !== void 0) {
+        if (!await exists(journalPath))
+          return {
+            recovered: false,
+            applied: false,
+            skipped: false,
+            restoredPaths: [],
+            conflicts: [
+              {
+                severity: "error",
+                code: "journal-missing",
+                message: "The mutation journal does not exist."
+              }
+            ]
+          };
+        if (!journals.has(journalPath)) journals.set(journalPath, []);
+      }
+      if (journals.size === 0)
+        return {
+          recovered: false,
+          applied: false,
+          skipped: true,
+          restoredPaths: [],
+          conflicts: []
+        };
+      let nextState = state;
+      let recovered = false;
+      let applied = false;
+      const restoredPaths = [];
+      const conflicts = [];
+      for (const [journal, records] of journals) {
+        const relativeJournal = isWithin(this.contentDirectory, journal) ? this.relativeToContent(journal) : void 0;
+        try {
+          const result = await this.mutation.recover(journal);
+          restoredPaths.push(...result.restoredPaths);
+          if (result.conflicts.length > 0) {
+            conflicts.push(
+              ...result.conflicts.map((issue) => mutationIssue(issue, "error"))
+            );
+            nextState = this.setStatuses(
+              nextState,
+              records,
+              "recovery-required",
+              /* @__PURE__ */ new Date(),
+              relativeJournal
+            );
+            await this.appendHistoryForRecords(
+              records,
+              "failure",
+              "required",
+              relativeJournal
+            );
+            continue;
+          }
+          if (result.recovered) {
+            recovered = true;
+            nextState = this.setStatuses(
+              nextState,
+              records,
+              "rolled-back",
+              /* @__PURE__ */ new Date(),
+              relativeJournal
+            );
+            await this.appendHistoryForRecords(
+              records,
+              "rolled-back",
+              "recovered",
+              relativeJournal
+            );
+            continue;
+          }
+          const snapshot = await readJournalSnapshot(journal);
+          if (snapshot?.state === "complete" && await journalMatchesApplied(this.contentDirectory, snapshot)) {
+            applied = true;
+            nextState = this.setStatuses(
+              nextState,
+              records,
+              "applied",
+              /* @__PURE__ */ new Date(),
+              relativeJournal
+            );
+            await this.appendHistoryForRecords(
+              records,
+              "success",
+              "recovered",
+              relativeJournal
+            );
+          } else if (snapshot?.state === "rolled-back" || snapshot?.state === "recovered") {
+            recovered = true;
+            nextState = this.setStatuses(
+              nextState,
+              records,
+              "rolled-back",
+              /* @__PURE__ */ new Date(),
+              relativeJournal
+            );
+            await this.appendHistoryForRecords(
+              records,
+              "rolled-back",
+              "recovered",
+              relativeJournal
+            );
+          } else {
+            nextState = this.setStatuses(
+              nextState,
+              records,
+              "recovery-required",
+              /* @__PURE__ */ new Date(),
+              relativeJournal
+            );
+            conflicts.push({
+              severity: "error",
+              code: "journal-not-recoverable",
+              message: "The mutation journal is not in a recoverable state."
+            });
+          }
+        } catch (error) {
+          conflicts.push({
+            severity: "error",
+            code: "recovery-failed",
+            message: errorMessage(error)
+          });
+          nextState = this.setStatuses(
+            nextState,
+            records,
+            "recovery-required",
+            /* @__PURE__ */ new Date(),
+            relativeJournal
+          );
+          await this.appendHistoryForRecords(
+            records,
+            "failure",
+            "required",
+            relativeJournal
+          );
+        }
+      }
+      await this.writeState(nextState);
+      return {
+        recovered,
+        applied,
+        skipped: false,
+        restoredPaths,
+        conflicts
+      };
+    } finally {
+      await release();
+    }
+  }
+  async rollback(options) {
+    const release = await this.acquireLock();
+    try {
+      const state = await this.readState();
+      const candidates = state.migrations.filter(
+        (record) => options.planId !== void 0 ? record.planId === options.planId : options.migrationId !== void 0 ? record.id === options.migrationId : false
+      );
+      const target = candidates.filter((record) => record.status === "applied").toSorted((left, right) => right.version - left.version)[0];
+      if (!target) {
+        if (candidates.some((record) => record.status === "rolled-back"))
+          return {
+            rolledBack: false,
+            skipped: true,
+            restoredPaths: [],
+            conflicts: []
+          };
+        return {
+          rolledBack: false,
+          skipped: false,
+          restoredPaths: [],
+          conflicts: [
+            {
+              severity: "error",
+              code: "rollback-not-applied",
+              message: "The migration has no applied state to roll back."
+            }
+          ]
+        };
+      }
+      if (!target.journalPath)
+        return {
+          rolledBack: false,
+          skipped: false,
+          restoredPaths: [],
+          conflicts: [
+            {
+              severity: "error",
+              code: "rollback-journal-missing",
+              message: "The applied migration has no mutation journal."
+            }
+          ]
+        };
+      const batch = state.migrations.filter(
+        (record) => record.status === "applied" && record.planId !== void 0 && record.planId === target.planId
+      );
+      const journal = this.absoluteFromContent(target.journalPath);
+      let result;
+      try {
+        result = await this.mutation.rollback(journal);
+      } catch (error) {
+        return {
+          rolledBack: false,
+          skipped: false,
+          restoredPaths: [],
+          conflicts: [
+            {
+              severity: "error",
+              code: "rollback-failed",
+              message: errorMessage(error)
+            }
+          ]
+        };
+      }
+      if (result.conflicts.length > 0) {
+        const nextState2 = this.setStatuses(
+          state,
+          batch,
+          "recovery-required",
+          /* @__PURE__ */ new Date(),
+          target.journalPath,
+          sanitizeErrorMessage(
+            result.conflicts.map((issue) => issue.message).join(" "),
+            this.contentDirectory
+          )
+        );
+        await this.writeState(nextState2);
+        await this.appendHistoryForRecords(
+          batch,
+          "failure",
+          "required",
+          target.journalPath
+        );
+        return {
+          rolledBack: false,
+          skipped: false,
+          restoredPaths: result.restoredPaths,
+          conflicts: result.conflicts.map(
+            (issue) => mutationIssue(issue, "error")
+          )
+        };
+      }
+      const nextState = this.setStatuses(
+        state,
+        batch,
+        "rolled-back",
+        /* @__PURE__ */ new Date(),
+        target.journalPath,
+        void 0,
+        /* @__PURE__ */ new Date()
+      );
+      await this.writeState(nextState);
+      await this.appendHistoryForRecords(
+        batch,
+        "rolled-back",
+        "recovered",
+        target.journalPath
+      );
+      return {
+        rolledBack: result.rolledBack,
+        skipped: result.skipped,
+        restoredPaths: result.restoredPaths,
+        conflicts: []
+      };
+    } finally {
+      await release();
+    }
+  }
+  async reconcile(record) {
+    if (record.status !== "applying") return record;
+    const journal = record.journalPath ? this.absoluteFromContent(record.journalPath) : record.mutationPlanId ? path5.join(
+      this.contentDirectory,
+      ".riebeckite",
+      "mutations",
+      record.mutationPlanId,
+      "journal.json"
+    ) : void 0;
+    const snapshot = journal ? await readJournalSnapshot(journal) : void 0;
+    if (!snapshot)
+      return {
+        ...record,
+        status: "failed",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...journal ? { journalPath: this.relativeToContent(journal) } : {},
+        error: "The mutation journal is missing."
+      };
+    const relative = this.relativeToContent(journal);
+    if (snapshot.state === "complete") {
+      if (await journalMatchesApplied(this.contentDirectory, snapshot))
+        return {
+          ...record,
+          status: "applied",
+          journalPath: relative,
+          appliedAt: record.appliedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      return {
+        ...record,
+        status: "recovery-required",
+        journalPath: relative,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: "Content changed after the mutation journal completed."
+      };
+    }
+    if (snapshot.state === "rolled-back" || snapshot.state === "recovered")
+      return {
+        ...record,
+        status: "rolled-back",
+        journalPath: relative,
+        rolledBackAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    return {
+      ...record,
+      status: "recovery-required",
+      journalPath: relative,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  preflight(plan, state) {
+    const conflicts = [];
+    for (const migration of plan.migrations) {
+      const records = state.migrations.filter(
+        (record) => record.id === migration.id
+      );
+      const sameVersion = records.find(
+        (record) => record.version === migration.version
+      );
+      if (sameVersion?.status === "applied" && sameVersion.definitionFingerprint !== migration.fingerprint)
+        conflicts.push({
+          severity: "error",
+          code: "migration-definition-changed",
+          message: `Migration "${migration.id}" changed without a version bump.`,
+          path: void 0
+        });
+      const higher = records.find(
+        (record) => record.version > migration.version && record.status === "applied"
+      );
+      if (higher)
+        conflicts.push({
+          severity: "error",
+          code: "migration-version-regressed",
+          message: `Migration "${migration.id}" version ${migration.version} is older than the applied version ${higher.version}.`
+        });
+      if (records.some(
+        (record) => record.version === migration.version && record.status === "applying"
+      ))
+        conflicts.push({
+          severity: "error",
+          code: "migration-in-progress",
+          message: `Migration "${migration.id}" is still applying; recover it first.`
+        });
+      if (records.some(
+        (record) => record.version === migration.version && record.status === "recovery-required"
+      ))
+        conflicts.push({
+          severity: "error",
+          code: "recovery-required",
+          message: `Migration "${migration.id}" requires recovery before it can be applied again.`
+        });
+    }
+    return conflicts;
+  }
+  stateWith(plan, migrations, state, status, now, extra = {}) {
+    let next = state;
+    for (const migration of migrations) {
+      const prior = findContentMigrationRecord(
+        state,
+        migration.id,
+        migration.version
+      );
+      next = upsertContentMigrationRecord(
+        next,
+        {
+          id: migration.id,
+          version: migration.version,
+          definitionFingerprint: migration.fingerprint,
+          status,
+          planId: plan.id,
+          planFingerprint: plan.planFingerprint,
+          contentFingerprint: plan.baseContentFingerprint,
+          mutationPlanId: plan.mutationPlanId,
+          mutationPlanFingerprint: plan.mutationPlanFingerprint,
+          journalPath: extra.journalPath ?? prior?.journalPath,
+          changedPaths: plan.changes.map((change) => change.path),
+          updatedAt: now.toISOString(),
+          appliedAt: status === "applied" ? prior?.appliedAt ?? now.toISOString() : prior?.appliedAt,
+          rolledBackAt: extra.rolledBackAt ?? prior?.rolledBackAt,
+          error: extra.error
+        },
+        now
+      );
+    }
+    return next;
+  }
+  supersede(migrations, state, now) {
+    let next = state;
+    for (const migration of migrations) {
+      for (const record of state.migrations) {
+        if (record.id === migration.id && record.version < migration.version && record.status === "applied")
+          next = upsertContentMigrationRecord(
+            next,
+            {
+              ...record,
+              status: "superseded",
+              updatedAt: now.toISOString()
+            },
+            now
+          );
+      }
+    }
+    return next;
+  }
+  setStatuses(state, records, status, now, journalPath, error, rolledBackAt) {
+    const keys = new Set(
+      records.map((record) => `${record.id}@${record.version}`)
+    );
+    let next = state;
+    for (const record of state.migrations) {
+      if (!keys.has(`${record.id}@${record.version}`)) continue;
+      next = upsertContentMigrationRecord(
+        next,
+        {
+          ...record,
+          status,
+          journalPath: journalPath ?? record.journalPath,
+          updatedAt: now.toISOString(),
+          appliedAt: status === "applied" ? record.appliedAt ?? now.toISOString() : record.appliedAt,
+          rolledBackAt: rolledBackAt?.toISOString() ?? record.rolledBackAt,
+          error
+        },
+        now
+      );
+    }
+    return next;
+  }
+  async appendHistory(plan, migrations, status, recoveryState, journal) {
+    if (migrations.length === 0) return;
+    const created = plan.changes.filter(
+      (change) => change.beforeFingerprint === null
+    ).length;
+    const deleted = plan.changes.filter(
+      (change) => change.afterFingerprint === null
+    ).length;
+    const updated = plan.changes.length - created - deleted;
+    const history = await this.readHistory();
+    let next = history;
+    for (const migration of migrations) {
+      const run = {
+        id: migration.id,
+        version: migration.version,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        planId: plan.id,
+        mutationPlanId: plan.mutationPlanId,
+        planFingerprint: plan.planFingerprint,
+        contentFingerprint: plan.baseContentFingerprint,
+        mutationPlanFingerprint: plan.mutationPlanFingerprint,
+        status,
+        created,
+        updated,
+        deleted,
+        moved: plan.impact.moved,
+        changedCount: plan.changes.length,
+        recoveryState,
+        journal
+      };
+      next = appendContentMigrationHistory(next, run);
+    }
+    await this.writeHistory(next);
+  }
+  async appendHistoryForRecords(records, status, recoveryState, journal) {
+    if (records.length === 0) return;
+    const history = await this.readHistory();
+    let next = history;
+    for (const record of records) {
+      if (!record.planId) continue;
+      const run = {
+        id: record.id,
+        version: record.version,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        planId: record.planId,
+        mutationPlanId: record.mutationPlanId,
+        planFingerprint: record.planFingerprint ?? "",
+        contentFingerprint: record.contentFingerprint ?? "",
+        mutationPlanFingerprint: record.mutationPlanFingerprint,
+        status,
+        created: 0,
+        updated: 0,
+        deleted: 0,
+        moved: 0,
+        changedCount: record.changedPaths.length,
+        recoveryState,
+        journal
+      };
+      next = appendContentMigrationHistory(next, run);
+    }
+    await this.writeHistory(next);
+  }
+  async failedJournal(plan) {
+    const journal = path5.join(
+      this.contentDirectory,
+      ".riebeckite",
+      "mutations",
+      plan.mutationPlanId,
+      "journal.json"
+    );
+    try {
+      await fs5.access(journal);
+      return this.relativeToContent(journal);
+    } catch {
+      return void 0;
+    }
+  }
+  async currentContentFingerprint() {
+    const entries = (await this.source.scan()).filter(
+      (entry) => entry.path.toLowerCase().endsWith(".md")
+    );
+    return fingerprintContentFiles(
+      await Promise.all(
+        entries.map(async (entry) => ({
+          path: entry.path,
+          content: await this.source.read(entry)
+        }))
+      )
+    );
+  }
+  async readState() {
+    return readMigrationState(this.contentDirectory);
+  }
+  async writeState(state) {
+    return writeMigrationState(this.contentDirectory, state);
+  }
+  async readHistory() {
+    return readMigrationHistory(this.contentDirectory);
+  }
+  async writeHistory(history) {
+    return writeMigrationHistory(this.contentDirectory, history);
+  }
+  relativeToContent(target) {
+    return sanitizeContentMigrationPath(
+      path5.relative(this.contentDirectory, target).split(path5.sep).join("/")
+    );
+  }
+  absoluteFromContent(target) {
+    return path5.isAbsolute(target) ? target : path5.join(this.contentDirectory, target);
+  }
+  async acquireLock() {
+    const lockPath = migrationLockPath(this.contentDirectory);
+    await fs5.mkdir(path5.dirname(lockPath), { recursive: true });
+    let handle;
+    for (let attempt = 0; attempt < 3 && !handle; attempt += 1) {
+      try {
+        handle = await fs5.open(lockPath, "wx");
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        const stale = await staleLockContent(lockPath);
+        if (stale === null)
+          throw new Error(
+            "Another migration is already applying or requires recovery."
+          );
+        const quarantine = `${lockPath}.stale-${randomUUID2()}`;
+        try {
+          await fs5.rename(lockPath, quarantine);
+        } catch (renameError) {
+          if (renameError.code === "ENOENT")
+            continue;
+          throw renameError;
+        }
+        const quarantined = await fs5.readFile(quarantine, "utf8");
+        if (quarantined !== stale) {
+          await fs5.writeFile(lockPath, quarantined, { flag: "wx" }).then(
+            () => void 0,
+            () => void 0
+          );
+          await fs5.rm(quarantine, { force: true });
+          throw new Error(
+            "Another migration is already applying or requires recovery."
+          );
+        }
+        await fs5.rm(quarantine, { force: true });
+      }
+    }
+    if (!handle)
+      throw new Error(
+        "Another migration is already applying or requires recovery."
+      );
+    const token = randomUUID2();
+    await handle.writeFile(
+      JSON.stringify({
+        pid: process.pid,
+        token,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    return async () => {
+      await handle.close();
+      try {
+        const current = JSON.parse(await fs5.readFile(lockPath, "utf8"));
+        if (isRecord(current) && current.token === token)
+          await fs5.rm(lockPath, { force: true });
+      } catch {
+      }
+    };
+  }
+  async tryAnalyze(source) {
+    try {
+      return { analysis: await this.analyze(source), diagnostics: [] };
+    } catch (error) {
+      const path7 = errorPath(error);
+      return {
+        diagnostics: [
+          {
+            severity: "error",
+            code: "manifest-build-failed",
+            message: `The content manifest could not be built: ${errorMessage(error)}`,
+            ...path7 === void 0 ? {} : { path: path7 }
+          }
+        ]
+      };
+    }
+  }
+  async analyze(source) {
+    const manager = new ContentManager(source, [], {
+      config: this.options.config,
+      plugins: this.options.plugins ? [...this.options.plugins] : void 0,
+      commitBuildState: false,
+      publishingBuildTime: this.options.buildTime
+    });
+    try {
+      const manifest = await manager.getManifest();
+      const locations = await manager.getContentLocations();
+      const snapshot = manager.getCompletedBuildSnapshot();
+      return {
+        manifest,
+        locations,
+        publicationFingerprint: publicationFingerprint(
+          publicationEntriesFromManifest(manifest),
+          publicationRedirectsFromManifest(manifest),
+          publicationOutputsFromManifest(manifest)
+        ),
+        derivedViews: snapshot?.derivedViews.length ?? 0
+      };
+    } finally {
+      await manager.dispose();
+    }
+  }
+  redirectOperations(batch, beforeManifest, afterManifest, field) {
+    const operations = [];
+    for (const file of batch.files) {
+      if (file.originalPath === file.path) continue;
+      const beforeEntry = findEntry(beforeManifest, file.originalPath);
+      const afterEntry = findEntry(afterManifest, file.path);
+      if (!beforeEntry || !afterEntry || beforeEntry.permalink === afterEntry.permalink)
+        continue;
+      const current = file.frontmatter[field];
+      const redirects = typeof current === "string" ? [current] : Array.isArray(current) ? current.filter(
+        (entry) => typeof entry === "string"
+      ) : [];
+      if (redirects.includes(beforeEntry.permalink)) continue;
+      operations.push({
+        kind: "frontmatter",
+        path: file.path,
+        set: { [field]: [...redirects, beforeEntry.permalink] },
+        remove: []
+      });
+    }
+    return operations;
+  }
+  verify(input) {
+    const diagnostics = [];
+    const beforeDiagnostics = new Set(
+      input.before.manifest.diagnostics.map(diagnosticKey)
+    );
+    for (const diagnostic of input.after.manifest.diagnostics) {
+      if (diagnostic.severity !== "error") continue;
+      if (beforeDiagnostics.has(diagnosticKey(diagnostic))) continue;
+      diagnostics.push({
+        severity: "error",
+        code: diagnostic.code,
+        message: diagnostic.message,
+        path: diagnostic.filePath
+      });
+    }
+    const permalinks = /* @__PURE__ */ new Map();
+    for (const entry of input.after.manifest.entries) {
+      const existing = permalinks.get(entry.permalink);
+      if (existing !== void 0) {
+        diagnostics.push({
+          severity: "error",
+          code: "permalink-collision",
+          message: `Content "${existing}" and "${entry.slug}" share the permalink "${entry.permalink}".`
+        });
+      } else permalinks.set(entry.permalink, entry.slug);
+    }
+    for (const file of input.batch.files) {
+      const beforeEntry = findEntry(input.before.manifest, file.originalPath);
+      const afterEntry = findEntry(input.after.manifest, file.path);
+      if (!afterEntry) {
+        diagnostics.push({
+          severity: "error",
+          code: "manifest-entry-missing",
+          message: "The migrated content is missing from the future manifest.",
+          path: file.path
+        });
+        continue;
+      }
+      if (!beforeEntry) continue;
+      const changed = changedFrontmatterKeys(file);
+      if (beforeEntry.contentId !== afterEntry.contentId && file.frontmatter.id === file.originalFrontmatter.id)
+        diagnostics.push({
+          severity: "error",
+          code: "content-id-changed",
+          message: "The migration changed the content ID without an explicit id rule.",
+          path: file.path
+        });
+      if (beforeEntry.publishing.visibility !== afterEntry.publishing.visibility && !changed.has("visibility") && !changed.has("published") && !changed.has("publish") && !changed.has("private") && !changed.has("draft") && !changed.has("publishAt"))
+        diagnostics.push({
+          severity: "error",
+          code: "visibility-changed",
+          message: "The migration changed the publishing visibility without an explicit rule.",
+          path: file.path
+        });
+      if (beforeEntry.permalink !== afterEntry.permalink && (beforeEntry.publishing.visibility === "public" || beforeEntry.publishing.visibility === "unlisted") && !input.after.manifest.redirects.has(beforeEntry.permalink))
+        diagnostics.push({
+          severity: "error",
+          code: "permalink-redirect-missing",
+          message: `The previous permalink "${beforeEntry.permalink}" has no redirect.`,
+          path: file.path
+        });
+    }
+    return { diagnostics };
+  }
+};
+function createFutureContentSource(base, changes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const change of changes) map.set(change.path, change.content);
+  return {
+    changes: map,
+    async scan() {
+      const entries = /* @__PURE__ */ new Map();
+      for (const entry of await base.scan()) entries.set(entry.path, entry);
+      for (const [changePath, content] of map) {
+        if (content === null) entries.delete(changePath);
+        else
+          entries.set(changePath, {
+            path: changePath,
+            metadata: entries.get(changePath)?.metadata
+          });
+      }
+      return [...entries.values()].sort(
+        (left, right) => left.path.localeCompare(right.path)
+      );
+    },
+    async read(entry) {
+      const content = map.get(entry.path);
+      if (content === null)
+        throw new Error(`The content path "${entry.path}" was deleted.`);
+      if (content !== void 0) return content;
+      return await base.read(entry);
+    }
+  };
+}
+function fingerprintContentFiles(files) {
+  return fingerprintFiles(files);
+}
+
+// src/path_helpers.ts
+import path6 from "node:path";
+import { normalizeContentPath as normalizeContentPath2 } from "@riebeckite/core";
+function isPathInsideDirectory(directory, file) {
+  const root = normalizeForCompare(directory).replace(/\/+$/, "");
+  if (!root) return false;
+  const target = normalizeForCompare(file);
+  return target === root || target.startsWith(`${root}/`);
+}
+function toLogicalPath(directory, file) {
+  return normalizeContentPath2(
+    path6.relative(normalizeContentPath2(directory), normalizeContentPath2(file))
+  );
+}
+function normalizeForCompare(value) {
+  const normalized = normalizeContentPath2(value);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
 export {
+  FileSystemContentMigration,
+  FileSystemContentMutation,
   FileSystemContentSource,
   INTERNAL_CONTENT_IGNORE_PATTERNS,
+  createContentSource,
+  createFutureContentSource,
+  fingerprintContentFiles,
   isIgnoredContentPath,
-  matchContentExcludePattern
+  isPathInsideDirectory,
+  matchContentExcludePattern,
+  toLogicalPath
 };