devframe 0.9.0 → 0.9.1

package/dist/constants.mjs

@@ -1,3 +1,4 @@
+import { t as DEVFRAME_EVENTS } from "./events-DKfSmoTj.mjs";
 //#region src/constants.ts
 const DEVFRAME_CONNECTION_META_FILENAME = "__connection.json";
 /**
@@ -41,6 +42,12 @@ const DEVFRAME_RPC_DUMP_MANIFEST_FILENAME = "__rpc-dump/index.json";
 const DEVFRAME_DOCK_IMPORTS_FILENAME = "__client-imports.js";
 const DEVFRAME_RPC_DUMP_DIRNAME = "__rpc-dump";
 /**
+* Shared-state key carrying the wire-service advertisements (package name →
+* `DevframeServiceMeta`). Written by the node services host; mirrored to
+* clients for feature-detection via `client.services`.
+*/
+const DEVFRAME_SERVICES_STATE_KEY = "devframe:services";
+/**
 * URL fragment / query parameter name carrying the remote dock
 * connection descriptor (defined as `RemoteConnectionInfo` in
 * `@vitejs/devtools-kit`) injected into remote-UI iframe dock URLs.
@@ -77,7 +84,7 @@ const DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM = "devframe_viewer_origin_token";
 * (`@devframes/hub-ui` does, in its iframe view). Payload shape:
 * `RemoteAssetsErrorMessage` (`devframe/types`).
 */
-const DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE = "devframe:remote-assets-error";
+const DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE = DEVFRAME_EVENTS.postMessage.remoteAssetsError;
 /**
 * Prefix that marks an RPC method as callable before a connection is
 * trusted. This is the *only* rule the pre-trust gate applies — there is no
@@ -96,4 +103,4 @@ function isAnonymousRpcMethod(name) {
 	return name.startsWith(ANONYMOUS_RPC_PREFIX);
 }
 //#endregion
-export { ANONYMOUS_RPC_PREFIX, DEVFRAME_AUTH_TOKEN_QUERY_PARAM, DEVFRAME_CONNECTION_KEY, DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_MCP_ROUTE, DEVFRAME_OTP_URL_PARAM, DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME, DEVFRAME_SSE_ROUTE, DEVFRAME_SSE_SESSION_HEADER, DEVFRAME_VIEWER_ORIGIN_QUERY_PARAM, DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM, DEVFRAME_WS_ROUTE, REMOTE_CONNECTION_KEY, isAnonymousRpcMethod };
+export { ANONYMOUS_RPC_PREFIX, DEVFRAME_AUTH_TOKEN_QUERY_PARAM, DEVFRAME_CONNECTION_KEY, DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_DOCK_IMPORTS_FILENAME, DEVFRAME_EVENTS, DEVFRAME_MCP_ROUTE, DEVFRAME_OTP_URL_PARAM, DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE, DEVFRAME_RPC_DUMP_DIRNAME, DEVFRAME_RPC_DUMP_MANIFEST_FILENAME, DEVFRAME_SERVICES_STATE_KEY, DEVFRAME_SSE_ROUTE, DEVFRAME_SSE_SESSION_HEADER, DEVFRAME_VIEWER_ORIGIN_QUERY_PARAM, DEVFRAME_VIEWER_ORIGIN_TOKEN_QUERY_PARAM, DEVFRAME_WS_ROUTE, REMOTE_CONNECTION_KEY, isAnonymousRpcMethod };

package/dist/{context-CEe4PBz1.mjs → context-Bdkakk8S.mjs}

@@ -2,13 +2,18 @@ import { i as defineDiagnostics } from "./nostics-CzECRXpE.mjs";
 import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
 import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
-import { t as diagnostics$1 } from "./diagnostics-DOQPnQmX.mjs";
-import { r as createEventEmitter, t as DevframeAgentHost } from "./host-agent-xLCSe65D.mjs";
-import { n as createDebug, t as resolveStaticAssetsSource } from "./remote-assets-nTTxY2MU.mjs";
-import { t as createStorage } from "./storage-CYye7P7L.mjs";
+import { t as DEVFRAME_EVENTS } from "./events-DKfSmoTj.mjs";
+import { DEVFRAME_SERVICES_STATE_KEY } from "./constants.mjs";
+import { t as diagnostics$1 } from "./diagnostics-Di8ytitn.mjs";
+import { r as createEventEmitter, t as DevframeAgentHost } from "./host-agent-BDdcOXhG.mjs";
+import { n as createDebug, t as resolveStaticAssetsSource } from "./remote-assets-DRfY2RjX.mjs";
+import { t as createStorage } from "./storage-D4a99Ung.mjs";
+import { createRequire } from "node:module";
 import { createSharedState } from "devframe/utils/shared-state";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { isAbsolute, join } from "pathe";
 import { existsSync } from "node:fs";
-import { join } from "pathe";
 //#region src/node/host-diagnostics.ts
 var DevframeDiagnosticsHost = class {
 	context;
@@ -25,7 +30,7 @@ var DevframeDiagnosticsHost = class {
 };
 //#endregion
 //#region src/node/rpc-shared-state.ts
-const debug$1 = createDebug("devframe:rpc:state:changed");
+const debug$2 = createDebug("devframe:rpc:state:changed");
 const debugSubscribe = createDebug("devframe:rpc:state:subscribe");
 function createRpcSharedStateServerHost(rpc) {
 	const sharedState = /* @__PURE__ */ new Map();
@@ -35,12 +40,12 @@ function createRpcSharedStateServerHost(rpc) {
 		const offs = [];
 		offs.push(state.on("updated", (fullState, patches, syncId) => {
 			if (patches) {
-				debug$1("patch", {
+				debug$2("patch", {
 					key,
 					syncId
 				});
 				rpc.broadcast({
-					method: "devframe:rpc:client-state:patch",
+					method: DEVFRAME_EVENTS.broadcast.clientStatePatch,
 					args: [
 						key,
 						patches,
@@ -49,12 +54,12 @@ function createRpcSharedStateServerHost(rpc) {
 					filter: (client) => client.$meta.subscribedStates.has(key)
 				});
 			} else {
-				debug$1("updated", {
+				debug$2("updated", {
 					key,
 					syncId
 				});
 				rpc.broadcast({
-					method: "devframe:rpc:client-state:updated",
+					method: DEVFRAME_EVENTS.broadcast.clientStateUpdated,
 					args: [
 						key,
 						fullState,
@@ -72,7 +77,7 @@ function createRpcSharedStateServerHost(rpc) {
 		get: async (key, options) => {
 			if (sharedState.has(key)) return sharedState.get(key);
 			if (options?.initialValue === void 0 && options?.sharedState === void 0) throw diagnostics$1.DF0013({ key });
-			debug$1("new-state", key);
+			debug$2("new-state", key);
 			const state = options.sharedState ?? createSharedState({
 				initialValue: options.initialValue,
 				enablePatches: false
@@ -402,7 +407,7 @@ function toErrorPayload(reason) {
 }
 //#endregion
 //#region src/node/rpc-streaming.ts
-const debug = createDebug("devframe:rpc:streaming");
+const debug$1 = createDebug("devframe:rpc:streaming");
 const STREAM_KEY_SEPARATOR = "";
 function streamKey(channel, id) {
 	return `${channel}${STREAM_KEY_SEPARATOR}${id}`;
@@ -427,7 +432,7 @@ function createRpcStreamingServerHost(rpc) {
 		}
 		for (const off of record.unbinders) off();
 		state.streams.delete(id);
-		debug("freed", state.name, id);
+		debug$1("freed", state.name, id);
 	}
 	function maybeFreeStream(state, id) {
 		const record = state.streams.get(id);
@@ -476,7 +481,7 @@ function createRpcStreamingServerHost(rpc) {
 			cancelRetention(record);
 			const afterSeq = opts?.afterSeq ?? 0;
 			for (const buffered of record.sink.buffer) if (buffered.seq > afterSeq) rpc.broadcast({
-				method: "devframe:streaming:chunk",
+				method: DEVFRAME_EVENTS.broadcast.streamingChunk,
 				args: [
 					channelName,
 					id,
@@ -488,7 +493,7 @@ function createRpcStreamingServerHost(rpc) {
 				filter: (client) => client.$meta === session.meta
 			});
 			if (record.sink.closed) rpc.broadcast({
-				method: "devframe:streaming:end",
+				method: DEVFRAME_EVENTS.broadcast.streamingEnd,
 				args: [
 					channelName,
 					id,
@@ -589,7 +594,7 @@ function createRpcStreamingServerHost(rpc) {
 			state.streams.set(sink.id, record);
 			record.unbinders.push(sink.events.on("chunk", (seq, chunk) => {
 				rpc.broadcast({
-					method: "devframe:streaming:chunk",
+					method: DEVFRAME_EVENTS.broadcast.streamingChunk,
 					args: [
 						name,
 						sink.id,
@@ -603,7 +608,7 @@ function createRpcStreamingServerHost(rpc) {
 			}));
 			record.unbinders.push(sink.events.on("end", (error) => {
 				rpc.broadcast({
-					method: "devframe:streaming:end",
+					method: DEVFRAME_EVENTS.broadcast.streamingEnd,
 					args: [
 						name,
 						sink.id,
@@ -636,7 +641,7 @@ function createRpcStreamingServerHost(rpc) {
 					const targetMeta = inboundRecord?.uploaderMeta;
 					if (!targetMeta) return;
 					rpc.broadcast({
-						method: "devframe:streaming:upload-cancel",
+						method: DEVFRAME_EVENTS.broadcast.streamingUploadCancel,
 						args: [name, reader.id],
 						event: true,
 						optional: true,
@@ -646,7 +651,7 @@ function createRpcStreamingServerHost(rpc) {
 			});
 			inboundRecord = { reader };
 			state.inbound.set(reader.id, inboundRecord);
-			debug("opened-inbound", name, reader.id);
+			debug$1("opened-inbound", name, reader.id);
 			return reader;
 		}
 		return {
@@ -758,15 +763,177 @@ var RpcFunctionsHostImpl = class extends RpcFunctionsCollectorBase {
 	}
 };
 //#endregion
+//#region src/node/services-install.ts
+/**
+* Turn a `resolveFrom` value (a file path, a file URL like `import.meta.url`,
+* or a directory) into something `createRequire` accepts — a directory gets a
+* synthetic filename appended so resolution starts inside it.
+*/
+function toRequireBase(resolveFrom) {
+	if (resolveFrom.startsWith("file://")) return resolveFrom;
+	if ((resolveFrom.split(/[/\\]/).pop() ?? "").includes(".")) return resolveFrom;
+	return join(resolveFrom, "_devframe_resolve.js");
+}
+/**
+* Normalize an `install()` `resolveFrom` into a resolution base. Paths and
+* file URLs pass through; a bare npm package name (the common case: the
+* declaring plugin's `packageName`) resolves to that package's location from
+* `cwd`, so a service it declares resolves against the plugin's own
+* dependencies. An unresolvable package name reads as no base (the caller's
+* workspace fallbacks apply).
+*/
+function expandResolveFrom(resolveFrom, cwd) {
+	if (resolveFrom.startsWith("file://") || resolveFrom.startsWith(".") || isAbsolute(resolveFrom)) return resolveFrom;
+	const require = createRequire(join(cwd, "_devframe_resolve.js"));
+	try {
+		return require.resolve(`${resolveFrom}/package.json`);
+	} catch {}
+	try {
+		return require.resolve(resolveFrom);
+	} catch {}
+}
+/**
+* Import a service package's module, trying each `resolveFrom` candidate in
+* order (so a plugin-declared service resolves against the plugin's own
+* dependency tree first, then the workspace fallback). Throws the last
+* resolution error when no candidate succeeds.
+*/
+async function importServicePackage(pkg, resolveFroms) {
+	const candidates = [...new Set(resolveFroms.filter((x) => typeof x === "string" && x.length > 0))];
+	let lastError = /* @__PURE__ */ new Error(`no resolution base available for "${pkg}"`);
+	for (const from of candidates) {
+		let resolved;
+		try {
+			resolved = createRequire(toRequireBase(from)).resolve(pkg);
+		} catch (error) {
+			lastError = error;
+			continue;
+		}
+		return await import(pathToFileURL(resolved).href);
+	}
+	throw lastError;
+}
+function parseVersion(input) {
+	const [core, ...prerelease] = input.trim().replace(/^v/, "").split("-");
+	if (!core) return void 0;
+	const parts = core.split(".").map((part) => Number.parseInt(part, 10));
+	if (parts.length === 0 || parts.some((part) => Number.isNaN(part) || part < 0)) return void 0;
+	while (parts.length < 3) parts.push(0);
+	return {
+		parts,
+		...prerelease.length ? { prerelease: prerelease.join("-") } : {}
+	};
+}
+function compareVersions(a, b) {
+	for (let i = 0; i < 3; i++) {
+		const diff = (a.parts[i] ?? 0) - (b.parts[i] ?? 0);
+		if (diff !== 0) return diff;
+	}
+	if (a.prerelease && !b.prerelease) return -1;
+	if (!a.prerelease && b.prerelease) return 1;
+	if (a.prerelease && b.prerelease) return a.prerelease < b.prerelease ? -1 : a.prerelease > b.prerelease ? 1 : 0;
+	return 0;
+}
+function satisfiesComparator(version, comparator) {
+	const raw = comparator.trim();
+	if (!raw || raw === "*" || raw === "x") return true;
+	const operatorMatch = raw.match(/^([\^~]|>=|<=|[><=])?(.+)$/);
+	if (!operatorMatch) return false;
+	const operator = operatorMatch[1];
+	const rest = operatorMatch[2].trim();
+	const segments = rest.replace(/\.[x*]/gi, "").split(".").filter(Boolean);
+	const base = parseVersion(rest.replace(/[x*]/gi, "0"));
+	if (!base) return false;
+	switch (operator) {
+		case ">": return compareVersions(version, base) > 0;
+		case ">=": return compareVersions(version, base) >= 0;
+		case "<": return compareVersions(version, base) < 0;
+		case "<=": return compareVersions(version, base) <= 0;
+		case "^": {
+			if (compareVersions(version, base) < 0) return false;
+			const fixedIndex = base.parts.findIndex((part) => part !== 0);
+			const lockUpTo = fixedIndex === -1 ? base.parts.length - 1 : fixedIndex;
+			for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+			return true;
+		}
+		case "~": {
+			if (compareVersions(version, base) < 0) return false;
+			const lockUpTo = segments.length >= 2 ? 1 : 0;
+			for (let i = 0; i <= lockUpTo; i++) if ((version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+			return true;
+		}
+		default:
+			for (let i = 0; i < Math.max(segments.length, 3); i++) if (i < segments.length && (version.parts[i] ?? 0) !== (base.parts[i] ?? 0)) return false;
+			return segments.length >= 3 ? compareVersions(version, base) === 0 : true;
+	}
+}
+/**
+* Pragmatic semver range check for service version declarations — supports
+* the common forms (`1.2.3`, `^1.2.3`, `~1.2`, `>=1 <3`, `1.x`, `*`, and
+* `||`-joined alternatives) without pulling in a semver dependency. An
+* unparseable version or range reads as **not satisfied**.
+*/
+function satisfiesVersionRange(version, range) {
+	const parsed = parseVersion(version);
+	if (!parsed) return false;
+	const alternatives = range.split("||").map((alt) => alt.trim()).filter(Boolean);
+	if (alternatives.length === 0) return true;
+	return alternatives.some((alternative) => alternative.split(/\s+/).every((comparator) => satisfiesComparator(parsed, comparator)));
+}
+/**
+* Default option-set merge when a service declares no `mergeOptions`:
+* shallow-merge plain objects in declaration order (later sets win); any
+* non-object set collapses the merge to "last one wins".
+*/
+function shallowMergeOptionSets(sets) {
+	if (sets.some((set) => typeof set !== "object" || set === null || Array.isArray(set))) return sets[sets.length - 1];
+	return Object.assign({}, ...sets);
+}
+//#endregion
 //#region src/node/host-services.ts
+const debug = createDebug("devframe:services");
+function isServiceDefinition(input) {
+	return typeof input.setup === "function";
+}
+function validateServiceInput(input) {
+	if (!input || typeof input.package !== "string" || input.package.length === 0) throw diagnostics$1.DF0070({
+		package: String(input?.package ?? input),
+		reason: "the input has no `package` name"
+	});
+	if (isServiceDefinition(input)) validateServiceDefinition(input);
+}
+function validateServiceDefinition(def) {
+	if (typeof def.version !== "string" || def.version.length === 0) throw diagnostics$1.DF0070({
+		package: def.package,
+		reason: "the definition has no `version`"
+	});
+	if (typeof def.scope !== "string" || def.scope.length === 0) throw diagnostics$1.DF0070({
+		package: def.package,
+		reason: "the definition has no RPC `scope` namespace"
+	});
+}
 /**
 * Cross-plugin service registry (see `types/services.ts` for the contract).
 * Values are held per context instance; `whenAvailable` subscriptions make
 * the mechanism robust against setup ordering between provider and consumer.
+*
+* On top of the in-process `provide`/`get` tier, this host implements the
+* **wire-service** lifecycle: `install()` queues definitions/descriptors,
+* `ready()` fires the collect-then-setup barrier — importing descriptor
+* packages, merging option sets per service, constructing each service once,
+* providing its node API under the package name, and advertising it to
+* clients through the `devframe:services` shared state.
 */
 var DevframeServicesHostImpl = class {
+	context;
 	services = /* @__PURE__ */ new Map();
 	listeners = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	installed = /* @__PURE__ */ new Map();
+	readyPromise;
+	constructor(context) {
+		this.context = context;
+	}
 	provide(id, service) {
 		const key = id;
 		if (this.services.has(key)) throw diagnostics$1.DF0037({ id: key });
@@ -799,6 +966,136 @@ var DevframeServicesHostImpl = class {
 	keys() {
 		return Array.from(this.services.keys());
 	}
+	install(input, options) {
+		validateServiceInput(input);
+		const promise = new Promise((resolve, reject) => {
+			const entry = {
+				input,
+				resolveFrom: options?.resolveFrom,
+				resolve,
+				reject
+			};
+			if (this.readyPromise) this.flushPackage(input.package, [entry]).catch(() => {});
+			else {
+				let entries = this.pending.get(input.package);
+				if (!entries) {
+					entries = [];
+					this.pending.set(input.package, entries);
+				}
+				entries.push(entry);
+			}
+		});
+		promise.catch(() => {});
+		return promise;
+	}
+	ready() {
+		if (this.readyPromise) return this.readyPromise;
+		this.readyPromise = this.flushAll();
+		return this.readyPromise;
+	}
+	async flushAll() {
+		if (this.context) await this.advertisementState();
+		const groups = Array.from(this.pending.entries());
+		this.pending.clear();
+		for (const [pkg, entries] of groups) await this.flushPackage(pkg, entries);
+	}
+	async flushPackage(pkg, entries) {
+		try {
+			const api = await this.installPackage(pkg, entries);
+			for (const entry of entries) entry.resolve(api);
+			return api;
+		} catch (error) {
+			for (const entry of entries) entry.reject(error);
+			throw error;
+		}
+	}
+	async installPackage(pkg, entries) {
+		if (this.installed.has(pkg)) {
+			diagnostics$1.DF0066({ package: pkg });
+			return this.installed.get(pkg);
+		}
+		let def = entries.filter((entry) => isServiceDefinition(entry.input))[0]?.input;
+		if (!def) {
+			const required = entries.map((entry) => entry.input).some((descriptor) => descriptor.required === true);
+			const cwd = this.context?.cwd ?? process.cwd();
+			const resolveFroms = [
+				...entries.map((entry) => entry.resolveFrom && expandResolveFrom(entry.resolveFrom, cwd)),
+				this.context?.workspaceRoot,
+				cwd
+			];
+			let mod;
+			try {
+				mod = await importServicePackage(pkg, resolveFroms);
+			} catch (error) {
+				const reason = error instanceof Error ? error.message : String(error);
+				if (required) throw diagnostics$1.DF0067({
+					package: pkg,
+					reason,
+					cause: error
+				});
+				debug("optional service %s not importable, skipping: %s", pkg, reason);
+				return;
+			}
+			const factory = mod.default;
+			if (typeof factory !== "function") throw diagnostics$1.DF0070({
+				package: pkg,
+				reason: "its default export is not a factory function"
+			});
+			def = await factory();
+			if (!def || typeof def.setup !== "function") throw diagnostics$1.DF0070({
+				package: pkg,
+				reason: "its factory did not return a definition with a `setup` function"
+			});
+			if (typeof def.package !== "string" || def.package.length === 0) def = {
+				...def,
+				package: pkg
+			};
+			validateServiceDefinition(def);
+		}
+		for (const entry of entries) {
+			const descriptor = entry.input;
+			if (isServiceDefinition(entry.input) || typeof descriptor.version !== "string") continue;
+			if (satisfiesVersionRange(def.version, descriptor.version)) continue;
+			if (descriptor.required === true) throw diagnostics$1.DF0068({
+				package: pkg,
+				required: descriptor.version,
+				installed: def.version
+			});
+			diagnostics$1.DF0069({
+				package: pkg,
+				required: descriptor.version,
+				installed: def.version
+			});
+		}
+		const sets = entries.map((entry) => entry.input.options).filter((options) => options !== void 0);
+		const options = def.mergeOptions ? def.mergeOptions(sets) : sets.length > 0 ? shallowMergeOptionSets(sets) : void 0;
+		if (!this.context) throw diagnostics$1.DF0070({
+			package: pkg,
+			reason: "this services host has no node context to install into"
+		});
+		debug("installing service %s@%s (scope %s)", def.package, def.version, def.scope);
+		const scoped = this.context.scope(def.scope);
+		const api = await def.setup(scoped, options === void 0 ? {} : { options });
+		this.installed.set(def.package, api);
+		this.provide(def.package, api);
+		await this.advertise(def);
+		return api;
+	}
+	advertisementState() {
+		return this.context.rpc.sharedState.get(DEVFRAME_SERVICES_STATE_KEY, { initialValue: {} });
+	}
+	async advertise(def) {
+		const state = await this.advertisementState();
+		const { package: pkg, version, scope, meta } = def;
+		state.mutate((value) => {
+			value[pkg] = {
+				package: pkg,
+				version,
+				scope,
+				...meta ? { meta } : {}
+			};
+		});
+	}
 };
 //#endregion
 //#region src/node/host-views.ts
@@ -900,7 +1197,8 @@ function createNodeSettingsStore(context, namespace, scope) {
 	let statePromise;
 	function store() {
 		if (!statePromise) {
-			const filepath = join(context.host.getStorageDir(STORAGE_SCOPE[scope]), "settings", `${namespace}.json`);
+			const dir = context.host.getStorageDir(STORAGE_SCOPE[scope]);
+			const filepath = join(dir, "settings", `${namespace}.json`);
 			statePromise = context.rpc.sharedState.get(stateKey, { sharedState: createStorage({
 				filepath,
 				initialValue: {}
@@ -1023,7 +1321,7 @@ async function createHostContext(options) {
 	context.rpc = rpcHost;
 	context.views = viewsHost;
 	context.diagnostics = diagnosticsHost;
-	context.services = new DevframeServicesHostImpl();
+	context.services = new DevframeServicesHostImpl(context);
 	context.agent = new DevframeAgentHost(context);
 	const scopedCache = /* @__PURE__ */ new Map();
 	context.scope = ((namespace) => {

package/dist/{context-xdynGSLP.mjs → context-CXhjygJU.mjs}

@@ -1,6 +1,6 @@
 import { n as randomToken } from "./crypto-token-XCqTSMg9.mjs";
-import { t as createStorage } from "./storage-CYye7P7L.mjs";
-import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "./revoke-DZbJ7Cl0.mjs";
+import { t as createStorage } from "./storage-D4a99Ung.mjs";
+import { n as revokeAuthToken, t as revokeActiveConnectionsForToken } from "./revoke-3Q6aDKWk.mjs";
 import { join } from "pathe";
 //#region src/node/hub-internals/context.ts
 const internalContextMap = /* @__PURE__ */ new WeakMap();

package/dist/{context-B3YUu_95.d.mts → context-dqyXS6o3.d.mts}

@@ -1,4 +1,4 @@
-import { g as DevframeNodeContext, lt as SharedState } from "./devframe-DJMg0WLe.mjs";
+import { g as DevframeNodeContext, gt as SharedState } from "./devframe-BlLEZR-x.mjs";
 //#region src/node/hub-internals/context.d.ts
 interface InternalAnonymousAuthStorage {
   trusted: Record<string, {

package/dist/{dev--rAPzbvO.mjs → dev-C8VHtuPP.mjs}

@@ -1,15 +1,15 @@
 import { DEVFRAME_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { t as diagnostics } from "./diagnostics-DOQPnQmX.mjs";
-import { t as createHostContext } from "./context-CEe4PBz1.mjs";
-import { t as resolveStaticAssetsSource } from "./remote-assets-nTTxY2MU.mjs";
-import { i as resolveMcpConnectionMeta, n as resolveBasePath, r as resolveDevServerPort, t as normalizeBasePath } from "./_shared-CbZ_yhbz.mjs";
-import { t as createH3DevframeHost } from "./host-h3-Crkzm42q.mjs";
-import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, t as createInstanceShell } from "./instance-shell-CMFyszWJ.mjs";
+import { t as diagnostics } from "./diagnostics-Di8ytitn.mjs";
+import { t as createHostContext } from "./context-Bdkakk8S.mjs";
+import { t as resolveStaticAssetsSource } from "./remote-assets-DRfY2RjX.mjs";
+import { i as resolveMcpConnectionMeta, n as resolveBasePath, r as resolveDevServerPort, t as normalizeBasePath } from "./_shared-BM3PdYli.mjs";
+import { t as createH3DevframeHost } from "./host-h3-fRbF9yor.mjs";
+import { i as normalizeHttpServerUrl, n as resolveInstanceRegister, t as createInstanceShell } from "./instance-shell-DbDoozNM.mjs";
 import { open } from "./utils/open.mjs";
 import { mountStaticHandler } from "./utils/serve-static.mjs";
 import { createServer } from "node:http";
-import { resolve } from "pathe";
 import process from "node:process";
+import { resolve } from "pathe";
 import { joinURL, withBase } from "ufo";
 import { H3, toNodeHandler } from "h3";
 //#region src/adapters/initiate.ts
@@ -39,10 +39,11 @@ function initDevframe(def, options) {
 	const base = normalizeBasePath(options.base);
 	const distDir = options.distDir === false ? void 0 : options.distDir ?? def.cli?.distDir;
 	const app = options.app ?? new H3();
+	const host = options.host ?? def.cli?.host ?? "localhost";
 	const shell = createInstanceShell({
 		base,
 		app,
-		host: options.host ?? def.cli?.host ?? "localhost",
+		host,
 		origin: options.origin,
 		auth: options.auth !== void 0 ? options.auth : def.cli?.auth,
 		server: options.server,
@@ -78,7 +79,9 @@ function initDevframe(def, options) {
 				host: hostImpl
 			});
 			const setupInfo = { flags: options.flags ?? {} };
+			for (const input of def.services ?? []) context.services.install(input, { resolveFrom: def.packageName });
 			await def.setup(context, setupInfo);
+			await context.services.ready();
 			const mcpOption = options.mcp ?? def.cli?.mcp;
 			const mcpMeta = resolveMcpConnectionMeta(def, mcpOption);
 			let mcpDispose;
@@ -87,7 +90,7 @@ function initDevframe(def, options) {
 				const mcpPath = joinURL(base, mcpMeta.path);
 				let mountMcpHttp;
 				try {
-					({mountMcpHttp} = await import("./http-DYpK0cUi.mjs").then((n) => n.t));
+					({mountMcpHttp} = await import("./http-BbHCU5Zs.mjs").then((n) => n.t));
 				} catch (error) {
 					const reason = error instanceof Error ? error.message : String(error);
 					throw diagnostics.DF0017({