@invarn/cibuild 2.9.4 → 2.9.7

package/dist/src/commands/android-scanner.d.ts

@@ -1,250 +0,0 @@
-export type WarningSeverity = "warning" | "info";
-export type WarningCategory = "missing-file" | "env-var" | "gradle-property" | "signing-config" | "build-config" | "firebase" | "secrets-plugin";
-export interface BuildWarning {
-    category: WarningCategory;
-    severity: WarningSeverity;
-    message: string;
-    hint?: string;
-    location?: string;
-}
-export interface ScanResult {
-    warnings: BuildWarning[];
-    /** Highest Java version requirement detected in Gradle files (e.g. 17, 21). */
-    detectedJavaVersion?: number;
-    /**
-     * The file that asked for it, when the level came from outside Gradle —
-     * `.github/workflows/Build.yml`, `.java-version`, `.tool-versions`.
-     *
-     * The scan computed this and dropped it, so a warning could name a version
-     * with no provenance and send a reader looking through every Gradle file for
-     * a number that is not in any of them. Undefined when the level came from a
-     * Gradle file, or when a Gradle file asked for at least as much.
-     */
-    detectedJavaVersionSource?: string;
-    /** Gradle version the wrapper pins, e.g. "8.9". Undefined when there is no wrapper. */
-    detectedGradleVersion?: string;
-    /** Build types, product flavors, and all variant combinations detected in Gradle files. */
-    buildVariants: BuildVariants;
-    /**
-     * The property names the build reads out of the properties file the Secrets
-     * Gradle plugin loads — sorted, deduplicated, empty when no module applies
-     * the plugin.
-     *
-     * **An empty properties file fixes "file missing", not "field missing".**
-     * The plugin turns each key of that file into a `BuildConfig` constant and a
-     * manifest placeholder, so a checkout without the file compiles neither.
-     * Supplying an empty stand-in gets the build past the plugin's own throw and
-     * then fails one step later, inside Gradle, at the first reference to a field
-     * that was never generated. These are those names: what a stand-in has to
-     * declare for the reference to resolve.
-     *
-     * Data, not prose — deliberately not more `warnings`. A warning is a sentence
-     * for a human to read; this is a list for a generator to consume, and sharing
-     * one channel between them means the generator has to parse English.
-     *
-     * Coarse on purpose. A name here that some other plugin turns out to
-     * generate costs one unused line in a properties file; a name missing from
-     * here costs the build.
-     */
-    missingPropertyKeys: string[];
-}
-export interface BuildVariants {
-    /** Build types found, e.g. ["debug", "release", "staging"]. Always includes debug + release. */
-    buildTypes: string[];
-    /** Product flavors found, e.g. ["dev", "prod"]. Empty if the project has no flavors. */
-    productFlavors: string[];
-    /** All variant combinations. Equals buildTypes when no product flavors are defined. */
-    variants: string[];
-}
-/**
- * Removes `if (file("…").exists()) { … }` blocks from build-file content.
- *
- * A plugin applied inside one of these is *conditional on a file the build
- * may not have*. Projects use the idiom precisely so a checkout without the
- * credential still builds:
- *
- *     if (file("google-services.json").exists()) {
- *       apply(plugin = libs.plugins.gms.googleServices.get().pluginId)
- *     }
- *
- * Reading the declaration and ignoring the guard turns "this project builds
- * fine without a credential" into "this project cannot build without one" —
- * a warning that sends the user looking for a file the build never asks for.
- *
- * Brace matching skips quoted strings so a `{` inside a literal cannot end
- * the block early. Anything it cannot match to a close brace is left alone:
- * losing a real declaration is worse than keeping a guarded one.
- */
-export declare function stripExistenceGuardedBlocks(content: string): string;
-/** The builds a settings file composes in, e.g. `includeBuild("build-logic")`. */
-export declare function parseIncludedBuilds(content: string): string[];
-/**
- * A Java version pinned outside Gradle, and the file that pins it.
- *
- * `mihonapp/mihon` declares no Java level in any Gradle file and pins 21 in
- * `.github/.java-version`, which its own workflows consume through
- * `setup-java`'s `java-version-file:`. The project says what it needs; it
- * just does not say it in Gradle, and reading only Gradle files scanned it as
- * "nothing declared" and ran it on the default. Across the thirty clones,
- * three repositories pin with a version file and ten name a version in a
- * workflow.
- *
- * A pin is a **floor**, folded in with `Math.max` like every other
- * declaration — not an override.
- */
-export declare function detectPinnedJavaVersion(root: string): {
-    version: number;
-    source: string;
-} | undefined;
-/**
- * The Gradle version a wrapper pins, read out of its `distributionUrl`.
- * `…/gradle-8.9-bin.zip` → `8.9`.
- *
- * This bounds which JDK the project can build on: Gradle refuses to start on
- * a JDK newer than it knows about, so the wrapper is a hard ceiling that no
- * `sourceCompatibility` declaration can raise.
- *
- * The trailing `-bin` / `-all` belongs to the file name rather than the
- * version, and a release candidate spends two more hyphens on `-rc-1`, so the
- * version group has to be able to give its last segment back.
- */
-export declare function parseGradleWrapperVersion(content: string): string | undefined;
-/**
- * The newest Java release a given Gradle version can run on, or undefined
- * when the version string says nothing usable.
- */
-export declare function gradleJavaCeiling(gradleVersion: string | undefined): number | undefined;
-/** The oldest Java release a given Gradle version will start on. */
-export declare function gradleJavaFloor(gradleVersion: string | undefined): number | undefined;
-/**
- * The JDKs a build machine installs, and therefore the only values the
- * generated `set-java-version` step can satisfy.
- *
- * 11 joined the images on 2026-09-05, for Gradle 5.x and 6.x — which cannot
- * *start* on 17, whatever the sources declare. It is a fallback, never a
- * preference: the selection takes the newest JDK that fits, so 11 is reached
- * only when a wrapper's ceiling leaves nothing else.
- *
- * 8 and 25 joined on 2026-09-07, the companion half of the "newest the
- * wrapper allows" decision — the images carry every JDK we find a project
- * asking for, rather than a project bending to what they carry. 8 is 11's
- * argument one line further back (Gradle 4.x tops out at Java 8); 25 covers
- * the six repositories in the 150-repo corpus that declare a level above 21.
- * Nothing reaches 8 unless a wrapper ceiling forces it.
- */
-export declare const AVAILABLE_JAVA_VERSIONS: number[];
-/**
- * The newest JDK a build machine carries.
- *
- * It is no longer what the chooser falls back to. It used to be: with no JDK
- * satisfying both the sources and the wrapper, `runnableJavaVersion` returned
- * this — which on a project pinning a modern Java level under an old Gradle
- * wrapper is a JDK **above** that wrapper's ceiling, and the build dies at
- * `:app:processDebugMainManifest` with "module java.base does not opens
- * java.io to unnamed module". A number above the ceiling is not a fallback;
- * it is the failure, chosen deliberately and reported as success.
- */
-export declare const NEWEST_AVAILABLE_JAVA_VERSION: number;
-/** Why the chooser answered as it did. See {@link chooseJavaVersion}. */
-export type JavaVersionKind = "unknown" | "satisfies" | "capped-by-wrapper" | "above-runners" | "wrapper-below-runners";
-/** The JDK choice and the reason for it, resolved together. */
-export interface JavaVersionChoice {
-    /** The JDK to write, or undefined where no answer exists. */
-    version: number | undefined;
-    kind: JavaVersionKind;
-    /** The highest level the project asked for, or 0 if it asked for none. */
-    declared: number;
-    /** The newest JDK the wrapper can start on, or undefined if unreadable. */
-    ceiling: number | undefined;
-    installed: number[];
-}
-/**
- * The JDK to build on, with the reason attached — one place where the
- * constraints are resolved, so the answer and the explanation cannot disagree.
- *
- * They used to. The chooser fell back to the newest installed JDK whenever
- * nothing satisfied both constraints, and the sentence beside it had two
- * branches — a ceiling below every installed JDK, and a declaration above
- * every installed JDK — so the commonest shape of all fell through both and
- * said nothing at all. A project pinning Java 12 against a Gradle wrapper that
- * runs on 11 at most got Java 25 and silence.
- *
- * Three facts decide it:
- *
- *  - **What the build machine has.** Only `AVAILABLE_JAVA_VERSIONS` exist, so
- *    a project declaring 30 cannot simply be given 30.
- *  - **What Gradle can run on.** The wrapper sets a ceiling that source
- *    compatibility cannot raise: Gradle starts before it reads a single
- *    `sourceCompatibility`.
- *  - **What the sources ask for.** A declaration is a floor, not an exact
- *    request — a project declaring 11 compiles fine on 21.
- *
- * `kind` distinguishes the five outcomes:
- *
- *  - `unknown` — nothing declared and no readable wrapper. Nothing to go on
- *    and nothing to say.
- *  - `satisfies` — an installed JDK meets both the floor and the ceiling.
- *  - `capped-by-wrapper` — nothing meets both, and the wrapper is why. The
- *    ceiling is hard and the declaration is a preference, so the newest JDK
- *    the wrapper *can* run is the answer, and the caller says so.
- *  - `above-runners` — the declaration is above every installed JDK, and that
- *    rather than the wrapper is what binds. **No answer**: asking for it would
- *    fail when the JDK is selected, and quietly picking a lower one would be
- *    the guess this exists to avoid.
- *  - `wrapper-below-runners` — the ceiling is below every installed JDK. No
- *    answer exists.
- *
- * `above-runners` is checked before `capped-by-wrapper` so a project declaring
- * 99 against a modern wrapper is told about the machines rather than about its
- * wrapper: both bind, and the one it can act on is the one worth naming.
- */
-export declare function chooseJavaVersion(detectedJavaVersion: number | undefined, gradleVersion?: string): JavaVersionChoice;
-/**
- * The Java version to write into a generated pipeline: the **newest**
- * available JDK that satisfies both what the sources declare and what the
- * Gradle wrapper can run on.
- *
- * DECIDED 2026-09-06 (Alex), reversing Invarn PRD decision #15 ("17 is the
- * JDK whenever nothing forces otherwise"). The thirty-app study measured the
- * cost of preferring 17 in one direction and none in the other: two rows
- * failed because 17 was too *low* for a build plugin's own runtime
- * requirement, and no row failed because 21 was too high. A project targeting
- * 17 runs fine on 21; never the reverse.
- *
- * Source compatibility is a floor, not an exact request. Gradle starts before
- * it reads a single `sourceCompatibility`, so a wrapper pinning an old Gradle
- * caps the JDK no matter what the sources say — which is why the ceiling
- * above had to learn minor versions before this could ship.
- */
-export declare function runnableJavaVersion(detectedJavaVersion: number | undefined, gradleVersion?: string): number | undefined;
-/**
- * What the choice could not honour, as a sentence, or undefined when it
- * honoured everything.
- *
- * Silence is the failure this exists to prevent: a pipeline that quietly
- * overruled what a project asked for reads as the project's own problem, and
- * the commonest shape of all — an old wrapper under a modern declaration — was
- * the one that used to fall through every branch.
- *
- * `source` names the file that asked, when the caller knows it. The scan now
- * returns it, so "asks for Java 12" can become "asks for Java 12
- * (.github/workflows/Build.yml)" — a version with no provenance sends a reader
- * looking through every Gradle file for a number that is not in any of them.
- */
-export declare function javaVersionProblem(detectedJavaVersion: number | undefined, gradleVersion?: string, source?: string): string | undefined;
-/**
- * Detects build types and product flavors from Gradle files by static parsing,
- * falling back to the module's source sets for the flavors when no Gradle file
- * declares any (see `flavorsFromSourceSets`).
- *
- * Always includes "debug" and "release" as defaults.
- *
- * The fallback only ever runs when the literal scan found nothing, so a
- * project whose Gradle files declare flavors is decided by those files exactly
- * as before. Merging the two would let a leftover directory invent a flavor
- * the build does not have.
- */
-export declare function detectBuildVariants(gradleFiles: string[]): BuildVariants;
-export declare function scanAndroidProject(projectRoot: string): Promise<ScanResult>;
-export declare function formatScanResult(result: ScanResult): string;
-//# sourceMappingURL=android-scanner.d.ts.map

package/dist/src/commands/android-scanner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"android-scanner.d.ts","sourceRoot":"","sources":["../../../src/commands/android-scanner.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjD,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,SAAS,GACT,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,GACd,UAAU,GACV,gBAAgB,CAAC;AAErB,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,+EAA+E;IAC/E,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;OAQG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,uFAAuF;IACvF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2FAA2F;IAC3F,aAAa,EAAE,aAAa,CAAC;IAC7B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,gGAAgG;IAChG,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,wFAAwF;IACxF,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAolBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcnE;AAyKD,kFAAkF;AAClF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAO7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GACX;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA8CjD;AA2BD;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG7E;AAQD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAsBvF;AAED,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAIrF;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,UAAsB,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,QAAuC,CAAC;AAElF,yEAAyE;AACzE,MAAM,MAAM,eAAe,GACvB,SAAS,GACT,WAAW,GACX,mBAAmB,GACnB,eAAe,GACf,uBAAuB,CAAC;AAE5B,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,6DAA6D;IAC7D,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,eAAe,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,iBAAiB,CAC/B,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,iBAAiB,CAkCnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,GACrB,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,mBAAmB,EAAE,MAAM,GAAG,SAAS,EACvC,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,CAAC,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAwBpB;AAwLD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,CAsCxE;AAMD,wBAAsB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA8RjF;AAgBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAqE3D"}