@oselvar/sveltekit-add-worker-exports 0.2.0 → 0.3.1

package/README.md

@@ -4,7 +4,7 @@ A Vite plugin that makes Durable Objects and Workflows work with SvelteKit on Cl
 
 **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.
 
-**Dev mode:** `getPlatformProxy` (used by `adapter-cloudflare` in dev) can't run internal Durable Objects. This plugin starts a separate wrangler dev server that runs the real DO worker with hot-reload. Clients connect directly to it via WebSocket on a separate port.
+**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).
 
 ## Install
 
@@ -87,7 +87,7 @@ export default defineConfig({
 });
 ```
 
-Point `adapter-cloudflare`'s platform proxy at the generated `.platform-proxy-wrangler.jsonc`. This is a copy of your wrangler config with internal Durable Object bindings, Workflows, and migrations stripped — those are served by the dev sidecar on a separate port, and `getPlatformProxy` would otherwise log warnings about classes it can't load:
+Point `adapter-cloudflare`'s platform proxy at the generated `.platform-proxy-wrangler.jsonc`. The plugin writes this file with internal Durable Object bindings rewritten to cross-worker form (each gets a `script_name` pointing at the sidecar). Workflows can't survive `getPlatformProxy` (wrangler unconditionally deletes them), so the plugin replaces them with a service binding pointing at the sidecar; a small SvelteKit hook synthesizes the missing `Workflow` API on top of that bridge — see [Dev mode: calling Workflows](#dev-mode-calling-workflows) below. Without this config path, `getPlatformProxy` would try to run the DO classes itself and warn that it can't:
 
 ```javascript
 // svelte.config.js
@@ -129,7 +129,41 @@ declare global {
 }
 ```
 
-The plugin auto-discovers your `wrangler.jsonc` (or `wrangler.toml`) and reads DO bindings, migrations, and compatibility settings from it. It overrides only the `main` entry point to use your source file instead of the SvelteKit build output.
+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 use a generated wrapper (in `node_modules/.cache/sveltekit-add-worker-exports/`) that re-exports your classes and adds the workflow bridge routes.
+
+### Dev mode: calling Workflows
+
+Workflow bindings can't be passed through `getPlatformProxy` — wrangler unconditionally strips them ([source](https://github.com/cloudflare/workers-sdk/blob/main/packages/wrangler/src/api/integrations/platform/index.ts)). The plugin works around this by adding a service binding to the sidecar and shipping a SvelteKit `Handle` that synthesizes `Workflow`-shaped objects on `platform.env`.
+
+Wire it up in `src/hooks.server.ts`:
+
+```typescript
+export { handle } from '@oselvar/sveltekit-add-worker-exports/hooks';
+```
+
+If you already have a `handle`, compose with `sequence`:
+
+```typescript
+import { sequence } from '@sveltejs/kit/hooks';
+import { handle as sweHandle } from '@oselvar/sveltekit-add-worker-exports/hooks';
+import { handle as myHandle } from './my-handle';
+
+export const handle = sequence(sweHandle, myHandle);
+```
+
+After that, `+server.ts` can call workflows the same way it does in production:
+
+```typescript
+export const POST: RequestHandler = async ({ params, request, platform }) => {
+  const userMessage = await request.text();
+  const instance = await platform!.env.MY_WORKFLOW.create({
+    params: { ... }
+  });
+  return new Response(instance.id);
+};
+```
+
+In production the hook is a no-op — it reads its config from runtime globals that only the dev plugin sets, and `platform.env.MY_WORKFLOW` is the real Cloudflare binding.
 
 ### Testing the production build locally
 
@@ -191,10 +225,10 @@ The plugin reads your wrangler config, creates a temporary config with `main` po
 
 ### Generating typed bindings
 
-The dev plugin creates a temporary `.dev-worker-wrangler.jsonc` with `main` pointing to your source entry point. You can use this to generate fully generic Cloudflare types:
+The dev plugin creates a temporary `.types-worker-wrangler.jsonc` with `main` pointing to your source entry point. Use it to generate fully generic Cloudflare types:
 
 ```bash
-wrangler types --config .dev-worker-wrangler.jsonc
+wrangler types --config .types-worker-wrangler.jsonc
 ```
 
 This produces typed DO bindings like `DurableObjectNamespace<MyDurableObject>` instead of the untyped `DurableObjectNamespace` you get from the default `wrangler.jsonc` (whose `main` points to the SvelteKit build output, which doesn't exist during dev).
@@ -204,12 +238,12 @@ Add this to your `package.json` scripts for convenience:
 ```json
 {
   "scripts": {
-    "types": "wrangler types --config .dev-worker-wrangler.jsonc"
+    "types": "wrangler types --config .types-worker-wrangler.jsonc"
   }
 }
 ```
 
-Note: the `.dev-worker-wrangler.jsonc` file is generated when the dev server starts. Run `pnpm dev` at least once before running `wrangler types`.
+Note: the `.types-worker-wrangler.jsonc` file is generated when the dev server starts. Run `pnpm dev` at least once before running `wrangler types`. (The plugin also writes `.dev-worker-wrangler.jsonc` for the runtime sidecar, but its `main` points at a generated bridge wrapper in `node_modules/.cache/`, which can't be used for type generation — wrangler doesn't follow `export *` re-exports out of node_modules.)
 
 ## Why this exists
 

package/dist/bridge/dev-handler.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Workerd-side bridge handler. Bundled into the dev sidecar by wrangler via
+ * the cache wrapper at `node_modules/.cache/sveltekit-add-worker-exports/`.
+ *
+ * The wrapper imports `createBridgeFetch` from this file and uses it as the
+ * default fetch handler. Routes `/__swe/wf/*` are handled here; anything else
+ * delegates to the user's own default fetch handler.
+ *
+ * This file is part of the workflow-bridge fallback that exists because
+ * `getPlatformProxy()` in unpatched wrangler/miniflare strips workflow
+ * bindings. Once the upstream patch lands (cloudflare/workers-sdk#7459),
+ * the entire `src/bridge/` directory can be deleted.
+ */
+type CtxLike = {
+    waitUntil(promise: Promise<unknown>): void;
+};
+type UserFetch = (request: Request, env: unknown, ctx: CtxLike) => Promise<Response> | Response;
+export interface BridgeOptions {
+    workflowBindings: readonly string[];
+    userFetch?: UserFetch;
+}
+/**
+ * Returns a `fetch` handler that intercepts `/__swe/wf/*` and forwards
+ * everything else to `userFetch`.
+ */
+export declare function createBridgeFetch(options: BridgeOptions): (request: Request, env: unknown, ctx: CtxLike) => Promise<Response>;
+export {};

package/dist/bridge/dev-handler.js

@@ -0,0 +1,88 @@
+/**
+ * Workerd-side bridge handler. Bundled into the dev sidecar by wrangler via
+ * the cache wrapper at `node_modules/.cache/sveltekit-add-worker-exports/`.
+ *
+ * The wrapper imports `createBridgeFetch` from this file and uses it as the
+ * default fetch handler. Routes `/__swe/wf/*` are handled here; anything else
+ * delegates to the user's own default fetch handler.
+ *
+ * This file is part of the workflow-bridge fallback that exists because
+ * `getPlatformProxy()` in unpatched wrangler/miniflare strips workflow
+ * bindings. Once the upstream patch lands (cloudflare/workers-sdk#7459),
+ * the entire `src/bridge/` directory can be deleted.
+ */
+/**
+ * Returns a `fetch` handler that intercepts `/__swe/wf/*` and forwards
+ * everything else to `userFetch`.
+ */
+export function createBridgeFetch(options) {
+    const bindings = new Set(options.workflowBindings);
+    return async (request, env, ctx) => {
+        const url = new URL(request.url);
+        if (url.pathname.startsWith('/__swe/wf/')) {
+            return handleWf(url.pathname.slice('/__swe/wf/'.length), request, env, bindings);
+        }
+        if (options.userFetch) {
+            return options.userFetch(request, env, ctx);
+        }
+        return new Response('Not found', { status: 404 });
+    };
+}
+async function handleWf(rest, request, env, bindings) {
+    const parts = rest.split('/').map(decodeURIComponent);
+    const [binding, op, ...tail] = parts;
+    if (!binding || !bindings.has(binding)) {
+        return new Response('unknown workflow binding: ' + binding, { status: 404 });
+    }
+    const wf = env[binding];
+    if (!wf) {
+        return new Response('binding ' + binding + ' missing on sidecar', { status: 500 });
+    }
+    try {
+        if (op === 'create' && request.method === 'POST') {
+            const opts = await request.json();
+            const inst = await wf.create(opts);
+            return Response.json({ id: inst.id });
+        }
+        if (op === 'createBatch' && request.method === 'POST') {
+            const batch = (await request.json());
+            const insts = await wf.createBatch(batch);
+            return Response.json(insts.map((i) => ({ id: i.id })));
+        }
+        if (op === 'get' && tail.length === 1) {
+            const inst = await wf.get(tail[0]);
+            return Response.json({ id: inst.id });
+        }
+        if (op === 'instance' && tail.length === 2) {
+            const [id, method] = tail;
+            const inst = await wf.get(id);
+            switch (method) {
+                case 'pause':
+                    await inst.pause();
+                    return new Response(null, { status: 204 });
+                case 'resume':
+                    await inst.resume();
+                    return new Response(null, { status: 204 });
+                case 'terminate':
+                    await inst.terminate();
+                    return new Response(null, { status: 204 });
+                case 'restart':
+                    await inst.restart();
+                    return new Response(null, { status: 204 });
+                case 'status':
+                    return Response.json(await inst.status());
+                case 'sendEvent': {
+                    const body = (await request.json());
+                    await inst.sendEvent(body);
+                    return new Response(null, { status: 204 });
+                }
+            }
+            return new Response('unknown method: ' + method, { status: 404 });
+        }
+        return new Response('unknown op: ' + op, { status: 404 });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return new Response('error: ' + message, { status: 500 });
+    }
+}

package/dist/bridge/runtime-hook.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SvelteKit `Handle` that injects fake Workflow bindings into `event.platform.env`
+ * during `vite dev`. In production this is a no-op.
+ *
+ * Why: wrangler's `getPlatformProxy` (used by `adapter-cloudflare` in dev) deletes
+ * workflow bindings before they reach miniflare, so `+server.ts` can't call
+ * `platform.env.MY_WORKFLOW.create(...)` directly. The companion vite plugin
+ * exposes a service binding (`__SWE_BRIDGE`) that fetches into a sidecar wrangler
+ * dev worker which has the real workflow binding. This hook synthesizes a
+ * `Workflow`-shaped object per declared workflow that proxies API calls through
+ * that bridge.
+ *
+ * Usage in `src/hooks.server.ts`:
+ *
+ *   export { handle } from '@oselvar/sveltekit-add-worker-exports/hooks';
+ *
+ * If you already have a `handle`, compose with `sequence`:
+ *
+ *   import { sequence } from '@sveltejs/kit/hooks';
+ *   import { handle as sweHandle } from '@oselvar/sveltekit-add-worker-exports/hooks';
+ *   export const handle = sequence(sweHandle, myHandle);
+ */
+import type { Handle } from '@sveltejs/kit';
+/**
+ * Reads bridge config from `globalThis`, set by the vite dev plugin at startup.
+ *
+ * We can't rely on vite `define` / compile-time substitution here because this
+ * file ships in node_modules and vite doesn't transform external modules in
+ * SSR by default. Plain runtime globals dodge that entirely and stay
+ * `undefined` in production (workerd), making this hook a no-op there.
+ */
+export declare const handle: Handle;

package/dist/bridge/runtime-hook.js

@@ -0,0 +1,105 @@
+/**
+ * SvelteKit `Handle` that injects fake Workflow bindings into `event.platform.env`
+ * during `vite dev`. In production this is a no-op.
+ *
+ * Why: wrangler's `getPlatformProxy` (used by `adapter-cloudflare` in dev) deletes
+ * workflow bindings before they reach miniflare, so `+server.ts` can't call
+ * `platform.env.MY_WORKFLOW.create(...)` directly. The companion vite plugin
+ * exposes a service binding (`__SWE_BRIDGE`) that fetches into a sidecar wrangler
+ * dev worker which has the real workflow binding. This hook synthesizes a
+ * `Workflow`-shaped object per declared workflow that proxies API calls through
+ * that bridge.
+ *
+ * Usage in `src/hooks.server.ts`:
+ *
+ *   export { handle } from '@oselvar/sveltekit-add-worker-exports/hooks';
+ *
+ * If you already have a `handle`, compose with `sequence`:
+ *
+ *   import { sequence } from '@sveltejs/kit/hooks';
+ *   import { handle as sweHandle } from '@oselvar/sveltekit-add-worker-exports/hooks';
+ *   export const handle = sequence(sweHandle, myHandle);
+ */
+/**
+ * Reads bridge config from `globalThis`, set by the vite dev plugin at startup.
+ *
+ * We can't rely on vite `define` / compile-time substitution here because this
+ * file ships in node_modules and vite doesn't transform external modules in
+ * SSR by default. Plain runtime globals dodge that entirely and stay
+ * `undefined` in production (workerd), making this hook a no-op there.
+ */
+export const handle = async ({ event, resolve }) => {
+    const g = globalThis;
+    const bridgeName = g.__SWE_BRIDGE_NAME__;
+    const workflows = g.__SWE_WORKFLOWS__;
+    if (!bridgeName || !workflows || workflows.length === 0)
+        return resolve(event);
+    const env = event.platform?.env;
+    if (!env)
+        return resolve(event);
+    const bridge = env[bridgeName];
+    if (!bridge)
+        return resolve(event);
+    for (const name of workflows) {
+        if (env[name])
+            continue;
+        env[name] = makeFakeWorkflow(bridge, name);
+    }
+    return resolve(event);
+};
+function makeFakeWorkflow(bridge, binding) {
+    const base = `http://swe/__swe/wf/${encodeURIComponent(binding)}`;
+    return {
+        async create(opts) {
+            const { id } = await postJson(bridge, `${base}/create`, opts ?? {});
+            return makeFakeInstance(bridge, binding, id);
+        },
+        async createBatch(batch) {
+            const ids = await postJson(bridge, `${base}/createBatch`, batch);
+            return ids.map(({ id }) => makeFakeInstance(bridge, binding, id));
+        },
+        async get(id) {
+            await getOk(bridge, `${base}/get/${encodeURIComponent(id)}`);
+            return makeFakeInstance(bridge, binding, id);
+        }
+    };
+}
+function makeFakeInstance(bridge, binding, id) {
+    const base = `http://swe/__swe/wf/${encodeURIComponent(binding)}/instance/${encodeURIComponent(id)}`;
+    const post = async (method, body) => {
+        const res = await bridge.fetch(`${base}/${method}`, {
+            method: 'POST',
+            body: body === undefined ? undefined : JSON.stringify(body)
+        });
+        if (!res.ok) {
+            throw new Error(`workflow ${method} failed: ${res.status} ${await res.text()}`);
+        }
+        const text = await res.text();
+        return text ? JSON.parse(text) : undefined;
+    };
+    return {
+        id,
+        pause: () => post('pause').then(() => undefined),
+        resume: () => post('resume').then(() => undefined),
+        terminate: () => post('terminate').then(() => undefined),
+        restart: () => post('restart').then(() => undefined),
+        status: () => post('status'),
+        sendEvent: (opts) => post('sendEvent', opts).then(() => undefined)
+    };
+}
+// Pass URL string + init (not a pre-built Request): miniflare's internal undici
+// won't accept a Request from a different realm — it stringifies it and tries
+// to parse `[object Request]` as a URL.
+async function postJson(bridge, url, body) {
+    const res = await bridge.fetch(url, { method: 'POST', body: JSON.stringify(body) });
+    if (!res.ok) {
+        throw new Error(`bridge POST ${url} failed: ${res.status} ${await res.text()}`);
+    }
+    return (await res.json());
+}
+async function getOk(bridge, url) {
+    const res = await bridge.fetch(url);
+    if (!res.ok) {
+        throw new Error(`bridge GET ${url} failed: ${res.status} ${await res.text()}`);
+    }
+}

package/dist/bridge/setup.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Vite-plugin-side bridge setup. Called from `src/index.ts` while the workflow
+ * bridge exists. Encapsulates everything bridge-specific:
+ *
+ *   - generates the cache wrapper at `node_modules/.cache/...` so the dev
+ *     sidecar serves the `/__swe/wf/*` routes used by the runtime hook
+ *   - publishes config on `globalThis` for the SvelteKit `handle` to read
+ *   - returns the proxy-config service binding to add and a disposer
+ *
+ * Once miniflare ships cross-worker workflow routing
+ * (cloudflare/workers-sdk#7459), delete `src/bridge/` and the call to
+ * `setupBridge` in `src/index.ts`.
+ */
+export declare const BRIDGE_BINDING = "__SWE_BRIDGE";
+export interface BridgeContext {
+    /** Path to the generated sidecar wrapper. Use as the dev config's `main`. */
+    wrapperPath: string;
+    /** Service binding entry to merge into the platform-proxy wrangler config. */
+    serviceBinding: {
+        binding: string;
+        service: string;
+    };
+    /** Best-effort cleanup of generated artifacts. */
+    dispose(): Promise<void>;
+}
+export interface SetupBridgeOptions {
+    userEntryAbs: string;
+    workflowBindings: readonly string[];
+    sidecarName: string;
+}
+export declare function setupBridge(options: SetupBridgeOptions): Promise<BridgeContext>;

package/dist/bridge/setup.js

@@ -0,0 +1,66 @@
+/**
+ * Vite-plugin-side bridge setup. Called from `src/index.ts` while the workflow
+ * bridge exists. Encapsulates everything bridge-specific:
+ *
+ *   - generates the cache wrapper at `node_modules/.cache/...` so the dev
+ *     sidecar serves the `/__swe/wf/*` routes used by the runtime hook
+ *   - publishes config on `globalThis` for the SvelteKit `handle` to read
+ *   - returns the proxy-config service binding to add and a disposer
+ *
+ * Once miniflare ships cross-worker workflow routing
+ * (cloudflare/workers-sdk#7459), delete `src/bridge/` and the call to
+ * `setupBridge` in `src/index.ts`.
+ */
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+export const BRIDGE_BINDING = '__SWE_BRIDGE';
+const CACHE_DIR_REL = 'node_modules/.cache/sveltekit-add-worker-exports';
+const WRAPPER_FILENAME = 'dev-worker-entry.ts';
+export async function setupBridge(options) {
+    const cacheDir = resolve(CACHE_DIR_REL);
+    await mkdir(cacheDir, { recursive: true });
+    const wrapperPath = join(cacheDir, WRAPPER_FILENAME);
+    const userEntryRel = relative(dirname(wrapperPath), options.userEntryAbs)
+        .replace(/\\/g, '/')
+        .replace(/\.(ts|tsx|js|jsx|mjs|mts)$/, '');
+    await writeFile(wrapperPath, generateWrapperSource(userEntryRel, options.workflowBindings));
+    // The runtime hook reads these from globalThis. We can't use vite's
+    // `define` because dist/hooks.js lives in node_modules and vite doesn't
+    // transform external modules in SSR by default — substitutions wouldn't
+    // reach the file.
+    globalThis.__SWE_BRIDGE_NAME__ = BRIDGE_BINDING;
+    globalThis.__SWE_WORKFLOWS__ = options.workflowBindings;
+    return {
+        wrapperPath,
+        serviceBinding: { binding: BRIDGE_BINDING, service: options.sidecarName },
+        dispose: async () => {
+            await unlink(wrapperPath).catch(() => { });
+        }
+    };
+}
+/**
+ * Tiny glue file that wrangler bundles into the dev sidecar. The substantive
+ * bridge logic lives in `./dev-handler.ts`, which the wrapper imports as a
+ * package subpath. Keeping the template this small makes it unlikely to
+ * harbour TypeScript errors that wouldn't be caught by tsc on the rest of
+ * the package.
+ */
+function generateWrapperSource(userEntryRel, workflowBindings) {
+    const importPath = JSON.stringify(userEntryRel);
+    const bindingList = JSON.stringify(workflowBindings);
+    return `// Auto-generated by @oselvar/sveltekit-add-worker-exports.
+// Bridges Workflow bindings to SvelteKit dev. Do not edit.
+import * as user from ${importPath};
+export * from ${importPath};
+import { createBridgeFetch } from '@oselvar/sveltekit-add-worker-exports/dev-bridge';
+
+const userDefault = (user as { default?: { fetch?: ExportedHandlerFetchHandler } }).default;
+
+export default {
+\tfetch: createBridgeFetch({
+\t\tworkflowBindings: ${bindingList},
+\t\tuserFetch: userDefault?.fetch?.bind(userDefault)
+\t})
+} satisfies ExportedHandler;
+`;
+}

package/dist/hooks.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SvelteKit `Handle` re-exported for users.
+ *
+ * Implementation lives in `./bridge/runtime-hook` while the workflow bridge
+ * exists. Once miniflare ships cross-worker workflow routing
+ * (cloudflare/workers-sdk#7459), replace this file with a no-op handle:
+ *
+ *   import type { Handle } from '@sveltejs/kit';
+ *   export const handle: Handle = ({ event, resolve }) => resolve(event);
+ *
+ * and delete `src/bridge/`.
+ */
+export { handle } from './bridge/runtime-hook.js';

package/dist/hooks.js

@@ -0,0 +1,13 @@
+/**
+ * SvelteKit `Handle` re-exported for users.
+ *
+ * Implementation lives in `./bridge/runtime-hook` while the workflow bridge
+ * exists. Once miniflare ships cross-worker workflow routing
+ * (cloudflare/workers-sdk#7459), replace this file with a no-op handle:
+ *
+ *   import type { Handle } from '@sveltejs/kit';
+ *   export const handle: Handle = ({ event, resolve }) => resolve(event);
+ *
+ * and delete `src/bridge/`.
+ */
+export { handle } from './bridge/runtime-hook.js';

package/dist/index.d.ts

@@ -11,6 +11,15 @@
  * server via `unstable_startWorker` that runs the real DO worker. Clients
  * connect directly to it via WebSocket on a separate port.
  *
+ * Workflows in dev are best-effort: if the installed wrangler/miniflare
+ * supports cross-worker workflow routing (cloudflare/workers-sdk#7459),
+ * `platform.env.MY_WORKFLOW.create(...)` works directly. Otherwise the bridge
+ * in `src/bridge/` synthesises the binding via an HTTP fallback. Once the
+ * upstream patch lands, delete `src/bridge/`, drop the `setupBridge` import
+ * and call below, replace `wrapperPath` with `options.entryPoint`, remove
+ * the `serviceBinding` insertion, and replace `src/hooks.ts` with a no-op
+ * handle.
+ *
  * Usage in vite.config.ts:
  *   addWorkerExports({ entryPoint: 'src/lib/server/index.ts' })
  *

package/dist/index.js

@@ -11,16 +11,57 @@
  * server via `unstable_startWorker` that runs the real DO worker. Clients
  * connect directly to it via WebSocket on a separate port.
  *
+ * Workflows in dev are best-effort: if the installed wrangler/miniflare
+ * supports cross-worker workflow routing (cloudflare/workers-sdk#7459),
+ * `platform.env.MY_WORKFLOW.create(...)` works directly. Otherwise the bridge
+ * in `src/bridge/` synthesises the binding via an HTTP fallback. Once the
+ * upstream patch lands, delete `src/bridge/`, drop the `setupBridge` import
+ * and call below, replace `wrapperPath` with `options.entryPoint`, remove
+ * the `serviceBinding` insertion, and replace `src/hooks.ts` with a no-op
+ * handle.
+ *
  * Usage in vite.config.ts:
  *   addWorkerExports({ entryPoint: 'src/lib/server/index.ts' })
  *
  * @see https://github.com/sveltejs/kit/issues/1712
  */
 import { build } from 'esbuild';
+import { existsSync } from 'node:fs';
 import { access, readFile, rename, writeFile, unlink } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
+import { setupBridge } from './bridge/setup.js';
 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`
+ * bindings can find each other.
+ */
+function getWranglerRegistryPath() {
+    if (process.env.WRANGLER_REGISTRY_PATH)
+        return process.env.WRANGLER_REGISTRY_PATH;
+    const legacy = join(homedir(), '.wrangler');
+    if (existsSync(legacy))
+        return join(legacy, 'registry');
+    if (process.platform === 'darwin') {
+        return join(homedir(), 'Library', 'Preferences', '.wrangler', 'registry');
+    }
+    if (process.platform === 'win32') {
+        return join(process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'), '.wrangler', 'registry');
+    }
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), '.wrangler', 'registry');
+}
 /**
  * Returns two Vite plugins: one for build (patches _worker.js) and one for
  * dev (starts a wrangler dev server for Durable Objects).
@@ -56,14 +97,30 @@ function buildPlugin(options) {
             if (!(await exists(workerPath))) {
                 return;
             }
-            // Bundle the named exports
+            // Bundle the named exports.
+            //
+            // `conditions: ['workerd', 'worker', 'browser']` is the Cloudflare-
+            // recommended set for bundlers targeting Workers — it picks the
+            // workerd-specific or browser-shimmed variants of packages over
+            // their Node variants (e.g. nanoid's webcrypto-via-`globalThis.crypto`
+            // browser build instead of the `node:crypto`-importing main build).
+            //
+            // Node built-ins are externalised so transitive deps that do
+            // `require('path')` or `import 'node:async_hooks'` survive bundling;
+            // the Workers runtime resolves them when `nodejs_compat` is enabled
+            // in wrangler.jsonc.
             await build({
                 entryPoints: [options.entryPoint],
                 bundle: true,
                 format: 'esm',
                 sourcemap: true,
                 target: 'esnext',
-                external: ['cloudflare:*'],
+                conditions: ['workerd', 'worker', 'browser'],
+                external: [
+                    'cloudflare:*',
+                    ...NODE_BUILTINS,
+                    ...NODE_BUILTINS.map((m) => `node:${m}`)
+                ],
                 outfile: exportsPath
             });
             // Rename original worker and create merged entry point
@@ -77,6 +134,19 @@ function devPlugin(options) {
     let worker = null;
     let tempConfigPath = null;
     let proxyConfigPath = null;
+    let typesConfigPath = null;
+    let bridgeDispose = null;
+    let cached = null;
+    async function readConfig() {
+        if (cached)
+            return cached;
+        const { unstable_readConfig } = await import('wrangler');
+        const parsed = unstable_readConfig(options.wranglerConfig ? { config: options.wranglerConfig } : {});
+        const rawJson = await readFile(parsed.configPath, 'utf-8');
+        const workflowBindings = (parsed.workflows ?? []).map((w) => w.binding);
+        cached = { rawJson, workflowBindings };
+        return cached;
+    }
     return {
         name: 'add-worker-exports-dev',
         apply: 'serve',
@@ -88,34 +158,75 @@ function devPlugin(options) {
             };
         },
         async configureServer(server) {
-            const { unstable_readConfig, unstable_startWorker } = await import('wrangler');
-            // Read the project's wrangler config (auto-discovers wrangler.jsonc/toml)
-            const wranglerConfig = unstable_readConfig(options.wranglerConfig ? { config: options.wranglerConfig } : {});
+            const { unstable_startWorker } = await import('wrangler');
+            const { rawJson, workflowBindings } = await readConfig();
+            const sidecarName = `${parseJsonc(rawJson).name ?? 'sveltekit'}-dev-worker`;
+            // Set up the workflow HTTP bridge (see src/bridge/). This is the
+            // fallback used when the installed wrangler/miniflare strips
+            // workflow bindings from getPlatformProxy. When the upstream
+            // patch lands (cloudflare/workers-sdk#7459), delete src/bridge,
+            // remove this call, and use options.entryPoint as the dev
+            // config's `main` directly (no service binding either).
+            const bridge = await setupBridge({
+                userEntryAbs: resolve(options.entryPoint),
+                workflowBindings,
+                sidecarName
+            });
+            bridgeDispose = bridge.dispose;
             // Copy the raw config and override main, name, and dev port
-            const rawJson = await readFile(wranglerConfig.configPath, 'utf-8');
             const devConfig = parseJsonc(rawJson);
-            devConfig.name = `${devConfig.name ?? 'sveltekit'}-dev-worker`;
-            devConfig.main = options.entryPoint;
+            devConfig.name = sidecarName;
+            devConfig.main = bridge.wrapperPath;
             devConfig.dev = { ...devConfig.dev, port: devPort };
             delete devConfig.assets;
             tempConfigPath = resolve('.dev-worker-wrangler.jsonc');
             await writeFile(tempConfigPath, JSON.stringify(devConfig, null, '\t'));
-            // Also write a wrangler config for adapter-cloudflare's getPlatformProxy
+            // Write a wrangler config for adapter-cloudflare's getPlatformProxy
             // (used by vite dev for platform.env). It can't run internal DOs or
-            // Workflows -- those are served by the sidecar above. Strip them so it
-            // doesn't emit warnings about classes it can't load.
+            // Workflows itself -- those are served by the sidecar above. Rewrite
+            // internal DO bindings as cross-worker bindings (script_name pointing
+            // at the sidecar) so platform.env.MY_DO calls in +server.ts reach the
+            // sidecar via the wrangler dev registry. Workflows get the same
+            // rewrite; on patched wrangler/miniflare miniflare routes them via
+            // the dev-registry-proxy. On unpatched, wrangler strips them and the
+            // bridge service binding (added below) drives the SvelteKit hook
+            // fallback.
             const proxyConfig = parseJsonc(rawJson);
             if (proxyConfig.durable_objects?.bindings) {
-                proxyConfig.durable_objects.bindings = proxyConfig.durable_objects.bindings.filter((b) => b.script_name);
-                if (proxyConfig.durable_objects.bindings.length === 0) {
-                    delete proxyConfig.durable_objects;
-                }
+                proxyConfig.durable_objects.bindings = proxyConfig.durable_objects.bindings.map((b) => b.script_name ? b : { ...b, script_name: sidecarName });
+            }
+            if (Array.isArray(proxyConfig.workflows)) {
+                proxyConfig.workflows = proxyConfig.workflows.map((w) => w.script_name ? w : { ...w, script_name: sidecarName });
+            }
+            if (workflowBindings.length > 0) {
+                proxyConfig.services = [
+                    ...(proxyConfig.services ?? []),
+                    bridge.serviceBinding
+                ];
             }
-            delete proxyConfig.workflows;
             delete proxyConfig.migrations;
             proxyConfigPath = resolve('.platform-proxy-wrangler.jsonc');
             await writeFile(proxyConfigPath, JSON.stringify(proxyConfig, null, '\t'));
-            worker = await unstable_startWorker({ config: tempConfigPath });
+            // A third config used only by `wrangler types`. Identical to the dev
+            // config except `main` points at the user's source entry, so wrangler
+            // can resolve typed bindings (DurableObjectNamespace<EchoDO>, etc.).
+            // Pointing types at our generated wrapper produces untyped bindings
+            // because wrangler's type resolver doesn't follow `export *` re-exports
+            // out of node_modules.
+            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() },
+                build: {
+                    nodejsCompatMode: (parsedConfig) => getNodejsCompatMode(parsedConfig.compatibility_date, parsedConfig.compatibility_flags)
+                }
+            });
             server.httpServer?.on('close', async () => {
                 if (worker) {
                     await worker.dispose();
@@ -127,6 +238,13 @@ function devPlugin(options) {
                 if (proxyConfigPath) {
                     await unlink(proxyConfigPath).catch(() => { });
                 }
+                if (typesConfigPath) {
+                    await unlink(typesConfigPath).catch(() => { });
+                }
+                if (bridgeDispose) {
+                    await bridgeDispose();
+                    bridgeDispose = null;
+                }
             });
         }
     };
@@ -140,3 +258,24 @@ async function exists(path) {
         return false;
     }
 }
+/**
+ * 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
+ * `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;
+}

package/package.json

@@ -1,51 +1,64 @@
 {
-  "name": "@oselvar/sveltekit-add-worker-exports",
-  "version": "0.2.0",
-  "description": "Vite plugin that adds Durable Object and Workflow exports to SvelteKit Cloudflare workers",
-  "type": "module",
-  "publishConfig": {
-    "access": "public"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/oselvar/sveltekit-add-worker-exports.git"
-  },
-  "keywords": [
-    "sveltekit",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "workflows",
-    "vite-plugin"
-  ],
-  "peerDependencies": {
-    "esbuild": ">=0.17",
-    "vite": ">=5",
-    "wrangler": ">=4"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "esbuild": "^0.25.0",
-    "np": "^11.2.0",
-    "typescript": "^5.0.0",
-    "vite": "^6.0.0",
-    "wrangler": "^4.84.0"
-  },
-  "dependencies": {
-    "jsonc-parser": "^3.3.1"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsc --noEmit"
-  }
-}
+	"name": "@oselvar/sveltekit-add-worker-exports",
+	"version": "0.3.1",
+	"description": "Vite plugin that adds Durable Object and Workflow exports to SvelteKit Cloudflare workers",
+	"type": "module",
+	"publishConfig": {
+		"access": "public"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./hooks": {
+			"types": "./dist/hooks.d.ts",
+			"import": "./dist/hooks.js"
+		},
+		"./dev-bridge": {
+			"types": "./dist/bridge/dev-handler.d.ts",
+			"import": "./dist/bridge/dev-handler.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/oselvar/sveltekit-add-worker-exports.git"
+	},
+	"keywords": [
+		"sveltekit",
+		"cloudflare",
+		"workers",
+		"durable-objects",
+		"workflows",
+		"vite-plugin"
+	],
+	"peerDependencies": {
+		"@sveltejs/kit": ">=2",
+		"esbuild": ">=0.17",
+		"miniflare": ">=4",
+		"vite": ">=5",
+		"wrangler": ">=4"
+	},
+	"devDependencies": {
+		"@sveltejs/kit": "^2.61.0",
+		"@types/node": "^22.19.19",
+		"esbuild": "^0.25.12",
+		"miniflare": "^4.20260521.0",
+		"np": "^11.2.1",
+		"typescript": "^5.9.3",
+		"vite": "^6.4.2",
+		"wrangler": "^4.94.0"
+	},
+	"scripts": {
+		"build": "tsc",
+		"test": "tsc --noEmit",
+		"prepublishOnly": "tsc"
+	},
+	"dependencies": {
+		"jsonc-parser": "^3.3.1"
+	}
+}