stim 1.20.2 → 1.22.0

package/dist/{android-Dlzxshgp.mjs → android-DGkNqa_c.mjs}

@@ -1,6 +1,6 @@
-import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-BTy8hZ0F.mjs";
-import { E as resolveVariant, T as resolveSystemImage, _ as findAapt, b as noDeviceDiagnostic, d as androidVariantSetting, f as apkDevClientFacts, g as dumpApkManifest, h as displayPath, i as NO_FINGERPRINT, p as apkPackage, r as NO_DEVICE, s as androidDevClientScheme, u as androidSystemImageSetting, x as parseXmltree, y as isReleaseVariant } from "./support-DMTqj3Hm.mjs";
-import { r as lastBuildRecord, t as androidFacts } from "./result-CaJg5Iat.mjs";
-import { i as runAndroidOperation, n as registerAndroid, r as runAndroid, t as androidCommand } from "./android-DCKZrNvV.mjs";
-import { a as killPreviousCollector, i as collectorLogFile, o as startCollector } from "./launch-F4sOqAhB.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-gwpm28fu.mjs";
+import { E as resolveVariant, T as resolveSystemImage, _ as findAapt, b as noDeviceDiagnostic, d as androidVariantSetting, f as apkDevClientFacts, g as dumpApkManifest, h as displayPath, i as NO_FINGERPRINT, p as apkPackage, r as NO_DEVICE, s as androidDevClientScheme, u as androidSystemImageSetting, x as parseXmltree, y as isReleaseVariant } from "./support-yUiOjnVY.mjs";
+import { r as lastBuildRecord, t as androidFacts } from "./result-D2Ykz_iD.mjs";
+import { i as runAndroidOperation, n as registerAndroid, r as runAndroid, t as androidCommand } from "./android-ByRMUoiJ.mjs";
+import { a as killPreviousCollector, i as collectorLogFile, o as startCollector } from "./launch-CCzXlc8r.mjs";
 export { NO_DEVICE, NO_FINGERPRINT, androidDevClientScheme, androidFacts, androidSystemImageSetting, androidVariantSetting, apkDevClientFacts, apkPackage, collectorLogFile, androidCommand as default, displayPath, dumpApkManifest, findAapt, formatDuration, isReleaseVariant, killPreviousCollector, lastBuildRecord, noDeviceDiagnostic, parseXmltree, phaseLine, registerAndroid, resolveSystemImage, resolveVariant, runAndroid, runAndroidOperation, shortHash, startCollector };

package/dist/{android-HqP1_vB_.mjs → android-DR5lZ2Az.mjs}

@@ -1,5 +1,5 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { u as androidToolCwd } from "./android-Mz_Inn3w.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { u as androidToolCwd } from "./android-C7sVmyI9.mjs";
 //#region src/collector/android.ts
 const LEVEL_BY_LETTER = {
 	V: "debug",

package/dist/android-cas-compiler.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { createHash, randomUUID } from "node:crypto";
 import { once } from "node:events";
 //#region bin/android-cas-compiler.ts
 const context = process.env.STIM_ANDROID_CAS_CONTEXT;

package/dist/{android-cas-Bl-cLJBk.mjs → android-cas-ngferVq2.mjs}

@@ -1,13 +1,13 @@
-import { d as getConfigDir } from "./config-BYDxlMY3.mjs";
-import { r as register } from "./cache-manifest-XH-fvDUj.mjs";
-import { m as defaultAndroidLayout } from "./settings-B717odTD.mjs";
-import { D as withDirLock$1, p as ensureWorkspaceStorage } from "./workspace-state-DJt_MMvf.mjs";
+import { n as ensureWorkspaceStorage, v as withDirLock$1 } from "./paths-DQtTgsBf.mjs";
+import { d as getConfigDir } from "./config-DlrsduwG.mjs";
+import { m as defaultAndroidLayout } from "./settings-C7O8A6ZI.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { createHash, randomUUID } from "node:crypto";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { quotedPath } from "@stim-cli/core";
 import { isJsonObject, readJsonFile } from "@stim-cli/core/state";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { quotedPath } from "@stim-cli/core";
-import { createHash, randomUUID } from "node:crypto";
 //#region src/engine/android-cas.ts
 const CAS_TOOLCHAIN_FIELDS = [
 	"clang",
@@ -144,6 +144,7 @@ function resolveAndroidCas(root, env = process.env, layout = defaultAndroidLayou
 	});
 	register({
 		dir,
+		registeredBy: root,
 		name: "android-cas",
 		prune: "atomic",
 		note: "Experimental Android compiler CAS"

package/dist/android-project-BCAAmMwz.mjs

@@ -0,0 +1,12 @@
+//#region src/integrations/android-project.ts
+var AndroidRecipeRefusal = class extends Error {
+	failure;
+	missReason;
+	constructor(failure, missReason) {
+		super(failure.message ?? failure.code);
+		this.failure = failure;
+		this.missReason = missReason;
+	}
+};
+//#endregion
+export { AndroidRecipeRefusal as t };

package/dist/android-project-DVWyCbWU.d.mts

@@ -0,0 +1,391 @@
+import { n as SettingsObject, t as AndroidLayout } from "./ios-CDvlmUs7.mjs";
+import { r as createNdjsonWriter } from "./exec-DnYc4HGH.mjs";
+import { readFileSync, writeFileSync } from "node:fs";
+import { StimContext, hostSimulatorArch } from "@stim-cli/core";
+import { ANDROID_EMULATOR_APPS, BuildPhase, BuildPlanPayload, Endpoint, RunEstimates, SettingScope, WebViewport, machineCapacity } from "@stim-cli/core/state";
+import "@stim-cli/core/noise-session";
+import { readFileSync as readFileSync$1 } from "fs";
+import { Command } from "commander";
+import "@expo/fingerprint";
+import { CacheProviderConfig, loadCacheProvider } from "@stim-cli/cache";
+import { BuildReactNativeArtifactQuery, BuildSwiftpmArtifactQuery, GradleOffloadInputs, HelloResult } from "@stim-cli/core/protocol";
+import { ChildProcess } from "node:child_process";
+//#region src/engine/build-facts.d.ts
+type CacheHitLevel = "local" | "remote" | false;
+type LaunchStatus = boolean | "unverified" | "bundling";
+interface LogsInfo {
+  dir?: string;
+}
+interface CompilationCacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  cacheableTasks: number | null;
+  hitRatePercent: number | null;
+  swiftTargetsWithoutExplicitModules?: number;
+}
+interface CcacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  misses: number | null;
+  hitRatePercent: number | null;
+}
+interface DevServerStart {
+  started: true;
+  reason: "not running" | "stopped (idle)";
+}
+interface RunLeaseFacts {
+  kind: string;
+  expiresAt: string;
+}
+interface IosFacts {
+  devicePlacement?: import("@stim-cli/core/state").DevicePlacement;
+  host?: import("@stim-cli/core/state").HostedIosStatus;
+  slot?: string;
+  platform: string;
+  udid: string;
+  deviceName: string | null;
+  deviceType: string | null;
+  runtime: string | null;
+  fingerprint?: string | null;
+  configuration: string | null;
+  scheme?: string;
+  cacheKey?: string | null;
+  cacheHit: CacheHitLevel;
+  cacheSkipped: boolean;
+  buildMachine?: string;
+  builtOn?: string;
+  /** The remote machine that compiled the app when the build was offloaded; absent otherwise. */
+  offloadedTo?: string;
+  /** Why the app was built here after the run considered offloading it; absent otherwise. */
+  offloadFallback?: string;
+  compilationCache: CompilationCacheActivity;
+  waitedForBuild: {
+    pid: number | null;
+    ms: number;
+  } | null;
+  appPath?: string | null;
+  bundleId?: string | null;
+  installSkipped: boolean;
+  launched: LaunchStatus;
+  metroPort?: number | null;
+  logs: LogsInfo;
+  agentDevice?: {
+    stateDir: string;
+  };
+  durationMs?: number;
+  webPreviewUrl?: string | null;
+  lease?: RunLeaseFacts | null;
+  devServer?: DevServerStart;
+}
+interface AndroidFacts {
+  devicePlacement?: import("@stim-cli/core/state").DevicePlacement;
+  host?: import("@stim-cli/core/state").HostedAndroidStatus;
+  slot?: string;
+  platform: string;
+  serial: string | null;
+  avdName: string | null;
+  deviceName: string | null;
+  systemImage: string | null;
+  deviceProfile: string | null;
+  fingerprint: string | null;
+  cacheKey: string | null;
+  variant: string | null;
+  metroPort: number | null;
+  cacheHit: CacheHitLevel;
+  cacheSkipped: boolean;
+  buildMachine?: string;
+  builtOn?: string;
+  /** The remote machine that compiled the APK when the build was offloaded; absent otherwise. */
+  offloadedTo?: string;
+  /** Why the APK was built here after the run considered offloading it; absent otherwise. */
+  offloadFallback?: string;
+  waitedForBuild: {
+    pid: number | null;
+    ms: number;
+  } | null;
+  appPath: string | null;
+  bundleId: string | null;
+  installSkipped: boolean;
+  launched: LaunchStatus;
+  ccache: CcacheActivity;
+  debugHttpHost: string | null;
+  debugHttpHostNote: string | null;
+  devClientUrl: string | null;
+  logs: string | null;
+  agentDevice?: {
+    stateDir: string;
+  };
+  durationMs: number | null;
+  lease?: RunLeaseFacts | null;
+  devServer?: DevServerStart;
+}
+//#endregion
+//#region src/optimizations.d.ts
+interface Optimizations {
+  buildCache: boolean;
+  remoteBuildCache: boolean;
+  releaseBundleSwap: boolean;
+  metroSharedCache: boolean;
+  metroWarmup: boolean;
+  ios: {
+    compilationCache: boolean;
+    swiftCompilationCache: boolean | null;
+    prefixMapping: boolean;
+  };
+  android: {
+    compilerCache: "ccache" | "cas" | "none";
+    casToolchain: string | null;
+    compilerCacheFallback: CompilerCacheFallback | null;
+    pch: "auto" | "on" | "off";
+    gradleBuildCache: boolean;
+    targetAbiOnly: boolean;
+  };
+}
+interface CompilerCacheFallback {
+  key: string;
+  reason: string;
+  fromEnvironment: boolean;
+  manifest: string | null;
+}
+declare function artifactCachePolicy(options: Optimizations, reuse: boolean, release: boolean): {
+  read: boolean;
+  write: boolean;
+  remote: boolean;
+};
+//#endregion
+//#region src/engine/android-cas.d.ts
+interface AndroidCasSetup {
+  id: string;
+  dir: string;
+  initScript: string;
+  env: Record<string, string>;
+}
+declare function resolveAndroidCas(root: string, env?: NodeJS.ProcessEnv, layout?: AndroidLayout): AndroidCasSetup | null;
+//#endregion
+//#region src/commands/android/types.d.ts
+type AndroidWriter = ReturnType<typeof createNdjsonWriter>;
+//#endregion
+//#region src/diagnostics/doctor.d.ts
+interface Finding {
+  code?: string;
+  level: "cost" | "note";
+  title: string;
+  detail: string;
+  fix: string | null;
+}
+type DoctorPlatform = "ios" | "android";
+//#endregion
+//#region src/budget.d.ts
+type ReclaimStepName = "idle-devices" | "idle-dev-servers" | "workspace-outputs" | "stale-cache-entries";
+interface ReclaimedStep {
+  step: ReclaimStepName;
+  targets: string[];
+  failures: number;
+  freedMb?: number;
+}
+interface BudgetReport {
+  budget: {
+    minFreeDiskGb: number;
+    hardFloorDiskGb: number;
+    maxCommittedMemoryGb: number;
+    maxLiveWorkspaces: number;
+  };
+  volumes: {
+    volume: string;
+    freeGb: number;
+  }[];
+  memory: {
+    committedGb: number;
+    liveWorkspaces: number;
+  } | null;
+  plan: ReclaimedStep[];
+}
+//#endregion
+//#region src/commands/android/plan.d.ts
+interface AndroidBuildPlan {
+  readonly build: {
+    readonly variant: string | null;
+    readonly release: boolean;
+    readonly profile: string | undefined;
+    readonly cas: ReturnType<typeof resolveAndroidCas>;
+    readonly cache: Readonly<ReturnType<typeof artifactCachePolicy>>;
+    readonly compilerCache: Optimizations["android"]["compilerCache"];
+    readonly gradleBuildCache: boolean;
+    readonly pch: Optimizations["android"]["pch"];
+    readonly targetAbiOnly: boolean;
+  };
+  readonly metroWarmup: boolean;
+  readonly cacheProviderConfig: CacheProviderConfig | null;
+}
+//#endregion
+//#region src/offload/toolchain.d.ts
+/** What must be identical on this Mac and a remote Mac for an iOS simulator build to come out the same. */
+interface IosToolchain {
+  /** A digest of Stim's built code, so both sides prove they run the same Stim. */
+  stimBuild: string | null;
+  arch: string;
+  xcode: string | null;
+  simulatorSdk: string | null;
+  cocoapods: string | null;
+}
+/** A remote machine's toolchain, the simulator runtimes it can build for, and its JDK and Android SDK packages. */
+interface WorkerToolchain extends IosToolchain {
+  /** The OS stim-server runs on, as Node names it; absent from a stim-server older than this field. */
+  os?: string;
+  macosSdk: string | null;
+  bundler: string | null;
+  runtimes: string[];
+  jdk: string | null;
+  androidSdk: {
+    ndk: string[];
+    buildTools: string[];
+    platforms: string[];
+  } | null;
+}
+/** One reason a remote machine cannot take this build now, with a stable `code` for doctor's JSON. */
+interface OffloadProblem {
+  code: "unreachable" | "checkout" | "stim-build" | "arch" | "xcode" | "macos-sdk" | "simulator-sdk" | "cocoapods" | "bundler" | "runtime" | "jdk" | "android-sdk" | "ndk" | "build-tools" | "compile-sdk" | "disk" | "busy" | "platform";
+  reason: string;
+}
+//#endregion
+//#region src/offload/tailnet.d.ts
+type Access = "build" | "device-host";
+/**
+ * How this machine proves itself to a remote stim-server: as a returning client that pins `serverKey`, or on first
+ * contact with the setup ticket the worker's `stim-server setup` approved. Both use this machine's client key.
+ */
+type MachineAuth = {
+  access: Access;
+  serverKey: string;
+} | {
+  access: Access;
+  ticket: string;
+  name: string;
+  /** Runs once the ticket's handshake authenticated the server key, before `hello`, so a lost reply can recover. */
+  onServerKey?: (serverKey: string) => void | Promise<void>;
+};
+type HelloReply = {
+  result: {
+    host?: {
+      name: string;
+      screenRecording: boolean;
+      accessibility: boolean;
+    } | null;
+    capabilities: string[];
+    features?: string[];
+    device: {
+      id: string;
+      name: string;
+    };
+  };
+  /** The server key the handshake authenticated. */
+  serverKey: string;
+} | {
+  error: {
+    code: string;
+    message: string;
+  };
+} | {
+  failed: string;
+};
+interface TailnetMachineIo {
+  /** `tailscale status --json`, or null when Tailscale is not running. */
+  status: () => unknown;
+  hello: (endpoint: Endpoint, auth: MachineAuth) => Promise<HelloReply>;
+}
+type GeneratedTickets = Map<string, {
+  ticket: string;
+  expiresAt: string;
+}>;
+//#endregion
+//#region src/offload/build-machines.d.ts
+/**
+ * Where this machine stands with one `remote.machines` entry, as `stim doctor --json` reports it under
+ * `remoteMachines`. `dnsName` is the peer's MagicDNS name when the name resolved; `deviceId` is the id the worker
+ * lists this machine under once it asked.
+ */
+interface BuildMachineReport {
+  machine: string;
+  state: "invalid" | "tailscale-off" | "not-on-tailnet" | "key-changed" | "not-asked" | "pending" | "approved" | "revoked" | "lapsed" | "outdated" | "unreachable";
+  dnsName?: string;
+  deviceId?: string;
+  requestedAt?: string;
+  expiresAt?: string;
+  host?: NonNullable<HelloResult["host"]>;
+  /** For an approved machine: whether it would take this project's build now, and every reason it would not. */
+  offloadable?: boolean;
+  reasons?: string[];
+  /** The same reasons with the code of each, in the same order. */
+  problems?: OffloadProblem[];
+  /** The machine's reported capacity, when it answered an offer. */
+  capacity?: Record<string, unknown>;
+}
+interface BuildMachinesInspection {
+  findings: Finding[];
+  machines: BuildMachineReport[];
+}
+//#endregion
+//#region src/offload/client.d.ts
+/** The Gradle choices that shape the APK, so the machine builds what this machine's cache key describes. */
+interface AndroidBuildOptions {
+  variant: string | null;
+  abi: string | null;
+  gradleBuildCache: boolean;
+  pch: "auto" | "on" | "off";
+  compilerCache: "ccache" | "none";
+  gradleRoot?: string | null;
+  module?: string | null;
+}
+//#endregion
+//#region src/integrations/swiftpm-artifact-inputs.d.ts
+interface SwiftpmArtifactToolchain {
+  swift: string;
+  sdk: string;
+  arch: string;
+  xcode: string;
+}
+//#endregion
+//#region src/web/launch.d.ts
+type WebLaunched = true | "bundling" | "unverified";
+//#endregion
+//#region src/integrations/native-gradle-artifact-inputs.d.ts
+interface GradleArtifactInputs extends GradleOffloadInputs {
+  localFiles: string[];
+  environment: string[];
+}
+type GradleArtifactBuild = Pick<AndroidArtifactContext["buildPlan"], "variant" | "compilerCache" | "gradleBuildCache" | "pch" | "cas">;
+interface NativeGradleArtifactReceipt {
+  source: string;
+  declaration: GradleArtifactInputs;
+  build: GradleArtifactBuild;
+  abi: string | null;
+}
+//#endregion
+//#region src/integrations/android-project.d.ts
+interface AndroidBuildTarget {
+  abi: string | null;
+}
+interface AndroidArtifactIdentity {
+  hash: string;
+  key: string;
+}
+interface AndroidArtifactContext {
+  operation?: StimContext;
+  artifactScope?: {
+    key: string;
+    validate(): Promise<void>;
+    record?(identity: AndroidArtifactIdentity, receipt: NativeGradleArtifactReceipt): void;
+  };
+  root: string;
+  buildLog: string;
+  writer: AndroidWriter;
+  settings: SettingsObject;
+  buildPlan: AndroidBuildPlan["build"];
+  target: AndroidBuildTarget;
+  phase: (label: unknown, text: string) => void;
+  out: (line: string) => void;
+  step: (phase: BuildPhase) => void;
+  estimates: () => RunEstimates;
+}
+//#endregion
+export { IosFacts as _, BuildMachinesInspection as a, IosToolchain as c, DoctorPlatform as d, Finding as f, CompilationCacheActivity as g, CcacheActivity as h, AndroidBuildOptions as i, WorkerToolchain as l, AndroidFacts as m, WebLaunched as n, GeneratedTickets as o, Optimizations as p, SwiftpmArtifactToolchain as r, TailnetMachineIo as s, NativeGradleArtifactReceipt as t, BudgetReport as u };