@codyswann/lisa 4.60.3 → 4.60.5

package/dist/core/reusable-workflow-load-adapter.d.ts

@@ -1,78 +0,0 @@
-/**
- * Turn GitHub's run endpoints into the pages `core/reusable-workflow-load-scan`
- * expects (CodySwannGT/lisa#3581).
- *
- * The HTTP request is injected. That keeps the endpoint shapes, the paging
- * parameters and the response handling under test against a stub, which is the
- * only way to prove this wiring without a live call whose rate limit decides
- * whether the suite passes — the lesson a sibling lane paid twenty minutes of
- * held-dirty tree to learn.
- *
- * ## Why this needs three endpoints and not one
- *
- * The run LIST gives id, caller path, timestamp and conclusion. It does not
- * give the two facts the verdict actually turns on: `referenced_workflows`
- * comes from the single-run endpoint, and the job count from the run's jobs
- * endpoint. So a full scan is inherently N+1, and reading every run's detail
- * across a wide window is the kind of request volume that gets a scheduled job
- * rate-limited into a false green.
- *
- * The narrowing that makes it affordable is sound rather than convenient: a
- * load failure is only reachable from a conclusion GitHub can produce BEFORE
- * creating a job. Detail is therefore fetched only for those, and a run with
- * any other conclusion keeps zeroes it never fetched.
- *
- * **Those zeroes are not measurements.** For a `success` run they are simply
- * absent evidence, and the classifier's label for such a run is not meaningful
- * — the only verdict this adapter's output supports is `load-failure`, which
- * is the one the scan filters for. Anything that starts reporting per-verdict
- * counts from these pages must fetch detail unconditionally first.
- * @module core/reusable-workflow-load-adapter
- */
-import type { RunPage } from "./reusable-workflow-load-scan.js";
-/** GitHub's default and maximum page size for the runs endpoint. */
-export declare const RUNS_PER_PAGE = 100;
-/** Performs one authenticated GET and returns the decoded JSON body. */
-export type GithubRequest = (path: string) => Promise<unknown>;
-/** What the fetcher needs to address a repository. */
-export interface AdapterOptions {
-    /** Repository in `owner/name` form. */
-    readonly repo: string;
-    /** The injected request function. */
-    readonly request: GithubRequest;
-    /** Page size; defaults to `RUNS_PER_PAGE`. */
-    readonly perPage?: number;
-}
-/**
- * Path for one page of run history, newest first.
- * @param repo - Repository in `owner/name` form
- * @param page - 1-based page number
- * @param perPage - Page size
- * @returns The API path to request
- */
-export declare function runsPath(repo: string, page: number, perPage: number): string;
-/**
- * Path for one run's detail, which is where `referenced_workflows` lives.
- * @param repo - Repository in `owner/name` form
- * @param id - The run id
- * @returns The API path to request
- */
-export declare function runPath(repo: string, id: number): string;
-/**
- * Path for one run's jobs, read only for its `total_count`.
- * @param repo - Repository in `owner/name` form
- * @param id - The run id
- * @returns The API path to request
- */
-export declare function jobsPath(repo: string, id: number): string;
-/**
- * Build the page fetcher `scanForLoadFailures` consumes.
- *
- * `hasMore` is derived from a full page rather than from `total_count`,
- * because a run created while the scan is paging shifts `total_count` under
- * it. A full page means "ask again"; a short page means the history ended.
- * @param options - Repository, request function and page size
- * @returns A fetcher for one 1-based page of run history
- */
-export declare function createRunPageFetcher(options: AdapterOptions): (page: number) => Promise<RunPage>;
-//# sourceMappingURL=reusable-workflow-load-adapter.d.ts.map

package/dist/core/reusable-workflow-load-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reusable-workflow-load-adapter.d.ts","sourceRoot":"","sources":["../../src/core/reusable-workflow-load-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,kCAAkC,CAAC;AAY5E,oEAAoE;AACpE,eAAO,MAAM,aAAa,MAAM,CAAC;AAEjC,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/D,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,uCAAuC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzD;AA8ED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,cAAc,GACtB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAqBpC"}

package/dist/core/reusable-workflow-load-adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reusable-workflow-load-adapter.js","sourceRoot":"","sources":["../../src/core/reusable-workflow-load-adapter.ts"],"names":[],"mappings":"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"}

package/dist/core/reusable-workflow-load-failure.d.ts

@@ -1,144 +0,0 @@
-/**
- * Distinguish a reusable workflow that failed to LOAD from one that failed to
- * RUN (CodySwannGT/lisa#3581).
- *
- * When an upstream commit makes a reusable workflow unparseable, GitHub
- * rejects the file before creating any job. The run has zero jobs, no
- * annotation naming the offending line, and a display `name` that degrades to
- * its `path` because GitHub never got as far as reading the `name:` key.
- * Nothing that watches for a failing JOB can see it — there is no red job to
- * open. Sibling module `core/reusable-workflow-pin` records the same failure
- * from the other end: "Actions creates zero jobs, so a required check is
- * ABSENT rather than red."
- *
- * ## Which moment this is open at
- *
- * On a pull request the exposure is CLOSED, and by something that already
- * exists: `check-skipped-required-checks --pr=<n>` raises
- * `absent_required_check` for a ruleset-required context that posted no
- * check-run at all, and a required context that never reports blocks the
- * merge regardless. Off a pull request — a `push` or `schedule` handler — no
- * arm looks. That is where the incident behind this ticket happened: a
- * consumer's handler failed five times in a row before anyone noticed, ~40
- * minutes after the upstream commit landed, with nothing changed on the
- * consumer side. So the gap is not that detection was never built; it is that
- * detection exists at exactly one moment and the failure occurs at every
- * moment.
- *
- * ## The one arm that discriminates, and the three that do not
- *
- * `referenced_workflows` on `GET /repos/{owner}/{repo}/actions/runs/{id}`
- * carries the resolved SHA of every reusable workflow a run actually used. A
- * caller that DECLARED one and RESOLVED ZERO did not parse; there is no other
- * way to reach that state.
- *
- * It is only meaningful INSIDE its population — runs whose caller declares a
- * reusable workflow at all. Measured on one consumer, 19 failing runs in a
- * day: the 5 in population all resolved at least one; the 14 outside it all
- * resolved zero. Read bare, the field reports 14 false positives out of 19.
- *
- * Three cheaper signals are each refuted by a measured run:
- *
- *  - `conclusion == "failure"` — six failures in that window, four load
- *    failures.
- *  - `jobs == 0` — one run IN the population resolved its workflow and still
- *    produced zero jobs, so an empty run is not the signature.
- *  - `name == path` — a display coincidence. Any workflow that omits `name:`
- *    satisfies it while perfectly healthy, so it corroborates and never
- *    decides.
- *
- * ## The false-red this must not become
- *
- * A dead runner produces a nearly identical run: `conclusion: failure`, no
- * useful output, nothing to open. The difference is structural and total —
- * **a load failure has NO JOBS AT ALL; a dead runner has JOBS THAT EXIST AND
- * ARE EMPTY.** Collapsing them would report every runner outage as a Lisa
- * regression. A skipped or cancelled run is excluded for the same reason: it
- * never intended to resolve anything, so calling it a load failure would be a
- * control that can only manufacture a red.
- * @module core/reusable-workflow-load-failure
- */
-/** How a run's relationship to reusable-workflow loading was resolved. */
-export type RunLoadClass = 
-/** In population, declared a reusable workflow, resolved none. */
-"load-failure"
-/** Jobs exist but are empty — a runner problem, not a parse problem. */
- | "dead-runner"
-/** Resolved at least one reusable workflow; it loaded. */
- | "resolved"
-/** The caller declares no reusable workflow, so the field says nothing. */
- | "out-of-population"
-/** Never intended to resolve anything. */
- | "skipped"
-/** Terminated without running and without failing. */
- | "inconclusive"
-/** Not finished; asking yet would read an unfinished field. */
- | "in-flight";
-/** The four run facts this classification needs. */
-export interface RunLoadFacts {
-    /** Whether the caller workflow declares a reusable workflow at all. */
-    readonly inPopulation: boolean;
-    /** Length of the run's `referenced_workflows` array. */
-    readonly referencedCount: number;
-    /** Number of jobs the run created. */
-    readonly jobCount: number;
-    /** The run's `conclusion`, or null while it is still in flight. */
-    readonly conclusion: string | null;
-}
-/**
- * Whether a caller workflow declares any reusable workflow.
- *
- * This is the population gate, and it is DERIVED from the caller's own source
- * rather than read from a roster. There is deliberately no list of known
- * callers or known upstream repositories anywhere in this module: a roster
- * would silently exclude every caller nobody remembered to add, which is the
- * failure mode this codebase already has a ticket for one level up.
- * @param source - Full text of a caller's workflow file
- * @returns True when at least one non-comment line calls a reusable workflow
- */
-export declare function callerDeclaresReusableWorkflow(source: string): boolean;
-/**
- * Classify what a finished run says about reusable-workflow loading.
- *
- * The order of these tests is the whole design, so it is worth stating: a run
- * that RESOLVED something is settled before the population gate is consulted,
- * because resolution is direct evidence that loading worked and the gate is
- * only a heuristic about whether the field can speak. That way an
- * under-detecting population gate can never manufacture a load-failure
- * verdict — it can only cause one to be missed, which is the direction a
- * detector should fail in.
- * @param facts - The four run facts
- * @returns The single class this run belongs to
- */
-export declare function classifyRunLoad(facts: RunLoadFacts): RunLoadClass;
-/** How far back a page set actually read. */
-export interface WindowScan {
-    /** Timestamp of the oldest run read, or null when none was read. */
-    readonly oldestSeen: string | null;
-    /** Timestamp the caller intended to cover back to. */
-    readonly windowStart: string;
-    /** Whether paging stopped because the history ran out. */
-    readonly exhausted: boolean;
-}
-/** Whether a scan covered its window, and why not when it did not. */
-export interface WindowVerdict {
-    /** True only when every run in the window was actually read. */
-    readonly covered: boolean;
-    /** Operator-readable reason, empty when covered. */
-    readonly reason: string;
-}
-/**
- * Whether a page set actually covered the window it claims to report on.
- *
- * A first implementation of this detector read one page of runs and filtered
- * by timestamp. On a busy repository the window's start fell off page one, so
- * it reported "OK, 100 runs inspected" across a period that contained four
- * known load failures. It was clean because it could not see. A scan that
- * cannot cover its window must report an ERROR, never a pass — a detector
- * that reports success for the range it failed to read is worse than no
- * detector, because it also retires the suspicion.
- * @param scan - How far back the page set reached
- * @returns Covered, or not covered with the reason
- */
-export declare function windowCoverage(scan: WindowScan): WindowVerdict;
-//# sourceMappingURL=reusable-workflow-load-failure.d.ts.map

package/dist/core/reusable-workflow-load-failure.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reusable-workflow-load-failure.d.ts","sourceRoot":"","sources":["../../src/core/reusable-workflow-load-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAyCH,0EAA0E;AAC1E,MAAM,MAAM,YAAY;AACtB,kEAAkE;AAChE,cAAc;AAChB,wEAAwE;GACtE,aAAa;AACf,0DAA0D;GACxD,UAAU;AACZ,2EAA2E;GACzE,mBAAmB;AACrB,0CAA0C;GACxC,SAAS;AACX,sDAAsD;GACpD,cAAc;AAChB,+DAA+D;GAC7D,WAAW,CAAC;AAEhB,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQtE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,CAYjE;AAED,6CAA6C;AAC7C,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,sDAAsD;IACtD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,CAgC9D"}

package/dist/core/reusable-workflow-load-failure.js

@@ -1,184 +0,0 @@
-/**
- * Distinguish a reusable workflow that failed to LOAD from one that failed to
- * RUN (CodySwannGT/lisa#3581).
- *
- * When an upstream commit makes a reusable workflow unparseable, GitHub
- * rejects the file before creating any job. The run has zero jobs, no
- * annotation naming the offending line, and a display `name` that degrades to
- * its `path` because GitHub never got as far as reading the `name:` key.
- * Nothing that watches for a failing JOB can see it — there is no red job to
- * open. Sibling module `core/reusable-workflow-pin` records the same failure
- * from the other end: "Actions creates zero jobs, so a required check is
- * ABSENT rather than red."
- *
- * ## Which moment this is open at
- *
- * On a pull request the exposure is CLOSED, and by something that already
- * exists: `check-skipped-required-checks --pr=<n>` raises
- * `absent_required_check` for a ruleset-required context that posted no
- * check-run at all, and a required context that never reports blocks the
- * merge regardless. Off a pull request — a `push` or `schedule` handler — no
- * arm looks. That is where the incident behind this ticket happened: a
- * consumer's handler failed five times in a row before anyone noticed, ~40
- * minutes after the upstream commit landed, with nothing changed on the
- * consumer side. So the gap is not that detection was never built; it is that
- * detection exists at exactly one moment and the failure occurs at every
- * moment.
- *
- * ## The one arm that discriminates, and the three that do not
- *
- * `referenced_workflows` on `GET /repos/{owner}/{repo}/actions/runs/{id}`
- * carries the resolved SHA of every reusable workflow a run actually used. A
- * caller that DECLARED one and RESOLVED ZERO did not parse; there is no other
- * way to reach that state.
- *
- * It is only meaningful INSIDE its population — runs whose caller declares a
- * reusable workflow at all. Measured on one consumer, 19 failing runs in a
- * day: the 5 in population all resolved at least one; the 14 outside it all
- * resolved zero. Read bare, the field reports 14 false positives out of 19.
- *
- * Three cheaper signals are each refuted by a measured run:
- *
- *  - `conclusion == "failure"` — six failures in that window, four load
- *    failures.
- *  - `jobs == 0` — one run IN the population resolved its workflow and still
- *    produced zero jobs, so an empty run is not the signature.
- *  - `name == path` — a display coincidence. Any workflow that omits `name:`
- *    satisfies it while perfectly healthy, so it corroborates and never
- *    decides.
- *
- * ## The false-red this must not become
- *
- * A dead runner produces a nearly identical run: `conclusion: failure`, no
- * useful output, nothing to open. The difference is structural and total —
- * **a load failure has NO JOBS AT ALL; a dead runner has JOBS THAT EXIST AND
- * ARE EMPTY.** Collapsing them would report every runner outage as a Lisa
- * regression. A skipped or cancelled run is excluded for the same reason: it
- * never intended to resolve anything, so calling it a load failure would be a
- * control that can only manufacture a red.
- * @module core/reusable-workflow-load-failure
- */
-/**
- * A job-level `uses:` naming a reusable workflow in another repository.
- *
- * The path shape is what discriminates, not a roster of known callers: a
- * reusable workflow is always `<owner>/<repo>/.github/workflows/<file>@<ref>`.
- * A step action is `<owner>/<repo>@<ref>` with no path, so `actions/checkout@v6`
- * cannot match — which matters, because reading step actions as declarations
- * is exactly what produced 14 false positives out of 19.
- */
-const CROSS_REPO_USES = /^[ \t]*uses:[ \t]*["']?[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+\/\.github\/workflows\/[A-Za-z0-9._-]+\.ya?ml@[^\s"'#]+/u;
-/**
- * A job-level `uses:` naming a reusable workflow in the caller's own
- * repository.
- *
- * Unlike the cross-repo arm this one is NOT backed by a measured run — the
- * ticket's evidence is all cross-repo. It is included because the path shape
- * is unambiguous and excluding it would leave local reusable workflows
- * undetectable, but if this detector ever reports a false positive, this is
- * the first line to suspect.
- */
-const LOCAL_USES = /^[ \t]*uses:[ \t]*["']?\.\/\.github\/workflows\/[A-Za-z0-9._-]+\.ya?ml/u;
-/** Whether a line is entirely a YAML comment. */
-const COMMENT_LINE = /^\s*#/u;
-/**
- * Conclusions that can be reached before a single job is created.
- *
- * `startup_failure` is GitHub's own name for this class and is the conclusion
- * a load failure most often carries; `failure` is what the runs measured for
- * this ticket carried. Anything else — `success`, `cancelled`, `neutral` — is
- * never a load failure, and treating it as one is how a detector starts
- * inventing reds.
- */
-const PRE_JOB_FAILURES = ["failure", "startup_failure"];
-/**
- * Whether a caller workflow declares any reusable workflow.
- *
- * This is the population gate, and it is DERIVED from the caller's own source
- * rather than read from a roster. There is deliberately no list of known
- * callers or known upstream repositories anywhere in this module: a roster
- * would silently exclude every caller nobody remembered to add, which is the
- * failure mode this codebase already has a ticket for one level up.
- * @param source - Full text of a caller's workflow file
- * @returns True when at least one non-comment line calls a reusable workflow
- */
-export function callerDeclaresReusableWorkflow(source) {
-    return source
-        .split("\n")
-        .some(line => !COMMENT_LINE.test(line) &&
-        (CROSS_REPO_USES.test(line) || LOCAL_USES.test(line)));
-}
-/**
- * Classify what a finished run says about reusable-workflow loading.
- *
- * The order of these tests is the whole design, so it is worth stating: a run
- * that RESOLVED something is settled before the population gate is consulted,
- * because resolution is direct evidence that loading worked and the gate is
- * only a heuristic about whether the field can speak. That way an
- * under-detecting population gate can never manufacture a load-failure
- * verdict — it can only cause one to be missed, which is the direction a
- * detector should fail in.
- * @param facts - The four run facts
- * @returns The single class this run belongs to
- */
-export function classifyRunLoad(facts) {
-    const { inPopulation, referencedCount, jobCount, conclusion } = facts;
-    if (conclusion === null)
-        return "in-flight";
-    if (conclusion === "skipped")
-        return "skipped";
-    // Resolution outranks the population gate: see the note above.
-    if (referencedCount > 0)
-        return "resolved";
-    if (!inPopulation)
-        return "out-of-population";
-    // Jobs that exist and are empty are a dead runner, not a parse failure.
-    if (jobCount > 0)
-        return "dead-runner";
-    if (!PRE_JOB_FAILURES.includes(conclusion))
-        return "inconclusive";
-    return "load-failure";
-}
-/**
- * Whether a page set actually covered the window it claims to report on.
- *
- * A first implementation of this detector read one page of runs and filtered
- * by timestamp. On a busy repository the window's start fell off page one, so
- * it reported "OK, 100 runs inspected" across a period that contained four
- * known load failures. It was clean because it could not see. A scan that
- * cannot cover its window must report an ERROR, never a pass — a detector
- * that reports success for the range it failed to read is worse than no
- * detector, because it also retires the suspicion.
- * @param scan - How far back the page set reached
- * @returns Covered, or not covered with the reason
- */
-export function windowCoverage(scan) {
-    const { oldestSeen, windowStart, exhausted } = scan;
-    // An exhausted history is covered even when it stops short: a repository
-    // younger than the window has no earlier runs to read, and refusing it
-    // would be a red nobody can ever clear.
-    if (exhausted)
-        return { covered: true, reason: "" };
-    if (oldestSeen === null) {
-        return {
-            covered: false,
-            reason: `read no runs at all, so it did not reach ${windowStart}. An empty read is not an empty window.`,
-        };
-    }
-    const oldest = Date.parse(oldestSeen);
-    const start = Date.parse(windowStart);
-    if (Number.isNaN(oldest) || Number.isNaN(start)) {
-        return {
-            covered: false,
-            reason: `could not read \`${oldestSeen}\` or \`${windowStart}\` as a timestamp, so it did not reach the start of the window. An unreadable bound is not a satisfied one.`,
-        };
-    }
-    if (oldest > start) {
-        return {
-            covered: false,
-            reason: `paging stopped at ${oldestSeen} and did not reach ${windowStart}, so any load failure older than that was never read. Page further, or narrow the window.`,
-        };
-    }
-    return { covered: true, reason: "" };
-}
-//# sourceMappingURL=reusable-workflow-load-failure.js.map

package/dist/core/reusable-workflow-load-failure.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reusable-workflow-load-failure.js","sourceRoot":"","sources":["../../src/core/reusable-workflow-load-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAEH;;;;;;;;GAQG;AACH,MAAM,eAAe,GACnB,iHAAiH,CAAC;AAEpH;;;;;;;;;GASG;AACH,MAAM,UAAU,GACd,yEAAyE,CAAC;AAE5E,iDAAiD;AACjD,MAAM,YAAY,GAAG,QAAQ,CAAC;AAE9B;;;;;;;;GAQG;AACH,MAAM,gBAAgB,GAAsB,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;AA+B3E;;;;;;;;;;GAUG;AACH,MAAM,UAAU,8BAA8B,CAAC,MAAc;IAC3D,OAAO,MAAM;SACV,KAAK,CAAC,IAAI,CAAC;SACX,IAAI,CACH,IAAI,CAAC,EAAE,CACL,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;QACxB,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CACxD,CAAC;AACN,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAAC,KAAmB;IACjD,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAEtE,IAAI,UAAU,KAAK,IAAI;QAAE,OAAO,WAAW,CAAC;IAC5C,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC/C,+DAA+D;IAC/D,IAAI,eAAe,GAAG,CAAC;QAAE,OAAO,UAAU,CAAC;IAC3C,IAAI,CAAC,YAAY;QAAE,OAAO,mBAAmB,CAAC;IAC9C,wEAAwE;IACxE,IAAI,QAAQ,GAAG,CAAC;QAAE,OAAO,aAAa,CAAC;IACvC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,UAAU,CAAC;QAAE,OAAO,cAAc,CAAC;IAClE,OAAO,cAAc,CAAC;AACxB,CAAC;AAoBD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAAC,IAAgB;IAC7C,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAEpD,yEAAyE;IACzE,uEAAuE;IACvE,wCAAwC;IACxC,IAAI,SAAS;QAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAEpD,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,4CAA4C,WAAW,yCAAyC;SACzG,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACtC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IACtC,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QAChD,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,oBAAoB,UAAU,WAAW,WAAW,6GAA6G;SAC1K,CAAC;IACJ,CAAC;IAED,IAAI,MAAM,GAAG,KAAK,EAAE,CAAC;QACnB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE,qBAAqB,UAAU,sBAAsB,WAAW,2FAA2F;SACpK,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;AACvC,CAAC"}

package/dist/core/reusable-workflow-load-scan.d.ts

@@ -1,92 +0,0 @@
-/**
- * Page a repository's run history and report reusable-workflow load failures
- * (CodySwannGT/lisa#3581).
- *
- * `core/reusable-workflow-load-failure` decides what a single run means. This
- * module is the part that has to READ enough runs for that verdict to be worth
- * anything, and it is a separate module because the two failure modes are
- * unrelated: one is a misclassification, the other is a detector reporting on
- * a window it never covered.
- *
- * The page fetcher is injected rather than imported. That is not a testing
- * convenience — it is the only way the paging and coverage logic here can be
- * exercised at all, because the alternative is a live API call whose rate
- * limit decides whether the suite passes. Every rule below is proven against
- * fixture pages; the `gh api` adapter that supplies real ones is a caller's
- * job and is deliberately not part of this module.
- * @module core/reusable-workflow-load-scan
- */
-import { type RunLoadClass } from "./reusable-workflow-load-failure.js";
-/** One run as this scan needs to see it. */
-export interface ScannedRun {
-    /** The run's id, for the operator to open. */
-    readonly id: number;
-    /** The caller workflow's path, e.g. `.github/workflows/nightly.yml`. */
-    readonly path: string;
-    /** ISO timestamp the run was created. */
-    readonly createdAt: string;
-    /** Length of the run's `referenced_workflows` array. */
-    readonly referencedCount: number;
-    /** Number of jobs the run created. */
-    readonly jobCount: number;
-    /** The run's `conclusion`, or null while in flight. */
-    readonly conclusion: string | null;
-}
-/** One page of run history. */
-export interface RunPage {
-    /** Runs on this page, newest first, as the API returns them. */
-    readonly runs: readonly ScannedRun[];
-    /** Whether another page exists after this one. */
-    readonly hasMore: boolean;
-}
-/** What the scan needs in order to run. */
-export interface ScanRequest {
-    /** Fetches one 1-based page of run history. */
-    readonly fetchPage: (page: number) => Promise<RunPage>;
-    /** ISO timestamp to cover back to. */
-    readonly windowStart: string;
-    /** Whether a caller path declares a reusable workflow. */
-    readonly inPopulation: (path: string) => boolean;
-    /** Hard cap on pages read, so a busy repository cannot spin forever. */
-    readonly maxPages: number;
-}
-/** One run the scan is reporting on. */
-export interface ScanFinding {
-    /** The run's id. */
-    readonly id: number;
-    /** The caller workflow's path. */
-    readonly path: string;
-    /** What this run turned out to be. */
-    readonly verdict: RunLoadClass;
-}
-/** The scan's answer. */
-export interface ScanResult {
-    /** Runs classified as load failures. */
-    readonly loadFailures: readonly ScanFinding[];
-    /** How many runs were read. */
-    readonly inspected: number;
-    /**
-     * True only when the window was covered AND the scan can speak for it.
-     *
-     * A false here is an ERROR, not a pass with a caveat: the whole reason this
-     * field exists is that an earlier implementation read one page, missed four
-     * known load failures that had fallen off it, and reported "OK, 100 runs
-     * inspected". A detector that reports success for a range it failed to read
-     * also retires the suspicion that would have found the failures by hand.
-     */
-    readonly covered: boolean;
-    /** Why the window was not covered, empty when it was. */
-    readonly reason: string;
-}
-/**
- * Read run history until the window is covered, then report load failures.
- *
- * Paging stops on the first of three conditions: a run older than the window
- * was seen, the history ran out, or `maxPages` was reached. Only the first
- * two are coverage; hitting the cap leaves `covered` false, because a cap is
- * a budget the operator set and not evidence about the runs beyond it.
- * @param request - Fetcher, window, population test, and page cap
- * @returns Findings plus whether the window was actually covered
- */
-export declare function scanForLoadFailures(request: ScanRequest): Promise<ScanResult>;
-//# sourceMappingURL=reusable-workflow-load-scan.d.ts.map

package/dist/core/reusable-workflow-load-scan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reusable-workflow-load-scan.d.ts","sourceRoot":"","sources":["../../src/core/reusable-workflow-load-scan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,qCAAqC,CAAC;AAE7C,4CAA4C;AAC5C,MAAM,WAAW,UAAU;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uDAAuD;IACvD,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,+BAA+B;AAC/B,MAAM,WAAW,OAAO;IACtB,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,CAAC;IACrC,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,2CAA2C;AAC3C,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACjD,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,wCAAwC;AACxC,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;CAChC;AAED,yBAAyB;AACzB,MAAM,WAAW,UAAU;IACzB,wCAAwC;IACxC,QAAQ,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,+BAA+B;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAyED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC,CAgCrB"}

package/dist/core/reusable-workflow-load-scan.js

@@ -1,108 +0,0 @@
-/**
- * Page a repository's run history and report reusable-workflow load failures
- * (CodySwannGT/lisa#3581).
- *
- * `core/reusable-workflow-load-failure` decides what a single run means. This
- * module is the part that has to READ enough runs for that verdict to be worth
- * anything, and it is a separate module because the two failure modes are
- * unrelated: one is a misclassification, the other is a detector reporting on
- * a window it never covered.
- *
- * The page fetcher is injected rather than imported. That is not a testing
- * convenience — it is the only way the paging and coverage logic here can be
- * exercised at all, because the alternative is a live API call whose rate
- * limit decides whether the suite passes. Every rule below is proven against
- * fixture pages; the `gh api` adapter that supplies real ones is a caller's
- * job and is deliberately not part of this module.
- * @module core/reusable-workflow-load-scan
- */
-import { classifyRunLoad, windowCoverage, } from "./reusable-workflow-load-failure.js";
-/**
- * Whether a run predates the window, so everything after it can be ignored.
- * @param run - The run being considered
- * @param windowStart - ISO timestamp the scan intends to cover back to
- * @returns True only when this run is at or before the start of the window
- */
-function reachedWindow(run, windowStart) {
-    const created = Date.parse(run.createdAt);
-    const start = Date.parse(windowStart);
-    // An unparseable timestamp must not read as "we are past the window" —
-    // that would end the scan early and call the short read complete.
-    if (Number.isNaN(created) || Number.isNaN(start))
-        return false;
-    return created <= start;
-}
-/**
- * Classify one run through the shared decision.
- * @param run - The run being classified
- * @param inPopulation - Whether this run's caller declares a reusable workflow
- * @returns The run's id, caller path, and verdict
- */
-function findingFor(run, inPopulation) {
-    return {
-        id: run.id,
-        path: run.path,
-        verdict: classifyRunLoad({
-            inPopulation,
-            referencedCount: run.referencedCount,
-            jobCount: run.jobCount,
-            conclusion: run.conclusion,
-        }),
-    };
-}
-/**
- * Fold one page into the running scan state.
- * @param state - Everything the scan has accumulated so far
- * @param page - The page just fetched
- * @param request - The scan request, for its window and population test
- * @returns The scan state after absorbing this page
- */
-function absorb(state, page, request) {
-    const findings = page.runs.map(run => findingFor(run, request.inPopulation(run.path)));
-    const oldest = page.runs.at(-1)?.createdAt ?? state.oldestSeen;
-    const reached = page.runs.some(run => reachedWindow(run, request.windowStart));
-    return {
-        findings: [...state.findings, ...findings],
-        inspected: state.inspected + page.runs.length,
-        oldestSeen: oldest,
-        exhausted: !page.hasMore,
-        done: reached || !page.hasMore,
-    };
-}
-/**
- * Read run history until the window is covered, then report load failures.
- *
- * Paging stops on the first of three conditions: a run older than the window
- * was seen, the history ran out, or `maxPages` was reached. Only the first
- * two are coverage; hitting the cap leaves `covered` false, because a cap is
- * a budget the operator set and not evidence about the runs beyond it.
- * @param request - Fetcher, window, population test, and page cap
- * @returns Findings plus whether the window was actually covered
- */
-export async function scanForLoadFailures(request) {
-    const initial = {
-        findings: [],
-        inspected: 0,
-        oldestSeen: null,
-        exhausted: false,
-        done: false,
-    };
-    const final = await Array.from({ length: request.maxPages }, (_unused, index) => index + 1).reduce(async (carried, pageNumber) => {
-        const state = await carried;
-        if (state.done)
-            return state;
-        return absorb(state, await request.fetchPage(pageNumber), request);
-    }, Promise.resolve(initial));
-    const coverage = windowCoverage({
-        oldestSeen: final.oldestSeen,
-        windowStart: request.windowStart,
-        exhausted: final.exhausted,
-    });
-    return {
-        loadFailures: final.findings.filter(finding => finding.verdict === "load-failure"),
-        inspected: final.inspected,
-        covered: coverage.covered,
-        reason: coverage.reason,
-    };
-}
-//# sourceMappingURL=reusable-workflow-load-scan.js.map

package/dist/core/reusable-workflow-load-scan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"reusable-workflow-load-scan.js","sourceRoot":"","sources":["../../src/core/reusable-workflow-load-scan.ts"],"names":[],"mappings":"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"}