@hawkeyexl/manni 2.8.2 → 2.8.4

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   readStdin,
   reportConfig,
   splitList
-} from "./chunk-7UBCWTCO.js";
+} from "./chunk-3QRJR6LM.js";
 import {
   CiteError,
   KeyError,
@@ -40,7 +40,7 @@ import {
   shortPin,
   shortSrc,
   spellSource
-} from "./chunk-WCNU53MJ.js";
+} from "./chunk-HZ2KWOOO.js";
 import {
   COMMON_FORMAT_LIST,
   FAMILY_CONFIG_NAMES,
@@ -80,7 +80,7 @@ import {
   splitPageArgument,
   terminalConfirm,
   valeConfigPath
-} from "./chunk-KEW557TN.js";
+} from "./chunk-XHH5OSQQ.js";
 
 // src/cli.ts
 import { Command as Command5 } from "commander";

package/dist/docmeta.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   buildProgram
-} from "./chunk-7UBCWTCO.js";
+} from "./chunk-3QRJR6LM.js";
 import {
   runIfMain
-} from "./chunk-KEW557TN.js";
+} from "./chunk-XHH5OSQQ.js";
 
 // src/docmeta.ts
 runIfMain(import.meta.url, () => buildProgram().name("docmeta"));

package/dist/index.d.ts

@@ -3425,7 +3425,17 @@ declare function applyFrontmatter(content: string, patch: MetadataPatch, options
  * target is locked — on Windows that is a real and recoverable situation, and
  * refusing to write at all would be worse than a non-atomic write.
  */
-declare function writeFileAtomic(path: string, 
+declare function writeFileAtomic(
+/**
+ * Absolute, or relative to the process's current directory. The manifest
+ * cache is keyed on absolute paths, and the invalidation in the `finally`
+ * below resolves `path` against that same implicit directory — so a caller
+ * that resolved its own path against some other base would invalidate a key
+ * no cache holds, and the stale parse would survive the write. That miss is
+ * silent, which is why the requirement is stated here rather than left to be
+ * discovered.
+ */
+path: string, 
 /**
  * A `Uint8Array` writes byte-for-byte. `schemas vendor` needs that: the
  * integrity pin it records is taken over exactly what the server sent, and a
@@ -4541,10 +4551,20 @@ declare function claimLine(claim: ClaimEnd): number | undefined;
  * bare pin, or a marker with no drift check on its sentence.
  */
 declare function claimEnd(page: PageCitations, entry: PageCitation, lines: readonly string[], misplaced?: MisplacedMarker): ClaimEnd | null;
-/** What `update --accept` re-pins over: the paragraph or fenced block at a line. */
+/**
+ * What `update --accept` re-pins over: the paragraph, whole fenced block, or
+ * lines inside a fenced block at a line.
+ *
+ * The three kinds are not interchangeable. `"block"` covers a fence, its
+ * content and its closing fence, which is the only shape a `quote: true`
+ * entry may hold. `"fenced-lines"` covers content lines inside a block and
+ * neither fence, which is what a claim minted over part of a code sample
+ * holds. `"paragraph"` covers prose, and table rows too, since `ClaimUnit`
+ * draws no line between them.
+ */
 interface ClaimUnit {
     lines: PageLines;
-    kind: "paragraph" | "block";
+    kind: "paragraph" | "block" | "fenced-lines";
     text: string[];
 }
 /**
@@ -4552,13 +4572,13 @@ interface ClaimUnit {
  * different repair, so `update --accept` names which it hit rather than
  * leaving the entry skipped with no reason.
  */
-type NoUnit = "outside" | "blank" | "fenced" | "marker" | "not-a-paragraph" | "table-short" | "table-rule";
+type NoUnit = "outside" | "blank" | "fence-crossed" | "marker" | "not-a-paragraph" | "table-short" | "table-rule";
 /**
- * The paragraph, fenced block or table rows at a file line. Undefined when the
- * line holds no claim at all: it is blank, outside the body, inside a fenced
- * block rather than opening one, another entry's marker, or a table rule.
- * Those are the claims `update --accept` skips, and `noUnitAt` says which of
- * them it is.
+ * The paragraph, fenced block, fenced lines or table rows at a file line.
+ * Undefined when the line holds no claim at all: it is blank, outside the
+ * body, another entry's marker, a table rule, or a line whose claim runs out
+ * of the fenced block it starts in. Those are the claims `update --accept`
+ * skips, and `noUnitAt` says which of them it is.
  *
  * A paragraph runs from this line to its end, not from the paragraph's own
  * first line. The line asked about is the claim's first line, and re-pinning
@@ -4979,41 +4999,61 @@ interface SplicedManifest {
  */
 declare function spliceManifestValue(text: string, options: SpliceManifestOptions): SplicedManifest;
 
-/** One edit this run made, replayable onto bytes read later. */
-type ManifestOp = {
-    kind: "splice";
-    entry: string;
-    join: string;
-    file: string;
-    value: unknown[];
-} | {
-    kind: "remove";
+/** One entry's one key: what an edit rewrites, and what a conflict is about. */
+interface ManifestKey {
+    /** The entry, as the manifest spells it. */
     entry: string;
+    /** The key of that entry the edit rewrites. */
+    key: string;
+    /** How entry keys are compared; `path` normalizes separators. */
     join: string;
+}
+/** One edit a run made, replayable onto bytes read later. */
+interface ManifestOp$1 extends ManifestKey {
+    /** The manifest as the run names it in its own messages. */
     file: string;
-};
-/** An entry this run rewrote, and what it held before the run touched it. */
-interface EntryBase {
-    entry: string;
-    join: string;
-    /** The entry's `citations` as they were read, encoded for comparison. */
+}
+/** An entry's key this run rewrote, and what it held before the run did. */
+interface KeyBase extends ManifestKey {
+    /** The value as it was read, encoded so absence cannot collide. */
     value: string;
 }
 /** One manifest held for the length of a run: its text before, and now. */
-interface HeldManifest {
+interface HeldManifest$1<Op extends ManifestOp$1> {
     /** Absolute path, the write target. */
     path: string;
     /** The manifest as the run reports it. */
     file: string;
-    /** The bytes as they were read. */
+    /** The bytes the run's edits were computed from. */
     before: string;
     /** The bytes as the run has rewritten them. */
     text: string;
     /** Every edit this run made, in order, for a replay onto newer bytes. */
-    ops: ManifestOp[];
-    /** Each entry this run rewrote, keyed as the manifest keys it. */
-    bases: Map<string, EntryBase>;
+    ops: Op[];
+    /** Each entry key this run rewrote, and what it held first. */
+    bases: Map<string, KeyBase>;
 }
+/** What a caller may substitute when it writes the manifests it held. */
+interface CommitIo$1<Change> {
+    /** The byte writer; an atomic write unless a test says otherwise. */
+    write?: (path: string, text: string) => Promise<void>;
+    /** The compare-and-swap re-read, for a test counting the retries. */
+    read?: (path: string) => Promise<string>;
+    /** Called after each manifest lands, in write order. */
+    after?: (change: Change) => void;
+    /** Called when one manifest fails to land; must throw. */
+    onError?: (change: Change, error: unknown) => Promise<never>;
+}
+
+/** One edit this run made, replayable onto bytes read later. */
+type ManifestOp = ManifestOp$1 & ({
+    kind: "splice";
+    value: unknown[];
+} | {
+    kind: "remove";
+});
+/** One manifest held for the length of a run: its text before, and now. */
+type HeldManifest = HeldManifest$1<ManifestOp>;
 /** One manifest this run rewrote, as `changed()` and `commit()` report it. */
 interface ManifestChange {
     path: string;
@@ -5028,19 +5068,7 @@ interface ManifestChange {
     diff: string;
 }
 /** What `commit()` does with each manifest it settles. */
-interface CommitIo {
-    /** The byte writer; `writeFileAtomic` unless a test says otherwise. */
-    write?: (path: string, text: string) => Promise<void>;
-    /**
-     * The compare-and-swap re-read, for a test counting the retries. It is that
-     * loop's read alone, not a general hook: `hold()` reads the file itself.
-     */
-    read?: (path: string) => Promise<string>;
-    /** Called after each manifest lands, in write order. */
-    after?: (change: ManifestChange) => void;
-    /** Called when one manifest fails to land; must throw. */
-    onError?: (change: ManifestChange, error: unknown) => Promise<never>;
-}
+type CommitIo = CommitIo$1<ManifestChange>;
 /** Every manifest one run writes, read once and spliced in memory. */
 declare class ManifestSet {
     private readonly held;

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   reencryptMetadata,
   runKeyRotate,
   runKeySet
-} from "./chunk-WCNU53MJ.js";
+} from "./chunk-HZ2KWOOO.js";
 import {
   BinMissing,
   COMMON_FORMATS,
@@ -127,7 +127,7 @@ import {
   valueOf,
   vendorFileName,
   writeFileAtomic
-} from "./chunk-KEW557TN.js";
+} from "./chunk-XHH5OSQQ.js";
 
 // src/key/index.ts
 var key_exports = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hawkeyexl/manni",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "One command line for documentation that is meant to be checked. `manni meta` validates the presence and format of document metadata (Markdown frontmatter and more) against JSON Schema, built for CI. Formerly docmeta.",
   "type": "module",
   "bin": {