willfire 0.1.14 → 0.1.16

package/dist/execute.js

@@ -40,19 +40,22 @@ import { UNKNOWN } from "./expr/val.js";
 /** `owner/repo:job1,job2` as the CLI spells a grant. */
 export function parseGrant(spec) {
     const colon = spec.indexOf(":");
-    if (colon <= 0)
+    if (colon <= 0) {
         return null;
+    }
     const repo = spec.slice(0, colon);
     const parts = repo.split("/");
-    if (parts.length !== 2 || parts.some((p) => p === ""))
+    if (parts.length !== 2 || parts.some((p) => p === "")) {
         return null;
+    }
     const jobs = spec
         .slice(colon + 1)
         .split(",")
         .map((s) => s.trim())
         .filter((s) => s !== "");
-    if (jobs.length === 0)
+    if (jobs.length === 0) {
         return null;
+    }
     return { repo, jobs };
 }
 const err = (reason) => ({ ok: false, reason });
@@ -77,15 +80,18 @@ function renderTemplate(text, scope) {
 }
 /** An `env:` block rendered to concrete strings, every key or nothing. */
 function renderEnvLayer(layer, scope) {
-    if (layer == null)
+    if (layer == null) {
         return { ok: true, v: {} };
-    if (typeof layer !== "object" || Array.isArray(layer))
+    }
+    if (typeof layer !== "object" || Array.isArray(layer)) {
         return err("env block is not a map");
+    }
     const out = {};
     for (const [k, raw] of Object.entries(layer)) {
         const rendered = renderTemplate(String(raw ?? ""), scope);
-        if (rendered == null)
+        if (rendered == null) {
             return err(`cannot resolve env '${k}'`);
+        }
         out[k] = rendered;
     }
     return { ok: true, v: out };
@@ -103,15 +109,17 @@ export function parseGithubOutput(text) {
     while (i < lines.length) {
         const line = lines[i];
         i++;
-        if (line === "")
+        if (line === "") {
             continue;
+        }
         const heredoc = /^([^=<]+)<<(.+)$/.exec(line);
         if (heredoc != null) {
             const [, name, delim] = heredoc;
             const buf = [];
             for (;;) {
-                if (i >= lines.length)
+                if (i >= lines.length) {
                     return null; // unterminated heredoc
+                }
                 if (lines[i] === delim) {
                     i++;
                     break;
@@ -123,8 +131,9 @@ export function parseGithubOutput(text) {
             continue;
         }
         const eq = line.indexOf("=");
-        if (eq <= 0)
+        if (eq <= 0) {
             return null;
+        }
         out[line.slice(0, eq)] = line.slice(eq + 1);
     }
     return out;
@@ -136,17 +145,21 @@ export function parseGithubOutput(text) {
  * lives at the repo root. Expressions and `docker://` images return null.
  */
 function parseActionUses(uses) {
-    if (uses.includes("${{") || uses.startsWith("docker://"))
+    if (uses.includes("${{") || uses.startsWith("docker://")) {
         return null;
+    }
     const at = uses.lastIndexOf("@");
-    if (at <= 0)
+    if (at <= 0) {
         return null;
+    }
     const ref = uses.slice(at + 1);
-    if (ref === "")
+    if (ref === "") {
         return null;
+    }
     const [owner, repo, ...rest] = uses.slice(0, at).split("/");
-    if (!owner || !repo)
+    if (!owner || !repo) {
         return null;
+    }
     return { path: rest.join("/"), source: { owner, repo, ref } };
 }
 /** Read `action.yml` (or `.yaml`) from a directory, or null if neither exists. */
@@ -171,8 +184,9 @@ async function readActionManifest(dir) {
  */
 function bindActionInputs(action, withBlock, scope) {
     const bind = (raw) => {
-        if (raw == null)
+        if (raw == null) {
             return { kind: "value", v: "" };
+        }
         if (typeof raw === "boolean" || typeof raw === "number") {
             return { kind: "value", v: String(raw) };
         }
@@ -213,13 +227,15 @@ async function runSteps(steps, scope, ctx) {
         const stepScope = { ...scope, steps: stepsCtx };
         if (step.if != null) {
             const verdict = evaluate(String(step.if), stepScope);
-            if (verdict == null)
+            if (verdict == null) {
                 return err(`cannot decide if: for ${label}`);
+            }
             if (!verdict) {
                 // A skipped step still occupies its id, with no outputs — that is the
                 // empty string every later read gets, and what `||` coalesces past.
-                if (typeof step.id === "string")
+                if (typeof step.id === "string") {
                     stepsCtx[step.id] = { outputs: {} };
+                }
                 continue;
             }
         }
@@ -233,10 +249,12 @@ async function runSteps(steps, scope, ctx) {
         else {
             return err(`${label} has neither uses nor run`);
         }
-        if (!res.ok)
+        if (!res.ok) {
             return res;
-        if (typeof step.id === "string")
+        }
+        if (typeof step.id === "string") {
             stepsCtx[step.id] = { outputs: res.v };
+        }
     }
     return { ok: true, v: stepsCtx };
 }
@@ -263,12 +281,14 @@ async function runUses(step, label, scope, ctx) {
     }
     else {
         const target = parseActionUses(uses);
-        if (target == null)
+        if (target == null) {
             return err(`${label}: unresolvable uses: ${uses}`);
+        }
         const { ref } = target.source;
         const sha = SHA_RE.test(ref) ? ref : await ctx.deps.resolveRef(target.source);
-        if (sha == null)
+        if (sha == null) {
             return err(`${label}: cannot resolve ref for ${uses}`);
+        }
         const source = { ...target.source, sha };
         const root = await ctx.deps.provideTree(source);
         if (root == null) {
@@ -277,8 +297,9 @@ async function runUses(step, label, scope, ctx) {
         actionDir = target.path === "" ? root : join(root, target.path);
     }
     const manifest = await readActionManifest(actionDir);
-    if (manifest == null)
+    if (manifest == null) {
         return err(`${label}: no action.yml under ${uses}`);
+    }
     let action;
     try {
         action = parseYaml(manifest);
@@ -302,19 +323,22 @@ async function runUses(step, label, scope, ctx) {
         actionPath: actionDir,
         depth: ctx.depth + 1,
     });
-    if (!walked.ok)
+    if (!walked.ok) {
         return err(`${label} (${uses}): ${walked.reason}`);
+    }
     // The action's declared outputs are its whole surface: each `value:` is
     // evaluated against the child's own steps, and every one must land.
     const outScope = { ...childScope, steps: walked.v };
     const outputs = {};
     for (const [name, decl] of Object.entries(action.outputs ?? {})) {
         const raw = decl?.["value"];
-        if (raw == null)
+        if (raw == null) {
             return err(`${label}: output '${name}' of ${uses} has no value`);
+        }
         const rendered = renderTemplate(String(raw), outScope);
-        if (rendered == null)
+        if (rendered == null) {
             return err(`${label}: cannot resolve output '${name}' of ${uses}`);
+        }
         outputs[name] = rendered;
     }
     return { ok: true, v: outputs };
@@ -326,8 +350,9 @@ async function runRun(step, label, scope, ctx) {
         return err(`${label}: shell '${shell}' is not modelled`);
     }
     const script = renderTemplate(String(step.run), scope);
-    if (script == null)
+    if (script == null) {
         return err(`${label}: cannot resolve \${{ }} in run`);
+    }
     const env = {
         // The two the runner always provides and scripts assume. Everything else
         // a step sees, it declared.
@@ -335,19 +360,22 @@ async function runRun(step, label, scope, ctx) {
         HOME: process.env.HOME ?? "",
         GITHUB_WORKSPACE: ctx.tree,
     };
-    if (ctx.actionPath != null)
+    if (ctx.actionPath != null) {
         env.GITHUB_ACTION_PATH = ctx.actionPath;
+    }
     for (const layer of [...ctx.envLayers, step.env]) {
         const rendered = renderEnvLayer(layer, scope);
-        if (!rendered.ok)
+        if (!rendered.ok) {
             return err(`${label}: ${rendered.reason}`);
+        }
         Object.assign(env, rendered.v);
     }
     let cwd = ctx.tree;
     if (step["working-directory"] != null) {
         const wd = renderTemplate(String(step["working-directory"]), scope);
-        if (wd == null)
+        if (wd == null) {
             return err(`${label}: cannot resolve working-directory`);
+        }
         cwd = resolve(ctx.tree, wd);
     }
     const outDir = await mkdtemp(join(tmpdir(), "willfire-out-"));
@@ -362,8 +390,9 @@ async function runRun(step, label, scope, ctx) {
         return err(`${label}: exited ${r.code}${tail === "" ? "" : ` (${tail})`}`);
     }
     const outputs = parseGithubOutput(await readFile(outFile, "utf8"));
-    if (outputs == null)
+    if (outputs == null) {
         return err(`${label}: malformed GITHUB_OUTPUT`);
+    }
     return { ok: true, v: outputs };
 }
 // ------------------------------------------------------------------ executor
@@ -382,13 +411,15 @@ export function makeExecutor(opts) {
             // The shapes execution does not model, refused by name rather than run
             // wrong: a matrix'd job is several executions, and a container changes
             // what every step means.
-            if (job.strategy != null)
+            if (job.strategy != null) {
                 return fail(`job '${jobId}' has a strategy; not modelled`);
+            }
             if (job.container != null || job.services != null) {
                 return fail(`job '${jobId}' uses a container or services; not modelled`);
             }
-            if (!Array.isArray(job.steps))
+            if (!Array.isArray(job.steps)) {
                 return fail(`job '${jobId}' has no steps`);
+            }
             const tree = await deps.provideTree(workspace);
             if (tree == null) {
                 return fail(`cannot materialize workspace ${workspace.owner}/${workspace.repo}@${workspace.sha}`);
@@ -400,8 +431,9 @@ export function makeExecutor(opts) {
                 deps,
                 depth: 0,
             });
-            if (!walked.ok)
+            if (!walked.ok) {
                 return fail(walked.reason);
+            }
             // The job's `outputs:` map is the whole point of having run anything.
             // Every declared entry must land; a hole here would hand consumers a
             // partial map, which the Scope contract calls a lie.
@@ -409,8 +441,9 @@ export function makeExecutor(opts) {
             const outputs = {};
             for (const [name, raw] of Object.entries(job.outputs ?? {})) {
                 const rendered = renderTemplate(String(raw), outScope);
-                if (rendered == null)
+                if (rendered == null) {
                     return fail(`cannot resolve job output '${name}'`);
+                }
                 outputs[name] = rendered;
             }
             return { ok: true, outputs };
@@ -436,8 +469,9 @@ export const runShell = (spec) => new Promise((resolvePromise) => {
     child.stderr.on("data", (d) => {
         stderr += String(d);
         // Keep the tail; a failure reason wants the last line, not a transcript.
-        if (stderr.length > 4096)
+        if (stderr.length > 4096) {
             stderr = stderr.slice(-4096);
+        }
     });
     child.on("error", () => resolvePromise({ code: 127, stderr }));
     child.on("close", (code) => resolvePromise({ code: code ?? 1, stderr }));
@@ -454,8 +488,9 @@ export function makeTreeProvider(download, runCommand) {
     return (source) => {
         const key = `${source.owner}/${source.repo}@${source.sha}`;
         const hit = cache.get(key);
-        if (hit !== undefined)
+        if (hit !== undefined) {
             return hit;
+        }
         const p = materialize(source, download, runCommand);
         cache.set(key, p);
         return p;
@@ -463,8 +498,9 @@ export function makeTreeProvider(download, runCommand) {
 }
 async function materialize(source, download, runCommand) {
     const bytes = await download(source);
-    if (bytes == null)
+    if (bytes == null) {
         return null;
+    }
     const dir = await mkdtemp(join(tmpdir(), "willfire-tree-"));
     const archive = join(dir, "tree.tar.gz");
     await writeFile(archive, bytes);
@@ -480,13 +516,15 @@ async function materialize(source, download, runCommand) {
             WILLFIRE_DEST: dest,
         },
     });
-    if (r.code !== 0)
+    if (r.code !== 0) {
         return null;
+    }
     const entries = await readdir(dest);
     if (entries.length === 1) {
         const sub = join(dest, entries[0]);
-        if ((await stat(sub)).isDirectory())
+        if ((await stat(sub)).isDirectory()) {
             return sub;
+        }
     }
     return dest;
 }

package/dist/filters/matchFilters.js

@@ -5,8 +5,9 @@ export function matchFilters(value, patterns) {
     for (const pat of patterns) {
         const neg = pat.startsWith("!");
         const p = neg ? pat.slice(1) : pat;
-        if (patternToRegex(p).test(value))
+        if (patternToRegex(p).test(value)) {
             matched = !neg;
+        }
     }
     return matched;
 }

package/dist/jobs/evalIf.js

@@ -9,10 +9,12 @@ import { prScope } from "./prScope.js";
  * `needs.*`.
  */
 export function evalIf(cond, scope = {}) {
-    if (cond == null)
+    if (cond == null) {
         return "run";
+    }
     const verdict = evaluate(String(cond), prScope(scope));
-    if (verdict === null)
+    if (verdict === null) {
         return "unknown";
+    }
     return verdict ? "run" : "skipped";
 }

package/dist/jobs/expandJobs.js

@@ -16,22 +16,27 @@ import { prScope } from "./prScope.js";
  * existed; nothing regresses.
  */
 function inputLiteral(raw) {
-    if (raw == null)
+    if (raw == null) {
         return { kind: "value", v: "" };
-    if (typeof raw === "boolean" || typeof raw === "number")
+    }
+    if (typeof raw === "boolean" || typeof raw === "number") {
         return { kind: "value", v: raw };
-    if (typeof raw === "string")
+    }
+    if (typeof raw === "string") {
         return raw.includes("${{") ? UNKNOWN : { kind: "value", v: raw };
+    }
     return UNKNOWN;
 }
 /** The `on.workflow_call.inputs` block, tolerating the YAML 1.1 `on` -> true key. */
 function workflowCallInputs(wf) {
     const on = wf?.["on"] ?? wf?.["true"];
-    if (on == null || typeof on !== "object")
+    if (on == null || typeof on !== "object") {
         return {};
+    }
     const call = on["workflow_call"];
-    if (call == null || typeof call !== "object")
+    if (call == null || typeof call !== "object") {
         return {};
+    }
     const inputs = call["inputs"];
     return inputs != null && typeof inputs === "object" ? inputs : {};
 }
@@ -87,11 +92,13 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
     const execFailures = {};
     if (executor != null) {
         for (const [jobId, jobRaw] of Object.entries(jobs)) {
-            if (!executor.granted(source, jobId))
+            if (!executor.granted(source, jobId)) {
                 continue;
+            }
             const job = jobRaw ?? {};
-            if (evalIf(job.if, scoped) !== "run")
+            if (evalIf(job.if, scoped) !== "run") {
                 continue;
+            }
             const res = await executor.executeJob(jobId, job, wf, scoped);
             if (res.ok) {
                 scoped = { ...scoped, needs: { ...scoped.needs, [jobId]: { outputs: res.outputs } } };
@@ -110,8 +117,9 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
         let status = evalIf(job.if, scoped);
         let reason = job.if != null ? `if: ${JSON.stringify(job.if)}` : "";
         let needs = job.needs ?? [];
-        if (typeof needs === "string")
+        if (typeof needs === "string") {
             needs = [needs];
+        }
         const cond = String(job.if ?? "");
         if (status !== "skipped" && !cond.includes("always()")) {
             for (const n of needs) {

package/dist/matrix/expandMatrixDetailed.js

@@ -9,35 +9,43 @@ import { evaluateValue } from "../expr/evaluateValue.js";
  * the whole job `unknown` rather than a guess at how many checks it creates.
  */
 function axisValues(v, scope) {
-    if (Array.isArray(v))
+    if (Array.isArray(v)) {
         return v;
-    if (typeof v !== "string")
+    }
+    if (typeof v !== "string") {
         return null;
+    }
     const val = evaluateValue(v, scope);
-    if (val.kind !== "json" || !Array.isArray(val.v))
+    if (val.kind !== "json" || !Array.isArray(val.v)) {
         return null;
+    }
     return val.v;
 }
 export function expandMatrixDetailed(strategy, scope = {}) {
     const matrix = strategy?.matrix;
-    if (matrix == null)
+    if (matrix == null) {
         return [null];
+    }
     // `matrix: ${{ ... }}` — the whole matrix as one expression, rather than the
     // per-axis form below. It yields include-style entries, not axes, so it is a
     // separate expansion and is not modelled.
-    if (typeof matrix === "string")
+    if (typeof matrix === "string") {
         return null;
+    }
     const include = matrix.include ?? [];
     const exclude = matrix.exclude ?? [];
-    if (typeof include === "string" || typeof exclude === "string")
+    if (typeof include === "string" || typeof exclude === "string") {
         return null;
+    }
     const axes = {};
     for (const [k, v] of Object.entries(matrix)) {
-        if (k === "include" || k === "exclude")
+        if (k === "include" || k === "exclude") {
             continue;
+        }
         const vals = axisValues(v, scope);
-        if (vals == null)
+        if (vals == null) {
             return null;
+        }
         axes[k] = vals;
     }
     const axisKeys = Object.keys(axes);
@@ -45,8 +53,9 @@ export function expandMatrixDetailed(strategy, scope = {}) {
     for (const [k, vals] of Object.entries(axes)) {
         combos = combos.flatMap((c) => vals.map((v) => ({ values: { ...c.values, [k]: v }, displayKeys: axisKeys })));
     }
-    if (axisKeys.length === 0)
+    if (axisKeys.length === 0) {
         combos = [];
+    }
     combos = combos.filter((c) => !exclude.some((ex) => Object.entries(ex).every(([k, v]) => c.values[k] === v)));
     const extra = [];
     for (const inc of include) {
@@ -57,8 +66,9 @@ export function expandMatrixDetailed(strategy, scope = {}) {
             // matches every combination, per the docs ("added to each of the matrix
             // combinations if none of the key:value pairs overwrite any of the
             // original matrix values").
-            for (const c of targets)
+            for (const c of targets) {
                 Object.assign(c.values, inc);
+            }
         }
         else {
             // No combination to attach to: the include entry becomes a combination

package/dist/matrix/formatMatrixValue.js

@@ -6,11 +6,14 @@
  * `m-object (linux, x64)`.
  */
 export function formatMatrixValue(v) {
-    if (v == null)
+    if (v == null) {
         return "";
-    if (Array.isArray(v))
+    }
+    if (Array.isArray(v)) {
         return v.map(formatMatrixValue).join(", ");
-    if (typeof v === "object")
+    }
+    if (typeof v === "object") {
         return Object.values(v).map(formatMatrixValue).join(", ");
+    }
     return String(v);
 }

package/dist/matrix/matrixSuffix.js

@@ -2,7 +2,8 @@ import { formatMatrixValue } from "./formatMatrixValue.js";
 /** The ` (v1, v2)` suffix GitHub appends for a matrix combination. */
 export function matrixSuffix(combo) {
     const keys = combo.displayKeys.filter((k) => k in combo.values);
-    if (keys.length === 0)
+    if (keys.length === 0) {
         return "";
+    }
     return ` (${keys.map((k) => formatMatrixValue(combo.values[k])).join(", ")})`;
 }

package/dist/predict/finalizePrediction.js

@@ -7,8 +7,9 @@ export function finalizePrediction(entries, skip, sources) {
     const final = entries.map(finalize);
     const names = new Set();
     for (const e of final) {
-        if (e.status === "run" && e.checkName != null)
+        if (e.status === "run" && e.checkName !== null) {
             names.add(e.checkName);
+        }
     }
     return {
         entries: final,

package/dist/predict/makeOctokit.js

@@ -1,7 +1,8 @@
 import { Octokit } from "@octokit/rest";
 export function makeOctokit() {
     const token = process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;
-    if (!token)
+    if (!token) {
         throw new Error("GH_TOKEN or GITHUB_TOKEN must be set");
+    }
     return new Octokit({ auth: token });
 }

package/dist/predict/predict.js

@@ -30,7 +30,7 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
         // is a guess kept only so existing callers keep working.
         action: opts.action ?? (pr.commits > 1 ? "synchronize" : "opened"),
         baseRef: pr.base.ref,
-        ...(stackTarget != null ? { stackTarget } : {}),
+        ...(stackTarget !== null ? { stackTarget } : {}),
         files: files.map((f) => f.filename),
     };
     const headSha = pr.head.sha;
@@ -58,8 +58,9 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
     const resolveRef = async (src) => {
         const key = sourceKey(src);
         const hit = refCache.get(key);
-        if (hit !== undefined)
+        if (hit !== undefined) {
             return hit;
+        }
         let sha;
         try {
             const { data } = await octokit.rest.repos.getCommit({
@@ -75,8 +76,9 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
             sha = null;
         }
         refCache.set(key, sha);
-        if (sha != null)
+        if (sha !== null) {
             sources.set(key, { ...src, sha });
+        }
         return sha;
     };
     // One callee is commonly reached from several callers — a fleet repo calls
@@ -89,8 +91,9 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
         // that moves mid-prediction cannot hand back two different files.
         const key = `${src.owner}/${src.repo}/${path}@${src.sha}`;
         const hit = cache.get(key);
-        if (hit !== undefined)
+        if (hit !== undefined) {
             return hit;
+        }
         let content;
         try {
             const { data } = await octokit.rest.repos.getContent({
@@ -115,7 +118,7 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
     // from the tarball endpoint at the resolved commit, and every subprocess —
     // `tar` included — goes through the one `runShell` seam.
     let executor;
-    if (opts.execute != null && opts.execute.length > 0) {
+    if (opts.execute !== undefined && opts.execute.length > 0) {
         const download = async (src) => {
             try {
                 const { data } = await octokit.rest.repos.downloadTarballArchive({
@@ -152,32 +155,20 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
     const prFacts = {
         github: { repository: `${headSource.owner}/${headSource.repo}` },
     };
-    const entries = [];
-    for (const w of workflows) {
-        const path = w.path;
-        if (!path.startsWith(".github/workflows/"))
-            continue;
-        if (w.state !== "active") {
-            entries.push({
-                workflow: path,
-                job: "*",
-                status: "no-dispatch",
-                reason: `workflow state: ${w.state}`,
-            });
-            continue;
+    const workflowEntries = async (path, state) => {
+        if (state !== "active") {
+            return [
+                { workflow: path, job: "*", status: "no-dispatch", reason: `workflow state: ${state}` },
+            ];
         }
         const content = await fetchWorkflow(path, headSource);
-        if (content == null) {
+        if (content === null) {
             // The Actions API keeps listing a workflow as `active` after its file is
             // deleted. There is no file at head, so there is nothing to dispatch —
             // the same verdict as the disabled case above, reached a different way.
-            entries.push({
-                workflow: path,
-                job: "*",
-                status: "no-dispatch",
-                reason: "no workflow file at head",
-            });
-            continue;
+            return [
+                { workflow: path, job: "*", status: "no-dispatch", reason: "no workflow file at head" },
+            ];
         }
         let wf;
         try {
@@ -187,27 +178,25 @@ export async function predict(octokit, repo, prNumber, opts = {}) {
             // GitHub creates a run for an unparseable workflow file and concludes it
             // `startup_failure`. The run exists but has no jobs, so this is a
             // workflow-level "it dispatches" with nothing to expand.
-            entries.push({
-                workflow: path,
-                job: "*",
-                status: "run",
-                reason: `YAML parse error: ${e}`,
-            });
-            continue;
+            return [{ workflow: path, job: "*", status: "run", reason: `YAML parse error: ${e}` }];
         }
         const [dispatches, reason] = workflowDispatches(wf, ctx);
         if (!dispatches) {
-            entries.push({ workflow: path, job: "*", status: "no-dispatch", reason });
-            continue;
+            return [{ workflow: path, job: "*", status: "no-dispatch", reason }];
         }
-        for (const j of await expandJobs(wf, ctx, reader, headSource, 0, "", true, prFacts, executor)) {
-            entries.push({
-                workflow: path,
-                job: jobName(j.job),
-                checkName: j.checkName,
-                status: j.status,
-                reason: j.reason || reason,
-            });
+        const jobs = await expandJobs(wf, ctx, reader, headSource, 0, "", true, prFacts, executor);
+        return jobs.map((j) => ({
+            workflow: path,
+            job: jobName(j.job),
+            checkName: j.checkName,
+            status: j.status,
+            reason: j.reason || reason,
+        }));
+    };
+    const entries = [];
+    for (const w of workflows) {
+        if (w.path.startsWith(".github/workflows/")) {
+            entries.push(...(await workflowEntries(w.path, w.state)));
         }
     }
     return finalizePrediction(entries, null, sources);

package/dist/predict/stackTargetRef.js

@@ -17,24 +17,27 @@ export async function stackTargetRef(octokit, owner, repo, pr) {
     try {
         for (let hop = 0; hop < MAX_STACK_DEPTH; hop++) {
             const mergeSha = cur.merge_commit_sha;
-            if (mergeSha == null)
+            if (mergeSha === null) {
                 break;
+            }
             const { data: preview } = await octokit.rest.repos.getCommit({
                 owner,
                 repo,
                 ref: mergeSha,
             });
             const previewParent = preview.parents[0]?.sha;
-            if (previewParent == null)
+            if (previewParent === undefined) {
                 break;
+            }
             const { data: baseTip } = await octokit.rest.repos.getCommit({
                 owner,
                 repo,
                 ref: cur.base.ref,
             });
             // Built on the base branch tip: normal mode, the walk is done.
-            if (previewParent === baseTip.sha)
+            if (previewParent === baseTip.sha) {
                 break;
+            }
             // Otherwise only an exact match against an open PR whose head is the
             // base branch proves stacked mode; a stale preview matches nothing.
             const { data: candidates } = await octokit.rest.pulls.list({
@@ -45,8 +48,9 @@ export async function stackTargetRef(octokit, owner, repo, pr) {
                 per_page: 100,
             });
             const parent = candidates.find((p) => p.merge_commit_sha === previewParent);
-            if (parent == null)
+            if (parent === undefined) {
                 break;
+            }
             target = parent.base.ref;
             cur = parent;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "willfire",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Predict the set of CI check entries GitHub Actions will create for a pull request",
   "license": "MIT",
   "packageManager": "pnpm@10.33.0",