devframe 0.9.8 → 0.9.9

package/dist/{instance-shell-Tcp5hGoq.d.mts → instance-shell-7Z52PE4_.d.mts}

@@ -1,6 +1,6 @@
-import { d as DevframeRpcConnection, n as WsOriginRegistry, u as DevframeNodeRpcSessionMeta } from "./ws-server-VyHlanzy.mjs";
-import { Ct as DevframeAuthHandler, U as DevframeSseOptions, W as DevframeWsOptions, _t as DevframeRpcServerFunctions, gt as DevframeRpcClientFunctions, o as DevframeNodeContext, s as DevframeNodeRpcSession, t as ConnectionMeta } from "./context-CLF4-8Pp.mjs";
-import "./index-D3k0BIhe.mjs";
+import { c as DevframeNodeRpcSessionMeta, l as DevframeRpcConnection, n as WsOriginRegistry } from "./ws-server-D2nv68Hg.mjs";
+import { U as DevframeSseOptions, W as DevframeWsOptions, _t as DevframeRpcClientFunctions, o as DevframeNodeContext, s as DevframeNodeRpcSession, t as ConnectionMeta, vt as DevframeRpcServerFunctions, wt as DevframeAuthHandler } from "./context-4AIVRLYF.mjs";
+import "./index-pKl67H6w.mjs";
 import { BirpcGroup } from "birpc";
 import { NodeAdapter } from "crossws/adapters/node";
 import { Buffer } from "node:buffer";
@@ -10,7 +10,7 @@ import { H3 } from "h3";
 //#region src/node/instance-registry.d.ts
 /**
  * One running devframe instance, as recorded in the instance registry.
- * Records are self-describing JSON — additive fields are safe.
+ * Records are self-describing JSON, so additive fields are safe.
  */
 interface DevframeInstanceRecord {
   /** Process id of the dev server. */
@@ -58,7 +58,7 @@ interface DevframeInstanceRegistration {
  * The record is written atomically to `<dir>/<pid>-<port>.json` and removed
  * by {@link DevframeInstanceRegistration.unregister}. Records surviving a
  * crash are pruned by readers whose liveness probe fails. Registration never
- * throws — a write failure degrades to a coded warning (`DF0045`), since a
+ * throws; a write failure degrades to a coded warning (`DF0045`), since a
  * dev server must not die over discovery metadata.
  */
 declare function registerDevframeInstance(record: DevframeInstanceRecord, options?: {
@@ -85,7 +85,7 @@ declare function listLiveDevframeInstances(options?: {
 //#endregion
 //#region src/node/instance-shell.d.ts
 /**
- * The live handle for a bound HTTP + WebSocket RPC server — what the
+ * The live handle for a bound HTTP + WebSocket RPC server: what the
  * side-car / shared-server tiers produce and what {@link createDevServer}
  * re-exposes through its own return contract.
  */
@@ -101,7 +101,7 @@ interface StartedServer {
   ws?: NodeAdapter;
   rpcGroup: BirpcGroup<DevframeRpcClientFunctions, DevframeRpcServerFunctions, false>;
   /**
-   * The {@link ConnectionMeta} descriptor for this server — the same shape a
+   * The {@link ConnectionMeta} descriptor for this server, the same shape a
    * `__connection.json` route should serve so a devframe client's
    * `resolveWsUrl` can dial back in.
    */
@@ -111,15 +111,15 @@ interface StartedServer {
 /**
  * How the instance's RPC socket is bound:
  *
- * - `sidecar` — its own HTTP+WS server on a dedicated port (`ws.port` /
+ * - `sidecar`: its own HTTP+WS server on a dedicated port (`ws.port` /
  *   `ws.sidecar`), advertised with that port.
- * - `server` — a shared upgrade route on the host's `node:http` server.
- * - `external` — no local transport: `ws.url` alone names a server that owns
+ * - `server`: a shared upgrade route on the host's `node:http` server.
+ * - `external`: no local transport; `ws.url` alone names a server that owns
  *   both the socket and its auth.
- * - `unbound` — the transport exists but nothing is bound to it yet; the host
+ * - `unbound`: the transport exists but nothing is bound to it yet; the host
  *   drives it through {@link InstanceShell.handleUpgrade} /
  *   {@link InstanceShell.attach}.
- * - `disabled` — `ws: false`: no WebSocket at all; clients connect over the
+ * - `disabled` (`ws: false`): no WebSocket at all; clients connect over the
  *   SSE endpoint instead (`backend: 'sse'`).
  */
 type InstanceWsTier = 'sidecar' | 'server' | 'external' | 'unbound' | 'disabled';
@@ -154,9 +154,9 @@ interface CreateInstanceShellOptions<TContext extends DevframeNodeContext> {
   auth?: boolean | DevframeAuthHandler;
   /** Host `node:http` server to share the WS upgrade with. */
   server?: Server;
-  /** Explicit WebSocket control — see {@link DevframeWsOptions}. `false` disables the socket (SSE-only). */
+  /** Explicit WebSocket control; see {@link DevframeWsOptions}. `false` disables the socket (SSE-only). */
   ws?: DevframeWsOptions | false;
-  /** SSE endpoint control — enabled by default; `false` disables, an object renames the route. */
+  /** SSE endpoint control, enabled by default; `false` disables, an object renames the route. */
   sse?: boolean | DevframeSseOptions;
   /** Bind host for a side-car WebSocket server. Default: `localhost`. */
   host?: string;
@@ -177,7 +177,7 @@ interface CreateInstanceShellOptions<TContext extends DevframeNodeContext> {
   resolveSidecarPort?: (host: string) => Promise<number>;
   /**
    * Publish this instance in the global registry (`~/.devframe/instances/`)
-   * once its public origin is known — a dynamic import so the registry code
+   * once its public origin is known, via a dynamic import so the registry code
    * stays out of instances that opt out. Omit to skip registration.
    */
   register?: InstanceRegisterConfig;
@@ -190,7 +190,7 @@ interface CreateInstanceShellOptions<TContext extends DevframeNodeContext> {
 }
 /**
  * The identity a shell needs to publish itself in the global instance
- * registry — the parts it can't derive on its own. The shell fills in
+ * registry: the parts it can't derive on its own. The shell fills in
  * `pid` / `origin` / `port` / `basePath` / `mcp` / `startedAt` once the
  * origin resolves, then merges {@link InstanceRegisterConfig.overrides} last.
  */
@@ -240,8 +240,8 @@ declare function samePath(a: string, b: string): boolean;
  * The shared machinery behind `initDevframe` and `initHub`: one mount base,
  * one h3 app, one lazily-derived public origin (and the auth banner that waits
  * for it), one WebSocket binding, and the fetch / connect-middleware pair that
- * serves them. Each factory supplies only what makes it itself — its context,
- * its routes, its diagnostics — through `init` / `mount`.
+ * serves them. Each factory supplies only what makes it itself (its context,
+ * its routes, its diagnostics) through `init` / `mount`.
  *
  * Nothing here listens on a port unless a side-car was explicitly requested:
  * the default tier leaves the socket `unbound`, so a host chains it onto its

package/dist/{instance-shell-CpVW4zG0.mjs → instance-shell-cdVETpfz.mjs}

@@ -1,7 +1,8 @@
 import "./constants.mjs";
-import { t as diagnostics } from "./diagnostics-BXWW3VK-.mjs";
-import { r as importServicePackage } from "./services-install-CqqQVls5.mjs";
-import { t as getInternalContext } from "./context-KUqAfawQ.mjs";
+import { r as validateOriginCandidate } from "./origin-DZit9g29.mjs";
+import { t as diagnostics } from "./diagnostics-BMfN8mb1.mjs";
+import { r as importServicePackage } from "./services-install-P_DV7VYL.mjs";
+import { t as getInternalContext } from "./context-DIUvJW4D.mjs";
 import { createInteractiveAuth } from "./recipes/interactive-auth.mjs";
 import { createServer } from "node:http";
 import process from "node:process";
@@ -20,6 +21,21 @@ async function importRuntimeModule(specifier) {
 	return await importServicePackage(specifier, [import.meta.url]);
 }
 //#endregion
+//#region src/node/runtime.ts
+/**
+* Detect the current server runtime from its runtime-specific global. The
+* WebSocket binding branches on this: Bun and Deno expose their sockets as
+* `fetch` upgrades through `Bun.serve` / `Deno.serve` (crossws's Bun/Deno
+* adapters), while the `node:http` upgrade event (and crossws's Node adapter,
+* which refuses to run anywhere else) is Node-only.
+*/
+function detectServerRuntime() {
+	const g = globalThis;
+	if (typeof g.Deno !== "undefined") return "deno";
+	if (typeof g.Bun !== "undefined") return "bun";
+	return "node";
+}
+//#endregion
 //#region src/node/utils.ts
 const NON_DIALABLE_HOSTS = /* @__PURE__ */ new Set([
 	"0.0.0.0",
@@ -42,8 +58,17 @@ function normalizeHttpServerUrl(host, port) {
 }
 //#endregion
 //#region src/node/instance-shell.ts
+function websocketConnectionMeta(rpcHost, path) {
+	const jsonSerializableMethods = [];
+	for (const def of rpcHost.definitions.values()) if (def.jsonSerializable === true) jsonSerializableMethods.push(def.name);
+	return {
+		backend: "websocket",
+		websocket: { path },
+		jsonSerializableMethods
+	};
+}
 /**
-* Compose an h3 + WebSocket RPC server for a devframe context — the low-level
+* Compose an h3 + WebSocket RPC server for a devframe context: the low-level
 * "listen on a port (or share one) + attach the WS transport" binding the
 * side-car and shared-server tiers below are built on. Owns and listens on a
 * fresh `node:http` server unless `server` is supplied, in which case it only
@@ -97,22 +122,13 @@ async function bindHttpAndWs(options) {
 	const internal = getInternalContext(context);
 	const wsUrl = `ws://${formatHostForUrl(bindHost)}:${resolvedPort}${options.path ?? ""}`;
 	if (websocket) internal.setWsEndpoint({ url: wsUrl });
-	function connectionMeta() {
-		const jsonSerializableMethods = [];
-		for (const def of rpcHost.definitions.values()) if (def.jsonSerializable === true) jsonSerializableMethods.push(def.name);
-		return {
-			backend: "websocket",
-			websocket: { path: options.path },
-			jsonSerializableMethods
-		};
-	}
 	return {
 		origin,
 		port: resolvedPort,
 		app,
 		ws,
 		rpcGroup: core.rpcGroup,
-		connectionMeta,
+		connectionMeta: () => websocketConnectionMeta(rpcHost, options.path),
 		async close() {
 			await closeWs();
 			if (ownsHttpServer) await new Promise((r) => httpServer.close(() => r()));
@@ -121,6 +137,105 @@ async function bindHttpAndWs(options) {
 	};
 }
 /**
+* Whether a request is a WebSocket upgrade aimed at `path`: the `fetch`-side
+* equivalent of the Node transport's `upgrade`-event path filter, used by the
+* native ({@link bindNativeHttpAndWs}) tiers to route only the RPC route to
+* the socket and leave every other request to the h3 app.
+*/
+function isWsUpgradeRequest(request, path) {
+	if ((request.headers.get("upgrade") ?? "").toLowerCase() !== "websocket") return false;
+	if (!path) return true;
+	try {
+		return samePath(new URL(request.url).pathname, path);
+	} catch {
+		return false;
+	}
+}
+/**
+* The Bun/Deno counterpart to {@link bindHttpAndWs}: own and listen on a
+* native `fetch`-upgrade server (`Bun.serve` / `Deno.serve`) with crossws's
+* Bun/Deno adapter driving the RPC socket, since crossws's Node adapter (and
+* the `node:http` `upgrade` event it needs) refuses to run off Node. Only the
+* owns-a-server tiers reach here; a shared foreign `node:http` server can't be
+* re-hosted on a native runtime, so that path falls back to SSE instead.
+*/
+async function bindNativeHttpAndWs(runtime, options) {
+	const { context, port, core } = options;
+	const bindHost = options.host;
+	const app = new H3();
+	const rpcHost = context.rpc;
+	const wsPath = options.path;
+	const fail = async (closeWs, error) => {
+		await closeWs().catch(() => {});
+		throw diagnostics.DF0052({
+			host: bindHost,
+			port,
+			reason: error instanceof Error ? error.message : String(error),
+			cause: error
+		});
+	};
+	let resolvedPort;
+	let closeWs;
+	let closeServer;
+	if (runtime === "bun") {
+		const { attachBunWsTransport } = await import("./rpc/transports/ws-bun.mjs");
+		const tier = await attachBunWsTransport(core, { allowedOrigins: options.allowedOrigins });
+		closeWs = tier.close;
+		const Bun = globalThis.Bun;
+		let server;
+		try {
+			server = Bun.serve({
+				port,
+				hostname: bindHost,
+				fetch: async (request, srv) => isWsUpgradeRequest(request, wsPath) ? await tier.handleUpgrade(request, srv) : await app.fetch(request),
+				websocket: tier.websocket
+			});
+		} catch (error) {
+			return await fail(closeWs, error);
+		}
+		resolvedPort = server.port;
+		closeServer = async () => {
+			await server.stop(true);
+		};
+	} else {
+		const { attachDenoWsTransport } = await import("./rpc/transports/ws-deno.mjs");
+		const tier = await attachDenoWsTransport(core, { allowedOrigins: options.allowedOrigins });
+		closeWs = tier.close;
+		const Deno = globalThis.Deno;
+		let server;
+		try {
+			server = Deno.serve({
+				port,
+				hostname: bindHost,
+				onListen: () => {}
+			}, async (request, info) => isWsUpgradeRequest(request, wsPath) ? await tier.handleUpgrade(request, info) : await app.fetch(request));
+		} catch (error) {
+			return await fail(closeWs, error);
+		}
+		resolvedPort = server.addr.port;
+		closeServer = async () => {
+			await server.shutdown();
+		};
+	}
+	const origin = normalizeHttpServerUrl(bindHost, resolvedPort);
+	const internal = getInternalContext(context);
+	const wsUrl = `ws://${formatHostForUrl(bindHost)}:${resolvedPort}${options.path ?? ""}`;
+	internal.setWsEndpoint({ url: wsUrl });
+	return {
+		origin,
+		port: resolvedPort,
+		app,
+		ws: void 0,
+		rpcGroup: core.rpcGroup,
+		connectionMeta: () => websocketConnectionMeta(rpcHost, options.path),
+		async close() {
+			await closeServer();
+			await closeWs();
+			if (getInternalContext(context).wsEndpoint?.url === wsUrl) getInternalContext(context).setWsEndpoint(void 0);
+		}
+	};
+}
+/**
 * Translate the public `register?: boolean | Partial<DevframeInstanceRecord>`
 * option into a shell {@link InstanceRegisterConfig}, or `undefined` when
 * registration is opted out. The object form supplies record overrides on top
@@ -141,8 +256,8 @@ function samePath(a, b) {
 }
 /**
 * Copy a web `Response` from a fetch-style transport handler onto the h3
-* event's response and return its body — mirroring the MCP route's bridge.
-* Returning the body (a `ReadableStream`, or `''` for an empty one — h3
+* event's response and return its body, mirroring the MCP route's bridge.
+* Returning the body (a `ReadableStream`, or `''` for an empty one, since h3
 * middleware only falls through on `undefined`) terminates the chain with
 * the status/headers set here instead of continuing to the SPA catch-all.
 */
@@ -158,8 +273,8 @@ function respondWith(event, response) {
 * The shared machinery behind `initDevframe` and `initHub`: one mount base,
 * one h3 app, one lazily-derived public origin (and the auth banner that waits
 * for it), one WebSocket binding, and the fetch / connect-middleware pair that
-* serves them. Each factory supplies only what makes it itself — its context,
-* its routes, its diagnostics — through `init` / `mount`.
+* serves them. Each factory supplies only what makes it itself (its context,
+* its routes, its diagnostics) through `init` / `mount`.
 *
 * Nothing here listens on a port unless a side-car was explicitly requested:
 * the default tier leaves the socket `unbound`, so a host chains it onto its
@@ -172,6 +287,8 @@ function createInstanceShell(options) {
 	const base = options.base;
 	const baseNoSlash = withoutTrailingSlash(base);
 	const app = options.app ?? new H3();
+	const runtime = detectServerRuntime();
+	const nativeRuntime = runtime !== "node";
 	const wsDisabled = options.ws === false;
 	const ws = options.ws === false ? {} : options.ws ?? {};
 	const route = withoutLeadingSlash(ws.route ?? "__ws");
@@ -186,8 +303,11 @@ function createInstanceShell(options) {
 	const sseRoutePath = joinURL(base, sseRoute);
 	const advertisedSsePath = options.absoluteWsPath ? sseRoutePath : sseRoute;
 	let derivedOrigin;
+	function explicitOrigin() {
+		return typeof options.origin === "function" ? options.origin() : options.origin;
+	}
 	function currentOrigin() {
-		return (typeof options.origin === "function" ? options.origin() : options.origin) || derivedOrigin;
+		return explicitOrigin() || derivedOrigin;
 	}
 	let authHandler;
 	let bannerPrinted = false;
@@ -201,7 +321,7 @@ function createInstanceShell(options) {
 	let registerPromise;
 	/**
 	* Publish the instance in the global registry the moment both its origin
-	* and connection meta are known — at init end for a pinned origin, or on
+	* and connection meta are known: at init end for a pinned origin, or on
 	* the first request for a derived one. Registration never throws (the
 	* registry writer degrades to a coded warning), so failures never surface.
 	*/
@@ -210,7 +330,7 @@ function createInstanceShell(options) {
 		const origin = currentOrigin();
 		if (!cfg || registerPromise || !origin || !meta) return;
 		const resolvedMeta = meta;
-		registerPromise = import("./instance-registry-BjlMQbFB.mjs").then((n) => n.t).then(({ registerDevframeInstance }) => {
+		registerPromise = import("./instance-registry-C7-41RSp.mjs").then((n) => n.t).then(({ registerDevframeInstance }) => {
 			let port = 0;
 			try {
 				const url = new URL(origin);
@@ -230,8 +350,20 @@ function createInstanceShell(options) {
 			});
 		}).catch(() => {});
 	}
-	function noteOrigin(origin) {
-		derivedOrigin ??= origin;
+	/**
+	* Consider a request-derived origin candidate for the advertised public
+	* origin (which backs the OTP magic link). {@link validateOriginCandidate}
+	* adopts only a loopback host or an exact `allowedOrigins` match, so a raw
+	* inbound `Host`/URL authority never redirects the credential-bearing link.
+	* First-valid-origin wins: an invalid candidate leaves `derivedOrigin` unset
+	* (printing/registering nothing) so a later valid one can still be adopted.
+	*/
+	function noteOrigin(candidate) {
+		if (derivedOrigin === void 0 && !explicitOrigin()) {
+			const allowed = options.allowedOrigins;
+			const accepted = validateOriginCandidate(candidate, Array.isArray(allowed) ? allowed : void 0);
+			if (accepted !== void 0) derivedOrigin = accepted;
+		}
 		maybePrintBanner();
 		maybeRegister();
 	}
@@ -248,7 +380,7 @@ function createInstanceShell(options) {
 	/**
 	* Auth resolution: gate by default, `false` opts out, a handler object
 	* installs a custom scheme. The `external` tier has no local transport to
-	* gate — the server behind `ws.url` owns auth — so it resolves to nothing.
+	* gate (the server behind `ws.url` owns auth) so it resolves to nothing.
 	*/
 	function resolveAuth() {
 		if (options.auth === false) return false;
@@ -260,7 +392,7 @@ function createInstanceShell(options) {
 		return authHandler;
 	}
 	/**
-	* The context's RPC core (birpc group, session lifecycle, auth gate) —
+	* The context's RPC core (birpc group, session lifecycle, auth gate) is
 	* one per instance, shared by every transport binding (WS and SSE), so a
 	* WS peer and an SSE session live in the same session/broadcast space.
 	* Built lazily: an `unbound` host that never wires a transport pays
@@ -270,7 +402,7 @@ function createInstanceShell(options) {
 	let resolvedAuth = false;
 	let corePromise;
 	function ensureCore() {
-		corePromise ??= import("./rpc-core-DlHd276T.mjs").then((n) => n.n).then(({ createContextRpcServer }) => createContextRpcServer({
+		corePromise ??= import("./rpc-core-DVQ7xi89.mjs").then((n) => n.n).then(({ createContextRpcServer }) => createContextRpcServer({
 			context: ctx,
 			auth: resolvedAuth,
 			onPeerConnect: options.onPeerConnect,
@@ -302,14 +434,17 @@ function createInstanceShell(options) {
 	*/
 	async function startSidecar(core) {
 		const sidecarHost = options.host ?? "localhost";
-		const start = (port) => bindHttpAndWs({
-			context: ctx,
-			core,
-			host: sidecarHost,
-			port,
-			path: withLeadingSlash(route),
-			allowedOrigins: options.allowedOrigins
-		});
+		const start = (port) => {
+			const bindOptions = {
+				context: ctx,
+				core,
+				host: sidecarHost,
+				port,
+				path: withLeadingSlash(route),
+				allowedOrigins: options.allowedOrigins
+			};
+			return nativeRuntime ? bindNativeHttpAndWs(runtime, bindOptions) : bindHttpAndWs(bindOptions);
+		};
 		if (ws.port != null) return await start(ws.port);
 		const { getPort } = await import("./dist-CZXfGEkd.mjs").then((n) => n.t);
 		let lastError;
@@ -326,37 +461,70 @@ function createInstanceShell(options) {
 		}
 		throw lastError;
 	}
+	async function startServerTier() {
+		if (nativeRuntime && !ws.url) {
+			const core = await ensureCore();
+			started = {
+				origin: currentOrigin() ?? "",
+				port: 0,
+				app,
+				ws: void 0,
+				rpcGroup: core.rpcGroup,
+				connectionMeta: () => meta ?? options.onMetaUnavailable(),
+				close: async () => {}
+			};
+			return { wsAvailable: false };
+		}
+		started = await bindHttpAndWs({
+			context: ctx,
+			core: await ensureCore(),
+			host: options.host ?? "localhost",
+			port: 0,
+			server: options.server,
+			path: routePath,
+			allowedOrigins: options.allowedOrigins,
+			destroyUnmatched: options.destroyUnmatchedUpgrades
+		});
+		return {
+			websocketMeta: { path: advertisedPath },
+			wsAvailable: !wsDisabled
+		};
+	}
+	async function resolveWebsocketBinding() {
+		if (tier === "sidecar") {
+			started = await startSidecar(await ensureCore());
+			return {
+				websocketMeta: {
+					port: started.port,
+					path: route
+				},
+				wsAvailable: !wsDisabled
+			};
+		}
+		if (tier === "server") return startServerTier();
+		if (tier === "external") return {
+			websocketMeta: ws.url,
+			wsAvailable: !wsDisabled
+		};
+		return {
+			websocketMeta: { path: advertisedPath },
+			wsAvailable: !wsDisabled
+		};
+	}
 	async function init() {
 		const result = await options.init(api);
 		ctx = result.context;
 		dispose = result.dispose;
 		resolvedAuth = tier === "external" ? false : resolveAuth();
-		let websocketMeta;
-		if (tier === "sidecar") {
-			started = await startSidecar(await ensureCore());
-			websocketMeta = {
-				port: started.port,
-				path: route
-			};
-		} else if (tier === "server") {
-			started = await bindHttpAndWs({
-				context: ctx,
-				core: await ensureCore(),
-				host: options.host ?? "localhost",
-				port: 0,
-				server: options.server,
-				path: routePath,
-				allowedOrigins: options.allowedOrigins,
-				destroyUnmatched: options.destroyUnmatchedUpgrades
-			});
-			websocketMeta = { path: advertisedPath };
-		} else if (tier === "external") websocketMeta = ws.url;
-		else if (tier === "unbound") websocketMeta = { path: advertisedPath };
+		const binding = await resolveWebsocketBinding();
+		const wsAvailable = binding.wsAvailable;
+		let websocketMeta = binding.websocketMeta;
 		if (!wsDisabled && ws.url) websocketMeta = ws.url;
 		if (sseEnabled) app.use(sseRoutePath, defineHandler(async (event) => respondWith(event, await (await ensureSse()).handler(event.req))));
+		if (!wsDisabled && !wsAvailable && !sseEnabled) diagnostics.DF0075({ runtime }, { method: "warn" });
 		meta = {
-			backend: wsDisabled ? sseEnabled ? "sse" : "none" : "websocket",
-			...websocketMeta !== void 0 ? { websocket: websocketMeta } : {},
+			backend: !wsDisabled && wsAvailable ? "websocket" : sseEnabled ? "sse" : "none",
+			...wsAvailable && websocketMeta !== void 0 ? { websocket: websocketMeta } : {},
 			...sseEnabled ? { sse: { path: advertisedSsePath } } : {},
 			...result.mcp ? { mcp: result.mcp } : {}
 		};
@@ -371,7 +539,7 @@ function createInstanceShell(options) {
 	contextPromise.catch(() => {});
 	/**
 	* The `unbound` tier: the RPC core and its crossws adapter, bound to
-	* nothing. Built on the first `attach` / `handleUpgrade` — a host that
+	* nothing. Built on the first `attach` / `handleUpgrade`; a host that
 	* never wires the socket (or whose runtime brings its own WS transport)
 	* pays nothing for it, not even the adapter's imports.
 	*/
@@ -437,6 +605,7 @@ function createInstanceShell(options) {
 		if (tier === "disabled") throw diagnostics.DF0057();
 		if (tier === "external") throw diagnostics.DF0056({ url: ws.url });
 		if (tier !== "unbound") throw diagnostics.DF0055({ tier });
+		if (nativeRuntime) throw diagnostics.DF0076({ runtime });
 	}
 	/**
 	* Publish the socket's absolute URL on the context, so surfaces that hand