willfire 0.1.29 → 0.1.31

package/dist/jobs/absentInputs.d.ts

@@ -0,0 +1,8 @@
+import type { Val } from "../expr/val.js";
+import type { Workflow } from "../types.js";
+/**
+ * Every declared input bound to the empty string, which is what an absent one
+ * reads as. `default:` is deliberately ignored: a default is applied by the
+ * dispatch or the call, and on a `pull_request` neither happened.
+ */
+export declare function absentInputs(wf: Workflow): Record<string, Val>;

package/dist/jobs/absentInputs.js

@@ -0,0 +1,18 @@
+/** The two triggers that carry an `inputs` context. A `pull_request` is neither. */
+const INPUT_TRIGGERS = ["workflow_dispatch", "workflow_call"];
+/**
+ * Every declared input bound to the empty string, which is what an absent one
+ * reads as. `default:` is deliberately ignored: a default is applied by the
+ * dispatch or the call, and on a `pull_request` neither happened.
+ */
+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 out = {};
+    for (const trigger of INPUT_TRIGGERS) {
+        for (const name of Object.keys(on?.[trigger]?.["inputs"] ?? {})) {
+            out[name] = { kind: "value", v: "" };
+        }
+    }
+    return out;
+}

package/dist/jobs/calleeInputs.d.ts

@@ -0,0 +1,12 @@
+import { type Scope, type Val } from "../expr/val.js";
+import type { Workflow } from "../types.js";
+/**
+ * What `inputs.*` resolves to inside a called workflow: what the caller passed,
+ * over the defaults the callee declares.
+ *
+ * A declared input the caller omits falls back to its `default`. A declared
+ * input with no default and no caller value is unknown rather than empty — the
+ * workflow would be invalid if it were required, and guessing empty would
+ * silently decide guards that are not decided.
+ */
+export declare function calleeInputs(withBlock: unknown, subWf: Workflow, scope: Scope): Record<string, Val>;

package/dist/jobs/calleeInputs.js

@@ -0,0 +1,28 @@
+import { UNKNOWN } from "../expr/val.js";
+import { inputValue } from "./inputValue.js";
+import { workflowCallInputs } from "./workflowCallInputs.js";
+/**
+ * What `inputs.*` resolves to inside a called workflow: what the caller passed,
+ * over the defaults the callee declares.
+ *
+ * A declared input the caller omits falls back to its `default`. A declared
+ * input with no default and no caller value is unknown rather than empty — the
+ * workflow would be invalid if it were required, and guessing empty would
+ * silently decide guards that are not decided.
+ */
+export 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
+                ? // Defaults live in the callee, out of the caller's context's reach.
+                    inputValue(decl["default"], {})
+                : UNKNOWN;
+    }
+    if (withBlock !== null && typeof withBlock === "object") {
+        for (const [name, raw] of Object.entries(withBlock)) {
+            out[name] = inputValue(raw, scope);
+        }
+    }
+    return out;
+}

package/dist/jobs/expandJobs.d.ts

@@ -1,4 +1,4 @@
-import { type Scope } from "../expr/val.js";
-import { type JobExecutor } from "../execute.js";
+import type { Scope } from "../expr/val.js";
+import type { JobExecutor } from "../execute.js";
 import type { Ctx, ExpandedJob, Workflow, WorkflowReader, WorkflowSource } from "../types.js";
 export declare function expandJobs(wf: Workflow, ctx: Ctx, reader: WorkflowReader, source: WorkflowSource, depth?: number, prefix?: string, prefixResolved?: boolean, scope?: Scope, executor?: JobExecutor): Promise<ExpandedJob[]>;

package/dist/jobs/expandJobs.js

@@ -1,77 +1,13 @@
 import { parse as parseYaml } from "yaml";
-import { evaluateValue } from "../expr/evaluateValue.js";
-import { UNKNOWN } from "../expr/val.js";
-import { renderTemplate } from "../execute.js";
 import { expandMatrixDetailed } from "../matrix/expandMatrixDetailed.js";
 import { jobDisplayName } from "../names/jobDisplayName.js";
 import { skippedDisplayName } from "../names/skippedDisplayName.js";
 import { parseUses } from "../uses/parseUses.js";
+import { absentInputs } from "./absentInputs.js";
+import { calleeInputs } from "./calleeInputs.js";
 import { evalIf } from "./evalIf.js";
+import { neededJobIds } from "./neededJobIds.js";
 import { prScope } from "./prScope.js";
-/**
- * A `with:` value as the callee will see it, evaluated in the caller's scope.
- * A whole-expression value keeps its evaluated type; mixed text renders to a
- * string, all or nothing; anything unresolvable stays unknown.
- */
-function inputValue(raw, scope) {
-    if (raw === null || raw === undefined) {
-        return { kind: "value", v: "" };
-    }
-    if (typeof raw === "boolean" || typeof raw === "number") {
-        return { kind: "value", v: raw };
-    }
-    if (typeof raw !== "string") {
-        return UNKNOWN;
-    }
-    if (!raw.includes("${{")) {
-        return { kind: "value", v: raw };
-    }
-    const t = raw.trim();
-    // `${{a}} x ${{b}}` fails this test and takes the render path instead.
-    if (t.startsWith("${{") && t.indexOf("}}") === t.length - 2) {
-        return evaluateValue(t.slice(3, -2), prScope(scope));
-    }
-    const rendered = renderTemplate(raw, prScope(scope));
-    return rendered === null ? UNKNOWN : { kind: "value", v: rendered };
-}
-/** 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") {
-        return {};
-    }
-    const call = on["workflow_call"];
-    if (call === null || call === undefined) {
-        return {};
-    }
-    const inputs = call["inputs"];
-    return inputs !== null && typeof inputs === "object" ? inputs : {};
-}
-/**
- * What `inputs.*` resolves to inside a called workflow: what the caller passed,
- * over the defaults the callee declares.
- *
- * A declared input the caller omits falls back to its `default`. A declared
- * input with no default and no caller value is unknown rather than empty — the
- * workflow would be invalid if it were required, and guessing empty would
- * silently decide guards that are not decided.
- */
-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
-                ? // Defaults live in the callee, out of the caller's context's reach.
-                    inputValue(decl["default"], {})
-                : UNKNOWN;
-    }
-    if (withBlock !== null && typeof withBlock === "object") {
-        for (const [name, raw] of Object.entries(withBlock)) {
-            out[name] = inputValue(raw, scope);
-        }
-    }
-    return out;
-}
 /**
  * GitHub allows a reusable-workflow call chain four levels deep. Past that the
  * run itself fails, so anything deeper is not a name we could predict anyway.
@@ -84,29 +20,17 @@ const MAX_REUSABLE_DEPTH = 4;
 /** `ref` is already a commit id, so resolving it is a no-op. */
 const SHA_RE = /^[0-9a-f]{40}$/i;
 const isSha = (ref) => SHA_RE.test(ref);
-const NEEDS_OUTPUTS_RE = /needs\s*\.\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\.\s*outputs\b/g;
-/**
- * The jobs some sibling reads outputs from — the only jobs worth executing.
- * Matching over the serialized job catches every read site without modelling
- * any; a false positive costs one wasted run, never a verdict.
- */
-function neededJobIds(jobs) {
-    const needed = new Set();
-    for (const job of Object.values(jobs)) {
-        for (const m of JSON.stringify(job ?? {}).matchAll(NEEDS_OUTPUTS_RE)) {
-            needed.add(m[1]);
-        }
-    }
-    return needed;
-}
 export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = "", prefixResolved = true, scope = {}, executor) {
     const entries = [];
     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
+    // over, whatever the caller bound.
+    let scoped = { ...scope, inputs: { ...absentInputs(wf), ...scope.inputs } };
     // Selection is derived, never configured: execute exactly the jobs some
     // sibling's `needs.*.outputs` read depends on, under the same `evalIf`
     // verdict the main loop applies.
-    let scoped = scope;
     const execFailures = {};
     if (executor !== undefined) {
         const needed = neededJobIds(jobs);

package/dist/jobs/inputValue.d.ts

@@ -0,0 +1,7 @@
+import { type Scope, type Val } from "../expr/val.js";
+/**
+ * A `with:` value as the callee will see it, evaluated in the caller's scope.
+ * A whole-expression value keeps its evaluated type; mixed text renders to a
+ * string, all or nothing; anything unresolvable stays unknown.
+ */
+export declare function inputValue(raw: unknown, scope: Scope): Val;

package/dist/jobs/inputValue.js

@@ -0,0 +1,30 @@
+import { evaluateValue } from "../expr/evaluateValue.js";
+import { UNKNOWN } from "../expr/val.js";
+import { renderTemplate } from "../execute.js";
+import { prScope } from "./prScope.js";
+/**
+ * A `with:` value as the callee will see it, evaluated in the caller's scope.
+ * A whole-expression value keeps its evaluated type; mixed text renders to a
+ * string, all or nothing; anything unresolvable stays unknown.
+ */
+export function inputValue(raw, scope) {
+    if (raw === null || raw === undefined) {
+        return { kind: "value", v: "" };
+    }
+    if (typeof raw === "boolean" || typeof raw === "number") {
+        return { kind: "value", v: raw };
+    }
+    if (typeof raw !== "string") {
+        return UNKNOWN;
+    }
+    if (!raw.includes("${{")) {
+        return { kind: "value", v: raw };
+    }
+    const t = raw.trim();
+    // `${{a}} x ${{b}}` fails this test and takes the render path instead.
+    if (t.startsWith("${{") && t.indexOf("}}") === t.length - 2) {
+        return evaluateValue(t.slice(3, -2), prScope(scope));
+    }
+    const rendered = renderTemplate(raw, prScope(scope));
+    return rendered === null ? UNKNOWN : { kind: "value", v: rendered };
+}

package/dist/jobs/neededJobIds.d.ts

@@ -0,0 +1,7 @@
+import type { Workflow } from "../types.js";
+/**
+ * The jobs some sibling reads outputs from — the only jobs worth executing.
+ * Matching over the serialized job catches every read site without modelling
+ * any; a false positive costs one wasted run, never a verdict.
+ */
+export declare function neededJobIds(jobs: Record<string, Workflow>): Set<string>;

package/dist/jobs/neededJobIds.js

@@ -0,0 +1,15 @@
+const NEEDS_OUTPUTS_RE = /needs\s*\.\s*([A-Za-z_][A-Za-z0-9_-]*)\s*\.\s*outputs\b/g;
+/**
+ * The jobs some sibling reads outputs from — the only jobs worth executing.
+ * Matching over the serialized job catches every read site without modelling
+ * any; a false positive costs one wasted run, never a verdict.
+ */
+export function neededJobIds(jobs) {
+    const needed = new Set();
+    for (const job of Object.values(jobs)) {
+        for (const m of JSON.stringify(job ?? {}).matchAll(NEEDS_OUTPUTS_RE)) {
+            needed.add(m[1]);
+        }
+    }
+    return needed;
+}

package/dist/jobs/workflowCallInputs.d.ts

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

package/dist/jobs/workflowCallInputs.js

@@ -0,0 +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 inputs = on?.["workflow_call"]?.["inputs"];
+    return inputs !== null && typeof inputs === "object" ? inputs : {};
+}

package/package.json

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