@marko/run 0.1.5 → 0.1.6

package/dist/adapter/dev-entry.mjs

@@ -0,0 +1,36 @@
+import { createServer } from "vite";
+
+let activeDevServers;
+
+process
+  .on("message", (message) => {
+    switch (message.type) {
+      case "start":
+        return start(message.entry, message.config);
+      case "shutdown":
+        return shutdown();
+    }
+  })
+  .send("ready");
+
+async function start(entry, config) {
+  let changed = false;
+  const loader = await createServer(config);
+  ({ activeDevServers } = await loader.ssrLoadModule("@marko/run/adapter"));
+  await loader.ssrLoadModule(entry);
+
+  loader.watcher.on("change", (path) => {
+    if (!changed && loader.moduleGraph.getModulesByFile(path)) {
+      changed = true;
+      process.send("restart");
+    }
+  });
+}
+
+function shutdown() {
+  if (activeDevServers) {
+    for (const devServer of activeDevServers) {
+      devServer.ws.send({ type: "full-reload" });
+    }
+  }
+}

package/dist/adapter/dev-server.d.ts

@@ -1,4 +1,6 @@
-import { InlineConfig, ViteDevServer } from "vite";
+import { type InlineConfig, type ViteDevServer } from "vite";
 import type { NodeMiddleware } from "./middleware";
+export declare const activeDevServers: Set<ViteDevServer>;
 export declare function createViteDevMiddleware<T>(devServer: ViteDevServer, load: (prev: T | undefined) => Promise<T>, factory: (value: T) => NodeMiddleware): NodeMiddleware;
+export declare function createViteDevServer(config?: InlineConfig): Promise<ViteDevServer>;
 export declare function createDevServer(config?: InlineConfig): Promise<ViteDevServer>;

package/dist/adapter/index.cjs

@@ -26,8 +26,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/adapter/index.ts
 var adapter_exports = {};
 __export(adapter_exports, {
+  activeDevServers: () => activeDevServers,
   createDevServer: () => createDevServer,
   createViteDevMiddleware: () => createViteDevMiddleware,
+  createViteDevServer: () => createViteDevServer,
   default: () => adapter
 });
 module.exports = __toCommonJS(adapter_exports);
@@ -37,6 +39,7 @@ var import_url = require("url");
 // src/adapter/dev-server.ts
 var import_vite = require("vite");
 var import_strip_ansi = __toESM(require("strip-ansi"), 1);
+var activeDevServers = /* @__PURE__ */ new Set();
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -59,12 +62,22 @@ function createViteDevMiddleware(devServer, load, factory) {
     }
   };
 }
-async function createDevServer(config2) {
+async function createViteDevServer(config2) {
   const devServer = await (0, import_vite.createServer)({
     ...config2,
     appType: "custom",
     server: { middlewareMode: true }
   });
+  const originalClose = devServer.close;
+  devServer.close = () => {
+    activeDevServers.delete(devServer);
+    return originalClose.call(devServer);
+  };
+  activeDevServers.add(devServer);
+  return devServer;
+}
+async function createDevServer(config2) {
+  const devServer = await createViteDevServer(config2);
   const { createMiddleware } = await devServer.ssrLoadModule(
     "@marko/run/adapter/middleware"
   );
@@ -82,6 +95,7 @@ var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
 var import_dotenv = require("dotenv");
 var import_fs = __toESM(require("fs"), 1);
+var import_cluster = __toESM(require("cluster"), 1);
 async function parseEnv(envFile) {
   if (import_fs.default.existsSync(envFile)) {
     const content = await import_fs.default.promises.readFile(envFile, "utf8");
@@ -120,9 +134,37 @@ async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), w
     close
   };
 }
+async function spawnServerWorker(module2, args = [], port = 0, env) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
+  const originalExec = import_cluster.default.settings.exec;
+  const originalArgs = import_cluster.default.settings.execArgv;
+  try {
+    import_cluster.default.settings.exec = module2;
+    import_cluster.default.settings.execArgv = args;
+    const worker = import_cluster.default.fork({ ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` });
+    return new Promise((resolve) => {
+      function ready(message) {
+        if (message === "ready") {
+          worker.off("message", ready);
+          resolve(worker);
+        }
+      }
+      worker.on("message", ready);
+    });
+  } finally {
+    import_cluster.default.settings.exec = originalExec;
+    import_cluster.default.settings.execArgv = originalArgs;
+  }
+}
 async function waitForServer(port, wait = 0) {
   let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
+  let connection;
+  while (!(connection = await getConnection(port))) {
     if (remaining >= 100) {
       remaining -= 100;
       await sleep(100);
@@ -132,14 +174,16 @@ async function waitForServer(port, wait = 0) {
       );
     }
   }
+  return connection;
 }
-async function isPortInUse(port) {
+async function getConnection(port) {
   return new Promise((resolve) => {
-    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
+    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
       connection.end();
-      resolve(connected);
-    }
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
   });
 }
 async function getAvailablePort() {
@@ -158,20 +202,56 @@ function sleep(ms) {
 var import_parse_node_args = __toESM(require("parse-node-args"), 1);
 var import_meta = {};
 var __dirname = (0, import_url.fileURLToPath)(new URL(".", import_meta.url));
+var defaultEntry = import_path.default.join(__dirname, "default-entry");
+var loadDevWorker = import_path.default.join(__dirname, "load-dev-worker.mjs");
 function adapter() {
   return {
     name: "base-adapter",
     async getEntryFile() {
-      const entry = import_path.default.join(__dirname, "default-entry");
-      return entry;
+      return defaultEntry;
     },
-    async startDev(config2, { port = 3e3, envFile }) {
-      const { root, configFile } = config2;
+    async startDev(entry, config2, options) {
+      const { port = 3e3, envFile } = options;
+      if (entry) {
+        const { nodeArgs } = (0, import_parse_node_args.default)(options.args);
+        let worker;
+        async function start() {
+          const nextWorker = await spawnServerWorker(
+            loadDevWorker,
+            nodeArgs,
+            port,
+            envFile
+          );
+          nextWorker.on("message", (messsage) => {
+            if (messsage === "restart") {
+              start();
+            }
+          }).send({ type: "start", entry, config: config2 });
+          await waitForWorker(nextWorker, port);
+          if (worker) {
+            const prevWorker = worker;
+            let timeout;
+            worker.once("disconnect", () => {
+              clearTimeout(timeout);
+            });
+            worker.send({ type: "shutdown" });
+            worker.disconnect();
+            timeout = setTimeout(() => {
+              prevWorker.kill();
+            }, 2e3);
+          }
+          worker = nextWorker;
+        }
+        await start();
+        return {
+          port,
+          close() {
+            worker.kill();
+          }
+        };
+      }
+      const devServer = await createDevServer(config2);
       envFile && await loadEnv(envFile);
-      const devServer = await createDevServer({
-        root,
-        configFile
-      });
       return new Promise((resolve) => {
         const listener = devServer.middlewares.listen(port, () => {
           const address = listener.address();
@@ -195,8 +275,21 @@ function adapter() {
     }
   };
 }
+async function waitForWorker(worker, port) {
+  return new Promise((resolve) => {
+    function listening(address) {
+      if (address.port === port) {
+        worker.off("listening", listening);
+        resolve();
+      }
+    }
+    worker.on("listening", listening);
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  activeDevServers,
   createDevServer,
-  createViteDevMiddleware
+  createViteDevMiddleware,
+  createViteDevServer
 });

package/dist/adapter/index.d.ts

@@ -1,6 +1,6 @@
 import type { Adapter } from "../vite";
 import { type SpawnedServer } from "../vite/utils/server";
-export { createDevServer, createViteDevMiddleware } from "./dev-server";
+export { activeDevServers, createDevServer, createViteDevServer, createViteDevMiddleware, } from "./dev-server";
 export type { Adapter, SpawnedServer };
 export type { NodePlatformInfo } from "./middleware";
 export default function adapter(): Adapter;

package/dist/adapter/index.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "url";
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
 import stripAnsi from "strip-ansi";
+var activeDevServers = /* @__PURE__ */ new Set();
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -27,12 +28,22 @@ function createViteDevMiddleware(devServer, load, factory) {
     }
   };
 }
-async function createDevServer(config2) {
+async function createViteDevServer(config2) {
   const devServer = await createServer({
     ...config2,
     appType: "custom",
     server: { middlewareMode: true }
   });
+  const originalClose = devServer.close;
+  devServer.close = () => {
+    activeDevServers.delete(devServer);
+    return originalClose.call(devServer);
+  };
+  activeDevServers.add(devServer);
+  return devServer;
+}
+async function createDevServer(config2) {
+  const devServer = await createViteDevServer(config2);
   const { createMiddleware } = await devServer.ssrLoadModule(
     "@marko/run/adapter/middleware"
   );
@@ -50,6 +61,7 @@ import net from "net";
 import cp from "child_process";
 import { parse, config } from "dotenv";
 import fs from "fs";
+import cluster from "cluster";
 async function parseEnv(envFile) {
   if (fs.existsSync(envFile)) {
     const content = await fs.promises.readFile(envFile, "utf8");
@@ -88,9 +100,37 @@ async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), w
     close
   };
 }
+async function spawnServerWorker(module, args = [], port = 0, env) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
+  const originalExec = cluster.settings.exec;
+  const originalArgs = cluster.settings.execArgv;
+  try {
+    cluster.settings.exec = module;
+    cluster.settings.execArgv = args;
+    const worker = cluster.fork({ ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` });
+    return new Promise((resolve) => {
+      function ready(message) {
+        if (message === "ready") {
+          worker.off("message", ready);
+          resolve(worker);
+        }
+      }
+      worker.on("message", ready);
+    });
+  } finally {
+    cluster.settings.exec = originalExec;
+    cluster.settings.execArgv = originalArgs;
+  }
+}
 async function waitForServer(port, wait = 0) {
   let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
+  let connection;
+  while (!(connection = await getConnection(port))) {
     if (remaining >= 100) {
       remaining -= 100;
       await sleep(100);
@@ -100,14 +140,16 @@ async function waitForServer(port, wait = 0) {
       );
     }
   }
+  return connection;
 }
-async function isPortInUse(port) {
+async function getConnection(port) {
   return new Promise((resolve) => {
-    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
+    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
       connection.end();
-      resolve(connected);
-    }
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
   });
 }
 async function getAvailablePort() {
@@ -125,20 +167,56 @@ function sleep(ms) {
 // src/adapter/index.ts
 import parseNodeArgs from "parse-node-args";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var defaultEntry = path.join(__dirname, "default-entry");
+var loadDevWorker = path.join(__dirname, "load-dev-worker.mjs");
 function adapter() {
   return {
     name: "base-adapter",
     async getEntryFile() {
-      const entry = path.join(__dirname, "default-entry");
-      return entry;
+      return defaultEntry;
     },
-    async startDev(config2, { port = 3e3, envFile }) {
-      const { root, configFile } = config2;
+    async startDev(entry, config2, options) {
+      const { port = 3e3, envFile } = options;
+      if (entry) {
+        const { nodeArgs } = parseNodeArgs(options.args);
+        let worker;
+        async function start() {
+          const nextWorker = await spawnServerWorker(
+            loadDevWorker,
+            nodeArgs,
+            port,
+            envFile
+          );
+          nextWorker.on("message", (messsage) => {
+            if (messsage === "restart") {
+              start();
+            }
+          }).send({ type: "start", entry, config: config2 });
+          await waitForWorker(nextWorker, port);
+          if (worker) {
+            const prevWorker = worker;
+            let timeout;
+            worker.once("disconnect", () => {
+              clearTimeout(timeout);
+            });
+            worker.send({ type: "shutdown" });
+            worker.disconnect();
+            timeout = setTimeout(() => {
+              prevWorker.kill();
+            }, 2e3);
+          }
+          worker = nextWorker;
+        }
+        await start();
+        return {
+          port,
+          close() {
+            worker.kill();
+          }
+        };
+      }
+      const devServer = await createDevServer(config2);
       envFile && await loadEnv(envFile);
-      const devServer = await createDevServer({
-        root,
-        configFile
-      });
       return new Promise((resolve) => {
         const listener = devServer.middlewares.listen(port, () => {
           const address = listener.address();
@@ -162,8 +240,21 @@ function adapter() {
     }
   };
 }
+async function waitForWorker(worker, port) {
+  return new Promise((resolve) => {
+    function listening(address) {
+      if (address.port === port) {
+        worker.off("listening", listening);
+        resolve();
+      }
+    }
+    worker.on("listening", listening);
+  });
+}
 export {
+  activeDevServers,
   createDevServer,
   createViteDevMiddleware,
+  createViteDevServer,
   adapter as default
 };

package/dist/adapter/load-dev-worker.mjs

@@ -0,0 +1,37 @@
+import { createServer } from "vite";
+
+let activeDevServers;
+
+process
+  .on("message", (message) => {
+    switch (message.type) {
+      case "start":
+        return start(message.entry, message.config);
+      case "shutdown":
+        return shutdown();
+    }
+  })
+  .send("ready");
+
+async function start(entry, config) {
+  let changed = false;
+  const loader = await createServer(config);
+  ({ activeDevServers } = await loader.ssrLoadModule("@marko/run/adapter"));
+  await loader.ssrLoadModule(entry);
+
+  loader.watcher.on("change", (path) => {
+    if (!changed && loader.moduleGraph.getModulesByFile(path)) {
+      changed = true;
+      process.send("restart");
+    }
+  });
+}
+
+function shutdown() {
+  if (activeDevServers) {
+    for (const devServer of activeDevServers) {
+      devServer.ws.send({ type: "full-reload" });
+    }
+    activeDevServers.clear();
+  }
+}

package/dist/cli/index.mjs

@@ -5,7 +5,7 @@ import sade from "sade";
 
 // src/cli/commands.ts
 import path3 from "path";
-import fs4 from "fs";
+import fs3 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { build as viteBuild, resolveConfig } from "vite";
 
@@ -26,84 +26,10 @@ var setExternalAdapterOptions = (viteConfig, value) => setConfig(viteConfig, Ada
 // src/cli/commands.ts
 import { MemoryStore } from "@marko/vite";
 
-// src/vite/utils/server.ts
-import net from "net";
-import cp from "child_process";
-import { parse, config } from "dotenv";
-import fs from "fs";
-async function parseEnv(envFile) {
-  if (fs.existsSync(envFile)) {
-    const content = await fs.promises.readFile(envFile, "utf8");
-    return parse(content);
-  }
-}
-async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), wait = 3e4) {
-  if (port <= 0) {
-    port = await getAvailablePort();
-  }
-  if (typeof env === "string") {
-    env = await parseEnv(env);
-  }
-  const proc = cp.spawn(cmd, args, {
-    cwd,
-    shell: true,
-    stdio: "inherit",
-    windowsHide: true,
-    env: { ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` }
-  });
-  const close = () => {
-    proc.unref();
-    proc.kill();
-  };
-  try {
-    await waitForServer(port, wait);
-  } catch (err) {
-    close();
-    throw err;
-  }
-  return {
-    port,
-    close
-  };
-}
-async function waitForServer(port, wait = 0) {
-  let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
-    if (remaining >= 100) {
-      remaining -= 100;
-      await sleep(100);
-    } else {
-      throw new Error(
-        `site-write: timeout while wating for server to start on port "${port}".`
-      );
-    }
-  }
-}
-async function isPortInUse(port) {
-  return new Promise((resolve) => {
-    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
-      connection.end();
-      resolve(connected);
-    }
-  });
-}
-async function getAvailablePort() {
-  return new Promise((resolve) => {
-    const server = net.createServer().listen(0, () => {
-      const { port } = server.address();
-      server.close(() => resolve(port));
-    });
-  });
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 // src/vite/plugin.ts
 import path2 from "path";
 import crypto from "crypto";
-import fs3 from "fs";
+import fs2 from "fs";
 import glob from "glob";
 import { mergeConfig } from "vite";
 import markoVitePlugin, { FileStore } from "@marko/vite";
@@ -131,7 +57,7 @@ var routeableFileRegex = new RegExp(
 );
 
 // src/vite/routes/walk.ts
-import fs2 from "fs";
+import fs from "fs";
 import path from "path";
 
 // src/vite/utils/ast.ts
@@ -216,7 +142,7 @@ async function preview(entry, cwd, configFile, port, outDir, envFile, args = [])
   };
   return await adapter.startPreview(entryFile, options);
 }
-async function dev(cmd, cwd, configFile, port, envFile, args = []) {
+async function dev(entry, cwd, configFile, port, envFile, args = []) {
   const resolvedConfig = await resolveConfig(
     { root: cwd, configFile, logLevel: "silent" },
     "build"
@@ -227,27 +153,23 @@ async function dev(cmd, cwd, configFile, port, envFile, args = []) {
   if (envFile) {
     envFile = path3.resolve(cwd, envFile);
   }
-  if (cmd) {
-    return await spawnServer(cmd, args, port, envFile, cwd);
-  } else {
-    const adapter = await resolveAdapter2(resolvedConfig);
-    if (!adapter) {
-      throw new Error(
-        "No adapter specified for 'dev' command without custom target"
-      );
-    } else if (!adapter.startDev) {
-      throw new Error(
-        `Adapter '${adapter.name}' does not support 'serve' command`
-      );
-    }
-    const options = {
-      cwd,
-      args,
-      port,
-      envFile
-    };
-    return await adapter.startDev({ root: cwd, configFile }, options);
+  const adapter = await resolveAdapter2(resolvedConfig);
+  if (!adapter) {
+    throw new Error(
+      "No adapter specified for 'dev' command without custom target"
+    );
+  } else if (!adapter.startDev) {
+    throw new Error(
+      `Adapter '${adapter.name}' does not support 'serve' command`
+    );
   }
+  const options = {
+    cwd,
+    args,
+    port,
+    envFile
+  };
+  return await adapter.startDev(entry, { root: cwd, configFile }, options);
 }
 async function build(entry, cwd, configFile, outDir, envFile) {
   var _a;
@@ -308,7 +230,7 @@ async function build(entry, cwd, configFile, outDir, envFile) {
 function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
   for (const ext of extensions) {
     const filePath = path3.join(dir, base + ext);
-    if (fs4.existsSync(filePath)) {
+    if (fs3.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -317,7 +239,7 @@ function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
 async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   if (configFile) {
     const configFilePath = path3.join(dir, configFile);
-    if (!fs4.existsSync(configFilePath)) {
+    if (!fs3.existsSync(configFilePath)) {
       throw new Error(`No config file found at '${configFilePath}'`);
     }
     return configFile;
@@ -330,12 +252,12 @@ async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   }
   return path3.join(__dirname2, "default.config.mjs");
 }
-async function resolveAdapter2(config2) {
-  const options = getExternalPluginOptions(config2);
+async function resolveAdapter2(config) {
+  const options = getExternalPluginOptions(config);
   if (!options) {
     throw new Error("Unable to resolve @marko/run options");
   }
-  return resolveAdapter(config2.root, options);
+  return resolveAdapter(config.root, options);
 }
 
 // src/cli/index.ts
@@ -355,12 +277,12 @@ prog.command("preview [entry]").describe("Start a production-like server for alr
   process.env.NODE_ENV = "production";
   const cwd = process.cwd();
   const args = process.argv.slice(entry ? 4 : 3);
-  const config2 = await getViteConfig(cwd, opts.config);
-  await build(entry, cwd, config2, opts.output, opts.env);
+  const config = await getViteConfig(cwd, opts.config);
+  await build(entry, cwd, config, opts.output, opts.env);
   await preview(
     opts.file,
     cwd,
-    config2,
+    config,
     opts.port,
     opts.output,
     opts.env,
@@ -373,15 +295,15 @@ prog.command("dev [entry]", "", { default: true }).describe("Start development s
 ).example("dev --config vite.config.js").action(async (entry, opts) => {
   const cwd = process.cwd();
   const args = process.argv.slice(entry ? 4 : 3);
-  const config2 = await getViteConfig(cwd, opts.config);
-  await dev(entry, cwd, config2, opts.port, opts.env, args);
+  const config = await getViteConfig(cwd, opts.config);
+  await dev(entry, cwd, config, opts.port, opts.env, args);
 });
 prog.command("build [entry]").describe("Build the application (without serving it)").option(
   "-o, --output",
   "Directory to write built files (default: 'build.outDir' in Vite config)"
 ).example("build --config vite.config.js").action(async (entry, opts) => {
   const cwd = process.cwd();
-  const config2 = await getViteConfig(cwd, opts.config);
-  await build(entry, cwd, config2, opts.ouput, opts.env);
+  const config = await getViteConfig(cwd, opts.config);
+  await build(entry, cwd, config, opts.ouput, opts.env);
 });
 prog.parse(process.argv);

package/dist/runtime/index.d.ts

@@ -1,5 +1,6 @@
-import type { HandlerLike, ParamsObject, Route as AnyRoute, Context as AnyContext } from "./types";
+import type { HandlerLike, ParamsObject, Route as AnyRoute, Context as AnyContext, RuntimeModule } from "./types";
 declare global {
+    var __marko_run__: RuntimeModule;
     namespace MarkoRun {
         const NotHandled: unique symbol;
         const NotMatched: unique symbol;

package/dist/runtime/router.cjs

@@ -25,14 +25,20 @@ __export(router_exports, {
   match: () => match
 });
 module.exports = __toCommonJS(router_exports);
-function notImplemented() {
-  throw new Error(
-    "This should have been replaced by the @marko/run plugin at build/dev time"
-  );
+function fromRuntime(name) {
+  return (...args) => {
+    const runtime = globalThis.__marko_run__;
+    if (!runtime) {
+      throw new Error(
+        "This should have been replaced by the @marko/run plugin at build/dev time"
+      );
+    }
+    return runtime[name](...args);
+  };
 }
-var fetch = notImplemented;
-var match = notImplemented;
-var invoke = notImplemented;
+var fetch = fromRuntime("fetch");
+var match = fromRuntime("match");
+var invoke = fromRuntime("invoke");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   fetch,

package/dist/runtime/router.js

@@ -1,12 +1,18 @@
 // src/runtime/router.ts
-function notImplemented() {
-  throw new Error(
-    "This should have been replaced by the @marko/run plugin at build/dev time"
-  );
+function fromRuntime(name) {
+  return (...args) => {
+    const runtime = globalThis.__marko_run__;
+    if (!runtime) {
+      throw new Error(
+        "This should have been replaced by the @marko/run plugin at build/dev time"
+      );
+    }
+    return runtime[name](...args);
+  };
 }
-var fetch = notImplemented;
-var match = notImplemented;
-var invoke = notImplemented;
+var fetch = fromRuntime("fetch");
+var match = fromRuntime("match");
+var invoke = fromRuntime("invoke");
 export {
   fetch,
   invoke,

package/dist/vite/index.cjs

@@ -680,7 +680,9 @@ function renderRouter(routes, options = {
       `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines("").writeBlockStart(`export function match(method, pathname) {`).writeLines(
+  writer.writeLines(`
+globalThis.__marko_run__ = { match, fetch, invoke };
+    `).writeBlockStart(`export function match(method, pathname) {`).writeLines(
     `if (!pathname) {
     pathname = '/';
   } else if (pathname.charAt(0) !== '/') {
@@ -1812,6 +1814,7 @@ var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
 var import_dotenv = require("dotenv");
 var import_fs3 = __toESM(require("fs"), 1);
+var import_cluster = __toESM(require("cluster"), 1);
 async function parseEnv(envFile) {
   if (import_fs3.default.existsSync(envFile)) {
     const content = await import_fs3.default.promises.readFile(envFile, "utf8");
@@ -1852,7 +1855,8 @@ async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), w
 }
 async function waitForServer(port, wait = 0) {
   let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
+  let connection;
+  while (!(connection = await getConnection(port))) {
     if (remaining >= 100) {
       remaining -= 100;
       await sleep(100);
@@ -1862,16 +1866,21 @@ async function waitForServer(port, wait = 0) {
       );
     }
   }
+  return connection;
 }
-async function isPortInUse(port) {
+async function getConnection(port) {
   return new Promise((resolve) => {
-    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
+    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
       connection.end();
-      resolve(connected);
-    }
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
   });
 }
+async function isPortInUse(port) {
+  return Boolean(await getConnection(port));
+}
 async function getAvailablePort() {
   return new Promise((resolve) => {
     const server = import_net.default.createServer().listen(0, () => {

package/dist/vite/index.js

@@ -643,7 +643,9 @@ function renderRouter(routes, options = {
       `import page${key} from '${virtualFilePrefix}/${markoRunFilePrefix}special__${key}.marko${serverEntryQuery}';`
     );
   }
-  writer.writeLines("").writeBlockStart(`export function match(method, pathname) {`).writeLines(
+  writer.writeLines(`
+globalThis.__marko_run__ = { match, fetch, invoke };
+    `).writeBlockStart(`export function match(method, pathname) {`).writeLines(
     `if (!pathname) {
     pathname = '/';
   } else if (pathname.charAt(0) !== '/') {
@@ -1774,6 +1776,7 @@ import net from "net";
 import cp from "child_process";
 import { parse, config } from "dotenv";
 import fs3 from "fs";
+import cluster from "cluster";
 async function parseEnv(envFile) {
   if (fs3.existsSync(envFile)) {
     const content = await fs3.promises.readFile(envFile, "utf8");
@@ -1814,7 +1817,8 @@ async function spawnServer(cmd, args = [], port = 0, env, cwd = process.cwd(), w
 }
 async function waitForServer(port, wait = 0) {
   let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
+  let connection;
+  while (!(connection = await getConnection(port))) {
     if (remaining >= 100) {
       remaining -= 100;
       await sleep(100);
@@ -1824,16 +1828,21 @@ async function waitForServer(port, wait = 0) {
       );
     }
   }
+  return connection;
 }
-async function isPortInUse(port) {
+async function getConnection(port) {
   return new Promise((resolve) => {
-    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
+    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
       connection.end();
-      resolve(connected);
-    }
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
   });
 }
+async function isPortInUse(port) {
+  return Boolean(await getConnection(port));
+}
 async function getAvailablePort() {
   return new Promise((resolve) => {
     const server = net.createServer().listen(0, () => {

package/dist/vite/types.d.ts

@@ -24,7 +24,7 @@ export interface Adapter {
     pluginOptions?(options: Options): Promise<Options> | Options | undefined;
     viteConfig?(config: UserConfig): Promise<UserConfig> | UserConfig | undefined;
     getEntryFile?(): Promise<string> | string;
-    startDev?(config: InlineConfig, options: StartDevOptions): Promise<SpawnedServer> | SpawnedServer;
+    startDev?(entry: string | undefined, config: InlineConfig, options: StartDevOptions): Promise<SpawnedServer> | SpawnedServer;
     startPreview?(entry: string | undefined, options: StartPreviewOptions): Promise<SpawnedServer> | SpawnedServer;
     buildEnd?(config: ResolvedConfig, routes: Route[], builtEntries: string[], sourceEntries: string[]): Promise<void> | void;
     typeInfo?(writer: (data: string) => void): Promise<string> | string;

package/dist/vite/utils/server.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" />
+import { type Socket } from "net";
+import { type Worker } from "cluster";
 export interface SpawnedServer {
     port: number;
     close(): Promise<void> | void;
@@ -5,6 +8,8 @@ export interface SpawnedServer {
 export declare function parseEnv(envFile: string): Promise<import("dotenv").DotenvParseOutput | undefined>;
 export declare function loadEnv(envFile: string): void;
 export declare function spawnServer(cmd: string, args?: string[], port?: number, env?: string | Record<string, string>, cwd?: string, wait?: number): Promise<SpawnedServer>;
-export declare function waitForServer(port: number, wait?: number): Promise<void>;
+export declare function spawnServerWorker(module: string, args?: string[], port?: number, env?: string | Record<string, string>): Promise<Worker>;
+export declare function waitForServer(port: number, wait?: number): Promise<Socket>;
+export declare function getConnection(port: number): Promise<Socket | null>;
 export declare function isPortInUse(port: number): Promise<boolean>;
 export declare function getAvailablePort(): Promise<number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "The Marko application framework.",
   "license": "MIT",
   "homepage": "https://github.com/marko-js/run/tree/main/packages/run",