@deftai/directive-core 0.55.0

package/dist/pr-monitor/readiness.js

@@ -0,0 +1,64 @@
+import { computeGateResult } from "../pr-merge-readiness/compute.js";
+import { EXIT_EXTERNAL_ERROR } from "../pr-merge-readiness/constants.js";
+import { defaultRunGh } from "../pr-merge-readiness/gh.js";
+import { exitCodeFor, gateResultToDict } from "../pr-merge-readiness/output.js";
+import { EXIT_CONFIG_ERROR } from "./constants.js";
+/** Match Python json.dumps(..., indent=2) default ensure_ascii=True. */
+function pythonJsonDumps(value) {
+    const json = JSON.stringify(value, null, 2);
+    return json.replace(/[\u007f-\uffff]/g, (ch) => {
+        const code = ch.charCodeAt(0);
+        return `\\u${code.toString(16).padStart(4, "0")}`;
+    });
+}
+/** Run one pr_merge_readiness-equivalent check and parse the verdict JSON. */
+export function callReadiness(prNumber, repo, options = {}) {
+    const stderrChunks = [];
+    const originalWrite = process.stderr.write.bind(process.stderr);
+    const captureWrite = ((chunk, ..._args) => {
+        if (typeof chunk === "string") {
+            stderrChunks.push(chunk);
+        }
+        else {
+            stderrChunks.push(Buffer.from(chunk).toString("utf8"));
+        }
+        return true;
+    });
+    try {
+        process.stderr.write = captureWrite;
+        const runGh = options.runGh ?? defaultRunGh;
+        const result = computeGateResult(prNumber, repo, runGh);
+        const payload = gateResultToDict(result);
+        const exitCode = exitCodeFor(result);
+        return {
+            exitCode,
+            payload,
+            rawStdout: `${pythonJsonDumps(payload)}\n`,
+            rawStderr: stderrChunks.join(""),
+        };
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : `unexpected exception running readiness: ${String(exc)}`;
+        return {
+            exitCode: EXIT_CONFIG_ERROR,
+            payload: {
+                via: "error",
+                merge_ready: false,
+                error: message,
+            },
+            rawStdout: "",
+            rawStderr: stderrChunks.join("") || message,
+        };
+    }
+    finally {
+        process.stderr.write = originalWrite;
+    }
+}
+/** Map readiness-layer external errors to monitor poll semantics. */
+export function readinessExitToPoll(exitCode) {
+    if (exitCode === EXIT_EXTERNAL_ERROR) {
+        return 1;
+    }
+    return exitCode;
+}
+//# sourceMappingURL=readiness.js.map

package/dist/pr-monitor/types.d.ts

@@ -0,0 +1,30 @@
+import type { RunGhFn } from "../pr-merge-readiness/types.js";
+export interface PollResult {
+    readonly exitCode: number;
+    readonly payload: Record<string, unknown>;
+    readonly rawStdout: string;
+    readonly rawStderr: string;
+}
+export interface MonotonicClock {
+    now(): number;
+}
+export type SleepFn = (seconds: number) => void;
+export type CallReadinessFn = (prNumber: number, repo: string) => PollResult;
+export interface MonitorOptions {
+    readonly capMinutes?: number;
+    readonly cadence?: ReadonlyArray<readonly [number, number]>;
+    readonly sleepFn?: SleepFn;
+    readonly clockFn?: MonotonicClock;
+    readonly callReadinessFn?: CallReadinessFn;
+    readonly runGh?: RunGhFn;
+}
+export interface MonitorRunResult {
+    readonly exitCode: number;
+    readonly payload: Record<string, unknown>;
+    readonly pollCount: number;
+}
+export interface CallReadinessOptions {
+    readonly runGh?: RunGhFn;
+    readonly timeoutMs?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/pr-monitor/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/pr-protected-issues/constants.d.ts

@@ -0,0 +1,7 @@
+/** Exit codes — mirrors scripts/pr_check_protected_issues.py. */
+export declare const EXIT_OK = 0;
+export declare const EXIT_PROTECTED_LINKED = 1;
+export declare const EXIT_EXTERNAL_ERROR = 2;
+/** gh subprocess timeout in seconds (matches Python oracle). */
+export declare const GH_TIMEOUT_S = 30;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pr-protected-issues/constants.js

@@ -0,0 +1,7 @@
+/** Exit codes — mirrors scripts/pr_check_protected_issues.py. */
+export const EXIT_OK = 0;
+export const EXIT_PROTECTED_LINKED = 1;
+export const EXIT_EXTERNAL_ERROR = 2;
+/** gh subprocess timeout in seconds (matches Python oracle). */
+export const GH_TIMEOUT_S = 30;
+//# sourceMappingURL=constants.js.map

package/dist/pr-protected-issues/gh.d.ts

@@ -0,0 +1,9 @@
+import type { RunGhFn, RunGhResult } from "./types.js";
+/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
+export declare function defaultRunGh(cmd: readonly string[]): RunGhResult;
+/**
+ * Run ``gh pr view <N> --json closingIssuesReferences`` and return linked issue
+ * numbers. Returns ``null`` on external error (caller maps to EXIT_EXTERNAL_ERROR).
+ */
+export declare function fetchClosingIssuesReferences(prNumber: number, repo: string | null, runGh: RunGhFn): number[] | null;
+//# sourceMappingURL=gh.d.ts.map

package/dist/pr-protected-issues/gh.js

@@ -0,0 +1,96 @@
+import { execFileSync } from "node:child_process";
+import { resolveBinary } from "../scm/binary.js";
+import { SUBPROCESS_MAX_BUFFER } from "../subprocess/max-buffer.js";
+import { GH_TIMEOUT_S } from "./constants.js";
+/** UTF-8-safe gh capture via execFile (no shell) — mirrors _safe_subprocess.run_text (#1366). */
+export function defaultRunGh(cmd) {
+    if (cmd.length === 0 || cmd[0] !== "gh") {
+        return { returncode: -1, stdout: "", stderr: "expected gh as first argv element" };
+    }
+    const binary = resolveBinary();
+    const args = cmd.slice(1);
+    try {
+        const stdout = execFileSync(binary, args, {
+            encoding: "utf8",
+            timeout: GH_TIMEOUT_S * 1000,
+            stdio: ["ignore", "pipe", "pipe"],
+            maxBuffer: SUBPROCESS_MAX_BUFFER,
+        });
+        return { returncode: 0, stdout: typeof stdout === "string" ? stdout : "", stderr: "" };
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT") {
+            return { returncode: -1, stdout: "", stderr: "gh CLI not found. Install GitHub CLI." };
+        }
+        if (e.code === "ETIMEDOUT") {
+            return { returncode: -2, stdout: "", stderr: "" };
+        }
+        return {
+            returncode: typeof e.status === "number" ? e.status : -1,
+            stdout: typeof e.stdout === "string" ? e.stdout : "",
+            stderr: typeof e.stderr === "string" ? e.stderr : String(e.message ?? ""),
+        };
+    }
+}
+/**
+ * Run ``gh pr view <N> --json closingIssuesReferences`` and return linked issue
+ * numbers. Returns ``null`` on external error (caller maps to EXIT_EXTERNAL_ERROR).
+ */
+export function fetchClosingIssuesReferences(prNumber, repo, runGh) {
+    const cmd = ["gh", "pr", "view", String(prNumber), "--json", "closingIssuesReferences"];
+    if (repo) {
+        cmd.push("--repo", repo);
+    }
+    let result;
+    try {
+        result = runGh(cmd);
+    }
+    catch {
+        process.stderr.write("Error: gh CLI not found. Install GitHub CLI.\n");
+        return null;
+    }
+    if (result.returncode === -1 && result.stderr.includes("gh CLI not found")) {
+        process.stderr.write("Error: gh CLI not found. Install GitHub CLI.\n");
+        return null;
+    }
+    if (result.returncode === -2) {
+        process.stderr.write(`Error: gh CLI timed out fetching PR #${prNumber}.\n`);
+        return null;
+    }
+    if (result.returncode !== 0) {
+        process.stderr.write(`Error: gh CLI failed fetching PR #${prNumber}: ${result.stderr.trim()}\n`);
+        return null;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(result.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        process.stderr.write(`Error: failed to parse gh CLI output for PR #${prNumber}: ${message}\n`);
+        return null;
+    }
+    const refs = payload.closingIssuesReferences;
+    if (!Array.isArray(refs)) {
+        const typeName = refs === null ? "null" : typeof refs;
+        process.stderr.write(`Error: unexpected closingIssuesReferences shape for PR #${prNumber} ` +
+            `(expected list, got ${typeName})\n`);
+        return null;
+    }
+    const linked = [];
+    for (const entry of refs) {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+            continue;
+        }
+        const number = entry.number;
+        if (typeof number === "number" && Number.isInteger(number)) {
+            linked.push(number);
+        }
+        else if (typeof number === "string" && /^[0-9]+$/.test(number)) {
+            linked.push(Number(number));
+        }
+    }
+    return linked;
+}
+//# sourceMappingURL=gh.js.map

package/dist/pr-protected-issues/index.d.ts

@@ -0,0 +1,6 @@
+export { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_PROTECTED_LINKED, GH_TIMEOUT_S, } from "./constants.js";
+export { defaultRunGh, fetchClosingIssuesReferences } from "./gh.js";
+export { cmdPrProtectedIssues, parseArgs, run } from "./main.js";
+export { parseProtected } from "./parse.js";
+export type { RunGhFn, RunGhResult } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-protected-issues/index.js

@@ -0,0 +1,5 @@
+export { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_PROTECTED_LINKED, GH_TIMEOUT_S, } from "./constants.js";
+export { defaultRunGh, fetchClosingIssuesReferences } from "./gh.js";
+export { cmdPrProtectedIssues, parseArgs, run } from "./main.js";
+export { parseProtected } from "./parse.js";
+//# sourceMappingURL=index.js.map

package/dist/pr-protected-issues/main.d.ts

@@ -0,0 +1,14 @@
+import type { RunGhFn } from "./types.js";
+export interface ParsedArgs {
+    readonly prNumber: number | null;
+    readonly protectedValues: readonly string[];
+    readonly repo: string | null;
+    readonly error?: string;
+}
+export declare function parseArgs(argv: readonly string[]): ParsedArgs;
+export interface RunOptions {
+    readonly runGh?: RunGhFn;
+}
+export declare function run(argv: readonly string[], options?: RunOptions): number;
+export declare function cmdPrProtectedIssues(argv: readonly string[], options?: RunOptions): number;
+//# sourceMappingURL=main.d.ts.map

package/dist/pr-protected-issues/main.js

@@ -0,0 +1,128 @@
+import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_PROTECTED_LINKED } from "./constants.js";
+import { defaultRunGh, fetchClosingIssuesReferences } from "./gh.js";
+import { parseProtected } from "./parse.js";
+export function parseArgs(argv) {
+    let prNumber = null;
+    const protectedValues = [];
+    let repo = null;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--protected") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    prNumber,
+                    protectedValues,
+                    repo,
+                    error: "argument --protected: expected one argument",
+                };
+            }
+            protectedValues.push(value);
+            i += 1;
+        }
+        else if (arg?.startsWith("--protected=")) {
+            protectedValues.push(arg.slice("--protected=".length));
+        }
+        else if (arg === "--repo") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return {
+                    prNumber,
+                    protectedValues,
+                    repo,
+                    error: "argument --repo: expected one argument",
+                };
+            }
+            repo = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--repo=")) {
+            repo = arg.slice("--repo=".length);
+        }
+        else if (arg?.startsWith("-")) {
+            return {
+                prNumber,
+                protectedValues,
+                repo,
+                error: `unrecognized arguments: ${arg}`,
+            };
+        }
+        else if (prNumber === null) {
+            const n = Number(arg);
+            if (!Number.isInteger(n)) {
+                return {
+                    prNumber,
+                    protectedValues,
+                    repo,
+                    error: `invalid PR number: ${arg}`,
+                };
+            }
+            prNumber = n;
+        }
+        else {
+            return {
+                prNumber,
+                protectedValues,
+                repo,
+                error: `unrecognized arguments: ${arg}`,
+            };
+        }
+    }
+    if (prNumber === null) {
+        return {
+            prNumber,
+            protectedValues,
+            repo,
+            error: "the following arguments are required: pr_number",
+        };
+    }
+    return { prNumber, protectedValues, repo };
+}
+export function run(argv, options = {}) {
+    const args = parseArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`Error: ${args.error}\n`);
+        return EXIT_EXTERNAL_ERROR;
+    }
+    let protectedIssues;
+    try {
+        protectedIssues = parseProtected(args.protectedValues);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        process.stderr.write(`Error: ${message}\n`);
+        return EXIT_EXTERNAL_ERROR;
+    }
+    if (protectedIssues.length === 0) {
+        process.stderr.write(`PR #${args.prNumber}: no --protected issues supplied; skipping check.\n`);
+        return EXIT_OK;
+    }
+    const runGh = options.runGh ?? defaultRunGh;
+    const linked = fetchClosingIssuesReferences(args.prNumber, args.repo, runGh);
+    if (linked === null) {
+        return EXIT_EXTERNAL_ERROR;
+    }
+    const linkedSorted = [...new Set(linked)].sort((a, b) => a - b);
+    process.stderr.write(`PR #${args.prNumber}: closingIssuesReferences = ${JSON.stringify(linkedSorted)}\n`);
+    const protectedSet = new Set(protectedIssues);
+    const overlap = linked.filter((n) => protectedSet.has(n));
+    const overlapSorted = [...new Set(overlap)].sort((a, b) => a - b);
+    if (overlapSorted.length > 0) {
+        const offenders = overlapSorted.map((n) => `#${n}`).join(", ");
+        process.stderr.write(`FAIL: PR #${args.prNumber} has persistent linked-issue relationships ` +
+            `with protected issue(s): ${offenders}. The link is recorded in GitHub's ` +
+            `database from a prior PR body revision (or sidebar attachment) and ` +
+            `survives subsequent body edits. Manually unlink via the PR's ` +
+            `'Development' sidebar panel (web UI -> PR -> right-side Development ` +
+            `section -> X next to the linked issue) before merging. See #701.\n`);
+        return EXIT_PROTECTED_LINKED;
+    }
+    const protectedStr = protectedIssues.map((n) => `#${n}`).join(", ");
+    process.stderr.write(`OK: PR #${args.prNumber} has no persistent links to any protected issue ` +
+        `(${protectedStr}). Safe to squash-merge with respect to Layer 3 (#701).\n`);
+    return EXIT_OK;
+}
+export function cmdPrProtectedIssues(argv, options = {}) {
+    return run(argv, options);
+}
+//# sourceMappingURL=main.js.map

package/dist/pr-protected-issues/parse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Flatten comma-separated and repeated ``--protected`` flags into a sorted,
+ * deduplicated list. Raises on non-decimal tokens (mirrors Python ``isdecimal()``).
+ */
+export declare function parseProtected(values: readonly string[]): number[];
+//# sourceMappingURL=parse.d.ts.map

package/dist/pr-protected-issues/parse.js

@@ -0,0 +1,21 @@
+/**
+ * Flatten comma-separated and repeated ``--protected`` flags into a sorted,
+ * deduplicated list. Raises on non-decimal tokens (mirrors Python ``isdecimal()``).
+ */
+export function parseProtected(values) {
+    const out = new Set();
+    for (const chunk of values) {
+        for (const raw of chunk.split(",")) {
+            const tok = raw.trim().replace(/^#/, "");
+            if (tok.length === 0) {
+                continue;
+            }
+            if (!/^[0-9]+$/.test(tok)) {
+                throw new Error(`Invalid protected issue token: '${tok}'`);
+            }
+            out.add(Number(tok));
+        }
+    }
+    return [...out].sort((a, b) => a - b);
+}
+//# sourceMappingURL=parse.js.map

package/dist/pr-protected-issues/types.d.ts

@@ -0,0 +1,8 @@
+export interface RunGhResult {
+    readonly returncode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/** Injectable gh capture seam for tests and parity harnesses. */
+export type RunGhFn = (cmd: readonly string[]) => RunGhResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/pr-protected-issues/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/pr-wait-mergeable/cascade.d.ts

@@ -0,0 +1,12 @@
+import type { MergeFn, MonitorFn, ProtectedCheckFn, WaitMergeableResult } from "./types.js";
+export interface WaitMergeableOptions {
+    readonly protectedFn?: ProtectedCheckFn;
+    readonly monitorFn?: MonitorFn;
+    readonly mergeFn?: MergeFn;
+}
+/** Run protected-check -> wait -> merge cascade (#1369). */
+export declare function waitMergeableAndMerge(prNumber: number, repo: string, options: {
+    readonly capMinutes: number;
+    readonly protected: readonly number[];
+} & WaitMergeableOptions): WaitMergeableResult;
+//# sourceMappingURL=cascade.d.ts.map

package/dist/pr-wait-mergeable/cascade.js

@@ -0,0 +1,107 @@
+import { classifyMonitorOutcome, parseMonitorPayload } from "./classify.js";
+import { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
+import { makeResult } from "./result.js";
+import { runGhMerge, runMonitor, runProtectedCheck } from "./wrappers.js";
+/** Run protected-check -> wait -> merge cascade (#1369). */
+export function waitMergeableAndMerge(prNumber, repo, options) {
+    const protectedFn = options.protectedFn ?? runProtectedCheck;
+    const monitorFn = options.monitorFn ?? runMonitor;
+    const mergeFn = options.mergeFn ?? runGhMerge;
+    const protectedIssues = options.protected;
+    let protectedCheckPayload = {};
+    if (protectedIssues.length > 0) {
+        const [prcRc, prcStdout, prcStderr] = protectedFn(prNumber, repo, protectedIssues);
+        protectedCheckPayload = {
+            returncode: prcRc,
+            stdout: prcStdout,
+            stderr: prcStderr,
+            protected: [...protectedIssues],
+        };
+        if (prcRc === 1) {
+            return makeResult({
+                prNumber,
+                repo,
+                outcome: "protected-linked",
+                exitCode: EXIT_TIMEOUT_OR_ESCALATION,
+                protectedCheck: protectedCheckPayload,
+                error: "PR has a persistent closingIssuesReferences link to a " +
+                    "protected issue (#701). Unlink via the PR's Development " +
+                    "sidebar before re-running.",
+            });
+        }
+        if (prcRc !== 0) {
+            return makeResult({
+                prNumber,
+                repo,
+                outcome: "config-error",
+                exitCode: EXIT_CONFIG_ERROR,
+                protectedCheck: protectedCheckPayload,
+                error: `protected-issue check exited ${prcRc} (config error). ` + `stderr: ${prcStderr.trim()}`,
+            });
+        }
+    }
+    const [monRc, monStdout, monStderr] = monitorFn(prNumber, repo, options.capMinutes);
+    const monitorPayload = parseMonitorPayload(monStdout);
+    const [outcome, monitorExit] = classifyMonitorOutcome(monRc, monitorPayload);
+    if (outcome !== "clean") {
+        const errorPayload = monitorExit === EXIT_MERGED
+            ? null
+            : monStderr.trim().length > 0
+                ? `monitor exited ${monRc} (outcome=${outcome}). stderr tail: ${monStderr.trim().slice(-200)}`
+                : `monitor exited ${monRc} (outcome=${outcome})`;
+        return makeResult({
+            prNumber,
+            repo,
+            outcome,
+            exitCode: monitorExit,
+            monitorResult: monitorPayload,
+            protectedCheck: protectedCheckPayload,
+            error: errorPayload,
+        });
+    }
+    const [mergeRc, mergeStdout, mergeStderr] = mergeFn(prNumber, repo);
+    if (mergeRc === 0) {
+        return makeResult({
+            prNumber,
+            repo,
+            outcome: "merged",
+            exitCode: EXIT_MERGED,
+            monitorResult: monitorPayload,
+            protectedCheck: protectedCheckPayload,
+            mergeStdout,
+            mergeStderr,
+            error: null,
+        });
+    }
+    if (mergeRc === -1) {
+        const tail = mergeStderr.trim();
+        return makeResult({
+            prNumber,
+            repo,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            monitorResult: monitorPayload,
+            protectedCheck: protectedCheckPayload,
+            mergeStdout,
+            mergeStderr,
+            error: tail.length > 0
+                ? `gh pr merge wrapper failed at OS layer (rc=-1). stderr: ${tail.slice(-200)}`
+                : "gh pr merge wrapper failed at OS layer (rc=-1).",
+        });
+    }
+    const mergeTail = mergeStderr.trim();
+    return makeResult({
+        prNumber,
+        repo,
+        outcome: "merge-failed",
+        exitCode: EXIT_TIMEOUT_OR_ESCALATION,
+        monitorResult: monitorPayload,
+        protectedCheck: protectedCheckPayload,
+        mergeStdout,
+        mergeStderr,
+        error: mergeTail.length > 0
+            ? `gh pr merge exited ${mergeRc}. stderr: ${mergeTail.slice(-200)}`
+            : `gh pr merge exited ${mergeRc}`,
+    });
+}
+//# sourceMappingURL=cascade.js.map

package/dist/pr-wait-mergeable/classify.d.ts

@@ -0,0 +1,5 @@
+/** Map monitor_pr exit code onto helper outcome + exit code. */
+export declare function classifyMonitorOutcome(monitorReturncode: number, monitorPayload: Record<string, unknown>): readonly [string, number];
+/** Parse the monitor's --json envelope. Returns {} on failure. */
+export declare function parseMonitorPayload(stdout: string): Record<string, unknown>;
+//# sourceMappingURL=classify.d.ts.map

package/dist/pr-wait-mergeable/classify.js

@@ -0,0 +1,47 @@
+import { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
+/** Map monitor_pr exit code onto helper outcome + exit code. */
+export function classifyMonitorOutcome(monitorReturncode, monitorPayload) {
+    if (monitorReturncode === 0) {
+        return ["clean", EXIT_MERGED];
+    }
+    if (monitorReturncode === 1) {
+        return ["cap-reached", EXIT_TIMEOUT_OR_ESCALATION];
+    }
+    if (monitorReturncode === 2) {
+        return ["config-error", EXIT_CONFIG_ERROR];
+    }
+    if (monitorReturncode === 3) {
+        const readiness = typeof monitorPayload.readiness === "object" &&
+            monitorPayload.readiness !== null &&
+            !Array.isArray(monitorPayload.readiness)
+            ? monitorPayload.readiness
+            : {};
+        const partial = typeof readiness.partial_data === "object" &&
+            readiness.partial_data !== null &&
+            !Array.isArray(readiness.partial_data)
+            ? readiness.partial_data
+            : {};
+        if (partial.merged === true) {
+            return ["merged-by-sibling", EXIT_MERGED];
+        }
+        return ["pr-closed", EXIT_TIMEOUT_OR_ESCALATION];
+    }
+    return ["config-error", EXIT_CONFIG_ERROR];
+}
+/** Parse the monitor's --json envelope. Returns {} on failure. */
+export function parseMonitorPayload(stdout) {
+    if (stdout.trim().length === 0) {
+        return {};
+    }
+    try {
+        const payload = JSON.parse(stdout);
+        if (typeof payload === "object" && payload !== null && !Array.isArray(payload)) {
+            return payload;
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+//# sourceMappingURL=classify.js.map

package/dist/pr-wait-mergeable/constants.d.ts

@@ -0,0 +1,5 @@
+/** Three-state exit codes — mirrors scripts/pr_wait_mergeable.py. */
+export declare const EXIT_MERGED = 0;
+export declare const EXIT_TIMEOUT_OR_ESCALATION = 1;
+export declare const EXIT_CONFIG_ERROR = 2;
+//# sourceMappingURL=constants.d.ts.map

package/dist/pr-wait-mergeable/constants.js

@@ -0,0 +1,5 @@
+/** Three-state exit codes — mirrors scripts/pr_wait_mergeable.py. */
+export const EXIT_MERGED = 0;
+export const EXIT_TIMEOUT_OR_ESCALATION = 1;
+export const EXIT_CONFIG_ERROR = 2;
+//# sourceMappingURL=constants.js.map

package/dist/pr-wait-mergeable/index.d.ts

@@ -0,0 +1,8 @@
+export { waitMergeableAndMerge } from "./cascade.js";
+export { classifyMonitorOutcome, parseMonitorPayload } from "./classify.js";
+export { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION, } from "./constants.js";
+export { cmdPrWaitMergeable, parseWaitMergeableArgs, runWaitMergeable } from "./main.js";
+export { makeResult, toResultDict } from "./result.js";
+export type { MergeFn, MonitorFn, ProtectedCheckFn, SubprocessTriple, WaitMergeableResult, } from "./types.js";
+export { captureExec, runGhMerge, runMonitor, runProtectedCheck, } from "./wrappers.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pr-wait-mergeable/index.js

@@ -0,0 +1,7 @@
+export { waitMergeableAndMerge } from "./cascade.js";
+export { classifyMonitorOutcome, parseMonitorPayload } from "./classify.js";
+export { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION, } from "./constants.js";
+export { cmdPrWaitMergeable, parseWaitMergeableArgs, runWaitMergeable } from "./main.js";
+export { makeResult, toResultDict } from "./result.js";
+export { captureExec, runGhMerge, runMonitor, runProtectedCheck, } from "./wrappers.js";
+//# sourceMappingURL=index.js.map

package/dist/pr-wait-mergeable/main.d.ts

@@ -0,0 +1,18 @@
+import { waitMergeableAndMerge } from "./cascade.js";
+export interface ParsedWaitMergeableArgs {
+    readonly prNumber: number | null;
+    readonly repo: string | null;
+    readonly capMinutes: number;
+    readonly protectedValues: readonly string[];
+    readonly emitJson: boolean;
+    readonly error?: string;
+}
+export declare function parseWaitMergeableArgs(argv: readonly string[]): ParsedWaitMergeableArgs;
+export interface RunWaitMergeableOptions {
+    readonly protectedFn?: Parameters<typeof waitMergeableAndMerge>[2]["protectedFn"];
+    readonly monitorFn?: Parameters<typeof waitMergeableAndMerge>[2]["monitorFn"];
+    readonly mergeFn?: Parameters<typeof waitMergeableAndMerge>[2]["mergeFn"];
+}
+export declare function runWaitMergeable(argv: readonly string[], options?: RunWaitMergeableOptions): number;
+export declare function cmdPrWaitMergeable(argv: readonly string[], options?: RunWaitMergeableOptions): number;
+//# sourceMappingURL=main.d.ts.map