nukejs 0.0.28 → 0.0.30

package/README.md

@@ -17,6 +17,7 @@ npm create nuke@latest
 - [Pages & Routing](#pages--routing)
 - [Layouts](#layouts)
 - [Client Components](#client-components)
+- [Web Workers](#web-workers)
 - [State Management](#state-management)
 - [API Routes](#api-routes)
 - [Middleware](#middleware)
@@ -294,6 +295,65 @@ Children and other React elements can be passed as props — NukeJS serializes t
 
 ---
 
+## Web Workers
+
+`"use client"` components can create Web Workers using the standard modern bundler pattern — no manual copying of worker files into `app/public/`, and no extra config:
+
+```ts
+"use client";
+
+function makeParserWorker() {
+  return new Worker(new URL("./parser.worker.ts", import.meta.url), {
+    type: "module",
+  });
+}
+```
+
+Any `new URL("./relative/path", import.meta.url)` reachable from a client component is discovered automatically while NukeJS bundles your app. The referenced file is bundled with esbuild as its own entry point, written out with a content hash in its filename, and the `new URL(...)` call is rewritten in place to point at the emitted file — in both `nuke dev` and `nuke build`, under the same `/__worker/<name>-<hash>.js` URL, so app code never has to branch on mode.
+
+### Workers from installed packages
+
+This also works when the worker lives inside a package you installed, either because the package references its own co-located worker internally:
+
+```ts
+// resolved correctly even though voiceClient.js ships inside node_modules
+new URL("./workers/stt-worker.js", import.meta.url)
+```
+
+or because your own code points at a worker a package exports by subpath:
+
+```ts
+new Worker(
+  new URL("monaco-editor/esm/vs/language/json/json.worker.js", import.meta.url),
+  { type: "module" }
+)
+```
+
+Bare specifiers are resolved through Node's own module resolution (honoring that package's `exports`/`main`), so the correct installed copy is found the same way a real `import` of that specifier would find it.
+
+### Overriding the URL
+
+Nothing here gets in the way of supplying your own worker URL at runtime — that's just a plain string, which is never something this rewrite touches:
+
+```ts
+function makeParserWorker(options: { workerUrls?: { parser?: string } } = {}) {
+  if (options.workerUrls?.parser) {
+    return new Worker(options.workerUrls.parser, { type: "module" });
+  }
+  return new Worker(new URL("./parser.worker.ts", import.meta.url), {
+    type: "module",
+  });
+}
+```
+
+If `options.workerUrls.parser` is set, it's always used. Otherwise the bundled worker is resolved automatically.
+
+### What's still out of reach
+
+Only string literals are resolved — a dynamic path (`new URL(someVariable, import.meta.url)`) can't be, since there's nothing to inspect until the code actually runs. And a worker a package never spells out as a specifier anywhere — no relative path, no subpath export, located via some entirely runtime-only scheme — can't be resolved by any static, build-time plugin, for this or any other bundler.
+
+---
+
 ## State Management
 
 NukeJS ships a lightweight built-in store for sharing state across client components. Because each `"use client"` component is hydrated into its own independent React root, React Context cannot cross component boundaries — the store solves this.
@@ -1336,6 +1396,7 @@ dist/
 ├── static/
 │   ├── __n.js              # NukeJS client runtime (React + NukeJS bundled together)
 │   ├── __client-component/ # Bundled "use client" component files
+│   ├── __worker/            # Auto-discovered Web Worker bundles (see Web Workers)
 │   └── <app/public files>  # Copied from app/public/ at build time
 ├── manifest.json   # Route dispatch table
 └── index.mjs       # HTTP server entry point
@@ -1357,6 +1418,7 @@ The build output goes to `.cloudflare/output/`:
 └── static/
     ├── __n.js                  # NukeJS client runtime
     ├── __client-component/     # Bundled "use client" component files
+    ├── __worker/                # Auto-discovered Web Worker bundles (see Web Workers) — unrelated to _worker.mjs above, which is Cloudflare's own deployment unit
     └── <app/public files>      # Copied from app/public/ at build time
 ```
 

package/dist/app.js

@@ -5,7 +5,7 @@ import { c, log, setDebugLevel, getDebugLevel } from "./logger.js";
 import { loadConfig } from "./config.js";
 import { discoverApiPrefixes, matchApiPrefix, createApiHandler } from "./http-server.js";
 import { loadMiddleware, runMiddleware } from "./middleware-loader.js";
-import { serveReactBundle, serveNukeBundle, serveClientComponentBundle } from "./bundler.js";
+import { serveReactBundle, serveNukeBundle, serveClientComponentBundle, serveWorkerAsset } from "./bundler.js";
 import { serverSideRender } from "./ssr.js";
 import { watchDir, broadcastRestart } from "./hmr.js";
 const isDev = process.env.ENVIRONMENT !== "production";
@@ -67,6 +67,8 @@ const server = http.createServer(async (req, res) => {
         url.slice(20).split("?")[0].replace(".js", ""),
         res
       );
+    if (url.startsWith("/__worker/"))
+      return await serveWorkerAsset(url.slice("/__worker/".length).split("?")[0], res);
     if (matchApiPrefix(url, apiPrefixes))
       return await handleApiRoute(url, req, res);
     return await serverSideRender(url, res, PAGES_DIR, isDev, req);

package/dist/build-common.js

@@ -4,6 +4,7 @@ import { randomBytes } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "url";
 import { build } from "esbuild";
 import { findClientComponentsInTree } from "./component-analyzer.js";
+import { WorkerAssetRegistry, createWorkerUrlPlugin } from "./worker-assets.js";
 const NODE_BUILTINS = [
   "node:*",
   "http",
@@ -871,6 +872,9 @@ async function bundleClientComponents(globalRegistry, pagesDir, staticDir) {
   if (globalRegistry.size === 0) return /* @__PURE__ */ new Map();
   const outDir = path.join(staticDir, "__client-component");
   fs.mkdirSync(outDir, { recursive: true });
+  const workerOutDir = path.join(staticDir, "__worker");
+  const workerRegistry = new WorkerAssetRegistry({ outDir: workerOutDir, minify: true });
+  const workerPlugin = createWorkerUrlPlugin(workerRegistry);
   const entryPoints = {};
   for (const [id, filePath] of globalRegistry) {
     entryPoints[id] = filePath;
@@ -895,10 +899,14 @@ async function bundleClientComponents(globalRegistry, pagesDir, staticDir) {
     define: { "process.env.NODE_ENV": '"production"' },
     entryNames: "[name]",
     // cc_abc123.js (no hash on entries)
-    chunkNames: "__chunks/[hash]"
+    chunkNames: "__chunks/[hash]",
     // __chunks/ABCDEF.js
+    plugins: [workerPlugin]
   });
   console.log(`  bundled   ${globalRegistry.size} client component(s) \u2192 ${path.relative(process.cwd(), outDir)}/`);
+  if (workerRegistry.size > 0) {
+    console.log(`  bundled   ${workerRegistry.size} worker asset(s) \u2192 ${path.relative(process.cwd(), workerOutDir)}/`);
+  }
   const prerendered = /* @__PURE__ */ new Map();
   for (const [id, filePath] of globalRegistry) {
     const ssrTmp = path.join(
@@ -915,7 +923,13 @@ async function bundleClientComponents(globalRegistry, pagesDir, staticDir) {
         jsx: "automatic",
         packages: "external",
         define: { "process.env.NODE_ENV": '"production"' },
-        write: false
+        write: false,
+        // Same registry as Pass 1 — any worker already bundled there is
+        // reused from cache. Keeps this SSR-only bundle's source consistent
+        // with the browser bundle in case any worker-referencing code path
+        // is reachable during prerendering (it also means, if it ever is,
+        // `new URL(...)` won't throw for pointing at a moved temp file).
+        plugins: [workerPlugin]
       });
       fs.writeFileSync(ssrTmp, ssrResult.outputFiles[0].text);
       const { default: Component } = await import(pathToFileURL(ssrTmp).href);

package/dist/bundler.js

@@ -5,9 +5,11 @@ import { fileURLToPath } from "url";
 import { build } from "esbuild";
 import { log } from "./logger.js";
 import { getComponentCache } from "./component-analyzer.js";
+import { WorkerAssetRegistry, createWorkerUrlPlugin } from "./worker-assets.js";
 let reactBundlePromise = null;
 let nukeBundlePromise = null;
 const SPLIT_OUT_DIR = path.join(os.tmpdir(), "nukejs-dev-components");
+const WORKER_OUT_DIR = path.join(os.tmpdir(), "nukejs-dev-workers");
 let splitBuildValid = false;
 let splitBuildPromise = null;
 async function buildAllComponentsSplit() {
@@ -28,6 +30,7 @@ async function buildAllComponentsSplit() {
   }
   fs.mkdirSync(SPLIT_OUT_DIR, { recursive: true });
   log.verbose(`[bundler] Split build: ${clientComponents.size} component(s) \u2192 ${SPLIT_OUT_DIR}`);
+  const workerRegistry = new WorkerAssetRegistry({ outDir: WORKER_OUT_DIR, minify: false });
   await build({
     entryPoints,
     bundle: true,
@@ -49,9 +52,13 @@ async function buildAllComponentsSplit() {
     define: { "process.env.NODE_ENV": '"development"' },
     entryNames: "[name]",
     // cc_abc123.js (stable, no hash)
-    chunkNames: "__chunks/[hash]"
+    chunkNames: "__chunks/[hash]",
     // __chunks/ABCDEF.js
+    plugins: [createWorkerUrlPlugin(workerRegistry)]
   });
+  if (workerRegistry.size > 0) {
+    log.verbose(`[bundler] Bundled ${workerRegistry.size} worker asset(s) \u2192 ${WORKER_OUT_DIR}`);
+  }
   splitBuildValid = true;
   log.verbose("[bundler] Split build complete");
 }
@@ -85,6 +92,18 @@ async function serveClientComponentBundle(componentId, res) {
   res.setHeader("Content-Type", "application/javascript");
   res.end(fs.readFileSync(outPath));
 }
+async function serveWorkerAsset(fileName, res) {
+  const outPath = path.join(WORKER_OUT_DIR, fileName);
+  const base = WORKER_OUT_DIR.endsWith(path.sep) ? WORKER_OUT_DIR : WORKER_OUT_DIR + path.sep;
+  if (!outPath.startsWith(base) || !fs.existsSync(outPath)) {
+    log.error(`Worker asset not found: ${fileName}`);
+    res.statusCode = 404;
+    res.end("Worker asset not found");
+    return;
+  }
+  res.setHeader("Content-Type", "application/javascript");
+  res.end(fs.readFileSync(outPath));
+}
 async function serveReactBundle(res) {
   log.verbose("Bundling React runtime");
   if (!reactBundlePromise) {
@@ -157,5 +176,6 @@ export {
   invalidateSplitBundle,
   serveClientComponentBundle,
   serveNukeBundle,
-  serveReactBundle
+  serveReactBundle,
+  serveWorkerAsset
 };

package/dist/index.d.ts

@@ -9,6 +9,8 @@ export type { RequestContext } from './use-request';
 export { normaliseHeaders, sanitiseHeaders, getRequestStore } from './request-store';
 export { cache } from './cache-store';
 export { default as Link } from './Link';
+export { renderComponent } from './render-component';
+export type { RenderComponentOptions } from './render-component';
 export { setupLocationChangeMonitor, initRuntime } from './bundle';
 export type { RuntimeData } from './bundle';
 export { escapeHtml } from './utils';

package/dist/index.js

@@ -5,6 +5,7 @@ import { useRequest } from "./use-request.js";
 import { normaliseHeaders, sanitiseHeaders, getRequestStore } from "./request-store.js";
 import { cache } from "./cache-store.js";
 import { default as default3 } from "./Link.js";
+import { renderComponent } from "./render-component.js";
 import { setupLocationChangeMonitor, initRuntime } from "./bundle.js";
 import { escapeHtml } from "./utils.js";
 import { ansi, c, log, setDebugLevel, getDebugLevel } from "./logger.js";
@@ -21,6 +22,7 @@ export {
   initRuntime,
   log,
   normaliseHeaders,
+  renderComponent,
   sanitiseHeaders,
   setDebugLevel,
   setupLocationChangeMonitor,

package/dist/render-component.js

@@ -0,0 +1,32 @@
+import { createElement } from "react";
+import { pathToFileURL } from "url";
+import { tsImport } from "tsx/esm/api";
+import path from "path";
+import { renderDocument } from "./ssr.js";
+async function renderComponent(filePath, props = {}, options = {}) {
+  const layoutPaths = options.layoutPaths ?? [];
+  const { default: Component } = await tsImport(pathToFileURL(filePath).href, { parentURL: import.meta.url });
+  let element = createElement(Component, props);
+  for (let i = layoutPaths.length - 1; i >= 0; i--) {
+    const { default: Layout } = await tsImport(pathToFileURL(layoutPaths[i]).href, { parentURL: import.meta.url });
+    element = createElement(Layout, { children: element });
+  }
+  return renderDocument({
+    registryEntryFiles: [filePath, ...layoutPaths],
+    pagesDir: options.pagesDir ?? path.resolve("./app/pages"),
+    element,
+    url: options.url ?? "/",
+    params: options.params,
+    query: options.query,
+    headers: options.headers,
+    isDev: options.isDev ?? process.env.ENVIRONMENT !== "production",
+    // Always false here: the whole point is a real server-rendered
+    // document for crawlers, not just a hydration target. skipClientSSR
+    // exists in renderDocument only for ssr.ts's dev-mode HMR fast path.
+    skipClientSSR: false,
+    defaultTitle: options.title ?? "NukeJS"
+  });
+}
+export {
+  renderComponent
+};

package/dist/ssr.js

@@ -92,34 +92,25 @@ function renderManagedBodyScripts(store) {
   if (bodyScripts.length === 0) return [];
   return ["  <!--n-body-scripts-->", ...bodyScripts.map(renderScriptTag), "  <!--/n-body-scripts-->"];
 }
-async function renderFile(filePath, params, url, pagesDir, isDev, res, req, statusCode, skipClientSSR) {
+async function renderDocument(options) {
+  const {
+    registryEntryFiles,
+    pagesDir,
+    element,
+    url,
+    params = {},
+    query = {},
+    headers = {},
+    isDev = false,
+    skipClientSSR = false,
+    defaultTitle = "NukeJS"
+  } = options;
   const cleanUrl = url.split("?")[0];
-  const searchParams = new URL(url, "http://localhost").searchParams;
-  const queryParams = {};
-  searchParams.forEach((_, k) => {
-    if (!(k in params)) {
-      const all = searchParams.getAll(k);
-      queryParams[k] = all.length > 1 ? all : all[0];
-    }
-  });
-  const mergedParams = { ...queryParams, ...params };
-  const rawHeaders = req?.headers ?? {};
-  const normHeaders = normaliseHeaders(rawHeaders);
-  const safeHeaders = sanitiseHeaders(rawHeaders);
-  const layoutPaths = findLayoutsForRoute(filePath, pagesDir);
-  const { default: PageComponent } = await tsImport(
-    pathToFileURL(filePath).href,
-    { parentURL: import.meta.url }
-  );
-  const wrappedElement = await wrapWithLayouts(
-    createElement(PageComponent, mergedParams),
-    layoutPaths
-  );
+  const normHeaders = normaliseHeaders(headers);
+  const safeHeaders = sanitiseHeaders(headers);
   const registry = /* @__PURE__ */ new Map();
-  for (const [id, p] of findClientComponentsInTree(filePath, pagesDir))
-    registry.set(id, p);
-  for (const layoutPath of layoutPaths)
-    for (const [id, p] of findClientComponentsInTree(layoutPath, pagesDir))
+  for (const entryFile of registryEntryFiles)
+    for (const [id, p] of findClientComponentsInTree(entryFile, pagesDir))
       registry.set(id, p);
   const ctx = { registry, hydrated: /* @__PURE__ */ new Set(), skipClientSSR };
   let appHtml = "";
@@ -128,14 +119,14 @@ async function renderFile(filePath, params, url, pagesDir, isDev, res, req, stat
       url,
       pathname: cleanUrl,
       params,
-      query: queryParams,
+      query,
       headers: normHeaders
     },
     () => runWithCacheStore(() => runWithHtmlStore(async () => {
-      appHtml = await renderElementToHtml(wrappedElement, ctx);
+      appHtml = await renderElementToHtml(element, ctx);
     }))
   );
-  const pageTitle = resolveTitle(store.titleOps, "NukeJS");
+  const pageTitle = resolveTitle(store.titleOps, defaultTitle);
   const headLines = [
     '  <meta charset="utf-8" />',
     '  <meta name="viewport" content="width=device-width, initial-scale=1" />',
@@ -147,13 +138,13 @@ async function renderFile(filePath, params, url, pagesDir, isDev, res, req, stat
     allIds: [...registry.keys()],
     url,
     params,
-    query: queryParams,
+    query,
     headers: safeHeaders,
     debug: toClientDebugLevel(getDebugLevel())
   }).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
   const bodyScriptLines = renderManagedBodyScripts(store);
   const bodyScriptsHtml = bodyScriptLines.length > 0 ? "\n" + bodyScriptLines.join("\n") + "\n" : "";
-  const html = `<!DOCTYPE html>
+  return `<!DOCTYPE html>
 ${openTag("html", store.htmlAttrs)}
 <head>
 ${headLines.join("\n")}
@@ -184,6 +175,38 @@ ${openTag("body", store.bodyAttrs)}
   ${isDev ? '<script type="module" src="/__hmr.js"></script>' : ""}
 ${bodyScriptsHtml}</body>
 </html>`;
+}
+async function renderFile(filePath, params, url, pagesDir, isDev, res, req, statusCode, skipClientSSR) {
+  const searchParams = new URL(url, "http://localhost").searchParams;
+  const queryParams = {};
+  searchParams.forEach((_, k) => {
+    if (!(k in params)) {
+      const all = searchParams.getAll(k);
+      queryParams[k] = all.length > 1 ? all : all[0];
+    }
+  });
+  const mergedParams = { ...queryParams, ...params };
+  const layoutPaths = findLayoutsForRoute(filePath, pagesDir);
+  const { default: PageComponent } = await tsImport(
+    pathToFileURL(filePath).href,
+    { parentURL: import.meta.url }
+  );
+  const wrappedElement = await wrapWithLayouts(
+    createElement(PageComponent, mergedParams),
+    layoutPaths
+  );
+  const html = await renderDocument({
+    registryEntryFiles: [filePath, ...layoutPaths],
+    pagesDir,
+    element: wrappedElement,
+    url,
+    params,
+    query: queryParams,
+    headers: req?.headers ?? {},
+    isDev,
+    skipClientSSR,
+    defaultTitle: "NukeJS"
+  });
   res.statusCode = statusCode;
   res.setHeader("Content-Type", "text/html");
   res.end(html);
@@ -259,5 +282,6 @@ async function serverSideRender(url, res, pagesDir, isDev = false, req) {
   }
 }
 export {
+  renderDocument,
   serverSideRender
 };

package/dist/worker-assets.js

@@ -0,0 +1,151 @@
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { build } from "esbuild";
+import { log } from "./logger.js";
+const WORKER_URL_PREFIX = "/__worker/";
+const NEW_URL_RE = /new\s+URL\s*\(\s*(['"`])([^'"`]+)\1\s*,\s*import\.meta\.url\s*\)/g;
+const RESOLVABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+const URL_SCHEME_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function isCandidateSpecifier(spec) {
+  if (spec.startsWith("/")) return false;
+  if (URL_SCHEME_RE.test(spec)) return false;
+  return true;
+}
+class WorkerAssetRegistry {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  built = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  /** Number of distinct worker assets bundled so far in this registry. */
+  get size() {
+    return this.built.size;
+  }
+  /**
+   * Resolves `rawSpecifier` (e.g. './parser.worker.ts', or a bare package
+   * specifier like 'monaco-editor/esm/.../json.worker.js') against the file
+   * that referenced it, bundling it on first use, and returns the public URL
+   * to substitute into the rewritten `new URL(...)` call.
+   *
+   * Returns null when the specifier isn't a candidate at all (see
+   * isCandidateSpecifier) or doesn't resolve to a real file on disk. The
+   * caller leaves the original expression untouched in that case — this is
+   * the mechanism that keeps non-local / dynamic `new URL(..., import.meta.url)`
+   * usages (including anything not meant to be a worker) working exactly as
+   * before.
+   */
+  async resolve(rawSpecifier, importerPath) {
+    if (!isCandidateSpecifier(rawSpecifier)) return null;
+    const absPath = resolveWorkerSpecifier(importerPath, rawSpecifier);
+    if (!absPath) return null;
+    const cached = this.built.get(absPath);
+    if (cached) return cached.publicUrl;
+    let inflight = this.pending.get(absPath);
+    if (!inflight) {
+      inflight = this.buildOne(absPath);
+      this.pending.set(absPath, inflight);
+    }
+    try {
+      const result = await inflight;
+      return result.publicUrl;
+    } finally {
+      this.pending.delete(absPath);
+    }
+  }
+  async buildOne(absPath) {
+    fs.mkdirSync(this.opts.outDir, { recursive: true });
+    log.verbose(`[worker-assets] bundling ${path.relative(process.cwd(), absPath)}`);
+    const result = await build({
+      entryPoints: [absPath],
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: "es2020",
+      jsx: "automatic",
+      minify: this.opts.minify,
+      write: true,
+      outdir: this.opts.outDir,
+      // esbuild computes [hash] from the output contents, so the filename
+      // — and therefore the emitted URL — changes automatically whenever the
+      // worker's own source (or anything it imports) changes. That's the
+      // "hashing/versioning" the rest of the framework's asset pipeline
+      // already relies on (see chunkNames in bundler.ts / build-common.ts).
+      entryNames: "[name]-[hash]",
+      metafile: true,
+      define: { "process.env.NODE_ENV": this.opts.minify ? '"production"' : '"development"' },
+      conditions: ["module", "browser", "import"]
+    });
+    const outputEntry = Object.entries(result.metafile.outputs).find(([, o]) => o.entryPoint);
+    if (!outputEntry) {
+      throw new Error(`[worker-assets] esbuild produced no output for ${absPath}`);
+    }
+    const outputPath = path.resolve(outputEntry[0]);
+    const publicUrl = WORKER_URL_PREFIX + path.basename(outputPath);
+    const info = { sourcePath: absPath, outputPath, publicUrl };
+    this.built.set(absPath, info);
+    log.verbose(`[worker-assets] ${path.relative(process.cwd(), absPath)} -> ${publicUrl}`);
+    return info;
+  }
+}
+function resolveWorkerSpecifier(importerPath, rawSpecifier) {
+  if (rawSpecifier.startsWith("./") || rawSpecifier.startsWith("../")) {
+    return resolveRelativeWorkerFile(path.dirname(importerPath), rawSpecifier);
+  }
+  return resolvePackageWorkerFile(importerPath, rawSpecifier);
+}
+function resolveRelativeWorkerFile(importerDir, rawSpecifier) {
+  const ext = path.extname(rawSpecifier);
+  const withoutExt = ext ? rawSpecifier.slice(0, -ext.length) : rawSpecifier;
+  const candidates = [rawSpecifier, ...RESOLVABLE_EXTENSIONS.map((e) => withoutExt + e)];
+  const tried = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (tried.has(candidate)) continue;
+    tried.add(candidate);
+    const abs = path.resolve(importerDir, candidate);
+    if (fs.existsSync(abs) && fs.statSync(abs).isFile()) return abs;
+  }
+  return null;
+}
+function resolvePackageWorkerFile(importerPath, rawSpecifier) {
+  try {
+    const resolve = createRequire(importerPath).resolve;
+    const resolved = resolve(rawSpecifier);
+    return fs.existsSync(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
+}
+function createWorkerUrlPlugin(registry) {
+  return {
+    name: "nukejs-worker-url",
+    setup(pluginBuild) {
+      pluginBuild.onLoad({ filter: /\.[jt]sx?$/ }, async (args) => {
+        const source = await fs.promises.readFile(args.path, "utf8");
+        if (!source.includes("import.meta.url")) return null;
+        const matches = [...source.matchAll(NEW_URL_RE)];
+        if (matches.length === 0) return null;
+        let contents = source;
+        for (let i = matches.length - 1; i >= 0; i--) {
+          const match = matches[i];
+          const [full, , rawSpecifier] = match;
+          const publicUrl = await registry.resolve(rawSpecifier, args.path);
+          if (!publicUrl) continue;
+          const start = match.index;
+          const end = start + full.length;
+          const replacement = `new URL(${JSON.stringify(publicUrl)}, import.meta.url)`;
+          contents = contents.slice(0, start) + replacement + contents.slice(end);
+        }
+        if (contents === source) return null;
+        const ext = path.extname(args.path).slice(1);
+        const loader = ext === "ts" || ext === "tsx" || ext === "jsx" ? ext : "js";
+        return { contents, loader, resolveDir: path.dirname(args.path) };
+      });
+    }
+  };
+}
+export {
+  WORKER_URL_PREFIX,
+  WorkerAssetRegistry,
+  createWorkerUrlPlugin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nukejs",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "A minimal, opinionated full-stack React framework on Node.js that server-renders everything and hydrates only interactive parts.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",