baesian 0.0.0-stage → 1.0.0

package/dist/gate.js

@@ -0,0 +1,237 @@
+import { execFileSync } from "node:child_process";
+import { cite } from "./cite.js";
+import { cmd, dim, failed, failure, head, id, indent, next, note, table, text, trailer, warning } from "./style.js";
+import { CONFIG_PATH, detectFacts } from "./facts.js";
+import { matcher } from "./globs.js";
+import { answerLine, byLine, q, reviewerOf } from "./quote.js";
+import { ACK_TRAILER, CARD_TRAILER } from "./trailers.js";
+// The commit gate (D24, D26, D30, D46, D52, D53): every detected decision is covered by a card or an
+// ack, and no commit builds on a rejected card or on a hard card without a verdict.
+/** Which detected facts a card covers, by the facts it declares in `touches` (D53). */
+export const KIND_OF_TOUCH = {
+    dependency: "dep",
+    schema: "schema",
+    "public-api": "api",
+    infra: "infra",
+};
+function lastVerdict(store, id) {
+    const card = store.card(id);
+    return store
+        .verdicts(id)
+        .filter((v) => v.revision === card?.meta.revision)
+        .at(-1);
+}
+/** Why a commit may not cite this card, or undefined if it may. */
+function cardProblem(store, id) {
+    const card = store.card(id);
+    if (!card) {
+        return {
+            card: id,
+            problem: "unknown",
+            lines: [`${id} isn't a card here. File it first (\`baesian file\`), or fix the ID.`],
+        };
+    }
+    const status = store.status(id);
+    if (status === "withdrawn" || status === "superseded") {
+        return { card: id, problem: status, lines: [`${id} is ${status}: it no longer applies, so nothing should build on it.`] };
+    }
+    const last = lastVerdict(store, id);
+    if (status === "returned" && last?.response === "reject") {
+        const built = store.ledger(id).map((e) => e.meta.commit?.slice(0, 7)).filter(Boolean);
+        return {
+            card: id,
+            problem: "rejected",
+            lines: [
+                `${id} was rejected by ${byLine(reviewerOf(last))}${last.comment ? `: ${q(last.comment)}` : "."}`,
+                `Don't build on it: revise it (\`baesian revise ${id}\`) or withdraw it, and rework what depends on it.`,
+                ...(built.length ? [`Commits already built on it: ${built.join(", ")}`] : []),
+            ],
+        };
+    }
+    // The level in force: the card's, raised in a hosted repo by the relay's signed gate record (P16 section 3).
+    if (store.levelOf(id) === "hard" && status !== "resolved") {
+        return {
+            card: id,
+            problem: "hard-unresolved",
+            lines: [`${id} is hard and isn't resolved yet: nothing can build on it until it is${cite("D46")}.`],
+        };
+    }
+    return undefined;
+}
+export function evaluate(store, detection, trailers) {
+    // One consistent read: a card's status reads the others, and in a hosted repo checks each answer's signature (D138).
+    return store.view(() => evaluateIn(store, detection, trailers));
+}
+function evaluateIn(store, detection, trailers) {
+    const problems = trailers.cards.map((id) => cardProblem(store, id)).filter((p) => p !== undefined);
+    const usable = trailers.cards.filter((id) => !problems.some((p) => p.card === id));
+    const rules = store
+        .rules()
+        .filter((r) => !r.retired)
+        .map((r) => ({ id: r.meta.id, covers: matcher(r.meta.covers) }));
+    const covered = [];
+    const uncovered = [];
+    for (const fact of detection.facts) {
+        const reason = trailers.acks.get(fact.id);
+        const card = usable.find((id) => store.card(id).meta.touches.some((t) => KIND_OF_TOUCH[t] === fact.kind));
+        const rule = rules.find((r) => r.covers(fact.id));
+        if (reason)
+            covered.push({ fact, cover: { by: "ack", reason } });
+        else if (card)
+            covered.push({ fact, cover: { by: "card", card } });
+        else if (rule)
+            covered.push({ fact, cover: { by: "rule", rule: rule.id } });
+        else
+            uncovered.push(fact);
+    }
+    const ids = new Set(detection.facts.map((f) => f.id));
+    const unusedAcks = [...trailers.acks.keys()].filter((id) => !ids.has(id));
+    return {
+        facts: detection.facts,
+        covered,
+        uncovered,
+        problems,
+        malformed: trailers.malformed,
+        unusedAcks,
+        warnings: detection.warnings,
+        ok: uncovered.length === 0 && problems.length === 0 && trailers.malformed.length === 0,
+    };
+}
+/**
+ * Detect the staged facts where the preferences in force say to look (B-qkek1), as the gate at filing reads its rows:
+ * locally, the newest preference file in the live layer; in CI, the newest in the commit's own record; in a hosted repo,
+ * only one that counts, so a commit can't make the gate see less by writing a file of its own (D138, D163). With none,
+ * the built-in paths. Warns when the config still has the keys the gate read before, unless asked not to (`verify` says
+ * so once, for HEAD).
+ */
+export function detectStaged(store, snap, opts = {}) {
+    const force = store.inForce();
+    const found = detectFacts(snap, force.settings.paths);
+    const warnings = [
+        ...(force.problem ? [`${force.problem}, so the gate looks where it does by default`] : []),
+        ...(opts.configWarning === false ? [] : configWarnings(store.config())),
+        ...found.warnings,
+    ];
+    return { facts: found.facts, warnings };
+}
+/** The keys a config still has that the gate read before B-qkek1, and reads no longer. */
+export function staleGateKeys(config) {
+    return ["gate_schema", "gate_infra", "gate_ignore", "gate_api"].filter((k) => config[k] !== undefined);
+}
+/** What to say when the config still has them: they're ignored, and what to do instead (B-qkek1). */
+export function configWarnings(config) {
+    const keys = staleGateKeys(config);
+    if (!keys.length)
+        return [];
+    const them = keys.length === 1 ? keys[0] : `${keys.slice(0, -1).join(", ")} and ${keys.at(-1)}`;
+    return [
+        `${CONFIG_PATH} still has ${them}, which the gate no longer reads${cite("B-qkek1")}: what it looks for is in your preferences now, which only you change, in the client (Your preferences, then "What the gate looks for"). Set it there if the built-in lists don't cover it, then delete ${keys.length === 1 ? "it" : "them"} from the config.`,
+    ];
+}
+/** Verdicts on this branch's cards given since the branch's last commit (D30). */
+export function verdictsSinceLastCommit(store) {
+    let since = "";
+    try {
+        since = execFileSync("git", ["log", "-1", "--format=%cI", "HEAD"], {
+            cwd: store.repo.toplevel,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        since = new Date(since).toISOString();
+    }
+    catch {
+        // no commits yet: everything is new
+    }
+    return store
+        .branchCards()
+        .flatMap((c) => store.verdicts(c.meta.id))
+        .filter((v) => v.at > since)
+        .sort((a, b) => a.at.localeCompare(b.at));
+}
+/** IDs in a sentence: "B-a", "B-a and B-b", "B-a, B-b and B-c". */
+export const named = (ids) => (ids.length < 2 ? ids.join("") : `${ids.slice(0, -1).join(", ")} and ${ids.at(-1)}`);
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+/** Why the gate blocks, in a clause: what isn't covered, the cards it can't build on, the trailers it can't read. */
+export function blockedBecause(r) {
+    const parts = [];
+    if (r.uncovered.length)
+        parts.push(`${plural(r.uncovered.length, "decision")} in it ${r.uncovered.length === 1 ? "isn't" : "aren't"} covered by a card or an ack`);
+    if (r.problems.length)
+        parts.push(`it cites ${named(r.problems.map((p) => p.card))}, which it can't build on`);
+    if (r.malformed.length)
+        parts.push(`${plural(r.malformed.length, "trailer")} can't be read`);
+    return parts.join("; ");
+}
+/** What to run for a card a commit can't build on: wait on a hard one, revise a rejected one. */
+function problemStep(p) {
+    if (p.problem === "hard-unresolved")
+        return [next(`baesian wait ${p.card}`, "until it's resolved")];
+    if (p.problem === "rejected")
+        return [next(`baesian revise ${p.card} card.md`, "or withdraw it")];
+    return [];
+}
+/**
+ * Why a commit is blocked, and how to cover what isn't: the body of the gate's report, and of each failing commit in
+ * `verify`. The trailers to paste are lines of their own, at the start of the line, never styled (B-eyrt5).
+ */
+export function blockedBody(r, opts = {}) {
+    const out = [];
+    for (const m of r.malformed)
+        out.push(indent(2, text("unreadable trailer: ", m)));
+    for (const p of r.problems) {
+        out.push(...indent(2, p.lines.map((l) => text(l))));
+        if (opts.steps !== false)
+            out.push(...problemStep(p));
+    }
+    if (r.uncovered.length) {
+        out.push(...table(undefined, r.uncovered.map((f) => [f.id, dim(f.detail)])));
+        out.push(indent(2, text("Cover each one with a trailer at the end of the message, after a blank line: a card whose touches include it (", cmd("baesian file"), "),")));
+        out.push(trailer(`${CARD_TRAILER}: <id>`));
+        out.push(indent(2, text("or, for a two-way door, an ack with a reason:")));
+        for (const f of r.uncovered)
+            out.push(trailer(`${ACK_TRAILER}: ${f.id} <why this is fine>`));
+    }
+    return out;
+}
+/** The decisions a passing commit has, each with what covers it. */
+function coveredRows(r) {
+    return table(undefined, r.covered.map(({ fact, cover }) => [fact.id, cover.by === "card" ? id(cover.card) : cover.by === "rule" ? ["rule ", id(cover.rule)] : "ack"]));
+}
+/**
+ * What the gate prints: at commit time (`for: "commit"`, from the hooks, which prefix each line), or as `baesian check`
+ * previews it. Agents read this, so it ends with exactly what to do. New verdicts since the branch's last commit come
+ * after, the reviewer's words quoted with their name (D169).
+ */
+export function describeReport(r, opts = {}) {
+    const commit = opts.for !== "check";
+    const out = [];
+    if (!r.ok) {
+        out.push(failed(failure(commit ? "commit blocked" : "this commit would be blocked"), ": ", blockedBecause(r)));
+        out.push(...blockedBody(r));
+        if (commit)
+            out.push(indent(2, text(dim("To bypass it in an emergency: git commit --no-verify. CI runs the same check."))));
+        else if (!opts.message && r.uncovered.length)
+            out.push(next("baesian check --message <file>", "check a message's trailers before you commit"));
+    }
+    else if (r.covered.length) {
+        const n = r.covered.length;
+        const covered = n === 1 ? "its decision is covered" : `its ${n} decisions are covered`;
+        out.push(head("done", commit ? covered : `this commit would pass: ${covered}`));
+        out.push(...coveredRows(r));
+    }
+    else if (!commit)
+        out.push(head("done", "no decisions detected in the staged changes"));
+    for (const w of r.warnings)
+        out.push(warning(w));
+    for (const a of r.unusedAcks)
+        out.push(note(`${ACK_TRAILER} ${a} matches nothing in this commit`));
+    const news = opts.news ?? [];
+    if (news.length) {
+        out.push(head("attention", plural(news.length, "new verdict"), " since this branch's last commit"));
+        // What the reviewer wrote is quoted, with their name (D169).
+        for (const v of news)
+            out.push(indent(2, text(id(v.card), " ", answerLine(v))));
+    }
+    return out;
+}
+//# sourceMappingURL=gate.js.map

package/dist/git.js

@@ -0,0 +1,100 @@
+import { execFileSync } from "node:child_process";
+export function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+/** The directory isn't inside a git repository. */
+export class NotARepo extends Error {
+}
+export function openRepo(cwd = process.cwd()) {
+    let toplevel;
+    try {
+        toplevel = git(cwd, ["rev-parse", "--show-toplevel"]);
+    }
+    catch {
+        throw new NotARepo(`not inside a git repository: ${cwd}`);
+    }
+    const commonDir = git(toplevel, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+    return { toplevel, commonDir, branch: currentBranch(toplevel) };
+}
+function currentBranch(toplevel) {
+    try {
+        // Works on an unborn branch too (a repo with no commits yet).
+        return git(toplevel, ["symbolic-ref", "--short", "HEAD"]);
+    }
+    catch {
+        return `detached-${git(toplevel, ["rev-parse", "--short", "HEAD"])}`;
+    }
+}
+/**
+ * The commits HEAD's history starts from (B-5gnea): one, or several where unrelated histories were merged. Undefined
+ * before the first commit. A shallow clone's boundary looks like a root: ask `isShallow()` first.
+ */
+export function rootCommits(toplevel) {
+    try {
+        return git(toplevel, ["rev-list", "--max-parents=0", "HEAD"]).split("\n").filter(Boolean);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether this clone is shallow, so its oldest commits aren't the history's first (B-5gnea). */
+export function isShallow(toplevel) {
+    try {
+        return git(toplevel, ["rev-parse", "--is-shallow-repository"]) === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The repo's default branch (B-jr8mk), the trunk the branches panel draws on top, read in this order, the first that
+ * names one:
+ * 1. **the remote's HEAD**: `refs/remotes/origin/HEAD`, which `git clone` sets (and `git fetch` since git 2.48, where it's
+ *    missing), naming the branch the remote calls its default; with no `origin`, the one remote's HEAD, if there's one;
+ * 2. **`init.defaultBranch`**, as git's config sets it at any level, if a local branch of that name exists: a setting for
+ *    new repos says nothing of an older one that never had the branch;
+ * 3. **the branch `git init` ran on**: the local branch whose reflog starts with the repo's first commit,
+ *    `commit (initial)`; the oldest, if an orphan branch started another. Reflogs are local and expire (90 days, by
+ *    default), so a clone or an old repo may have none, but those have a remote's HEAD.
+ * Undefined when none does: the panel then guesses as it did. A few git calls, none of them over the network.
+ */
+export function defaultBranch(toplevel) {
+    const tryGit = (args) => {
+        try {
+            return git(toplevel, args);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const heads = (tryGit(["for-each-ref", "--format=%(refname) %(symref)", "refs/remotes/*/HEAD"]) ?? "")
+        .split("\n")
+        .flatMap((l) => {
+        const m = /^refs\/remotes\/([^/]+)\/HEAD refs\/remotes\/\1\/(.+)$/.exec(l);
+        return m ? [{ remote: m[1], branch: m[2] }] : [];
+    });
+    const remote = heads.find((h) => h.remote === "origin") ?? (heads.length === 1 ? heads[0] : undefined);
+    if (remote)
+        return { branch: remote.branch, from: "remote" };
+    const configured = tryGit(["config", "--get", "init.defaultBranch"]);
+    if (configured && tryGit(["show-ref", "--verify", "--quiet", `refs/heads/${configured}`]) !== undefined)
+        return { branch: configured, from: "init.defaultBranch" };
+    // `--date=unix` names each entry by when it was written, which is when that first commit was made here.
+    const initial = (tryGit(["log", "-g", "--all", "--grep-reflog=commit (initial)", "--date=unix", "--format=%gD"]) ?? "")
+        .split("\n")
+        .flatMap((l) => {
+        const m = /^refs\/heads\/(.+)@\{(\d+)\}$/.exec(l);
+        return m ? [{ at: Number(m[2]), branch: m[1] }] : [];
+    })
+        // A deleted branch's reflog goes with it, so each of these still exists.
+        .sort((a, b) => a.at - b.at);
+    return initial[0] ? { branch: initial[0].branch, from: "first-commit" } : undefined;
+}
+/** `feat/run-store` → `feat-run-store`. */
+export function slug(text) {
+    return (text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "x");
+}
+//# sourceMappingURL=git.js.map

package/dist/globs.js

@@ -0,0 +1,120 @@
+// Path globs for the gate's detectors: `**` crosses directories, `*` and `?` don't. Also used for
+// fact-ID patterns in rules (`dep:pytest-*`).
+export function globToRegExp(glob) {
+    let re = "";
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === "*" && glob[i + 1] === "*") {
+            const slash = glob[i + 2] === "/";
+            re += slash ? "(?:.*/)?" : ".*";
+            i += slash ? 2 : 1;
+        }
+        else if (c === "*")
+            re += "[^/]*";
+        else if (c === "?")
+            re += "[^/]";
+        else
+            re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(`^${re}$`);
+}
+export function matcher(globs) {
+    const res = globs.map(globToRegExp);
+    return (path) => res.some((r) => r.test(path));
+}
+function automatonOf(glob) {
+    const trans = [[]];
+    const eps = [[]];
+    const state = () => {
+        eps.push([]);
+        return trans.push([]) - 1;
+    };
+    let at = 0;
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        const next = state();
+        if (c === "*" && glob[i + 1] === "*") {
+            if (glob[i + 2] === "/") {
+                // `**/`: nothing, or anything that ends in a slash.
+                const any = state();
+                eps[at].push(next, any);
+                trans[any].push(["any", any], [{ lit: "/" }, next]);
+                i += 2;
+            }
+            else {
+                trans[at].push(["any", at]);
+                eps[at].push(next);
+                i += 1;
+            }
+        }
+        else if (c === "*") {
+            trans[at].push(["nonslash", at]);
+            eps[at].push(next);
+        }
+        else {
+            trans[at].push([c === "?" ? "nonslash" : { lit: c }, next]);
+        }
+        at = next;
+    }
+    return { trans, eps, accept: at };
+}
+function closure(a, from) {
+    const seen = new Set(from);
+    const stack = [...from];
+    while (stack.length) {
+        for (const t of a.eps[stack.pop()]) {
+            if (seen.has(t))
+                continue;
+            seen.add(t);
+            stack.push(t);
+        }
+    }
+    return [...seen].sort((x, y) => x - y);
+}
+/** "" stands for every character the globs don't name: not a slash, and no glob's literal. */
+const fits = (l, ch) => l === "any" || (l === "nonslash" ? ch !== "/" : l.lit === ch);
+function step(a, states, ch) {
+    const to = states.flatMap((s) => a.trans[s].filter(([l]) => fits(l, ch)).map(([, t]) => t));
+    return to.length ? closure(a, to) : [];
+}
+/** How far the walk goes before it gives up, and counts the glob as not covered. Real lists stay far below it. */
+const BUDGET = 50_000;
+/** Whether `by` matches every path `glob` matches: true, false, or undefined when it can't tell within its budget. */
+function covers(by, glob) {
+    if (by.includes(glob))
+        return true;
+    const g = automatonOf(glob);
+    const hs = by.map(automatonOf);
+    const alphabet = ["/", "", ...new Set([...glob, ...by.join("")].filter((c) => c !== "/"))];
+    const start = [closure(g, [0]), ...hs.map((h) => closure(h, [0]))];
+    const seen = new Set([JSON.stringify(start)]);
+    const queue = [start];
+    for (let i = 0; i < queue.length; i++) {
+        const [gs, ...hss] = queue[i];
+        // A path the glob matches, and nothing in `by` does.
+        if (gs.includes(g.accept) && !hss.some((s, j) => s.includes(hs[j].accept)))
+            return false;
+        for (const ch of alphabet) {
+            const g2 = step(g, gs, ch);
+            if (!g2.length)
+                continue;
+            const next = [g2, ...hss.map((s, j) => (s.length ? step(hs[j], s, ch) : s))];
+            const key = JSON.stringify(next);
+            if (seen.has(key))
+                continue;
+            if (seen.size >= BUDGET)
+                return undefined;
+            seen.add(key);
+            queue.push(next);
+        }
+    }
+    return true;
+}
+/**
+ * The globs in `globs` that `by` doesn't cover: each that matches some path no glob in `by` matches, by `globToRegExp()`'s
+ * reading. One it can't tell is counted as not covered (B-qkek1).
+ */
+export function uncovered(by, globs) {
+    return globs.filter((g) => covers(by, g) !== true);
+}
+//# sourceMappingURL=globs.js.map

package/dist/hookblock.js

@@ -0,0 +1,146 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+import { VERSION, compareReleases } from "./version.js";
+// D54: Baesian's hooks are a marked block inside whatever hook files the repo already uses, placed right after the
+// shebang, because livedocs' pre-commit ends in `exec`. The block's text is here, apart from the installer in
+// src/hooks.ts, so the fact detector can tell Baesian's own block from any other change to a hook (B-g6ywj).
+/**
+ * The hooks Baesian installs. `post-merge` and `post-rewrite` find merges (D181): git runs the first after a merge or a
+ * fast-forward (`git pull` too), never `post-commit`; the second after a rebase (`git pull --rebase` too). `pre-push`
+ * records a branch pushed to the remote's default branch as merged into it (B-h7rsv), and never stops a push.
+ */
+export const HOOKS = ["pre-commit", "commit-msg", "post-commit", "post-merge", "post-rewrite", "pre-push"];
+/** The hooks that can't stop anything, or mustn't (B-h7rsv): with Baesian missing, or failing, they carry on quietly. */
+const NEVER_STOPS = ["post-commit", "post-merge", "post-rewrite", "pre-push"];
+export const BEGIN = "# >>> baesian >>>";
+export const END = "# <<< baesian <<<";
+/** Per-clone git config key holding the command that runs Baesian when it isn't on PATH (D48). */
+export const FALLBACK_KEY = "baesian.fallback";
+/** What `writeHook` writes for a hook that didn't exist: a shebang, then the block. */
+export const NEW_HOOK = (block) => `#!/bin/sh\n${block}\n`;
+/** Text quoted for a double-quoted shell string. */
+const dq = (s) => s.replace(/[\\"$`]/g, (c) => `\\${c}`);
+/**
+ * The marked block for one hook. It's the same on every machine, because `.githooks/` is committed:
+ * the machine-specific fallback lives in the clone's own git config, never in the file.
+ *
+ * In personal mode (B-4rwyz) it's in the clone's own hooks instead, written by `baesian init --personal`, before the line
+ * that runs the repo's hook. There `post-rewrite`'s and `pre-push`'s standard input has been read into `$baesian_input`
+ * first, and Baesian gets a copy of it, as the repo's hook does; and a missing Baesian says how to stop using it in this
+ * clone, rather than to commit with `--no-verify`.
+ *
+ * `pre-push` (B-h7rsv) reads the refs being pushed from its standard input. In shared mode the block sits at the top of
+ * the repo's own hook, whose lines after it may read them too (Git LFS's do): the input is copied to a temporary file,
+ * which Baesian reads and which becomes the script's standard input again, whole. It never stops a push: whatever
+ * Baesian does, the hook carries on.
+ */
+export function hookBlock(name, personal) {
+    // commit-msg gets the message file; post-merge whether it was a squash; post-rewrite what rewrote (D181); pre-push the
+    // remote's name. post-rewrite's standard input (the commits rewritten) is left for the repo's own lines after the
+    // block: Baesian doesn't read it.
+    const withArg = name === "commit-msg" || name === "post-merge" || name === "post-rewrite" || name === "pre-push";
+    const pushing = name === "pre-push" && !personal;
+    const stdin = name === "post-rewrite" && !personal ? " </dev/null" : pushing ? ` <"$baesian_refs"` : "";
+    const pipe = (name === "post-rewrite" || name === "pre-push") && personal ? `printf '%s' "$baesian_input" | ` : "";
+    const args = withArg ? ` ${name} "$1"${stdin}` : ` ${name}`;
+    const evalArgs = withArg ? ` ${name} \\"\\$1\\"${stdin.replace(/"/g, '\\"').replace(/\$/g, "\\$")}` : ` ${name}`;
+    const never = NEVER_STOPS.includes(name);
+    // The hooks after the fact can't stop anything: they record the ledger and merges, so a missing binary is skipped
+    // quietly. Nor does pre-push stop a push, whatever happens (B-h7rsv).
+    const missing = never
+        ? "  :"
+        : personal
+            ? `  echo "baesian: not on PATH; this clone's hooks run Baesian's gate (personal mode). Install it, or stop using it here: ${dq(personal.restore)}" >&2\n  exit 1`
+            : `  echo "baesian: not on PATH; install it (npm i -g baesian) or commit with --no-verify (CI runs the same check)." >&2\n  exit 1`;
+    const after = name === "pre-push" ? " || :" : " || exit $?";
+    return [
+        BEGIN,
+        personal
+            ? "# Baesian's commit gate, for this clone only (B-4rwyz). Managed by `baesian init --personal`."
+            : "# Baesian's commit gate (D54). Managed by `baesian init`: edit outside the markers.",
+        ...(pushing ? ['if baesian_refs="$(mktemp 2>/dev/null)"; then cat >"$baesian_refs"; exec <"$baesian_refs"; else baesian_refs=/dev/null; fi'] : []),
+        "if command -v baesian >/dev/null 2>&1; then",
+        `  ${pipe}baesian hook${args}${after}`,
+        `elif baesian_fallback="$(git config --get ${FALLBACK_KEY})" && [ -n "$baesian_fallback" ]; then`,
+        `  ${pipe}eval "$baesian_fallback hook${evalArgs}"${after}`,
+        "else",
+        missing,
+        "fi",
+        ...(pushing ? ['[ "$baesian_refs" = /dev/null ] || rm -f "$baesian_refs"'] : []),
+        END,
+    ].join("\n");
+}
+/** A hook's text with Baesian's block, and the line break after it, taken out. */
+function withoutBlock(text) {
+    const start = text.indexOf(BEGIN);
+    const end = text.indexOf(END);
+    if (start < 0 || end < start)
+        return text;
+    const after = end + END.length;
+    return text.slice(0, start) + text.slice(text[after] === "\n" ? after + 1 : after);
+}
+/**
+ * Every block a released Baesian's `baesian init` wrote in a repo's committed hooks (B-np6af), by hook: the SHA-256 of
+ * the block's text, from its first marker to its last, as `hookBlock()` returned it in that release. Personal mode's
+ * blocks (B-4rwyz) are never committed, so they're not here. Teammates and CI are often a release apart, so a block any
+ * release wrote is Baesian's own, as this one's is (B-g6ywj).
+ *
+ * A release that changes a block adds the one it replaces here, if a release wrote it, and in `CHANGED_BLOCKS`, so
+ * `baesian init` writes it for one more release (B-amxkp); test/releases.test.ts checks every release tag's blocks are
+ * listed. A block found flawed is taken out, and from then on counts as any change to a hook.
+ * A release can't know the blocks of the releases after it: a newer release's block, which this list lacks, counts as a
+ * change to the hook here, as before B-np6af.
+ */
+export const RELEASED_BLOCKS = {
+    "pre-commit": ["24cb63901109e4b7868618c4c51a88e5ddcaf72426ee5d40c4680bfc8b3921e9"], // v0.1.0 to v0.1.10
+    "commit-msg": ["2f4a00b996aefc51e88e05c18709f7a3ef59e5444ff30229488d1d4bebce24a3"], // v0.1.0 to v0.1.10
+    "post-commit": ["cae9c1b0840004bdee362cbb9d43f6184f99c972351105c3895a1b574757d214"], // v0.1.0 to v0.1.10
+    "post-merge": ["8912aee3dee4dfde79bf04687553b3a4d9400bc9351cf3cfbe8f15b9a0803c39"], // v0.1.5 to v0.1.10
+    "post-rewrite": ["944bb30617d56c767f8229cdb76cdb76b42f4684b799bba436c563e0fc69e73c"], // v0.1.5 to v0.1.10
+    "pre-push": ["ad03a493a081320304d0b2a1040a6c676725244bb818561372ee508ad12b08dd"], // v0.1.8 to v0.1.10
+};
+/** A block's digest, as `RELEASED_BLOCKS` lists it. */
+export const blockDigest = (block) => createHash("sha256").update(block).digest("hex");
+/**
+ * The hooks whose block a release changed, by hook (B-amxkp, "The old block for a release"): when a release changes what
+ * `hookBlock()` returns for a committed hook, it puts the block before here, and adds the new one's digest to
+ * `RELEASED_BLOCKS` once a release has written it. `baesian init` writes the block before until a release after `since`
+ * (`writtenBlock()`), so CI pinned a release behind (B-c0e0d), and a teammate a release behind, recognise every block a
+ * commit adds, as formats roll out under B-4p43b. An entry may go once no release it names is supported. None today.
+ */
+export const CHANGED_BLOCKS = {};
+/**
+ * The block `baesian init` writes in a repo's hooks (B-amxkp): this release's, `hookBlock()`, or while a change to it is
+ * new, the block before (`CHANGED_BLOCKS`). Personal mode's blocks are never committed, so they're written new at once.
+ */
+export function writtenBlock(name, release = VERSION) {
+    const changed = CHANGED_BLOCKS[name];
+    return changed && compareReleases(changed.since, release) >= 0 ? changed.before : hookBlock(name);
+}
+/** Whether a block is one Baesian wrote for this hook: this release's, or any released one's (B-np6af). */
+export function isBaesianBlock(name, block) {
+    return block === hookBlock(name) || RELEASED_BLOCKS[name].includes(blockDigest(block));
+}
+/**
+ * Whether a change to a hook file only adds, updates or swaps Baesian's own block (B-g6ywj, B-np6af): the file is a hook
+ * Baesian installs, its new block is one a Baesian's `baesian init` wrote for that hook, this release's or any released
+ * one's (`isBaesianBlock()`), and nothing outside the block changed. Such a change isn't an infra fact: its text is
+ * Baesian's, so an ack on it would record nothing anyone decided. Any other change to a hook is one (D135), as is
+ * deleting a hook or taking the block out. The commit gate and `baesian verify` both judge hooks by it.
+ */
+export function onlyBaesianBlock(path, before, after) {
+    const name = basename(path);
+    if (after === undefined || !HOOKS.includes(name))
+        return false;
+    const start = after.indexOf(BEGIN);
+    const end = after.indexOf(END);
+    if (start < 0 || end < start)
+        return false;
+    const block = after.slice(start, end + END.length);
+    if (!isBaesianBlock(name, block))
+        return false;
+    if (after.indexOf(BEGIN, start + 1) >= 0)
+        return false;
+    return before === undefined ? after === NEW_HOOK(block) : withoutBlock(before) === withoutBlock(after);
+}
+//# sourceMappingURL=hookblock.js.map