willfire 0.1.34 → 0.1.36

package/dist/execute.d.ts

@@ -6,7 +6,7 @@
  * with a reason — never a guess.
  */
 import { type Scope } from "./expr/val.js";
-import type { ResolveRef, WorkflowSource } from "./types.js";
+import type { ResolveRef, Workflow, WorkflowSource } from "./types.js";
 /** A host path a sandboxed runner must expose inside, at the same path. */
 export interface Mount {
     path: string;
@@ -54,7 +54,7 @@ export type ExecOutcome = {
  * running it yields.
  */
 export interface JobExecutor {
-    executeJob(jobId: string, job: any, wf: any, scope: Scope): Promise<ExecOutcome>;
+    executeJob(jobId: string, job: Workflow, wf: Workflow, scope: Scope): Promise<ExecOutcome>;
 }
 /**
  * Render every `${{ }}` to literal text, or null when any cannot be settled —

package/dist/execute.js

@@ -194,15 +194,16 @@ async function runSteps(steps, scope, ctx) {
 /** A `uses:` step: a runner-provided postcondition, an action to run, or a stop. */
 async function runUses(step, label, scope, ctx) {
     const uses = step.uses;
+    const withBlock = step.with ?? {};
     if (CHECKOUT_RE.test(uses)) {
         // Runner-provided, and its postcondition — the head tree at the workspace
         // path — is already true. Any input beyond `fetch-depth: 0` asks for a
         // different tree than the one provided.
-        const withKeys = Object.keys(step.with ?? {});
+        const withKeys = Object.keys(withBlock);
         if (withKeys.length === 0) {
             return { ok: true, v: {} };
         }
-        if (withKeys.length === 1 && String(step.with["fetch-depth"]) === "0") {
+        if (withKeys.length === 1 && String(withBlock["fetch-depth"]) === "0") {
             // Unmet inside a composite: the pre-scan that picks the tree provider
             // only reads the job's own steps.
             if (!ctx.hasHistory) {
@@ -215,12 +216,12 @@ async function runUses(step, label, scope, ctx) {
     if (SETUP_NODE_RE.test(uses)) {
         // The execution world ships exactly one node: asking for it is already
         // satisfied, asking for anything else cannot be.
-        const withKeys = Object.keys(step.with ?? {});
+        const withKeys = Object.keys(withBlock);
         if (withKeys.length === 0) {
             return { ok: true, v: {} };
         }
         if (withKeys.length === 1 && withKeys[0] === "node-version") {
-            const wanted = renderTemplate(String(step.with["node-version"]), scope);
+            const wanted = renderTemplate(String(withBlock["node-version"]), scope);
             if (wanted === null) {
                 return err(`${label}: cannot resolve node-version`);
             }
@@ -467,9 +468,10 @@ export function makeExecutor(opts) {
             if (!Array.isArray(job.steps)) {
                 return fail(`job '${jobId}' has no steps`);
             }
+            const steps = job.steps;
             // Any checkout input might be the `fetch-depth: 0` form. Over-asking for
             // one the walk will refuse anyway costs a clone, never correctness.
-            const needsHistory = job.steps.some((s) => s !== null &&
+            const needsHistory = steps.some((s) => s !== null &&
                 s !== undefined &&
                 typeof s.uses === "string" &&
                 CHECKOUT_RE.test(s.uses) &&
@@ -479,7 +481,7 @@ export function makeExecutor(opts) {
                 return fail(`cannot materialize workspace ${workspace.owner}/${workspace.repo}@${workspace.sha}`);
             }
             const jobScope = { ...scope, github: { ...github, ...scope.github } };
-            const walked = await runSteps(job.steps, jobScope, {
+            const walked = await runSteps(steps, jobScope, {
                 tree,
                 hasHistory: needsHistory,
                 envLayers: [wf?.env, job.env],

package/dist/jobs/absentInputs.js

@@ -7,7 +7,7 @@ const INPUT_TRIGGERS = ["workflow_dispatch", "workflow_call"];
  */
 export function absentInputs(wf) {
     // Tolerates the YAML 1.1 `on` -> true key, as the callee's own lookup does.
-    const on = wf["on"] ?? wf["true"];
+    const on = (wf["on"] ?? wf["true"]);
     const out = {};
     for (const trigger of INPUT_TRIGGERS) {
         for (const name of Object.keys(on?.[trigger]?.["inputs"] ?? {})) {

package/dist/jobs/evalIf.d.ts

@@ -7,4 +7,4 @@ import type { Scope } from "../expr/val.js";
  * unknown, because every one of them is written against `inputs.*` or
  * `needs.*`.
  */
-export declare function evalIf(cond: any, scope?: Scope): "run" | "skipped" | "unknown";
+export declare function evalIf(cond: unknown, scope?: Scope): "run" | "skipped" | "unknown";

package/dist/jobs/expandJobs.js

@@ -22,7 +22,7 @@ const SHA_RE = /^[0-9a-f]{40}$/i;
 const isSha = (ref) => SHA_RE.test(ref);
 export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = "", prefixResolved = true, scope = {}, executor) {
     const entries = [];
-    const jobs = wf.jobs ?? {};
+    const jobs = (wf["jobs"] ?? {});
     const statuses = {};
     // Nothing dispatched or called this run, so an input this workflow declares
     // and nothing supplied reads as the empty string (#125) — laid under, never
@@ -57,10 +57,8 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
         const job = jobRaw ?? {};
         let status = evalIf(job.if, scoped);
         let reason = job.if !== undefined && job.if !== null ? `if: ${JSON.stringify(job.if)}` : "";
-        let needs = job.needs ?? [];
-        if (typeof needs === "string") {
-            needs = [needs];
-        }
+        const needsRaw = job["needs"];
+        const needs = typeof needsRaw === "string" ? [needsRaw] : (needsRaw ?? []);
         const cond = String(job.if ?? "");
         if (status !== "skipped" && !cond.includes("always()")) {
             for (const n of needs) {
@@ -94,7 +92,7 @@ export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = ""
             // 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;
+            const uses = job["uses"];
             if (combos === null) {
                 entries.push({
                     job: prefix + jobId,

package/dist/jobs/workflowCallInputs.d.ts

@@ -1,3 +1,4 @@
 import type { Workflow } from "../types.js";
+import type { YamlMap } from "../yamlValue.js";
 /** The `on.workflow_call.inputs` block, tolerating the YAML 1.1 `on` -> true key. */
-export declare function workflowCallInputs(wf: Workflow): Record<string, any>;
+export declare function workflowCallInputs(wf: Workflow): YamlMap;

package/dist/jobs/workflowCallInputs.js

@@ -1,6 +1,6 @@
 /** The `on.workflow_call.inputs` block, tolerating the YAML 1.1 `on` -> true key. */
 export function workflowCallInputs(wf) {
-    const on = wf?.["on"] ?? wf?.["true"];
+    const on = (wf?.["on"] ?? wf?.["true"]);
     const inputs = on?.["workflow_call"]?.["inputs"];
     return inputs !== null && typeof inputs === "object" ? inputs : {};
 }

package/dist/matrix/expandMatrix.d.ts

@@ -1,4 +1,4 @@
 import type { Scope } from "../expr/val.js";
 import type { Combo } from "../types.js";
 /** Return list of matrix combination dicts, or null if dynamic. */
-export declare function expandMatrix(strategy: any, scope?: Scope): Combo[] | null;
+export declare function expandMatrix(strategy: unknown, scope?: Scope): Combo[] | null;

package/dist/matrix/expandMatrixDetailed.d.ts

@@ -1,3 +1,3 @@
 import type { Scope } from "../expr/val.js";
 import type { DetailedCombos } from "../types.js";
-export declare function expandMatrixDetailed(strategy: any, scope?: Scope): DetailedCombos;
+export declare function expandMatrixDetailed(strategy: unknown, scope?: Scope): DetailedCombos;

package/dist/matrix/expandMatrixDetailed.js

@@ -42,7 +42,9 @@ function comboList(v, scope) {
     return val.v;
 }
 export function expandMatrixDetailed(strategy, scope = {}) {
-    const matrix = strategy?.matrix;
+    const matrix = strategy !== null && typeof strategy === "object"
+        ? strategy["matrix"]
+        : undefined;
     if (matrix === null || matrix === undefined) {
         return [null];
     }
@@ -52,13 +54,14 @@ export function expandMatrixDetailed(strategy, scope = {}) {
     if (typeof matrix === "string") {
         return null;
     }
-    const include = comboList(matrix.include, scope);
-    const exclude = comboList(matrix.exclude, scope);
+    const m = matrix;
+    const include = comboList(m["include"], scope);
+    const exclude = comboList(m["exclude"], scope);
     if (include === null || exclude === null) {
         return null;
     }
     const axes = {};
-    for (const [k, v] of Object.entries(matrix)) {
+    for (const [k, v] of Object.entries(m)) {
         if (k !== "include" && k !== "exclude") {
             const vals = axisValues(v, scope);
             if (vals === null) {

package/dist/names/lookupPath.d.ts

@@ -1,2 +1,2 @@
 import type { YamlValue } from "../yamlValue.js";
-export declare function lookupPath(obj: any, path: string): YamlValue | undefined;
+export declare function lookupPath(obj: YamlValue | undefined, path: string): YamlValue | undefined;

package/dist/triggers/getPrTrigger.d.ts

@@ -1,3 +1,4 @@
 import type { Workflow } from "../types.js";
+import type { YamlMap } from "../yamlValue.js";
 export declare const MISSING: unique symbol;
-export declare function getPrTrigger(wf: Workflow): Record<string, any> | typeof MISSING;
+export declare function getPrTrigger(wf: Workflow): YamlMap | typeof MISSING;

package/dist/triggers/getPrTrigger.js

@@ -14,7 +14,7 @@ export function getPrTrigger(wf) {
     }
     if (typeof on === "object") {
         if ("pull_request" in on) {
-            return on["pull_request"] ?? {};
+            return (on["pull_request"] ?? {});
         }
         return MISSING;
     }

package/dist/triggers/workflowDispatches.js

@@ -10,7 +10,7 @@ export function workflowDispatches(wf, ctx) {
     if (trig === MISSING) {
         return [false, "no pull_request trigger"];
     }
-    const types = trig["types"] ?? DEFAULT_TYPES;
+    const types = (trig["types"] ?? DEFAULT_TYPES);
     if (!types.includes(ctx.action)) {
         return [false, `action '${ctx.action}' not in types [${types}]`];
     }
@@ -39,7 +39,8 @@ export function workflowDispatches(wf, ctx) {
     if ("paths" in trig && !ctx.files.some((f) => matchFilters(f, trig["paths"]))) {
         return [false, "no changed file matches paths"];
     }
-    if ("paths-ignore" in trig && ctx.files.every((f) => matchFilters(f, trig["paths-ignore"]))) {
+    if ("paths-ignore" in trig &&
+        ctx.files.every((f) => matchFilters(f, trig["paths-ignore"]))) {
         return [false, "all changed files match paths-ignore"];
     }
     return [true, "trigger matched"];

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { JobExecutor } from "./execute.js";
+import type { YamlMap } from "./yamlValue.js";
 export interface EntryBase {
     workflow: string;
     reason: string;
@@ -134,8 +135,8 @@ export interface Ctx {
     stackTarget?: string;
     files: string[];
 }
-export type Workflow = Record<string, any>;
-export type Combo = Record<string, any> | null;
+export type Workflow = YamlMap;
+export type Combo = YamlMap | null;
 /**
  * A matrix combination plus the keys that appear in its check-name
  * parenthetical. The two differ: a key contributed by an `include` entry that
@@ -148,7 +149,7 @@ export type Combo = Record<string, any> | null;
  * created from scratch shows all of its own keys.
  */
 export interface DetailedCombo {
-    values: Record<string, any>;
+    values: YamlMap;
     displayKeys: string[];
 }
 /**

package/package.json

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