@stim-cli/cache 1.0.0-rc.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Janic Duplessis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# @stim-cli/cache
+
+The cache provider contract Stim uses for Metro transforms and native build
+artifacts, plus the tier coordination, timeout, and warning policy that sit in
+front of it.
+
+The local filesystem is always the first tier. A project can add one optional
+second tier by pointing `cache.provider` at a module that implements this
+contract. Stim ships no network provider; writing one is an addition, not a
+change to Stim.
+
+If Stim is not installed globally, replace `stim` with `npx stim-cli`.
+
+## Selecting a provider
+
+```json
+{
+  "cache": {
+    "provider": "./tools/cache-provider.cjs",
+    "options": { "bucket": "mobile-cache" }
+  }
+}
+```
+
+The reference is a package name or a path relative to the settings file that
+declares it. Machine settings override committed `.stim.json` settings, and the
+existing nested merge rules apply to `cache.options`. Keep secrets out of
+committed settings; read them from the environment or from machine settings.
+
+## Writing a provider
+
+```js
+export const apiVersion = 1;
+
+export async function createCacheProvider({ projectRoot, options }) {
+  return {
+    metro: {
+      async get({ key, cacheName, signal }) {
+        return null;
+      },
+      async set({ key, value, cacheName, signal }) {},
+    },
+    builds: {
+      async resolve({ platform, key, destinationDir, signal }) {
+        return null;
+      },
+      async store({ platform, key, sourcePath, overwrite, signal }) {},
+    },
+  };
+}
+```
+
+A provider implements one or both capabilities. It owns transport,
+serialization, archive format, authentication, and remote retention. Stim owns
+fingerprints, cache keys, and local artifact paths.
+
+`metro.get` returns the stored value or `null`.
+
+`builds.resolve` returns an existing path to the artifact, or `null` for a
+miss. `destinationDir` is a scratch directory Stim creates and owns: a provider
+that fetches the artifact must materialize it there and return a path inside
+it, and must leave the directory empty on a miss. The built-in filesystem tier
+already holds the artifact, so it returns its own cache path instead.
+
+`builds.store` receives the `.app` directory or `.apk` file that Stim just
+built. `overwrite: false` must keep an entry that already exists for the key,
+and `overwrite: true` must replace it.
+
+Every call receives an `AbortSignal`. A provider must honor it: Stim abandons
+the call at the deadline and keeps building or bundling with the local tier.
+
+`stim gc` never deletes provider data, and the contract has no delete
+operation, so shared team or CI data is never removed by a local command.
+
+## Failure rules
+
+Provider failures are cache misses. A timeout, module error, authentication
+error, or network error produces one warning per failure class per command or
+supervisor run and never fails a bundle, an install, a launch, or a successful
+build.
+
+## Contract tests
+
+Run the shipped checks against your own module:
+
+```js
+import { runCacheProviderContract } from '@stim-cli/cache';
+
+const results = await runCacheProviderContract({
+  provider: await createCacheProvider({ projectRoot, options }),
+  projectRoot,
+  workDir,
+});
+
+for (const result of results) {
+  if (!result.passed) throw new Error(`${result.name}: ${result.error}`);
+}
+```
+
+Pass `providerModule` instead of `provider` to load the module the way Stim
+does, which also checks `apiVersion` and the factory:
+
+```js
+const results = await runCacheProviderContract({
+  providerModule: './tools/cache-provider.cjs',
+  projectRoot,
+  workDir,
+});
+```
+
+`cacheProviderContractChecks()` returns the same checks as individual cases for
+a test runner that reports each one separately. Both helpers only check the
+capabilities a provider advertises, bound every check with a deadline, and
+verify that a call settles once its `AbortSignal` aborts.
+
+## Budgets
+
+Every provider call is bounded. The defaults are 2s for a Metro read, 10s for a
+Metro write, 30s for a build lookup, 60s for a build upload, and 10s to load the
+module. Override any of them per run with an environment variable:
+
+```bash
+STIM_CACHE_METRO_READ_TIMEOUT_MS=5000 stim start
+STIM_CACHE_BUILD_RESOLVE_TIMEOUT_MS=60000 stim ios
+```
+
+The variables are `STIM_CACHE_METRO_READ_TIMEOUT_MS`,
+`STIM_CACHE_METRO_WRITE_TIMEOUT_MS`, `STIM_CACHE_BUILD_RESOLVE_TIMEOUT_MS`,
+`STIM_CACHE_BUILD_UPLOAD_TIMEOUT_MS`, and `STIM_CACHE_LOAD_TIMEOUT_MS`. Each
+takes whole milliseconds; any other value keeps the default.
+
+The tiered Metro store also exposes `flush()`, which resolves once queued
+provider writes have drained. Metro never calls it; every in-flight write holds
+a referenced deadline, so a Metro process drains on its own within the write
+budget. It exists for tests and embedders that own the process.
+
+Metro reads are also capped: at most six can be in flight, and the tier turns
+itself off for the rest of the run after five consecutive failures, so a broken
+provider costs one round of warnings rather than a timeout per transform.
+
+The npm scope remains `@stim-cli` until the `@stim` scope is available.

package/dist/index.d.mts

@@ -0,0 +1,252 @@
+//#region provider.d.ts
+declare const CACHE_PROVIDER_API_VERSION: 1;
+declare const CACHE_PROVIDER_ENV = "STIM_CACHE_PROVIDER_CONFIG";
+declare const CACHE_PROVIDER_ENV_NONE = "none";
+declare const PROVIDER_LOAD_TIMEOUT_MS = 1e4;
+declare const PROVIDER_LOAD_TIMEOUT_ENV = "STIM_CACHE_LOAD_TIMEOUT_MS";
+/**
+ * Reads a positive integer millisecond override from the environment. Any other
+ * value falls back to the shipped default.
+ */
+declare function timeoutFromEnv(name: string, fallback: number, env?: NodeJS.ProcessEnv): number;
+/**
+ * One resolved provider selection: the module reference, the options passed to
+ * its factory, and the directory the reference resolves from.
+ */
+interface CacheProviderConfig {
+  provider: string;
+  options: Record<string, unknown>;
+  baseDir: string;
+}
+interface MetroCacheContext {
+  projectRoot: string;
+  cacheName: string;
+  signal: AbortSignal;
+}
+interface MetroCacheGetInput extends MetroCacheContext {
+  key: Buffer;
+}
+interface MetroCacheSetInput extends MetroCacheContext {
+  key: Buffer;
+  value: unknown;
+}
+/**
+ * Metro transform cache. `get` returns `null` or `undefined` for a miss. `set`
+ * stores the value under the key. Both receive an `AbortSignal` the provider
+ * must honor.
+ */
+interface MetroCacheCapability {
+  get(input: MetroCacheGetInput): unknown;
+  set(input: MetroCacheSetInput): void | Promise<void>;
+}
+interface BuildCacheTarget {
+  projectRoot: string;
+  platform: "ios" | "android";
+  key: string;
+}
+interface BuildCacheContext extends BuildCacheTarget {
+  signal: AbortSignal;
+}
+interface BuildResolveInput extends BuildCacheContext {
+  destinationDir: string;
+}
+interface BuildStoreInput extends BuildCacheContext {
+  sourcePath: string;
+  overwrite: boolean;
+}
+/**
+ * Native build artifacts.
+ *
+ * `resolve` returns an existing path to the artifact for the key, or `null` for
+ * a miss. `destinationDir` is a scratch directory Stim creates and owns: a
+ * capability that fetches the artifact must materialize it there and return a
+ * path inside it, and a capability that already holds a local copy (the
+ * built-in filesystem tier) returns that copy instead. A miss must leave
+ * `destinationDir` empty.
+ *
+ * `store` publishes the `.app` directory or `.apk` file at `sourcePath`.
+ * `overwrite: false` must keep an entry that already exists for the key;
+ * `overwrite: true` must replace it. A capability that owns a local path
+ * returns it, and any other capability returns nothing.
+ *
+ * Stim owns fingerprints and cache keys; the capability owns transport,
+ * archive format, authentication, and retention.
+ */
+interface BuildCacheCapability {
+  resolve(input: BuildResolveInput): string | null | Promise<string | null>;
+  store(input: BuildStoreInput): string | null | void | Promise<string | null | void>;
+}
+interface CacheProvider {
+  metro?: MetroCacheCapability;
+  builds?: BuildCacheCapability;
+}
+/**
+ * The module shape a provider author exports. The loader rejects any other
+ * `apiVersion`.
+ */
+interface CacheProviderModule {
+  apiVersion: typeof CACHE_PROVIDER_API_VERSION;
+  createCacheProvider(input: {
+    projectRoot: string;
+    options: Record<string, unknown>;
+  }): CacheProvider | Promise<CacheProvider>;
+}
+interface LoadCacheProviderResult {
+  provider?: CacheProvider;
+  name?: string;
+  none?: true;
+  unavailable?: string;
+}
+interface ProviderCallResult<T> {
+  value?: T;
+  failed?: string;
+  timedOut?: true;
+}
+type WarnOnce = (code: string, message: string) => void;
+declare function loadCacheProvider({ projectRoot, config, timeoutMs }: {
+  projectRoot: string;
+  config?: CacheProviderConfig | null;
+  timeoutMs?: number;
+}): Promise<LoadCacheProviderResult>;
+declare function callWithTimeout<T>(call: (signal: AbortSignal) => T | Promise<T>, timeoutMs: number): Promise<ProviderCallResult<T>>;
+declare function createWarnOnce(emit: (message: string) => void): WarnOnce;
+declare function cacheProviderEnv(config: CacheProviderConfig | null): string;
+/**
+ * True when a parent process decided the provider selection, including the
+ * `none` sentinel. A child must not run its own search once this is set.
+ */
+declare function cacheProviderEnvIsSet(env?: NodeJS.ProcessEnv): boolean;
+declare function cacheProviderConfigFromEnv(env?: NodeJS.ProcessEnv): CacheProviderConfig | null;
+//#endregion
+//#region metro.d.ts
+declare const METRO_READ_TIMEOUT_MS = 2e3;
+declare const METRO_WRITE_TIMEOUT_MS = 1e4;
+declare const METRO_READ_CONCURRENCY = 6;
+declare const METRO_READ_FAILURE_LIMIT = 5;
+declare const METRO_UPLOAD_CONCURRENCY = 4;
+declare const METRO_UPLOAD_MAX_ITEMS = 128;
+declare const METRO_UPLOAD_MAX_BYTES: number;
+declare const METRO_READ_TIMEOUT_ENV = "STIM_CACHE_METRO_READ_TIMEOUT_MS";
+declare const METRO_WRITE_TIMEOUT_ENV = "STIM_CACHE_METRO_WRITE_TIMEOUT_MS";
+/**
+ * Metro's structural cache-store contract: `get` returns the value or `null`,
+ * `set` stores it, and `clear` empties the store.
+ */
+interface MetroCacheStore {
+  get(key: Buffer): unknown;
+  set(key: Buffer, value: unknown): unknown;
+  clear(): unknown;
+}
+interface TieredMetroStore extends MetroCacheStore {
+  get(key: Buffer): Promise<unknown>;
+  set(key: Buffer, value: unknown): Promise<void>;
+  clear(): unknown;
+  /**
+   * Resolves once queued provider writes have drained. Metro never calls it:
+   * every in-flight write already holds a referenced deadline, so the process
+   * drains on its own. Tests and embedders that own the process use it to wait
+   * without polling.
+   */
+  flush(): Promise<void>;
+}
+interface MetroTierLimits {
+  concurrency?: number;
+  maxItems?: number;
+  maxBytes?: number;
+  readConcurrency?: number;
+  failureLimit?: number;
+}
+interface MetroTierTimeouts {
+  readMs?: number;
+  writeMs?: number;
+}
+interface TieredMetroStoreOptions {
+  local: MetroCacheStore;
+  projectRoot: string;
+  cacheName: string;
+  loadProvider: () => Promise<LoadCacheProviderResult>;
+  warn?: WarnOnce;
+  limits?: MetroTierLimits;
+  timeouts?: MetroTierTimeouts;
+}
+declare function metroCapabilityFromStore(store: MetroCacheStore): MetroCacheCapability;
+declare function createTieredMetroStore({ local, projectRoot, cacheName, loadProvider, warn: emit, limits, timeouts }: TieredMetroStoreOptions): TieredMetroStore;
+//#endregion
+//#region builds.d.ts
+declare const BUILD_RESOLVE_TIMEOUT_MS = 3e4;
+declare const BUILD_UPLOAD_TIMEOUT_MS = 6e4;
+declare const BUILD_RESOLVE_TIMEOUT_ENV = "STIM_CACHE_BUILD_RESOLVE_TIMEOUT_MS";
+declare const BUILD_UPLOAD_TIMEOUT_ENV = "STIM_CACHE_BUILD_UPLOAD_TIMEOUT_MS";
+declare function buildResolveTimeoutMs(env?: NodeJS.ProcessEnv): number;
+declare function buildUploadTimeoutMs(env?: NodeJS.ProcessEnv): number;
+interface TieredBuildResolution {
+  path: string;
+  tier: "local" | "provider";
+  providerName?: string;
+  storedLocally?: boolean;
+}
+type LoadBuildProvider = () => Promise<LoadCacheProviderResult> | LoadCacheProviderResult;
+interface ResolveTieredBuildOptions {
+  local: BuildCacheCapability;
+  loadProvider?: LoadBuildProvider | null;
+  target: BuildCacheTarget;
+  destinationDir: string;
+  /** Called right before a provider is asked, so a local hit creates nothing on disk. */
+  ensureDestination?: (destinationDir: string) => void;
+  skipRead?: boolean;
+  warn?: WarnOnce;
+  timeoutMs?: number;
+}
+interface StoreTieredBuildOptions {
+  local: BuildCacheCapability;
+  loadProvider?: LoadBuildProvider | null;
+  target: BuildCacheTarget;
+  sourcePath: string;
+  overwrite: boolean;
+  warn?: WarnOnce;
+  timeoutMs?: number;
+}
+interface TieredBuildStoreResult {
+  localPath: string | null;
+  providerUpload: Promise<ProviderCallResult<void>> | null;
+  providerName: string | null;
+}
+declare function resolveTieredBuild({ local, loadProvider, target, destinationDir, ensureDestination, skipRead, warn, timeoutMs }: ResolveTieredBuildOptions): Promise<TieredBuildResolution | null>;
+declare function storeTieredBuild({ local, loadProvider, target, sourcePath, overwrite, warn, timeoutMs }: StoreTieredBuildOptions): Promise<TieredBuildStoreResult>;
+//#endregion
+//#region contract.d.ts
+interface CacheContractCheck {
+  name: string;
+  capability: "metro" | "builds";
+  run(): Promise<void>;
+}
+interface CacheContractResult {
+  name: string;
+  capability: "metro" | "builds" | "module";
+  passed: boolean;
+  error?: string;
+}
+interface CacheContractOptions {
+  provider: CacheProvider;
+  projectRoot: string;
+  workDir: string;
+  cacheName?: string;
+  platform?: "ios" | "android";
+  checkTimeoutMs?: number;
+  abortSettleMs?: number;
+}
+/**
+ * Loads the provider the way Stim does, from a module reference, so a provider
+ * author exercises `apiVersion` and factory validation as well as the
+ * capability checks.
+ */
+interface CacheContractModuleOptions extends Omit<CacheContractOptions, "provider"> {
+  providerModule: string;
+  options?: Record<string, unknown>;
+  baseDir?: string;
+}
+declare const CACHE_CONTRACT_CHECK_TIMEOUT_MS = 3e4;
+declare function cacheProviderContractChecks(options: CacheContractOptions): CacheContractCheck[];
+declare function runCacheProviderContract(options: CacheContractOptions | CacheContractModuleOptions): Promise<CacheContractResult[]>;
+//#endregion
+export { BUILD_RESOLVE_TIMEOUT_ENV, BUILD_RESOLVE_TIMEOUT_MS, BUILD_UPLOAD_TIMEOUT_ENV, BUILD_UPLOAD_TIMEOUT_MS, BuildCacheCapability, BuildCacheContext, BuildCacheTarget, BuildResolveInput, BuildStoreInput, CACHE_CONTRACT_CHECK_TIMEOUT_MS, CACHE_PROVIDER_API_VERSION, CACHE_PROVIDER_ENV, CACHE_PROVIDER_ENV_NONE, CacheContractCheck, CacheContractModuleOptions, CacheContractOptions, CacheContractResult, CacheProvider, CacheProviderConfig, CacheProviderModule, LoadBuildProvider, LoadCacheProviderResult, METRO_READ_CONCURRENCY, METRO_READ_FAILURE_LIMIT, METRO_READ_TIMEOUT_ENV, METRO_READ_TIMEOUT_MS, METRO_UPLOAD_CONCURRENCY, METRO_UPLOAD_MAX_BYTES, METRO_UPLOAD_MAX_ITEMS, METRO_WRITE_TIMEOUT_ENV, METRO_WRITE_TIMEOUT_MS, MetroCacheCapability, MetroCacheContext, MetroCacheGetInput, MetroCacheSetInput, MetroCacheStore, MetroTierLimits, MetroTierTimeouts, PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, ProviderCallResult, ResolveTieredBuildOptions, StoreTieredBuildOptions, TieredBuildResolution, TieredBuildStoreResult, TieredMetroStore, TieredMetroStoreOptions, WarnOnce, buildResolveTimeoutMs, buildUploadTimeoutMs, cacheProviderConfigFromEnv, cacheProviderContractChecks, cacheProviderEnv, cacheProviderEnvIsSet, callWithTimeout, createTieredMetroStore, createWarnOnce, loadCacheProvider, metroCapabilityFromStore, resolveTieredBuild, runCacheProviderContract, storeTieredBuild, timeoutFromEnv };

package/dist/index.mjs

@@ -0,0 +1,889 @@
+import { createRequire } from "node:module";
+import { join, relative, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { randomBytes, randomUUID } from "node:crypto";
+//#region provider.ts
+const CACHE_PROVIDER_API_VERSION = 1;
+const CACHE_PROVIDER_ENV = "STIM_CACHE_PROVIDER_CONFIG";
+const CACHE_PROVIDER_ENV_NONE = "none";
+const PROVIDER_LOAD_TIMEOUT_MS = 1e4;
+const PROVIDER_LOAD_TIMEOUT_ENV = "STIM_CACHE_LOAD_TIMEOUT_MS";
+/**
+* Reads a positive integer millisecond override from the environment. Any other
+* value falls back to the shipped default.
+*/
+function timeoutFromEnv(name, fallback, env = process.env) {
+	const raw = env[name];
+	if (typeof raw !== "string" || !/^[1-9]\d*$/.test(raw.trim())) return fallback;
+	const parsed = Number(raw.trim());
+	return Number.isSafeInteger(parsed) ? parsed : fallback;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function reason(error) {
+	return String(error?.message || error || "unknown error").split("\n")[0].trim() || "unknown error";
+}
+function moduleCandidate(namespace) {
+	if (!isRecord(namespace)) return namespace;
+	if ("apiVersion" in namespace) return namespace;
+	return "default" in namespace ? namespace.default : namespace;
+}
+function capabilityError(provider) {
+	const metro = provider.metro;
+	if (metro !== void 0 && (typeof metro?.get !== "function" || typeof metro?.set !== "function")) return "the metro capability must implement get() and set()";
+	const builds = provider.builds;
+	if (builds !== void 0 && (typeof builds?.resolve !== "function" || typeof builds?.store !== "function")) return "the builds capability must implement resolve() and store()";
+	if (metro === void 0 && builds === void 0) return "the provider advertises neither a metro nor a builds capability";
+	return null;
+}
+async function loadCacheProvider({ projectRoot, config, timeoutMs = timeoutFromEnv(PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS) }) {
+	const reference = typeof config?.provider === "string" ? config.provider.trim() : "";
+	if (!config || reference === "") return { none: true };
+	const outcome = await callWithTimeout(() => importCacheProvider({
+		projectRoot,
+		config,
+		reference
+	}), timeoutMs);
+	if (outcome.timedOut) return {
+		name: reference,
+		unavailable: `the module did not load within ${timeoutMs}ms`
+	};
+	if (outcome.failed) return {
+		name: reference,
+		unavailable: outcome.failed
+	};
+	return outcome.value ?? {
+		name: reference,
+		unavailable: "the module produced no provider"
+	};
+}
+async function importCacheProvider({ projectRoot, config, reference }) {
+	const options = isRecord(config.options) ? config.options : {};
+	const baseDir = typeof config.baseDir === "string" && config.baseDir !== "" ? config.baseDir : projectRoot;
+	let namespace;
+	try {
+		const resolved = createRequire(join(baseDir, "package.json")).resolve(reference);
+		namespace = await import(pathToFileURL(resolved).href);
+	} catch (error) {
+		return {
+			name: reference,
+			unavailable: reason(error)
+		};
+	}
+	const candidate = moduleCandidate(namespace);
+	if (!isRecord(candidate) || candidate.apiVersion !== 1) return {
+		name: reference,
+		unavailable: `expected apiVersion 1, found ${JSON.stringify(isRecord(candidate) ? candidate.apiVersion : candidate)}`
+	};
+	if (typeof candidate.createCacheProvider !== "function") return {
+		name: reference,
+		unavailable: "the module does not export createCacheProvider()"
+	};
+	let provider;
+	try {
+		provider = await candidate.createCacheProvider({
+			projectRoot,
+			options
+		});
+	} catch (error) {
+		return {
+			name: reference,
+			unavailable: `createCacheProvider() failed: ${reason(error)}`
+		};
+	}
+	if (!isRecord(provider)) return {
+		name: reference,
+		unavailable: "createCacheProvider() did not return a provider object"
+	};
+	const invalid = capabilityError(provider);
+	if (invalid) return {
+		name: reference,
+		unavailable: invalid
+	};
+	return {
+		name: reference,
+		provider
+	};
+}
+async function callWithTimeout(call, timeoutMs) {
+	const controller = new AbortController();
+	let timer = null;
+	const expired = new Promise((resolve) => {
+		timer = setTimeout(() => {
+			controller.abort();
+			resolve("timeout");
+		}, timeoutMs);
+	});
+	try {
+		const outcome = await Promise.race([Promise.resolve().then(() => call(controller.signal)).then((value) => ({ value }), (error) => ({ failed: reason(error) })), expired]);
+		return outcome === "timeout" ? { timedOut: true } : outcome;
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+function createWarnOnce(emit) {
+	const seen = /* @__PURE__ */ new Set();
+	return (code, message) => {
+		if (seen.has(code)) return;
+		seen.add(code);
+		emit(message);
+	};
+}
+function cacheProviderEnv(config) {
+	if (!config) return CACHE_PROVIDER_ENV_NONE;
+	return JSON.stringify({
+		provider: config.provider,
+		options: config.options ?? {},
+		baseDir: config.baseDir
+	});
+}
+/**
+* True when a parent process decided the provider selection, including the
+* `none` sentinel. A child must not run its own search once this is set.
+*/
+function cacheProviderEnvIsSet(env = process.env) {
+	const raw = env[CACHE_PROVIDER_ENV];
+	return typeof raw === "string" && raw.trim() !== "";
+}
+function cacheProviderConfigFromEnv(env = process.env) {
+	const raw = env[CACHE_PROVIDER_ENV];
+	if (typeof raw !== "string" || raw.trim() === "" || raw.trim() === "none") return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!isRecord(parsed)) return null;
+	const provider = parsed.provider;
+	const baseDir = parsed.baseDir;
+	if (typeof provider !== "string" || provider.trim() === "" || typeof baseDir !== "string" || baseDir === "") return null;
+	return {
+		provider,
+		options: isRecord(parsed.options) ? parsed.options : {},
+		baseDir
+	};
+}
+//#endregion
+//#region metro.ts
+const METRO_READ_TIMEOUT_MS = 2e3;
+const METRO_WRITE_TIMEOUT_MS = 1e4;
+const METRO_READ_CONCURRENCY = 6;
+const METRO_READ_FAILURE_LIMIT = 5;
+const METRO_UPLOAD_CONCURRENCY = 4;
+const METRO_UPLOAD_MAX_ITEMS = 128;
+const METRO_UPLOAD_MAX_BYTES = 33554432;
+const METRO_READ_TIMEOUT_ENV = "STIM_CACHE_METRO_READ_TIMEOUT_MS";
+const METRO_WRITE_TIMEOUT_ENV = "STIM_CACHE_METRO_WRITE_TIMEOUT_MS";
+function metroCapabilityFromStore(store) {
+	return {
+		get: ({ key }) => store.get(key),
+		set: async ({ key, value }) => {
+			await store.set(key, value);
+		}
+	};
+}
+const defaultWarn = (_code, message) => {
+	process.stderr.write(`${message}\n`);
+};
+function onceByCode(warn) {
+	const seen = /* @__PURE__ */ new Set();
+	return (code, message) => {
+		if (seen.has(code)) return;
+		seen.add(code);
+		warn(code, message);
+	};
+}
+function valueBytes(value) {
+	if (Buffer.isBuffer(value)) return value.length;
+	try {
+		const json = JSON.stringify(value);
+		return json === void 0 ? null : Buffer.byteLength(json);
+	} catch {
+		return null;
+	}
+}
+function createUploadQueue({ concurrency, maxItems, maxBytes }) {
+	const pending = [];
+	const waiters = [];
+	let active = 0;
+	let items = 0;
+	let bytes = 0;
+	function settle() {
+		if (active > 0 || pending.length > 0) return;
+		while (waiters.length) waiters.shift()?.();
+	}
+	function pump() {
+		while (active < concurrency && pending.length > 0) {
+			const task = pending.shift();
+			active += 1;
+			task.run().catch(() => {}).finally(() => {
+				active -= 1;
+				items -= 1;
+				bytes -= task.bytes;
+				pump();
+				settle();
+			});
+		}
+	}
+	return {
+		add(size, run) {
+			if (items + 1 > maxItems || bytes + size > maxBytes) return false;
+			items += 1;
+			bytes += size;
+			pending.push({
+				bytes: size,
+				run
+			});
+			pump();
+			return true;
+		},
+		idle() {
+			if (active === 0 && pending.length === 0) return Promise.resolve();
+			return new Promise((resolve) => waiters.push(resolve));
+		}
+	};
+}
+function createTieredMetroStore({ local, projectRoot, cacheName, loadProvider, warn: emit = defaultWarn, limits = {}, timeouts = {} }) {
+	const warn = onceByCode(emit);
+	const localCapability = metroCapabilityFromStore(local);
+	const readMs = timeouts.readMs ?? timeoutFromEnv("STIM_CACHE_METRO_READ_TIMEOUT_MS", 2e3);
+	const writeMs = timeouts.writeMs ?? timeoutFromEnv("STIM_CACHE_METRO_WRITE_TIMEOUT_MS", 1e4);
+	const readConcurrency = limits.readConcurrency ?? 6;
+	const failureLimit = limits.failureLimit ?? 5;
+	const queue = createUploadQueue({
+		concurrency: limits.concurrency ?? 4,
+		maxItems: limits.maxItems ?? 128,
+		maxBytes: limits.maxBytes ?? 33554432
+	});
+	let loading = null;
+	let disabled = false;
+	let consecutiveFailures = 0;
+	let activeReads = 0;
+	function recordFailure() {
+		consecutiveFailures += 1;
+		if (consecutiveFailures < failureLimit) return;
+		disabled = true;
+		warn("provider-disabled", `the cache provider failed ${consecutiveFailures} times in a row; this run keeps its transforms local`);
+	}
+	function providerCapability() {
+		if (disabled) return Promise.resolve(null);
+		loading ??= loadProvider().then((loaded) => {
+			if (loaded?.unavailable) {
+				disabled = true;
+				warn("provider-load", `cache provider ${loaded.name} is not usable: ${loaded.unavailable}; using local transforms`);
+				return null;
+			}
+			return loaded?.provider?.metro ?? null;
+		});
+		return loading;
+	}
+	return {
+		async get(key) {
+			const hit = await localCapability.get({
+				key,
+				projectRoot,
+				cacheName,
+				signal: neverAborted$2()
+			});
+			if (hit !== null && hit !== void 0) return hit;
+			if (activeReads >= readConcurrency) {
+				warn("provider-read-busy", `the cache provider already has ${activeReads} reads in flight; further transforms read locally until it catches up`);
+				return null;
+			}
+			activeReads += 1;
+			let outcome;
+			try {
+				const capability = await providerCapability();
+				if (!capability) return null;
+				outcome = await callWithTimeout((signal) => capability.get({
+					key,
+					projectRoot,
+					cacheName,
+					signal
+				}), readMs);
+			} finally {
+				activeReads -= 1;
+			}
+			if (outcome.timedOut) {
+				recordFailure();
+				warn("provider-read", `the cache provider did not answer a transform read within ${readMs}ms; using local transforms`);
+				return null;
+			}
+			if (outcome.failed) {
+				recordFailure();
+				warn("provider-read", `the cache provider could not read a transform: ${outcome.failed}; using local transforms`);
+				return null;
+			}
+			consecutiveFailures = 0;
+			const value = outcome.value;
+			if (value === null || value === void 0) return null;
+			try {
+				await localCapability.set({
+					key,
+					value,
+					projectRoot,
+					cacheName,
+					signal: neverAborted$2()
+				});
+			} catch (error) {
+				warn("provider-backfill", `a provider transform could not be written locally: ${String(error?.message || error)}`);
+			}
+			return value;
+		},
+		async set(key, value) {
+			await localCapability.set({
+				key,
+				value,
+				projectRoot,
+				cacheName,
+				signal: neverAborted$2()
+			});
+			const capability = await providerCapability();
+			if (!capability) return;
+			const bytes = valueBytes(value);
+			if (bytes === null) {
+				warn("provider-write", "a transform could not be measured for the cache provider; it stays local");
+				return;
+			}
+			if (!queue.add(bytes, async () => {
+				if (disabled) return;
+				const outcome = await callWithTimeout((signal) => capability.set({
+					key,
+					value,
+					projectRoot,
+					cacheName,
+					signal
+				}), writeMs);
+				if (outcome.timedOut || outcome.failed) recordFailure();
+				else consecutiveFailures = 0;
+				if (outcome.timedOut) warn("provider-write", `the cache provider did not accept a transform within ${writeMs}ms; later transforms stay local until it answers`);
+				else if (outcome.failed) warn("provider-write", `the cache provider could not store a transform: ${outcome.failed}`);
+			})) warn("provider-queue", "the cache provider upload queue is full; those transforms stay local");
+		},
+		clear() {
+			return local.clear();
+		},
+		flush() {
+			return queue.idle();
+		}
+	};
+}
+function neverAborted$2() {
+	return new AbortController().signal;
+}
+//#endregion
+//#region builds.ts
+const BUILD_RESOLVE_TIMEOUT_MS = 3e4;
+const BUILD_UPLOAD_TIMEOUT_MS = 6e4;
+const BUILD_RESOLVE_TIMEOUT_ENV = "STIM_CACHE_BUILD_RESOLVE_TIMEOUT_MS";
+const BUILD_UPLOAD_TIMEOUT_ENV = "STIM_CACHE_BUILD_UPLOAD_TIMEOUT_MS";
+function buildResolveTimeoutMs(env) {
+	return timeoutFromEnv(BUILD_RESOLVE_TIMEOUT_ENV, BUILD_RESOLVE_TIMEOUT_MS, env);
+}
+function buildUploadTimeoutMs(env) {
+	return timeoutFromEnv(BUILD_UPLOAD_TIMEOUT_ENV, BUILD_UPLOAD_TIMEOUT_MS, env);
+}
+async function providerTier(loadProvider, warn) {
+	if (!loadProvider) return null;
+	const loaded = await loadProvider();
+	if (loaded?.unavailable) {
+		warn("provider-load", `provider not usable (${loaded.name ?? "the cache provider"}): ${loaded.unavailable}; using local cache`);
+		return null;
+	}
+	const capability = loaded?.provider?.builds;
+	if (!capability) return null;
+	return {
+		capability,
+		name: loaded.name ?? "the cache provider"
+	};
+}
+function neverAborted$1() {
+	return new AbortController().signal;
+}
+function ignore() {}
+async function resolveTieredBuild({ local, loadProvider = null, target, destinationDir, ensureDestination, skipRead = false, warn = ignore, timeoutMs = buildResolveTimeoutMs() }) {
+	if (skipRead) return null;
+	const hit = await local.resolve({
+		...target,
+		destinationDir,
+		signal: neverAborted$1()
+	});
+	if (hit) return {
+		path: hit,
+		tier: "local"
+	};
+	const tier = await providerTier(loadProvider, warn);
+	if (!tier) return null;
+	const { capability: provider, name: label } = tier;
+	ensureDestination?.(destinationDir);
+	const outcome = await callWithTimeout((signal) => provider.resolve({
+		...target,
+		destinationDir,
+		signal
+	}), timeoutMs);
+	if (outcome.timedOut) {
+		warn("provider-resolve", `${label} did not answer within ${timeoutMs}ms; building instead`);
+		return null;
+	}
+	if (outcome.failed) {
+		warn("provider-resolve", `${label} could not be used: ${outcome.failed}; building instead`);
+		return null;
+	}
+	const path = typeof outcome.value === "string" ? outcome.value.trim() : "";
+	if (path === "") return null;
+	if (!existsSync(path)) {
+		warn("provider-resolve", `${label} returned ${path}, which does not exist; building instead`);
+		return null;
+	}
+	let stored = null;
+	try {
+		stored = await local.store({
+			...target,
+			sourcePath: path,
+			overwrite: false,
+			signal: neverAborted$1()
+		}) || null;
+	} catch (error) {
+		warn("provider-backfill", `a ${label} hit could not be stored locally: ${String(error?.message || error)}`);
+	}
+	return {
+		path: stored || path,
+		tier: "provider",
+		providerName: label,
+		storedLocally: Boolean(stored)
+	};
+}
+async function storeTieredBuild({ local, loadProvider = null, target, sourcePath, overwrite, warn = ignore, timeoutMs = buildUploadTimeoutMs() }) {
+	const localPath = await local.store({
+		...target,
+		sourcePath,
+		overwrite,
+		signal: neverAborted$1()
+	}) || null;
+	const tier = await providerTier(loadProvider, warn);
+	if (!tier) return {
+		localPath,
+		providerUpload: null,
+		providerName: null
+	};
+	return {
+		localPath,
+		providerUpload: callWithTimeout(async (signal) => {
+			await tier.capability.store({
+				...target,
+				sourcePath,
+				overwrite,
+				signal
+			});
+		}, timeoutMs),
+		providerName: tier.name
+	};
+}
+//#endregion
+//#region contract.ts
+const CACHE_CONTRACT_CHECK_TIMEOUT_MS = 3e4;
+const ABORT_SETTLE_MS = 1e3;
+async function settlesAfterAbort(start, settleMs) {
+	const controller = new AbortController();
+	const call = Promise.resolve().then(() => start(controller.signal)).then(() => "settled", () => "settled");
+	controller.abort();
+	let timer;
+	const outcome = await Promise.race([call, new Promise((resolve) => {
+		timer = setTimeout(() => resolve("ignored"), settleMs);
+	})]);
+	clearTimeout(timer);
+	assert(outcome === "settled", `the call did not settle within ${settleMs}ms of its signal aborting`);
+}
+function isInside(parent, child) {
+	const rel = relative(parent, child);
+	return rel !== "" && !rel.startsWith(`..${sep}`) && rel !== "..";
+}
+function neverAborted() {
+	return new AbortController().signal;
+}
+function assert(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function metroChecks({ provider, projectRoot, cacheName = "app", abortSettleMs = ABORT_SETTLE_MS }) {
+	const metro = provider.metro;
+	if (!metro) return [];
+	const context = {
+		projectRoot,
+		cacheName,
+		signal: neverAborted()
+	};
+	return [
+		{
+			name: "metro get returns null or undefined for an unknown key",
+			capability: "metro",
+			async run() {
+				const value = await metro.get({
+					...context,
+					key: randomBytes(32)
+				});
+				assert(value === null || value === void 0, `expected a miss, received ${JSON.stringify(value)}`);
+			}
+		},
+		{
+			name: "metro set then get returns the stored buffer",
+			capability: "metro",
+			async run() {
+				const key = randomBytes(32);
+				const value = randomBytes(64);
+				await metro.set({
+					...context,
+					key,
+					value
+				});
+				const stored = await metro.get({
+					...context,
+					key
+				});
+				assert(Buffer.isBuffer(stored), `expected a Buffer, received ${typeof stored}`);
+				assert(Buffer.compare(stored, value) === 0, "the stored buffer does not match the written buffer");
+			}
+		},
+		{
+			name: "metro set then get returns the stored object",
+			capability: "metro",
+			async run() {
+				const key = randomBytes(32);
+				const value = {
+					code: `contract-${randomUUID()}`,
+					map: [
+						1,
+						2,
+						3
+					]
+				};
+				await metro.set({
+					...context,
+					key,
+					value
+				});
+				const stored = await metro.get({
+					...context,
+					key
+				});
+				assert(JSON.stringify(stored) === JSON.stringify(value), `expected ${JSON.stringify(value)}, received ${JSON.stringify(stored)}`);
+			}
+		},
+		{
+			name: "metro get settles when its signal aborts",
+			capability: "metro",
+			async run() {
+				await settlesAfterAbort((signal) => metro.get({
+					projectRoot,
+					cacheName,
+					key: randomBytes(32),
+					signal
+				}), abortSettleMs);
+			}
+		},
+		{
+			name: "metro keys do not collide",
+			capability: "metro",
+			async run() {
+				const first = randomBytes(32);
+				const second = randomBytes(32);
+				await metro.set({
+					...context,
+					key: first,
+					value: Buffer.from("first")
+				});
+				await metro.set({
+					...context,
+					key: second,
+					value: Buffer.from("second")
+				});
+				const stored = await metro.get({
+					...context,
+					key: first
+				});
+				assert(Buffer.isBuffer(stored) && stored.toString() === "first", "the second write overwrote the value of an unrelated key");
+			}
+		}
+	];
+}
+function buildChecks({ provider, projectRoot, workDir, platform = "android", abortSettleMs = ABORT_SETTLE_MS }) {
+	const builds = provider.builds;
+	if (!builds) return [];
+	const signal = neverAborted();
+	function artifact() {
+		const dir = join(workDir, `source-${randomUUID()}`);
+		mkdirSync(dir, { recursive: true });
+		const sourcePath = join(dir, platform === "ios" ? "Contract.app" : "contract.apk");
+		const contents = randomBytes(128);
+		if (platform === "ios") {
+			mkdirSync(sourcePath, { recursive: true });
+			writeFileSync(join(sourcePath, "contract.bin"), contents);
+		} else writeFileSync(sourcePath, contents);
+		return {
+			sourcePath,
+			contents
+		};
+	}
+	function destination() {
+		const dir = join(workDir, `destination-${randomUUID()}`);
+		mkdirSync(dir, { recursive: true });
+		return dir;
+	}
+	function storedContents(path) {
+		return readFileSync(platform === "ios" ? join(path, "contract.bin") : path);
+	}
+	return [
+		{
+			name: "builds resolve returns null for an unknown key",
+			capability: "builds",
+			async run() {
+				const found = await builds.resolve({
+					projectRoot,
+					platform,
+					key: `contract-miss-${randomUUID()}`,
+					destinationDir: destination(),
+					signal
+				});
+				assert(found === null || found === void 0, `expected a miss, received ${String(found)}`);
+			}
+		},
+		{
+			name: "builds store then resolve returns the same artifact",
+			capability: "builds",
+			async run() {
+				const key = `contract-${randomUUID()}`;
+				const { sourcePath, contents } = artifact();
+				await builds.store({
+					projectRoot,
+					platform,
+					key,
+					sourcePath,
+					overwrite: false,
+					signal
+				});
+				const found = await builds.resolve({
+					projectRoot,
+					platform,
+					key,
+					destinationDir: destination(),
+					signal
+				});
+				assert(typeof found === "string" && found !== "", "the stored key did not resolve");
+				assert(Buffer.compare(storedContents(found), contents) === 0, "the resolved artifact does not match the stored artifact");
+			}
+		},
+		{
+			name: "builds resolve settles when its signal aborts",
+			capability: "builds",
+			async run() {
+				await settlesAfterAbort((aborting) => builds.resolve({
+					projectRoot,
+					platform,
+					key: `contract-abort-${randomUUID()}`,
+					destinationDir: destination(),
+					signal: aborting
+				}), abortSettleMs);
+			}
+		},
+		{
+			name: "builds resolve leaves the destination directory empty on a miss",
+			capability: "builds",
+			async run() {
+				const dir = destination();
+				await builds.resolve({
+					projectRoot,
+					platform,
+					key: `contract-miss-${randomUUID()}`,
+					destinationDir: dir,
+					signal
+				});
+				assert(readdirSync(dir).length === 0, `a miss left ${readdirSync(dir).join(", ")} in the destination`);
+			}
+		},
+		{
+			name: "builds resolve returns a path it owns or one inside the destination",
+			capability: "builds",
+			async run() {
+				const key = `contract-${randomUUID()}`;
+				const { sourcePath, contents } = artifact();
+				await builds.store({
+					projectRoot,
+					platform,
+					key,
+					sourcePath,
+					overwrite: false,
+					signal
+				});
+				const dir = destination();
+				const found = await builds.resolve({
+					projectRoot,
+					platform,
+					key,
+					destinationDir: dir,
+					signal
+				});
+				assert(typeof found === "string" && found !== "", "the stored key did not resolve");
+				const path = found;
+				assert(isInside(dir, path) || Buffer.compare(storedContents(path), contents) === 0, `${path} is neither inside the destination nor a copy the capability owns`);
+			}
+		},
+		{
+			name: "builds store honors overwrite",
+			capability: "builds",
+			async run() {
+				const key = `contract-${randomUUID()}`;
+				const first = artifact();
+				const second = artifact();
+				await builds.store({
+					projectRoot,
+					platform,
+					key,
+					sourcePath: first.sourcePath,
+					overwrite: false,
+					signal
+				});
+				await builds.store({
+					projectRoot,
+					platform,
+					key,
+					sourcePath: second.sourcePath,
+					overwrite: false,
+					signal
+				});
+				const kept = await builds.resolve({
+					projectRoot,
+					platform,
+					key,
+					destinationDir: destination(),
+					signal
+				});
+				assert(typeof kept === "string", "the stored key did not resolve");
+				assert(Buffer.compare(storedContents(kept), first.contents) === 0, "overwrite: false replaced an entry that already existed");
+				await builds.store({
+					projectRoot,
+					platform,
+					key,
+					sourcePath: second.sourcePath,
+					overwrite: true,
+					signal
+				});
+				const replaced = await builds.resolve({
+					projectRoot,
+					platform,
+					key,
+					destinationDir: destination(),
+					signal
+				});
+				assert(typeof replaced === "string", "the overwritten key did not resolve");
+				assert(Buffer.compare(storedContents(replaced), second.contents) === 0, "overwrite: true kept the previous entry");
+			}
+		},
+		{
+			name: "builds store keeps unrelated keys separate",
+			capability: "builds",
+			async run() {
+				const first = `contract-${randomUUID()}`;
+				const second = `contract-${randomUUID()}`;
+				const one = artifact();
+				const two = artifact();
+				await builds.store({
+					projectRoot,
+					platform,
+					key: first,
+					sourcePath: one.sourcePath,
+					overwrite: false,
+					signal
+				});
+				await builds.store({
+					projectRoot,
+					platform,
+					key: second,
+					sourcePath: two.sourcePath,
+					overwrite: false,
+					signal
+				});
+				const found = await builds.resolve({
+					projectRoot,
+					platform,
+					key: first,
+					destinationDir: destination(),
+					signal
+				});
+				assert(typeof found === "string" && found !== "", "the first key stopped resolving after the second store");
+				assert(Buffer.compare(storedContents(found), one.contents) === 0, "the second store replaced the artifact of an unrelated key");
+			}
+		}
+	];
+}
+const MODULE_CHECK = "the module loads through loadCacheProvider()";
+async function loadContractProvider(options) {
+	const loaded = await loadCacheProvider({
+		projectRoot: options.projectRoot,
+		config: {
+			provider: options.providerModule,
+			options: options.options ?? {},
+			baseDir: options.baseDir ?? options.projectRoot
+		}
+	});
+	if (!loaded.provider) return { failure: {
+		name: MODULE_CHECK,
+		capability: "module",
+		passed: false,
+		error: loaded.unavailable ?? "the reference selected no provider"
+	} };
+	return {
+		...options,
+		provider: loaded.provider
+	};
+}
+function cacheProviderContractChecks(options) {
+	return [...metroChecks({
+		provider: options.provider,
+		projectRoot: options.projectRoot,
+		...options.cacheName ? { cacheName: options.cacheName } : {},
+		...options.abortSettleMs ? { abortSettleMs: options.abortSettleMs } : {}
+	}), ...buildChecks({
+		provider: options.provider,
+		projectRoot: options.projectRoot,
+		workDir: options.workDir,
+		...options.platform ? { platform: options.platform } : {},
+		...options.abortSettleMs ? { abortSettleMs: options.abortSettleMs } : {}
+	})];
+}
+async function runCacheProviderContract(options) {
+	const resolved = "providerModule" in options ? await loadContractProvider(options) : options;
+	if ("failure" in resolved) return [resolved.failure];
+	const checkTimeoutMs = resolved.checkTimeoutMs ?? 3e4;
+	const results = [];
+	for (const check of cacheProviderContractChecks(resolved)) try {
+		await withDeadline(check.run(), checkTimeoutMs);
+		results.push({
+			name: check.name,
+			capability: check.capability,
+			passed: true
+		});
+	} catch (error) {
+		results.push({
+			name: check.name,
+			capability: check.capability,
+			passed: false,
+			error: String(error?.message || error)
+		});
+	}
+	return results;
+}
+async function withDeadline(work, timeoutMs) {
+	let timer;
+	const expired = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`the check did not finish within ${timeoutMs}ms`)), timeoutMs);
+	});
+	try {
+		await Promise.race([work, expired]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+//#endregion
+export { BUILD_RESOLVE_TIMEOUT_ENV, BUILD_RESOLVE_TIMEOUT_MS, BUILD_UPLOAD_TIMEOUT_ENV, BUILD_UPLOAD_TIMEOUT_MS, CACHE_CONTRACT_CHECK_TIMEOUT_MS, CACHE_PROVIDER_API_VERSION, CACHE_PROVIDER_ENV, CACHE_PROVIDER_ENV_NONE, METRO_READ_CONCURRENCY, METRO_READ_FAILURE_LIMIT, METRO_READ_TIMEOUT_ENV, METRO_READ_TIMEOUT_MS, METRO_UPLOAD_CONCURRENCY, METRO_UPLOAD_MAX_BYTES, METRO_UPLOAD_MAX_ITEMS, METRO_WRITE_TIMEOUT_ENV, METRO_WRITE_TIMEOUT_MS, PROVIDER_LOAD_TIMEOUT_ENV, PROVIDER_LOAD_TIMEOUT_MS, buildResolveTimeoutMs, buildUploadTimeoutMs, cacheProviderConfigFromEnv, cacheProviderContractChecks, cacheProviderEnv, cacheProviderEnvIsSet, callWithTimeout, createTieredMetroStore, createWarnOnce, loadCacheProvider, metroCapabilityFromStore, resolveTieredBuild, runCacheProviderContract, storeTieredBuild, timeoutFromEnv };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@stim-cli/cache",
+  "version": "1.0.0-rc.10",
+  "description": "Cache provider contract and tier coordination for Stim.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/appandflow/stim.git",
+    "directory": "packages/cache"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "module-sync": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "engines": {
+    "node": "^20.19.4 || >=22.12.0"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}