@invarn/cibuild 2.6.7 → 2.6.8

package/dist/src/commands/ios-scheme-ranking.test.js

@@ -0,0 +1,152 @@
+/**
+ * Which scheme an iOS pipeline builds.
+ *
+ * It used to be the first `.xcscheme` the filesystem listed, and that has a
+ * rule: a space (0x20) sorts before a period (0x2E), so
+ * `"<App> <Suffix>.xcscheme"` always lists before `"<App>.xcscheme"`. An app
+ * named after its project loses to its own extension or tvOS companion every
+ * time. Four of the eight iOS rows that built in the thirty-app study got a
+ * non-app scheme:
+ *
+ *   Stay       → "Stay Extension" → "There are no test bundles available to test"
+ *   Swiftfin   → "Swiftfin tvOS"  → "Unable to find a destination matching … iOS Simulator"
+ *   wikipedia  → "ContinueReadingWidget"  (masked by an earlier failure)
+ *   pocketcasts → "NotificationContent"   (masked by an earlier failure)
+ *
+ * The `.xcscheme` XML says what each scheme is, so the ranking reads it.
+ */
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { rankSchemes } from "./ios-scanner.js";
+let root;
+beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "cibuild-scheme-"));
+});
+afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+/** An `.xcscheme` with the parts the ranking reads, in Xcode's own shape. */
+function scheme(project, name, { runnable, testable }) {
+    const dir = join(root, `${project}.xcodeproj`, "xcshareddata", "xcschemes");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${name}.xcscheme`), `<?xml version="1.0" encoding="UTF-8"?>
+<Scheme LastUpgradeVersion = "1600" version = "1.7">
+   <TestAction buildConfiguration = "Debug">
+      <Testables>${testable
+        ? `
+         <TestableReference skipped = "NO">
+            <BuildableReference BuildableName = "${name}Tests.xctest" />
+         </TestableReference>`
+        : ""}
+      </Testables>
+   </TestAction>
+   <LaunchAction buildConfiguration = "Debug">${runnable
+        ? `
+      <BuildableProductRunnable runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BuildableName = "${runnable}"
+            BlueprintName = "${name}"
+            ReferencedContainer = "container:${project}.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>`
+        : ""}
+   </LaunchAction>
+</Scheme>
+`);
+}
+/** The ranking, given the order `readdirSync` happens to produce. */
+const pick = (projectPath, names) => rankSchemes(root, projectPath, names)[0];
+describe("rankSchemes", () => {
+    // shenruisi/Stay. "Stay Extension" listed first and was written into the
+    // pipeline; the app is named after its project.
+    test("prefers the scheme named after the project", () => {
+        scheme("Stay", "Stay", { runnable: "Stay.app", testable: true });
+        scheme("Stay", "Stay Extension", { runnable: "Stay.app" });
+        expect(pick("Stay.xcodeproj", ["Stay Extension", "Stay"])).toBe("Stay");
+    });
+    // jellyfin/Swiftfin. Every destination "Swiftfin tvOS" offered was tvOS.
+    test("prefers the project's own name over a platform companion", () => {
+        scheme("Swiftfin", "Swiftfin", { runnable: "Swiftfin iOS.app" });
+        scheme("Swiftfin", "Swiftfin tvOS", { runnable: "Swiftfin tvOS.app" });
+        expect(pick("Swiftfin.xcodeproj", ["Swiftfin tvOS", "Swiftfin"])).toBe("Swiftfin");
+    });
+    // Finb/Bark builds from a workspace; the schemes live in the project inside.
+    test("matches the workspace basename too", () => {
+        scheme("Bark", "Bark", { runnable: "Bark.app", testable: true });
+        scheme("Bark", "NotificationContentExtension", { runnable: "Bark.app" });
+        expect(pick("Bark.xcworkspace", ["Bark", "NotificationContentExtension"])).toBe("Bark");
+    });
+    // Automattic/pocket-casts-ios: the scheme is `pocketcasts`, the project is
+    // `podcasts.xcodeproj`, so no name matches. What separates them is that one
+    // launches an app and has tests, and the others are extensions.
+    test("falls back to an app scheme with tests when no name matches", () => {
+        scheme("podcasts", "pocketcasts", { runnable: "podcasts.app", testable: true });
+        scheme("podcasts", "NotificationContent", { runnable: "podcasts.app" });
+        scheme("podcasts", "PocketCastsWatch", { runnable: "PocketCastsWatch.app" });
+        expect(pick("podcasts.xcodeproj", ["NotificationContent", "PocketCastsWatch", "pocketcasts"])).toBe("pocketcasts");
+    });
+    // thebaselab/codeapp: `Code App` launches `Code.app` and declares no tests
+    // at all; `Code UI` has two test bundles and launches `CodeUI.app`. The
+    // product named after the project is the app; tests are a weaker signal.
+    test("prefers the product named after the project over one with tests", () => {
+        scheme("Code", "Code App", { runnable: "Code.app" });
+        scheme("Code", "Code UI", { runnable: "CodeUI.app", testable: true });
+        scheme("Code", "extension", { runnable: "CodeUI.app" });
+        expect(pick("Code.xcodeproj", ["Code App", "Code UI", "extension"])).toBe("Code App");
+    });
+    // oblador/hush: `Hush iOS` and `Hush macOS`, project `Hush.xcodeproj`.
+    test("prefers the iOS variant over the macOS one", () => {
+        scheme("Hush", "Hush iOS", { runnable: "Hush.app", testable: true });
+        scheme("Hush", "Hush macOS", { runnable: "Hush.app" });
+        expect(pick("Hush.xcodeproj", ["Hush iOS", "Hush macOS"])).toBe("Hush iOS");
+    });
+    // home-assistant/iOS: App-Debug and App-Release, both runnable, both with
+    // tests. Debug is what the template builds.
+    test("prefers the debug configuration when two app schemes tie", () => {
+        scheme("HomeAssistant", "App-Debug", { runnable: "Home Assistant.app", testable: true });
+        scheme("HomeAssistant", "App-Release", { runnable: "Home Assistant.app", testable: true });
+        expect(pick("HomeAssistant.xcodeproj", ["App-Debug", "App-Release"])).toBe("App-Debug");
+    });
+    test("prefers the shortest name when nothing else separates them", () => {
+        scheme("Demo", "App", { runnable: "App.app", testable: true });
+        scheme("Demo", "App With A Longer Name", { runnable: "App.app", testable: true });
+        expect(pick("Demo.xcodeproj", ["App With A Longer Name", "App"])).toBe("App");
+    });
+    // The whole defect: a space sorts before a period, so the companion is
+    // always listed first. The answer must not depend on that.
+    test("gives the same answer whatever order the filesystem lists", () => {
+        scheme("Stay", "Stay", { runnable: "Stay.app", testable: true });
+        scheme("Stay", "Stay Extension", { runnable: "Stay.app" });
+        scheme("Stay", "Stay Widget", { runnable: "Stay.app" });
+        const orders = [
+            ["Stay Extension", "Stay Widget", "Stay"],
+            ["Stay", "Stay Extension", "Stay Widget"],
+            ["Stay Widget", "Stay", "Stay Extension"],
+        ];
+        for (const order of orders) {
+            expect([order.join(","), pick("Stay.xcodeproj", order)]).toEqual([
+                order.join(","),
+                "Stay",
+            ]);
+        }
+    });
+    test("keeps every scheme in the list, only reordered", () => {
+        scheme("Stay", "Stay", { runnable: "Stay.app", testable: true });
+        scheme("Stay", "Stay Extension", { runnable: "Stay.app" });
+        const ranked = rankSchemes(root, "Stay.xcodeproj", ["Stay Extension", "Stay"]);
+        expect([...ranked].sort()).toEqual(["Stay", "Stay Extension"]);
+    });
+    test("leaves a single scheme alone", () => {
+        scheme("Solo", "Solo", { runnable: "Solo.app", testable: true });
+        expect(pick("Solo.xcodeproj", ["Solo"])).toBe("Solo");
+    });
+    // A scheme with no shared `.xcscheme` on disk — `detectSchemes` falls back
+    // to the project name — must still come out first, not be ranked below a
+    // companion it cannot read.
+    test("keeps the order it was given when nothing can be read", () => {
+        expect(pick("Solo.xcodeproj", ["Solo", "Other"])).toBe("Solo");
+    });
+});
+//# sourceMappingURL=ios-scheme-ranking.test.js.map

package/dist/src/shared/detect-project.d.ts

@@ -1,11 +1,23 @@
 export type MobileProjectType = "android" | "ios" | "kmm";
+declare function isDirectory(path: string): boolean;
 /**
  * Detects whether the given directory is the root of an Android, iOS, or
  * KMM project. Returns the detected project type, or null if none match.
  *
- * KMM is checked before Android because both have Gradle files; KMM is
- * distinguished by the presence of an `iosApp/`, `shared/`, or
- * `composeApp/` directory alongside the Gradle files.
+ * KMM is checked before Android because both have Gradle files, and it is
+ * decided by what the repository *is*: a module that applies the Kotlin
+ * Multiplatform plugin, and an Apple consumer within one directory of the
+ * root. The three conventional directory names (`shared`, `composeApp`,
+ * `iosApp`) used to be the whole rule, and were wrong in both directions —
+ * `joreilly/PeopleInSpace` (`common` + `PeopleInSpaceSwiftUI/`) and
+ * `openMF/mifos-pay` (`cmp-shared` + `cmp-ios/`) were detected `android`,
+ * while an Android-only project with a module *named* `shared` was detected
+ * KMM and given a pipeline with an xcodebuild step aimed at nothing.
+ *
+ * Without an Apple consumer it is Android: an Android-only Kotlin
+ * Multiplatform library builds perfectly well with the Android template.
  */
 export declare function detectMobileProjectRoot(dir: string): MobileProjectType | null;
+/** Kept for callers that only ask whether a path is a directory. */
+export { isDirectory };
 //# sourceMappingURL=detect-project.d.ts.map

package/dist/src/shared/detect-project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detect-project.d.ts","sourceRoot":"","sources":["../../../src/shared/detect-project.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA0C7E"}
+{"version":3,"file":"detect-project.d.ts","sourceRoot":"","sources":["../../../src/shared/detect-project.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,CAAC;AAoB1D,iBAAS,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAM1C;AA+ED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAiC7E;AAED,oEAAoE;AACpE,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/src/shared/detect-project.js

@@ -1,12 +1,131 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
+import { declaresKotlinMultiplatformPlugin, parseSettingsModules, } from "./gradle-settings.js";
+/** Directories that hold a copy of a project rather than the source of it. */
+const NON_SOURCE_DIRS = new Set([
+    ".git",
+    ".gradle",
+    ".idea",
+    "build",
+    "DerivedData",
+    "Pods",
+    "node_modules",
+]);
+/**
+ * The module names the multiplatform wizards write. Tried first because
+ * they are right most of the time and cost two `existsSync` calls — but they
+ * are a fast path through the rule below, not the rule.
+ */
+const CONVENTIONAL_MULTIPLATFORM_MODULES = ["shared", "composeApp", "common"];
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function readOrNull(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** True when this directory holds something an Apple build reads. */
+function holdsAppleConsumer(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return false;
+    }
+    if (entries.some((e) => e.endsWith(".xcodeproj") || e.endsWith(".xcworkspace"))) {
+        return true;
+    }
+    if (entries.includes("Podfile"))
+        return true;
+    // An XcodeGen spec generates the project during the build, so the absence
+    // of a `.xcodeproj` says nothing about whether there is an iOS app.
+    if (entries.includes("project.yml")) {
+        const content = readOrNull(resolve(dir, "project.yml"));
+        return content !== null && /^\s*targets\s*:/m.test(content);
+    }
+    return false;
+}
+/**
+ * An Apple consumer at the root or one directory below it.
+ *
+ * One level, because that is where every KMM repository in the thirty-app
+ * study put its iOS app — under names as varied as `iosApp`,
+ * `PeopleInSpaceSwiftUI`, `cmp-ios` and `cmp-iosApp` — and because looking
+ * deeper starts finding sample apps inside library modules.
+ */
+function hasAppleConsumerWithinOneLevel(root) {
+    if (holdsAppleConsumer(root))
+        return true;
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (NON_SOURCE_DIRS.has(entry.name) || entry.name.startsWith("."))
+            continue;
+        if (entry.name.endsWith(".xcodeproj") || entry.name.endsWith(".xcworkspace"))
+            continue;
+        if (holdsAppleConsumer(resolve(root, entry.name)))
+            return true;
+    }
+    return false;
+}
+function moduleAppliesMultiplatformPlugin(root, module) {
+    for (const name of ["build.gradle.kts", "build.gradle"]) {
+        const content = readOrNull(resolve(root, module, name));
+        if (content !== null && declaresKotlinMultiplatformPlugin(content))
+            return true;
+    }
+    return false;
+}
+/** True when any module this build includes applies the Kotlin MP plugin. */
+function hasMultiplatformModule(root) {
+    for (const module of CONVENTIONAL_MULTIPLATFORM_MODULES) {
+        if (moduleAppliesMultiplatformPlugin(root, module))
+            return true;
+    }
+    for (const name of ["settings.gradle", "settings.gradle.kts"]) {
+        const content = readOrNull(resolve(root, name));
+        if (content === null)
+            continue;
+        for (const module of parseSettingsModules(content)) {
+            if (moduleAppliesMultiplatformPlugin(root, module))
+                return true;
+        }
+    }
+    return false;
+}
 /**
  * Detects whether the given directory is the root of an Android, iOS, or
  * KMM project. Returns the detected project type, or null if none match.
  *
- * KMM is checked before Android because both have Gradle files; KMM is
- * distinguished by the presence of an `iosApp/`, `shared/`, or
- * `composeApp/` directory alongside the Gradle files.
+ * KMM is checked before Android because both have Gradle files, and it is
+ * decided by what the repository *is*: a module that applies the Kotlin
+ * Multiplatform plugin, and an Apple consumer within one directory of the
+ * root. The three conventional directory names (`shared`, `composeApp`,
+ * `iosApp`) used to be the whole rule, and were wrong in both directions —
+ * `joreilly/PeopleInSpace` (`common` + `PeopleInSpaceSwiftUI/`) and
+ * `openMF/mifos-pay` (`cmp-shared` + `cmp-ios/`) were detected `android`,
+ * while an Android-only project with a module *named* `shared` was detected
+ * KMM and given a pipeline with an xcodebuild step aimed at nothing.
+ *
+ * Without an Apple consumer it is Android: an Android-only Kotlin
+ * Multiplatform library builds perfectly well with the Android template.
  */
 export function detectMobileProjectRoot(dir) {
     const androidIndicators = [
@@ -18,17 +137,7 @@ export function detectMobileProjectRoot(dir) {
     ];
     const hasAndroidIndicator = androidIndicators.some((f) => existsSync(resolve(dir, f)));
     if (hasAndroidIndicator) {
-        const kmmIndicators = ["iosApp", "shared", "composeApp"];
-        const hasKmmIndicator = kmmIndicators.some((d) => {
-            const fullPath = resolve(dir, d);
-            try {
-                return existsSync(fullPath) && statSync(fullPath).isDirectory();
-            }
-            catch {
-                return false;
-            }
-        });
-        if (hasKmmIndicator)
+        if (hasAppleConsumerWithinOneLevel(dir) && hasMultiplatformModule(dir))
             return "kmm";
         return "android";
     }
@@ -50,4 +159,6 @@ export function detectMobileProjectRoot(dir) {
     }
     return null;
 }
+/** Kept for callers that only ask whether a path is a directory. */
+export { isDirectory };
 //# sourceMappingURL=detect-project.js.map

package/dist/src/shared/detect-project.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=detect-project.test.d.ts.map

package/dist/src/shared/detect-project.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-project.test.d.ts","sourceRoot":"","sources":["../../../src/shared/detect-project.test.ts"],"names":[],"mappings":""}

package/dist/src/shared/detect-project.test.js

@@ -0,0 +1,126 @@
+/**
+ * What makes a Gradle repository a Kotlin Multiplatform one.
+ *
+ * The old rule was three directory names — `iosApp`, `shared`, `composeApp`
+ * — and it was wrong in both directions. Two of the ten KMM apps in the
+ * thirty-app study use none of those names and were detected `android`
+ * (`joreilly/PeopleInSpace` keeps its iOS app in `PeopleInSpaceSwiftUI/` and
+ * its shared code in `common`; `openMF/mifos-pay` uses `cmp-ios` and
+ * `cmp-shared`). In the other direction, an Android-only project with a
+ * `shared` module was called KMM and handed a pipeline that builds an iOS app
+ * it does not have.
+ */
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { detectMobileProjectRoot } from "./detect-project.js";
+let root;
+beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "cibuild-detect-"));
+});
+afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+});
+function write(relative, content) {
+    const path = join(root, relative);
+    mkdirSync(join(path, ".."), { recursive: true });
+    writeFileSync(path, content);
+}
+function settings(...modules) {
+    write("settings.gradle.kts", `include(${modules.map((m) => `":${m}"`).join(", ")})\n`);
+}
+const KMP = 'plugins { kotlin("multiplatform") }\n';
+const ANDROID_APP = 'plugins { id("com.android.application") }\n';
+const ANDROID_LIB = 'plugins { id("com.android.library") }\n';
+/** An Xcode project is a directory, not a file. */
+function xcodeProject(dir, name) {
+    mkdirSync(join(root, dir, `${name}.xcodeproj`), { recursive: true });
+    writeFileSync(join(root, dir, `${name}.xcodeproj`, "project.pbxproj"), "// stub\n");
+}
+describe("detectMobileProjectRoot", () => {
+    describe("Kotlin Multiplatform", () => {
+        test("a multiplatform module and an iOS app one level down is KMM", () => {
+            settings("common", "app");
+            write("common/build.gradle.kts", KMP);
+            write("app/build.gradle.kts", ANDROID_APP);
+            xcodeProject("PeopleInSpaceSwiftUI", "PeopleInSpaceSwiftUI");
+            expect(detectMobileProjectRoot(root)).toBe("kmm");
+        });
+        test("a CocoaPods Podfile is an Apple consumer too", () => {
+            settings("cmp-shared", "cmp-android");
+            write("cmp-shared/build.gradle.kts", KMP);
+            write("cmp-android/build.gradle.kts", ANDROID_APP);
+            write("cmp-ios/Podfile", "pod 'cmp_shared', :path => '../cmp-shared'\n");
+            expect(detectMobileProjectRoot(root)).toBe("kmm");
+        });
+        test("an XcodeGen spec is an Apple consumer, project or no project", () => {
+            settings("shared", "androidApp");
+            write("shared/build.gradle.kts", KMP);
+            write("androidApp/build.gradle.kts", ANDROID_APP);
+            write("iosApp/project.yml", "name: FeedFlow\ntargets:\n  FeedFlow:\n");
+            expect(detectMobileProjectRoot(root)).toBe("kmm");
+        });
+        test("the conventional names still work, when they are true", () => {
+            settings("shared", "androidApp");
+            write("shared/build.gradle.kts", KMP);
+            write("androidApp/build.gradle.kts", ANDROID_APP);
+            xcodeProject("iosApp", "iosApp");
+            expect(detectMobileProjectRoot(root)).toBe("kmm");
+        });
+        test("a nested multiplatform module counts", () => {
+            settings("core:domain", "app");
+            write("core/domain/build.gradle.kts", KMP);
+            write("app/build.gradle.kts", ANDROID_APP);
+            xcodeProject("iosApp", "iosApp");
+            expect(detectMobileProjectRoot(root)).toBe("kmm");
+        });
+    });
+    describe("Android", () => {
+        // The correction the closed study asked for (C3): a repository with
+        // multiplatform modules and no Apple side builds with the Android
+        // template, and a KMM pipeline would aim an xcodebuild step at nothing.
+        test("multiplatform modules with no Apple consumer is Android", () => {
+            settings("shared", "app");
+            write("shared/build.gradle.kts", 'plugins { kotlin("multiplatform") }\nkotlin { androidTarget()\n jvm() }\n');
+            write("app/build.gradle.kts", ANDROID_APP);
+            expect(detectMobileProjectRoot(root)).toBe("android");
+        });
+        // The false positive the three directory names caused.
+        test("a module merely named shared is not multiplatform", () => {
+            settings("shared", "app");
+            write("shared/build.gradle.kts", ANDROID_LIB);
+            write("app/build.gradle.kts", ANDROID_APP);
+            xcodeProject("iosApp", "iosApp");
+            expect(detectMobileProjectRoot(root)).toBe("android");
+        });
+        test("a plain Android repository is unchanged", () => {
+            settings("app");
+            write("app/build.gradle.kts", ANDROID_APP);
+            write("gradlew", "#!/bin/sh\n");
+            expect(detectMobileProjectRoot(root)).toBe("android");
+        });
+        // Build output and dependency caches hold copies of Xcode projects.
+        test("an Xcode project in build output is not an Apple consumer", () => {
+            settings("shared", "app");
+            write("shared/build.gradle.kts", KMP);
+            write("app/build.gradle.kts", ANDROID_APP);
+            xcodeProject("build", "Stale");
+            xcodeProject("Pods", "Pods");
+            expect(detectMobileProjectRoot(root)).toBe("android");
+        });
+    });
+    describe("iOS and nothing", () => {
+        test("an Xcode project with no Gradle is iOS", () => {
+            xcodeProject(".", "App");
+            expect(detectMobileProjectRoot(root)).toBe("ios");
+        });
+        test("a Podfile with no Gradle is iOS", () => {
+            write("Podfile", "target 'App' do\nend\n");
+            expect(detectMobileProjectRoot(root)).toBe("ios");
+        });
+        test("an empty directory is nothing", () => {
+            expect(detectMobileProjectRoot(root)).toBeNull();
+        });
+    });
+});
+//# sourceMappingURL=detect-project.test.js.map

package/dist/src/shared/gradle-settings.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Reading a Gradle settings file, once.
+ *
+ * There were two parsers for the same sentence and they disagreed. The
+ * scanner's matched only the first argument of an `include`, so
+ * `include(":android", ":common", ":viewmodels")` — one call, eight modules
+ * in `SimonSchubert/LinuxCommandLibrary` — was read as one module, and the
+ * seven others were never opened. That is how a project declaring
+ * `jvmToolchain(21)` was scanned as Java 17 and died at configuration.
+ */
+/**
+ * The module paths an `include` names, as directories.
+ *
+ * Gradle writes project paths colon-separated (`:core:network`) and the
+ * directory is the same path with slashes. Every argument of every `include`
+ * counts, in both the Groovy (`include ':a', ':b'`) and Kotlin
+ * (`include(":a", ":b")`) forms, and a leading colon is not part of the name.
+ */
+export declare function parseSettingsModules(content: string): string[];
+/**
+ * True when a build file applies the Kotlin Multiplatform plugin, in any of
+ * the forms a Gradle build uses for it — including a project-local
+ * convention plugin whose own id ends in `multiplatform`.
+ */
+export declare function declaresKotlinMultiplatformPlugin(content: string): boolean;
+/**
+ * Every plugin identifier a build file declares: `id("x")`, `id 'x'`,
+ * `apply plugin: 'x'` / `apply(plugin = "x")`, and the version-catalog alias
+ * `alias(libs.plugins.x.y)`.
+ */
+export declare function declaredPluginIds(content: string): string[];
+//# sourceMappingURL=gradle-settings.d.ts.map

package/dist/src/shared/gradle-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradle-settings.d.ts","sourceRoot":"","sources":["../../../src/shared/gradle-settings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAY9D;AAED;;;;GAIG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAO1E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAW3D"}

package/dist/src/shared/gradle-settings.js

@@ -0,0 +1,66 @@
+/**
+ * Reading a Gradle settings file, once.
+ *
+ * There were two parsers for the same sentence and they disagreed. The
+ * scanner's matched only the first argument of an `include`, so
+ * `include(":android", ":common", ":viewmodels")` — one call, eight modules
+ * in `SimonSchubert/LinuxCommandLibrary` — was read as one module, and the
+ * seven others were never opened. That is how a project declaring
+ * `jvmToolchain(21)` was scanned as Java 17 and died at configuration.
+ */
+/**
+ * The module paths an `include` names, as directories.
+ *
+ * Gradle writes project paths colon-separated (`:core:network`) and the
+ * directory is the same path with slashes. Every argument of every `include`
+ * counts, in both the Groovy (`include ':a', ':b'`) and Kotlin
+ * (`include(":a", ":b")`) forms, and a leading colon is not part of the name.
+ */
+export function parseSettingsModules(content) {
+    if (!content || typeof content !== "string")
+        return [];
+    const modules = [];
+    const re = /include\s*[(]?\s*((?:['"][^'"]+['"]\s*,?\s*)+)/g;
+    let match;
+    while ((match = re.exec(content)) !== null) {
+        for (const quoted of match[1].matchAll(/['"]([^'"]+)['"]/g)) {
+            const name = quoted[1].replace(/^:/, "").replace(/:/g, "/");
+            if (name && !modules.includes(name))
+                modules.push(name);
+        }
+    }
+    return modules;
+}
+/**
+ * True when a build file applies the Kotlin Multiplatform plugin, in any of
+ * the forms a Gradle build uses for it — including a project-local
+ * convention plugin whose own id ends in `multiplatform`.
+ */
+export function declaresKotlinMultiplatformPlugin(content) {
+    if (!content || typeof content !== "string")
+        return false;
+    if (/org\.jetbrains\.kotlin\.multiplatform/.test(content))
+        return true;
+    if (/kotlin\s*\(\s*["']multiplatform["']\s*\)/.test(content))
+        return true;
+    return declaredPluginIds(content).some((id) => /kotlin[._-]?multiplatform$/i.test(id));
+}
+/**
+ * Every plugin identifier a build file declares: `id("x")`, `id 'x'`,
+ * `apply plugin: 'x'` / `apply(plugin = "x")`, and the version-catalog alias
+ * `alias(libs.plugins.x.y)`.
+ */
+export function declaredPluginIds(content) {
+    if (!content || typeof content !== "string")
+        return [];
+    const ids = [];
+    for (const m of content.matchAll(/\bid\s*(?:\(\s*)?["']([^"']+)["']/g))
+        ids.push(m[1]);
+    for (const m of content.matchAll(/\bapply\s*(?:plugin\s*[:=]|\(\s*plugin\s*=)\s*["']([^"']+)["']/g)) {
+        ids.push(m[1]);
+    }
+    for (const m of content.matchAll(/\balias\s*\(\s*([A-Za-z0-9_.]+)\s*\)/g))
+        ids.push(m[1]);
+    return ids;
+}
+//# sourceMappingURL=gradle-settings.js.map

package/dist/src/yaml/steps/android-variant-resolution.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=android-variant-resolution.test.d.ts.map

package/dist/src/yaml/steps/android-variant-resolution.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"android-variant-resolution.test.d.ts","sourceRoot":"","sources":["../../../../src/yaml/steps/android-variant-resolution.test.ts"],"names":[],"mappings":""}