@openclaw/acpx 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/pi-session-paths-EMbd4Hkz.js

@@ -0,0 +1,84 @@
+import { isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+//#region extensions/acpx/src/pi-session-catalog-shared.ts
+const PI_SESSIONS_LIST_COMMAND = "acpx.pi.sessions.list.v1";
+const PI_SESSION_READ_COMMAND = "acpx.pi.sessions.read.v1";
+const PI_TERMINAL_RESUME_COMMAND = "acpx.pi.terminal.resume.v1";
+const PI_SESSIONS_CAPABILITY = "pi-sessions";
+const PI_LOCAL_SESSION_HOST_ID = "gateway";
+const PI_SESSION_ID_PATTERN = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
+//#endregion
+//#region extensions/acpx/src/pi-session-paths.ts
+function piHome(env) {
+	return (process.platform === "win32" ? env.USERPROFILE?.trim() : env.HOME?.trim()) || os.homedir();
+}
+function isPiSessionCatalogPathAbsolute(value, platform = process.platform) {
+	if (platform !== "win32") return path.posix.isAbsolute(value);
+	const root = path.win32.parse(value).root;
+	return path.win32.isAbsolute(value) && root !== "\\" && root !== "/";
+}
+function resolveConfiguredPath(value, env, relativeBase) {
+	const home = piHome(env);
+	let resolved = value;
+	if (value === "~") resolved = home;
+	if (value.startsWith("~/") || value.startsWith("~\\")) resolved = path.join(home, value.slice(2));
+	if (!isPiSessionCatalogPathAbsolute(resolved)) {
+		if (relativeBase) return path.resolve(relativeBase, resolved);
+		throw new Error("Pi session catalog requires absolute or home-relative storage paths");
+	}
+	return path.resolve(resolved);
+}
+function settingsSessionDir(file) {
+	try {
+		const value = JSON.parse(readFileSync(file, "utf8"));
+		return isRecord(value) ? normalizeBoundedOptionalString(value.sessionDir, 4096) : void 0;
+	} catch {
+		return;
+	}
+}
+function piSessionStore(env, cwd = process.cwd()) {
+	const customSessionDir = env.PI_CODING_AGENT_SESSION_DIR?.trim();
+	if (customSessionDir) return {
+		root: resolveConfiguredPath(customSessionDir, env),
+		flat: true,
+		usesProcessHomeFallback: false
+	};
+	const home = piHome(env);
+	const customAgentDir = env.PI_CODING_AGENT_DIR?.trim();
+	const agentDir = customAgentDir ? resolveConfiguredPath(customAgentDir, env) : path.join(home, ".pi", "agent");
+	const projectSessionDir = settingsSessionDir(path.join(cwd, ".pi", "settings.json"));
+	if (projectSessionDir) return {
+		root: resolveConfiguredPath(projectSessionDir, env, path.join(cwd, ".pi")),
+		flat: true,
+		usesProcessHomeFallback: false
+	};
+	const globalSessionDir = settingsSessionDir(path.join(agentDir, "settings.json"));
+	if (globalSessionDir) return {
+		root: resolveConfiguredPath(globalSessionDir, env, agentDir),
+		flat: true,
+		usesProcessHomeFallback: false
+	};
+	return {
+		root: path.join(agentDir, "sessions"),
+		flat: false,
+		usesProcessHomeFallback: !customAgentDir
+	};
+}
+/** Store root scanned by pi-acp@0.0.26 when resolving a native session id. */
+function piAcpSessionStoreRoot(env) {
+	const configuredAgentDir = env.PI_CODING_AGENT_DIR?.trim();
+	if (configuredAgentDir && !isPiSessionCatalogPathAbsolute(configuredAgentDir)) return;
+	const agentDir = configuredAgentDir ? path.resolve(configuredAgentDir) : path.join(piHome(env), ".pi", "agent");
+	return path.join(agentDir, "sessions");
+}
+function piSessionStoreAvailable(env, store) {
+	try {
+		return statSync((store ?? piSessionStore(env)).root).isDirectory();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { PI_SESSIONS_CAPABILITY as a, PI_SESSION_READ_COMMAND as c, PI_LOCAL_SESSION_HOST_ID as i, PI_TERMINAL_RESUME_COMMAND as l, piSessionStore as n, PI_SESSIONS_LIST_COMMAND as o, piSessionStoreAvailable as r, PI_SESSION_ID_PATTERN as s, piAcpSessionStoreRoot as t };

package/dist/{process-lease-DSLDgiNl.js → process-lease-Cwvj7WGe.js}

@@ -74,6 +74,8 @@ function normalizeAcpxGatewayInstanceRecord(value) {
 const OPENCLAW_ACPX_LEASE_ID_ARG = "--openclaw-acpx-lease-id";
 /** CLI argument carrying the owning gateway instance id. */
 const OPENCLAW_GATEWAY_INSTANCE_ID_ARG = "--openclaw-gateway-instance-id";
+/** Synthetic session identity for generated-wrapper health probes. */
+const ACPX_PROBE_LEASE_SESSION_KEY = "openclaw:acpx:probe";
 /** Read OpenClaw lease identity from a generated wrapper command. */
 function readAcpxProcessLeaseIdentity(command) {
 	const parts = splitCommandParts(command?.trim() ?? "");
@@ -119,7 +121,8 @@ function normalizeAcpxProcessLeaseFile(value) {
 function openAcpxProcessLeaseStateStore(openKeyedStore) {
 	return openKeyedStore({
 		namespace: ACPX_PROCESS_LEASE_NAMESPACE,
-		maxEntries: ACPX_PROCESS_LEASE_MAX_ENTRIES
+		maxEntries: ACPX_PROCESS_LEASE_MAX_ENTRIES,
+		overflowPolicy: "reject-new"
 	});
 }
 /** Create a serialized SQLite-backed ACPX process lease store. */
@@ -189,4 +192,4 @@ function withAcpxLeaseEnvironment(params) {
 	return appendAcpxLeaseArgs(params);
 }
 //#endregion
-export { splitCommandParts as _, hashAcpxProcessCommand as a, openAcpxProcessLeaseStateStore as c, ACPX_GATEWAY_INSTANCE_KEY as d, ACPX_GATEWAY_INSTANCE_NAMESPACE as f, quoteCommandPart as g, normalizeAcpxGatewayInstanceRecord as h, createAcpxProcessLeaseStore as i, readAcpxProcessLeaseIdentity as l, ACPX_LEGACY_PROCESS_LEASE_FILE as m, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as n, normalizeAcpxProcessLease as o, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as p, createAcpxProcessLeaseId as r, normalizeAcpxProcessLeaseFile as s, OPENCLAW_ACPX_LEASE_ID_ARG as t, withAcpxLeaseEnvironment as u };
+export { quoteCommandPart as _, createAcpxProcessLeaseStore as a, normalizeAcpxProcessLeaseFile as c, withAcpxLeaseEnvironment as d, ACPX_GATEWAY_INSTANCE_KEY as f, normalizeAcpxGatewayInstanceRecord as g, ACPX_LEGACY_PROCESS_LEASE_FILE as h, createAcpxProcessLeaseId as i, openAcpxProcessLeaseStateStore as l, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as m, OPENCLAW_ACPX_LEASE_ID_ARG as n, hashAcpxProcessCommand as o, ACPX_GATEWAY_INSTANCE_NAMESPACE as p, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as r, normalizeAcpxProcessLease as s, ACPX_PROBE_LEASE_SESSION_KEY as t, readAcpxProcessLeaseIdentity as u, splitCommandParts as v };

package/dist/{process-reaper-DFwbcdPa.js → process-reaper-DduWm_7N.js}

@@ -1,12 +1,12 @@
-import { t as AcpxPluginConfigSchema } from "./config-schema-lrk5nlcV.js";
-import { _ as splitCommandParts } from "./process-lease-DSLDgiNl.js";
+import { t as AcpxPluginConfigSchema } from "./config-schema-DN_uAi4R.js";
+import { u as readAcpxProcessLeaseIdentity, v as splitCommandParts } from "./process-lease-Cwvj7WGe.js";
 import { createRequire } from "node:module";
-import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs";
 import path from "node:path";
-import { runExec } from "openclaw/plugin-sdk/process-runtime";
+import { isPidAlive, runExec } from "openclaw/plugin-sdk/process-runtime";
 import { fileURLToPath } from "node:url";
+import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
 //#region extensions/acpx/src/codex-adapter.ts
 const CODEX_ACP_PACKAGE = "@agentclientprotocol/codex-acp";
 const CODEX_ACP_BIN = "codex-acp";
@@ -65,8 +65,6 @@ function resolveAcpxPluginRoot(moduleUrl = import.meta.url) {
 }
 const DEFAULT_PERMISSION_MODE = "approve-reads";
 const DEFAULT_NON_INTERACTIVE_POLICY = "fail";
-const DEFAULT_QUEUE_OWNER_TTL_SECONDS = .1;
-const DEFAULT_STRICT_WINDOWS_CMD_WRAPPER = true;
 function parseAcpxPluginConfig(value) {
 	if (value === void 0) return {
 		ok: true,
@@ -186,13 +184,7 @@ function resolveAcpxPluginConfig(params) {
 		nonInteractivePermissions: normalized.nonInteractivePermissions ?? DEFAULT_NON_INTERACTIVE_POLICY,
 		pluginToolsMcpBridge,
 		openClawToolsMcpBridge,
-		strictWindowsCmdWrapper: normalized.strictWindowsCmdWrapper ?? DEFAULT_STRICT_WINDOWS_CMD_WRAPPER,
 		timeoutSeconds: normalized.timeoutSeconds ?? 120,
-		queueOwnerTtlSeconds: normalized.queueOwnerTtlSeconds ?? DEFAULT_QUEUE_OWNER_TTL_SECONDS,
-		legacyCompatibilityConfig: {
-			strictWindowsCmdWrapper: normalized.strictWindowsCmdWrapper,
-			queueOwnerTtlSeconds: normalized.queueOwnerTtlSeconds
-		},
 		mcpServers,
 		agents
 	};
@@ -272,6 +264,15 @@ function commandWrapperBelongsToRoot(command, wrapperRoot) {
 	const normalizedRoot = normalizePathLike(wrapperRoot).replace(/\/+$/, "");
 	return Array.from(GENERATED_WRAPPER_BASENAMES).some((basename) => normalizedCommand.includes(`${normalizedRoot}/${basename}`));
 }
+function commandContainsExactWrapperPath(command, wrapperPath) {
+	const expectedPath = normalizePathLike(wrapperPath);
+	return splitCommandParts(command).some((part) => normalizePathLike(part) === expectedPath);
+}
+function wrapperPathBelongsToRoot(wrapperPath, wrapperRoot) {
+	const normalizedPath = normalizePathLike(wrapperPath);
+	const normalizedRoot = normalizePathLike(wrapperRoot).replace(/\/+$/, "");
+	return GENERATED_WRAPPER_BASENAMES.has(path.posix.basename(normalizedPath)) && normalizedPath.startsWith(`${normalizedRoot}/`);
+}
 /** Check whether a command references an OpenClaw-generated ACPX wrapper path. */
 function isOpenClawLeaseAwareAcpxProcessCommand(params) {
 	const command = params.command?.trim();
@@ -354,14 +355,6 @@ function collectProcessTree(processes, rootPid) {
 function uniquePids(processes) {
 	return Array.from(new Set(processes.map((processInfo) => processInfo.pid).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid)));
 }
-function isProcessAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
 async function terminatePids(pids, deps) {
 	const killProcess = deps?.killProcess ?? ((pid, signal) => process.kill(pid, signal));
 	const sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => {
@@ -374,7 +367,7 @@ async function terminatePids(pids, deps) {
 	} catch {}
 	if (terminated.length === 0) return terminated;
 	await sleep(750);
-	for (const pid of terminated) if (deps?.killProcess || isProcessAlive(pid)) try {
+	for (const pid of terminated) if (deps?.killProcess || isPidAlive(pid)) try {
 		killProcess(pid, "SIGKILL");
 	} catch {}
 	return terminated;
@@ -387,6 +380,11 @@ async function cleanupOpenClawOwnedAcpxProcessTree(params) {
 		terminatedPids: [],
 		skippedReason: "missing-root"
 	};
+	if ((params.deps?.platform ?? process.platform) === "win32") return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unsupported-platform"
+	};
 	let processes;
 	try {
 		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
@@ -439,9 +437,53 @@ async function cleanupOpenClawOwnedAcpxProcessTree(params) {
 		terminatedPids: await terminatePids(pids, params.deps)
 	};
 }
+/** Recover a pending lease by matching its exact live wrapper identity. */
+async function cleanupOpenClawOwnedAcpxPendingLease(params) {
+	if ((params.deps?.platform ?? process.platform) === "win32") return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unsupported-platform"
+	};
+	if (!params.wrapperPath || !wrapperPathBelongsToRoot(params.wrapperPath, params.wrapperRoot)) return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "unverified-root"
+	};
+	let processes;
+	try {
+		processes = await (params.deps?.listProcesses ?? listPlatformProcesses)();
+	} catch {
+		return {
+			inspectedPids: [],
+			terminatedPids: [],
+			skippedReason: "process-list-unavailable"
+		};
+	}
+	const matchingRoots = processes.filter((processInfo) => commandContainsExactWrapperPath(processInfo.command, params.wrapperPath) && liveCommandMatchesLeaseIdentity({
+		command: processInfo.command,
+		expectedLeaseId: params.leaseId,
+		expectedGatewayInstanceId: params.gatewayInstanceId
+	}));
+	if (matchingRoots.length === 0) return {
+		inspectedPids: [],
+		terminatedPids: [],
+		skippedReason: "missing-root"
+	};
+	if (matchingRoots.length > 1) return {
+		inspectedPids: uniquePids(matchingRoots),
+		terminatedPids: [],
+		skippedReason: "ambiguous-root"
+	};
+	const listedTree = collectProcessTree(processes, matchingRoots[0].pid);
+	const pids = uniquePids(listedTree.toReversed());
+	return {
+		inspectedPids: uniquePids(listedTree),
+		terminatedPids: await terminatePids(pids, params.deps)
+	};
+}
 /** Reap orphaned OpenClaw-owned ACPX wrapper trees during runtime startup. */
 async function reapStaleOpenClawOwnedAcpxOrphans(params) {
-	if (process.platform === "win32") return {
+	if ((params.deps?.platform ?? process.platform) === "win32") return {
 		inspectedPids: [],
 		terminatedPids: [],
 		skippedReason: "unsupported-platform"
@@ -456,7 +498,7 @@ async function reapStaleOpenClawOwnedAcpxOrphans(params) {
 			skippedReason: "process-list-unavailable"
 		};
 	}
-	const orphanTrees = processes.filter((processInfo) => processInfo.ppid === 1 && isOpenClawOwnedAcpxProcessCommand({
+	const orphanTrees = processes.filter((processInfo) => processInfo.ppid === 1 && !readAcpxProcessLeaseIdentity(processInfo.command) && isOpenClawOwnedAcpxProcessCommand({
 		command: processInfo.command,
 		wrapperRoot: params.wrapperRoot
 	})).map((orphan) => collectProcessTree(processes, orphan.pid));
@@ -466,4 +508,4 @@ async function reapStaleOpenClawOwnedAcpxOrphans(params) {
 	};
 }
 //#endregion
-export { resolveAcpxPluginRoot as a, CODEX_ACP_PACKAGE as c, resolveAcpxPluginConfig as i, LEGACY_CODEX_ACP_PACKAGE as l, isOpenClawLeaseAwareAcpxProcessCommand as n, toAcpMcpServers as o, reapStaleOpenClawOwnedAcpxOrphans as r, CODEX_ACP_BIN as s, cleanupOpenClawOwnedAcpxProcessTree as t, OPENCLAW_CODEX_CONFIG_ARG as u };
+export { resolveAcpxPluginConfig as a, CODEX_ACP_BIN as c, OPENCLAW_CODEX_CONFIG_ARG as d, reapStaleOpenClawOwnedAcpxOrphans as i, CODEX_ACP_PACKAGE as l, cleanupOpenClawOwnedAcpxProcessTree as n, resolveAcpxPluginRoot as o, isOpenClawLeaseAwareAcpxProcessCommand as r, toAcpMcpServers as s, cleanupOpenClawOwnedAcpxPendingLease as t, LEGACY_CODEX_ACP_PACKAGE as u };

package/dist/register.runtime-Dj29TKFy.js

@@ -0,0 +1,180 @@
+import { getAcpRuntimeBackend, registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+//#region extensions/acpx/src/runtime-proxy.ts
+/** Start an ACP turn through a lazy runtime resolver without awaiting resolution up front. */
+function lazyStartRuntimeTurn(resolveRuntime, input) {
+	const turnPromise = resolveRuntime().then((runtime) => runtime.startTurn(input));
+	return {
+		requestId: input.requestId,
+		get promptStarted() {
+			return turnPromise.then((turn) => turn.promptStarted);
+		},
+		events: { async *[Symbol.asyncIterator]() {
+			yield* (await turnPromise).events;
+		} },
+		result: turnPromise.then((turn) => turn.result),
+		cancel(inputArgs) {
+			return turnPromise.then((turn) => turn.cancel(inputArgs));
+		},
+		closeStream(inputArgs) {
+			return turnPromise.then((turn) => turn.closeStream(inputArgs));
+		}
+	};
+}
+/** Create an ACP runtime facade backed by an async runtime resolver. */
+function createLazyAcpRuntimeProxy(resolveRuntime) {
+	return {
+		async ensureSession(input) {
+			return await (await resolveRuntime()).ensureSession(input);
+		},
+		startTurn(input) {
+			return lazyStartRuntimeTurn(resolveRuntime, input);
+		},
+		async *runTurn(input) {
+			yield* (await resolveRuntime()).runTurn(input);
+		},
+		async getCapabilities(input) {
+			return await (await resolveRuntime()).getCapabilities(input);
+		},
+		async getStatus(input) {
+			return await (await resolveRuntime()).getStatus(input);
+		},
+		async setMode(input) {
+			await (await resolveRuntime()).setMode(input);
+		},
+		async setConfigOption(input) {
+			await (await resolveRuntime()).setConfigOption(input);
+		},
+		async doctor() {
+			return await (await resolveRuntime()).doctor();
+		},
+		async prepareFreshSession(input) {
+			await (await resolveRuntime()).prepareFreshSession(input);
+		},
+		async cancel(input) {
+			await (await resolveRuntime()).cancel(input);
+		},
+		async close(input) {
+			await (await resolveRuntime()).close(input);
+		}
+	};
+}
+//#endregion
+//#region extensions/acpx/register.runtime.ts
+/**
+* Lazy ACPX runtime service registration. The plugin exposes an ACP backend
+* immediately, then imports the heavier service only when a session needs it.
+*/
+const ACPX_BACKEND_ID = "acpx";
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-PRlUtXMf.js"));
+function unregisterOwnedRuntime(runtime) {
+	if (runtime && getAcpRuntimeBackend(ACPX_BACKEND_ID)?.runtime === runtime) unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
+}
+async function startRealService(state, lifecycleRevision, deferredRuntime) {
+	if (state.lifecycleRevision !== lifecycleRevision || !state.ctx) throw new Error("ACPX runtime service is not started");
+	if (state.realRuntime) return state.realRuntime;
+	if (state.startPromise) return await state.startPromise;
+	const ctx = state.ctx;
+	state.startPromise = (async () => {
+		let publishedRuntime = null;
+		const { createAcpxRuntimeService: createAcpxRuntimeServiceLocal } = await loadServiceModule();
+		const service = createAcpxRuntimeServiceLocal({
+			...state.params,
+			backendLifecycle: {
+				publish(backend) {
+					if (state.lifecycleRevision !== lifecycleRevision || state.ctx !== ctx) throw new Error("ACPX runtime service stopped during activation");
+					if (getAcpRuntimeBackend(ACPX_BACKEND_ID)?.runtime !== deferredRuntime) throw new Error("ACPX runtime service lost registry ownership during activation");
+					registerAcpRuntimeBackend({
+						id: ACPX_BACKEND_ID,
+						...backend
+					});
+					publishedRuntime = backend.runtime;
+					state.ownedRuntime = backend.runtime;
+				},
+				retract(runtime) {
+					unregisterOwnedRuntime(runtime);
+				}
+			}
+		});
+		state.realService = service;
+		await service.start(ctx);
+		if (state.lifecycleRevision !== lifecycleRevision || state.ctx !== ctx) throw new Error("ACPX runtime service stopped during activation");
+		if (!publishedRuntime) throw new Error("ACPX runtime service did not register an ACP backend");
+		if (getAcpRuntimeBackend(ACPX_BACKEND_ID)?.runtime !== publishedRuntime) throw new Error("ACPX runtime service lost registry ownership during activation");
+		state.realRuntime = publishedRuntime;
+		return publishedRuntime;
+	})();
+	try {
+		return await state.startPromise;
+	} catch (error) {
+		if (state.lifecycleRevision === lifecycleRevision) {
+			state.startPromise = null;
+			state.realService = null;
+		}
+		throw error;
+	}
+}
+function createDeferredRuntime(state, lifecycleRevision) {
+	const deferredRuntime = createLazyAcpRuntimeProxy(() => startRealService(state, lifecycleRevision, deferredRuntime));
+	return deferredRuntime;
+}
+/** Creates the plugin service that registers ACPX as an ACP runtime backend. */
+function createAcpxRuntimeService(params = {}) {
+	const state = {
+		ctx: null,
+		lifecycleRevision: 0,
+		ownedRuntime: null,
+		params,
+		realRuntime: null,
+		realService: null,
+		startPromise: null,
+		stopPromise: null
+	};
+	return {
+		id: "acpx-runtime",
+		async start(ctx) {
+			if (process.env.OPENCLAW_SKIP_ACPX_RUNTIME === "1") {
+				ctx.logger.info("skipping embedded acpx runtime backend (OPENCLAW_SKIP_ACPX_RUNTIME=1)");
+				return;
+			}
+			if (state.stopPromise) await state.stopPromise;
+			state.lifecycleRevision += 1;
+			const lifecycleRevision = state.lifecycleRevision;
+			state.ctx = ctx;
+			const deferredRuntime = createDeferredRuntime(state, lifecycleRevision);
+			state.ownedRuntime = deferredRuntime;
+			registerAcpRuntimeBackend({
+				id: ACPX_BACKEND_ID,
+				runtime: deferredRuntime
+			});
+			ctx.logger.info("embedded acpx runtime backend registered lazily");
+		},
+		async stop(ctx) {
+			if (state.stopPromise) return await state.stopPromise;
+			state.lifecycleRevision += 1;
+			state.ctx = null;
+			const ownedRuntime = state.ownedRuntime;
+			unregisterOwnedRuntime(ownedRuntime);
+			const startPromise = state.startPromise;
+			state.stopPromise = (async () => {
+				await startPromise?.catch(() => void 0);
+				try {
+					await state.realService?.stop?.(ctx);
+				} finally {
+					unregisterOwnedRuntime(ownedRuntime);
+					state.ownedRuntime = null;
+					state.realRuntime = null;
+					state.realService = null;
+					state.startPromise = null;
+				}
+			})();
+			try {
+				await state.stopPromise;
+			} finally {
+				state.stopPromise = null;
+			}
+		}
+	};
+}
+//#endregion
+export { createLazyAcpRuntimeProxy as n, createAcpxRuntimeService as t };

package/dist/register.runtime.js

@@ -1,2 +1,2 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-BbS2JTTv.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-Dj29TKFy.js";
 export { createAcpxRuntimeService };