@intentius/chant 0.124.13 → 0.124.15

package/dist/workspace/patch.js

@@ -0,0 +1,301 @@
+/**
+ * The hunks of a diff: `chant workspace patch <base>..<head>|<base>...<head>|<commit>
+ * [--path <p>...] [--max-bytes <n>] [--json]`, or `chant workspace patch [<commit>]
+ * --worktree` for the working tree's changes against a commit (HEAD unless given).
+ *
+ * `check --changes` maps the paths a diff changes to records and prints no
+ * lines of it. A reader showing what a work branch or a commit did needs the
+ * lines, and a reader that runs no git of its own (hud) gets them here. The
+ * range is read as `check --changes` reads one, except that a lone revision
+ * is that commit against its first parent, or against the empty tree for a
+ * root commit, since a reader drawing one commit wants that commit's change.
+ * With --worktree the head is the working tree as it is on disk: staged or
+ * not, and each untracked file git does not ignore, as added.
+ *
+ * Each changed file under the workspace root is listed, with renames
+ * followed, its added and deleted line counts, and its hunks. A file's hunk
+ * text stops at `maxBytes` (64 KiB unless given), and all files' together at
+ * sixteen times that; a file cut short, or left without hunks once the total
+ * is spent, says `truncated`. A binary file has counts of null and no hunks.
+ * Git is read through a local `git` subprocess only: no fetch, no network.
+ */
+import { execFileSync } from "node:child_process";
+import { formatError } from "../cli/format.js";
+import { readDeclaration, readerVersion, WORKSPACE_ERROR_CODES, WorkspaceReadError } from "./declaration.js";
+import { isWorkspacePath } from "./record-assets.js";
+import { joinPath } from "./tree.js";
+import { locateWorkspace } from "./which-chant.js";
+/** The version of the `patch` document this chant writes. */
+export const PATCH_CONTRACT_VERSION = 1;
+/** `$id` of the JSON Schema for the document, shipped beside this file. */
+export const PATCH_OUTPUT_SCHEMA_ID = "https://intentius.io/chant/schemas/workspace/patch/v1/patch.schema.json";
+/** Why the read failed as a whole. */
+export const PATCH_ERROR_CODES = [
+    ...WORKSPACE_ERROR_CODES,
+    /** A --path is not a relative path inside the workspace. */
+    "patch-path-invalid",
+];
+/** The hunk text one file gets unless `maxBytes` says otherwise. */
+export const PATCH_FILE_BYTES = 64 * 1024;
+/** The hunk text every file gets together, as a multiple of the per-file cap. */
+export const PATCH_TOTAL_FACTOR = 16;
+/** Git's empty tree, the base of a root commit. */
+const EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+class PatchError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PatchError";
+    }
+}
+function git(top, args) {
+    return execFileSync("git", args, { cwd: top, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 1024 * 1024 * 1024 });
+}
+function commitOf(top, rev) {
+    if (rev === "" || rev.startsWith("-"))
+        throw new PatchError("revision-unknown", `the patch needs <base>..<head>, <base>...<head> or a commit, and ${JSON.stringify(rev)} is not a revision`);
+    try {
+        return git(top, ["rev-parse", "--verify", "--quiet", `${rev}^{commit}`]).trim();
+    }
+    catch {
+        throw new PatchError("revision-unknown", `${rev} is no commit in this repository`);
+    }
+}
+function resolveRange(top, spec) {
+    const three = spec.indexOf("...");
+    if (three >= 0) {
+        const head = commitOf(top, spec.slice(three + 3) || "HEAD");
+        const other = commitOf(top, spec.slice(0, three));
+        try {
+            return { form: "merge-base", base: git(top, ["merge-base", other, head]).trim(), head };
+        }
+        catch {
+            throw new PatchError("revision-unknown", `${spec}: the two revisions have no merge base`);
+        }
+    }
+    const two = spec.indexOf("..");
+    if (two >= 0)
+        return { form: "range", base: commitOf(top, spec.slice(0, two)), head: commitOf(top, spec.slice(two + 2) || "HEAD") };
+    const head = commitOf(top, spec);
+    let base = EMPTY_TREE;
+    try {
+        base = git(top, ["rev-parse", "--verify", "--quiet", `${head}^1`]).trim();
+    }
+    catch {
+        // A root commit: against the empty tree.
+    }
+    return { form: "commit", base, head };
+}
+/** Each changed file, from the repository root, with its counts; renames and copies followed. */
+function changedFiles(top, revs, pathspecs) {
+    const spec = ["--", ...pathspecs];
+    const status = git(top, ["diff", "--name-status", "-z", "-M", "--no-color", ...revs, ...spec]).split("\0");
+    const counts = git(top, ["diff", "--numstat", "-z", "-M", "--no-color", ...revs, ...spec]).split("\0");
+    const numstat = new Map();
+    for (let i = 0; i < counts.length && counts[i] !== "";) {
+        const [a, d, path] = counts[i].split("\t");
+        const n = { additions: a === "-" ? null : Number(a), deletions: d === "-" ? null : Number(d) };
+        if (path === "") {
+            // A rename or a copy: the old path, then the new.
+            numstat.set(counts[i + 2], n);
+            i += 3;
+        }
+        else {
+            numstat.set(path, n);
+            i += 1;
+        }
+    }
+    const out = [];
+    for (let i = 0; i < status.length && status[i] !== "";) {
+        const s = status[i];
+        const paired = s.startsWith("R") || s.startsWith("C");
+        const path = paired ? status[i + 2] : status[i + 1];
+        const from = paired ? status[i + 1] : null;
+        const change = s.startsWith("R") ? "renamed" : s.startsWith("C") ? "copied" : s === "A" ? "added" : s === "D" ? "deleted" : "modified";
+        const n = numstat.get(path) ?? { additions: null, deletions: null };
+        out.push({ path, change, from, binary: n.additions === null, ...n });
+        i += paired ? 3 : 2;
+    }
+    return out;
+}
+/** The hunks of one file's diff text, and the bytes of hunk text, before any cut. */
+function parseHunks(text) {
+    const hunks = [];
+    let bytes = 0;
+    let current = null;
+    const lines = text.split("\n");
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    for (const line of lines) {
+        const m = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (m) {
+            current = { header: line, oldStart: Number(m[1]), oldLines: m[2] === undefined ? 1 : Number(m[2]), newStart: Number(m[3]), newLines: m[4] === undefined ? 1 : Number(m[4]), lines: [] };
+            hunks.push(current);
+            bytes += Buffer.byteLength(line) + 1;
+        }
+        else if (current && /^[ +\-\\]/.test(line)) {
+            current.lines.push(line);
+            bytes += Buffer.byteLength(line) + 1;
+        }
+    }
+    return { hunks, bytes };
+}
+/**
+ * Each file's section of the diff, in the order `--name-status` lists the
+ * files: one `git diff` for the whole range, split at its `diff --git` lines.
+ * When the count of sections is not the count of files, each file's diff is
+ * read on its own instead.
+ */
+function fileSections(top, revs, pathspecs, files) {
+    const diff = (spec) => git(top, ["diff", "--no-color", "--no-ext-diff", "-M", ...revs, "--", ...spec]);
+    const text = diff(pathspecs);
+    const sections = text === "" ? [] : text.split(/^(?=diff --git )/m).filter((x) => x.startsWith("diff --git "));
+    if (sections.length === files.length)
+        return sections;
+    return files.map((f) => diff(f.from ? [f.from, f.path] : [f.path]));
+}
+/** `git diff --no-index`, which exits 1 when the two differ: its output either way. */
+function gitNoIndex(top, args) {
+    try {
+        return git(top, ["diff", "--no-index", "--no-color", "--no-ext-diff", ...args]);
+    }
+    catch (err) {
+        const out = err.stdout;
+        if (err.status === 1 && typeof out === "string")
+            return out;
+        throw err;
+    }
+}
+/** Each untracked file git does not ignore, under the pathspecs, as an added file with its diff text. */
+function untrackedFiles(top, pathspecs) {
+    const listed = git(top, ["ls-files", "--others", "--exclude-standard", "-z", "--", ...pathspecs]).split("\0").filter((p) => p !== "");
+    return listed.map((path) => {
+        const [a, d] = gitNoIndex(top, ["--numstat", "--", "/dev/null", path]).split("\t");
+        const binary = a === "-";
+        return {
+            file: { path, change: "added", from: null, binary, additions: binary ? null : Number(a) || 0, deletions: binary ? null : Number(d) || 0 },
+            section: binary ? "" : gitNoIndex(top, ["--", "/dev/null", path]),
+        };
+    });
+}
+/** The hunks cut to `budget` bytes: whole hunks while they fit, then the lines of the next that fit. */
+function cut(hunks, budget) {
+    const out = [];
+    let used = 0;
+    for (const h of hunks) {
+        const header = Buffer.byteLength(h.header) + 1;
+        if (used + header > budget)
+            return { hunks: out, used, truncated: true };
+        const kept = [];
+        used += header;
+        for (const l of h.lines) {
+            const n = Buffer.byteLength(l) + 1;
+            if (used + n > budget) {
+                out.push({ ...h, lines: kept });
+                return { hunks: out, used, truncated: true };
+            }
+            kept.push(l);
+            used += n;
+        }
+        out.push(h);
+    }
+    return { hunks: out, used, truncated: false };
+}
+/** Build the document. Never throws a {@link WorkspaceReadError}. */
+export async function workspacePatch(query) {
+    const head = { $schema: PATCH_OUTPUT_SCHEMA_ID, contract: PATCH_CONTRACT_VERSION, chant: readerVersion() };
+    try {
+        return { doc: run(query, head), failed: false };
+    }
+    catch (err) {
+        if (err instanceof PatchError || err instanceof WorkspaceReadError) {
+            return { doc: { ...head, error: { code: err.code, message: err.message } }, failed: true };
+        }
+        throw err;
+    }
+}
+function run(query, head) {
+    const located = locateWorkspace(query.cwd);
+    const top = located.top;
+    if (!top)
+        throw new PatchError("not-a-git-repository", "the patch read reads a git diff, and this directory is not in a git repository");
+    const declaration = readDeclaration(located.tree, "", { rootChant: true });
+    const prefix = located.root === "." ? "" : located.root;
+    const paths = (query.paths ?? []).map((p) => p.replace(/\/+$/, ""));
+    for (const p of paths)
+        if (p !== "." && !isWorkspacePath(p))
+            throw new PatchError("patch-path-invalid", `--path ${p} is not a relative path inside the workspace`);
+    const pathspecs = paths.length === 0 ? [prefix === "" ? "." : prefix] : paths.map((p) => (joinPath(prefix, p) === "" ? "." : joinPath(prefix, p)));
+    const range = query.worktree
+        ? { form: "worktree", base: commitOf(top, query.range === "" ? "HEAD" : query.range), head: null }
+        : resolveRange(top, query.range);
+    const revs = range.head === null ? [range.base] : [range.base, range.head];
+    const fileBytes = query.maxBytes ?? PATCH_FILE_BYTES;
+    const totalBytes = fileBytes * PATCH_TOTAL_FACTOR;
+    const fromWorkspace = (full) => (prefix === "" ? full : full.slice(prefix.length + 1));
+    let left = totalBytes;
+    const files = [];
+    const tracked = changedFiles(top, revs, pathspecs);
+    const trackedSections = tracked.length > 0 ? fileSections(top, revs, pathspecs, tracked) : [];
+    const fresh = range.head === null ? untrackedFiles(top, pathspecs) : [];
+    const both = [...tracked.map((file, i) => ({ file, section: trackedSections[i] })), ...fresh].sort((a, b) => (a.file.path < b.file.path ? -1 : a.file.path > b.file.path ? 1 : 0));
+    const changed = both.map((x) => x.file);
+    const sections = both.map((x) => x.section);
+    for (const [i, f] of changed.entries()) {
+        const entry = { ...f, path: fromWorkspace(f.path), from: f.from === null ? null : fromWorkspace(f.from) };
+        if (f.binary) {
+            files.push({ ...entry, hunkCount: 0, bytes: 0, hunks: [], truncated: false });
+            continue;
+        }
+        const all = parseHunks(sections[i]);
+        const kept = cut(all.hunks, Math.min(fileBytes, left));
+        left -= kept.used;
+        files.push({ ...entry, hunkCount: all.hunks.length, bytes: all.bytes, hunks: kept.hunks, truncated: kept.truncated });
+    }
+    return {
+        ...head,
+        workspace: { name: declaration.name, root: located.root },
+        range: { spec: query.range, ...range },
+        paths,
+        limits: { fileBytes, totalBytes },
+        files,
+        summary: {
+            files: files.length,
+            additions: files.reduce((n, f) => n + (f.additions ?? 0), 0),
+            deletions: files.reduce((n, f) => n + (f.deletions ?? 0), 0),
+            truncated: files.some((f) => f.truncated),
+        },
+    };
+}
+const USAGE = "chant workspace patch <base>..<head>|<base>...<head>|<commit> [--path <p>...] [--max-bytes <n>] [--json], or chant workspace patch [<commit>] --worktree [--path <p>...] [--max-bytes <n>] [--json]";
+/** Each file's line, then its hunks as git writes them, then a summary. */
+export function formatPatch(doc) {
+    const out = [`patch     ${doc.range.base.slice(0, 8)}..${doc.range.head === null ? "worktree" : doc.range.head.slice(0, 8)} (${doc.range.spec}, ${doc.range.form})`];
+    for (const f of doc.files) {
+        const counts = f.binary ? "binary" : `+${f.additions} -${f.deletions}`;
+        out.push(`${f.change.padEnd(9)} ${f.path}${f.from ? ` (from ${f.from})` : ""} ${counts}${f.truncated ? `; truncated, ${f.hunks.length} of ${f.hunkCount} hunks shown` : ""}`);
+        for (const h of f.hunks)
+            out.push(h.header, ...h.lines);
+    }
+    const s = doc.summary;
+    out.push(`${s.files} files, +${s.additions} -${s.deletions}${s.truncated ? `; truncated at ${doc.limits.fileBytes} bytes a file, ${doc.limits.totalBytes} in all` : ""}`);
+    return out.join("\n");
+}
+export async function runWorkspacePatch(ctx) {
+    const { args } = ctx;
+    const range = args.extraPositional ?? (args.worktree ? "" : undefined);
+    if (range === undefined) {
+        console.error(formatError({ message: "chant workspace patch needs a range or a commit", hint: USAGE }));
+        return 1;
+    }
+    const { doc, failed } = await workspacePatch({ cwd: process.cwd(), range, paths: args.paths, maxBytes: args.maxBytes, worktree: args.worktree === true });
+    if (args.json)
+        console.log(JSON.stringify(doc, null, 2));
+    if ("error" in doc) {
+        console.error(formatError({ message: `${doc.error.code}: ${doc.error.message}`, hint: USAGE }));
+        return 1;
+    }
+    if (!args.json)
+        console.log(formatPatch(doc));
+    return failed ? 1 : 0;
+}

package/dist/workspace/patch.schema.json

@@ -0,0 +1,321 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://intentius.io/chant/schemas/workspace/patch/v1/patch.schema.json",
+  "title": "chant workspace patch output",
+  "description": "What `chant workspace patch <range> --json` prints: each file a diff changes under the workspace root, with its line counts and hunks, cut to a size limit. The range is <base>..<head>, <base>...<head> (from the merge base), or one commit against its first parent, or against the empty tree for a root commit. Contract version 1 is written by chant 0.81.0 and newer, and this document was added to it by workspace patch; a chant without the command refuses it. Every code is in the one closed list of `reason-codes.ts`.",
+  "oneOf": [
+    {
+      "$ref": "#/$defs/result"
+    },
+    {
+      "$ref": "#/$defs/failure"
+    }
+  ],
+  "$defs": {
+    "result": {
+      "description": "The diff was read. Exit code 0.",
+      "type": "object",
+      "required": [
+        "$schema",
+        "contract",
+        "chant",
+        "workspace",
+        "range",
+        "paths",
+        "limits",
+        "files",
+        "summary"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://intentius.io/chant/schemas/workspace/patch/v1/patch.schema.json"
+        },
+        "contract": {
+          "const": 1
+        },
+        "chant": {
+          "type": "string",
+          "description": "The chant that wrote the document."
+        },
+        "workspace": {
+          "type": "object",
+          "required": [
+            "name",
+            "root"
+          ],
+          "properties": {
+            "name": {
+              "type": "string"
+            },
+            "root": {
+              "type": "string",
+              "description": "The workspace root relative to the git root, \".\" for the git root."
+            }
+          }
+        },
+        "range": {
+          "type": "object",
+          "required": [
+            "spec",
+            "form",
+            "base",
+            "head"
+          ],
+          "properties": {
+            "spec": {
+              "type": "string",
+              "description": "The range as given."
+            },
+            "form": {
+              "enum": [
+                "range",
+                "merge-base",
+                "commit",
+                "worktree"
+              ],
+              "description": "range: <base>..<head>. merge-base: <base>...<head>, so base is their merge base. commit: one commit, so base is its first parent, or the empty tree. worktree: --worktree, the working tree against one commit (HEAD unless given), untracked files that git does not ignore as added."
+            },
+            "base": {
+              "type": "string",
+              "pattern": "^[0-9a-f]{40,64}$",
+              "description": "The commit, or for a root commit the empty tree, the diff starts from."
+            },
+            "head": {
+              "type": [
+                "string",
+                "null"
+              ],
+              "pattern": "^[0-9a-f]{40,64}$",
+              "description": "The commit the diff ends at; null for the working tree (worktree)."
+            }
+          }
+        },
+        "paths": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The --path filters, from the workspace root. Empty for the whole workspace."
+        },
+        "limits": {
+          "type": "object",
+          "required": [
+            "fileBytes",
+            "totalBytes"
+          ],
+          "properties": {
+            "fileBytes": {
+              "type": "integer",
+              "minimum": 1,
+              "description": "The hunk text, headers included, one file gets: --max-bytes, or 65536."
+            },
+            "totalBytes": {
+              "type": "integer",
+              "minimum": 1,
+              "description": "The hunk text every file gets together: 16 times fileBytes."
+            }
+          }
+        },
+        "files": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/file"
+          },
+          "description": "In the order git lists them."
+        },
+        "summary": {
+          "type": "object",
+          "required": [
+            "files",
+            "additions",
+            "deletions",
+            "truncated"
+          ],
+          "properties": {
+            "files": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "additions": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "deletions": {
+              "type": "integer",
+              "minimum": 0
+            },
+            "truncated": {
+              "type": "boolean",
+              "description": "Whether any file is truncated."
+            }
+          }
+        },
+        "error": false
+      }
+    },
+    "file": {
+      "type": "object",
+      "required": [
+        "path",
+        "change",
+        "from",
+        "binary",
+        "additions",
+        "deletions",
+        "hunkCount",
+        "bytes",
+        "hunks",
+        "truncated"
+      ],
+      "properties": {
+        "path": {
+          "type": "string",
+          "description": "From the workspace root."
+        },
+        "change": {
+          "enum": [
+            "added",
+            "modified",
+            "deleted",
+            "renamed",
+            "copied"
+          ]
+        },
+        "from": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "For a rename or a copy, the path it came from, from the workspace root."
+        },
+        "binary": {
+          "type": "boolean"
+        },
+        "additions": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0,
+          "description": "Lines added, as git counts them; null for a binary file."
+        },
+        "deletions": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "minimum": 0,
+          "description": "Lines deleted; null for a binary file."
+        },
+        "hunkCount": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "How many hunks git wrote for the file. hunks holds fewer when truncated."
+        },
+        "bytes": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "The bytes of hunk text git wrote for the file, headers included, before any cut."
+        },
+        "hunks": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/hunk"
+          }
+        },
+        "truncated": {
+          "type": "boolean",
+          "description": "Whether hunks holds less than git wrote: the file's text passed fileBytes, or the total passed totalBytes. The last hunk kept may be cut short."
+        }
+      }
+    },
+    "hunk": {
+      "type": "object",
+      "required": [
+        "header",
+        "oldStart",
+        "oldLines",
+        "newStart",
+        "newLines",
+        "lines"
+      ],
+      "properties": {
+        "header": {
+          "type": "string",
+          "description": "The @@ line as git writes it."
+        },
+        "oldStart": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "oldLines": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "newStart": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "newLines": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "lines": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Each line with its leading space, +, - or backslash, without its newline."
+        }
+      }
+    },
+    "failure": {
+      "description": "The declaration could not be read, a revision is not a commit, or a --path is not inside the workspace, and nothing was read. Exit code 1.",
+      "type": "object",
+      "required": [
+        "$schema",
+        "contract",
+        "chant",
+        "error"
+      ],
+      "properties": {
+        "$schema": {
+          "const": "https://intentius.io/chant/schemas/workspace/patch/v1/patch.schema.json"
+        },
+        "contract": {
+          "const": 1
+        },
+        "chant": {
+          "type": "string"
+        },
+        "error": {
+          "type": "object",
+          "required": [
+            "code",
+            "message"
+          ],
+          "properties": {
+            "code": {
+              "enum": [
+                "declaration-missing",
+                "declaration-ambiguous",
+                "declaration-unparseable",
+                "declaration-invalid",
+                "placement-invalid",
+                "reader-too-old",
+                "root-chant-required",
+                "not-a-git-repository",
+                "revision-unknown",
+                "patch-path-invalid"
+              ]
+            },
+            "message": {
+              "type": "string"
+            }
+          }
+        },
+        "files": false
+      }
+    }
+  }
+}

package/dist/workspace/pin-cli.js

@@ -0,0 +1,55 @@
+/**
+ * `chant workspace pin <path> [--json]` (#2547, ws-065): print the `integrity`
+ * value that pins the plugin at `path`, a directory or file inside the
+ * workspace. What the hash covers is in ./pin-integrity.ts. The command reads
+ * files only, and says whether a path pin the declaration already has for
+ * that path matches.
+ */
+import { relative, resolve, sep } from "node:path";
+import { formatError } from "../cli/format.js";
+import { readDeclaration, WorkspaceReadError } from "./declaration.js";
+import { integrityOf, PinHashError } from "./pin-integrity.js";
+import { locateWorkspace } from "./which-chant.js";
+const USAGE = "chant workspace pin <path> [--json]";
+export async function runWorkspacePin(ctx) {
+    const { args } = ctx;
+    const given = args.extraPositional;
+    if (!given) {
+        console.error(formatError({ message: "chant workspace pin needs the plugin's path", hint: USAGE }));
+        return 1;
+    }
+    try {
+        const located = locateWorkspace(process.cwd());
+        const declaration = readDeclaration(located.tree, "", { rootChant: true });
+        const abs = resolve(process.cwd(), given);
+        const rel = relative(located.rootOnDisk, abs).split(sep).join("/");
+        if (rel === "" || rel.startsWith("../") || rel === "..") {
+            console.error(formatError({ message: `${given} is not inside the workspace`, hint: USAGE }));
+            return 1;
+        }
+        const { integrity, files } = integrityOf(abs);
+        const declared = declaration.pins.find((p) => p.path === rel);
+        const state = declared === undefined ? "undeclared" : declared.integrity === null ? "declared-unpinned" : declared.integrity === integrity ? "matches" : "differs";
+        if (args.json) {
+            console.log(JSON.stringify({ path: rel, integrity, files, pin: state }, null, 2));
+        }
+        else {
+            console.log(integrity);
+            const note = {
+                undeclared: `${rel} is not a path pin in ${declaration.file}; add { "path": "${rel}", "integrity": "${integrity}" } to pins`,
+                "declared-unpinned": `${rel} is a path pin with no integrity; add "integrity": "${integrity}" to it`,
+                matches: `${rel} matches the integrity its pin states`,
+                differs: `${rel} does not match the integrity its pin states (${declared?.integrity}); update the pin if the change is intended`,
+            }[state];
+            console.error(`${files} file${files === 1 ? "" : "s"} hashed. ${note}`);
+        }
+        return state === "differs" ? 1 : 0;
+    }
+    catch (err) {
+        if (err instanceof WorkspaceReadError || err instanceof PinHashError) {
+            console.error(formatError({ message: `${given}: ${err.message}`, hint: USAGE }));
+            return 1;
+        }
+        throw err;
+    }
+}