@hawkeyexl/manni 2.12.0 → 3.0.0

package/dist/{chunk-UKRYPLZS.js → chunk-W75SLU7Z.js}

@@ -12,10 +12,12 @@ import {
   STDIN_LABEL,
   STDIN_TOKEN,
   ToolError,
+  __default,
   __export,
   assertNonEmpty,
   classifyRef,
   committedKeyWarning,
+  configMarks,
   decryptValue,
   encryptValue,
   ensureEncryptionKey,
@@ -50,11 +52,12 @@ import {
   loadExternalMetadata,
   locateFrontmatter,
   memberOf,
-  mergeExternalMetadata,
+  mergeWithMarks,
   normalizeText,
   orphanEntries,
   orphanError,
   orphanJoins,
+  ownsKey,
   pageManifestPath,
   palette,
   parseLines,
@@ -81,7 +84,7 @@ import {
   withValueAt,
   writeEncryptionKey,
   writeFileAtomic
-} from "./chunk-P4V5IMHM.js";
+} from "./chunk-I6PYC7EP.js";
 
 // src/meta/core/reencrypt.ts
 import { extname } from "node:path";
@@ -577,123 +580,6 @@ async function readTracked(root, path) {
 import { extname as extname2 } from "node:path";
 import * as Ajv2020Ns from "ajv/dist/2020.js";
 
-// src/cite/schema/citations.json
-var citations_default = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "manni:citations:1.0.0-proposal.4",
-  title: "manni citations vocabulary (1.0.0-proposal.4)",
-  description: "What do this page's claims rest on? For each claim, the page lines that make it, the source lines it was written from, and a hash of each. A manni common vocabulary: any drift check can implement it, and other schemas may compose on top of it. A pin is a record of the past, not a copy of the present. It says what the lines were when the sentence was written. The check compares that record with the files as they are now. Recompute it on every run and there is nothing to compare against. `source-of-truth` (manni:stewardship) names the file a page answers to; a citation names the lines a sentence answers to. The page root stays open so sibling tools' keys pass untouched. The `citation-` prefix is reserved, so an unrecognized `citation-*` key is rejected and a typo fails loudly.",
-  type: "object",
-  additionalProperties: true,
-  properties: {
-    citations: {
-      type: "array",
-      minItems: 1,
-      items: {
-        $ref: "#/$defs/citationEntry"
-      },
-      description: "The page's citations, one entry per claim or pin. An empty list is not a declaration; a page with no citations omits the key. Ids are unique within a page, and two entries claiming one id is an error. JSON Schema cannot say that over a list whose members may omit the id. So it is a requirement on implementations, stated here so every tool agrees.",
-      "x-manni-location": "external"
-    }
-  },
-  patternProperties: {
-    "^citation-": false
-  },
-  $defs: {
-    citationEntry: {
-      type: "object",
-      additionalProperties: false,
-      required: [
-        "source"
-      ],
-      description: "One citation: the page text it supports, the source lines it rests on, and how the two are anchored. Both ends share one shape, a line range and a hash.",
-      properties: {
-        id: {
-          type: "string",
-          pattern: "^[a-z0-9][a-z0-9-]*$",
-          description: "A kebab-case name for this citation, unique within the page. A body marker names an entry by it, and findings are reported under it. Optional for an entry anchored by its claim lines or pinned bare. Required when a marker names the entry."
-        },
-        claim: {
-          $ref: "#/$defs/claim"
-        },
-        source: {
-          $ref: "#/$defs/source"
-        },
-        quote: {
-          type: "boolean",
-          default: false,
-          description: "The claim is a fenced block that reproduces the source lines. The pinned claim covers the whole block, fences included. An implementer compares the lines inside the fences with the source under the pin's rule. So a quoted snippet that drifts from its source is a finding even while the pin still holds. Under a marker, the block is the next fence after the marker. Default false."
-        }
-      }
-    },
-    claim: {
-      type: "object",
-      additionalProperties: false,
-      required: [
-        "integrity"
-      ],
-      description: "The page text the citation supports, pinned by lines and a hash. Absent, the entry is a bare pin, or a marker with no drift check on its sentence. Without `lines`, the text pinned is what a body marker naming this entry anchors.",
-      properties: {
-        lines: {
-          $ref: "#/$defs/lines",
-          description: "Lines of the page body. The body starts on the first line after the closing frontmatter fence, or on line 1 with no frontmatter. So editing the frontmatter never moves a claim. Required unless a marker names the entry, and never inside the frontmatter."
-        },
-        integrity: {
-          type: "string",
-          pattern: "^sha256-[0-9a-f]{64}$",
-          description: "`sha256-` and sixty-four lowercase hex digits over the claimed lines, under the rule `source.integrity` states. Always plain, never keyed: the page is public, so there is nothing to hide. With a marker, the lines hashed are the ones the marker anchors."
-        }
-      }
-    },
-    source: {
-      type: "object",
-      additionalProperties: false,
-      required: [
-        "file",
-        "integrity"
-      ],
-      description: "The lines the claim rests on: a file, an optional line range, a pin, and the commit the pin was taken at.",
-      properties: {
-        file: {
-          $ref: "#/$defs/fileRef"
-        },
-        lines: {
-          $ref: "#/$defs/lines",
-          description: "File lines. Absent, the whole file is pinned. The lines stay readable even when `file` is encrypted."
-        },
-        integrity: {
-          type: "string",
-          pattern: "^(?:sha256|hmac-sha256)-[0-9a-f]{64}$",
-          description: "The pin: an algorithm prefix and sixty-four lowercase hex digits over the cited lines under one rule. Decode as UTF-8 and drop one leading byte-order mark. Turn CRLF into LF, split on LF, and discard the empty element a trailing LF leaves. Take lines L1 to L2 inclusive, or every line for a whole file. Join with LF and no trailing LF, and keep trailing whitespace. A plain `file` is pinned `sha256-` over that text. An encrypted `file` is pinned `hmac-sha256-`: the HMAC-SHA256 of that text under a key derived from the encryption key. So a public page carries no verifier a reader could run against a guessed private line. The prefix follows `file`, and any other pairing is an invalid entry."
-        },
-        "commit-sha": {
-          type: "string",
-          pattern: "^[0-9a-f]{7,64}$",
-          description: "The git commit hash the source pin was taken at, as lowercase hex. Seven digits is what git abbreviates to; sixty-four covers a SHA-256 repository. A tool writes the full hash, because an abbreviation that is unique today need not be next year. Without it, a check can still say the lines changed. With it, the check can say since when, and whether the pin was ever true."
-        }
-      }
-    },
-    lines: {
-      oneOf: [
-        {
-          type: "integer",
-          minimum: 1
-        },
-        {
-          type: "string",
-          pattern: "^[1-9][0-9]*-[1-9][0-9]*$"
-        }
-      ],
-      description: 'A line range, 1-based and inclusive: an integer for one line, or `"L1-L2"` for several. `L1 <= L2` is a rule on implementations, since a pattern cannot compare two numbers. There is no line 0 to cite.'
-    },
-    fileRef: {
-      type: "string",
-      pattern: "^(?:~[A-Za-z0-9_-]{82,}|(?!~)(?:(?!\\.\\.?(?:/|$))[^/\\\\:\\r\\n\\t]+)(?:/(?:(?!\\.\\.?(?:/|$))[^/\\\\:\\r\\n\\t]+))*)$",
-      description: "The file: a path relative to the repository root, posix-separated, and free of `.` and `..` segments. Segments may hold spaces and dots but not `/`, `\\`, `:` or a line break. So a URL, a drive letter, a Windows path and an absolute path all fail here. In place of the path, `~` and at least 82 base64url characters is the path encrypted with the family key. Proposal 0045 states the construction. Only a checkout with the key and the files can decrypt the path and read the lines. So a public docs repo can cite a private code repo without publishing its paths. The value carries no encryption mark, because the citation tool encrypts it, and a plain path stays valid."
-    }
-  }
-};
-
 // src/shared/code-regions.ts
 var SKIP_MARKDOWN_FENCE = /^[ \t]*(`{3,}|~{3,})/;
 var SKIP_ASCIIDOC_FENCE = /^(-{4,})/;
@@ -1215,9 +1101,9 @@ var entryValidator;
 function compileEntryValidator() {
   if (entryValidator) return entryValidator;
   const ajv = new Ajv2020({ allErrors: false, strict: false });
-  ajv.addSchema(citations_default);
+  ajv.addSchema(__default);
   entryValidator = ajv.compile({
-    $ref: `${citations_default.$id}#/$defs/citationEntry`
+    $ref: `${__default.$id}#/$defs/citationEntry`
   });
   return entryValidator;
 }
@@ -1900,6 +1786,19 @@ function gitClient(root) {
   });
   return {
     available,
+    shallow,
+    // `merge-base --is-ancestor` exits 0 for yes and 1 for no. For a commit
+    // it does not have it exits 128, `Not a valid commit name`, which reads
+    // as git failing. So `hasCommit` answers first, and is required rather
+    // than an optimization: a commit git lacks is in no history it holds,
+    // which is a no, and exactly the pin a deleted branch leaves behind.
+    isAncestor: (commit, of) => once(`ancestor\0${commit}\0${of}`, async () => {
+      if (!await hasCommit(commit)) return false;
+      const out = await run2(root, ["merge-base", "--is-ancestor", "--end-of-options", commit, of]);
+      if (out.ok) return true;
+      if (out.code === 1) return false;
+      throw failed("merge-base", out);
+    }),
     head: () => once("head", async () => {
       if (!await available()) return null;
       const out = await run2(root, ["rev-parse", "HEAD"]);
@@ -1966,6 +1865,7 @@ function gitClient(root) {
 var UNIT = "";
 var GIT_UNAVAILABLE_HISTORY = "git is not available here, so citations are checked without history: no never-true, no reanchored claims, no diffs, no commit subjects.";
 var PAGE_HISTORY_UNAVAILABLE = "the page history ends before the pin held; use fetch-depth: 0 to tell reanchored claims from changed ones";
+var SHALLOW_RECOMMIT = "this clone is shallow, so --recommit re-recorded only commits that do not contain their lines. Fetch full history to check the rest.";
 var GIT_UNAVAILABLE_COMMIT = "git is not available here, so the citation records no commit.";
 function noGit() {
   return {
@@ -2502,52 +2402,80 @@ function twoManifestsRefusal(label, a, b) {
   return `${label} is in collections ${a} and ${b}, and both keep citations in a manifest.`;
 }
 function ownsCitations(manifest) {
-  return manifest.keys.includes(CITATIONS_KEY2);
+  return manifest.keys === void 0 || manifest.keys.includes(CITATIONS_KEY2);
+}
+function emptyIndex() {
+  return { owners: /* @__PURE__ */ new Map(), byPath: /* @__PURE__ */ new Map(), byField: /* @__PURE__ */ new Map(), entries: [] };
 }
 async function loadCitationSidecars(opts) {
   const toError = opts.toError ?? ((message) => new CiteError(message));
   const manifests = [];
+  const urls = [];
   const scoped = [];
   for (const collection of opts.collections) {
     const owning = collection.externalMetadata.filter(ownsCitations);
     if (owning.length === 0) continue;
+    const loaded = [];
     for (const manifest of owning) {
+      const implied = manifest.keys === void 0 ? { implied: { collection, manifest } } : {};
       if (classifyRef(manifest.file).kind === "url") {
-        throw toError(urlManifestRefusal(opts.configSource, collection.name));
+        if (manifest.keys !== void 0) {
+          throw toError(urlManifestRefusal(opts.configSource, collection.name));
+        }
+        urls.push({ collection: collection.name, path: manifest.file, file: manifest.file, join: externalMetadataJoin(manifest), ...implied });
+        continue;
       }
+      loaded.push(manifest);
       const path = isAbsolute(manifest.file) ? manifest.file : resolve(opts.configDir, manifest.file);
       manifests.push({
         collection: collection.name,
         path,
         file: reportedPath(path, opts.base),
         join: externalMetadataJoin(manifest),
-        ...hasPagePlaceholder(manifest.file) ? { pattern: manifest.file } : {}
+        ...hasPagePlaceholder(manifest.file) ? { pattern: manifest.file } : {},
+        ...implied
       });
     }
-    scoped.push({ ...collection, externalMetadata: owning });
+    if (loaded.length > 0) scoped.push({ ...collection, externalMetadata: loaded });
   }
-  if (manifests.length === 0) return null;
+  if (manifests.length === 0 && urls.length === 0) return null;
   const index = await loadExternalMetadata(scoped, {
     configDir: opts.configDir,
     base: opts.base,
     ...opts.pages === void 0 ? {} : { pages: opts.pages }
-  });
+  }) ?? (urls.length > 0 ? emptyIndex() : null);
   if (index === null) return null;
-  return sidecars(index, manifests, scoped, opts);
+  return sidecars(index, manifests, urls, scoped, opts);
 }
-function sidecars(index, manifests, collections, opts) {
+function sidecars(index, manifests, urls, collections, opts) {
   const toError = opts.toError ?? ((message) => new CiteError(message));
   const { configDir, base } = opts;
+  let marks;
+  const marksOnce = () => marks ??= opts.marks?.() ?? Promise.resolve(void 0);
   const pageOwner = (owner, label) => {
     if (owner.pattern === void 0) return owner;
     const resolved = pageManifestPath(owner.pattern, configDir, resolve(base, label));
     if ("outside" in resolved) return void 0;
     return { ...owner, path: resolved.abs, file: reportedPath(resolved.abs, base) };
   };
-  const forPage = (label, content, format) => {
+  const forPage = async (label, content, format) => {
+    const declaredMembers = memberOf(opts.collections, configDir, base, label);
+    if (declaredMembers.length === 0) return { joins: [] };
     const members = memberOf(collections, configDir, base, label);
-    if (members.length === 0) return { joins: [] };
-    const mine = manifests.filter((m) => members.includes(m.collection));
+    const memberOfCollection = (m) => declaredMembers.includes(m.collection);
+    let extracted;
+    const extract = () => extracted ??= pickExtractor(label, format).extract(content, label);
+    const candidates2 = [...manifests, ...urls].filter((m) => m.implied !== void 0 && memberOfCollection(m));
+    let marked;
+    if (candidates2.length > 0) {
+      const read = await marksOnce();
+      const data = extract().data;
+      marked = read === void 0 ? void 0 : await read(label, Object.hasOwn(data, CITATIONS_KEY2) ? data : { ...data, [CITATIONS_KEY2]: null }, declaredMembers);
+    }
+    const keeps = (m) => m.implied === void 0 || ownsKey(m.implied.collection, m.implied.manifest, CITATIONS_KEY2, marked);
+    const url = urls.find((m) => memberOfCollection(m) && keeps(m));
+    if (url !== void 0) throw toError(urlManifestRefusal(opts.configSource, url.collection));
+    const mine = manifests.filter((m) => members.includes(m.collection) && keeps(m));
     const [declared, second] = mine;
     if (declared === void 0) return { joins: [] };
     if (second !== void 0) {
@@ -2555,17 +2483,17 @@ function sidecars(index, manifests, collections, opts) {
     }
     const owner = pageOwner(declared, label);
     if (owner === void 0) return { joins: [] };
-    const extractor = pickExtractor(label, format);
-    const extracted = extractor.extract(content, label);
-    const merged = mergeExternalMetadata(label, extracted, index, members, base, {
-      encryptionKey: () => opts.key
+    const readMarks = await marksOnce();
+    const merged = await mergeWithMarks(label, extract(), index, members, base, {
+      encryptionKey: () => opts.key,
+      ...readMarks === void 0 ? {} : { marks: readMarks }
     });
     const out = { owner, joins: merged.joins };
     if (owner.join === PATH_JOIN) {
       out.entry = toPosix(relative(configDir, resolve(base, label)));
     } else {
       const value = merged.joins.find((j) => j.field === owner.join)?.value;
-      const raw = value ?? extracted.data[owner.join];
+      const raw = value ?? extract().data[owner.join];
       if (typeof raw === "string" && raw !== "") out.entry = raw;
       else if (typeof raw === "number" || typeof raw === "boolean") out.entry = String(raw);
     }
@@ -2624,6 +2552,7 @@ function duplicateJoinRefusal(field, value, file, labels) {
 function sidecarsFor(run3, over = {}) {
   const declared = run3.configFile?.collections ?? [];
   if (run3.configDir === void 0 || declared.length === 0) return Promise.resolve(null);
+  const { configPath } = run3;
   return loadCitationSidecars({
     // Every declared collection, whatever `--collection` or the paths chose.
     collections: declared,
@@ -2632,7 +2561,10 @@ function sidecarsFor(run3, over = {}) {
     configSource: run3.configSource ?? run3.configPath ?? "the config",
     ...run3.key === void 0 ? {} : { key: run3.key },
     ...over.toError === void 0 ? {} : { toError: over.toError },
-    ...over.pages === void 0 ? {} : { pages: over.pages }
+    ...over.pages === void 0 ? {} : { pages: over.pages },
+    // A keyless manifest (proposal 0068) keeps what a page's schemas mark,
+    // read from meta's section of the same file.
+    ...configPath === void 0 ? {} : { marks: () => configMarks(configPath, run3.base) }
   });
 }
 
@@ -3400,7 +3332,7 @@ async function checkCitations(page, opts) {
     page: read,
     lines,
     root: opts.root,
-    index: index ?? emptyIndex,
+    index: index ?? emptyIndex2,
     checkSources,
     ...opts.key === void 0 ? {} : { key: opts.key }
   };
@@ -3511,7 +3443,7 @@ function skippedSource(entry) {
   if (source["commit-sha"] !== void 0) out.commitSha = source["commit-sha"];
   return out;
 }
-var emptyIndex = { files: () => [], has: () => false };
+var emptyIndex2 = { files: () => [], has: () => false };
 
 // src/cite/core/mint.ts
 var COMMIT_PATTERN = /^[0-9a-f]{7,64}$/;
@@ -3868,8 +3800,8 @@ async function prepareRun(opts, action, verb, sources = {}) {
   };
   if (checkSources) pageOptions.sourceIndex = await sourceIndexFor(run3.root, git);
   const sidecars2 = await sidecarsFor(run3, { pages: files.map((file) => resolve3(base, file)) });
-  const setupFor = (label, content) => {
-    const page = sidecars2?.forPage(label, content, forced?.name);
+  const setupFor = async (label, content) => {
+    const page = await sidecars2?.forPage(label, content, forced?.name);
     if (page?.owner === void 0) return { options: pageOptions };
     return {
       sidecar: page,
@@ -3933,7 +3865,7 @@ async function runCheck(opts) {
   const hits = joinHits();
   const pages = [];
   const checkOne = async (label, content) => {
-    const setup = prepared.setupFor(label, content);
+    const setup = await prepared.setupFor(label, content);
     if (setup.sidecar !== void 0) hits.record(setup.sidecar, label);
     pages.push(await checkCitations({ file: label, content, format: forced?.name }, setup.options));
   };
@@ -4055,7 +3987,7 @@ async function runAdd(opts) {
       `A page read from stdin has no path, and its citations live in ${firstManifest.file}, which is keyed by ${keyedBy}.`
     );
   }
-  const sidecar = usingStdin ? void 0 : sidecars2?.forPage(label, content, opts.as);
+  const sidecar = usingStdin ? void 0 : await sidecars2?.forPage(label, content, opts.as);
   const owner = sidecar?.owner;
   const page = readPage(label, content, {
     ...opts.as === void 0 ? {} : { format: opts.as },
@@ -4351,7 +4283,7 @@ async function runRemove(opts) {
   const pageCount = files.length + (usingStdin ? 1 : 0);
   const planned = [];
   const removeOne = async (label, content, path) => {
-    const setup = prepared.setupFor(label, content);
+    const setup = await prepared.setupFor(label, content);
     if (setup.sidecar !== void 0) hits.record(setup.sidecar, label);
     const owner = setup.sidecar?.owner;
     const page = readPage(label, content, {
@@ -4806,6 +4738,7 @@ function rewriteOf(plan) {
         reason: "recommitted",
         // The source itself held. Only its date was wrong.
         status: "current",
+        because: plan.because,
         from: plan.from,
         to: plan.commitSha,
         fromCommit: plan.from,
@@ -5017,19 +4950,29 @@ async function runUpdate(opts) {
       "--recommit needs git to verify recorded commits, and git is not available here."
     );
   }
+  const outsideHistory = async (commit, head) => {
+    if (git.shallow === void 0 || git.isAncestor === void 0) return false;
+    if (await git.shallow()) return false;
+    return !await git.isAncestor(commit, head);
+  };
   const recommitFor = async (result) => {
     const recorded = result.citation.source["commit-sha"];
     const path = result.source.resolvedPath;
     if (recorded === void 0 || path === void 0) return void 0;
+    const head = await git.head();
+    if (head === null || head === recorded) return void 0;
     const range = sourceRange(result.citation.source);
     const pin = result.citation.source.integrity;
     const key = range.encrypted ? run3.key : void 0;
-    const was = await historyOf(git, recorded, path, range, pin, key, void 0);
-    if (was.kind !== "never-true") return void 0;
-    const head = await git.head();
-    if (head === null || head === recorded) return void 0;
+    let because;
+    if (await outsideHistory(recorded, head)) because = "not-in-history";
+    else {
+      const was = await historyOf(git, recorded, path, range, pin, key, void 0);
+      if (was.kind !== "never-true") return void 0;
+      because = "not-contained";
+    }
     const now = await historyOf(git, head, path, range, pin, key, void 0);
-    return now.kind === "original" ? head : void 0;
+    return now.kind === "original" ? { commit: head, because } : void 0;
   };
   const plansFor = async (result, entry, page, lines, lineNow, declined) => {
     const out = [];
@@ -5129,7 +5072,8 @@ async function runUpdate(opts) {
           kind: "source-recommitted",
           result,
           from: result.citation.source["commit-sha"] ?? "",
-          commitSha: to
+          commitSha: to.commit,
+          because: to.because
         });
       }
     }
@@ -5227,7 +5171,7 @@ async function runUpdate(opts) {
   };
   const pages = [];
   const updateOne = async (label, content, path) => {
-    const setup = prepared.setupFor(label, content);
+    const setup = await prepared.setupFor(label, content);
     if (setup.sidecar !== void 0) hits.record(setup.sidecar, label);
     const report = await checkCitations({ file: label, content, format: forced?.name }, setup.options);
     const { format } = report;
@@ -5444,7 +5388,12 @@ async function runUpdate(opts) {
   const reminted = pages.some(
     (page) => page.rewritten.some((r) => r.reason === "accepted" && r.end === "source")
   );
-  sayNotices(reports, opts.onNotice, reminted && !await git.available() ? [GIT_UNAVAILABLE_COMMIT] : []);
+  const also = [];
+  if (reminted && !await git.available()) also.push(GIT_UNAVAILABLE_COMMIT);
+  if (recommit && git.shallow !== void 0 && git.isAncestor !== void 0 && await git.shallow()) {
+    also.push(SHALLOW_RECOMMIT);
+  }
+  sayNotices(reports, opts.onNotice, also);
   const rewritten = pages.reduce((n, page) => n + citationsIn(page.rewritten), 0);
   const skipped = pages.reduce((n, page) => n + page.skipped.length + page.refused.length, 0);
   const undone = pages.some(
@@ -5871,6 +5820,15 @@ function refusalLine(rewrite) {
   }
   return `${where} that line now holds different text than the claim at ${at2}. Re-add it with cite add.`;
 }
+function recommitWhy(because) {
+  switch (because) {
+    case "not-in-history":
+      return "not in this branch's history";
+    case "not-contained":
+    case void 0:
+      return "did not contain the pinned lines";
+  }
+}
 function rewriteLine(rewrite) {
   const word = rewrite.from.includes("-") ? "lines" : "line";
   const status = rewrite.status === "never-true" ? "never true" : rewrite.status;
@@ -5880,7 +5838,7 @@ function rewriteLine(rewrite) {
   if (rewrite.reason === "recommitted") {
     const from = shortCommit(rewrite.fromCommit ?? "");
     const to = shortCommit(rewrite.toCommit ?? "");
-    return `source ${shortSrc(rewrite.src ?? "")} commit ${from} -> ${to} (did not contain the pinned lines)`;
+    return `source ${shortSrc(rewrite.src ?? "")} commit ${from} -> ${to} (${recommitWhy(rewrite.because)})`;
   }
   if (rewrite.reason === "shifted") {
     return `claim ${word} ${rewrite.from} -> ${rewrite.to} (shifted by a marker)`;
@@ -6164,7 +6122,7 @@ function encryptedCitations(file, content, format) {
 async function rotateManifestCitations(sidecars2, manifests, page, opts) {
   const none = { rewritten: [], skipped: [], wantsHistory: false };
   if (sidecars2 === null) return none;
-  const sidecar = sidecars2.forPage(page.file, page.content, page.format);
+  const sidecar = await sidecars2.forPage(page.file, page.content, page.format);
   const owner = sidecar.owner;
   if (owner === void 0 || sidecar.citations === void 0) return none;
   if (!sidecar.citations.some((input) => ANY_CIPHERTEXT.test(JSON.stringify(input.entry)))) {
@@ -6384,6 +6342,8 @@ async function runKeyRotate(opts) {
     configSource: file.source,
     key: current,
     toError: toKeyError,
+    // A keyless manifest (proposal 0068) keeps what a page's schemas mark.
+    marks: () => configMarks(file.path, file.dir),
     // A `{page}` manifest (0058) is read for exactly the pages rotated.
     pages: files.map((rel) => resolve7(base, rel))
   });
@@ -6578,4 +6538,4 @@ export {
   runKeyRotate,
   runKeySet
 };
-//# sourceMappingURL=chunk-UKRYPLZS.js.map
+//# sourceMappingURL=chunk-W75SLU7Z.js.map