paperlint 2.0.0

package/dist/adapters/banal/failure.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Every way getting a measurement from banal can fail, as ONE union — and `describe`, the only
+ * place a sentence about it is written. Callers branch on `kind`; nobody parses a message.
+ */
+import type { Lines } from "../../domain/text.ts";
+import type { BanalMissing } from "./locate.ts";
+export type { BanalMissing } from "./locate.ts";
+export type BanalFailure = {
+    readonly kind: "perl-missing";
+} | {
+    readonly kind: "banal-missing";
+    readonly missing: BanalMissing;
+} | {
+    readonly kind: "process-failed";
+    readonly status: number;
+    readonly stderrHead: string;
+} | {
+    readonly kind: "signalled";
+    readonly signal: string;
+    readonly stderrHead: string;
+} | {
+    readonly kind: "spawn-failed";
+    readonly message: string;
+} | {
+    readonly kind: "timed-out";
+    readonly afterMs: number;
+} | {
+    readonly kind: "no-json";
+    readonly head: string;
+}
+/** banal's own `{"error": true}` — printed with exit 0 for an input it could not read. */
+ | {
+    readonly kind: "banal-error";
+    readonly stderrHead: string;
+} | {
+    readonly kind: "unexpected-shape";
+    readonly issues: readonly string[];
+} | {
+    readonly kind: "probe-rejected";
+    readonly got: unknown;
+} | {
+    readonly kind: "download-failed";
+    readonly url: string;
+    readonly detail: string;
+} | {
+    readonly kind: "sha-mismatch";
+    readonly url: string;
+    readonly expected: string;
+    readonly got: string;
+}
+/** The installed file is there, and is not the pin. */
+ | {
+    readonly kind: "not-pinned";
+    readonly path: string;
+}
+/** The installed, pinned banal did not measure the probe page. */
+ | {
+    readonly kind: "does-not-run";
+    readonly path: string;
+    readonly why: BanalFailure;
+};
+export declare const PERL_MISSING: string;
+/**
+ * What to tell a person. Most failures are one line; a sha256 mismatch shows both hashes.
+ *
+ * The one assertion below narrows the table's entry for `f.kind` to a function of `f`: the mapped
+ * type already pairs each kind with its own variant, and TypeScript cannot correlate the index with
+ * the argument on its own.
+ */
+export declare function describe(f: BanalFailure): Lines;
+/** `describe` as one line, for a caller that has a single line to fill. */
+export declare function describeLine(f: BanalFailure): string;
+//# sourceMappingURL=failure.d.ts.map

package/dist/adapters/banal/failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure.d.ts","sourceRoot":"","sources":["../../../src/adapters/banal/failure.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;CAAE,GACjC;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAClE;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxD;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AACrD,0FAA0F;GACxF;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GACzE;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;CAAE,GAC1D;IACE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AACH,uDAAuD;GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AACxD,kEAAkE;GAChE;IACE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEN,eAAO,MAAM,YAAY,QAE+E,CAAC;AAmDzG;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAG/C;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAEpD"}

package/dist/adapters/banal/failure.js

@@ -0,0 +1,58 @@
+export const PERL_MISSING = "perl is not installed — banal, the page-geometry script HotCRP runs, is a Perl program. " +
+    "Install perl (Debian/Ubuntu: apt-get install perl; macOS ships it) and run `npx paperlint toolchain`";
+function missing(m) {
+    return m.kind === "explicit-not-found"
+        ? `banal not found: $BANAL names ${m.path}, which does not exist`
+        : `banal not found: ${m.installed} — \`npx paperlint toolchain\` installs it`;
+}
+const orNone = (s) => s || "no output";
+const DESCRIBE = {
+    "perl-missing": () => [PERL_MISSING],
+    "banal-missing": (f) => [missing(f.missing)],
+    "process-failed": (f) => [
+        `banal failed (exit ${String(f.status)}): ${orNone(f.stderrHead)}`,
+    ],
+    signalled: (f) => [`banal failed (${f.signal}): ${orNone(f.stderrHead)}`],
+    "spawn-failed": (f) => [`banal failed: ${f.message}`],
+    "timed-out": (f) => [`banal failed: no answer after ${String(f.afterMs)} ms`],
+    "no-json": (f) => [`banal printed no JSON: ${f.head || "nothing"}`],
+    "banal-error": (f) => [
+        `banal could not read the banal input XML: ${f.stderrHead}`,
+    ],
+    "unexpected-shape": (f) => [
+        `banal printed JSON that is not a measurement: ${f.issues.join("; ")}`,
+    ],
+    "probe-rejected": (f) => [
+        `banal ran on a one-page probe but measured nothing: ${JSON.stringify(f.got)}`,
+    ],
+    "download-failed": (f) => [
+        `could not download banal from ${f.url}: ${f.detail}`,
+    ],
+    "sha-mismatch": (f) => [
+        `banal from ${f.url} does not have the pinned sha256 — refusing to install it`,
+        `expected ${f.expected}`,
+        `got      ${f.got}`,
+    ],
+    "not-pinned": (f) => [
+        `banal in ${f.path} is not the pinned one (sha256 differs)`,
+    ],
+    "does-not-run": (f) => [
+        `banal in ${f.path} does not run: ${describeLine(f.why)}`,
+    ],
+};
+/**
+ * What to tell a person. Most failures are one line; a sha256 mismatch shows both hashes.
+ *
+ * The one assertion below narrows the table's entry for `f.kind` to a function of `f`: the mapped
+ * type already pairs each kind with its own variant, and TypeScript cannot correlate the index with
+ * the argument on its own.
+ */
+export function describe(f) {
+    const write = DESCRIBE[f.kind];
+    return write(f);
+}
+/** `describe` as one line, for a caller that has a single line to fill. */
+export function describeLine(f) {
+    return describe(f).join("; ");
+}
+//# sourceMappingURL=failure.js.map

package/dist/adapters/banal/failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure.js","sourceRoot":"","sources":["../../../src/adapters/banal/failure.ts"],"names":[],"mappings":"AAiDA,MAAM,CAAC,MAAM,YAAY,GACvB,0FAA0F;IAC1F,sGAAsG,CAAC;AAEzG,SAAS,OAAO,CAAC,CAAe;IAC9B,OAAO,CAAC,CAAC,IAAI,KAAK,oBAAoB;QACpC,CAAC,CAAC,iCAAiC,CAAC,CAAC,IAAI,wBAAwB;QACjE,CAAC,CAAC,oBAAoB,CAAC,CAAC,SAAS,4CAA4C,CAAC;AAClF,CAAC;AAQD,MAAM,MAAM,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,IAAI,WAAW,CAAC;AAEvD,MAAM,QAAQ,GAAe;IAC3B,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC,YAAY,CAAC;IACpC,eAAe,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAC5C,gBAAgB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACvB,sBAAsB,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE;KACnE;IACD,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAC,MAAM,MAAM,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC;IACzE,cAAc,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,CAAC,CAAC,OAAO,EAAE,CAAC;IACrD,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,iCAAiC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;IAC7E,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,0BAA0B,CAAC,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;IACnE,aAAa,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACpB,6CAA6C,CAAC,CAAC,UAAU,EAAE;KAC5D;IACD,kBAAkB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACzB,iDAAiD,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;KACvE;IACD,gBAAgB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACvB,uDAAuD,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;KAC/E;IACD,iBAAiB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACxB,iCAAiC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE;KACtD;IACD,cAAc,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACrB,cAAc,CAAC,CAAC,GAAG,2DAA2D;QAC9E,YAAY,CAAC,CAAC,QAAQ,EAAE;QACxB,YAAY,CAAC,CAAC,GAAG,EAAE;KACpB;IACD,YAAY,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACnB,YAAY,CAAC,CAAC,IAAI,yCAAyC;KAC5D;IACD,cAAc,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC;QACrB,YAAY,CAAC,CAAC,IAAI,kBAAkB,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;KAC1D;CACF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAe;IACtC,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAA+B,CAAC;IAC7D,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,YAAY,CAAC,CAAe;IAC1C,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC"}

package/dist/adapters/banal/index.d.ts

@@ -0,0 +1,17 @@
+import type { AbsolutePath } from "../../domain/paths.ts";
+import type { MeasureGeometry } from "../../ports/measure-geometry.ts";
+import type { ToolInstaller } from "../../ports/tool-installer.ts";
+import { type BanalSource } from "./pin.ts";
+import { type BanalDeps, type InstallDeps } from "./run.ts";
+import type { BanalSettings } from "./settings.ts";
+export { BANAL_DIR_ENV, BANAL_ENV, parseBanalSettings, type BanalSettings, } from "./settings.ts";
+export type { BanalDeps, InstallDeps } from "./run.ts";
+export type { BanalSource } from "./pin.ts";
+/** banal as the `MeasureGeometry` port: `$BANAL`, the project's `vendor/banal`, then the cache. */
+export declare function banalMeasurer(d: BanalDeps, s: BanalSettings, projectRoot: AbsolutePath): MeasureGeometry;
+/**
+ * banal as the `ToolInstaller` port: download at the pin, check the sha256, accept by measuring a
+ * probe page. `source` is the pin unless a test passes a local file.
+ */
+export declare function banalInstaller(d: InstallDeps, s: BanalSettings, source?: BanalSource): ToolInstaller;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/banal/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/banal/index.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAS,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAG1E,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAIL,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EACL,aAAa,EACb,SAAS,EACT,kBAAkB,EAClB,KAAK,aAAa,GACnB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvD,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAS5C,mGAAmG;AACnG,wBAAgB,aAAa,CAC3B,CAAC,EAAE,SAAS,EACZ,CAAC,EAAE,aAAa,EAChB,WAAW,EAAE,YAAY,GACxB,eAAe,CAajB;AAUD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,WAAW,EACd,CAAC,EAAE,aAAa,EAChB,MAAM,CAAC,EAAE,WAAW,GACnB,aAAa,CAiBf"}

package/dist/adapters/banal/index.js

@@ -0,0 +1,56 @@
+import { err, ok } from "../../domain/result.js";
+import { describe } from "./failure.js";
+import { provenanceLabel } from "./locate.js";
+import { pinLabel } from "./pin.js";
+import { checkBanal, ensureBanal, measureGeometry, } from "./run.js";
+export { BANAL_DIR_ENV, BANAL_ENV, parseBanalSettings, } from "./settings.js";
+/** The domain's provenance for a banal: what the facts file writes, and which rule found it. */
+const provenance = (c) => ({
+    tool: "banal",
+    path: c.path,
+    how: provenanceLabel(c.provenance),
+});
+/** banal as the `MeasureGeometry` port: `$BANAL`, the project's `vendor/banal`, then the cache. */
+export function banalMeasurer(d, s, projectRoot) {
+    return {
+        measure(pages) {
+            const g = measureGeometry(d, s, projectRoot, pages);
+            return g.source === "banal"
+                ? { kind: "measured", by: provenance(g.by), geometry: g.geometry }
+                : {
+                    kind: "unmeasured",
+                    why: describe(g.why),
+                    tried: g.tried ? provenance(g.tried) : null,
+                };
+        },
+    };
+}
+/** The one place banal's `Ready` is minted: from an `Installed`, whose `PinnedBanal` only run.ts mints. */
+const ready = (i) => ({
+    where: i.banal.path,
+    fresh: i.fresh,
+    verified: "sha256 verified, and it measured a probe page",
+});
+/**
+ * banal as the `ToolInstaller` port: download at the pin, check the sha256, accept by measuring a
+ * probe page. `source` is the pin unless a test passes a local file.
+ */
+export function banalInstaller(d, s, source) {
+    return {
+        label: pinLabel(),
+        ensure(report) {
+            const r = ensureBanal(d, s, {
+                ...(source ? { source } : {}),
+                onDownload: report,
+            });
+            return r.ok ? ok(ready(r.value)) : err(describe(r.error));
+        },
+        check() {
+            const r = checkBanal(d, s, source);
+            return r.ok
+                ? ok(ready({ banal: r.value, fresh: false }))
+                : err(describe(r.error));
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/adapters/banal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/banal/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAGjD,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,eAAe,EAAuB,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAoB,MAAM,UAAU,CAAC;AACtD,OAAO,EACL,UAAU,EACV,WAAW,EACX,eAAe,GAIhB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,aAAa,EACb,SAAS,EACT,kBAAkB,GAEnB,MAAM,eAAe,CAAC;AAIvB,gGAAgG;AAChG,MAAM,UAAU,GAAG,CAAC,CAAiB,EAAc,EAAE,CAAC,CAAC;IACrD,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,CAAC,CAAC,IAAI;IACZ,GAAG,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC;CACnC,CAAC,CAAC;AAEH,mGAAmG;AACnG,MAAM,UAAU,aAAa,CAC3B,CAAY,EACZ,CAAgB,EAChB,WAAyB;IAEzB,OAAO;QACL,OAAO,CAAC,KAAK;YACX,MAAM,CAAC,GAAG,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;YACpD,OAAO,CAAC,CAAC,MAAM,KAAK,OAAO;gBACzB,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE;gBAClE,CAAC,CAAC;oBACE,IAAI,EAAE,YAAY;oBAClB,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC;oBACpB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI;iBAC5C,CAAC;QACR,CAAC;KACF,CAAC;AACJ,CAAC;AAED,2GAA2G;AAC3G,MAAM,KAAK,GAAG,CAAC,CAAY,EAAS,EAAE,CACpC,CAAC;IACC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,IAAc;IAC7B,KAAK,EAAE,CAAC,CAAC,KAAK;IACd,QAAQ,EAAE,+CAA+C;CAC1D,CAAU,CAAC;AAEd;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,CAAc,EACd,CAAgB,EAChB,MAAoB;IAEpB,OAAO;QACL,KAAK,EAAE,QAAQ,EAAE;QACjB,MAAM,CAAC,MAAM;YACX,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE;gBAC1B,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7B,UAAU,EAAE,MAAM;aACnB,CAAC,CAAC;YACH,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5D,CAAC;QACD,KAAK;YACH,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;YACnC,OAAO,CAAC,CAAC,EAAE;gBACT,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;gBAC7C,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QAC7B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/adapters/banal/install.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The install decisions, on bytes: is what is on disk the pin, and may downloaded bytes be kept.
+ * One predicate for `paperlint toolchain` and `paperlint toolchain --check`, so the two cannot disagree.
+ */
+import type { Opaque } from "ts-essentials";
+import { type Result } from "../../domain/result.ts";
+import { type Sha256 } from "../../domain/sha256.ts";
+import type { BanalSource } from "./pin.ts";
+/** Bytes that hash to the pin. Minted by `verifyPin` only; the installer writes nothing else. */
+export type PinnedBytes = Opaque<Uint8Array, "PinnedBytes">;
+export interface ShaMismatch {
+    readonly expected: Sha256;
+    readonly got: Sha256;
+}
+export declare function verifyPin(bytes: Uint8Array, source: BanalSource): Result<PinnedBytes, ShaMismatch>;
+/** What is installed, judged against the pin. */
+export type InstalledState = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "other-bytes";
+    readonly mismatch: ShaMismatch;
+} | {
+    readonly kind: "pinned";
+};
+export declare function installedState(current: Uint8Array | null, source: BanalSource): InstalledState;
+//# sourceMappingURL=install.d.ts.map

package/dist/adapters/banal/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/adapters/banal/install.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAa,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,iGAAiG;AACjG,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,WAAW,GAClB,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAKlC;AAED,iDAAiD;AACjD,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAA;CAAE,GAChE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAEhC,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,GAAG,IAAI,EAC1B,MAAM,EAAE,WAAW,GAClB,cAAc,CAIhB"}

package/dist/adapters/banal/install.js

@@ -0,0 +1,15 @@
+import { err, ok } from "../../domain/result.js";
+import { sha256Hex } from "../../domain/sha256.js";
+export function verifyPin(bytes, source) {
+    const got = sha256Hex(bytes);
+    return got === source.sha256
+        ? ok(bytes)
+        : err({ expected: source.sha256, got });
+}
+export function installedState(current, source) {
+    if (current === null)
+        return { kind: "absent" };
+    const v = verifyPin(current, source);
+    return v.ok ? { kind: "pinned" } : { kind: "other-bytes", mismatch: v.error };
+}
+//# sourceMappingURL=install.js.map

package/dist/adapters/banal/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","sourceRoot":"","sources":["../../../src/adapters/banal/install.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,GAAG,EAAE,EAAE,EAAe,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAe,MAAM,wBAAwB,CAAC;AAWhE,MAAM,UAAU,SAAS,CACvB,KAAiB,EACjB,MAAmB;IAEnB,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IAC7B,OAAO,GAAG,KAAK,MAAM,CAAC,MAAM;QAC1B,CAAC,CAAC,EAAE,CAAC,KAAoB,CAAC;QAC1B,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;AAC5C,CAAC;AAQD,MAAM,UAAU,cAAc,CAC5B,OAA0B,EAC1B,MAAmB;IAEnB,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IAChD,MAAM,CAAC,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;AAChF,CAAC"}

package/dist/adapters/banal/invocation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A banal run, as DATA. What must be on disk before banal starts — the banal input XML and the
+ * `pdftohtml -v` stub, always together — and the command that runs it.
+ *
+ * Why the stub: banal asks `$pdftohtml -v` once, before it reads any input (the XML included), to
+ * pick the zoom and a font-size correction (banal 1.2, lines 1828-1868). With no pdftohtml it stops
+ * (`Error: Failed to run pdftohtml`, measured); told a version below 0.85 it applies a larger
+ * correction and every font size moves. So `$PDFTOHTML` (banal's own override, line 166) points at a
+ * stub that answers `-v` with `XML_DIALECT.version` — the pdftohtml whose XML `xml.ts` writes — and
+ * refuses anything else. `test/e2e/banal.mjs` shows both failures with the real banal.
+ */
+import type { Opaque } from "ts-essentials";
+import type { AbsolutePath } from "../../domain/paths.ts";
+import type { Command } from "../../ports/process.ts";
+import type { Scratch } from "../../ports/workspace.ts";
+import type { LocatedBanal } from "./locate.ts";
+import type { PageLayout } from "../../domain/page-layout.ts";
+/** banal takes well under a second on a paper; a hang still has to end. */
+export declare const BANAL_RUN_MS = 120000;
+/** A path quoted for `/bin/sh`. Minted by `shQuote` only. */
+export type ShQuoted = Opaque<string, "ShQuoted">;
+/** banal interpolates `$PDFTOHTML` into a shell command unquoted — so the value is quoted here. */
+export declare const shQuote: (s: string) => ShQuoted;
+/** The stub standing in for `pdftohtml`: it answers `-v` and refuses to convert anything. */
+export declare const PDFTOHTML_STUB: string;
+export interface StagedFile<N extends string, M extends "read" | "exec"> {
+    readonly name: N;
+    readonly content: string;
+    readonly mode: M;
+}
+/** What must exist on disk before banal runs. Both files, always: there is no way to build one alone. */
+export interface BanalStaging {
+    readonly files: readonly [
+        StagedFile<"paper.xml", "read">,
+        StagedFile<"pdftohtml", "exec">
+    ];
+}
+export declare const stageBanalInput: (pages: readonly PageLayout[]) => BanalStaging;
+/** The staging written to disk. Minted by `stage` only: both files written, or nothing returned. */
+export type StagedInput = Opaque<{
+    readonly xml: AbsolutePath;
+    readonly stub: AbsolutePath;
+}, "StagedInput">;
+/** Write a staging into a scratch directory, the stub executable. The only minter of `StagedInput`. */
+export declare function stage(s: Scratch, staging: BanalStaging): StagedInput;
+/** `perl banal -no-time -json <xml>`, with `$PDFTOHTML` quoted by construction. */
+export declare function banalCommand(banal: LocatedBanal, staged: StagedInput, baseEnv: Readonly<Record<string, string>>): Command;
+//# sourceMappingURL=invocation.d.ts.map

package/dist/adapters/banal/invocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation.d.ts","sourceRoot":"","sources":["../../../src/adapters/banal/invocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAG9D,2EAA2E;AAC3E,eAAO,MAAM,YAAY,SAAU,CAAC;AAEpC,6DAA6D;AAC7D,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAElD,mGAAmG;AACnG,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,QACS,CAAC;AAE9C,6FAA6F;AAC7F,eAAO,MAAM,cAAc,QAWf,CAAC;AAEb,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM;IACrE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CAClB;AAED,yGAAyG;AACzG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS;QACvB,UAAU,CAAC,WAAW,EAAE,MAAM,CAAC;QAC/B,UAAU,CAAC,WAAW,EAAE,MAAM,CAAC;KAChC,CAAC;CACH;AAED,eAAO,MAAM,eAAe,GAC1B,OAAO,SAAS,UAAU,EAAE,KAC3B,YAKD,CAAC;AAEH,oGAAoG;AACpG,MAAM,MAAM,WAAW,GAAG,MAAM,CAC9B;IAAE,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE,EAC3D,aAAa,CACd,CAAC;AAEF,uGAAuG;AACvG,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,GAAG,WAAW,CAMpE;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAC1B,KAAK,EAAE,YAAY,EACnB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACxC,OAAO,CAQT"}

package/dist/adapters/banal/invocation.js

@@ -0,0 +1,43 @@
+import { pdf2xml, XML_DIALECT } from "./xml.js";
+/** banal takes well under a second on a paper; a hang still has to end. */
+export const BANAL_RUN_MS = 120_000;
+/** banal interpolates `$PDFTOHTML` into a shell command unquoted — so the value is quoted here. */
+export const shQuote = (s) => `'${s.replace(/'/g, `'"'"'`)}'`;
+/** The stub standing in for `pdftohtml`: it answers `-v` and refuses to convert anything. */
+export const PDFTOHTML_STUB = [
+    "#!/bin/sh",
+    "# research-paper-pipeline: banal reads the banal input XML rpp writes, never a PDF. banal still",
+    "# asks `pdftohtml -v` which dialect to expect; this answers with the one rpp writes.",
+    'if [ "$1" = "-v" ]; then',
+    `  echo "pdftohtml version ${XML_DIALECT.version}"`,
+    "  exit 0",
+    "fi",
+    'echo "rpp: this pdftohtml only answers -v; banal was given a PDF instead of the banal input XML" >&2',
+    "exit 1",
+    "",
+].join("\n");
+export const stageBanalInput = (pages) => ({
+    files: [
+        { name: "paper.xml", content: pdf2xml(pages), mode: "read" },
+        { name: "pdftohtml", content: PDFTOHTML_STUB, mode: "exec" },
+    ],
+});
+/** Write a staging into a scratch directory, the stub executable. The only minter of `StagedInput`. */
+export function stage(s, staging) {
+    const [xml, stub] = staging.files;
+    return {
+        xml: s.write(xml.name, xml.content, xml.mode),
+        stub: s.write(stub.name, stub.content, stub.mode),
+    };
+}
+/** `perl banal -no-time -json <xml>`, with `$PDFTOHTML` quoted by construction. */
+export function banalCommand(banal, staged, baseEnv) {
+    return {
+        file: "perl",
+        args: [banal.path, "-no-time", "-json", staged.xml],
+        env: { ...baseEnv, PDFTOHTML: shQuote(staged.stub) },
+        timeoutMs: BANAL_RUN_MS,
+        maxOutputBytes: 64 * 1024 * 1024,
+    };
+}
+//# sourceMappingURL=invocation.js.map

package/dist/adapters/banal/invocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation.js","sourceRoot":"","sources":["../../../src/adapters/banal/invocation.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEhD,2EAA2E;AAC3E,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC;AAKpC,mGAAmG;AACnG,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAS,EAAY,EAAE,CAC7C,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAe,CAAC;AAE9C,6FAA6F;AAC7F,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,WAAW;IACX,iGAAiG;IACjG,sFAAsF;IACtF,0BAA0B;IAC1B,6BAA6B,WAAW,CAAC,OAAO,GAAG;IACnD,UAAU;IACV,IAAI;IACJ,sGAAsG;IACtG,QAAQ;IACR,EAAE;CACH,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAgBb,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAA4B,EACd,EAAE,CAAC,CAAC;IAClB,KAAK,EAAE;QACL,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE;QAC5D,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,EAAE;KAC7D;CACF,CAAC,CAAC;AAQH,uGAAuG;AACvG,MAAM,UAAU,KAAK,CAAC,CAAU,EAAE,OAAqB;IACrD,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC;IAClC,OAAO;QACL,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC;QAC7C,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC;KACnC,CAAC;AACnB,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,YAAY,CAC1B,KAAmB,EACnB,MAAmB,EACnB,OAAyC;IAEzC,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC;QACnD,GAAG,EAAE,EAAE,GAAG,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;QACpD,SAAS,EAAE,YAAY;QACvB,cAAc,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;KACjC,CAAC;AACJ,CAAC"}

package/dist/adapters/banal/locate.d.ts

@@ -0,0 +1,50 @@
+import type { Opaque } from "ts-essentials";
+import type { AbsolutePath } from "../../domain/paths.ts";
+import { type Result } from "../../domain/result.ts";
+import type { BanalSettings } from "./settings.ts";
+export type Provenance = {
+    readonly kind: "env";
+} | {
+    readonly kind: "vendor";
+} | {
+    readonly kind: "cache";
+};
+export interface BanalCandidate {
+    readonly path: AbsolutePath;
+    readonly provenance: Provenance;
+}
+/** A candidate the `Files` port confirmed is a file. Minted by `pickBanal` only. */
+export type LocatedBanal = Opaque<BanalCandidate, "LocatedBanal">;
+/**
+ * `paperlint toolchain`'s banal after its bytes hashed to the pin AND it measured the probe page. Minted by
+ * `ensureBanal` / `checkBanal` only (`./index.ts`): a "ready" line cannot be printed without one.
+ */
+export type PinnedBanal = Opaque<BanalCandidate, "PinnedBanal">;
+/** Why there is no banal to run. */
+export type BanalMissing = 
+/** `$BANAL` names a file that is not there. An explicit choice: no fallback to another banal. */
+{
+    readonly kind: "explicit-not-found";
+    readonly path: string;
+}
+/** Nothing named, nothing vendored, and `paperlint toolchain` has not installed it (here). */
+ | {
+    readonly kind: "not-installed";
+    readonly installed: string;
+};
+/** Where to look. An explicit `$BANAL` is the whole search; otherwise vendor, then the cache. */
+export type LookupOrder = {
+    readonly kind: "explicit";
+    readonly path: AbsolutePath;
+} | {
+    readonly kind: "search";
+    readonly vendor: AbsolutePath;
+    readonly cache: AbsolutePath;
+};
+/** Where `paperlint toolchain` puts the pinned banal: one directory per HotCRP commit. */
+export declare const installedBanal: (s: BanalSettings) => AbsolutePath;
+export declare function lookupOrder(s: BanalSettings, projectRoot: AbsolutePath): LookupOrder;
+export declare function pickBanal(order: LookupOrder, isFile: (p: AbsolutePath) => boolean): Result<LocatedBanal, BanalMissing>;
+/** Which rule found it, as a person reads it. */
+export declare const provenanceLabel: (p: Provenance) => string;
+//# sourceMappingURL=locate.d.ts.map

package/dist/adapters/banal/locate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locate.d.ts","sourceRoot":"","sources":["../../../src/adapters/banal/locate.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/B,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CACjC;AAED,oFAAoF;AACpF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;AAElE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;AAEhE,oCAAoC;AACpC,MAAM,MAAM,YAAY;AACtB,iGAAiG;AAC/F;IAAE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAChE,8FAA8F;GAC5F;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,iGAAiG;AACjG,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;CAAE,GAC1D;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;CAC9B,CAAC;AAEN,0FAA0F;AAC1F,eAAO,MAAM,cAAc,GAAI,GAAG,aAAa,KAAG,YACwB,CAAC;AAE3E,wBAAgB,WAAW,CACzB,CAAC,EAAE,aAAa,EAChB,WAAW,EAAE,YAAY,GACxB,WAAW,CAOb;AAKD,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,GACnC,MAAM,CAAC,YAAY,EAAE,YAAY,CAAC,CAQpC;AAED,iDAAiD;AACjD,eAAO,MAAM,eAAe,GAAI,GAAG,UAAU,KAAG,MAG7C,CAAC"}

package/dist/adapters/banal/locate.js

@@ -0,0 +1,34 @@
+/**
+ * Where a banal may be, in order; which one is there; and which rule found it. The order:
+ * `$BANAL` (an explicit choice — if it names nothing, there is NO fallback), `<project>/vendor/banal`
+ * (a project that vendors its own copy), then the one `paperlint toolchain` installed.
+ */
+import { join } from "node:path";
+import { err, ok } from "../../domain/result.js";
+import { BANAL_PIN } from "./pin.js";
+/** Where `paperlint toolchain` puts the pinned banal: one directory per HotCRP commit. */
+export const installedBanal = (s) => join(s.cacheDir, BANAL_PIN.commit.slice(0, 12), "banal");
+export function lookupOrder(s, projectRoot) {
+    if (s.explicit)
+        return { kind: "explicit", path: s.explicit };
+    return {
+        kind: "search",
+        vendor: join(projectRoot, "vendor", "banal"),
+        cache: installedBanal(s),
+    };
+}
+const located = (path, kind) => ok({ path, provenance: { kind } });
+export function pickBanal(order, isFile) {
+    if (order.kind === "explicit")
+        return isFile(order.path)
+            ? located(order.path, "env")
+            : err({ kind: "explicit-not-found", path: order.path });
+    if (isFile(order.vendor))
+        return located(order.vendor, "vendor");
+    if (isFile(order.cache))
+        return located(order.cache, "cache");
+    return err({ kind: "not-installed", installed: order.cache });
+}
+/** Which rule found it, as a person reads it. */
+export const provenanceLabel = (p) => ({ env: "$BANAL", vendor: "vendor/banal", cache: "paperlint toolchain" })[p.kind];
+//# sourceMappingURL=locate.js.map

package/dist/adapters/banal/locate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locate.js","sourceRoot":"","sources":["../../../src/adapters/banal/locate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,GAAG,EAAE,EAAE,EAAe,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAsCrC,0FAA0F;AAC1F,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAgB,EAAgB,EAAE,CAC/D,IAAI,CAAC,CAAC,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,OAAO,CAAiB,CAAC;AAE3E,MAAM,UAAU,WAAW,CACzB,CAAgB,EAChB,WAAyB;IAEzB,IAAI,CAAC,CAAC,QAAQ;QAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC9D,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAiB;QAC5D,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC;KACzB,CAAC;AACJ,CAAC;AAED,MAAM,OAAO,GAAG,CAAC,IAAkB,EAAE,IAAwB,EAAE,EAAE,CAC/D,EAAE,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,IAAI,EAAE,EAAkB,CAAC,CAAC;AAErD,MAAM,UAAU,SAAS,CACvB,KAAkB,EAClB,MAAoC;IAEpC,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU;QAC3B,OAAO,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;YACvB,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC;YAC5B,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5D,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;QAAE,OAAO,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjE,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;QAAE,OAAO,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9D,OAAO,GAAG,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;AAChE,CAAC;AAED,iDAAiD;AACjD,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAa,EAAU,EAAE,CACvD,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,qBAAqB,EAAE,CAAC,CACvE,CAAC,CAAC,IAAI,CACP,CAAC"}

package/dist/adapters/banal/output.d.ts

@@ -0,0 +1,27 @@
+/**
+ * banal's output, PARSED — one schema, one type, read by both consumers (the facts file and the
+ * install probe). What banal prints was measured on the pinned banal 1.2 (2026-09-25): an object
+ * with `papersize` ([height, width] in points), `columns`, `bodyfontsize` — null on an empty
+ * document — and `pages`, one entry per page, where a page's `type` is OMITTED when it is "body".
+ */
+import { z } from "zod";
+import type { PageGeometry } from "../../domain/geometry.ts";
+import type { ProcessExit } from "../../ports/process.ts";
+import { type Result } from "../../domain/result.ts";
+import type { BanalFailure } from "./failure.ts";
+export declare const measurementSchema: z.ZodObject<{
+    papersize: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    columns: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    bodyfontsize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    pages: z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        reffontsize: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** A measurement banal printed. banal's `{"error": true}` object cannot be one: it is refused first. */
+export type BanalMeasurement = z.infer<typeof measurementSchema>;
+/** A banal run as a measurement, or which failure it was. Total over `ProcessExit`. */
+export declare const parseBanalOutput: (r: ProcessExit) => Result<BanalMeasurement, BanalFailure>;
+/** The measurement → the domain's page geometry. */
+export declare function geometryOf(m: BanalMeasurement): PageGeometry;
+//# sourceMappingURL=output.d.ts.map

package/dist/adapters/banal/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/adapters/banal/output.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAoB,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAUjD,eAAO,MAAM,iBAAiB;;;;;;;;iBAM5B,CAAC;AAEH,wGAAwG;AACxG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AA8DjE,uFAAuF;AACvF,eAAO,MAAM,gBAAgB,GAC3B,GAAG,WAAW,KACb,MAAM,CAAC,gBAAgB,EAAE,YAAY,CACF,CAAC;AA2BvC,oDAAoD;AACpD,wBAAgB,UAAU,CAAC,CAAC,EAAE,gBAAgB,GAAG,YAAY,CAgB5D"}

package/dist/adapters/banal/output.js

@@ -0,0 +1,112 @@
+/**
+ * banal's output, PARSED — one schema, one type, read by both consumers (the facts file and the
+ * install probe). What banal prints was measured on the pinned banal 1.2 (2026-09-25): an object
+ * with `papersize` ([height, width] in points), `columns`, `bodyfontsize` — null on an empty
+ * document — and `pages`, one entry per page, where a page's `type` is OMITTED when it is "body".
+ */
+import { z } from "zod";
+import { firstLine } from "../../domain/text.js";
+import { andThen, err, ok } from "../../domain/result.js";
+const page = z.looseObject({
+    type: z.string().optional(),
+    reffontsize: z.number().nullable().optional(),
+});
+/** banal's own failure object: exit 0 and `{"error": true, …}`. It has no measurement in it. */
+const banalError = z.looseObject({ error: z.literal(true) });
+export const measurementSchema = z.looseObject({
+    papersize: z.tuple([z.number(), z.number()]).optional(),
+    columns: z.number().nullable().optional(),
+    bodyfontsize: z.number().nullable().optional(),
+    /** Required: banal emits it on every run, an empty document included (measured). */
+    pages: z.array(page),
+});
+/** The process-level outcome, before stdout is read: banal's streams, or why there are none. */
+function streamsOf(r) {
+    switch (r.kind) {
+        case "not-found":
+            return err({ kind: "perl-missing" });
+        case "spawn-failed":
+            return err({ kind: "spawn-failed", message: r.message });
+        case "timed-out":
+            return err({ kind: "timed-out", afterMs: r.afterMs });
+        case "signalled":
+            return err({
+                kind: "signalled",
+                signal: r.signal,
+                stderrHead: firstLine(r.stderr),
+            });
+        case "exited":
+            return r.status === 0
+                ? ok(r)
+                : err({
+                    kind: "process-failed",
+                    status: r.status,
+                    stderrHead: firstLine(r.stderr),
+                });
+    }
+}
+function jsonOf(stdout) {
+    try {
+        return ok(JSON.parse(stdout));
+    }
+    catch {
+        return err(null);
+    }
+}
+/** What banal printed, as a measurement — or which failure it is. */
+function measurementOf(o) {
+    const json = jsonOf(o.stdout);
+    if (!json.ok)
+        return err({
+            kind: "no-json",
+            head: firstLine(o.stdout) || firstLine(o.stderr),
+        });
+    if (banalError.safeParse(json.value).success)
+        return err({ kind: "banal-error", stderrHead: firstLine(o.stderr) });
+    const m = measurementSchema.safeParse(json.value);
+    return m.success
+        ? ok(m.data)
+        : err({
+            kind: "unexpected-shape",
+            issues: m.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`),
+        });
+}
+/** A banal run as a measurement, or which failure it was. Total over `ProcessExit`. */
+export const parseBanalOutput = (r) => andThen(streamsOf(r), measurementOf);
+const inches = (pt) => pt === undefined ? null : Number((pt / 72).toFixed(3));
+/**
+ * 🔴 banal OMITS a page's `type` when it is "body" (its line 1022: `push … if $page->{type} ne
+ * "body"`), so counting pages whose type equals "body" gives ZERO for every paper in the world —
+ * that is how the first page-limit gate was written, and it could not fire once. A page without a
+ * type IS a body page.
+ */
+const typeOf = (p) => p.type ?? "body";
+/** Pages per type, body pages included under "body". */
+function countByType(pages) {
+    const byType = {};
+    for (const p of pages)
+        byType[typeOf(p)] = (byType[typeOf(p)] ?? 0) + 1;
+    return byType;
+}
+/** The reference font size: the first bibliography page that has one. */
+const refFontSize = (pages) => pages.find((p) => p.type === "bib" && p.reffontsize != null)?.reffontsize ??
+    null;
+/** The measurement → the domain's page geometry. */
+export function geometryOf(m) {
+    const byType = countByType(m.pages);
+    const refPages = byType["bib"] ?? 0;
+    const appendixPages = byType["appendix"] ?? 0;
+    return {
+        // banal gives papersize as [height, width] in points — checked against live output 2026-08-26.
+        pageWidthIn: inches(m.papersize?.[1]),
+        pageHeightIn: inches(m.papersize?.[0]),
+        columns: m.columns ?? null,
+        bodyPt: m.bodyfontsize ?? null,
+        refPt: refFontSize(m.pages),
+        bodyPages: m.pages.length - refPages - appendixPages,
+        refPages,
+        appendixPages,
+        pagesByType: byType,
+    };
+}
+//# sourceMappingURL=output.js.map