stim 1.8.0 → 1.10.0

package/dist/simslim-Ca3487H6.mjs

@@ -0,0 +1,436 @@
+import { D as process_identity_exports, H as projectDeviceSlots, g as loadConfig, k as ownership_claim_exports, u as getConfigDir, z as deviceSlotPlatforms } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { g as releaseBuildLock, m as acquireBuildLock } from "./device-lease-CbEaIk7b.mjs";
+import { w as listAdbDevices } from "./android-787HhP5w.mjs";
+import { l as listAllIosSims, s as iosRuntimeMatches } from "./ios-B2Fpqvlb.mjs";
+import { _ as easCliSupport, s as readInstalledEasCliVersion, v as easCliUpgradeRemedy, z as resolveEasCliBin } from "./device-remote-Dy1jGj3U.mjs";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/engine/eas-build.ts
+const MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION = "18.9.0";
+function isEasBuildFailure(result) {
+	return result?.ok === false;
+}
+function easOptionRefusal({ profile, isExpo, buildSelector, buildCache }) {
+	if (profile === void 0) return null;
+	if (profile.trim() && isExpo && buildSelector === void 0 && buildCache !== false) return null;
+	return {
+		code: "STIM_BAD_ARG",
+		message: "--eas-profile requires an Expo project and a non-empty development profile.",
+		remedy: "Use --eas-profile <name> without --scheme, --configuration, --variant, or --no-build-cache."
+	};
+}
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function shellArg(value) {
+	return /^[a-zA-Z0-9_.-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+function easDeviceBuildRemedy(profile) {
+	return `If the device is not registered, run npx eas-cli device:create. With approval for cloud build costs and signing changes, run npx eas-cli build --platform ios --profile ${shellArg(profile)} to produce a build with a valid profile for this device, then retry the same Stim command.`;
+}
+var EasFailure = class extends Error {
+	code;
+	remedy;
+	constructor(code, message, remedy) {
+		super(message);
+		this.code = code;
+		this.remedy = remedy;
+	}
+};
+function selectEasBuild(builds, { platform, profile, fingerprint, projectId, physical = false }) {
+	if (!Array.isArray(builds)) throw new Error("EAS build:list did not return an array.");
+	for (const value of builds) {
+		const build = object(value);
+		if (typeof build.id === "string" && build.id.length > 0 && build.status === "FINISHED" && build.platform === platform.toUpperCase() && build.buildProfile === profile && object(build.fingerprint).hash === fingerprint && (object(build.app).id ?? object(build.project).id) === projectId && (platform !== "ios" || build.isForIosSimulator === !physical) && build.distribution === "INTERNAL" && typeof object(build.artifacts).applicationArchiveUrl === "string") return build.id;
+	}
+	return null;
+}
+async function resolveEasDevelopmentBuild({ root, platform, profile, note, isExpo = true, physical = false, selectors = [], buildCache, readEasCliVersion = readInstalledEasCliVersion }) {
+	if (profile === void 0) return null;
+	const refusal = easOptionRefusal({
+		profile,
+		isExpo,
+		buildSelector: selectors.find((value) => value != null) ?? void 0,
+		buildCache
+	});
+	if (refusal) return {
+		ok: false,
+		...refusal
+	};
+	const retry = "the same Stim command";
+	const buildCommand = `npx eas-cli build --platform ${platform} --profile ${shellArg(profile)}`;
+	let lock = null;
+	try {
+		const cli = resolveEasCliBin(root);
+		if (!cli) throw new EasFailure("STIM_EAS_UNAVAILABLE", "EAS CLI is not installed.", "Install eas-cli, run eas login, then retry.");
+		const easCli = easCliSupport(readEasCliVersion(cli.file, root), MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION);
+		if (!easCli.supported) throw new EasFailure("STIM_EAS_UNAVAILABLE", easCli.version ? `eas-cli ${easCli.version} (${cli.file}) cannot download a build by ID; --eas-profile needs eas-cli ${MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION} or later.` : `Could not read an eas-cli version from \`${cli.file} --version\`; --eas-profile needs eas-cli ${MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION} or later.`, `${easCliUpgradeRemedy(MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION)}, then retry ${retry}.`);
+		let profileEnv = {};
+		const run = (args, timeoutMs = 12e4) => {
+			try {
+				return JSON.parse(getExecutor().runFile(cli.file, [
+					...args,
+					"--json",
+					"--non-interactive"
+				], {
+					cwd: root,
+					timeoutMs,
+					env: profileEnv
+				}));
+			} catch {
+				throw new EasFailure("STIM_EAS_UNAVAILABLE", `EAS ${args[0]} failed or returned invalid JSON.`, `Run npx eas-cli ${args.map(shellArg).join(" ")} to inspect the error, then retry ${retry}.`);
+			}
+		};
+		note(`eas   resolving profile ${profile}`);
+		const config = object(run([
+			"config",
+			"--platform",
+			platform,
+			"--profile",
+			profile
+		]));
+		const buildProfile = object(config.buildProfile);
+		profileEnv = object(buildProfile.env);
+		const projectId = object(object(object(config.appConfig).extra).eas).projectId;
+		if (buildProfile.developmentClient !== true || buildProfile.distribution !== "internal" || platform === "ios" && buildProfile.simulator === true !== !physical) throw new EasFailure("STIM_BAD_ARG", `EAS profile ${profile} is not an internal development build for this ${platform} target.`, `Set developmentClient: true and distribution: internal${platform === "ios" ? `, with ios.simulator: ${!physical}` : ""} in that eas.json profile.`);
+		if (typeof projectId !== "string" || !projectId) throw new EasFailure("STIM_BAD_ARG", "The Expo app is not linked to an EAS project.", "Link the intended EAS project with eas init, then retry.");
+		if (platform === "ios" ? buildProfile.buildConfiguration !== void 0 && buildProfile.buildConfiguration !== "Debug" : buildProfile.gradleCommand !== void 0 && (typeof buildProfile.gradleCommand !== "string" || !/^:app:assemble\w*Debug$/.test(buildProfile.gradleCommand))) throw new EasFailure("STIM_BAD_ARG", `EAS profile ${profile} overrides the development build configuration.`, "Use ios.buildConfiguration: Debug or an android.gradleCommand that assembles a single Debug APK, or remove the override.");
+		note(`eas   fingerprinting ${platform} with profile ${profile}`);
+		const fingerprint = object(run([
+			"fingerprint:generate",
+			"--platform",
+			platform,
+			"--build-profile",
+			profile
+		])).hash;
+		if (typeof fingerprint !== "string" || !/^[a-f0-9]{40,64}$/.test(fingerprint)) throw new EasFailure("STIM_EAS_UNAVAILABLE", "EAS returned no valid native fingerprint.", `Run npx eas-cli fingerprint:generate --platform ${platform} --build-profile ${shellArg(profile)} to inspect the result.`);
+		note(`eas   looking for ${fingerprint.slice(0, 8)}`);
+		const buildId = selectEasBuild(run([
+			"build:list",
+			"--platform",
+			platform,
+			"--build-profile",
+			profile,
+			"--fingerprint-hash",
+			fingerprint,
+			"--status",
+			"finished",
+			...platform === "ios" && !physical ? ["--simulator"] : ["--distribution", "internal"],
+			"--limit",
+			"1"
+		]), {
+			platform,
+			profile,
+			fingerprint,
+			projectId,
+			physical
+		});
+		if (!buildId) throw new EasFailure("STIM_EAS_BUILD_MISSING", `No compatible EAS ${platform} build exists for profile ${profile} and fingerprint ${fingerprint}.`, `A cloud build may incur charges. With approval to run it, use ${buildCommand}, then retry ${retry}.`);
+		const cacheKey = `eas-${createHash("sha256").update(JSON.stringify({
+			projectId,
+			buildId
+		})).digest("hex")}-debug-${physical && platform === "ios" ? "device" : "sim"}`;
+		lock = acquireBuildLock({
+			platform,
+			key: cacheKey,
+			root
+		});
+		if (!lock.acquired) throw new EasFailure("STIM_EAS_UNAVAILABLE", `Another run holds the EAS artifact claim at ${lock.path}.`, `Wait for that run to finish, then retry ${retry}.`);
+		note(`eas   resolving artifact for build ${buildId}`);
+		const result = object(run([
+			"build:download",
+			"--build-id",
+			buildId
+		], 6e5));
+		if (typeof result.path !== "string" || !existsSync(result.path)) throw new Error("EAS returned no downloaded artifact.");
+		const path = realpathSync(result.path);
+		if (platform === "ios" ? !path.endsWith(".app") || !statSync(path).isDirectory() : !path.endsWith(".apk") || !statSync(path).isFile()) throw new Error("EAS returned an unexpected artifact path or type.");
+		note(`eas   artifact ready ${fingerprint.slice(0, 8)}`);
+		return {
+			ok: true,
+			path,
+			fingerprint,
+			cacheKey,
+			cacheHit: "remote"
+		};
+	} catch (error) {
+		const claim = (0, ownership_claim_exports.claimFailure)(error, null);
+		if (claim) return {
+			ok: false,
+			code: claim.code,
+			message: claim.message,
+			remedy: claim.remedy
+		};
+		if (error instanceof EasFailure) return {
+			ok: false,
+			code: error.code,
+			message: error.message,
+			remedy: error.remedy
+		};
+		return {
+			ok: false,
+			code: "STIM_EAS_UNAVAILABLE",
+			message: `Could not resolve the EAS development build: ${error.message}`,
+			remedy: `Retry ${retry}. No cloud build was started.`
+		};
+	} finally {
+		releaseBuildLock(lock);
+	}
+}
+//#endregion
+//#region src/engine/device-capacity.ts
+function liveOwnedDeviceCount({ sims = [], adbEmulators = [], config = null } = {}) {
+	let count = 0;
+	for (const sim of sims) if (sim?.state === "Booted" && sim.name?.startsWith("stim-")) count++;
+	const livePorts = new Set(adbEmulators.map((e) => e.consolePort));
+	for (const proj of Object.values(config?.projects || {})) for (const { platforms } of projectDeviceSlots(proj)) {
+		const android = platforms.android;
+		if (android?.owned && android.avdName && typeof android.consolePort === "number" && livePorts.has(android.consolePort)) count++;
+	}
+	return count;
+}
+function workspaceHasLiveDevice({ platform, project, slot = "default", sims = [], adbEmulators = [] } = {}) {
+	if (!platform) return false;
+	const record = deviceSlotPlatforms(project, slot)?.[platform];
+	if (!record) return false;
+	if (platform === "ios") return sims.some((s) => s.udid === record.deviceUdid && s.state === "Booted");
+	return typeof record.consolePort === "number" && adbEmulators.some((e) => e.consolePort === record.consolePort);
+}
+function deviceCapacityRefusal({ platform, project, slot = "default", max, sims = [], adb = null, config = null } = {}) {
+	if (!max || max <= 0) return null;
+	const adbEmulators = adb?.emulators || [];
+	if (workspaceHasLiveDevice({
+		platform,
+		project,
+		slot,
+		sims,
+		adbEmulators
+	})) return null;
+	const count = liveOwnedDeviceCount({
+		sims,
+		adbEmulators,
+		config
+	});
+	if (count < max) return null;
+	return {
+		code: "STIM_AT_CAPACITY",
+		message: `${count} Stim device(s) are already booted and concurrency.maxDevices is ${max}, so booting another would exceed the cap.`,
+		remedy: "stop an environment (stim stop) or raise concurrency.maxDevices"
+	};
+}
+function checkDeviceCapacity({ platform, project, slot = "default", max, sims = listAllIosSims, adb = listAdbDevices, config = loadConfig } = {}) {
+	if (!max || max <= 0) return null;
+	let simList = [];
+	let adbRes = {
+		emulators: [],
+		physical: [],
+		unhealthy: []
+	};
+	try {
+		simList = typeof sims === "function" ? sims() || [] : sims || [];
+	} catch {}
+	try {
+		adbRes = typeof adb === "function" ? adb() || adbRes : adb || adbRes;
+	} catch {}
+	let cfg = null;
+	try {
+		cfg = typeof config === "function" ? config() : config ?? null;
+	} catch {}
+	return deviceCapacityRefusal({
+		platform,
+		project,
+		slot,
+		max,
+		sims: simList,
+		adb: adbRes,
+		config: cfg
+	});
+}
+function deviceTypeMismatch(recordedTypeId, requestedName, deviceTypes) {
+	if (!requestedName || !recordedTypeId) return null;
+	const wanted = (deviceTypes || []).find((d) => d.name === requestedName);
+	if (!wanted) return null;
+	if (wanted.identifier === recordedTypeId) return null;
+	const recorded = (deviceTypes || []).find((d) => d.identifier === recordedTypeId);
+	return `this project's sim is ${recorded ? recorded.name : recordedTypeId}, but --device-type asked for ${requestedName}`;
+}
+function installedNames(names) {
+	const unique = [...new Set(names.filter((n) => typeof n === "string" && n !== ""))];
+	return unique.length > 0 ? unique.join(", ") : "none";
+}
+function unknownIosRuntimeRefusal(requested, runtimes) {
+	if (!requested) return null;
+	if ((runtimes || []).some((r) => iosRuntimeMatches(r, requested))) return null;
+	return {
+		message: `No installed simulator runtime matches "${requested}". Installed runtimes: ${installedNames((runtimes || []).map((r) => r.version))}.`,
+		remedy: "Pass `--runtime` (or set ios.runtime) a version printed above (\"26.5\") or a runtime's full name (\"iOS 26.5\"); nothing else matches. Install more runtimes through Xcode."
+	};
+}
+function creatableIosDeviceTypeNames(runtimes, runtime) {
+	return (runtime ? (runtimes || []).filter((r) => iosRuntimeMatches(r, runtime)) : runtimes || []).flatMap((r) => (r.supportedDeviceTypes || []).map((d) => d.name));
+}
+function unknownIosDeviceTypeRefusal(requested, runtimes, runtime) {
+	if (!requested) return null;
+	const creatable = creatableIosDeviceTypeNames(runtimes, runtime);
+	if (creatable.includes(requested)) return null;
+	return {
+		message: `No device type named "${requested}" can be created on ${runtime ? `runtime ${runtime}` : "any installed simulator runtime"}. ${runtime ? `Device types runtime ${runtime} supports` : "Device types the installed runtimes support"}: ${installedNames(creatable)}.`,
+		remedy: "Pass `--device-type` (or set ios.deviceType) one of the names printed above, exactly as `xcrun simctl list devicetypes` spells it. `xcrun simctl list devicetypes` also lists watchOS, tvOS and visionOS models, which no iOS runtime can create. Install more models through Xcode."
+	};
+}
+function unknownAndroidSystemImageRefusal(requested, images) {
+	if (!requested) return null;
+	if ((images || []).some((i) => i.pkg === requested)) return null;
+	return {
+		message: `No installed Android system image is named "${requested}". Installed system images: ${installedNames((images || []).map((i) => i.pkg))}.`,
+		remedy: "Pass `--system-image` (or set android.systemImage) to one of the package ids printed above. Install more with `sdkmanager \"system-images;android-36;google_apis;arm64-v8a\"`."
+	};
+}
+//#endregion
+//#region src/engine/simslim.ts
+async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn, timeoutMs = 72e4, cleanupMs = 1e4 }) {
+	if (!profile && !previouslyManaged) return {
+		managed: false,
+		profile: null
+	};
+	const action = profile ? "on" : "off";
+	const args = profile ? [
+		"on",
+		udid,
+		"--profile",
+		profile
+	] : ["off", udid];
+	const lines = [];
+	const onLine = (raw) => {
+		const line = stripAnsi(raw).trim();
+		if (!line) return;
+		lines.push(line);
+		if (lines.length > 20) lines.shift();
+		out(`SimSlim: ${line}`);
+	};
+	const stdout = createLineReader(onLine);
+	const stderr = createLineReader(onLine);
+	const root = join(getConfigDir(), "simslim-locks", `${encodeURIComponent(udid.toLowerCase())}.lock`);
+	const label = `SimSlim for ${udid}`;
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root,
+		mode: "exclusive",
+		label
+	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new ownership_claim_exports.ClaimRefusedError({
+		root,
+		claimPath: attempt.held?.path ?? root,
+		label,
+		reason: "another SimSlim operation is still using this simulator"
+	});
+	let child;
+	let result;
+	let identity;
+	let cancellation;
+	const stopGroup = () => {
+		if (child?.pid !== void 0 && identity && (0, process_identity_exports.inspectProcessIdentity)(identity) === "same") try {
+			process.kill(-child.pid, "SIGKILL");
+		} catch {}
+	};
+	const cancel = (signal) => {
+		cancellation ??= signal;
+		stopGroup();
+	};
+	const onInterrupt = () => cancel("SIGINT");
+	const onTerminate = () => cancel("SIGTERM");
+	const groupAlive = () => child?.pid !== void 0 && (0, ownership_claim_exports.processGroupAlive)(child.pid);
+	const settled = () => result !== void 0 && !groupAlive();
+	const waitUntil = async (deadline, cancellable = false) => {
+		while (!settled() && Date.now() < deadline) {
+			if (cancellable && cancellation) break;
+			await new Promise((resolve) => setTimeout(resolve, Math.min(50, deadline - Date.now())));
+		}
+		return settled();
+	};
+	process.on("SIGINT", onInterrupt);
+	process.on("SIGTERM", onTerminate);
+	process.on("exit", stopGroup);
+	try {
+		(0, ownership_claim_exports.markClaimChildPending)(claim);
+		try {
+			child = (spawn ?? ((cmd, childArgs, opts) => getExecutor().spawn(cmd, childArgs, opts)))("simslim", args, {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				detached: true
+			});
+		} catch (error) {
+			throw simslimLaunchError(error);
+		}
+		child.stdout?.on("data", (chunk) => stdout.push(chunk));
+		child.stderr?.on("data", (chunk) => stderr.push(chunk));
+		waitForChild(child).then((value) => {
+			result = value;
+		});
+		if (child.pid !== void 0) {
+			const captured = (0, process_identity_exports.captureProcessIdentity)(child.pid);
+			if (captured.ok) {
+				identity = {
+					pid: child.pid,
+					processToken: captured.token
+				};
+				try {
+					(0, ownership_claim_exports.setClaimChild)(claim, identity);
+				} catch {}
+			}
+		}
+		const completed = await waitUntil(Date.now() + timeoutMs, true);
+		if (cancellation || !completed) {
+			stopGroup();
+			const stopped = await waitUntil(Date.now() + cleanupMs);
+			const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+			const recovery = stopped ? "Its process group has stopped. Retry stim ios to reconcile the retained simulator settings." : `Its process group could not be confirmed stopped. The claim remains at ${claim.path}. Inspect the SimSlim process group ${child.pid ?? "unknown"} before retrying. Only when nothing is using it, remove the claim: ${(0, ownership_claim_exports.claimRemoveCommand)(claim.path)}`;
+			const message = `SimSlim ${action} ${cancellation ? `interrupted by ${cancellation}` : `exceeded ${Math.round(timeoutMs / 1e3)}s`}. ${recovery}${detail}`;
+			if (cancellation) out(message);
+			throw Object.assign(new Error(message), { code: cancellation ? "EINTR" : "ETIMEDOUT" });
+		}
+	} finally {
+		if (!child || settled()) (0, ownership_claim_exports.releaseClaim)(claim);
+		else {
+			child.stdout?.destroy?.();
+			child.stderr?.destroy?.();
+			child.unref();
+		}
+		process.off("SIGINT", onInterrupt);
+		process.off("SIGTERM", onTerminate);
+		process.off("exit", stopGroup);
+		if (cancellation) process.exit(cancellation === "SIGINT" ? 130 : 143);
+	}
+	stdout.flush();
+	stderr.flush();
+	if (result?.error) throw simslimLaunchError(result.error);
+	if (result?.code !== 0) {
+		const detail = lines.length ? ` ${lines.join(" | ")}` : "";
+		throw new Error(`SimSlim ${action} failed with exit code ${result?.code ?? "unknown"}.${detail}`);
+	}
+	return {
+		managed: Boolean(profile),
+		profile: profile ?? null
+	};
+}
+function simslimLaunchError(error) {
+	const cause = error;
+	if (cause?.code === "ENOENT") return new Error("SimSlim is configured but the `simslim` command is not installed. Run `brew install mobai-app/tap/simslim`.", { cause });
+	return new Error(`Could not start SimSlim: ${String(cause?.message || cause)}`, { cause });
+}
+function simslimIsOnPath() {
+	try {
+		return Boolean(getExecutor().findExecutable("simslim"));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { liveOwnedDeviceCount as a, unknownIosRuntimeRefusal as c, isEasBuildFailure as d, resolveEasDevelopmentBuild as f, deviceTypeMismatch as i, MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION as l, simslimIsOnPath as n, unknownAndroidSystemImageRefusal as o, checkDeviceCapacity as r, unknownIosDeviceTypeRefusal as s, reconcileSimSlim as t, easDeviceBuildRemedy as u };

package/dist/{slot-launch-ZUUe0TQP.mjs → slot-launch-C5cg0fmk.mjs}

@@ -1,7 +1,7 @@
-import { f as getProject } from "./config-B7iyKWkL.mjs";
-import { r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { h as deviceShellArg } from "./app-install-BDbsSgCl.mjs";
-import { n as fileLeaseIo } from "./device-lease-Ffz_M5t0.mjs";
+import { f as getProject } from "./config-BEq0Qw_a.mjs";
+import { m as readWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { n as fileLeaseIo } from "./device-lease-CbEaIk7b.mjs";
+import { d as deviceShellArg } from "./app-install-CrJ6t_bv.mjs";
 //#region src/engine/slot-launch.ts
 function launchSlotScope(root, slot = "default") {
 	if (slot !== "default") return slot;

package/dist/spawn-claims-CUleC2cM.mjs

@@ -0,0 +1,49 @@
+import { D as process_identity_exports, k as ownership_claim_exports } from "./config-BEq0Qw_a.mjs";
+//#region src/engine/spawn-claims.ts
+const declaring = /* @__PURE__ */ new Set();
+/** Record every child later started through `spawnDeclared` on `claim` until `stopDeclaringSpawnsOn(claim)`. */
+function declareSpawnsOn(claim) {
+	if (claim) declaring.add(claim);
+}
+function stopDeclaringSpawnsOn(claim) {
+	if (claim) declaring.delete(claim);
+}
+/**
+* Start a child that every claim passed to `declareSpawnsOn` records until it exits. The child keeps
+* the caller's process group, so a terminal interrupt still reaches it; the claim follows the child
+* itself. A claim that cannot be marked stops the spawn rather than letting it run unprotected. A claim
+* records one child, so declared spawns must not overlap.
+*/
+function spawnDeclared(spawn) {
+	const claims = [...declaring];
+	if (claims.length === 0) return spawn();
+	const forget = () => {
+		for (const claim of claims) try {
+			(0, ownership_claim_exports.clearClaimChild)(claim);
+		} catch {}
+	};
+	let child;
+	try {
+		for (const claim of claims) (0, ownership_claim_exports.markClaimChildPending)(claim);
+		child = spawn();
+	} catch (error) {
+		forget();
+		throw error;
+	}
+	const pid = child.pid;
+	if (pid === void 0) {
+		forget();
+		return child;
+	}
+	const captured = (0, process_identity_exports.captureProcessIdentity)(pid);
+	if (captured.ok) for (const claim of claims) try {
+		(0, ownership_claim_exports.setClaimChild)(claim, {
+			pid,
+			processToken: captured.token
+		});
+	} catch {}
+	child.once("exit", forget);
+	return child;
+}
+//#endregion
+export { spawnDeclared as n, stopDeclaringSpawnsOn as r, declareSpawnsOn as t };