@oselvar/sveltekit-add-worker-exports 0.3.0 → 0.3.2

package/README.md

@@ -87,7 +87,7 @@ export default defineConfig({
 });
 ```
 
-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 and migrations are stripped — calling a Workflow from `platform.env` in vite dev isn't supported, but it works in production. Without this config path, `getPlatformProxy` would try to run the classes itself and warn that it can't:
+Point `adapter-cloudflare`'s platform proxy at the generated `.platform-proxy-wrangler.jsonc`. The plugin writes this file with internal Durable Object and Workflow bindings rewritten to cross-worker form (each gets a `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. Without this config path, `getPlatformProxy` would try to run the DO/Workflow classes itself and warn that it can't:
 
 ```javascript
 // svelte.config.js
@@ -129,7 +129,23 @@ 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 point at your source entry.
+
+### Dev mode: calling Workflows
+
+`+server.ts` calls 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);
+};
+```
+
+The sidecar runs the real `WorkflowEntrypoint` class; calls reach it via the `script_name` rewrite in the platform-proxy config. This requires `wrangler >= 4.98.0` ([cloudflare/workers-sdk#13863](https://github.com/cloudflare/workers-sdk/pull/13863)).
 
 ### Testing the production build locally
 
@@ -191,10 +207,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 +220,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`.
 
 ## Why this exists
 

package/dist/hooks.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SvelteKit `Handle` re-exported for users.
+ *
+ * Kept as a no-op for backwards compatibility. Wrangler 4.98.0 fixed
+ * cross-worker workflow routing in `getPlatformProxy`
+ * (cloudflare/workers-sdk#13863), so `platform.env.MY_WORKFLOW` is now a
+ * real binding in both dev and production — no synthesis required.
+ */
+import type { Handle } from '@sveltejs/kit';
+export declare const handle: Handle;

package/dist/hooks.js

@@ -0,0 +1,9 @@
+/**
+ * SvelteKit `Handle` re-exported for users.
+ *
+ * Kept as a no-op for backwards compatibility. Wrangler 4.98.0 fixed
+ * cross-worker workflow routing in `getPlatformProxy`
+ * (cloudflare/workers-sdk#13863), so `platform.env.MY_WORKFLOW` is now a
+ * real binding in both dev and production — no synthesis required.
+ */
+export const handle = ({ event, resolve }) => resolve(event);

package/dist/index.d.ts

@@ -7,9 +7,13 @@
  * exports. This plugin post-processes the build output to merge them.
  *
  * **Dev mode:** `getPlatformProxy` (used by adapter-cloudflare in dev) can't
- * run internal Durable Objects. This plugin starts a separate wrangler dev
- * server via `unstable_startWorker` that runs the real DO worker. Clients
- * connect directly to it via WebSocket on a separate port.
+ * run internal Durable Objects or Workflows. This plugin starts a separate
+ * wrangler dev server via `unstable_startWorker` that runs the real
+ * DO/Workflow worker. Internal DO and Workflow bindings in the platform-proxy
+ * config get a `script_name` pointing at that sidecar; miniflare routes calls
+ * across the dev registry (cloudflare/workers-sdk#7459, fixed in wrangler
+ * 4.98.0). Clients connect directly to the sidecar via WebSocket on a
+ * separate port.
  *
  * Usage in vite.config.ts:
  *   addWorkerExports({ entryPoint: 'src/lib/server/index.ts' })

package/dist/index.js

@@ -7,9 +7,13 @@
  * exports. This plugin post-processes the build output to merge them.
  *
  * **Dev mode:** `getPlatformProxy` (used by adapter-cloudflare in dev) can't
- * run internal Durable Objects. This plugin starts a separate wrangler dev
- * server via `unstable_startWorker` that runs the real DO worker. Clients
- * connect directly to it via WebSocket on a separate port.
+ * run internal Durable Objects or Workflows. This plugin starts a separate
+ * wrangler dev server via `unstable_startWorker` that runs the real
+ * DO/Workflow worker. Internal DO and Workflow bindings in the platform-proxy
+ * config get a `script_name` pointing at that sidecar; miniflare routes calls
+ * across the dev registry (cloudflare/workers-sdk#7459, fixed in wrangler
+ * 4.98.0). Clients connect directly to the sidecar via WebSocket on a
+ * separate port.
  *
  * Usage in vite.config.ts:
  *   addWorkerExports({ entryPoint: 'src/lib/server/index.ts' })
@@ -23,6 +27,16 @@ import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
 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`
@@ -77,14 +91,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
@@ -98,6 +128,12 @@ function devPlugin(options) {
     let worker = null;
     let tempConfigPath = null;
     let proxyConfigPath = null;
+    let typesConfigPath = null;
+    async function readRawConfig() {
+        const { unstable_readConfig } = await import('wrangler');
+        const parsed = unstable_readConfig(options.wranglerConfig ? { config: options.wranglerConfig } : {});
+        return readFile(parsed.configPath, 'utf-8');
+    }
     return {
         name: 'add-worker-exports-dev',
         apply: 'serve',
@@ -109,36 +145,51 @@ 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 = await readRawConfig();
+            const sidecarName = `${parseJsonc(rawJson).name ?? 'sveltekit'}-dev-worker`;
             // 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.name = sidecarName;
             devConfig.main = options.entryPoint;
             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 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 and migrations get
-            // stripped (Workflow bindings have no script_name equivalent).
+            // internal DO and Workflow bindings as cross-worker bindings
+            // (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: devConfig.name });
+                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 });
             }
-            delete proxyConfig.workflows;
             delete proxyConfig.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() }
+                dev: { registry: getWranglerRegistryPath() },
+                build: {
+                    nodejsCompatMode: (parsedConfig) => getNodejsCompatMode(parsedConfig.compatibility_date, parsedConfig.compatibility_flags)
+                }
             });
             server.httpServer?.on('close', async () => {
                 if (worker) {
@@ -151,6 +202,9 @@ function devPlugin(options) {
                 if (proxyConfigPath) {
                     await unlink(proxyConfigPath).catch(() => { });
                 }
+                if (typesConfigPath) {
+                    await unlink(typesConfigPath).catch(() => { });
+                }
             });
         }
     };
@@ -164,3 +218,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,62 @@
 {
-  "name": "@oselvar/sveltekit-add-worker-exports",
-  "version": "0.3.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.2",
+	"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"
+		}
+	},
+	"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": {
+		"@release-it/conventional-changelog": "^11.0.1",
+		"@sveltejs/kit": "^2.62.0",
+		"@types/node": "^25.9.1",
+		"esbuild": "^0.28.0",
+		"miniflare": "^4.20260601.0",
+		"release-it": "^20.2.0",
+		"typescript": "^6.0.3",
+		"vite": "^8.0.16",
+		"wrangler": "^4.98.0"
+	},
+	"scripts": {
+		"build": "tsc",
+		"test": "tsc --noEmit",
+		"prepublishOnly": "tsc",
+		"release": "release-it"
+	},
+	"dependencies": {
+		"jsonc-parser": "^3.3.1"
+	}
+}