@oselvar/sveltekit-add-worker-exports 0.3.3 → 1.0.0

package/README.md

@@ -1,10 +1,20 @@
 # @oselvar/sveltekit-add-worker-exports
 
-A Vite plugin that makes Durable Objects and Workflows work with SvelteKit on Cloudflare, in both dev and production.
+A Vite plugin that makes any class-based Cloudflare Worker export (Durable Objects, Workflows, `WorkerEntrypoint` RPC, voice agents, …) work with SvelteKit on Cloudflare, in both dev and production.
 
-**Build mode:** SvelteKit's `adapter-cloudflare` generates `_worker.js` with only a default export (the fetch handler). Cloudflare Workers requires Durable Object and Workflow classes to be **named exports**. This plugin post-processes the build output to merge your named exports with SvelteKit's default export.
+**Build mode:** SvelteKit's `adapter-cloudflare` generates `_worker.js` with only a default export (the fetch handler). Cloudflare Workers requires class-based bindings (Durable Objects, Workflows, `WorkerEntrypoint`, etc.) to be **named exports**. This plugin post-processes the build output to merge your named exports with SvelteKit's default export.
 
-**Dev mode:** `getPlatformProxy` (used by `adapter-cloudflare` in dev) can't run internal Durable Objects or Workflows. This plugin starts a separate wrangler dev server that runs the real DO/Workflow worker with hot-reload. SvelteKit `+server.ts` handlers call DOs through `platform.env.MY_DO.<rpc>()` as usual — the plugin rewrites those bindings to point at the sidecar via wrangler's dev registry, so cross-worker calls Just Work. Clients can also connect directly to the sidecar via WebSocket on a separate port (see below).
+**Dev mode:** `getPlatformProxy` (used by `adapter-cloudflare` in dev) can't run internal Durable Objects, Workflows, or other class-based bindings. This plugin starts a separate wrangler dev server that runs the real worker with hot-reload. SvelteKit `+server.ts` handlers call bindings through `platform.env.MY_BINDING.<rpc>()` as usual — the plugin rewrites those bindings to point at the sidecar via wrangler's dev registry, so cross-worker calls Just Work. WebSocket clients in dev connect to the sidecar directly on a separate port — see [WebSockets](#websockets) below.
+
+## What this works with
+
+The plugin is binding-agnostic: if Cloudflare resolves it through a named class export plus a `wrangler.jsonc` binding, the plugin handles it. Confirmed working:
+
+- Durable Objects
+- Workflows (`WorkflowEntrypoint`)
+- Voice agents
+
+It should also work with `WorkerEntrypoint` RPC and any future class-based export that follows the same export-plus-binding pattern. The examples below use Durable Objects and Workflows because they're the most common, but the wiring is the same for any class-based entrypoint — export the class from your entry point, declare the binding in `wrangler.jsonc`, and call it via `platform.env.MY_BINDING` in your routes.
 
 ## Install
 
@@ -16,61 +26,17 @@ pnpm add -D @oselvar/sveltekit-add-worker-exports
 
 ## Usage
 
-Create a worker entry point that exports your Durable Object classes and a default fetch handler. The fetch handler is only used by the wrangler dev server — in production, SvelteKit's route handlers handle all requests.
+Create a worker entry point that exports your class-based bindings:
 
 ```typescript
 // src/lib/server/index.ts
 export { MyDurableObject } from './MyDurableObject';
 export { MyWorkflow } from './MyWorkflow';
-export { default } from './devHandler';
 ```
 
 Workflow classes (extending `WorkflowEntrypoint`) are exported the same way as Durable Objects — the plugin merges them into `_worker.js` as named exports. Declare them in `wrangler.jsonc` under `workflows`, and they become available as bindings (e.g. `env.MY_WORKFLOW.create({ params })`) in both dev and production.
 
-Both the dev handler and the production SvelteKit route need to do the same thing: validate the upgrade header and forward the request to a Durable Object. Extract that into a small helper so the two callers stay in sync:
-
-```typescript
-// src/lib/server/forwardWebSocket.ts
-export async function forwardWebSocket<T extends Rpc.DurableObjectBranded | undefined>(
-  request: Request,
-  namespace: DurableObjectNamespace<T>,
-  name: string
-): Promise<Response> {
-  if (request.headers.get('upgrade') !== 'websocket') {
-    return new Response('Expected WebSocket', { status: 426 });
-  }
-  const id = namespace.idFromName(name);
-  return namespace.get(id).fetch(request);
-}
-```
-
-The dev handler parses the URL and delegates. It's only used by the wrangler dev sidecar:
-
-```typescript
-// src/lib/server/devHandler.ts
-import { forwardWebSocket } from './forwardWebSocket';
-
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const match = new URL(request.url).pathname.match(/^\/ws\/(.+)$/);
-    if (!match) return new Response('Not found', { status: 404 });
-    return forwardWebSocket(request, env.MY_DO, match[1]);
-  }
-};
-```
-
-In production, the dev handler is *not* used — SvelteKit serves the same path through a `+server.ts` route, which delegates to the same helper:
-
-```typescript
-// src/routes/ws/[id]/+server.ts
-import { forwardWebSocket } from '$lib/server/forwardWebSocket';
-import type { RequestHandler } from './$types';
-
-export const GET: RequestHandler = ({ params, request, platform }) =>
-  forwardWebSocket(request, platform!.env.MY_DO, params.id);
-```
-
-Now any change to the upgrade-and-forward logic (auth, rate-limiting, response shape) lives in one place and applies to both dev and production.
+If clients need to talk directly to the dev sidecar over HTTP (e.g. WebSockets), also export a default fetch handler — see [WebSockets](#websockets) below.
 
 Add the plugin to your `vite.config.ts` **after** `sveltekit()`:
 
@@ -104,36 +70,11 @@ export default {
 };
 ```
 
-### Dev mode: connecting to Durable Objects
-
-In dev mode, the plugin starts a wrangler dev server on a separate port and injects `__DEV_WORKER_PORT__` as a compile-time constant. Use it to connect your client:
-
-```typescript
-import { dev } from '$app/environment';
+The plugin auto-discovers your `wrangler.jsonc` (or `wrangler.toml`) and reads bindings, workflows, migrations, and compatibility settings from it. It overrides only the `main` entry point to point at your source entry.
 
-let wsUrl: string;
-if (dev) {
-  wsUrl = `ws://${window.location.hostname}:${__DEV_WORKER_PORT__}/ws/${id}`;
-} else {
-  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-  wsUrl = `${protocol}//${window.location.host}/ws/${id}`;
-}
-const ws = new WebSocket(wsUrl);
-```
+### Calling Workflows
 
-Add the type declaration to your `src/app.d.ts`:
-
-```typescript
-declare global {
-  const __DEV_WORKER_PORT__: number;
-}
-```
-
-The plugin auto-discovers your `wrangler.jsonc` (or `wrangler.toml`) and reads DO bindings, workflows, migrations, and compatibility settings from it. It overrides only the `main` entry point to point at your source entry.
-
-### Dev mode: calling Workflows
-
-`+server.ts` calls workflows the same way it does in production:
+`+server.ts` calls workflows the same way in dev and production:
 
 ```typescript
 export const POST: RequestHandler = async ({ params, request, platform }) => {
@@ -149,14 +90,14 @@ The sidecar runs the real `WorkflowEntrypoint` class; calls reach it via the `sc
 
 ### Testing the production build locally
 
-`vite dev` exercises the dev handler via the wrangler-dev sidecar; it does *not* exercise your `+server.ts` route or the merged `_worker.js`. To verify the production wiring (named DO exports + SvelteKit routes in the same worker), run wrangler against the build output:
+`vite dev` exercises your code via the wrangler-dev sidecar; it does *not* exercise the merged `_worker.js`. To verify the production wiring (named class exports + SvelteKit routes in the same worker), run wrangler against the build output:
 
 ```bash
 pnpm build              # produces .svelte-kit/cloudflare/_worker.js with merged exports
 pnpm wrangler dev       # uses wrangler.jsonc → main: .svelte-kit/cloudflare/_worker.js
 ```
 
-This serves the exact bundle that gets deployed, with local Durable Object storage. Connect a WebSocket client to `ws://localhost:8787/ws/<id>` and confirm you get a `101 Switching Protocols` response — that proves the request flowed through the SvelteKit `+server.ts` and into your DO.
+This serves the exact bundle that gets deployed, with local Durable Object storage. Exercise whichever route calls your binding (HTTP, WebSocket, whatever your app uses) and confirm the response — that proves the request flowed through the SvelteKit `+server.ts` and into your class.
 
 A handy shortcut is to add a `preview` script to `package.json`:
 
@@ -170,6 +111,109 @@ A handy shortcut is to add a `preview` script to `package.json`:
 
 > Note: `vite preview` is *not* suitable here — it only serves static assets and cannot run Durable Objects. Always use `wrangler dev` to preview the production worker.
 
+## Scheduled, queue, email, tail handlers
+
+Cloudflare invokes non-fetch handlers (`scheduled`, `queue`, `email`, `tail`, `trace`) as methods on the worker's default export, not as named exports. Put them on the `default` export of your entry point and the plugin merges them onto the production worker's default alongside SvelteKit's fetch handler:
+
+```typescript
+// src/lib/server/index.ts
+export { MyDurableObject } from './MyDurableObject';
+export default {
+  async scheduled(event: ScheduledEvent, env: Env, ctx: ExecutionContext) {
+    // runs from the cron triggers in wrangler.jsonc
+  }
+};
+```
+
+If you also need a dev-only `fetch` (e.g. for WebSocket upgrades), put it on the same default — the plugin keeps the non-`fetch` handlers and drops `fetch` in production. See [WebSockets](#websockets) below for the full shape.
+
+### Firing scheduled in dev
+
+Wrangler dev never auto-fires crons — `triggers.crons` in `wrangler.jsonc` is only honored on the real Cloudflare edge. The plugin enables `testScheduled` on the sidecar so you can invoke the handler manually:
+
+```bash
+curl 'http://localhost:8787/__scheduled?cron=*+*+*+*+*'
+```
+
+The `cron` query parameter (URL-encoded — `+` instead of spaces) is what gets passed to your handler as `event.cron`. Stdout from the sidecar lands in the vite terminal.
+
+## WebSockets
+
+`vite dev` doesn't proxy WebSocket upgrades to the wrangler-dev sidecar, so in dev mode the browser needs to connect to the sidecar directly. The plugin exposes the sidecar's port as a compile-time constant `__DEV_WORKER_PORT__` for exactly this.
+
+The pattern: one helper handles the upgrade-and-forward, called from both the dev sidecar's fetch handler and the production `+server.ts` route, so both code paths stay in sync.
+
+```typescript
+// src/lib/server/forwardWebSocket.ts
+export async function forwardWebSocket<T extends Rpc.DurableObjectBranded | undefined>(
+  request: Request,
+  namespace: DurableObjectNamespace<T>,
+  name: string
+): Promise<Response> {
+  if (request.headers.get('upgrade') !== 'websocket') {
+    return new Response('Expected WebSocket', { status: 426 });
+  }
+  const id = namespace.idFromName(name);
+  return namespace.get(id).fetch(request);
+}
+```
+
+Put a `fetch` on the entry's default export so the dev sidecar can receive the direct connection:
+
+```typescript
+// src/lib/server/index.ts
+import { forwardWebSocket } from './forwardWebSocket';
+
+export { MyDurableObject } from './MyDurableObject';
+export { MyWorkflow } from './MyWorkflow';
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    const match = new URL(request.url).pathname.match(/^\/ws\/(.+)$/);
+    if (!match) return new Response('Not found', { status: 404 });
+    return forwardWebSocket(request, env.MY_DO, match[1]);
+  }
+};
+```
+
+In production this `fetch` is dropped (SvelteKit owns request handling — the plugin's merge strips it). The same path is served through a `+server.ts` route that delegates to the same helper:
+
+```typescript
+// src/routes/ws/[id]/+server.ts
+import { forwardWebSocket } from '$lib/server/forwardWebSocket';
+import type { RequestHandler } from './$types';
+
+export const GET: RequestHandler = ({ params, request, platform }) =>
+  forwardWebSocket(request, platform!.env.MY_DO, params.id);
+```
+
+Any change to the upgrade-and-forward logic (auth, rate-limiting, response shape) now lives in one place and applies to both dev and production.
+
+### Connecting from the client
+
+Use `__DEV_WORKER_PORT__` to pick between the sidecar (dev) and the SvelteKit route (production):
+
+```typescript
+import { dev } from '$app/environment';
+
+let wsUrl: string;
+if (dev) {
+  wsUrl = `ws://${window.location.hostname}:${__DEV_WORKER_PORT__}/ws/${id}`;
+} else {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  wsUrl = `${protocol}//${window.location.host}/ws/${id}`;
+}
+const ws = new WebSocket(wsUrl);
+```
+
+Add the type declaration to your `src/app.d.ts`:
+
+```typescript
+declare global {
+  const __DEV_WORKER_PORT__: number;
+}
+```
+
 ## Options
 
 | Option | Type | Required | Default | Description |
@@ -187,11 +231,14 @@ The plugin runs in the `closeBundle` hook (after SvelteKit's adapter has generat
 
 1. Bundles your `entryPoint` with esbuild into `_extra_exports.js`
 2. Renames the original `_worker.js` to `_sveltekit_worker.js`
-3. Creates a new `_worker.js` that re-exports both:
+3. Creates a new `_worker.js` that re-exports the named exports and merges the entry's `default` handlers (`scheduled`, `queue`, `email`, …) onto the SvelteKit default:
 
 ```javascript
-export { default } from './_sveltekit_worker.js';
+import sveltekitWorker from './_sveltekit_worker.js';
+import * as extra from './_extra_exports.js';
 export * from './_extra_exports.js';
+const { fetch: _ignored, ...extraHandlers } = extra.default ?? {};
+export default { ...sveltekitWorker, ...extraHandlers };
 ```
 
 The operation is idempotent -- if `_sveltekit_worker.js` already exists, the plugin skips.
@@ -229,7 +276,19 @@ Note: the `.types-worker-wrangler.jsonc` file is generated when the dev server s
 
 ## Why this exists
 
-SvelteKit's adapter-cloudflare does not support named exports from the worker entry point ([sveltejs/kit#1712](https://github.com/sveltejs/kit/issues/1712)). Additionally, `getPlatformProxy` (used for local dev) cannot run internal Durable Objects because it uses an empty worker script.
+SvelteKit's adapter-cloudflare does not support named exports from the worker entry point ([sveltejs/kit#1712](https://github.com/sveltejs/kit/issues/1712)) — which blocks every class-based Cloudflare binding, not just Durable Objects. Additionally, `getPlatformProxy` (used for local dev) cannot run internal class-based bindings because it uses an empty worker script.
+
+## When this plugin can be retired
+
+This plugin is a stopgap. The single blocker for retirement is [sveltejs/kit#15627](https://github.com/sveltejs/kit/pull/15627) — which replaces `adapter-cloudflare`'s custom build with `@cloudflare/vite-plugin`. Open as of writing. Closes [#1712](https://github.com/sveltejs/kit/issues/1712), [#10496](https://github.com/sveltejs/kit/issues/10496), [#13692](https://github.com/sveltejs/kit/issues/13692), [#2963](https://github.com/sveltejs/kit/issues/2963), [#13300](https://github.com/sveltejs/kit/issues/13300), [#1519](https://github.com/sveltejs/kit/issues/1519).
+
+Once that PR lands, `@cloudflare/vite-plugin` handles everything this plugin does, natively:
+
+- **Build:** the plugin bundles a single worker entry that exports `default` + named classes directly — no `_worker.js` post-processing, no second esbuild pass to merge exports.
+- **Dev:** Durable Objects and Workflows run in the same worker as SvelteKit on real workerd, hot-reloaded — no sidecar via `unstable_startWorker`, no platform-proxy `script_name` rewrite, no separate WebSocket port, no dev registry routing.
+- **Types:** `wrangler types` resolves typed bindings (`DurableObjectNamespace<MyDO>`) from the user entry, no `.types-worker-wrangler.jsonc` indirection.
+
+Side note: [cloudflare/workers-sdk#14013](https://github.com/cloudflare/workers-sdk/pull/14013) introduces an experimental `cloudflare.config.ts` flow (typed `exports` API) where the Durable Object branch currently throws `"Durable Object exports are not currently supported."` (see [`convert.ts`](https://github.com/cloudflare/workers-sdk/blob/main/packages/config/src/convert.ts)) and Workflows are commented out. This is a separate, opt-in config surface — the standard `wrangler.jsonc` path that kit#15627 uses already supports DO and Workflow named exports, so this limitation does **not** gate retirement.
 
 ## License
 

package/dist/index.js

@@ -23,20 +23,12 @@
 import { build } from 'esbuild';
 import { existsSync } from 'node:fs';
 import { access, readFile, rename, writeFile, unlink } from 'node:fs/promises';
+import { builtinModules as NODE_BUILTINS } from 'node:module';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
+import { getNodeCompat } from 'miniflare';
 const DEFAULT_DEV_PORT = 8787;
-const NODE_BUILTINS = [
-    'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console',
-    'constants', 'crypto', 'dgram', 'diagnostics_channel', 'dns', 'domain',
-    'events', 'fs', 'fs/promises', 'http', 'http2', 'https', 'inspector',
-    'module', 'net', 'os', 'path', 'path/posix', 'path/win32', 'perf_hooks',
-    'process', 'punycode', 'querystring', 'readline', 'repl', 'stream',
-    'stream/consumers', 'stream/promises', 'stream/web', 'string_decoder',
-    'sys', 'timers', 'timers/promises', 'tls', 'trace_events', 'tty', 'url',
-    'util', 'util/types', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib'
-];
 /**
  * Mirrors wrangler's internal getRegistryPath() — wrangler doesn't export it.
  * Workers register themselves under this path so cross-worker `script_name`
@@ -117,9 +109,22 @@ function buildPlugin(options) {
                 ],
                 outfile: exportsPath
             });
-            // Rename original worker and create merged entry point
+            // Rename original worker and create merged entry point.
+            //
+            // `export *` re-exports named exports only, so class-based bindings
+            // (DOs, Workflows, WorkerEntrypoint) from `_extra_exports.js` flow
+            // through. Non-fetch handlers (scheduled, queue, email, tail, trace)
+            // live on the user entry's `default` export — Cloudflare invokes
+            // them as methods on the worker's default object, not as named
+            // exports — so we spread them onto the SvelteKit default. `fetch`
+            // is dropped from the user default because SvelteKit owns request
+            // handling in production.
             await rename(workerPath, sveltekitPath);
-            await writeFile(workerPath, `export { default } from './_sveltekit_worker.js';\nexport * from './_extra_exports.js';\n`);
+            await writeFile(workerPath, `import sveltekitWorker from './_sveltekit_worker.js';\n` +
+                `import * as extra from './_extra_exports.js';\n` +
+                `export * from './_extra_exports.js';\n` +
+                `const { fetch: _ignored, ...extraHandlers } = extra.default ?? {};\n` +
+                `export default { ...sveltekitWorker, ...extraHandlers };\n`);
         }
     };
 }
@@ -147,15 +152,30 @@ function devPlugin(options) {
         async configureServer(server) {
             const { unstable_startWorker } = await import('wrangler');
             const rawJson = await readRawConfig();
-            const sidecarName = `${parseJsonc(rawJson).name ?? 'sveltekit'}-dev-worker`;
+            const baseConfig = parseJsonc(rawJson);
+            const sidecarName = `${baseConfig.name ?? 'sveltekit'}-dev-worker`;
+            // When CLOUDFLARE_ENV is set, wrangler suffixes the registered
+            // worker name with `-${env}` (see appendEnvName in wrangler), so
+            // cross-worker `script_name` lookups must use the suffixed name.
+            // We don't suffix `devConfig.name` itself — wrangler does that
+            // based on CLOUDFLARE_ENV when starting the sidecar.
+            const envName = process.env.CLOUDFLARE_ENV;
+            const registeredSidecarName = envName ? `${sidecarName}-${envName}` : sidecarName;
             // Copy the raw config and override main, name, and dev port
-            const devConfig = parseJsonc(rawJson);
+            const devConfig = structuredClone(baseConfig);
             devConfig.name = sidecarName;
             devConfig.main = options.entryPoint;
             devConfig.dev = { ...devConfig.dev, port: devPort };
             delete devConfig.assets;
+            // Serialised dev config is reused verbatim as the `wrangler types`
+            // config — the user can run `wrangler types --config
+            // .types-worker-wrangler.jsonc` to get typed bindings like
+            // DurableObjectNamespace<EchoDO> resolved from the source entry.
+            const devConfigJson = JSON.stringify(devConfig, null, '\t');
             tempConfigPath = resolve('.dev-worker-wrangler.jsonc');
-            await writeFile(tempConfigPath, JSON.stringify(devConfig, null, '\t'));
+            typesConfigPath = resolve('.types-worker-wrangler.jsonc');
+            await writeFile(tempConfigPath, devConfigJson);
+            await writeFile(typesConfigPath, devConfigJson);
             // Write a wrangler config for adapter-cloudflare's getPlatformProxy
             // (used by vite dev for platform.env). It can't run internal DOs or
             // Workflows itself -- those are served by the sidecar above. Rewrite
@@ -163,30 +183,32 @@ function devPlugin(options) {
             // (script_name pointing at the sidecar) so platform.env.MY_DO and
             // platform.env.MY_WORKFLOW calls in +server.ts reach the sidecar via
             // the wrangler dev registry.
-            const proxyConfig = parseJsonc(rawJson);
-            if (proxyConfig.durable_objects?.bindings) {
-                proxyConfig.durable_objects.bindings = proxyConfig.durable_objects.bindings.map((b) => b.script_name ? b : { ...b, script_name: sidecarName });
+            const proxyConfig = structuredClone(baseConfig);
+            // Wrangler does not merge per-env `durable_objects`/`workflows`/
+            // `migrations` arrays with the top-level — the selected env wholly
+            // overrides them. So we patch only the scope wrangler will actually
+            // use: top-level when no env, env[envName] when CLOUDFLARE_ENV is set.
+            const activeScope = envName ? proxyConfig.env?.[envName] : proxyConfig;
+            if (envName && !activeScope) {
+                throw new Error(`CLOUDFLARE_ENV="${envName}" but no \`env.${envName}\` block in the wrangler config`);
             }
-            if (Array.isArray(proxyConfig.workflows)) {
-                proxyConfig.workflows = proxyConfig.workflows.map((w) => w.script_name ? w : { ...w, script_name: sidecarName });
+            if (activeScope.durable_objects?.bindings) {
+                activeScope.durable_objects.bindings = activeScope.durable_objects.bindings.map((b) => b.script_name ? b : { ...b, script_name: registeredSidecarName });
             }
-            delete proxyConfig.migrations;
+            if (Array.isArray(activeScope.workflows)) {
+                activeScope.workflows = activeScope.workflows.map((w) => w.script_name ? w : { ...w, script_name: registeredSidecarName });
+            }
+            delete activeScope.migrations;
             proxyConfigPath = resolve('.platform-proxy-wrangler.jsonc');
             await writeFile(proxyConfigPath, JSON.stringify(proxyConfig, null, '\t'));
-            // A third config used only by `wrangler types`. Identical to the dev
-            // config but kept separate so the user can run `wrangler types
-            // --config .types-worker-wrangler.jsonc` to get typed bindings like
-            // DurableObjectNamespace<EchoDO> resolved from the source entry.
-            const typesConfig = parseJsonc(rawJson);
-            typesConfig.name = sidecarName;
-            typesConfig.main = options.entryPoint;
-            typesConfig.dev = { ...typesConfig.dev, port: devPort };
-            delete typesConfig.assets;
-            typesConfigPath = resolve('.types-worker-wrangler.jsonc');
-            await writeFile(typesConfigPath, JSON.stringify(typesConfig, null, '\t'));
             worker = await unstable_startWorker({
                 config: tempConfigPath,
-                dev: { registry: getWranglerRegistryPath() },
+                // `testScheduled` mounts a `/__scheduled` endpoint on the sidecar
+                // so cron handlers can be invoked manually in dev — wrangler dev
+                // never auto-fires crons. Curl
+                // `http://localhost:<devPort>/__scheduled?cron=*+*+*+*+*` to
+                // trigger your `scheduled` handler.
+                dev: { registry: getWranglerRegistryPath(), testScheduled: true },
                 build: {
                     nodejsCompatMode: (parsedConfig) => getNodejsCompatMode(parsedConfig.compatibility_date, parsedConfig.compatibility_flags)
                 }
@@ -219,23 +241,11 @@ async function exists(path) {
     }
 }
 /**
- * Mirrors miniflare's `getNodeCompat` mode resolution. wrangler's
- * `unstable_startWorker` does not derive this from the config flags
- * automatically — without it, wrangler falls back to the legacy nodejs
- * compat plugin and warns about `node:*` imports even when
+ * wrangler's `unstable_startWorker` does not derive this from the config
+ * flags automatically — without it, wrangler falls back to the legacy
+ * nodejs compat plugin and warns about `node:*` imports even when
  * `nodejs_compat` is enabled.
  */
 function getNodejsCompatMode(compatibilityDate, compatibilityFlags = []) {
-    const hasCompat = compatibilityFlags.includes('nodejs_compat');
-    const hasCompatV2 = compatibilityFlags.includes('nodejs_compat_v2');
-    const hasNoCompatV2 = compatibilityFlags.includes('no_nodejs_compat_v2');
-    const hasAls = compatibilityFlags.includes('nodejs_als');
-    const date = compatibilityDate ?? '2000-01-01';
-    if (hasCompatV2 || (hasCompat && date >= '2024-09-23' && !hasNoCompatV2))
-        return 'v2';
-    if (hasCompat)
-        return 'v1';
-    if (hasAls)
-        return 'als';
-    return null;
+    return getNodeCompat(compatibilityDate, [...compatibilityFlags]).mode;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oselvar/sveltekit-add-worker-exports",
-	"version": "0.3.3",
+	"version": "1.0.0",
 	"description": "Vite plugin that adds Durable Object and Workflow exports to SvelteKit Cloudflare workers",
 	"type": "module",
 	"publishConfig": {
@@ -10,10 +10,6 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
-		},
-		"./hooks": {
-			"types": "./dist/hooks.d.ts",
-			"import": "./dist/hooks.js"
 		}
 	},
 	"files": [