zidane 9.1.1 → 9.1.3

package/dist/{host-wO_6GW0y.js → host-C61ntFBC.js}

@@ -1,22 +1,22 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.js";
 import { p as errorMessage } from "./errors-C3z7pmOx.js";
 import { i as ARTIFACT_KIND_PATTERN } from "./artifacts-DPVc-oG0.js";
-import { i as extensionStoragePath, o as withProvenance } from "./json-Dj-YATkZ.js";
-import { a as readonlyView, i as isKnownHookEvent, n as createDecider, o as unwrapReadonly } from "./decisions-CXmK0nz9.js";
-import { D as errorMessage$1, E as checkSchema, G as NoUiError, H as DialogTimeoutError, I as checkSettingsValues, Jt as DisposedError, L as cleanSettingsSchema, N as createFacetRegistry, O as isPlainRecord, R as settingsWire, Rt as validateDefinition, S as createMemoryRegistry, T as validateStoreValue, _ as createMemorySettingsPort, a as systemClock, bt as normalizeChords, ct as track, dt as createWorkspaceSurface, f as EMPTY_MCP_PORT, g as NO_UI_CLIENT_PORT, h as NO_INTEGRATION_FLOWS, lt as createArtifactsSurface, m as NO_CLIENT_DIALOG_PORT, ot as assertAlive, r as createUiRegistry, st as createOwner, u as runtimeSettingsWire, v as createMemoryStoragePort, w as createStorageDomain, xt as resolveMod, yt as createKeymap, zt as actionScope } from "./registry-B9INJwJR.js";
+import { a as withProvenance } from "./json-BjClr43H.js";
+import { a as readonlyView, i as isKnownHookEvent, n as createDecider, o as unwrapReadonly } from "./decisions-hsw5XS2g.js";
+import { Ct as normalizeChords, D as errorMessage$1, E as checkSchema, Ht as actionScope, K as NoUiError, L as checkSettingsValues, O as isPlainRecord, P as createFacetRegistry, R as cleanSettingsSchema, S as createMemoryRegistry, St as createKeymap, T as validateStoreValue, U as DialogTimeoutError, Vt as validateDefinition, Zt as DisposedError, _ as createMemorySettingsPort, a as systemClock, ct as assertUsable, dt as track, f as EMPTY_MCP_PORT, ft as createArtifactsSurface, g as NO_UI_CLIENT_PORT, h as NO_INTEGRATION_FLOWS, k as resolveStoragePath, lt as createOwner, m as NO_CLIENT_DIALOG_PORT, mt as createWorkspaceSurface, r as createUiRegistry, st as assertAlive, u as runtimeSettingsWire, ut as isTornDown, v as createMemoryStoragePort, w as createStorageDomain, wt as resolveMod, z as settingsWire } from "./registry-CnnKaY9s.js";
 import { t as generateStructuredData } from "./generate-data-Cs86LH2u.js";
 import { t as createArtifactDetectHook } from "./artifact-detect-BkDNUhfB.js";
-import { t as ZIDANE_VERSION } from "./version-DqqqvHDP.js";
-import { n as satisfiesVersionRange } from "./host-version-CNAr9pov.js";
+import { t as ZIDANE_VERSION } from "./version-szdW1Od9.js";
+import { n as satisfiesVersionRange } from "./host-version-BIx4CuBM.js";
 import { F as parseBindingSpec } from "./references-DZ5qTYDl.js";
 import { r as createLogger, t as consoleSink } from "./logger-BQj8QCJp.js";
-import { a as createSettingsDomain, n as RpcErrorType, r as jsonBytes } from "./wire-CLm2rMK0.js";
+import { a as createSettingsDomain, n as RpcErrorType, r as jsonBytes } from "./wire-C3l9jl9x.js";
 import { t as IMAGE_ASPECT_RATIOS } from "./types-JzccL5GE.js";
-import { s as onProviderAccountsChange } from "./credentials-wwETW8rI.js";
-import { n as integrationRegistry, t as createIntegrationRegistry } from "./registry-BKjeBnoy.js";
+import { s as onProviderAccountsChange } from "./credentials-Bqg-qNBM.js";
+import { n as integrationRegistry, t as createIntegrationRegistry } from "./registry-CJHvmvaP.js";
 import { n as RpcCallError } from "./rpc-Daec0xVh.js";
 import { r as loadAgentPlugin } from "./plugins-CNj4kHpO.js";
-import { a as createModelsCatalog, c as addTransform, d as reloadWith, f as createCatalogSet, h as createSessionsDomain, i as watchProviderAccounts, l as extensionOrigin, m as clonePlain, n as createProvidersCatalog, o as createModelsDomain, p as once, r as createProvidersDomain, u as owned } from "./providers-Z0TaBp1O.js";
+import { a as createModelsCatalog, c as addTransform, d as reloadWith, f as createCatalogSet, h as createSessionsDomain, i as watchProviderAccounts, l as extensionOrigin, m as clonePlain, n as createProvidersCatalog, o as createModelsDomain, p as once, r as createProvidersDomain, u as owned } from "./providers-CpXV_uLE.js";
 import { basename, isAbsolute, resolve } from "node:path";
 import { createHooks } from "hookable";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -914,6 +914,54 @@ function paletteProviderEntry(deps, spec, group) {
 		} } : {}
 	};
 }
+/** Marks a run in flight (`Guard.lease`): an unload meanwhile tears down only once it ends. Throws `DisposedError` once unloaded. */
+function lease(guard, label) {
+	return guard.lease?.(label) ?? (() => {});
+}
+/** `fn` holding a lease while it runs. */
+function leased(guard, label, fn) {
+	return (...args) => {
+		const release = lease(guard, label);
+		let result;
+		try {
+			result = fn(...args);
+		} catch (error) {
+			release();
+			throw error;
+		}
+		if (result && typeof result.then === "function") return result.finally(release);
+		release();
+		return result;
+	};
+}
+/**
+* The steps of one pipeline share one lease, from the first step to the last
+* (or the step that throws, or an abort), so an unload between two steps does
+* not tear the extension down under the next one. Keyed by the run's context,
+* which `executeCommand` hands to every step.
+*/
+function pipeline(guard, label, steps) {
+	const runs = /* @__PURE__ */ new WeakMap();
+	const end = (ctx) => {
+		const release = runs.get(ctx);
+		runs.delete(ctx);
+		release?.();
+	};
+	return steps.map((step, i) => ({ run: async (ctx) => {
+		if (!runs.has(ctx)) {
+			runs.set(ctx, lease(guard, label));
+			ctx.signal?.addEventListener("abort", () => end(ctx), { once: true });
+		}
+		try {
+			const result = await step.run(ctx);
+			if (i === steps.length - 1) end(ctx);
+			return result;
+		} catch (error) {
+			end(ctx);
+			throw error;
+		}
+	} }));
+}
 /**
 * Makes `ctx.commands` and `ctx.keymap` for one extension.
 *
@@ -1012,7 +1060,7 @@ function createCommandsDomain(deps, port, opts = {}) {
 		}
 		const run = spec.run;
 		const complete = spec.slash?.complete;
-		const steps = hasSteps ? spec.steps.map((step, i) => ({ run: attributed(`command ${id} step ${i + 1}`, step.run) })) : void 0;
+		const steps = hasSteps ? pipeline(guard, `command ${id}`, spec.steps.map((step, i) => ({ run: attributed(`command ${id} step ${i + 1}`, step.run) }))) : void 0;
 		const entry = {
 			id,
 			extensionId,
@@ -1040,7 +1088,7 @@ function createCommandsDomain(deps, port, opts = {}) {
 					for (const stop of stops) guard.callSync(`command ${id} unsubscribe`, stop);
 				};
 			},
-			...typeof run === "function" ? { run: attributed(`command ${id}`, run) } : {},
+			...typeof run === "function" ? { run: leased(guard, `command ${id}`, attributed(`command ${id}`, run)) } : {},
 			...steps ? { steps } : {},
 			...typeof complete === "function" ? { complete: async (prefix) => await guard.call(`command ${id} complete`, () => complete(prefix), { fallback: [] }) ?? [] } : {}
 		};
@@ -2118,6 +2166,16 @@ function createGuard(options) {
 	const threw = (label, cause) => {
 		fail(new ExtensionCallbackError(extensionId, label, "error", errorMessage(cause), cause));
 	};
+	const lease = (label, opts = {}) => options.lease ? options.lease(`[${extensionId}] ${label}`, opts) : () => {};
+	/** A lease for a guarded call, or `undefined` when the extension is unloaded (the call does not run). */
+	const tryLease = (label, timeoutMs) => {
+		try {
+			return lease(label, timeoutMs !== void 0 && Number.isFinite(timeoutMs) ? { timeoutMs } : {});
+		} catch (error) {
+			if (error instanceof DisposedError) return void 0;
+			throw error;
+		}
+	};
 	return {
 		extensionId,
 		get tripped() {
@@ -2128,56 +2186,74 @@ function createGuard(options) {
 			return [...failures];
 		},
 		report: threw,
+		lease,
 		async call(label, fn, opts = {}) {
 			if (tripped && !opts.teardown) return opts.fallback;
-			const controller = new AbortController();
-			let result;
-			try {
-				result = stalls.run(extensionId, label, () => fn(controller.signal));
-			} catch (error) {
-				threw(label, error);
-				return opts.fallback;
-			}
-			if (!isThenable(result)) return result;
-			const pending = Promise.resolve(result);
-			const timeoutMs = opts.timeoutMs ?? defaultTimeout;
-			if (!Number.isFinite(timeoutMs)) try {
-				return await pending;
-			} catch (error) {
-				threw(label, error);
-				return opts.fallback;
-			}
-			let timer;
-			const timedOut = new Promise((resolve) => {
-				timer = setTimeout(resolve, timeoutMs, TIMED_OUT);
-			});
+			const release = opts.teardown ? () => {} : tryLease(label, opts.timeoutMs ?? defaultTimeout);
+			if (!release) return opts.fallback;
 			try {
-				const value = await Promise.race([pending, timedOut]);
-				if (value !== TIMED_OUT) return value;
-				const message = `timed out after ${timeoutMs}ms`;
-				controller.abort(/* @__PURE__ */ new Error(`${label} ${message}`));
-				pending.catch(() => {});
-				fail(new ExtensionCallbackError(extensionId, label, "timeout", message));
-				return opts.fallback;
-			} catch (error) {
-				threw(label, error);
-				return opts.fallback;
+				return await runCall(label, fn, opts);
 			} finally {
-				clearTimeout(timer);
+				release();
 			}
 		},
 		callSync(label, fn, opts = {}) {
 			if (tripped) return opts.fallback;
+			const release = tryLease(label);
+			if (!release) return opts.fallback;
+			let value;
 			try {
-				const value = stalls.run(extensionId, label, fn);
-				if (isThenable(value)) Promise.resolve(value).catch((error) => threw(label, error));
-				return value;
+				value = stalls.run(extensionId, label, fn);
 			} catch (error) {
+				release();
 				threw(label, error);
 				return opts.fallback;
 			}
+			if (isThenable(value)) {
+				Promise.resolve(value).catch((error) => threw(label, error)).finally(release);
+				return value;
+			}
+			release();
+			return value;
 		}
 	};
+	async function runCall(label, fn, opts) {
+		const controller = new AbortController();
+		let result;
+		try {
+			result = stalls.run(extensionId, label, () => fn(controller.signal));
+		} catch (error) {
+			threw(label, error);
+			return opts.fallback;
+		}
+		if (!isThenable(result)) return result;
+		const pending = Promise.resolve(result);
+		const timeoutMs = opts.timeoutMs ?? defaultTimeout;
+		if (!Number.isFinite(timeoutMs)) try {
+			return await pending;
+		} catch (error) {
+			threw(label, error);
+			return opts.fallback;
+		}
+		let timer;
+		const timedOut = new Promise((resolve) => {
+			timer = setTimeout(resolve, timeoutMs, TIMED_OUT);
+		});
+		try {
+			const value = await Promise.race([pending, timedOut]);
+			if (value !== TIMED_OUT) return value;
+			const message = `timed out after ${timeoutMs}ms`;
+			controller.abort(/* @__PURE__ */ new Error(`${label} ${message}`));
+			pending.catch(() => {});
+			fail(new ExtensionCallbackError(extensionId, label, "timeout", message));
+			return opts.fallback;
+		} catch (error) {
+			threw(label, error);
+			return opts.fallback;
+		} finally {
+			clearTimeout(timer);
+		}
+	}
 }
 function isThenable(value) {
 	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
@@ -2509,6 +2585,32 @@ function createToolsCatalog(port, options = {}) {
 		}
 	};
 }
+/**
+* `def` whose `execute` holds a lease on the extension (`Guard.lease`) while
+* it runs: an agent that took the tool before an unload finishes the call
+* on live domains. A call that starts after the unload throws
+* `DisposedError`. Same prototype and properties, like {@link cloneTool}.
+*/
+function leasedTool(deps, name, def) {
+	const lease = deps.guard.lease;
+	if (!lease) return def;
+	const execute = def.execute;
+	const wrapped = Object.create(Object.getPrototypeOf(def), Object.getOwnPropertyDescriptors(def));
+	wrapped.execute = function(...args) {
+		const release = lease(`tool ${name}`);
+		let result;
+		try {
+			result = execute.apply(this, args);
+		} catch (error) {
+			release();
+			throw error;
+		}
+		if (result && typeof result.then === "function") return result.finally(release);
+		release();
+		return result;
+	};
+	return wrapped;
+}
 /** Creates one extension's `ctx.tools` over the shared catalog. */
 function createToolsDomain(deps, catalog) {
 	return {
@@ -2517,7 +2619,7 @@ function createToolsDomain(deps, catalog) {
 			if (!def || typeof def.execute !== "function") throw new TypeError(`tools.register: "${name}" needs a ToolDef with execute`);
 			return owned(deps, "tools.register", () => catalog.register({
 				name,
-				def
+				def: leasedTool(deps, name, def)
 			}, extensionOrigin(deps)));
 		},
 		metadata(namespace, spec) {
@@ -2795,15 +2897,15 @@ function createArtifactsDomain(deps, port) {
 			}));
 		} },
 		list: async (query) => {
-			assertAlive(owner, "artifacts.list");
+			assertUsable(owner, "artifacts.list");
 			return surface.list(query);
 		},
 		find: async (kind, uri) => {
-			assertAlive(owner, "artifacts.find");
+			assertUsable(owner, "artifacts.find");
 			return (await surface.find(kind, uri))[0];
 		},
 		record: async (input) => {
-			assertAlive(owner, "artifacts.record");
+			assertUsable(owner, "artifacts.record");
 			return surface.record(input);
 		}
 	};
@@ -2890,9 +2992,9 @@ function createGenerateDomain(deps, port) {
 		hooks: createHooks()
 	}).forRun(void 0));
 	const resolve = async (method, model) => {
-		assertAlive(owner, `generate.${method}`);
+		assertUsable(owner, `generate.${method}`);
 		const resolved = await port.resolve(model);
-		assertAlive(owner, `generate.${method}`);
+		assertUsable(owner, `generate.${method}`);
 		const counted = counting(resolved.provider, (usage) => {
 			try {
 				port.recordUsage?.({
@@ -2912,14 +3014,14 @@ function createGenerateDomain(deps, port) {
 		};
 	};
 	const decide = ((request, options) => {
-		assertAlive(owner, "generate.decide");
+		assertUsable(owner, "generate.decide");
 		const scoped = {
 			...request,
 			signal: combined(owner.signal, request.signal)
 		};
 		return options ? decider()(scoped, options) : decider()(scoped);
 	});
-	Object.defineProperty(decide, "available", { get: () => !owner.disposed && decider().available });
+	Object.defineProperty(decide, "available", { get: () => !isTornDown(owner) && decider().available });
 	return {
 		async text(opts) {
 			const { counted, modelId } = await resolve("text", opts.model);
@@ -2947,11 +3049,11 @@ function createGenerateDomain(deps, port) {
 		},
 		decide,
 		async image(opts) {
-			assertAlive(owner, "generate.image");
+			assertUsable(owner, "generate.image");
 			const request = imageRequest(extensionId, opts, combined(owner.signal, opts?.signal));
 			if (!port.image) throw new Error("generate.image: this host cannot generate images");
 			const result = await port.image(request);
-			assertAlive(owner, "generate.image");
+			assertUsable(owner, "generate.image");
 			try {
 				port.recordUsage?.({
 					extensionId,
@@ -3069,7 +3171,12 @@ function createPluginsDomain(deps, port) {
 		const source = skillSource(extension.source);
 		const loaded = await loadAgentPlugin(target, {
 			source,
-			dataRoot: extensionStoragePath(extension.paths, extensionId, "data", "plugin-data"),
+			dataRoot: extension.storagePath?.("data", "plugin-data") ?? resolveStoragePath({
+				paths: extension.paths,
+				extensionId,
+				...extension.dir !== void 0 ? { dir: extension.dir } : {},
+				logger
+			}, "data", "plugin-data"),
 			...options.skills !== void 0 ? { skills: options.skills } : {},
 			...options.mcp !== void 0 ? { mcp: options.mcp } : {},
 			...options.namePrefix !== void 0 ? { namePrefix: options.namePrefix } : {}
@@ -3134,11 +3241,11 @@ function createWorkspaceDomain(deps, port) {
 	const surface = createWorkspaceSurface(async () => await port.current()?.workspace?.() ?? null, () => port.current()?.workspaceAvailable?.());
 	return {
 		available: async () => {
-			assertAlive(owner, "workspace.available");
+			assertUsable(owner, "workspace.available");
 			return surface.available();
 		},
 		exec: async (command, options = {}) => {
-			assertAlive(owner, "workspace.exec");
+			assertUsable(owner, "workspace.exec");
 			const signal = options.signal ? AbortSignal.any([options.signal, owner.signal]) : owner.signal;
 			return surface.exec(command, {
 				...options,
@@ -3146,19 +3253,19 @@ function createWorkspaceDomain(deps, port) {
 			});
 		},
 		readFile: async (path) => {
-			assertAlive(owner, "workspace.readFile");
+			assertUsable(owner, "workspace.readFile");
 			return surface.readFile(path);
 		},
 		writeFile: async (path, content) => {
-			assertAlive(owner, "workspace.writeFile");
+			assertUsable(owner, "workspace.writeFile");
 			return surface.writeFile(path, content);
 		},
 		listFiles: async (path, options) => {
-			assertAlive(owner, "workspace.listFiles");
+			assertUsable(owner, "workspace.listFiles");
 			return surface.listFiles(path, options);
 		},
 		fileSize: async (path) => {
-			assertAlive(owner, "workspace.fileSize");
+			assertUsable(owner, "workspace.fileSize");
 			return surface.fileSize(path);
 		}
 	};
@@ -3303,7 +3410,7 @@ function createExtensionContext(input, services, owner) {
 			const childCtx = createExtensionContext(input, services, child);
 			return Object.assign(childCtx, { dispose: () => child.dispose() });
 		},
-		onCleanup: (cleanup) => owner.onCleanup(cleanup),
+		onCleanup: (cleanup) => owner.onTeardown(cleanup),
 		add: createUiAdd(deps, services.ui),
 		tools: createToolsDomain(deps, catalogs.tools),
 		hooks: createHooksDomain(deps, input.hooks, { interceptors: services.interceptors }),
@@ -3341,6 +3448,8 @@ function desktopDomain(port, owner) {
 		}
 	};
 }
+/** How long unload waits for async cleanups, in ms. */
+const UNLOAD_TIMEOUT_MS = 5e3;
 const NOT_SETTLED = Symbol("not settled");
 /**
 * Runs `definition.setup` with a context bound to `owner`.
@@ -3408,7 +3517,7 @@ async function runSetup(definition, ctxFactory, owner, guard, options = {}) {
 	const warnings = [];
 	if (typeof result === "function") {
 		const cleanup = result;
-		owner.onCleanup(() => runCleanup(cleanup));
+		owner.onTeardown(() => runCleanup(cleanup));
 	} else if (result !== void 0) warnings.push(`setup returned ${typeof result}; only a cleanup function or nothing is used`);
 	return {
 		ok: true,
@@ -3416,9 +3525,11 @@ async function runSetup(definition, ctxFactory, owner, guard, options = {}) {
 	};
 }
 /**
-* Unloads an extension: disposes its owner (aborting `ctx.signal`, then
-* every registration and cleanup in reverse order) and waits for the async
-* cleanups up to a bound. Calling it again is harmless.
+* Unloads an extension: disposes its owner (every registration withdrawn,
+* then `ctx.signal` aborted and the teardown cleanups run) and waits for the
+* async cleanups up to a bound. With calls in flight the teardown waits for
+* them (`owner.ts`): unload then waits only for the withdrawal and reports
+* `draining`. Calling it again is harmless.
 *
 * @param owner - The extension's root owner.
 * @param options - `timeoutMs`, default {@link UNLOAD_TIMEOUT_MS}.
@@ -3426,14 +3537,26 @@ async function runSetup(definition, ctxFactory, owner, guard, options = {}) {
 * @returns Whether every cleanup finished in time.
 */
 async function unload(owner, options = {}) {
-	const timeoutMs = options.timeoutMs ?? 5e3;
 	owner.dispose();
+	if (owner.draining) return {
+		...await settleWithin(owner.withdrawn, options.timeoutMs),
+		draining: true
+	};
+	return settleWithin(owner.settled, options.timeoutMs);
+}
+/**
+* Waits for `done` up to `timeoutMs` (default {@link UNLOAD_TIMEOUT_MS}).
+*
+* @param done - Async cleanups settling.
+* @param timeoutMs - The bound.
+*/
+async function settleWithin(done, timeoutMs = UNLOAD_TIMEOUT_MS) {
 	let timer;
 	const timedOut = new Promise((resolve) => {
 		timer = setTimeout(resolve, timeoutMs, NOT_SETTLED);
 	});
 	try {
-		return await Promise.race([owner.settled, timedOut]) === NOT_SETTLED ? {
+		return await Promise.race([done, timedOut]) === NOT_SETTLED ? {
 			ok: false,
 			error: `cleanup still running after ${timeoutMs}ms`
 		} : { ok: true };
@@ -3627,7 +3750,9 @@ function createShared(options, ports, baseLogger, records, order, rank) {
 			changeListeners.delete(listener);
 		};
 	};
+	let withdrawals = 0;
 	const outputs = {
+		withdrawals: () => withdrawals,
 		interceptors: createInterceptorRegistry({ loadOrder: rank }),
 		catalogs: {
 			tools: createToolsCatalog(ports.catalogs?.tools ?? { base: () => [] }, loadOrder),
@@ -3675,7 +3800,8 @@ function createShared(options, ports, baseLogger, records, order, rank) {
 			return r ? {
 				...r.entry.dir !== void 0 ? { dir: r.entry.dir } : {},
 				source: r.entry.source,
-				paths: options.paths
+				paths: options.paths,
+				...r.storage ? { storagePath: r.storage.storage.path } : {}
 			} : void 0;
 		},
 		registerSkill: (skill, origin) => outputs.catalogs.skills.register(skill, origin),
@@ -3729,6 +3855,9 @@ function createShared(options, ports, baseLogger, records, order, rank) {
 		commands.dispose();
 		services.dialogs.dispose();
 	};
+	const withdrawn = () => {
+		withdrawals++;
+	};
 	return {
 		outputs,
 		services,
@@ -3741,7 +3870,8 @@ function createShared(options, ports, baseLogger, records, order, rank) {
 		subscribe,
 		changeListeners,
 		...rpcBridge ? { rpcBridge } : {},
-		release
+		release,
+		withdrawn
 	};
 }
 /** The per-extension hooks port: the host's bus when given, else the extension's own. */
@@ -3882,8 +4012,9 @@ async function preloadSessions(records, sessionId, logger) {
 * withdrawn, cleanups run) and its async cleanups get the unload bound; one
 * still running then is logged and left alone. Called again while that runs
 * (an unload after the guard tripped), it waits for the same teardown.
+* `withdrawn` is told before an active owner's registrations go.
 */
-function deactivateRecord(r, logger) {
+function deactivateRecord(r, logger, withdrawn) {
 	const owner = r.owner;
 	r.owner = void 0;
 	r.guard = void 0;
@@ -3894,6 +4025,9 @@ function deactivateRecord(r, logger) {
 		r.host.clear();
 		return r.deactivating ?? Promise.resolve();
 	}
+	withdrawn();
+	owner.dispose();
+	if (owner.draining) r.teardown = awaitTeardown(owner, r.id, logger);
 	r.deactivating = (async () => {
 		const outcome = await unload(owner);
 		if (!outcome.ok) logger.warn(`unload: ${outcome.error}`, { extension: r.id });
@@ -3902,6 +4036,61 @@ function deactivateRecord(r, logger) {
 	})();
 	return r.deactivating;
 }
+/**
+* Waits for a draining owner's teardown: it runs once its calls in flight
+* ended (bounded by the drain bound), then its async cleanups get the unload bound.
+*/
+function awaitTeardown(owner, id, logger) {
+	return new Promise((resolve) => {
+		const started = () => {
+			settleWithin(owner.settled).then((outcome) => {
+				if (!outcome.ok) logger.warn(`unload: ${outcome.error}`, { extension: id });
+				resolve();
+			});
+		};
+		if (owner.tornDown) started();
+		else owner.signal.addEventListener("abort", started, { once: true });
+	});
+}
+/**
+* One extension's guard and root owner. Every guarded call holds a lease on
+* the owner, and the owner logs a deferred teardown on the extension's logger.
+*/
+function createGuardedOwner(id, logger, stalls, options, onTrip) {
+	let owner;
+	const guard = createGuard({
+		extensionId: id,
+		logger,
+		stalls,
+		...options.budget !== void 0 ? { budget: options.budget } : {},
+		...options.callbackTimeoutMs !== void 0 ? { timeoutMs: options.callbackTimeoutMs } : {},
+		lease: (label, leaseOpts) => owner.lease(label, leaseOpts),
+		onTrip: (trip) => onTrip(trip, guard)
+	});
+	const track = options.trackCalls;
+	if (track) {
+		const call = guard.call;
+		guard.call = (label, fn, opts) => {
+			const pending = call(label, fn, opts);
+			track(pending);
+			return pending;
+		};
+	}
+	owner = createOwner(void 0, {
+		onError: (error, label) => guard.report(label, error),
+		label: id,
+		...options.drainTimeoutMs !== void 0 ? { drainMs: options.drainTimeoutMs } : {},
+		onDrain: ({ active, ms }) => logger.warn(`unloaded with ${active.length} call${active.length === 1 ? "" : "s"} in flight (${active.join(", ")}): its registrations are withdrawn, the rest is torn down once they finish (at most ${Math.round(ms / 1e3)}s)`, {
+			active,
+			boundMs: ms
+		}),
+		onDrainTimeout: ({ active, ms }) => logger.warn(`calls still running ${Math.round(ms / 1e3)}s after unload (${active.join(", ")}): tearing down now`, { active })
+	});
+	return {
+		guard,
+		owner
+	};
+}
 /** Runs async work one at a time, in call order; a failure does not stop the next. */
 function createSerial() {
 	let queue = Promise.resolve();
@@ -3929,7 +4118,7 @@ async function reloadInPlace(c, id, opts) {
 		...entry,
 		enabled: r.entry.enabled
 	};
-	await deactivateRecord(r, c.logger);
+	await deactivateRecord(r, c.logger, c.withdrawn);
 	c.removeUi(id);
 	if (c.disposed() || c.records.get(id) !== r) return void 0;
 	const known = c.order.filter((other) => other !== id).map((other) => c.records.get(other));
@@ -3959,7 +4148,7 @@ async function reloadInPlace(c, id, opts) {
 function defaultReimport() {
 	return async (entry) => {
 		if (entry.dir === void 0 || entry.source === "inline" || entry.source === "builtin") return entry;
-		const [{ loadExtensionFolder }, { runtimeEntryOf }] = await Promise.all([import("./discovery-DycXFxdA.js").then((n) => n.a), import("./loaded-entry-DTURJo_R.js").then((n) => n.r)]);
+		const [{ loadExtensionFolder }, { runtimeEntryOf }] = await Promise.all([import("./discovery-CX7nbMCn.js").then((n) => n.a), import("./loaded-entry-C0vkCVNQ.js").then((n) => n.r)]);
 		return {
 			...runtimeEntryOf(await loadExtensionFolder(entry.dir, { source: entry.source === "project" ? "project" : "user" }), entry.enabled),
 			source: entry.source
@@ -3986,7 +4175,7 @@ function createExtensionRuntime(options) {
 		const at = order.indexOf(id);
 		return at === -1 ? Number.MAX_SAFE_INTEGER : at;
 	};
-	const { outputs, services, hostListeners, refreshObservers, artifactKinds, pluginRecords, changed, statusChanged, subscribe, changeListeners, rpcBridge, release } = createShared(options, ports, baseLogger, records, order, rank);
+	const { outputs, services, hostListeners, refreshObservers, artifactKinds, pluginRecords, changed, statusChanged, subscribe, changeListeners, rpcBridge, release, withdrawn } = createShared(options, ports, baseLogger, records, order, rank);
 	const { ui } = outputs;
 	const stalls = createStallMonitor({ onStall: (report) => {
 		baseLogger.warn(`${report.label} blocked the event loop for ${Math.round(report.durationMs)}ms`, {
@@ -4014,30 +4203,10 @@ function createExtensionRuntime(options) {
 	const activate = async (r) => {
 		const def = r.definition;
 		const logger = baseLogger.with({ extension: r.id });
-		const guard = createGuard({
-			extensionId: r.id,
-			logger,
-			stalls,
-			...options.budget !== void 0 ? { budget: options.budget } : {},
-			...options.callbackTimeoutMs !== void 0 ? { timeoutMs: options.callbackTimeoutMs } : {},
-			onTrip: (trip) => {
-				if (r.guard !== guard) return;
-				setStatus(r, "failed", `Disabled: ${trip.reason}`);
-				deactivateRecord(r, baseLogger);
-			}
-		});
-		const track = options.trackCalls;
-		if (track) {
-			const call = guard.call;
-			guard.call = (label, fn, opts) => {
-				const pending = call(label, fn, opts);
-				track(pending);
-				return pending;
-			};
-		}
-		const owner = createOwner(void 0, {
-			onError: (error, label) => guard.report(label, error),
-			label: r.id
+		const { guard, owner } = createGuardedOwner(r.id, logger, stalls, options, (trip, tripped) => {
+			if (r.guard !== tripped) return;
+			setStatus(r, "failed", `Disabled: ${trip.reason}`);
+			deactivateRecord(r, baseLogger, withdrawn);
 		});
 		const deps = {
 			extensionId: r.id,
@@ -4048,6 +4217,7 @@ function createExtensionRuntime(options) {
 		const settings = createSettingsDomain(deps, settingsPort, def.settings);
 		const storage = createStorageDomain(deps, storagePort, {
 			paths: options.paths,
+			...r.entry.dir !== void 0 ? { dir: r.entry.dir } : {},
 			memory,
 			...ports.currentSessionId ? { currentSessionId: ports.currentSessionId } : {}
 		});
@@ -4119,7 +4289,7 @@ function createExtensionRuntime(options) {
 		if (!r) return;
 		records.delete(id);
 		order.splice(order.indexOf(id), 1);
-		await deactivateRecord(r, baseLogger);
+		await deactivateRecord(r, baseLogger, withdrawn);
 		ui.removeExtension(id);
 		if (opts.forget) {
 			memory.clear(id);
@@ -4137,6 +4307,7 @@ function createExtensionRuntime(options) {
 		logger: baseLogger,
 		reimport: options.reimport ?? defaultReimport(),
 		disposed: () => disposed,
+		withdrawn,
 		setStatus,
 		activate,
 		unload: unloadNow,
@@ -4181,13 +4352,15 @@ function createExtensionRuntime(options) {
 		dispose: async () => {
 			if (disposed) return;
 			disposed = true;
+			withdrawn();
 			services.facets.close();
 			const all = [...order].reverse().map((id) => records.get(id));
-			await Promise.all(all.map((r) => deactivateRecord(r, baseLogger)));
+			await Promise.all(all.map((r) => deactivateRecord(r, baseLogger, withdrawn)));
 			for (const r of all) ui.removeExtension(r.id);
 			records.clear();
 			order.length = 0;
 			changeListeners.clear();
+			await Promise.all(all.map((r) => r.teardown));
 			release();
 		}
 	};
@@ -4195,4 +4368,4 @@ function createExtensionRuntime(options) {
 //#endregion
 export { HOST_EVENT_NAMES as a, createRpcDomain as i, host_exports as n, isSyncInterceptor as o, createGuard as r, createExtensionRuntime as t };
 
-//# sourceMappingURL=host-wO_6GW0y.js.map
+//# sourceMappingURL=host-C61ntFBC.js.map