@oselvar/sveltekit-add-worker-exports 2.1.1 → 2.2.0

package/README.md

@@ -4,6 +4,8 @@ A Vite plugin that makes any class-based Cloudflare Worker export (Durable Objec
 
 Works with **SvelteKit 2 and SvelteKit 3** (see [`example/`](example) and [`example-v3/`](example-v3)).
 
+The examples below use SvelteKit 2's `platform.env`. SvelteKit 3's `adapter-cloudflare` (8.0.0-next.7 and later) no longer provides `event.platform`: read bindings with `import { env } from 'cloudflare:workers'` instead, as [`example-v3/`](example-v3) does. The plugin's dev-registry wiring works the same either way.
+
 **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**, and non-fetch handlers (`scheduled`, `queue`, `email`, …) to be **methods on the default export**. This plugin post-processes the build output to merge both kinds onto SvelteKit's worker.
 
 **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. The sidecar also exposes `/__scheduled` so `scheduled` handlers can be fired manually in dev — see [Scheduled, queue, email, tail handlers](#scheduled-queue-email-tail-handlers).
@@ -217,6 +219,49 @@ declare global {
 }
 ```
 
+## Importing non-JS modules (`.sql`, `.txt`, …)
+
+Wrangler lets workers import non-JavaScript files as modules via
+[module rules](https://developers.cloudflare.com/workers/wrangler/configuration/#bundling):
+`Text` rules import as a `string`, `Data` rules as an `ArrayBuffer`. Wrangler
+applies a set of default rules even without any config — `**/*.txt`,
+`**/*.html`, and `**/*.sql` as `Text`, `**/*.bin` as `Data`.
+
+The plugin honors the same contract in both modes: the dev sidecar is bundled
+by wrangler itself, and the build-mode esbuild pass translates the `rules`
+from your wrangler config (plus wrangler's defaults) into esbuild loaders and
+inlines the file contents into `_extra_exports.js`.
+
+This makes [Drizzle's durable-sqlite migrations](https://orm.drizzle.team/docs/sqlite/connect-cloudflare-do)
+work out of the box ([#8](https://github.com/oselvar/sveltekit-add-worker-exports/issues/8)):
+the generated `drizzle/migrations.js` imports `.sql` files, which wrangler's
+default rules cover — no `rules` config needed. Custom extensions need a rule:
+
+```jsonc
+// wrangler.jsonc
+"rules": [{ "type": "Text", "globs": ["**/*.graphql"], "fallthrough": true }]
+```
+
+And a type declaration so TypeScript accepts the import:
+
+```typescript
+// src/app.d.ts
+declare module '*.graphql' {
+	const contents: string;
+	export default contents;
+}
+```
+
+Caveats:
+
+- `CompiledWasm`, `PythonModule`, and `PythonRequirement` rules can't be
+  inlined into the single-file production bundle; importing a file matched by
+  one fails the build with an explanatory error.
+- Glob matching in build mode uses miniflare's matcher (`globstar` semantics,
+  matched against resolved file paths) while wrangler's dev bundler matches
+  import specifiers with non-`globstar` semantics. The canonical shapes
+  (`**/*.ext`) behave identically under both; exotic globs may differ.
+
 ## Options
 
 | Option | Type | Required | Default | Description |
@@ -232,7 +277,7 @@ declare global {
 
 The plugin runs after SvelteKit's adapter has generated `_worker.js`. SvelteKit v2 runs the adapter in Vite's `closeBundle` hook, while SvelteKit v3 moved it into the newer `buildApp` hook (which runs *after* every `closeBundle`). The plugin registers its patch step on **both** hooks (idempotent), so whichever one runs after the adapter does the work:
 
-1. Bundles your `entryPoint` with esbuild into `_extra_exports.js`
+1. Bundles your `entryPoint` with esbuild into `_extra_exports.js`, applying the wrangler config's module `rules` (plus wrangler's defaults) so `.sql`/`.txt`-style imports are inlined — see [Importing non-JS modules](#importing-non-js-modules-sql-txt-)
 2. Renames the original `_worker.js` to `_sveltekit_worker.js`
 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:
 
@@ -259,25 +304,29 @@ 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. Use it to generate fully generic Cloudflare types:
+The dev plugin runs the sidecar from a derived `.dev-worker-wrangler.jsonc`: your wrangler config with `main` pointing to your source entry point and `assets` removed. Use it to generate fully generic Cloudflare types:
 
 ```bash
+npx sveltekit-add-worker-exports write-config
 wrangler types --config .dev-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).
+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 also drags `.svelte-kit/cloudflare/_worker` into `tsc` via `mainModule`).
 
-Add this to your `package.json` scripts for convenience:
+`write-config` writes the same file the dev server does, without starting it. It reads `entryPoint` (and `wranglerConfig`, if set) from the `addWorkerExports()` call in your `vite.config.ts`, so it works in CI. Add scripts to `package.json`:
 
 ```json
 {
   "scripts": {
-    "types": "wrangler types --config .dev-worker-wrangler.jsonc"
+    "types": "sveltekit-add-worker-exports write-config && wrangler types --config .dev-worker-wrangler.jsonc",
+    "types:check": "sveltekit-add-worker-exports write-config && wrangler types --config .dev-worker-wrangler.jsonc --check"
   }
 }
 ```
 
-Note: the `.dev-worker-wrangler.jsonc` file is generated when the dev server starts. Run `pnpm dev` at least once before running `wrangler types`.
+Commit `worker-configuration.d.ts` and run `types:check` in CI to catch stale types. Add `.dev-worker-wrangler.jsonc` to `.gitignore`.
+
+Options: `--out <path>` changes the output file, `--vite-config <path>` points at a non-default vite config, and `--entry <path>` (with optional `--wrangler-config <path>`) skips loading the vite config altogether. From code, use `writeDevWorkerConfig({ entryPoint })` or the pure `deriveDevWorkerConfig(config, { entryPoint })`.
 
 ## Why this exists
 

package/bin/sveltekit-add-worker-exports.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// Committed launcher (not built) so package managers can link the bin
+// before `dist/` exists, e.g. in this workspace right after `pnpm install`.
+import '../dist/bin.js';

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin.js

@@ -0,0 +1,9 @@
+import { main, USAGE, UsageError } from './cli.js';
+main(process.argv.slice(2)).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`sveltekit-add-worker-exports: ${message}\n`);
+    if (error instanceof UsageError) {
+        process.stderr.write(`\n${USAGE}`);
+    }
+    process.exitCode = 1;
+});

package/dist/cli.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CLI for tasks that shouldn't require a running `vite dev`.
+ *
+ *   sveltekit-add-worker-exports write-config [options]
+ *
+ * Writes `.dev-worker-wrangler.jsonc` (the config the dev sidecar runs) so
+ * `wrangler types --config .dev-worker-wrangler.jsonc [--check]` works in CI.
+ * The plugin options are read from the vite config by default; `--entry`
+ * skips loading it.
+ */
+import { type AddWorkerExportsOptions } from './index.js';
+export declare const USAGE = "Usage: sveltekit-add-worker-exports write-config [options]\n\nWrites .dev-worker-wrangler.jsonc for `wrangler types --config .dev-worker-wrangler.jsonc`\nwithout starting the dev server.\n\nOptions:\n  --out <path>              Output file (default: .dev-worker-wrangler.jsonc)\n  --vite-config <path>      Vite config to read plugin options from (default: auto-discovered)\n  --entry <path>            Worker entry point; skips loading the vite config\n  --wrangler-config <path>  Wrangler config (default: from the vite config, else auto-discovered)\n  -h, --help                Show this help\n";
+export declare function main(argv: string[]): Promise<void>;
+/**
+ * Loads the vite config and returns the options passed to
+ * `addWorkerExports()`, which the dev plugin exposes as `api.options`.
+ */
+export declare function loadPluginOptions(configFile?: string): Promise<AddWorkerExportsOptions>;
+export declare class UsageError extends Error {
+}

package/dist/cli.js

@@ -0,0 +1,86 @@
+/**
+ * CLI for tasks that shouldn't require a running `vite dev`.
+ *
+ *   sveltekit-add-worker-exports write-config [options]
+ *
+ * Writes `.dev-worker-wrangler.jsonc` (the config the dev sidecar runs) so
+ * `wrangler types --config .dev-worker-wrangler.jsonc [--check]` works in CI.
+ * The plugin options are read from the vite config by default; `--entry`
+ * skips loading it.
+ */
+import { relative } from 'node:path';
+import { parseArgs } from 'node:util';
+import { DEV_WORKER_CONFIG_FILE, writeDevWorkerConfig } from './index.js';
+export const USAGE = `Usage: sveltekit-add-worker-exports write-config [options]
+
+Writes ${DEV_WORKER_CONFIG_FILE} for \`wrangler types --config ${DEV_WORKER_CONFIG_FILE}\`
+without starting the dev server.
+
+Options:
+  --out <path>              Output file (default: ${DEV_WORKER_CONFIG_FILE})
+  --vite-config <path>      Vite config to read plugin options from (default: auto-discovered)
+  --entry <path>            Worker entry point; skips loading the vite config
+  --wrangler-config <path>  Wrangler config (default: from the vite config, else auto-discovered)
+  -h, --help                Show this help
+`;
+export async function main(argv) {
+    const { positionals, values } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            out: { type: 'string' },
+            'vite-config': { type: 'string' },
+            entry: { type: 'string' },
+            'wrangler-config': { type: 'string' },
+            help: { type: 'boolean', short: 'h' }
+        }
+    });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (positionals[0] !== 'write-config' || positionals.length > 1) {
+        throw new UsageError(positionals.length ? `Unknown command: ${positionals.join(' ')}` : 'No command given');
+    }
+    const options = values.entry
+        ? { entryPoint: values.entry }
+        : await loadPluginOptions(values['vite-config']);
+    if (values['wrangler-config']) {
+        options.wranglerConfig = values['wrangler-config'];
+    }
+    const path = await writeDevWorkerConfig(options, values.out);
+    process.stdout.write(`Wrote ${relative(process.cwd(), path) || path}\n`);
+}
+/**
+ * Loads the vite config and returns the options passed to
+ * `addWorkerExports()`, which the dev plugin exposes as `api.options`.
+ */
+export async function loadPluginOptions(configFile) {
+    const { loadConfigFromFile } = await import('vite');
+    const loaded = await loadConfigFromFile({ command: 'serve', mode: 'development' }, configFile, process.cwd(), 'silent');
+    if (!loaded) {
+        throw new Error('No vite config found. Pass --vite-config <path> or --entry <path>.');
+    }
+    const plugins = await flattenPlugins(loaded.config.plugins ?? []);
+    const plugin = plugins.find((p) => p.name === 'add-worker-exports-dev');
+    const options = plugin?.api?.options;
+    if (!options) {
+        throw new Error(`addWorkerExports() not found in ${relative(process.cwd(), loaded.path)}. Pass --entry <path> instead.`);
+    }
+    return { ...options };
+}
+async function flattenPlugins(options) {
+    const plugins = [];
+    for (const option of options) {
+        const resolved = await option;
+        if (Array.isArray(resolved)) {
+            plugins.push(...(await flattenPlugins(resolved)));
+        }
+        else if (resolved) {
+            plugins.push(resolved);
+        }
+    }
+    return plugins;
+}
+export class UsageError extends Error {
+}

package/dist/index.d.ts

@@ -20,7 +20,9 @@
  *
  * @see https://github.com/sveltejs/kit/issues/1712
  */
+import { type ModuleRule } from 'miniflare';
 import type { Plugin } from 'vite';
+export { createModuleRulesPlugin, toModuleRule, WRANGLER_DEFAULT_MODULE_RULES, type WranglerRule } from './moduleRules.js';
 /**
  * Parses a wrangler config file. Picks the parser by extension:
  * `.toml` uses smol-toml; everything else (`.jsonc`, `.json`, or no
@@ -46,6 +48,15 @@ export declare const PLUGIN_ASSETS_IGNORE_ENTRIES: string[];
  * public asset serving, so the listed files stay on disk for wrangler to bundle.
  */
 export declare function mergeAssetsIgnore(existing: string, entries: string[]): string;
+/**
+ * Deletes `name`'s dev-registry entry if nothing is listening on its debug
+ * port. A sidecar that doesn't shut down cleanly (killed, crashed) leaves its
+ * entry behind, and the next sidecar with the same name doesn't replace it:
+ * `platform.env` calls then go to the dead address and fail with "Network
+ * connection lost" until the file is deleted. A live entry (e.g. another
+ * `vite dev` of the same app) is left alone.
+ */
+export declare function removeDeadRegistryEntry(registryPath: string, name: string): Promise<void>;
 export interface AddWorkerExportsOptions {
     /** File that exports Durable Object and/or Workflow classes */
     entryPoint: string;
@@ -82,3 +93,56 @@ export interface AddWorkerExportsOptions {
  * ```
  */
 export declare function addWorkerExports(options: AddWorkerExportsOptions): Plugin[];
+/**
+ * Patches the adapter-generated `_worker.js`: bundles the named exports into
+ * `_extra_exports.js`, renames the original worker to `_sveltekit_worker.js`,
+ * and writes a merged `_worker.js`. Idempotent — safe to call from more than
+ * one Vite hook; the first call that finds `_worker.js` does the work, later
+ * calls see `_sveltekit_worker.js` and return.
+ *
+ * Returns `true` if it patched (or had already patched), `false` if the
+ * adapter hasn't written `_worker.js` yet.
+ */
+/**
+ * Reads the module `rules` from the wrangler config (auto-discovered, or
+ * `options.wranglerConfig` when set) for the build-mode bundle. Wrangler
+ * resolves `CLOUDFLARE_ENV` and per-env `rules` inheritance itself.
+ *
+ * When no config is found by auto-discovery, wrangler returns an empty
+ * config, so this yields no user rules (wrangler's default rules still
+ * apply). A missing `wranglerConfig` path, a syntax error, or a validation
+ * error throws and fails the build — the same config would fail
+ * `wrangler dev`/`deploy`, so surfacing it here is strictly earlier, not a
+ * new requirement.
+ */
+export declare function readModuleRules(options: AddWorkerExportsOptions): Promise<ModuleRule[]>;
+/** Default file name for the derived dev-worker wrangler config. */
+export declare const DEV_WORKER_CONFIG_FILE = ".dev-worker-wrangler.jsonc";
+/**
+ * Reads and parses the raw wrangler config (auto-discovered, or
+ * `wranglerConfig` when set). Returns the unresolved file contents — not
+ * wrangler's normalised config — so derived configs stay close to what the
+ * user wrote.
+ */
+export declare function readWranglerConfig(wranglerConfig?: string): Promise<{
+    path: string;
+    config: any;
+}>;
+/**
+ * Derives the wrangler config the dev sidecar runs from the user's config:
+ * `main` points at the source entry point, the name gets a `-dev-worker`
+ * suffix, the dev port is set, and `assets` is dropped.
+ *
+ * The same config is what `wrangler types` should read: generating from the
+ * user's config (whose `main` is the SvelteKit build output) makes wrangler
+ * emit `mainModule: typeof import(".svelte-kit/cloudflare/_worker")` and
+ * untyped Durable Object bindings.
+ */
+export declare function deriveDevWorkerConfig(baseConfig: any, options: Pick<AddWorkerExportsOptions, 'entryPoint' | 'devPort'>): any;
+/**
+ * Reads the wrangler config, derives the dev-worker config and writes it to
+ * `outPath`. Lets `wrangler types --config .dev-worker-wrangler.jsonc` run
+ * without starting `vite dev` (e.g. in CI, with `--check`). Returns the
+ * absolute path written.
+ */
+export declare function writeDevWorkerConfig(options: AddWorkerExportsOptions, outPath?: string): Promise<string>;

package/dist/index.js

@@ -24,11 +24,14 @@ 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 { connect } from 'node:net';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
 import { getNodeCompat } from 'miniflare';
 import { parse as parseToml } from 'smol-toml';
+import { createModuleRulesPlugin, toModuleRule } from './moduleRules.js';
+export { createModuleRulesPlugin, toModuleRule, WRANGLER_DEFAULT_MODULE_RULES } from './moduleRules.js';
 /**
  * Parses a wrangler config file. Picks the parser by extension:
  * `.toml` uses smol-toml; everything else (`.jsonc`, `.json`, or no
@@ -90,6 +93,42 @@ function getWranglerRegistryPath() {
     }
     return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), '.wrangler', 'registry');
 }
+/**
+ * Deletes `name`'s dev-registry entry if nothing is listening on its debug
+ * port. A sidecar that doesn't shut down cleanly (killed, crashed) leaves its
+ * entry behind, and the next sidecar with the same name doesn't replace it:
+ * `platform.env` calls then go to the dead address and fail with "Network
+ * connection lost" until the file is deleted. A live entry (e.g. another
+ * `vite dev` of the same app) is left alone.
+ */
+export async function removeDeadRegistryEntry(registryPath, name) {
+    const entryPath = join(registryPath, name);
+    let address;
+    try {
+        address = JSON.parse(await readFile(entryPath, 'utf-8')).debugPortAddress;
+    }
+    catch {
+        return; // no entry, or one we can't parse -- leave it to wrangler
+    }
+    if (typeof address === 'string' && (await isListening(address)))
+        return;
+    await unlink(entryPath).catch(() => { });
+}
+function isListening(address, timeoutMs = 1_000) {
+    const separator = address.lastIndexOf(':');
+    const host = address.slice(0, separator);
+    const port = Number(address.slice(separator + 1));
+    return new Promise((resolve) => {
+        const socket = connect({ host, port });
+        const done = (listening) => {
+            socket.destroy();
+            resolve(listening);
+        };
+        socket.setTimeout(timeoutMs, () => done(false));
+        socket.once('connect', () => done(true));
+        socket.once('error', () => done(false));
+    });
+}
 /**
  * Returns two Vite plugins: one for build (patches _worker.js) and one for
  * dev (starts a wrangler dev server for Durable Objects).
@@ -105,7 +144,7 @@ function getWranglerRegistryPath() {
  * ```
  */
 export function addWorkerExports(options) {
-    return [buildPlugin(options), devPlugin(options)];
+    return [buildPlugin(options), ...devPlugins(options)];
 }
 /**
  * Patches the adapter-generated `_worker.js`: bundles the named exports into
@@ -117,6 +156,27 @@ export function addWorkerExports(options) {
  * Returns `true` if it patched (or had already patched), `false` if the
  * adapter hasn't written `_worker.js` yet.
  */
+/**
+ * Reads the module `rules` from the wrangler config (auto-discovered, or
+ * `options.wranglerConfig` when set) for the build-mode bundle. Wrangler
+ * resolves `CLOUDFLARE_ENV` and per-env `rules` inheritance itself.
+ *
+ * When no config is found by auto-discovery, wrangler returns an empty
+ * config, so this yields no user rules (wrangler's default rules still
+ * apply). A missing `wranglerConfig` path, a syntax error, or a validation
+ * error throws and fails the build — the same config would fail
+ * `wrangler dev`/`deploy`, so surfacing it here is strictly earlier, not a
+ * new requirement.
+ */
+export async function readModuleRules(options) {
+    // Dynamic import: loading wrangler's bundle takes ~500ms, and this module
+    // is evaluated on every vite invocation via vite.config.ts. Deferring the
+    // import to the once-per-run call sites (here and the dev plugin's
+    // configureServer) keeps that cost out of vite's config load.
+    const { unstable_readConfig } = await import('wrangler');
+    const config = unstable_readConfig(options.wranglerConfig ? { config: options.wranglerConfig } : {}, { hideWarnings: true });
+    return (config.rules ?? []).map(toModuleRule);
+}
 async function patchWorker(options) {
     const outputDir = resolve(options.outputDir ?? '.svelte-kit/cloudflare');
     const workerPath = resolve(outputDir, '_worker.js');
@@ -143,6 +203,10 @@ async function patchWorker(options) {
     // `require('path')` or `import 'node:async_hooks'` survive bundling;
     // the Workers runtime resolves them when `nodejs_compat` is enabled
     // in wrangler.jsonc.
+    //
+    // The module-rules plugin applies the wrangler config's `rules` (plus
+    // wrangler's defaults, e.g. `.sql`/`.txt` as Text), matching what
+    // wrangler's own bundler does for the dev sidecar. See moduleRules.ts.
     await build({
         entryPoints: [options.entryPoint],
         bundle: true,
@@ -151,6 +215,7 @@ async function patchWorker(options) {
         target: 'esnext',
         conditions: ['workerd', 'worker', 'browser'],
         external: ['cloudflare:*', ...NODE_BUILTINS, ...NODE_BUILTINS.map((m) => `node:${m}`)],
+        plugins: [createModuleRulesPlugin(await readModuleRules(options))],
         outfile: exportsPath
     });
     // Rename original worker and create merged entry point.
@@ -204,116 +269,191 @@ function buildPlugin(options) {
         }
     };
 }
-function devPlugin(options) {
+/** Default file name for the derived dev-worker wrangler config. */
+export const DEV_WORKER_CONFIG_FILE = '.dev-worker-wrangler.jsonc';
+/**
+ * Reads and parses the raw wrangler config (auto-discovered, or
+ * `wranglerConfig` when set). Returns the unresolved file contents — not
+ * wrangler's normalised config — so derived configs stay close to what the
+ * user wrote.
+ */
+export async function readWranglerConfig(wranglerConfig) {
+    // Dynamic import — see readModuleRules for why.
+    const { unstable_readConfig } = await import('wrangler');
+    const parsed = unstable_readConfig(wranglerConfig ? { config: wranglerConfig } : {});
+    const path = parsed.configPath;
+    if (!path) {
+        throw new Error(wranglerConfig
+            ? `Could not read wrangler config at ${wranglerConfig}`
+            : 'No wrangler config (wrangler.jsonc, wrangler.json or wrangler.toml) found');
+    }
+    const contents = await readFile(path, 'utf-8');
+    return { path, config: parseWranglerConfig(path, contents) };
+}
+/**
+ * Derives the wrangler config the dev sidecar runs from the user's config:
+ * `main` points at the source entry point, the name gets a `-dev-worker`
+ * suffix, the dev port is set, and `assets` is dropped.
+ *
+ * The same config is what `wrangler types` should read: generating from the
+ * user's config (whose `main` is the SvelteKit build output) makes wrangler
+ * emit `mainModule: typeof import(".svelte-kit/cloudflare/_worker")` and
+ * untyped Durable Object bindings.
+ */
+export function deriveDevWorkerConfig(baseConfig, options) {
+    const devConfig = structuredClone(baseConfig);
+    devConfig.name = devWorkerName(baseConfig);
+    devConfig.main = options.entryPoint;
+    devConfig.dev = { ...devConfig.dev, port: options.devPort ?? DEFAULT_DEV_PORT };
+    delete devConfig.assets;
+    return devConfig;
+}
+/**
+ * Reads the wrangler config, derives the dev-worker config and writes it to
+ * `outPath`. Lets `wrangler types --config .dev-worker-wrangler.jsonc` run
+ * without starting `vite dev` (e.g. in CI, with `--check`). Returns the
+ * absolute path written.
+ */
+export async function writeDevWorkerConfig(options, outPath = DEV_WORKER_CONFIG_FILE) {
+    const { config } = await readWranglerConfig(options.wranglerConfig);
+    const path = resolve(outPath);
+    await writeFile(path, JSON.stringify(deriveDevWorkerConfig(config, options), null, '\t'));
+    return path;
+}
+function devWorkerName(baseConfig) {
+    return `${baseConfig.name ?? 'sveltekit'}-dev-worker`;
+}
+function devPlugins(options) {
     const devPort = options.devPort ?? DEFAULT_DEV_PORT;
     let worker = null;
     let tempConfigPath = null;
     let proxyConfigPath = null;
-    async function readRawConfig() {
-        const { unstable_readConfig } = await import('wrangler');
-        const parsed = unstable_readConfig(options.wranglerConfig ? { config: options.wranglerConfig } : {});
-        const path = parsed.configPath;
-        const contents = await readFile(path, 'utf-8');
-        return { path, contents };
+    let sidecarName = '';
+    let registeredSidecarName = '';
+    /**
+     * Writes `.dev-worker-wrangler.jsonc` (the sidecar's config) and
+     * `.platform-proxy-wrangler.jsonc` (for adapter-cloudflare's
+     * `getPlatformProxy`).
+     */
+    async function writeConfigs() {
+        const { config: baseConfig } = await readWranglerConfig(options.wranglerConfig);
+        sidecarName = devWorkerName(baseConfig);
+        // 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;
+        registeredSidecarName = envName ? `${sidecarName}-${envName}` : sidecarName;
+        // The user can also pass this file to `wrangler types --config
+        // .dev-worker-wrangler.jsonc` to get typed bindings like
+        // DurableObjectNamespace<EchoDO> resolved from the source entry.
+        // Outside of dev, `writeDevWorkerConfig` writes the same file.
+        const devConfig = deriveDevWorkerConfig(baseConfig, options);
+        tempConfigPath = resolve(DEV_WORKER_CONFIG_FILE);
+        await writeFile(tempConfigPath, JSON.stringify(devConfig, null, '\t'));
+        // 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 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 = 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 (activeScope.durable_objects?.bindings) {
+            activeScope.durable_objects.bindings = activeScope.durable_objects.bindings.map((b) => b.script_name ? b : { ...b, script_name: registeredSidecarName });
+        }
+        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'));
     }
-    return {
-        name: 'add-worker-exports-dev',
-        apply: 'serve',
-        config() {
-            return {
-                define: {
-                    __DEV_WORKER_PORT__: JSON.stringify(devPort)
-                }
-            };
-        },
-        async configureServer(server) {
-            const { unstable_startWorker } = await import('wrangler');
-            const { path: configPath, contents } = await readRawConfig();
-            const baseConfig = parseWranglerConfig(configPath, contents);
-            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 = structuredClone(baseConfig);
-            devConfig.name = sidecarName;
-            devConfig.main = options.entryPoint;
-            devConfig.dev = { ...devConfig.dev, port: devPort };
-            delete devConfig.assets;
-            // The user can also pass this file to `wrangler types --config
-            // .dev-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, 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
-            // 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 = 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 (activeScope.durable_objects?.bindings) {
-                activeScope.durable_objects.bindings = activeScope.durable_objects.bindings.map((b) => b.script_name ? b : { ...b, script_name: registeredSidecarName });
+    return [
+        // Writes the config files before other plugins' dev-server hooks run.
+        // adapter-cloudflare 8 calls `getPlatformProxy` from its own
+        // `configureServer`, which reads `.platform-proxy-wrangler.jsonc` and
+        // fails on a fresh checkout if we haven't written it yet. Vite awaits
+        // these hooks in order.
+        {
+            name: 'add-worker-exports-dev-config',
+            apply: 'serve',
+            configureServer: {
+                order: 'pre',
+                handler: writeConfigs
             }
-            if (Array.isArray(activeScope.workflows)) {
-                activeScope.workflows = activeScope.workflows.map((w) => w.script_name ? w : { ...w, script_name: registeredSidecarName });
+        },
+        // Starts the sidecar in normal order, after SvelteKit's hooks. Starting
+        // it earlier makes wrangler reload it when SvelteKit regenerates files
+        // the bundle watches (e.g. the tsconfig chain), dropping in-flight work
+        // such as a just-created Workflow.
+        {
+            name: 'add-worker-exports-dev',
+            apply: 'serve',
+            // Lets the CLI (`sveltekit-add-worker-exports write-config`) find the
+            // plugin options in a loaded vite config.
+            api: { options },
+            config() {
+                return {
+                    define: {
+                        __DEV_WORKER_PORT__: JSON.stringify(devPort)
+                    }
+                };
+            },
+            async configureServer(server) {
+                // Dynamic import — see readModuleRules for why.
+                const { unstable_startWorker } = await import('wrangler');
+                const structuredLogsHandler = options.structuredLogsHandler ?? makeDefaultWorkerLogHandler(sidecarName);
+                const registryPath = getWranglerRegistryPath();
+                await removeDeadRegistryEntry(registryPath, registeredSidecarName);
+                worker = await unstable_startWorker({
+                    config: tempConfigPath,
+                    // `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.
+                    //
+                    // `structuredLogsHandler` (added in wrangler 4.99) routes each
+                    // worker log line through `onWorkerLog`. Without it, wrangler
+                    // pipes worker logs through its own Logger which can get
+                    // swallowed when `unstable_startWorker` is driven
+                    // programmatically — `console.log` inside the worker
+                    // disappears. Cast is needed because peer wrangler types may
+                    // be older.
+                    dev: {
+                        registry: registryPath,
+                        testScheduled: true,
+                        structuredLogsHandler
+                    },
+                    build: {
+                        nodejsCompatMode: (parsedConfig) => getNodejsCompatMode(parsedConfig.compatibility_date, parsedConfig.compatibility_flags)
+                    }
+                });
+                server.httpServer?.on('close', async () => {
+                    if (worker) {
+                        await worker.dispose();
+                        worker = null;
+                    }
+                    if (tempConfigPath) {
+                        await unlink(tempConfigPath).catch(() => { });
+                    }
+                    if (proxyConfigPath) {
+                        await unlink(proxyConfigPath).catch(() => { });
+                    }
+                });
             }
-            delete activeScope.migrations;
-            proxyConfigPath = resolve('.platform-proxy-wrangler.jsonc');
-            await writeFile(proxyConfigPath, JSON.stringify(proxyConfig, null, '\t'));
-            const structuredLogsHandler = options.structuredLogsHandler ?? makeDefaultWorkerLogHandler(sidecarName);
-            worker = await unstable_startWorker({
-                config: tempConfigPath,
-                // `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.
-                //
-                // `structuredLogsHandler` (added in wrangler 4.99) routes each
-                // worker log line through `onWorkerLog`. Without it, wrangler
-                // pipes worker logs through its own Logger which can get
-                // swallowed when `unstable_startWorker` is driven
-                // programmatically — `console.log` inside the worker
-                // disappears. Cast is needed because peer wrangler types may
-                // be older.
-                dev: {
-                    registry: getWranglerRegistryPath(),
-                    testScheduled: true,
-                    structuredLogsHandler
-                },
-                build: {
-                    nodejsCompatMode: (parsedConfig) => getNodejsCompatMode(parsedConfig.compatibility_date, parsedConfig.compatibility_flags)
-                }
-            });
-            server.httpServer?.on('close', async () => {
-                if (worker) {
-                    await worker.dispose();
-                    worker = null;
-                }
-                if (tempConfigPath) {
-                    await unlink(tempConfigPath).catch(() => { });
-                }
-                if (proxyConfigPath) {
-                    await unlink(proxyConfigPath).catch(() => { });
-                }
-            });
         }
-    };
+    ];
 }
 /**
  * Default handler for sidecar worker logs. Writes each line to stdout (or

package/dist/moduleRules.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Translates wrangler module `rules` into an esbuild plugin so the build-mode
+ * bundle honors the same contract wrangler's own bundler honors in dev.
+ *
+ * Wrangler config rules look like
+ * `{ "type": "Text", "globs": ["**\/*.sql"], "fallthrough": true }` and make
+ * matching imports resolve to the file contents (as a string for `Text`, an
+ * `ArrayBuffer` for `Data`). Wrangler applies them — plus a set of default
+ * rules — whenever it bundles a worker (`wrangler dev`, `wrangler deploy`,
+ * and this plugin's dev sidecar). The build-mode `esbuild.build()` call in
+ * `patchWorker` runs outside wrangler, so without this plugin a `.sql` import
+ * that works in dev fails the production build with "No loader is configured".
+ * See https://github.com/oselvar/sveltekit-add-worker-exports/issues/8
+ *
+ * Wrangler exports none of its rules machinery, but miniflare (already a peer
+ * dependency) exports `compileModuleRules`/`testRegExps` with the same
+ * fallthrough semantics, so only wrangler's default rule list is replicated
+ * here. One divergence: miniflare compiles globs with `globstar: true` and
+ * matches resolved file paths, while wrangler's bundler compiles with
+ * `globstar: false` and matches import specifiers. The canonical shapes
+ * (`**\/*.sql`, `**\/*.txt`) behave identically under both.
+ */
+import type { Plugin as EsbuildPlugin } from 'esbuild';
+import { type ModuleRule, type ModuleRuleType } from 'miniflare';
+/** A module rule as it appears in wrangler config (miniflare uses `include`). */
+export interface WranglerRule {
+    type: ModuleRuleType;
+    globs: string[];
+    fallthrough?: boolean;
+}
+export declare function toModuleRule(rule: WranglerRule): ModuleRule;
+/**
+ * Wrangler's `DEFAULT_MODULE_RULES` (src/deployment-bundle/rules.ts), in
+ * miniflare's shape. Wrangler appends these after user rules everywhere it
+ * bundles, so the plugin does the same — `.sql`, `.txt`, and `.html` imports
+ * work with no `rules` config at all, matching `wrangler dev`.
+ */
+export declare const WRANGLER_DEFAULT_MODULE_RULES: ModuleRule[];
+/**
+ * Builds an esbuild plugin that applies `userRules` followed by wrangler's
+ * default rules, first match wins. Matching honors wrangler's fallthrough
+ * semantics: the first rule of a type without `fallthrough: true` finalises
+ * that type, and a file matching only a later (shadowed) rule of that type
+ * fails the build with wrangler's own actionable error.
+ */
+export declare function createModuleRulesPlugin(userRules: ModuleRule[]): EsbuildPlugin;

package/dist/moduleRules.js

@@ -0,0 +1,130 @@
+/**
+ * Translates wrangler module `rules` into an esbuild plugin so the build-mode
+ * bundle honors the same contract wrangler's own bundler honors in dev.
+ *
+ * Wrangler config rules look like
+ * `{ "type": "Text", "globs": ["**\/*.sql"], "fallthrough": true }` and make
+ * matching imports resolve to the file contents (as a string for `Text`, an
+ * `ArrayBuffer` for `Data`). Wrangler applies them — plus a set of default
+ * rules — whenever it bundles a worker (`wrangler dev`, `wrangler deploy`,
+ * and this plugin's dev sidecar). The build-mode `esbuild.build()` call in
+ * `patchWorker` runs outside wrangler, so without this plugin a `.sql` import
+ * that works in dev fails the production build with "No loader is configured".
+ * See https://github.com/oselvar/sveltekit-add-worker-exports/issues/8
+ *
+ * Wrangler exports none of its rules machinery, but miniflare (already a peer
+ * dependency) exports `compileModuleRules`/`testRegExps` with the same
+ * fallthrough semantics, so only wrangler's default rule list is replicated
+ * here. One divergence: miniflare compiles globs with `globstar: true` and
+ * matches resolved file paths, while wrangler's bundler compiles with
+ * `globstar: false` and matches import specifiers. The canonical shapes
+ * (`**\/*.sql`, `**\/*.txt`) behave identically under both.
+ */
+import { readFile } from 'node:fs/promises';
+import { compileModuleRules, globsToRegExps, testRegExps } from 'miniflare';
+export function toModuleRule(rule) {
+    return { type: rule.type, include: rule.globs, fallthrough: rule.fallthrough };
+}
+/**
+ * Wrangler's `DEFAULT_MODULE_RULES` (src/deployment-bundle/rules.ts), in
+ * miniflare's shape. Wrangler appends these after user rules everywhere it
+ * bundles, so the plugin does the same — `.sql`, `.txt`, and `.html` imports
+ * work with no `rules` config at all, matching `wrangler dev`.
+ */
+export const WRANGLER_DEFAULT_MODULE_RULES = [
+    { type: 'Text', include: ['**/*.txt', '**/*.html', '**/*.sql'] },
+    { type: 'Data', include: ['**/*.bin'] },
+    { type: 'CompiledWasm', include: ['**/*.wasm', '**/*.wasm?module'] }
+];
+/** Rules esbuild already handles natively; wrangler skips these too. */
+function isJavaScriptRuleType(type) {
+    return type === 'ESModule' || type === 'CommonJS';
+}
+/**
+ * Builds an esbuild plugin that applies `userRules` followed by wrangler's
+ * default rules, first match wins. Matching honors wrangler's fallthrough
+ * semantics: the first rule of a type without `fallthrough: true` finalises
+ * that type, and a file matching only a later (shadowed) rule of that type
+ * fails the build with wrangler's own actionable error.
+ */
+export function createModuleRulesPlugin(userRules) {
+    const allRules = [...userRules, ...WRANGLER_DEFAULT_MODULE_RULES];
+    // `compileModuleRules` keeps the same rules wrangler's `parseRules` keeps.
+    // JS rules are dropped from the match loop — esbuild's default handling is
+    // exactly their meaning — but they still participate in fallthrough
+    // finalisation above, like in wrangler.
+    const kept = compileModuleRules(allRules).filter((rule) => !isJavaScriptRuleType(rule.type));
+    // Recompute which rules `compileModuleRules` dropped, so files matching
+    // only a shadowed rule get wrangler's error instead of esbuild's opaque
+    // "No loader is configured".
+    const finalisedTypes = new Set();
+    const removed = [];
+    for (const rule of allRules) {
+        if (finalisedTypes.has(rule.type)) {
+            removed.push({ rule, include: globsToRegExps(rule.include, { endAnchor: true }) });
+        }
+        else if (!rule.fallthrough) {
+            finalisedTypes.add(rule.type);
+        }
+    }
+    return {
+        name: 'wrangler-module-rules',
+        setup(build) {
+            build.onLoad({ filter: /.*/ }, async (args) => {
+                // Match with `/` separators so globs behave the same on Windows.
+                const path = args.path.replaceAll('\\', '/');
+                for (const rule of kept) {
+                    if (testRegExps(rule.include, path)) {
+                        return loadModule(rule.type, args.path);
+                    }
+                }
+                for (const { rule, include } of removed) {
+                    if (testRegExps(include, path)) {
+                        return {
+                            errors: [
+                                {
+                                    text: `The file ${args.path} matched a module rule in your configuration ` +
+                                        `(${JSON.stringify({ type: rule.type, globs: rule.include })}), but was ignored because a ` +
+                                        'previous rule with the same type was not marked as `fallthrough = true`.'
+                                }
+                            ]
+                        };
+                    }
+                }
+                return undefined;
+            });
+        }
+    };
+}
+async function loadModule(type, path) {
+    switch (type) {
+        case 'Text':
+            // esbuild's text loader default-exports the contents as a string,
+            // exactly like a workerd Text module.
+            return { contents: await readFile(path, 'utf-8'), loader: 'text' };
+        case 'Data': {
+            // workerd Data modules import as an ArrayBuffer, but esbuild's
+            // `binary` loader yields a Uint8Array — so inline a stub that
+            // decodes to the exact runtime type.
+            const base64 = (await readFile(path)).toString('base64');
+            return {
+                contents: `const bytes = Uint8Array.from(atob(${JSON.stringify(base64)}), (c) => c.charCodeAt(0));\n` +
+                    'export default bytes.buffer;\n',
+                loader: 'js'
+            };
+        }
+        default:
+            // CompiledWasm / PythonModule / PythonRequirement: workerd loads
+            // these as separate deploy-time modules, which can't be inlined
+            // into the single-file _extra_exports.js bundle. (Workers forbids
+            // compiling WebAssembly from bytes at runtime.)
+            return {
+                errors: [
+                    {
+                        text: `"${type}" module rules are not supported by @oselvar/sveltekit-add-worker-exports: ` +
+                            `${path} cannot be inlined into the single-file worker bundle.`
+                    }
+                ]
+            };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oselvar/sveltekit-add-worker-exports",
-	"version": "2.1.1",
+	"version": "2.2.0",
 	"description": "Vite plugin that adds Durable Object and Workflow exports to SvelteKit Cloudflare workers",
 	"type": "module",
 	"publishConfig": {
@@ -12,7 +12,11 @@
 			"import": "./dist/index.js"
 		}
 	},
+	"bin": {
+		"sveltekit-add-worker-exports": "./bin/sveltekit-add-worker-exports.js"
+	},
 	"files": [
+		"bin",
 		"dist"
 	],
 	"license": "MIT",
@@ -37,24 +41,33 @@
 	},
 	"devDependencies": {
 		"@release-it/conventional-changelog": "^11.0.1",
-		"@sveltejs/kit": "^2.66.0",
-		"@types/node": "^26.0.0",
-		"esbuild": "^0.28.1",
-		"miniflare": "^4.20260617.1",
-		"release-it": "^20.2.0",
-		"typescript": "^6.0.3",
-		"vite": "^8.0.16",
-		"vitest": "^4.1.9",
-		"wrangler": "^4.103.0"
+		"@sveltejs/kit": "^2.70.3",
+		"@types/node": "^26.6.2",
+		"esbuild": "^0.28.2",
+		"miniflare": "^4.20260730.0",
+		"release-it": "^20.2.1",
+		"typescript": "^7.0.2",
+		"vite": "^8.3.0",
+		"vitest": "^4.1.11",
+		"wrangler": "^4.136.2"
 	},
 	"scripts": {
 		"build": "tsc",
 		"test": "vitest run && tsc --noEmit",
+		"test:acceptance": "pnpm build && vitest run --config vitest.acceptance.config.ts",
 		"prepublishOnly": "tsc",
 		"release": "release-it"
 	},
+	"packageManager": "pnpm@11.9.0",
+	"devEngines": {
+		"runtime": {
+			"name": "node",
+			"version": ">=26",
+			"onFail": "warn"
+		}
+	},
 	"dependencies": {
 		"jsonc-parser": "^3.3.1",
-		"smol-toml": "^1.6.1"
+		"smol-toml": "^1.8.0"
 	}
 }