willfire 0.1.26 → 0.1.28

package/dist/execute.js

@@ -33,7 +33,7 @@ export 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 || layer === undefined) {
         return { ok: true, v: {} };
     }
     if (typeof layer !== "object" || Array.isArray(layer)) {
@@ -42,7 +42,7 @@ function renderEnvLayer(layer, scope) {
     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;
@@ -60,32 +60,25 @@ export function parseGithubOutput(text) {
     while (i < lines.length) {
         const line = lines[i];
         i++;
-        if (line === "") {
-            continue;
-        }
-        const heredoc = /^([^=<]+)<<(.+)$/.exec(line);
-        if (heredoc != null) {
-            const [, name, delim] = heredoc;
-            const buf = [];
-            for (;;) {
-                if (i >= lines.length) {
+        if (line !== "") {
+            const heredoc = /^([^=<]+)<<(.+)$/.exec(line);
+            if (heredoc !== null) {
+                const [, name, delim] = heredoc;
+                const end = lines.indexOf(delim, i);
+                if (end === -1) {
                     return null; // unterminated heredoc
                 }
-                if (lines[i] === delim) {
-                    i++;
-                    break;
+                out[name] = lines.slice(i, end).join("\n");
+                i = end + 1;
+            }
+            else {
+                const eq = line.indexOf("=");
+                if (eq <= 0) {
+                    return null;
                 }
-                buf.push(lines[i]);
-                i++;
+                out[line.slice(0, eq)] = line.slice(eq + 1);
             }
-            out[name] = buf.join("\n");
-            continue;
-        }
-        const eq = line.indexOf("=");
-        if (eq <= 0) {
-            return null;
         }
-        out[line.slice(0, eq)] = line.slice(eq + 1);
     }
     return out;
 }
@@ -130,23 +123,22 @@ async function readActionManifest(dir) {
  */
 function bindActionInputs(action, withBlock, scope) {
     const bind = (raw) => {
-        if (raw == null) {
+        if (raw === null || raw === undefined) {
             return { kind: "value", v: "" };
         }
         if (typeof raw === "boolean" || typeof raw === "number") {
             return { kind: "value", v: String(raw) };
         }
         const rendered = renderTemplate(String(raw), scope);
-        return rendered == null ? UNKNOWN : { kind: "value", v: rendered };
+        return rendered === null ? UNKNOWN : { kind: "value", v: rendered };
     };
     const out = {};
     for (const [name, decl] of Object.entries(action?.inputs ?? {})) {
-        out[name] =
-            decl != null && typeof decl === "object" && "default" in decl
-                ? bind(decl["default"])
-                : { kind: "value", v: "" };
+        // An input declared without a `default:` binds the same empty string a
+        // missing declaration does, so the two cases share one path.
+        out[name] = bind(decl?.["default"]);
     }
-    if (withBlock != null && typeof withBlock === "object") {
+    if (withBlock !== null && typeof withBlock === "object") {
         for (const [name, raw] of Object.entries(withBlock)) {
             out[name] = bind(raw);
         }
@@ -164,34 +156,37 @@ async function runSteps(steps, scope, ctx) {
         const step = steps[i] ?? {};
         const label = `step '${step.id ?? step.name ?? `#${i + 1}`}'`;
         const stepScope = { ...scope, steps: stepsCtx };
-        if (step.if != null) {
+        let skipped = false;
+        if (step.if !== undefined && 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.
-                if (typeof step.id === "string") {
-                    stepsCtx[step.id] = { outputs: {} };
-                }
-                continue;
-            }
+            skipped = !verdict;
         }
-        let res;
-        if (typeof step.uses === "string") {
-            res = await runUses(step, label, stepScope, ctx);
-        }
-        else if (step.run != null) {
-            res = await runRun(step, label, stepScope, ctx);
+        if (skipped) {
+            // A skipped step still occupies its id, with no outputs.
+            if (typeof step.id === "string") {
+                stepsCtx[step.id] = { outputs: {} };
+            }
         }
         else {
-            return err(`${label} has neither uses nor run`);
-        }
-        if (!res.ok) {
-            return res;
-        }
-        if (typeof step.id === "string") {
-            stepsCtx[step.id] = { outputs: res.v };
+            let res;
+            if (typeof step.uses === "string") {
+                res = await runUses(step, label, stepScope, ctx);
+            }
+            else if (step.run !== undefined && step.run !== null) {
+                res = await runRun(step, label, stepScope, ctx);
+            }
+            else {
+                return err(`${label} has neither uses nor run`);
+            }
+            if (!res.ok) {
+                return res;
+            }
+            if (typeof step.id === "string") {
+                stepsCtx[step.id] = { outputs: res.v };
+            }
         }
     }
     return { ok: true, v: stepsCtx };
@@ -247,24 +242,24 @@ 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) {
+        if (root === null) {
             return err(`${label}: cannot materialize ${source.owner}/${source.repo}@${sha}`);
         }
-        actionDir = target.path === "" ? root : join(root, target.path);
+        actionDir = join(root, target.path);
         actionRoot = root;
     }
     const manifest = await readActionManifest(actionDir);
-    if (manifest == null) {
+    if (manifest === null) {
         return err(`${label}: no action.yml under ${uses}`);
     }
     let action;
@@ -300,11 +295,11 @@ async function runUses(step, label, scope, ctx) {
     const outputs = {};
     for (const [name, decl] of Object.entries(action.outputs ?? {})) {
         const raw = decl?.["value"];
-        if (raw == null) {
+        if (raw === null || raw === undefined) {
             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;
@@ -384,12 +379,12 @@ async function runNodeAction(step, label, uses, action, actionDir, actionRoot, u
 }
 /** A `run:` step, executed under its declared shell with its declared env. */
 async function runRun(step, label, scope, ctx) {
-    const shell = step.shell == null ? "bash" : String(step.shell);
+    const shell = step.shell === null || step.shell === undefined ? "bash" : String(step.shell);
     if (shell !== "bash" && shell !== "sh") {
         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 = {
@@ -416,9 +411,9 @@ async function runRun(step, label, scope, ctx) {
         Object.assign(env, rendered.v);
     }
     let cwd = ctx.tree;
-    if (step["working-directory"] != null) {
+    if (step["working-directory"] !== undefined && 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);
@@ -445,7 +440,7 @@ 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 };
@@ -463,7 +458,10 @@ export function makeExecutor(opts) {
             if (job.strategy !== undefined && job.strategy !== null) {
                 return fail(`job '${jobId}' has a strategy; not modelled`);
             }
-            if (job.container != null || job.services != null) {
+            if (job.container !== null && job.container !== undefined) {
+                return fail(`job '${jobId}' uses a container or services; not modelled`);
+            }
+            if (job.services !== null && job.services !== undefined) {
                 return fail(`job '${jobId}' uses a container or services; not modelled`);
             }
             if (!Array.isArray(job.steps)) {
@@ -477,7 +475,7 @@ export function makeExecutor(opts) {
                 CHECKOUT_RE.test(s.uses) &&
                 Object.keys(s.with ?? {}).length > 0);
             const tree = await deps.provideTree(workspace, { history: needsHistory });
-            if (tree == null) {
+            if (tree === null) {
                 return fail(`cannot materialize workspace ${workspace.owner}/${workspace.repo}@${workspace.sha}`);
             }
             const jobScope = { ...scope, github: { ...github, ...scope.github } };
@@ -496,7 +494,7 @@ 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;
@@ -609,7 +607,7 @@ async function cloneAt(source, remote, token, 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-"));

package/dist/expr/cursor.js

@@ -13,7 +13,7 @@ export class Cursor {
     }
     eatOp(v) {
         const t = this.peek();
-        if (t != null && t.t === "op" && t.v === v) {
+        if (t !== undefined && t.t === "op" && t.v === v) {
             this.pos++;
             return true;
         }

package/dist/expr/evaluateValue.js

@@ -23,7 +23,7 @@ export function evaluateValue(expr, scope = {}) {
         return UNKNOWN;
     }
     const toks = tokenize(stripped);
-    if (toks == null || toks.length === 0) {
+    if (toks === null) {
         return UNKNOWN;
     }
     const cur = new Cursor(toks);

package/dist/expr/indexVal.js

@@ -24,7 +24,7 @@ export function indexVal(base, idx) {
         }
         el = base.v[idx.v];
     }
-    if (el == null) {
+    if (el === null || el === undefined) {
         return { kind: "value", v: "" };
     }
     if (typeof el === "object") {

package/dist/expr/lookup.js

@@ -22,7 +22,7 @@ export function lookup(scope, path) {
             return UNKNOWN;
         }
         const job = scope.needs?.[parts[0]];
-        if (job == null) {
+        if (job === undefined) {
             return UNKNOWN;
         }
         // A known job's missing output is the empty string, not a hole: the
@@ -40,7 +40,7 @@ export function lookup(scope, path) {
             return UNKNOWN;
         }
         const step = scope.steps?.[parts[0]];
-        if (step == null) {
+        if (step === undefined) {
             return UNKNOWN;
         }
         return { kind: "value", v: step.outputs[parts[2]] ?? "" };

package/dist/expr/parseAtom.js

@@ -4,7 +4,7 @@ import { parseOr } from "./parseOr.js";
 import { UNKNOWN } from "./val.js";
 export function parseAtom(cur, scope) {
     const t = cur.peek();
-    if (t == null) {
+    if (t === undefined) {
         return UNKNOWN;
     }
     if (t.t === "op" && t.v === "(") {

package/dist/expr/parseCall.js

@@ -12,13 +12,12 @@ export function parseCall(cur, scope, name) {
     if (!cur.eatOp(")")) {
         for (;;) {
             args.push(parseOr(cur, scope));
-            if (cur.eatOp(",")) {
-                continue;
+            if (!cur.eatOp(",")) {
+                if (cur.eatOp(")")) {
+                    break;
+                }
+                return UNKNOWN; // malformed argument list
             }
-            if (cur.eatOp(")")) {
-                break;
-            }
-            return UNKNOWN; // malformed argument list
         }
     }
     return applyFunction(name.toLowerCase(), args);

package/dist/expr/tokenize.js

@@ -11,13 +11,13 @@ export function tokenize(src) {
         const c = src[i];
         if (c === " " || c === "\t" || c === "\n" || c === "\r") {
             i++;
-            continue;
         }
-        // Single-quoted string. GitHub escapes an inner quote by doubling it.
-        if (c === "'") {
+        else if (c === "'") {
+            // Single-quoted string. GitHub escapes an inner quote by doubling it.
             let j = i + 1;
             let s = "";
-            for (;;) {
+            let closed = false;
+            while (!closed) {
                 if (j >= src.length) {
                     return null; // unterminated
                 }
@@ -25,50 +25,57 @@ export function tokenize(src) {
                     if (src[j + 1] === "'") {
                         s += "'";
                         j += 2;
-                        continue;
                     }
+                    else {
+                        j++;
+                        closed = true;
+                    }
+                }
+                else {
+                    s += src[j];
                     j++;
-                    break;
                 }
-                s += src[j];
-                j++;
             }
             out.push({ t: "str", v: s });
             i = j;
-            continue;
         }
-        const op = OPS.find((o) => src.startsWith(o, i));
-        if (op != null) {
-            out.push({ t: "op", v: op });
-            i += op.length;
-            continue;
-        }
-        const word = /^[A-Za-z_][A-Za-z0-9_.\-]*/.exec(src.slice(i));
-        if (word != null) {
-            const w = word[0];
-            i += w.length;
-            const lower = w.toLowerCase();
-            if (lower === "true") {
-                out.push({ t: "bool", v: true });
-            }
-            else if (lower === "false") {
-                out.push({ t: "bool", v: false });
-            }
-            else if (lower === "null") {
-                out.push({ t: "null" });
+        else {
+            const op = OPS.find((o) => src.startsWith(o, i));
+            if (op !== undefined) {
+                out.push({ t: "op", v: op });
+                i += op.length;
             }
             else {
-                out.push({ t: "path", v: w });
+                const word = /^[A-Za-z_][A-Za-z0-9_.\-]*/.exec(src.slice(i));
+                if (word !== null) {
+                    const w = word[0];
+                    i += w.length;
+                    const lower = w.toLowerCase();
+                    if (lower === "true") {
+                        out.push({ t: "bool", v: true });
+                    }
+                    else if (lower === "false") {
+                        out.push({ t: "bool", v: false });
+                    }
+                    else if (lower === "null") {
+                        out.push({ t: "null" });
+                    }
+                    else {
+                        out.push({ t: "path", v: w });
+                    }
+                }
+                else {
+                    const num = /^-?\d+(\.\d+)?/.exec(src.slice(i));
+                    if (num !== null) {
+                        out.push({ t: "num", v: Number(num[0]) });
+                        i += num[0].length;
+                    }
+                    else {
+                        return null; // a character we have no token for
+                    }
+                }
             }
-            continue;
-        }
-        const num = /^-?\d+(\.\d+)?/.exec(src.slice(i));
-        if (num != null) {
-            out.push({ t: "num", v: Number(num[0]) });
-            i += num[0].length;
-            continue;
         }
-        return null; // a character we have no token for
     }
     return out;
 }

package/dist/jobs/evalIf.js

@@ -9,7 +9,7 @@ import { prScope } from "./prScope.js";
  * `needs.*`.
  */
 export function evalIf(cond, scope = {}) {
-    if (cond == null) {
+    if (cond === null || cond === undefined) {
         return "run";
     }
     const verdict = evaluate(String(cond), prScope(scope));

package/dist/jobs/expandJobs.js

@@ -37,15 +37,15 @@ function inputValue(raw, scope) {
 /** 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 || call === undefined) {
         return {};
     }
     const inputs = call["inputs"];
-    return inputs != null && typeof inputs === "object" ? inputs : {};
+    return inputs !== null && typeof inputs === "object" ? inputs : {};
 }
 /**
  * What `inputs.*` resolves to inside a called workflow: what the caller passed,
@@ -60,12 +60,12 @@ function calleeInputs(withBlock, subWf, scope) {
     const out = {};
     for (const [name, decl] of Object.entries(workflowCallInputs(subWf))) {
         out[name] =
-            decl != null && typeof decl === "object" && "default" in decl
+            decl !== null && typeof decl === "object" && "default" in decl
                 ? // Defaults live in the callee, out of the caller's context's reach.
                     inputValue(decl["default"], {})
                 : UNKNOWN;
     }
-    if (withBlock != null && typeof withBlock === "object") {
+    if (withBlock !== null && typeof withBlock === "object") {
         for (const [name, raw] of Object.entries(withBlock)) {
             out[name] = inputValue(raw, scope);
         }
@@ -108,7 +108,7 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
     // verdict the main loop applies.
     let scoped = scope;
     const execFailures = {};
-    if (executor != null) {
+    if (executor !== undefined) {
         const needed = neededJobIds(jobs);
         for (const [jobId, jobRaw] of Object.entries(jobs)) {
             const job = jobRaw ?? {};
@@ -127,12 +127,12 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
     }
     const execNote = (needs) => {
         const failed = needs.find((n) => n in execFailures);
-        return failed == null ? "" : `; executing '${failed}' failed: ${execFailures[failed]}`;
+        return failed === undefined ? "" : `; executing '${failed}' failed: ${execFailures[failed]}`;
     };
     for (const [jobId, jobRaw] of Object.entries(jobs)) {
         const job = jobRaw ?? {};
         let status = evalIf(job.if, scoped);
-        let reason = job.if != null ? `if: ${JSON.stringify(job.if)}` : "";
+        let reason = job.if !== undefined && job.if !== null ? `if: ${JSON.stringify(job.if)}` : "";
         let needs = job.needs ?? [];
         if (typeof needs === "string") {
             needs = [needs];
@@ -162,113 +162,122 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
                 status,
                 reason,
             });
-            continue;
         }
-        const combos = expandMatrixDetailed(job.strategy, prScope(scoped));
-        if ("uses" in job) {
+        else if ("uses" in job) {
             // Reusable workflow call. The calling job produces no check of its own;
             // each called job becomes `<calling job name> / <called job name>`, and
             // a matrix on the *caller* multiplies the whole callee set. A cross-repo
             // call names its checks exactly the same way a local one does — probe
             // PR #9, `call-remote-tag / r-inner` alongside `call-plain / inner`.
+            const combos = expandMatrixDetailed(job.strategy, prScope(scoped));
             const uses = job.uses;
-            if (combos == null) {
+            if (combos === null) {
                 entries.push({
                     job: prefix + jobId,
                     checkName: null,
                     status: "unknown",
                     reason: "dynamic matrix on reusable workflow call" + execNote(needs),
                 });
-                continue;
-            }
-            // Resolve the called workflow once, not once per matrix combination.
-            let subWf = null;
-            let failure = null;
-            // Where the callee's own `./` calls will resolve. A remote `uses:` moves
-            // this to the callee's repo and pinned ref; a local one leaves it alone.
-            let subSource = source;
-            // What `inputs.*` means on the other side of the call.
-            let subScope = {};
-            const target = parseUses(uses);
-            if (depth + 1 > MAX_REUSABLE_DEPTH) {
-                failure = `reusable workflow nested deeper than ${MAX_REUSABLE_DEPTH} levels`;
-            }
-            else if (target == null) {
-                failure = `unresolvable reusable reference: ${uses}`;
             }
             else {
-                // A local `./` call stays on the caller's source, which is already
-                // pinned to a commit. A cross-repo one arrives as whatever the `uses:`
-                // string spelled — `@v0` — and has to be resolved before anything is
-                // read from it, so the file that gets read and the commit the
-                // prediction names are the same one.
-                let resolved = source;
-                if (target.source != null) {
-                    const { ref } = target.source;
-                    const sha = isSha(ref) ? ref : await reader.resolveRef(target.source);
-                    resolved = sha == null ? null : { ...target.source, sha };
+                // Resolve the called workflow once, not once per matrix combination.
+                let subWf = null;
+                let failure = null;
+                // Where the callee's own `./` calls will resolve. A remote `uses:`
+                // moves this to the callee's repo and pinned ref; a local one leaves
+                // it alone.
+                let subSource = source;
+                // What `inputs.*` means on the other side of the call.
+                let subScope = {};
+                const target = parseUses(uses);
+                if (depth + 1 > MAX_REUSABLE_DEPTH) {
+                    failure = `reusable workflow nested deeper than ${MAX_REUSABLE_DEPTH} levels`;
                 }
-                if (resolved == null) {
-                    failure = `cannot resolve ref for ${uses}`;
+                else if (target === null) {
+                    failure = `unresolvable reusable reference: ${uses}`;
                 }
                 else {
-                    subSource = resolved;
-                    const content = await reader.fetchWorkflow(target.path, subSource);
-                    if (content == null) {
-                        failure = `cannot fetch ${uses}`;
+                    // A local `./` call stays on the caller's source, which is already
+                    // pinned to a commit. A cross-repo one arrives as whatever the
+                    // `uses:` string spelled — `@v0` — and has to be resolved before
+                    // anything is read from it, so the file that gets read and the
+                    // commit the prediction names are the same one.
+                    let resolved = source;
+                    if (target.source !== null) {
+                        const { ref } = target.source;
+                        const sha = isSha(ref) ? ref : await reader.resolveRef(target.source);
+                        resolved = sha === null ? null : { ...target.source, sha };
+                    }
+                    if (resolved === null) {
+                        failure = `cannot resolve ref for ${uses}`;
                     }
                     else {
-                        try {
-                            subWf = parseYaml(content);
-                            // `inputs.*` changes at the call boundary; `github.*` does not.
-                            // A callee's jobs run in the caller's repo, so the facts seeded
-                            // at the top of the prediction stay true all the way down.
-                            subScope = {
-                                inputs: calleeInputs(job.with, subWf ?? {}, scoped),
-                                github: scoped.github,
-                            };
+                        subSource = resolved;
+                        const content = await reader.fetchWorkflow(target.path, subSource);
+                        if (content === null) {
+                            failure = `cannot fetch ${uses}`;
                         }
-                        catch (e) {
-                            failure = `YAML parse error in ${uses}: ${e}`;
+                        else {
+                            try {
+                                const parsed = parseYaml(content);
+                                // `inputs.*` changes at the call boundary; `github.*` does
+                                // not. A callee's jobs run in the caller's repo, so the facts
+                                // seeded at the top of the prediction stay true all the way
+                                // down.
+                                subScope = {
+                                    inputs: calleeInputs(job.with, parsed ?? {}, scoped),
+                                    github: scoped.github,
+                                };
+                                // Assigned last, so a throw above leaves it null and the one
+                                // check below covers every way the call failed to resolve.
+                                subWf = parsed;
+                            }
+                            catch (e) {
+                                failure = `YAML parse error in ${uses}: ${e}`;
+                            }
                         }
                     }
                 }
+                for (const combo of combos) {
+                    const disp = jobDisplayName(jobId, job, combo);
+                    const baseName = prefix + disp.name;
+                    const nameResolved = prefixResolved && disp.resolved;
+                    if (subWf === null) {
+                        entries.push({
+                            job: baseName,
+                            checkName: null,
+                            status: "unknown",
+                            reason: failure ?? `cannot resolve ${uses}`,
+                        });
+                    }
+                    else {
+                        entries.push(...(await expandJobs(subWf, ctx, reader, subSource, depth + 1, `${baseName} / `, nameResolved, subScope, executor)));
+                    }
+                }
+            }
+        }
+        else {
+            const combos = expandMatrixDetailed(job.strategy, prScope(scoped));
+            if (combos === null) {
+                entries.push({
+                    job: prefix + jobId,
+                    checkName: null,
+                    status: "unknown",
+                    reason: "dynamic matrix" + execNote(needs),
+                });
             }
-            for (const combo of combos) {
-                const disp = jobDisplayName(jobId, job, combo);
-                const baseName = prefix + disp.name;
-                const nameResolved = prefixResolved && disp.resolved;
-                if (failure != null || subWf == null) {
+            else {
+                for (const combo of combos) {
+                    const disp = jobDisplayName(jobId, job, combo);
+                    const name = prefix + disp.name;
                     entries.push({
-                        job: baseName,
-                        checkName: null,
-                        status: "unknown",
-                        reason: failure ?? `cannot resolve ${uses}`,
+                        job: name,
+                        checkName: prefixResolved && disp.resolved ? name : null,
+                        status,
+                        reason,
                     });
-                    continue;
                 }
-                entries.push(...(await expandJobs(subWf, ctx, reader, subSource, depth + 1, `${baseName} / `, nameResolved, subScope, executor)));
             }
-            continue;
-        }
-        if (combos == null) {
-            entries.push({
-                job: prefix + jobId,
-                checkName: null,
-                status: "unknown",
-                reason: "dynamic matrix" + execNote(needs),
-            });
-            continue;
-        }
-        for (const combo of combos) {
-            const disp = jobDisplayName(jobId, job, combo);
-            const name = prefix + disp.name;
-            entries.push({
-                job: name,
-                checkName: prefixResolved && disp.resolved ? name : null,
-                status,
-                reason,
-            });
         }
     }
     return entries;

package/dist/matrix/expandMatrix.js

@@ -2,5 +2,5 @@ import { expandMatrixDetailed } from "./expandMatrixDetailed.js";
 /** Return list of matrix combination dicts, or null if dynamic. */
 export function expandMatrix(strategy, scope = {}) {
     const detailed = expandMatrixDetailed(strategy, scope);
-    return detailed == null ? null : detailed.map((c) => (c == null ? null : c.values));
+    return detailed === null ? null : detailed.map((c) => (c === null ? null : c.values));
 }

package/dist/matrix/expandMatrixDetailed.js

@@ -43,7 +43,7 @@ function comboList(v, scope) {
 }
 export function expandMatrixDetailed(strategy, scope = {}) {
     const matrix = strategy?.matrix;
-    if (matrix == null) {
+    if (matrix === null || matrix === undefined) {
         return [null];
     }
     // `matrix: ${{ ... }}` — the whole matrix as one expression, rather than the
@@ -59,14 +59,13 @@ export function expandMatrixDetailed(strategy, scope = {}) {
     }
     const axes = {};
     for (const [k, v] of Object.entries(matrix)) {
-        if (k === "include" || k === "exclude") {
-            continue;
-        }
-        const vals = axisValues(v, scope);
-        if (vals == null) {
-            return null;
+        if (k !== "include" && k !== "exclude") {
+            const vals = axisValues(v, scope);
+            if (vals === null) {
+                return null;
+            }
+            axes[k] = vals;
         }
-        axes[k] = vals;
     }
     const axisKeys = Object.keys(axes);
     let combos = [{ values: {}, displayKeys: axisKeys }];

package/dist/matrix/formatMatrixValue.js

@@ -6,7 +6,7 @@
  * `m-object (linux, x64)`.
  */
 export function formatMatrixValue(v) {
-    if (v == null) {
+    if (v === null || v === undefined) {
         return "";
     }
     if (Array.isArray(v)) {

package/dist/names/jobDisplayName.js

@@ -16,7 +16,7 @@ import { renderName } from "./renderName.js";
 export const EXPRESSION_RE = /\$\{\{/;
 /** The check name for one job/combination. */
 export function jobDisplayName(jobId, job, combo) {
-    const raw = job != null && job.name != null ? String(job.name) : null;
+    const raw = job.name !== undefined && job.name !== null ? String(job.name) : null;
     if (raw === null) {
         return { name: capDisplayName(jobId + (combo ? matrixSuffix(combo) : "")), resolved: true };
     }

package/dist/names/skippedDisplayName.js

@@ -12,6 +12,6 @@ import { capDisplayName } from "./capDisplayName.js";
  * caller, with no `/ <callee job>` entries.
  */
 export function skippedDisplayName(jobId, job) {
-    const raw = job != null && job.name != null ? String(job.name) : null;
+    const raw = job.name !== undefined && job.name !== null ? String(job.name) : null;
     return { name: capDisplayName(raw ?? jobId), resolved: true };
 }

package/dist/predict/predict.js

@@ -35,10 +35,18 @@ export async function predict(github, repo, prNumber, opts = {}) {
     };
     const headSha = pr.head.sha;
     /**
-     * The PR's own repo at the head commit — where expansion starts, and already
-     * a commit id, so its `ref` and `sha` are the same string.
+     * The PR's own repo at the head commit — the surface the skip instruction is
+     * read from, and already a commit id, so its `ref` and `sha` are the same
+     * string.
      */
     const headSource = { owner, repo: name, ref: headSha, sha: headSha };
+    /**
+     * GitHub evaluates a `pull_request` at the test merge, not the head (#105).
+     * Null when it has none: a conflict, or a merge not computed yet.
+     */
+    const mergeSha = pr.merge_commit_sha;
+    const readSource = mergeSha === null ? headSource : { owner, repo: name, ref: mergeSha, sha: mergeSha };
+    const readLabel = readSource.sha === headSha ? "head" : "the test merge commit";
     // Provenance for the answer, filled as expansion reaches each source. The head
     // is in from the start: it is read even on the skip path, where the commit
     // message is what decides the verdict.
@@ -51,6 +59,7 @@ export async function predict(github, repo, prNumber, opts = {}) {
     if (SKIP_RE.test(headMsg) || SKIP_TRAILER_RE.test(headMsg)) {
         return finalizePrediction([], "head commit message contains a skip instruction", sources);
     }
+    sources.set(sourceKey(readSource), readSource);
     // A `uses:` naming a tag is the same lookup from every caller that writes it,
     // so resolve each `owner/repo@ref` once. Misses are cached too: a ref that
     // cannot be resolved will not start resolving on the second ask.
@@ -115,7 +124,7 @@ export async function predict(github, repo, prNumber, opts = {}) {
     const reader = { fetchWorkflow, resolveRef };
     // Execution is on by default and costs nothing until a workflow needs it.
     const executor = opts.executor === undefined
-        ? makeLiveExecutor(github, headSource, resolveRef)
+        ? makeLiveExecutor(github, readSource, resolveRef)
         : (opts.executor ?? undefined);
     const workflows = await github.paginate(github.rest.actions.listRepoWorkflows, {
         ...base,
@@ -134,13 +143,18 @@ export async function predict(github, repo, prNumber, opts = {}) {
                 { workflow: path, job: "*", status: "no-dispatch", reason: `workflow state: ${state}` },
             ];
         }
-        const content = await fetchWorkflow(path, headSource);
+        const content = await fetchWorkflow(path, readSource);
         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 —
+            // deleted. There is no file to evaluate, so there is nothing to dispatch —
             // the same verdict as the disabled case above, reached a different way.
             return [
-                { workflow: path, job: "*", status: "no-dispatch", reason: "no workflow file at head" },
+                {
+                    workflow: path,
+                    job: "*",
+                    status: "no-dispatch",
+                    reason: `no workflow file at ${readLabel}`,
+                },
             ];
         }
         let wf;
@@ -157,7 +171,7 @@ export async function predict(github, repo, prNumber, opts = {}) {
         if (!dispatches) {
             return [{ workflow: path, job: "*", status: "no-dispatch", reason }];
         }
-        const jobs = await expandJobs(wf, ctx, reader, headSource, 0, "", true, prFacts, executor);
+        const jobs = await expandJobs(wf, ctx, reader, readSource, 0, "", true, prFacts, executor);
         return jobs.map((j) => ({
             workflow: path,
             job: jobName(j.job),

package/dist/triggers/workflowDispatches.js

@@ -22,13 +22,13 @@ export function workflowDispatches(wf, ctx) {
     }
     const branchRef = ctx.stackTarget ?? ctx.baseRef;
     if ("branches" in trig && !matchFilters(branchRef, trig["branches"])) {
-        const label = ctx.stackTarget == null ? "base branch" : "stack target";
+        const label = ctx.stackTarget === undefined ? "base branch" : "stack target";
         return [false, `${label} '${branchRef}' not in branches`];
     }
     if ("branches-ignore" in trig && matchFilters(branchRef, trig["branches-ignore"])) {
         return [
             false,
-            ctx.stackTarget == null
+            ctx.stackTarget === undefined
                 ? "base branch in branches-ignore"
                 : `stack target '${branchRef}' in branches-ignore`,
         ];

package/dist/verify.js

@@ -50,9 +50,9 @@ const { entries: predictedRaw } = await predict(octokit, repo, pr);
 // no key to compare and are reported separately below.
 const predicted = new Map(predictedRaw
     .filter(isJobEntry)
-    .filter((r) => r.checkName != null)
+    .filter((r) => r.checkName !== null)
     .map((r) => [`${r.workflow} :: ${r.checkName}`, r.status]));
-const unresolved = predictedRaw.filter(isJobEntry).filter((r) => r.checkName == null);
+const unresolved = predictedRaw.filter(isJobEntry).filter((r) => r.checkName === null);
 const unknownWfs = new Set(predictedRaw
     .filter((r) => r.status === "unknown")
     .map((r) => r.workflow)

package/package.json

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