@delacour/warden-e2e 0.4.0 → 0.5.0

package/{chunk-3874jt2j.mjs → chunk-j9b17ade.mjs}

@@ -2685,6 +2685,71 @@ function createConsoleCapture(options = {}) {
   };
 }
 
+// ../../packages/e2e/src/devtools/logbox.script.ts
+var LOGBOX_SCRIPT = `function (g) {
+  var req = g.__r;
+  if (typeof req !== "function" || typeof req.getModules !== "function") return "no-require";
+  var modules = req.getModules();
+  if (!modules || typeof modules.forEach !== "function") return "no-require";
+  var data = null;
+  modules.forEach(function (mod) {
+    if (data || !mod || typeof mod.verboseName !== "string" || !mod.isInitialized) return;
+    var name = mod.verboseName.replace(/\\\\/g, "/");
+    if (!/(^|\\/)react-native\\/Libraries\\/LogBox\\/Data\\/LogBoxData\\.js$/.test(name)) return;
+    var exports = mod.publicModule && mod.publicModule.exports;
+    if (exports && typeof exports.addIgnorePatterns === "function") data = exports;
+  });
+  if (!data) return "not-ready";
+  data.addIgnorePatterns([/[\\s\\S]*/]);
+  if (typeof data.setDisabled === "function") data.setDisabled(true);
+  if (typeof data.setSelectedLog === "function") data.setSelectedLog(-1);
+  return "off";
+}`;
+var LOGBOX_EXPRESSION = `(${LOGBOX_SCRIPT})(typeof globalThis !== "undefined" ? globalThis : (typeof global !== "undefined" ? global : this))`;
+
+// ../../packages/e2e/src/devtools/logbox.ts
+var INTERVAL_MS = 250;
+var ATTEMPTS = 80;
+var timerSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function muteLogBox(session, options = {}) {
+  const sleep = options.sleep ?? timerSleep;
+  const intervalMs = options.intervalMs ?? INTERVAL_MS;
+  const attempts = options.attempts ?? ATTEMPTS;
+  let generation = 0;
+  let stopped = false;
+  async function tryOnce() {
+    const reply = await session.evaluate(LOGBOX_EXPRESSION);
+    if (!reply.success)
+      return reply.error.message;
+    return reply.data === "off" ? undefined : String(reply.data);
+  }
+  async function apply(mine) {
+    const current = () => !stopped && mine === generation;
+    let last = "no reply";
+    for (let attempt = 1;attempt <= attempts && current(); attempt++) {
+      last = await tryOnce();
+      if (last === undefined)
+        return;
+      if (attempt < attempts)
+        await sleep(intervalMs);
+    }
+    if (current())
+      options.log?.(`devtools: LogBox left on (${last} after ${attempts} attempts)`);
+  }
+  const start = () => apply(++generation);
+  const off = session.on("reconnected", () => {
+    start();
+  });
+  const settled = start();
+  return {
+    settled,
+    stop() {
+      stopped = true;
+      off();
+    }
+  };
+}
+
 // ../../packages/e2e/src/devtools/network.ts
 import { z as z3 } from "zod";
 
@@ -2825,10 +2890,10 @@ var pageEntrySchema = z3.looseObject({
   responseBodyTruncated: z3.boolean().optional(),
   error: z3.string().optional()
 });
-var timerSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var timerSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function attachNetwork(session, options = {}) {
   const ring = options.ring ?? DEFAULT_RING2;
-  const sleep = options.sleep ?? timerSleep;
+  const sleep = options.sleep ?? timerSleep2;
   const pollMs = options.pollMs ?? DEFAULT_POLL_MS2;
   const installExpression = networkInstallExpression({
     ring,
@@ -3074,13 +3139,13 @@ var RECONNECT_BUDGET_MS = 30000;
 var RELOAD_WAIT_MS = 5000;
 var HANDSHAKE_OPTIONAL_TIMEOUT_MS = 3000;
 var RELOAD_EXPRESSION = '(function(){var g=globalThis;if(g.expo&&typeof g.expo.reloadAppAsync==="function"){setTimeout(function(){g.expo.reloadAppAsync("warden e2e reloadJs")},0);return "expo"}var m=g.nativeModuleProxy&&g.nativeModuleProxy.DevSettings;if(m&&typeof m.reload==="function"){setTimeout(function(){m.reload()},0);return "devsettings"}return false})()';
-var timerSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var timerSleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function connectDevtools(o) {
   const { metroUrl } = o;
   if (!metroUrl) {
     return devtoolsErr("devtools_unavailable", "no Metro URL: release builds have no devtools (start a dev client)");
   }
-  const sleep = o.sleep ?? timerSleep2;
+  const sleep = o.sleep ?? timerSleep3;
   const log = o.log ?? (() => {
     return;
   });
@@ -3856,7 +3921,7 @@ var scriptResultSchema = z5.union([
   z5.object({ screen: z5.string().optional(), components: z5.array(componentSchema), truncated: z5.boolean() })
 ]);
 var bindingPayloadSchema2 = z5.object({ requestId: z5.string(), result: z5.unknown() });
-var timerSleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var timerSleep4 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var requestCounter = 0;
 function scriptError(message) {
   if (message === "no-hook")
@@ -3919,7 +3984,7 @@ async function viaBinding(session, expression, requestId, timeoutMs) {
 }
 async function fetchTree(session, options = {}, deps = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
-  const resolved = { sleep: deps.sleep ?? timerSleep3, now: deps.now ?? Date.now };
+  const resolved = { sleep: deps.sleep ?? timerSleep4, now: deps.now ?? Date.now };
   requestCounter += 1;
   const requestId = `tree-${Date.now().toString(36)}-${requestCounter}`;
   const config = {
@@ -3970,6 +4035,7 @@ async function openDevtoolsFacet(o) {
     return attached;
   }
   const network = attached.data;
+  const logbox = o.muteLogBox ? muteLogBox(session, { log: o.log }) : undefined;
   return ok({
     evaluate: (expression, options) => session.evaluate(expression, options),
     reloadJs: () => session.reloadJs(),
@@ -3995,6 +4061,7 @@ async function openDevtoolsFacet(o) {
       return ok(paths);
     },
     close() {
+      logbox?.stop();
       network.stop();
       session.close();
     }
@@ -5203,7 +5270,8 @@ var openDevtools = (env) => openDevtoolsFacet({
   WebSocket,
   timeoutMs: 5000,
   log: (line) => process.stderr.write(`[devtools] ${line}
-`)
+`),
+  muteLogBox: true
 });
 var SESSION_KEY = Symbol.for("@delacour/warden-e2e/session");
 var slot = () => globalThis;
@@ -5950,6 +6018,6 @@ function onlyWasSeen() {
 
 // ../../packages/e2e/src/version.ts
 var WORKSPACE_VERSION = "0.0.0-workspace";
-var WARDEN_E2E_VERSION2 = "0.4.0";
+var WARDEN_E2E_VERSION2 = "0.5.0";
 
 export { E2eError2, noteSpanDetail, addSpanDetail, canObserve, canDetectAlerts, settleDetailOf, DEFAULT_SETTLE_QUIET_MS, DEFAULT_SETTLE_TIMEOUT_MS, settleByHash, snapshotHash, ok, err, swipeVector, screenRect, fieldValue, PINCH_MS, ROTATE_MS, PATH_MS, centreOf, pinchRadius, rotateRadius, requireGesture, assertScale, assertDegrees, isInteractiveRole, resolveRole, normalizeText, matchesText, indexSnapshot, testIdQuery, textQuery, roleQuery, selectorExpression, renderSnapshot, renderHeader, resolve, locateByTestIdViaReact, isLocator, Locator, pickOne, textOf, scrollUntilVisible, bunExec, execError, driverError, driverErr, logEventSchema, fatalEventSchema, responseSchema, mapWireError, encodeRequest, bunSpawn, stdioTransport, spawnSimd, connectSimd, isHidLost, ENV_NAMES, DEFAULT_ASSERTION_TIMEOUT_MS, readEnv, runStep, setDefaultHidRecovery, setDefaultNativeLog, setDefaultDriverFactory, hasDefaultDriverFactory, setDefaultFixtureFactory, hasDefaultFixtureFactory, attemptSession, getSession, parseBudgets, createDevicePerf, perfStartFor, spawnWarden, hash6, attemptDir, screenshotPath, specIdOf, realNativeLogDeps, captureNativeLog, callerFile, BUN_TIMEOUT_MARGIN_MS2, ownHook, currentScope, createScope, runInScope, hooksFor, resolveUse, registrationDefaults, markOnly, onlyWasSeen, WORKSPACE_VERSION, WARDEN_E2E_VERSION2 };

package/index.mjs

@@ -31,7 +31,7 @@ import {
   registrationDefaults,
   markOnly,
   WARDEN_E2E_VERSION2
-} from "./chunk-3874jt2j.mjs";
+} from "./chunk-j9b17ade.mjs";
 // ../../packages/e2e/src/expect/expect.ts
 import { expect as bunExpect } from "bun:test";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delacour/warden-e2e",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "TypeScript spec API for `warden e2e`: test, expect, screen, device, app",
   "license": "MIT",
   "repository": {
@@ -37,7 +37,7 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "@delacour/warden": "0.4.0"
+    "@delacour/warden": "0.5.0"
   },
   "dependencies": {
     "zod": "^4.4.3"

package/preload.mjs

@@ -68,7 +68,7 @@ import {
   onlyWasSeen,
   WORKSPACE_VERSION,
   WARDEN_E2E_VERSION2
-} from "./chunk-3874jt2j.mjs";
+} from "./chunk-j9b17ade.mjs";
 
 // ../../packages/e2e/src/preload.ts
 import { afterAll, setDefaultTimeout } from "bun:test";
@@ -3983,6 +3983,8 @@ function createApp({ session, driver, env, log = stderrLog2, clock = systemClock
     if (options.env !== undefined)
       opts.env = options.env;
     await unwrap(() => driver.app.launch(bundleId, opts), `launch ${bundleId}`, session.signal);
+    if (env.metroUrl !== undefined)
+      session.devtools?.();
     if (options.url !== undefined) {
       const url = options.url;
       await unwrap(() => driver.app.openUrl(url), `open ${url}`, session.signal);

package/types/core/src/affected/affected.schema.d.ts

@@ -0,0 +1,185 @@
+import { z } from "zod";
+import { slimConfigSchema } from "../batch/preset.schema";
+/** `e2e.<suite>.specs.<id|glob>`: what a spec covers and whether it gates. */
+export declare const e2eSpecEntrySchema: z.ZodObject<{
+    entries: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    platforms: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ios: "ios";
+        android: "android";
+    }>>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** How a suite's spec processes are laid out: one per device running its share of the specs, or one per spec. */
+export type E2eIsolation = "device" | "spec";
+type RunSettings = {
+    isolate?: E2eIsolation | undefined;
+    passes: number;
+    count?: number | undefined;
+    profile?: string | undefined;
+    devices?: Array<{
+        profile: string;
+        default: boolean;
+    }> | undefined;
+};
+/**
+ * The isolation a suite runs with: what it asked for (`isolate`), else one
+ * process per device, except that `passes` > 1 needs a process per spec (a spec's passes are
+ * re-runs of that spec).
+ */
+export declare function suiteIsolation(suite: Pick<RunSettings, "isolate" | "passes">): E2eIsolation;
+/** `e2e.<suite>.metro`: warden starts one Metro for the run and points the dev client at it. */
+export declare const e2eMetroSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    port: z.ZodDefault<z.ZodString>;
+    launchArgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    open: z.ZodDefault<z.ZodBoolean>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    prewarm: z.ZodDefault<z.ZodBoolean>;
+    readyTimeout: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+/** `e2e.<suite>.devices[]`: one leg of the run, with its own device pool. */
+export declare const e2eDeviceLegSchema: z.ZodObject<{
+    profile: z.ZodString;
+    count: z.ZodDefault<z.ZodNumber>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    default: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/** `perf` (top level, or per `e2e.<suite>`): ceilings `device.perf.stop()` holds the report to. Each is lower-is-better. */
+export declare const perfConfigSchema: z.ZodObject<{
+    budgets: z.ZodOptional<z.ZodObject<{
+        startupColdMs: z.ZodOptional<z.ZodNumber>;
+        jankPct: z.ZodOptional<z.ZodNumber>;
+        maxCommitMs: z.ZodOptional<z.ZodNumber>;
+        p95CpuPct: z.ZodOptional<z.ZodNumber>;
+        peakMemoryMb: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** `e2e.<suite>.spec`: how warden runs the `*.e2e.ts` specs (`bun test` + `@delacour/warden-e2e`). */
+export declare const e2eSpecSchema: z.ZodObject<{
+    bundleId: z.ZodOptional<z.ZodString>;
+    launchArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodString>;
+    actionTimeout: z.ZodOptional<z.ZodString>;
+    assertionTimeout: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * `e2e.<suite>` in `warden.config.ts`: specs under `specsDir`, how they map to source, how to run one.
+ * Paths and globs are relative to the config file's directory.
+ */
+export declare const e2eSuiteSchema: z.ZodObject<{
+    project: z.ZodOptional<z.ZodString>;
+    specsDir: z.ZodString;
+    spec: z.ZodOptional<z.ZodObject<{
+        bundleId: z.ZodOptional<z.ZodString>;
+        launchArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        timeout: z.ZodOptional<z.ZodString>;
+        actionTimeout: z.ZodOptional<z.ZodString>;
+        assertionTimeout: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    isolate: z.ZodOptional<z.ZodEnum<{
+        device: "device";
+        spec: "spec";
+    }>>;
+    shutdown: z.ZodOptional<z.ZodEnum<{
+        idle: "idle";
+        always: "always";
+    }>>;
+    jobTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    devices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        profile: z.ZodString;
+        count: z.ZodDefault<z.ZodNumber>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        default: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    metro: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        port: z.ZodDefault<z.ZodString>;
+        launchArgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        open: z.ZodDefault<z.ZodBoolean>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        prewarm: z.ZodDefault<z.ZodBoolean>;
+        readyTimeout: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>;
+    tsconfig: z.ZodOptional<z.ZodString>;
+    routerRoot: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodEnum<{
+        ios: "ios";
+        android: "android";
+    }>>;
+    base: z.ZodDefault<z.ZodString>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    runAll: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    ignore: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    always: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    scope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    unmatched: z.ZodDefault<z.ZodEnum<{
+        skip: "skip";
+        "run-all": "run-all";
+    }>>;
+    unmapped: z.ZodDefault<z.ZodEnum<{
+        run: "run";
+        skip: "skip";
+    }>>;
+    passes: z.ZodDefault<z.ZodNumber>;
+    retry: z.ZodDefault<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+    profile: z.ZodOptional<z.ZodString>;
+    app: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        installMode: z.ZodOptional<z.ZodEnum<{
+            clean: "clean";
+            reinstall: "reinstall";
+        }>>;
+        resetKeychain: z.ZodOptional<z.ZodBoolean>;
+        clean: z.ZodOptional<z.ZodBoolean>;
+        variant: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            release: "release";
+            dev: "dev";
+            simulator: "simulator";
+        }>>;
+    }, z.core.$strict>]>>;
+    ports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    serve: z.ZodOptional<z.ZodString>;
+    serveReady: z.ZodOptional<z.ZodString>;
+    serveTimeout: z.ZodOptional<z.ZodString>;
+    setup: z.ZodOptional<z.ZodString>;
+    slim: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        except: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        keep: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    warmRunners: z.ZodOptional<z.ZodUndefined>;
+    warmDrivers: z.ZodOptional<z.ZodBoolean>;
+    headless: z.ZodOptional<z.ZodBoolean>;
+    perf: z.ZodOptional<z.ZodObject<{
+        budgets: z.ZodOptional<z.ZodObject<{
+            startupColdMs: z.ZodOptional<z.ZodNumber>;
+            jankPct: z.ZodOptional<z.ZodNumber>;
+            maxCommitMs: z.ZodOptional<z.ZodNumber>;
+            p95CpuPct: z.ZodOptional<z.ZodNumber>;
+            peakMemoryMb: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    specs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        entries: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        platforms: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            ios: "ios";
+            android: "android";
+        }>>>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type E2eSpecConfig = z.infer<typeof e2eSpecSchema>;
+export type E2eMetroConfig = z.infer<typeof e2eMetroSchema>;
+export type E2eDeviceLeg = z.infer<typeof e2eDeviceLegSchema>;
+export type E2eSpecEntryConfig = z.infer<typeof e2eSpecEntrySchema>;
+export type E2eSlimConfig = z.infer<typeof slimConfigSchema>;
+export type E2eSuiteConfig = z.infer<typeof e2eSuiteSchema>;
+export {};

package/types/core/src/batch/preset.schema.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+/** `slim`: on/off, or the categories (`except`, ids) and single labels (`keep`) to leave running. */
+export declare const slimConfigSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    except: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    keep: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>]>;
+export declare const duration: z.ZodString;
+export declare const portSpec: z.ZodString;
+/** `batches.<name>` in `warden.config.ts`: a saved `warden batch` invocation. */
+export declare const batchPresetSchema: z.ZodObject<{
+    project: z.ZodOptional<z.ZodString>;
+    platform: z.ZodEnum<{
+        ios: "ios";
+        android: "android";
+    }>;
+    count: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    profile: z.ZodOptional<z.ZodString>;
+    runtime: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    ttl: z.ZodOptional<z.ZodString>;
+    wait: z.ZodOptional<z.ZodString>;
+    ports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    app: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        installMode: z.ZodOptional<z.ZodEnum<{
+            clean: "clean";
+            reinstall: "reinstall";
+        }>>;
+        resetKeychain: z.ZodOptional<z.ZodBoolean>;
+        clean: z.ZodOptional<z.ZodBoolean>;
+        variant: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            release: "release";
+            dev: "dev";
+            simulator: "simulator";
+        }>>;
+    }, z.core.$strict>]>>;
+    headless: z.ZodOptional<z.ZodBoolean>;
+    slim: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        except: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        keep: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    retry: z.ZodOptional<z.ZodNumber>;
+    passes: z.ZodOptional<z.ZodNumber>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    serve: z.ZodOptional<z.ZodString>;
+    serveReady: z.ZodOptional<z.ZodString>;
+    serveTimeout: z.ZodOptional<z.ZodString>;
+    jobs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    jobsFrom: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+    }, z.core.$strict>]>>;
+    record: z.ZodOptional<z.ZodString>;
+    logs: z.ZodOptional<z.ZodString>;
+    cmd: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type BatchPresetConfig = z.infer<typeof batchPresetSchema>;
+/** Preset names that would shadow the platform operand of `warden batch`. */
+export declare const RESERVED_PRESET_NAMES: readonly string[];

package/types/core/src/builds/app-option.schema.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type BuildKind } from "./kinds";
 /**
  * What to do with the app's installed state before a run:
  * - unset: install only when the device lacks this build; a different build is installed over the old one.
@@ -14,7 +15,8 @@ export type InstallMode = z.infer<typeof installModeSchema>;
  * `app` on a batch preset / e2e suite: `true` installs the project's app on every device first;
  * `{ installMode }` also resets the installed app (see {@link InstallMode}); `{ resetKeychain: true }`
  * (needs `installMode`) also resets the iOS simulator's keychain;
- * `{ variant }` installs that `projects[].variants` build instead of the project's default one.
+ * `{ variant }` installs that `projects[].variants` build instead of the project's default one;
+ * `{ kind }` installs that build kind (`dev` | `simulator` | `release`) instead (not together with `variant`).
  * `{ clean: true }` is the deprecated spelling of `{ installMode: "reinstall" }`.
  */
 export declare const appOptionSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
@@ -25,6 +27,11 @@ export declare const appOptionSchema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodOb
     resetKeychain: z.ZodOptional<z.ZodBoolean>;
     clean: z.ZodOptional<z.ZodBoolean>;
     variant: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        release: "release";
+        dev: "dev";
+        simulator: "simulator";
+    }>>;
 }, z.core.$strict>]>;
 export type AppOption = z.infer<typeof appOptionSchema>;
 export type AppSwitches = {
@@ -32,6 +39,7 @@ export type AppSwitches = {
     installMode?: InstallMode;
     resetKeychain?: true;
     variant?: string;
+    kind?: BuildKind;
 };
 /** The switches `app` stands for. An object means install (`app: {}` = `app: true`). */
 export declare function appSwitches(app: AppOption | undefined): AppSwitches;

package/types/core/src/builds/builds.defaults.d.ts

@@ -0,0 +1,62 @@
+import type { Platform } from "../types";
+import type { AppFramework } from "./native-ids";
+/** EAS build profile searched when the project config names none. */
+export declare const DEFAULT_EAS_PROFILE = "development-simulator";
+/** Xcode / Gradle build configuration the local build produces (`build.configuration`). */
+export type BuildConfiguration = "Debug" | "Release";
+/**
+ * Makes a fresh (CNG) checkout buildable: `expo run:ios --no-install` skips CocoaPods, so generate
+ * `ios/` when it has no Podfile and run `pod install` when the Pods sandbox is missing or out of sync
+ * with `Podfile.lock` (the check Xcode's own build phase makes). A no-op on a prepared project.
+ */
+export declare const IOS_NATIVE_PREPARE: string;
+/** Local build command (run in the project root) when `build.<platform>` is not configured. */
+export declare function defaultBuildCommand(platform: Platform, configuration: BuildConfiguration, framework?: AppFramework): string;
+/** Android twin of `IOS_NATIVE_PREPARE`: generate `android/` when a CNG checkout has none. */
+export declare const ANDROID_NATIVE_PREPARE = "{ [ -f android/gradlew ] || bunx expo prebuild --platform android --no-install; }";
+/**
+ * Local build command of the `simulator` kind: the Release configuration for a simulator / emulator; a repack swaps the
+ * JS in. iOS: Xcode's bundling phase is skipped with `SKIP_BUNDLING=1`. Android: plain `assembleRelease`. Excluding
+ * `createBundleReleaseJsAndAssets` (`-x`) fails on RN 0.86 / AGP 9 ("Querying the mapped value ... before task ... has
+ * completed"), and the bundler's `drawable-*` / `raw` images are compiled into the APK's resource table by that task:
+ * without them the Android repack finds no image in the base and always falls back to a full build.
+ */
+export declare function simulatorBuildCommand(platform: Platform, framework?: AppFramework): string;
+/**
+ * What a kind's JS key (and a `release` kind's build key) covers when `kinds.<kind>.jsInputs` is not set: every file git
+ * tracks (or would) under the project root except the native projects and dependencies. A monorepo workspace package the
+ * bundle embeds is not under the root: list it (`../../packages/ui/src/**`) in `jsInputs`.
+ */
+export declare const DEFAULT_JS_INPUTS: readonly string[];
+/** The Debug defaults. */
+export declare const DEFAULT_BUILD_COMMAND: Record<Platform, string>;
+/** `warden prune` default budget. */
+export declare const DEFAULT_MAX_CACHE_SIZE = "20G";
+/** EAS poll interval while a build for the hash is in flight. */
+export declare const EAS_POLL_MS = 30000;
+/** Give up waiting on EAS after this long (then fall through to a local build). */
+export declare const EAS_TIMEOUT_MS: number;
+/** With `eas.trigger`, wait this long for a build to appear before triggering the workflow. */
+export declare const EAS_TRIGGER_GRACE_MS: number;
+/** Local native build timeout. */
+export declare const LOCAL_BUILD_TIMEOUT_MS: number;
+/** Fingerprint command timeout. */
+export declare const FINGERPRINT_TIMEOUT_MS: number;
+/** Build-lock lease ttl; the lease also carries the holder's pid so it lives as long as the process. */
+export declare const BUILD_LOCK_TTL_MS: number;
+/** How long a resolver waits for another process's build/download of the same hash. */
+export declare const BUILD_LOCK_WAIT_MS: number;
+export declare const BUILD_LOCK_POLL_MS = 2000;
+/**
+ * Pre-warden cache roots (`<dir>/<hash>/*.app|*.apk`) by project name, used when the project config
+ * sets no `cacheDirs`. Builds found there are copied into the warden cache on first use.
+ */
+export declare const LEGACY_CACHE_DIRS: Readonly<Record<string, readonly string[]>>;
+/** ccache sloppiness for Xcode/clang builds: lets worktrees with different mtimes/PCH state still hit. */
+export declare const CCACHE_SLOPPINESS = "clang_index_store,file_stat_matches,include_file_ctime,include_file_mtime,ivfsoverlay,pch_defines,modules,system_headers,time_macros";
+/** Subdirectory of WARDEN_HOME holding the shared ccache. */
+export declare const CCACHE_DIR_NAME = "ccache";
+/** First Xcode major with compilation caching (`COMPILATION_CACHE_ENABLE_CACHING`). */
+export declare const XCODE_COMPILATION_CACHE_MIN_MAJOR = 26;
+/** Timeout for the quick `git` / `xcodebuild -version` probes before a build. */
+export declare const PROBE_TIMEOUT_MS = 10000;

package/types/core/src/builds/config.d.ts

@@ -0,0 +1,122 @@
+import { type Result } from "../../../types/src/result";
+import type { z } from "zod";
+import type { Platform } from "../types";
+import { type BuildConfiguration } from "./builds.defaults";
+import type { projectConfigSchema, wardenConfigSchema } from "./config.schema";
+import type { BuildKind, ProjectKinds } from "./kinds";
+import { type AppFramework } from "./native-ids";
+/** The preferred config file, named in hints. */
+export declare const CONFIG_FILE = "warden.config.ts";
+/** Still read, so JSON configs keep working. */
+export declare const JSON_CONFIG_FILE = "warden.config.json";
+/** Every file name `findWardenConfig` looks for, in preference order; at most one may exist per dir. */
+export declare const CONFIG_FILES: string[];
+/** Parsed (defaults applied). The documented input types live in `define-config.ts`. */
+export type ParsedProjectConfig = z.infer<typeof projectConfigSchema>;
+export type ParsedWardenConfig = z.infer<typeof wardenConfigSchema>;
+export type EasSettings = {
+    profile: string;
+    workflow?: string;
+    trigger: boolean;
+};
+/** A project ready for the build cache: absolute root, defaults applied. */
+export type Project = {
+    name: string;
+    root: string;
+    bundleId: {
+        ios?: string;
+        android?: string;
+    };
+    fingerprintCommand?: string;
+    /** set = JS-aware key (`fingerprint.include: "native+js"`): globs of the JS sources the key covers */
+    jsInputs?: string[];
+    /** undefined = EAS not used (no `eas` config and no `eas.json`) */
+    eas?: EasSettings;
+    build: Record<Platform, string>;
+    /** Debug unless `build.configuration` says Release */
+    buildConfiguration: BuildConfiguration;
+    /** false = `build.cache: false`: no shared compiler caches in local builds */
+    compilerCache?: false;
+    /** false = `build.prebuiltReactNative: false`: never opt iOS builds into the precompiled RN core */
+    prebuiltReactNative?: false;
+    /** the `variants.<name>` this project was resolved with; undefined = the project's own settings */
+    variant?: string;
+    /** `projects[].kinds`: per-kind overrides of the built-in dev / simulator / release builds (see `kinds.ts`) */
+    kinds?: ProjectKinds;
+    /** set by `projectForKind`: the kind this project is resolved as; undefined = the kind-less flow */
+    kind?: BuildKind;
+    /** set by `projectForKind`: env of the local build (`kinds.<kind>.env`) */
+    buildEnv?: Record<string, string>;
+    cacheDirs: string[];
+    /** `expo` (expo start + a dev client) or bare `react-native` (react-native start, the app itself) */
+    framework: AppFramework;
+    /** where the project came from; `react-native` = autodetected from a bare app's package.json + native projects */
+    origin: "config" | "app.json" | "app.config" | "react-native";
+    /** which lookup found it: the repo's own config, the `~/.warden` overlay config, or autodetected from the app config */
+    source: ConfigSource;
+};
+/** `repo` = a `warden.config.*` in the checkout; `overlay` = one in `<WARDEN_HOME>/projects/<key>/`; `auto` = none (app.json). */
+export type ConfigSource = "repo" | "overlay" | "auto";
+/** A parsed warden config and where it was found. */
+export type FoundConfig = {
+    /** the config's own dir: what a config function sees as `configDir`, and what suite `specsDir`s resolve against */
+    dir: string;
+    config: ParsedWardenConfig;
+    source: Exclude<ConfigSource, "auto">;
+    /** what `projects[].root` resolves against: `dir` for a repo config, the checkout root for an overlay one */
+    rootDir: string;
+};
+/** Validate a config value; `file` names it in the error. */
+export declare function parseWardenConfig(raw: unknown, file?: string): Result<ParsedWardenConfig>;
+/** Pick the project containing `start` (deepest root wins); a single project is picked regardless. */
+export declare function selectProject(projects: readonly Project[], start: string, name?: string): Result<Project>;
+export type LoadProjectInput = {
+    /** `--project` dir or cwd */
+    start: string;
+    env: Record<string, string | undefined>;
+    /** stop walking up here (git toplevel); default filesystem root */
+    stopAt?: string;
+    name?: string;
+    /** `--bundle-id` for the requested platform */
+    bundleId?: Project["bundleId"];
+    /** `projects[].variants.<name>` to resolve the project with */
+    variant?: string;
+    /** a missing `variant` falls back to the project's own settings instead of erroring (`warden dev`) */
+    variantOptional?: boolean;
+    /** `<WARDEN_HOME>/projects/<key>/` (see `overlay.ts`): its config is used when the repo has none */
+    overlayDir?: string;
+    /** the app's slug when `app.json` has none (read from `expo config` for a dynamic `app.config.*`) */
+    appName?: string;
+};
+/** Is there a warden config file in `start` or a parent (to `stopAt`)? File names only: nothing is evaluated. */
+export declare function hasRepoConfig(start: string, stopAt?: string): boolean;
+/**
+ * The nearest `warden.config.{ts,mts,js,mjs,json}` walking up from `start` (to `stopAt`), parsed;
+ * undefined = none. Else the one in `overlayDir`, if given (project roots then resolve against the
+ * checkout: `stopAt`, else `start`). A config function gets `{ configDir, env }`.
+ */
+export declare function findWardenConfig(start: string, stopAt?: string, env?: Record<string, string | undefined>, overlayDir?: string): Result<FoundConfig | undefined>;
+/**
+ * Find the project for `start`: nearest warden config walking up (to `stopAt`), else the
+ * `overlayDir` config, else the nearest Expo app (`app.json` / `app.config.*`). `--bundle-id` overrides the configured id.
+ */
+export declare function loadProject(input: LoadProjectInput): Result<Project>;
+/**
+ * The app dirs below `root` (a monorepo root): its `package.json` workspaces, else `apps/*` and
+ * `packages/*`, that hold a React Native app (`isAppDir`). Sorted, no duplicates.
+ */
+export declare function appDirsBelow(root: string): string[];
+/**
+ * Where the project lookup really starts: `start`, unless nothing is found from there upwards and
+ * exactly one app sits below it (a monorepo root), then that app's dir.
+ */
+export declare function appStart(start: string, stopAt?: string, overlayDir?: string): string;
+/** The apps below `start` to pick from, when nothing is found upwards and there are several; else empty. */
+export declare function appChoices(start: string, stopAt?: string, overlayDir?: string): string[];
+/**
+ * The app dir `loadProject` would autodetect from `start` whose bundle id only Expo can read: no warden
+ * config in reach, a dynamic `app.config.*`, and neither `app.json` nor `bundleOverride` names a bundle id.
+ * Undefined otherwise. File names and `app.json` only: nothing is evaluated.
+ */
+export declare function dynamicAppConfigDir(start: string, stopAt: string | undefined, bundleOverride?: Project["bundleId"], overlayDir?: string): string | undefined;
+export declare function bundleIdFor(project: Project, platform: Platform): Result<string>;