willfire 0.1.11 → 0.1.13

package/dist/jobs/expandJobs.js

@@ -0,0 +1,247 @@
+import { parse as parseYaml } from "yaml";
+import { UNKNOWN } from "../expr/val.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 { evalIf } from "./evalIf.js";
+import { prScope } from "./prScope.js";
+/**
+ * A `with:` value as the callee will see it.
+ *
+ * A value carrying `${{ }}` is left unknown rather than evaluated. Resolving
+ * it would mean evaluating the caller's own expression context, and every
+ * caller in practice passes plain literals — so the reach that would buy is
+ * not worth the surface. Unknown here is the same unknown as before this
+ * existed; nothing regresses.
+ */
+function inputLiteral(raw) {
+    if (raw == null)
+        return { kind: "value", v: "" };
+    if (typeof raw === "boolean" || typeof raw === "number")
+        return { kind: "value", v: raw };
+    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")
+        return {};
+    const call = on["workflow_call"];
+    if (call == null || typeof call !== "object")
+        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) {
+    const out = {};
+    for (const [name, decl] of Object.entries(workflowCallInputs(subWf))) {
+        out[name] =
+            decl != null && typeof decl === "object" && "default" in decl
+                ? inputLiteral(decl["default"])
+                : UNKNOWN;
+    }
+    if (withBlock != null && typeof withBlock === "object") {
+        for (const [name, raw] of Object.entries(withBlock)) {
+            out[name] = inputLiteral(raw);
+        }
+    }
+    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.
+ * Probe-verified to three levels: `call-nested / Mid Call / inner`.
+ *
+ * A cross-repo hop costs the same one level as a local one, so a chain that
+ * mixes the two is counted the same way.
+ */
+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);
+export async function expandJobs(wf, ctx, reader, source, depth = 0, prefix = "", prefixResolved = true, scope = {}, executor) {
+    const entries = [];
+    const jobs = wf.jobs ?? {};
+    const statuses = {};
+    // Execute what the caller granted, before anything reads `needs`. The
+    // grant names the repo the workflow *file* lives in, so a granted callee
+    // job fires here in the recursion, where `source` is that repo. The guard
+    // is the same `evalIf` the main loop applies — same scope, same verdict —
+    // so a job is executed exactly when it is predicted to run. A job that
+    // would not run is not executed; a job that fails to execute contributes
+    // nothing but its reason, which `execNote` threads into the entries that
+    // needed it.
+    let scoped = scope;
+    const execFailures = {};
+    if (executor != null) {
+        for (const [jobId, jobRaw] of Object.entries(jobs)) {
+            if (!executor.granted(source, jobId))
+                continue;
+            const job = jobRaw ?? {};
+            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 } } };
+            }
+            else {
+                execFailures[jobId] = res.reason;
+            }
+        }
+    }
+    const execNote = (needs) => {
+        const failed = needs.find((n) => n in execFailures);
+        return failed == null ? "" : `; 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 needs = job.needs ?? [];
+        if (typeof needs === "string")
+            needs = [needs];
+        const cond = String(job.if ?? "");
+        if (status !== "skipped" && !cond.includes("always()")) {
+            for (const n of needs) {
+                if (statuses[n] === "skipped") {
+                    status = "skipped";
+                    reason = `needs '${n}' which is skipped`;
+                }
+                else if (statuses[n] === "unknown" && status === "run") {
+                    status = "unknown";
+                    reason = `needs '${n}' whose status is unknown`;
+                }
+            }
+        }
+        statuses[jobId] = status;
+        // A skipped job never expands its matrix and never dispatches a called
+        // workflow: it collapses to a single check under the bare job name.
+        if (status === "skipped") {
+            const disp = skippedDisplayName(jobId, job);
+            const name = prefix + disp.name;
+            entries.push({
+                job: name,
+                checkName: prefixResolved && disp.resolved ? name : null,
+                status,
+                reason,
+            });
+            continue;
+        }
+        const combos = expandMatrixDetailed(job.strategy, prScope(scoped));
+        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 uses = job.uses;
+            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 };
+                }
+                if (resolved == null) {
+                    failure = `cannot resolve ref for ${uses}`;
+                }
+                else {
+                    subSource = resolved;
+                    const content = await reader.fetchWorkflow(target.path, subSource);
+                    if (content == null) {
+                        failure = `cannot fetch ${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 ?? {}), github: scoped.github };
+                        }
+                        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 (failure != null || subWf == null) {
+                    entries.push({
+                        job: baseName,
+                        checkName: null,
+                        status: "unknown",
+                        reason: failure ?? `cannot resolve ${uses}`,
+                    });
+                    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/jobs/expandWorkflowJobs.d.ts

@@ -0,0 +1,14 @@
+import type { Scope } from "../expr/val.js";
+import type { JobExecutor } from "../execute.js";
+import type { Ctx, ExpandedJob, Workflow, WorkflowReader, WorkflowSource } from "../types.js";
+/**
+ * Expand one already-parsed workflow into its job entries. Exported so check
+ * names can be tested against recorded GitHub behaviour without a network
+ * round-trip; `predict` is the API you want.
+ *
+ * `scope` seeds what this workflow's own `${{ }}` resolve against — notably
+ * `needs`, the outputs of jobs that have not run. Nothing here works out what
+ * those are; a caller that knows hands them in, and a caller that does not
+ * leaves them out and gets `unknown` where they would have been used.
+ */
+export declare function expandWorkflowJobs(wf: Workflow, ctx: Ctx, reader: WorkflowReader, source: WorkflowSource, scope?: Scope, executor?: JobExecutor): Promise<ExpandedJob[]>;

package/dist/jobs/expandWorkflowJobs.js

@@ -0,0 +1,14 @@
+import { expandJobs } from "./expandJobs.js";
+/**
+ * Expand one already-parsed workflow into its job entries. Exported so check
+ * names can be tested against recorded GitHub behaviour without a network
+ * round-trip; `predict` is the API you want.
+ *
+ * `scope` seeds what this workflow's own `${{ }}` resolve against — notably
+ * `needs`, the outputs of jobs that have not run. Nothing here works out what
+ * those are; a caller that knows hands them in, and a caller that does not
+ * leaves them out and gets `unknown` where they would have been used.
+ */
+export function expandWorkflowJobs(wf, ctx, reader, source, scope = {}, executor) {
+    return expandJobs(wf, ctx, reader, source, 0, "", true, scope, executor);
+}

package/dist/jobs/index.d.ts

@@ -0,0 +1,4 @@
+export { prScope } from "./prScope.js";
+export { evalIf } from "./evalIf.js";
+export { expandJobs } from "./expandJobs.js";
+export { expandWorkflowJobs } from "./expandWorkflowJobs.js";

package/dist/jobs/index.js

@@ -0,0 +1,4 @@
+export { prScope } from "./prScope.js";
+export { evalIf } from "./evalIf.js";
+export { expandJobs } from "./expandJobs.js";
+export { expandWorkflowJobs } from "./expandWorkflowJobs.js";

package/dist/jobs/prScope.d.ts

@@ -0,0 +1,10 @@
+import type { Scope } from "../expr/val.js";
+/**
+ * A scope with the fixed pull-request facts filled in.
+ *
+ * Every `${{ }}` this module evaluates — a job `if:`, a matrix axis — is
+ * evaluated for the same event, so they all get the same `github.*`. Anything
+ * the caller states wins; there is nothing here worth overriding, but a scope
+ * that silently ignored what it was handed would be the wrong shape.
+ */
+export declare const prScope: (scope: Scope) => Scope;

package/dist/jobs/prScope.js

@@ -0,0 +1,19 @@
+/**
+ * The `github.*` values that are fixed for everything this module predicts.
+ * `predict` only ever answers for a pull request, so `event_name` is not a
+ * variable — which is what lets a `github.event_name == 'pull_request'` guard
+ * resolve instead of hanging the job on an unknown.
+ */
+const PR_GITHUB_CONTEXT = { event_name: "pull_request" };
+/**
+ * A scope with the fixed pull-request facts filled in.
+ *
+ * Every `${{ }}` this module evaluates — a job `if:`, a matrix axis — is
+ * evaluated for the same event, so they all get the same `github.*`. Anything
+ * the caller states wins; there is nothing here worth overriding, but a scope
+ * that silently ignored what it was handed would be the wrong shape.
+ */
+export const prScope = (scope) => ({
+    ...scope,
+    github: { ...PR_GITHUB_CONTEXT, ...scope.github },
+});

package/dist/matrix/expandMatrix.d.ts

@@ -0,0 +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;

package/dist/matrix/expandMatrix.js

@@ -0,0 +1,6 @@
+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));
+}

package/dist/matrix/expandMatrixDetailed.d.ts

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

package/dist/matrix/expandMatrixDetailed.js

@@ -0,0 +1,74 @@
+import { evaluateValue } from "../expr/evaluateValue.js";
+/**
+ * The values of one matrix axis, or null when they cannot be known.
+ *
+ * A plain list is itself. An axis written as an expression —
+ * `language: ${{ fromJSON(needs.detect.outputs.coverage_languages) }}` — is
+ * the values another job computed, and is knowable exactly when the scope
+ * carries that job's outputs. Anything else stays null, which is what makes
+ * the whole job `unknown` rather than a guess at how many checks it creates.
+ */
+function axisValues(v, scope) {
+    if (Array.isArray(v))
+        return v;
+    if (typeof v !== "string")
+        return null;
+    const val = evaluateValue(v, scope);
+    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)
+        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")
+        return null;
+    const include = matrix.include ?? [];
+    const exclude = matrix.exclude ?? [];
+    if (typeof include === "string" || typeof exclude === "string")
+        return null;
+    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;
+        axes[k] = vals;
+    }
+    const axisKeys = Object.keys(axes);
+    let combos = [{ values: {}, displayKeys: axisKeys }];
+    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)
+        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) {
+        const overlapping = Object.fromEntries(Object.entries(inc).filter(([k]) => k in axes));
+        const targets = combos.filter((c) => Object.entries(overlapping).every(([k, v]) => c.values[k] === v));
+        if (axisKeys.length > 0 && targets.length > 0) {
+            // Merge into the matching combinations. With no overlapping keys this
+            // 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)
+                Object.assign(c.values, inc);
+        }
+        else {
+            // No combination to attach to: the include entry becomes a combination
+            // of its own, and every one of its keys shows in the name.
+            extra.push({ values: { ...inc }, displayKeys: Object.keys(inc) });
+        }
+    }
+    combos.push(...extra);
+    // Zero combinations is a real answer, not a missing one: an empty axis, or an
+    // `exclude` that removes everything, schedules no jobs at all. Only an absent
+    // `matrix:` key means "one unsuffixed job", and that returned above.
+    return combos;
+}

package/dist/matrix/formatMatrixValue.d.ts

@@ -0,0 +1,8 @@
+/**
+ * How a single matrix value is rendered inside a check name.
+ *
+ * Probe-verified: object values are flattened to their own values, so
+ * `cfg: {os: linux, arch: x64}` renders as `linux, x64` — the check is
+ * `m-object (linux, x64)`.
+ */
+export declare function formatMatrixValue(v: unknown): string;

package/dist/matrix/formatMatrixValue.js

@@ -0,0 +1,16 @@
+/**
+ * How a single matrix value is rendered inside a check name.
+ *
+ * Probe-verified: object values are flattened to their own values, so
+ * `cfg: {os: linux, arch: x64}` renders as `linux, x64` — the check is
+ * `m-object (linux, x64)`.
+ */
+export function formatMatrixValue(v) {
+    if (v == null)
+        return "";
+    if (Array.isArray(v))
+        return v.map(formatMatrixValue).join(", ");
+    if (typeof v === "object")
+        return Object.values(v).map(formatMatrixValue).join(", ");
+    return String(v);
+}

package/dist/matrix/index.d.ts

@@ -0,0 +1,4 @@
+export { expandMatrixDetailed } from "./expandMatrixDetailed.js";
+export { expandMatrix } from "./expandMatrix.js";
+export { formatMatrixValue } from "./formatMatrixValue.js";
+export { matrixSuffix } from "./matrixSuffix.js";

package/dist/matrix/index.js

@@ -0,0 +1,4 @@
+export { expandMatrixDetailed } from "./expandMatrixDetailed.js";
+export { expandMatrix } from "./expandMatrix.js";
+export { formatMatrixValue } from "./formatMatrixValue.js";
+export { matrixSuffix } from "./matrixSuffix.js";

package/dist/matrix/matrixSuffix.d.ts

@@ -0,0 +1,3 @@
+import type { DetailedCombo } from "../types.js";
+/** The ` (v1, v2)` suffix GitHub appends for a matrix combination. */
+export declare function matrixSuffix(combo: DetailedCombo): string;

package/dist/matrix/matrixSuffix.js

@@ -0,0 +1,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)
+        return "";
+    return ` (${keys.map((k) => formatMatrixValue(combo.values[k])).join(", ")})`;
+}

package/dist/names/index.d.ts

@@ -0,0 +1,4 @@
+export { lookupPath } from "./lookupPath.js";
+export { renderName } from "./renderName.js";
+export { jobDisplayName, EXPRESSION_RE } from "./jobDisplayName.js";
+export { skippedDisplayName } from "./skippedDisplayName.js";

package/dist/names/index.js

@@ -0,0 +1,4 @@
+export { lookupPath } from "./lookupPath.js";
+export { renderName } from "./renderName.js";
+export { jobDisplayName, EXPRESSION_RE } from "./jobDisplayName.js";
+export { skippedDisplayName } from "./skippedDisplayName.js";

package/dist/names/jobDisplayName.d.ts

@@ -0,0 +1,16 @@
+import type { DetailedCombo, DisplayName, Workflow } from "../types.js";
+/**
+ * A `name:` that contains any `${{ }}` expression suppresses the matrix
+ * parenthetical; a literal one does not.
+ *
+ * Probe-verified three ways over `a: [x, y]`: `name: Static Label` yields
+ * `Static Label (x)` / `Static Label (y)`, `name: ev ${{ github.event_name }}`
+ * yields two checks both called `ev pull_request`, and
+ * `name: p ${{ matrix.a }}` over `a: [x], b: ["1", "2"]` yields two checks
+ * both called `p x`. So the trigger is the presence of an expression, not
+ * whether the expression happens to read the matrix — and duplicate check
+ * names are a real outcome GitHub allows.
+ */
+export declare const EXPRESSION_RE: RegExp;
+/** The check name for one job/combination. */
+export declare function jobDisplayName(jobId: string, job: Workflow, combo: DetailedCombo | null): DisplayName;

package/dist/names/jobDisplayName.js

@@ -0,0 +1,25 @@
+import { matrixSuffix } from "../matrix/matrixSuffix.js";
+import { renderName } from "./renderName.js";
+/**
+ * A `name:` that contains any `${{ }}` expression suppresses the matrix
+ * parenthetical; a literal one does not.
+ *
+ * Probe-verified three ways over `a: [x, y]`: `name: Static Label` yields
+ * `Static Label (x)` / `Static Label (y)`, `name: ev ${{ github.event_name }}`
+ * yields two checks both called `ev pull_request`, and
+ * `name: p ${{ matrix.a }}` over `a: [x], b: ["1", "2"]` yields two checks
+ * both called `p x`. So the trigger is the presence of an expression, not
+ * whether the expression happens to read the matrix — and duplicate check
+ * names are a real outcome GitHub allows.
+ */
+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;
+    if (raw === null) {
+        return { name: jobId + (combo ? matrixSuffix(combo) : ""), resolved: true };
+    }
+    const { text, resolved } = renderName(raw, combo?.values ?? null);
+    const suffix = combo && !EXPRESSION_RE.test(raw) ? matrixSuffix(combo) : "";
+    return { name: text + suffix, resolved };
+}

package/dist/names/lookupPath.d.ts

@@ -0,0 +1 @@
+export declare function lookupPath(obj: any, path: string): unknown;

package/dist/names/lookupPath.js

@@ -0,0 +1,9 @@
+export function lookupPath(obj, path) {
+    let cur = obj;
+    for (const seg of path.split(".")) {
+        if (cur == null || typeof cur !== "object" || !(seg in cur))
+            return undefined;
+        cur = cur[seg];
+    }
+    return cur;
+}

package/dist/names/renderName.d.ts

@@ -0,0 +1,2 @@
+import type { Combo, Rendered } from "../types.js";
+export declare function renderName(template: string, combo: Combo): Rendered;

package/dist/names/renderName.js

@@ -0,0 +1,26 @@
+import { formatMatrixValue } from "../matrix/formatMatrixValue.js";
+import { lookupPath } from "./lookupPath.js";
+export function renderName(template, combo) {
+    let resolved = true;
+    const text = template.replace(/\$\{\{(.*?)\}\}/g, (whole, inner) => {
+        const expr = String(inner).trim();
+        if (expr.startsWith("matrix.")) {
+            if (!combo) {
+                resolved = false;
+                return whole;
+            }
+            const val = lookupPath(combo, expr.slice("matrix.".length));
+            if (val === undefined) {
+                resolved = false;
+                return whole;
+            }
+            return formatMatrixValue(val);
+        }
+        // We only predict pull_request dispatch, so this one is knowable.
+        if (expr === "github.event_name")
+            return "pull_request";
+        resolved = false;
+        return whole;
+    });
+    return { text, resolved };
+}

package/dist/names/skippedDisplayName.d.ts

@@ -0,0 +1,14 @@
+import type { DisplayName, Workflow } from "../types.js";
+/**
+ * The check name a job gets when it is skipped.
+ *
+ * A skipped job is never set up, so nothing about it is evaluated: the matrix
+ * does not expand and `name:` is not interpolated. Probe-verified twice over:
+ * `if: false` with `a: [x, y]` produces the single check `m-skipped`, not
+ * `m-skipped (x)` / `m-skipped (y)`; and `name: sk ${{ github.event_name }}`
+ * with `if: false` produces a check literally called
+ * `sk ${{ github.event_name }}`, expression text and all. The same collapse
+ * applies to a skipped reusable-workflow call: one check named after the
+ * caller, with no `/ <callee job>` entries.
+ */
+export declare function skippedDisplayName(jobId: string, job: Workflow): DisplayName;

package/dist/names/skippedDisplayName.js

@@ -0,0 +1,16 @@
+/**
+ * The check name a job gets when it is skipped.
+ *
+ * A skipped job is never set up, so nothing about it is evaluated: the matrix
+ * does not expand and `name:` is not interpolated. Probe-verified twice over:
+ * `if: false` with `a: [x, y]` produces the single check `m-skipped`, not
+ * `m-skipped (x)` / `m-skipped (y)`; and `name: sk ${{ github.event_name }}`
+ * with `if: false` produces a check literally called
+ * `sk ${{ github.event_name }}`, expression text and all. The same collapse
+ * applies to a skipped reusable-workflow call: one check named after the
+ * caller, with no `/ <callee job>` entries.
+ */
+export function skippedDisplayName(jobId, job) {
+    const raw = job != null && job.name != null ? String(job.name) : null;
+    return { name: raw ?? jobId, resolved: true };
+}

package/dist/predict/finalizePrediction.d.ts

@@ -0,0 +1,2 @@
+import type { DraftEntry, Prediction, WorkflowSource } from "../types.js";
+export declare function finalizePrediction(entries: DraftEntry[], skip: string | null, sources: Map<string, WorkflowSource>): Prediction;

package/dist/predict/finalizePrediction.js

@@ -0,0 +1,19 @@
+import { sourceKey } from "./sourceKey.js";
+const isWorkflowDraft = (e) => e.job === "*";
+const finalize = (e) => isWorkflowDraft(e)
+    ? { ...e, checkName: null }
+    : { ...e, checkName: e.checkName ?? null };
+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)
+            names.add(e.checkName);
+    }
+    return {
+        entries: final,
+        checkNames: [...names].sort(),
+        skip,
+        sources: [...sources.values()].sort((a, b) => sourceKey(a).localeCompare(sourceKey(b))),
+    };
+}

package/dist/predict/index.d.ts

@@ -0,0 +1,5 @@
+export { makeOctokit } from "./makeOctokit.js";
+export { sourceKey } from "./sourceKey.js";
+export { stackTargetRef } from "./stackTargetRef.js";
+export { finalizePrediction } from "./finalizePrediction.js";
+export { predict } from "./predict.js";

package/dist/predict/index.js

@@ -0,0 +1,5 @@
+export { makeOctokit } from "./makeOctokit.js";
+export { sourceKey } from "./sourceKey.js";
+export { stackTargetRef } from "./stackTargetRef.js";
+export { finalizePrediction } from "./finalizePrediction.js";
+export { predict } from "./predict.js";

package/dist/predict/makeOctokit.d.ts

@@ -0,0 +1,2 @@
+import { Octokit } from "@octokit/rest";
+export declare function makeOctokit(): Octokit;