npm - env-runner - Versions diffs - 0.1.9 → 0.1.11 - Mend

env-runner 0.1.9 → 0.1.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/README.md +130 -16
package/dist/THIRD-PARTY-LICENSES.md +19 -0
package/dist/_chunks/base-runner.d.mts +80 -3
package/dist/_chunks/base-runner.mjs +108 -44
package/dist/_chunks/libs/cjs-module-lexer.mjs +1 -1
package/dist/_chunks/libs/es-module-lexer.mjs +83 -0
package/dist/_chunks/runner.d.mts +3 -3
package/dist/_chunks/runner.mjs +6 -3
package/dist/_chunks/runner2.d.mts +15 -3
package/dist/_chunks/runner2.mjs +145 -56
package/dist/_chunks/runner3.d.mts +3 -3
package/dist/_chunks/runner3.mjs +3 -3
package/dist/_chunks/runner4.d.mts +4 -4
package/dist/_chunks/runner4.mjs +3 -2
package/dist/_chunks/runner5.d.mts +4 -4
package/dist/_chunks/runner5.mjs +3 -2
package/dist/_chunks/server.mjs +60 -17
package/dist/_chunks/types.d.mts +15 -3
package/dist/_chunks/virtual-loader.mjs +63 -0
package/dist/_chunks/worker-utils.mjs +123 -9
package/dist/cli.mjs +1 -1
package/dist/index.d.mts +52 -14
package/dist/index.mjs +6 -6
package/dist/runners/bun-process/runner.d.mts +2 -2
package/dist/runners/bun-process/runner.mjs +12 -2
package/dist/runners/bun-process/worker.mjs +23 -3
package/dist/runners/deno-process/runner.d.mts +2 -2
package/dist/runners/deno-process/runner.mjs +1 -1
package/dist/runners/deno-process/worker.mjs +22 -3
package/dist/runners/miniflare/runner.d.mts +2 -2
package/dist/runners/miniflare/runner.mjs +1 -1
package/dist/runners/netlify/runner.d.mts +2 -2
package/dist/runners/netlify/runner.mjs +1 -1
package/dist/runners/node-process/runner.d.mts +2 -2
package/dist/runners/node-process/runner.mjs +4 -2
package/dist/runners/node-process/worker.mjs +23 -3
package/dist/runners/node-worker/runner.d.mts +2 -2
package/dist/runners/node-worker/runner.mjs +1 -1
package/dist/runners/node-worker/worker.mjs +22 -3
package/dist/runners/self/runner.d.mts +3 -2
package/dist/runners/self/runner.mjs +6 -3
package/dist/runners/vercel/runner.d.mts +2 -2
package/dist/runners/vercel/runner.mjs +1 -1
package/dist/vite.d.mts +1 -1
package/package.json +12 -11

package/README.md CHANGED Viewed

@@ -50,7 +50,7 @@ import { serve } from "srvx";
 import { EnvServer } from "env-runner";
 const envServer = new EnvServer({
-  runner: "node-process",
+  runner: "node-process", // optional, defaults to "node-worker"
   entry: "./app.ts",
   watch: true,
   watchPaths: ["./src"],
@@ -64,8 +64,12 @@ envServer.onReload(() => {
   console.log("Reloaded!");
 });
+// Optional — the server auto-starts on first fetch()
 await envServer.start();
+// Restart with a fresh runner created from the server options
+await envServer.reload();
 // Use with any HTTP server
 const server = serve({
   fetch: (request) => envServer.fetch(request),
@@ -79,7 +83,7 @@ Proxy manager for hot-reload with message queueing and listener forwarding:
 ```ts
 import { RunnerManager, NodeProcessEnvRunner } from "env-runner";
-const manager = new RunnerManager();
+await using manager = new RunnerManager();
 manager.onReady((_runner, address) => {
   console.log("Ready:", address);
@@ -106,9 +110,11 @@ await manager.reload(newRunner); // old runner is closed automatically
 manager.sendMessage({ type: "config", value: 42 });
 manager.onMessage((msg) => console.log("From worker:", msg));
-await manager.close();
+// manager.close() is awaited automatically at the end of the scope (`await using`)
 ```
+All runners, `RunnerManager`, and `EnvServer` implement `AsyncDisposable`, so they can be auto-closed with [explicit resource management](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/await_using) (`await using`) — or closed manually with `await runner.close()`.
 ### Runners
 Use runners directly for lower-level control:
@@ -127,7 +133,7 @@ import { NetlifyEnvRunner } from "env-runner/runners/netlify";
 All runners implement the [`EnvRunner`](./src/types.ts) interface:
 ```ts
-const runner = new NodeProcessEnvRunner({
+await using runner = new NodeProcessEnvRunner({
   name: "my-app",
   data: { entry: "./app.ts" },
   hooks: {
@@ -138,7 +144,8 @@ const runner = new NodeProcessEnvRunner({
 });
 // Proxy HTTP requests (retries with exponential backoff)
-const response = await runner.fetch("http://localhost/api");
+// Relative URLs are resolved against a placeholder origin
+const response = await runner.fetch("/api");
 // Proxy WebSocket upgrades
 runner.upgrade?.({ node: { req, socket, head } });
@@ -156,8 +163,12 @@ const result = await runner.rpc<string>("transformHTML", "<html>...</html>");
 // Hot-reload entry module without restarting the worker
 await runner.reloadModule();
-// Graceful shutdown
-await runner.close();
+// Invalidate a virtual module (re-runs a factory source), then reload
+await runner.invalidateModule("#config.json");
+await runner.reloadModule();
+// Graceful shutdown happens automatically at the end of the scope
+// (`await using`) — or call `await runner.close()` explicitly
 ```
 **Available runners:**
@@ -173,6 +184,107 @@ await runner.close();
 | `VercelEnvRunner`      | Worker thread (Vercel context)  | `workerData` / `parentPort`        |
 | `NetlifyEnvRunner`     | Worker thread (Netlify context) | `workerData` / `parentPort`        |
+#### Virtual Modules
+The Node.js runners (`NodeWorkerEnvRunner`, `NodeProcessEnvRunner`, and the runners built on top of them), `BunProcessEnvRunner`, `DenoProcessEnvRunner` (Deno >= 2.x), and `MiniflareEnvRunner` can serve **virtual modules** from an in-memory `specifier => source` map passed via `data.virtual`. The entry (and its dependencies) can then `import` them as if they were real files:
+```ts
+import { NodeWorkerEnvRunner } from "env-runner/runners/node-worker";
+await using runner = new NodeWorkerEnvRunner({
+  name: "my-app",
+  data: {
+    entry: "./app.ts",
+    virtual: {
+      "#config": `export const apiBase = "https://api.example.com";`,
+      "#banner": `export default "Hello from a virtual module!";`,
+    },
+  },
+});
+```
+```ts
+// app.ts
+import banner from "#banner";
+import { apiBase } from "#config";
+export default {
+  fetch: () => new Response(`${banner} (${apiBase})`),
+};
+```
+The **entry itself can be virtual** — set `data.entry` to one of the `data.virtual` keys to run an entry whose source lives in memory (it may import other virtual modules too):
+```ts
+await using runner = new NodeWorkerEnvRunner({
+  name: "my-app",
+  data: {
+    entry: "#entry",
+    virtual: {
+      "#entry": `import { body } from "#dep";
+        export default { fetch: () => new Response(body) };`,
+      "#dep": `export const body = "Hello from a virtual entry!";`,
+    },
+  },
+});
+```
+Each source may also be a **factory** `() => string | Promise<string>` instead of a literal string — useful for lazily computed or asynchronously loaded sources:
+```ts
+await using runner = new NodeWorkerEnvRunner({
+  name: "my-app",
+  data: {
+    entry: "./app.ts",
+    virtual: {
+      "#config": () => `export const apiBase = ${JSON.stringify(getApiBase())};`,
+      "#schema": async () => `export default ${await loadSchemaJson()};`,
+    },
+  },
+});
+```
+Factories are invoked once on the host (before the worker is spawned), so the worker always receives plain strings — functions can't cross the `workerData`/`JSON` boundary, and Node's synchronous load hook can't await. For the same reason, **all** factories are resolved eagerly at startup (in parallel), not lazily on first import — so keep them cheap, or use plain strings for sources that don't need computation. Maps containing only strings skip this step entirely.
+To refresh a single virtual module without restarting the worker, call `invalidateModule(specifier)`: a factory-valued source is re-run on the host and the module is invalidated in the worker so its **next import evaluates fresh**. Virtual modules that import the invalidated one (directly or transitively) are invalidated along with it, so the fresh module is picked up even through intermediate virtual importers. Already-imported modules keep their instances, so pair it with `reloadModule()` to re-import the entry graph:
+```ts
+await runner.invalidateModule("#config"); // re-runs the factory, busts the module
+await runner.reloadModule(); // re-imports the entry, picking up the fresh module
+```
+When fetching through `RunnerManager` or `EnvServer`, the reload is automatic: `invalidateModule()` marks the manager dirty and the next `fetch()` reloads the entry once before serving (concurrent fetches share the reload), so no explicit `reloadModule()` call is needed.
+The module format is derived from the specifier extension: `.ts`/`.mts` sources are served as **TypeScript** and `.json` sources as **JSON modules**; everything else is plain JavaScript ESM:
+```ts
+await using runner = new NodeWorkerEnvRunner({
+  name: "my-app",
+  data: {
+    entry: "#entry.ts",
+    virtual: {
+      "#entry.ts": `
+        import { getGreeting } from "#util.ts";
+        import config from "#config.json";
+        const handler: () => Response = () => new Response(getGreeting(config.name));
+        export default { fetch: handler };
+      `,
+      "#util.ts": `export function getGreeting(name: string): string {
+        return \`Hello, \${name}!\`;
+      }`,
+      "#config.json": JSON.stringify({ name: "virtual" }),
+    },
+  },
+});
+```
+- **TypeScript** is type-stripped by Node's native [type stripping](https://nodejs.org/api/typescript.html#type-stripping) (Node.js >= 22.18 / 23.6 — erasable syntax only) and by Bun's `ts` loader. On Deno, custom load hooks bypass its native type stripping, so sources are pre-stripped with [`module.stripTypeScriptTypes`](https://docs.deno.com/api/node/module/~/Module.stripTypeScriptTypes) (Deno >= 2.8.2); on older Deno without it, virtual `.ts`/`.mts` sources **throw at registration** — pass pre-transpiled JavaScript instead. On miniflare, sources are likewise pre-stripped with `module.stripTypeScriptTypes` on the host (workerd does not parse TypeScript).
+- **JSON** sources expose the parsed value as the default export on all runtimes. The `with { type: "json" }` import attribute is optional on Node.js and Bun; on Deno and miniflare it must be **omitted** (static imports carrying an import attribute bypass `registerHooks` resolution on Deno, and workerd rejects import attributes outright).
+Virtual modules are registered inside the worker, before the entry is imported. On Node.js (>= 22.15 / 23.5) and Deno (>= 2.x) this uses [ESM customization hooks](https://nodejs.org/api/module.html#moduleregisterhooksoptions) (`module.registerHooks`); on Bun (which does not implement `registerHooks`) it uses [`Bun.plugin()`](https://bun.com/docs/runtime/plugins) virtual modules instead. The source string is treated as an ES module, and virtual specifiers (including a virtual entry) resolve across `reloadModule()`. On runtimes supporting neither mechanism, a warning is logged and registration is skipped. When the worker shuts down gracefully the registration is unregistered again (the `registerHooks` registration is deregistered; on Bun, which has no plugin-removal API, the in-memory source map is detached so fresh loads and reloads stop resolving).
+On `MiniflareEnvRunner` there is no in-worker registration: the runner's module fallback service serves virtual specifiers to workerd directly (taking precedence over disk files and the `transformRequest` pipeline, so a virtual key overrides a real file with the same path). One limitation: named `exports` (Durable Objects / WorkerEntrypoints) cannot be combined with a **virtual entry** — the wrapper would need a static re-export that miniflare cannot resolve at startup — and the runner fails fast with a clear error in that case.
 #### Miniflare Runner
 Run your app in the Cloudflare Workers runtime using [miniflare](https://github.com/cloudflare/workers-sdk/tree/main/packages/miniflare):
@@ -184,7 +296,7 @@ npm install miniflare
 ```ts
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
-const runner = new MiniflareEnvRunner({
+await using runner = new MiniflareEnvRunner({
   name: "my-worker",
   data: { entry: "./worker.ts" },
   miniflareOptions: {
@@ -194,7 +306,6 @@ const runner = new MiniflareEnvRunner({
 });
 const response = await runner.fetch("http://localhost/api");
-await runner.close();
 ```
 The `miniflareOptions` object is passed directly to the [Miniflare constructor](https://developers.cloudflare.com/workers/testing/miniflare/) — you can configure bindings, KV, D1, Durable Objects, and any other Miniflare option.
@@ -206,7 +317,7 @@ Pass a `transformRequest` callback to route module resolution through Vite's (or
 ```ts
 import { MiniflareEnvRunner } from "env-runner/runners/miniflare";
-const runner = new MiniflareEnvRunner({
+await using runner = new MiniflareEnvRunner({
   name: "my-worker",
   data: { entry: "./worker.ts" },
   // Route module resolution through Vite's transform pipeline
@@ -245,7 +356,7 @@ export default {
 To explicitly declare exports or override auto-detection:
 ```ts
-const runner = new MiniflareEnvRunner({
+await using runner = new MiniflareEnvRunner({
   name: "my-worker",
   data: { entry: "./worker.ts" },
   // Explicit exports (merged with auto-detected ones)
@@ -300,7 +411,7 @@ Simulates a Vercel deployment environment with automatic header injection (`x-ve
 ```ts
 import { VercelEnvRunner } from "env-runner/runners/vercel";
-const runner = new VercelEnvRunner({
+await using runner = new VercelEnvRunner({
   name: "my-app",
   data: { entry: "./app.ts" },
 });
@@ -313,7 +424,7 @@ Simulates a Netlify deployment environment with automatic header injection (`x-n
 ```ts
 import { NetlifyEnvRunner } from "env-runner/runners/netlify";
-const runner = new NetlifyEnvRunner({
+await using runner = new NetlifyEnvRunner({
   name: "my-app",
   data: { entry: "./app.ts" },
 });
@@ -343,7 +454,10 @@ const env = new DevEnvironment("ssr", config, { hot: true, transport });
 import { createViteTransport } from "env-runner/vite";
 const transport = createViteTransport(sendMessage, onMessage, "ssr");
-const runner = new ModuleRunner({ transport, sourcemapInterceptor: "prepareStackTrace" });
+const runner = new ModuleRunner({
+  transport,
+  sourcemapInterceptor: "prepareStackTrace",
+});
 ```
 Messages are namespaced by environment name, so multiple Vite environments can share a single runner's IPC channel.
@@ -389,7 +503,7 @@ You can also use `loadRunner()` to dynamically load a runner by name:
 ```ts
 import { loadRunner } from "env-runner";
-const runner = await loadRunner("node-worker", {
+await using runner = await loadRunner("node-worker", {
   name: "my-app",
   data: { entry: "./app.ts" },
 });
@@ -448,7 +562,7 @@ The built-in worker automatically:
 For advanced use cases, you can provide a custom worker entry:
 ```ts
-const runner = new NodeProcessEnvRunner({
+await using runner = new NodeProcessEnvRunner({
   name: "my-app",
   workerEntry: "/path/to/custom-worker.ts",
   data: { entry: "./app.ts" },

package/dist/THIRD-PARTY-LICENSES.md CHANGED Viewed

@@ -21,3 +21,22 @@ Repository: https://github.com/nodejs/cjs-module-lexer
 > The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 >
 > THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+---------------------------------------
+## es-module-lexer
+License: MIT
+By: Guy Bedford
+Repository: https://github.com/guybedford/es-module-lexer
+> MIT License
+> -----------
+>
+> Copyright (C) 2018-2022 Guy Bedford
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/_chunks/base-runner.d.mts CHANGED Viewed

@@ -1,18 +1,48 @@
-import { a as RunnerMessageListener, l as WorkerAddress, t as EnvRunner, u as WorkerHooks } from "./types.mjs";
+import { EnvRunner, RunnerMessageListener, WorkerAddress, WorkerHooks } from "./types.mjs";
 import { IncomingMessage } from "node:http";
 import { Socket } from "node:net";
+/**
+ * Source for a virtual module: either a literal ES module string or a factory
+ * that returns one (sync or async).
+ *
+ * Factories are evaluated **once on the host side** before the worker is spawned
+ * (functions can't cross the `workerData`/`JSON` boundary, and Node's synchronous
+ * load hook can't await), so the worker always receives plain strings. See
+ * {@link resolveVirtualModules}.
+ */
+type VirtualModuleSource = string | (() => string | Promise<string>);
+/** Virtual modules as a `specifier => source` map. */
+type VirtualModules = Record<string, VirtualModuleSource>;
 interface EnvRunnerData {
   name?: string;
+  /**
+   * Virtual modules as a `specifier => source` map.
+   *
+   * Registered as Node.js ESM customization hooks in the worker so the entry
+   * (and its dependencies) can `import` them, e.g.
+   * `{ "#virtual-import": "export const foo = 1" }`.
+   *
+   * Each source may be a string or a factory `() => string | Promise<string>`.
+   * Factories are evaluated once on the host before the worker is spawned (so the
+   * worker always receives plain strings).
+   *
+   * Supported by the `node-worker`, `node-process`, `bun-process`,
+   * `deno-process`, `vercel`, `netlify`, and `miniflare` runners.
+   */
+  virtual?: VirtualModules;
   [key: string]: unknown;
 }
-declare abstract class BaseEnvRunner implements EnvRunner {
+declare abstract class BaseEnvRunner implements EnvRunner, AsyncDisposable {
   closed: boolean;
   protected _name: string;
   protected _workerEntry: string;
   protected _data?: EnvRunnerData;
+  protected _virtualSources?: VirtualModules;
   protected _hooks: Partial<WorkerHooks>;
   protected _address?: WorkerAddress;
   protected _messageListeners: Set<(data: unknown) => void>;
+  protected _pendingRequests: Set<(cause?: unknown) => void>;
+  protected _virtualResolved?: Promise<void>;
   constructor(opts: {
     name: string;
     workerEntry: string;
@@ -36,11 +66,58 @@ declare abstract class BaseEnvRunner implements EnvRunner {
     timeout?: number;
   }): Promise<T>;
   reloadModule(timeout?: number): Promise<void>;
+  /**
+   * Invalidate a virtual module so the next `reloadModule()` re-evaluates it.
+   * A factory-valued `data.virtual` source is re-run on the host and the fresh
+   * source is shipped to the worker along with the invalidation. Rejects when
+   * the specifier is not a registered virtual module.
+   */
+  invalidateModule(specifier: string, timeout?: number): Promise<void>;
   close(cause?: unknown): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+  /**
+   * Resolve a relative fetch input (e.g. `"/path"`) against a placeholder
+   * `http://localhost` origin so it parses as a full URL. The origin is a
+   * placeholder — requests are dispatched to the worker address regardless.
+   */
+  protected _resolveFetchInput(input: string | URL | Request): string | URL | Request;
   protected _handleMessage(message: any): void;
+  /**
+   * Send a message and await a matching response message. Shared by `rpc()`,
+   * `reloadModule()`, and `invalidateModule()`. Rejects on timeout, on a
+   * response carrying an `error`, and promptly when the runner closes mid-wait
+   * (instead of letting callers wait out the timeout on a dead worker).
+   */
+  protected _request<T = unknown>(message: unknown, opts: {
+    match: (msg: any) => boolean;
+    timeout: number;
+    timeoutError: string;
+    send?: (message: unknown) => void;
+  }): Promise<T>;
+  /**
+   * Resolve any factory-valued `data.virtual` sources to strings before the
+   * worker is spawned. Returns a pending promise only when there is async work
+   * to do (a factory is present); otherwise returns `undefined` so subclasses can
+   * keep their synchronous spawn path. Factories must be resolved here because
+   * functions can't cross the worker boundary and the load hook can't await.
+   */
+  protected _resolveVirtualData(): Promise<void> | undefined;
+  /**
+   * Re-run a factory-valued virtual source on the host and sync the resolved
+   * `data.virtual` map. Returns the fresh source, or `undefined` when the
+   * source is a plain string or unknown (nothing to re-evaluate).
+   */
+  protected _refreshVirtualSource(specifier: string): Promise<string | undefined>;
+  /**
+   * Run a subclass spawn callback after `data.virtual` is resolved.
+   * Synchronous when no factory-valued source is present; otherwise defers
+   * `init` until factories resolve. A throwing/rejecting factory closes the
+   * runner with the error as cause instead of leaving an unhandled rejection.
+   */
+  protected _initWithVirtualData(init: () => void): void;
   protected _closeSocket(): Promise<void>;
   protected abstract _hasRuntime(): boolean;
   protected abstract _closeRuntime(): Promise<void>;
   protected abstract _runtimeType(): string;
 }
-export { EnvRunnerData as n, BaseEnvRunner as t };
+export { BaseEnvRunner, EnvRunnerData, VirtualModuleSource, VirtualModules };

package/dist/_chunks/base-runner.mjs CHANGED Viewed

@@ -1,3 +1,4 @@
+import { resolveVirtualModules } from "./virtual-loader.mjs";
 import { rm } from "node:fs/promises";
 import { proxyFetch, proxyUpgrade } from "httpxy";
 var BaseEnvRunner = class {
@@ -5,15 +6,19 @@ var BaseEnvRunner = class {
 	_name;
 	_workerEntry;
 	_data;
+	_virtualSources;
 	_hooks;
 	_address;
 	_messageListeners;
+	_pendingRequests;
+	_virtualResolved;
 	constructor(opts) {
 		this._name = opts.name;
 		this._workerEntry = opts.workerEntry;
 		this._data = opts.data;
 		this._hooks = opts.hooks || {};
 		this._messageListeners = /* @__PURE__ */ new Set();
+		this._pendingRequests = /* @__PURE__ */ new Set();
 	}
 	get ready() {
 		return Boolean(!this.closed && this._address && this._hasRuntime());
@@ -21,7 +26,7 @@ var BaseEnvRunner = class {
 	async fetch(input, init) {
 		for (let i = 0; i < 5 && !this._address && !this.closed; i++) await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
 		if (!this._address) return new Response(`${this._runtimeType()} env runner is unavailable`, { status: 503 });
-		return proxyFetch(this._address, input, init);
+		return proxyFetch(this._address, this._resolveFetchInput(input), init);
 	}
 	async upgrade(context) {
 		if (!this.ready || !this._address) return;
@@ -35,6 +40,7 @@ var BaseEnvRunner = class {
 	}
 	waitForReady(timeout = 5e3) {
 		if (this.ready) return Promise.resolve();
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Runner closed before becoming ready"));
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
 				this._messageListeners.delete(listener);
@@ -45,6 +51,10 @@ var BaseEnvRunner = class {
 					clearTimeout(timer);
 					this._messageListeners.delete(listener);
 					resolve();
+				} else if (this.closed) {
+					clearTimeout(timer);
+					this._messageListeners.delete(listener);
+					reject(/* @__PURE__ */ new Error("Runner closed before becoming ready"));
 				}
 			};
 			this._messageListeners.add(listener);
@@ -52,76 +62,130 @@ var BaseEnvRunner = class {
 	}
 	rpc(name, data, opts) {
 		const id = Math.random().toString(36).slice(2);
-		const timeout = opts?.timeout ?? 3e3;
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
-				cleanup();
-				reject(/* @__PURE__ */ new Error(`RPC "${name}" timed out`));
-			}, timeout);
-			const listener = (msg) => {
-				if (msg?.__rpc_id === id) {
-					cleanup();
-					if (msg.error) reject(typeof msg.error === "string" ? new Error(msg.error) : msg.error);
-					else resolve(msg.data);
-				}
-			};
-			const cleanup = () => {
-				clearTimeout(timer);
-				this.offMessage(listener);
-			};
-			this.onMessage(listener);
-			this.sendMessage({
-				__rpc: name,
-				__rpc_id: id,
-				data
-			});
-		});
+		return this._request({
+			__rpc: name,
+			__rpc_id: id,
+			data
+		}, {
+			match: (msg) => msg?.__rpc_id === id,
+			timeout: opts?.timeout ?? 3e3,
+			timeoutError: `RPC "${name}" timed out`
+		}).then((msg) => msg.data);
 	}
 	async reloadModule(timeout = 5e3) {
-		return new Promise((resolve, reject) => {
-			const timer = setTimeout(() => {
-				cleanup();
-				reject(/* @__PURE__ */ new Error("Module reload timed out"));
-			}, timeout);
-			const listener = (msg) => {
-				if (msg?.event === "module-reloaded") {
-					cleanup();
-					if (msg.error) reject(typeof msg.error === "string" ? new Error(msg.error) : msg.error);
-					else resolve();
-				}
-			};
-			const cleanup = () => {
-				clearTimeout(timer);
-				this.offMessage(listener);
-			};
-			this.onMessage(listener);
-			this.sendMessage({ event: "reload-module" });
+		await this._request({ event: "reload-module" }, {
+			match: (msg) => msg?.event === "module-reloaded",
+			timeout,
+			timeoutError: "Module reload timed out"
+		});
+	}
+	async invalidateModule(specifier, timeout = 5e3) {
+		const source = await this._refreshVirtualSource(specifier);
+		await this._request({
+			event: "invalidate-module",
+			specifier,
+			source
+		}, {
+			match: (msg) => msg?.event === "module-invalidated" && msg.specifier === specifier,
+			timeout,
+			timeoutError: `Module invalidation timed out for "${specifier}"`
 		});
 	}
 	async close(cause) {
 		if (this.closed) return;
 		this.closed = true;
+		for (const rejectPending of this._pendingRequests) rejectPending(cause);
+		this._pendingRequests.clear();
 		this._hooks.onClose?.(this, cause);
 		this._hooks = {};
 		const onError = (error) => console.error(error);
 		await this._closeRuntime().catch(onError);
 		await this._closeSocket().catch(onError);
 	}
+	async [Symbol.asyncDispose]() {
+		await this.close();
+	}
 	[Symbol.for("nodejs.util.inspect.custom")]() {
 		const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
 		return `${this.constructor.name}#${this._name}(${status})`;
 	}
+	_resolveFetchInput(input) {
+		if (typeof input === "string" && !URL.canParse(input)) return new URL(input, "http://localhost");
+		return input;
+	}
 	_handleMessage(message) {
 		if (message?.address) {
 			this._address = message.address;
 			this._hooks.onReady?.(this, this._address);
 		}
+		if (message?.event === "init-error" && !this.ready && !this.closed) this.close(new Error(String(message.error || "Worker initialization failed")));
 		for (const listener of this._messageListeners) listener(message);
 	}
+	_request(message, opts) {
+		if (this.closed) return Promise.reject(/* @__PURE__ */ new Error("Runner is closed"));
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				cleanup();
+				reject(new Error(opts.timeoutError));
+			}, opts.timeout);
+			const listener = (msg) => {
+				if (opts.match(msg)) {
+					cleanup();
+					if (msg.error) reject(typeof msg.error === "string" ? new Error(msg.error) : msg.error);
+					else resolve(msg);
+				}
+			};
+			const onClose = (cause) => {
+				cleanup();
+				reject(new Error("Runner closed before responding", cause ? { cause } : void 0));
+			};
+			const cleanup = () => {
+				clearTimeout(timer);
+				this.offMessage(listener);
+				this._pendingRequests.delete(onClose);
+			};
+			this.onMessage(listener);
+			this._pendingRequests.add(onClose);
+			try {
+				(opts.send ?? ((m) => this.sendMessage(m)))(message);
+			} catch (error) {
+				cleanup();
+				reject(error);
+			}
+		});
+	}
+	_resolveVirtualData() {
+		const virtual = this._data?.virtual;
+		this._virtualSources = virtual;
+		if (!virtual || !Object.values(virtual).some((v) => typeof v === "function")) return;
+		this._virtualResolved = resolveVirtualModules(virtual).then((resolved) => {
+			this._data = {
+				...this._data,
+				virtual: resolved
+			};
+		});
+		return this._virtualResolved;
+	}
+	async _refreshVirtualSource(specifier) {
+		await this._virtualResolved?.catch(() => {});
+		const original = this._virtualSources?.[specifier];
+		if (typeof original !== "function") return;
+		const source = await original();
+		const resolved = this._data?.virtual;
+		if (resolved) resolved[specifier] = source;
+		return source;
+	}
+	_initWithVirtualData(init) {
+		const pending = this._resolveVirtualData();
+		if (pending) pending.then(() => {
+			if (!this.closed) init();
+		}, (error) => this.close(error));
+		else init();
+	}
 	async _closeSocket() {
 		const socketPath = this._address?.socketPath;
 		if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\\pipe`)) await rm(socketPath).catch(() => {});
 		this._address = void 0;
 	}
 };
-export { BaseEnvRunner as t };
+export { BaseEnvRunner };

package/dist/_chunks/libs/cjs-module-lexer.mjs CHANGED Viewed

@@ -142,4 +142,4 @@ function init() {
 		A = Q;
 	})());
 }
-export { parse as n, init as t };
+export { init, parse };