devflare 1.0.0-next.34 → 1.0.0-next.36

package/dist/{dev-9scy9gap.js → dev-mkhjdwh7.js}

@@ -1,9 +1,20 @@
+import {
+  buildLocalSecretWrappedBindingConfig
+} from "./index-kcp7y951.js";
+import {
+  bundleWorkerEntry,
+  createDOBundler
+} from "./index-mjvybn39.js";
 import {
   detectViteProject,
   resolveViteMode,
   stopSpawnedProcessTree,
   waitForViteReady
 } from "./index-zdd0d9qa.js";
+import {
+  clearLocalSendEmailBindings,
+  setLocalSendEmailBindings
+} from "./index-n4xkaymm.js";
 import {
   createCliTheme,
   cyanBold,
@@ -12,25 +23,11 @@ import {
   yellow
 } from "./index-maw0jjnn.js";
 import"./index-3t6rypgc.js";
-import {
-  bundleWorkflowEntrypointScript
-} from "./index-pmnb7eke.js";
-import {
-  bundleWorkerEntry,
-  createDOBundler
-} from "./index-dem45895.js";
 import {
   DEFAULT_EMAIL_ENTRY_FILES,
   DEFAULT_FETCH_ENTRY_FILES,
   DEFAULT_QUEUE_ENTRY_FILES,
   DEFAULT_SCHEDULED_ENTRY_FILES,
-  hasWorkerSurfacePaths,
-  prepareComposedWorkerEntrypoint,
-  resolveEffectiveViteProject,
-  resolveWorkerSurfacePaths,
-  writeGeneratedViteConfig
-} from "./index-bhxj7ff6.js";
-import {
   buildAiSearchInstancesConfig,
   buildAiSearchNamespacesConfig,
   buildArtifactsConfig,
@@ -50,55 +47,46 @@ import {
   buildWorkflowsConfig,
   discoverRoutes,
   getRouteDirectoryCandidate,
-  resolveServiceBindings
-} from "./index-dgx495pv.js";
+  hasWorkerSurfacePaths,
+  prepareComposedWorkerEntrypoint,
+  resolveEffectiveViteProject,
+  resolveServiceBindings,
+  resolveWorkerSurfacePaths,
+  writeGeneratedViteConfig
+} from "./index-e251zhns.js";
 import"./index-by27mzra.js";
-import"./index-5dkjffqz.js";
-import"./index-7m557715.js";
-import"./index-p93cngdp.js";
 import {
-  GATEWAY_RUNTIME_JS,
-  createMiniflareLog,
-  isIgnorableMiniflareDisposeError
-} from "./index-za0r01bx.js";
-import {
-  buildLocalBindingShimServiceConfig
-} from "./index-dm9q84c7.js";
-import {
-  buildLocalSecretWrappedBindingConfig
-} from "./index-13sfensw.js";
-import {
-  clearLocalSendEmailBindings,
-  setLocalSendEmailBindings
-} from "./index-n4xkaymm.js";
+  DEFAULT_WORKFLOW_PATTERN,
+  findFiles
+} from "./index-5dkjffqz.js";
 import {
   applyLocalDevVarsToConfig
-} from "./index-w8c8tjc5.js";
+} from "./index-mek9msfv.js";
 import {
+  EnvVarResolutionError,
+  getDevflareDotenvPaths,
   getLocalD1DatabaseIdentifier,
   getLocalKVNamespaceIdentifier,
   getSingleBrowserBindingName,
   loadConfig,
+  normalizeWorkflowBinding,
+  resolveConfigEnvVars,
   resolveConfigPath
-} from "./index-pd97hk2j.js";
+} from "./index-x8s9rwfh.js";
 import"./index-h7r11y4a.js";
 import"./index-04wh9bxx.js";
-import {
-  EnvVarResolutionError,
-  getDevflareDotenvPaths,
-  resolveConfigEnvVars
-} from "./index-wxdcrzcp.js";
-import"./index-34dejneh.js";
+import"./index-7m557715.js";
+import"./index-p93cngdp.js";
 import {
   __require
 } from "./index-37x76zdn.js";
 
 // src/cli/commands/dev.ts
 import { createConsola } from "consola";
-import { relative, resolve as resolve7 } from "pathe";
+import { relative as relative2, resolve as resolve8 } from "pathe";
 
 // src/dev-server/server.ts
-import { dirname as dirname2, resolve as resolve6 } from "pathe";
+import { dirname as dirname3, resolve as resolve7 } from "pathe";
 
 // src/cli/wrangler-auth.ts
 import { exec } from "node:child_process";
@@ -173,9 +161,106 @@ async function checkRemoteBindingRequirements(config) {
   };
 }
 
+// src/workflows/local-workflow-entrypoints.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative, resolve } from "pathe";
+function findExportedClasses(code) {
+  const classes = [];
+  const classPattern = /export\s+class\s+(\w+)/g;
+  let match;
+  while ((match = classPattern.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+function toImportSpecifier(fromDir, filePath) {
+  const relativePath = relative(fromDir, filePath).replace(/\\/g, "/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+async function discoverWorkflowClasses(config, configDir) {
+  const classToFilePath = new Map;
+  const workflowPatternConfig = config.files?.workflows;
+  const workflowPattern = typeof workflowPatternConfig === "string" ? workflowPatternConfig : DEFAULT_WORKFLOW_PATTERN;
+  if (workflowPatternConfig === false) {
+    return classToFilePath;
+  }
+  const files = await findFiles(workflowPattern, { cwd: configDir });
+  for (const filePath of files) {
+    try {
+      const code = await readFile(filePath, "utf-8");
+      for (const className of findExportedClasses(code)) {
+        classToFilePath.set(className, filePath);
+      }
+    } catch {}
+  }
+  return classToFilePath;
+}
+async function resolveLocalWorkflowEntrypoints(config, configDir) {
+  const workflows = config.bindings?.workflows;
+  if (!workflows || Object.keys(workflows).length === 0) {
+    return [];
+  }
+  const classToFilePath = await discoverWorkflowClasses(config, configDir);
+  const entrypoints = [];
+  for (const [bindingName, binding] of Object.entries(workflows)) {
+    const normalized = normalizeWorkflowBinding(binding);
+    if (normalized.scriptName) {
+      continue;
+    }
+    const scriptPath = classToFilePath.get(normalized.className);
+    if (!scriptPath) {
+      throw new Error(`Workflow binding ${bindingName} (className: '${normalized.className}') not found.
+` + `Either set files.workflows to match the workflow source file, or set scriptName when the workflow lives in another worker.`);
+    }
+    entrypoints.push({
+      bindingName,
+      className: normalized.className,
+      scriptPath
+    });
+  }
+  return entrypoints;
+}
+function buildWorkflowVirtualEntry(entrypoints, entryDir) {
+  const imports = entrypoints.map((entrypoint, index) => {
+    const importName = `__DevflareWorkflow${index}`;
+    const importPath = toImportSpecifier(entryDir, entrypoint.scriptPath);
+    return {
+      importName,
+      className: entrypoint.className,
+      line: `import { ${entrypoint.className} as ${importName} } from '${importPath}'`
+    };
+  });
+  const exports = imports.map((entrypoint) => {
+    return `export { ${entrypoint.importName} as ${entrypoint.className} }`;
+  });
+  return [...imports.map((entrypoint) => entrypoint.line), "", ...exports].join(`
+`);
+}
+async function bundleWorkflowEntrypointScript(config, configDir, options = {}) {
+  const entrypoints = await resolveLocalWorkflowEntrypoints(config, configDir);
+  if (entrypoints.length === 0) {
+    return "";
+  }
+  const entryDir = resolve(configDir, ".devflare", "workflow-entrypoints");
+  const entryPath = join(entryDir, "__entry.ts");
+  const outFile = join(entryDir, "index.js");
+  await mkdir(entryDir, { recursive: true });
+  await writeFile(entryPath, buildWorkflowVirtualEntry(entrypoints, entryDir));
+  await bundleWorkerEntry({
+    cwd: configDir,
+    inputFile: entryPath,
+    outFile,
+    rolldownOptions: config.rolldown?.options,
+    sourcemap: config.rolldown?.sourcemap,
+    minify: config.rolldown?.minify,
+    logger: options.logger
+  });
+  return await readFile(outFile, "utf-8");
+}
+
 // src/dev-server/d1-migrations.ts
 import { createHash } from "node:crypto";
-import { resolve } from "pathe";
+import { resolve as resolve2 } from "pathe";
 var MIGRATION_RETRY_DELAYS_MS = [500, 1000, 1500, 2000];
 function collectMigrationStatements(sql) {
   const cleanedSql = sql.split(`
@@ -238,7 +323,7 @@ async function runD1Migrations(options) {
     return;
   }
   const { existsSync, readdirSync, readFileSync, statSync } = await import("node:fs");
-  const migrationsDir = resolve(cwd, "migrations");
+  const migrationsDir = resolve2(cwd, "migrations");
   if (!existsSync(migrationsDir)) {
     logger?.debug("No migrations/ directory found, skipping D1 migrations");
     return;
@@ -248,7 +333,7 @@ async function runD1Migrations(options) {
   if (sharedFiles.length > 0) {
     sharedFileEntries = [];
     for (const file of sharedFiles) {
-      const sql = readFileSync(resolve(migrationsDir, file), "utf-8");
+      const sql = readFileSync(resolve2(migrationsDir, file), "utf-8");
       const fileStatements = collectMigrationStatements(sql);
       sharedFileEntries.push({
         filename: file,
@@ -259,7 +344,7 @@ async function runD1Migrations(options) {
     }
   }
   for (const [bindingName] of Object.entries(config.bindings.d1)) {
-    const perBindingDir = resolve(migrationsDir, bindingName);
+    const perBindingDir = resolve2(migrationsDir, bindingName);
     const hasPerBindingDir = existsSync(perBindingDir) && statSync(perBindingDir).isDirectory();
     let files = [];
     let sourceLabel = "";
@@ -270,7 +355,7 @@ async function runD1Migrations(options) {
         continue;
       }
       for (const file of perBindingFiles) {
-        const sql = readFileSync(resolve(perBindingDir, file), "utf-8");
+        const sql = readFileSync(resolve2(perBindingDir, file), "utf-8");
         const fileStatements = collectMigrationStatements(sql);
         files.push({
           filename: file,
@@ -303,6 +388,819 @@ async function runD1Migrations(options) {
   }
 }
 
+// src/dev-server/miniflare-log.ts
+var ANSI_ESCAPE_REGEX = /\u001B\[[0-9;]*m/g;
+var COMPATIBILITY_DATE_FALLBACK_REGEX = /^The latest compatibility date supported by the installed Cloudflare Workers Runtime is "([^"]+)", but you've requested "([^"]+)"\. Falling back to "([^"]+)"\.\.\.$/;
+var MINIFLARE_LOG_LEVEL_FALLBACKS = {
+  WARN: 2,
+  DEBUG: 4
+};
+function normalizeMiniflareMessage(message) {
+  return message.replace(ANSI_ESCAPE_REGEX, "").replace(/\s+/g, " ").trim();
+}
+function formatCompatibilityDateFallbackNotice(message) {
+  const normalizedMessage = normalizeMiniflareMessage(message);
+  const match = COMPATIBILITY_DATE_FALLBACK_REGEX.exec(normalizedMessage);
+  if (!match) {
+    return null;
+  }
+  const [, _supportedDate, requestedDate, fallbackDate] = match;
+  return `Using latest supported Cloudflare Workers Runtime compatibility date ${fallbackDate} (requested ${requestedDate})`;
+}
+function resolveMiniflareLogLevel(logLevel, levelName) {
+  return logLevel?.[levelName] ?? MINIFLARE_LOG_LEVEL_FALLBACKS[levelName];
+}
+function createMiniflareLog(BaseLog, logLevel, levelName, logger) {
+  if (!BaseLog) {
+    return;
+  }
+  return createCompatibilityAwareMiniflareLog(BaseLog, resolveMiniflareLogLevel(logLevel, levelName), logger);
+}
+function createCompatibilityAwareMiniflareLog(BaseLog, level, logger) {
+  const log = new BaseLog(level);
+  const originalWarn = log.warn.bind(log);
+  const originalInfo = log.info.bind(log);
+  log.warn = (message) => {
+    const notice = formatCompatibilityDateFallbackNotice(message);
+    if (!notice) {
+      originalWarn(message);
+      return;
+    }
+    if (logger) {
+      logger.info(notice);
+      return;
+    }
+    originalInfo(notice);
+  };
+  return log;
+}
+
+// src/shims/local-media-bindings.ts
+var LOCAL_MEDIA_BINDING_SCRIPT = `
+import { RpcTarget, WorkerEntrypoint } from 'cloudflare:workers'
+
+function emptyStream() {
+	return new ReadableStream({
+		start(controller) {
+			controller.close()
+		}
+	})
+}
+
+function normalizeContentType(value, fallback) {
+	if (typeof value !== 'string' || value.length === 0) return fallback
+	if (value.includes('/')) return value
+	if (value === 'jpg') return 'image/jpeg'
+	if (value === 'jpeg') return 'image/jpeg'
+	if (value === 'png') return 'image/png'
+	if (value === 'webp') return 'image/webp'
+	if (value === 'avif') return 'image/avif'
+	if (value === 'mp4') return 'video/mp4'
+	return value
+}
+
+async function readBytes(stream) {
+	return await new Response(stream || emptyStream()).arrayBuffer()
+}
+
+function streamFromBytes(bytes) {
+	return new Response(bytes.slice(0)).body || emptyStream()
+}
+
+function createBodyReader(bytes) {
+	return function takeBody() {
+		return streamFromBytes(bytes)
+	}
+}
+
+class LocalImageResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	contentType() {
+		return this.contentTypeValue
+	}
+
+	image() {
+		return this.takeBody()
+	}
+}
+
+class LocalImageTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return this
+	}
+
+	draw() {
+		return this
+	}
+
+	async output(options = {}) {
+		return new LocalImageResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'image/png')
+		)
+	}
+}
+
+function createHostedImagesBinding() {
+	const unsupported = () => {
+		throw new Error('Devflare local Images hosted API is not implemented. Use the transform/info APIs locally, or connect to Cloudflare for hosted image storage.')
+	}
+	return {
+		image() {
+			return {
+				details: unsupported,
+				bytes: unsupported,
+				update: unsupported,
+				delete: unsupported
+			}
+		},
+		upload: unsupported,
+		list: unsupported
+	}
+}
+
+export class LocalImagesBinding extends WorkerEntrypoint {
+	async info(stream) {
+		const bytes = await readBytes(stream)
+		return {
+			format: 'image/png',
+			fileSize: bytes.byteLength,
+			width: 1,
+			height: 1
+		}
+	}
+
+	async input(stream) {
+		return new LocalImageTransformer(await readBytes(stream))
+	}
+
+	get hosted() {
+		return createHostedImagesBinding()
+	}
+}
+
+class LocalMediaResult extends RpcTarget {
+	constructor(takeBody, contentType) {
+		super()
+		this.takeBody = takeBody
+		this.contentTypeValue = contentType
+	}
+
+	async media() {
+		return this.takeBody()
+	}
+
+	async response() {
+		return new Response(this.takeBody(), {
+			headers: { 'Content-Type': this.contentTypeValue }
+		})
+	}
+
+	async contentType() {
+		return this.contentTypeValue
+	}
+}
+
+class LocalMediaTransformationGenerator extends RpcTarget {
+	constructor(takeBody) {
+		super()
+		this.takeBody = takeBody
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+class LocalMediaTransformer extends RpcTarget {
+	constructor(bytes) {
+		super()
+		this.takeBody = createBodyReader(bytes)
+	}
+
+	transform() {
+		return new LocalMediaTransformationGenerator(this.takeBody)
+	}
+
+	output(options = {}) {
+		return new LocalMediaResult(
+			this.takeBody,
+			normalizeContentType(options.format, 'video/mp4')
+		)
+	}
+}
+
+export class LocalMediaBinding extends WorkerEntrypoint {
+	async input(stream) {
+		return new LocalMediaTransformer(await readBytes(stream))
+	}
+}
+
+export default {
+	fetch() {
+		return new Response('Devflare local Images/Media binding')
+	}
+}
+`;
+function toLocalShimWorkerName(kind, bindingName, index) {
+  const slug = bindingName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || kind;
+  return `devflare-local-${kind}-${index}-${slug}`;
+}
+function getEntrypoint(kind) {
+  return kind === "images" ? "LocalImagesBinding" : "LocalMediaBinding";
+}
+function buildLocalBindingShimServiceConfig(config) {
+  const entries = [
+    ...Object.keys(config.bindings?.images ?? {}).map((bindingName) => ({
+      bindingName,
+      kind: "images"
+    })),
+    ...Object.keys(config.bindings?.media ?? {}).map((bindingName) => ({
+      bindingName,
+      kind: "media"
+    }))
+  ];
+  return {
+    localBindingNames: entries.map((entry) => entry.bindingName),
+    serviceBindings: Object.fromEntries(entries.map((entry, index) => {
+      const workerName = toLocalShimWorkerName(entry.kind, entry.bindingName, index);
+      return [
+        entry.bindingName,
+        {
+          name: workerName,
+          entrypoint: getEntrypoint(entry.kind)
+        }
+      ];
+    })),
+    workers: entries.map((entry, index) => ({
+      name: toLocalShimWorkerName(entry.kind, entry.bindingName, index),
+      modules: true,
+      script: LOCAL_MEDIA_BINDING_SCRIPT,
+      compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+      ...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags }
+    }))
+  };
+}
+
+// src/bridge/gateway-runtime.ts
+var GATEWAY_RUNTIME_JS = `
+const RAW_EMAIL = 'EmailMessage::raw'
+
+function arrayBufferToBase64(buffer) {
+	const bytes = new Uint8Array(buffer)
+	let binary = ''
+	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i])
+	return btoa(binary)
+}
+
+function base64ToArrayBuffer(base64) {
+	const binary = atob(base64)
+	const bytes = new Uint8Array(binary.length)
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)
+	return bytes.buffer
+}
+
+function serializeR2Object(obj) {
+	if (!obj) return null
+	return {
+		__type: 'R2Object',
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		checksums: obj.checksums,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata,
+		range: obj.range,
+		storageClass: obj.storageClass
+	}
+}
+
+function serializeR2ObjectBody(obj, bodyData) {
+	if (!obj) return null
+	return {
+		__type: 'R2ObjectBody',
+		key: obj.key,
+		version: obj.version,
+		size: obj.size,
+		etag: obj.etag,
+		httpEtag: obj.httpEtag,
+		checksums: obj.checksums,
+		uploaded: obj.uploaded?.toISOString(),
+		httpMetadata: obj.httpMetadata,
+		customMetadata: obj.customMetadata,
+		range: obj.range,
+		storageClass: obj.storageClass,
+		bodyData
+	}
+}
+
+function serializeR2Objects(result) {
+	if (!result) return null
+	return {
+		objects: result.objects.map(serializeR2Object),
+		truncated: result.truncated,
+		cursor: result.cursor,
+		delimitedPrefixes: result.delimitedPrefixes
+	}
+}
+
+async function serializeResponse(response) {
+	let body = null
+	if (response.body) {
+		const bytes = await response.arrayBuffer()
+		if (bytes.byteLength > 0) {
+			body = { type: 'bytes', data: arrayBufferToBase64(bytes) }
+		}
+	}
+	return {
+		status: response.status,
+		statusText: response.statusText,
+		headers: [...response.headers.entries()],
+		body
+	}
+}
+
+function deserializeRequest(serializedReq) {
+	return new Request(serializedReq.url, {
+		method: serializedReq.method,
+		headers: serializedReq.headers,
+		body: serializedReq.body?.type === 'bytes'
+			? base64ToArrayBuffer(serializedReq.body.data)
+			: undefined,
+		redirect: serializedReq.redirect
+	})
+}
+
+function createEmailMessageRaw(raw) {
+	if (typeof raw === 'string' || raw instanceof ReadableStream) {
+		return raw
+	}
+	if (raw instanceof ArrayBuffer || raw instanceof Uint8Array) {
+		return new Response(raw).body
+	}
+	throw new Error('Unsupported EmailMessage raw payload')
+}
+
+function isDurableObjectNamespace(binding) {
+	return !!binding
+		&& typeof binding.idFromName === 'function'
+		&& typeof binding.idFromString === 'function'
+		&& typeof binding.newUniqueId === 'function'
+}
+
+/**
+ * Resolve a (possibly jurisdiction-scoped) DurableObjectNamespace.
+ * Forwards the jurisdiction faithfully when the binding supports it
+ * (real Cloudflare), and degrades to the plain binding otherwise
+ * (miniflare/workerd local emulation, which does not pin jurisdictions).
+ */
+function resolveDoNamespace(binding, jurisdiction) {
+	if (jurisdiction && typeof binding.jurisdiction === 'function') {
+		return binding.jurisdiction(jurisdiction)
+	}
+	return binding
+}
+
+/**
+ * Execute an RPC method against the gateway's bindings.
+ *
+ * Method format: "binding.operation". Operations must be namespaced by
+ * binding kind (e.g. "kv.get", "r2.head", "d1.stmt.first", "do.fetch",
+ * "service.fetch", "queue.send", "email.send", "ai.run"). Bare verbs and the legacy
+ * "stmt.*" / "stub.*" sub-prefixes were removed in B3-final and now throw.
+ * Method vocabulary must stay in sync with the canonical server in
+ * src/bridge/server.ts.
+ */
+async function executeRpcMethod(method, params, env, _ctx) {
+	const parts = method.split('.')
+	if (parts.length < 2) throw new Error('Invalid method format: ' + method)
+
+	const bindingName = parts[0]
+	const operation = parts.slice(1).join('.')
+	const binding = env[bindingName]
+
+	if (!binding) throw new Error('Binding not found: ' + bindingName)
+
+	const isNamespaced =
+		operation.indexOf('kv.') === 0 ||
+		operation.indexOf('r2.') === 0 ||
+		operation.indexOf('d1.') === 0 ||
+		operation.indexOf('do.') === 0 ||
+		operation.indexOf('service.') === 0 ||
+		operation.indexOf('queue.') === 0 ||
+		operation.indexOf('email.') === 0 ||
+		operation.indexOf('ai.') === 0 ||
+		operation.indexOf('workflow.') === 0 ||
+		operation.indexOf('var.') === 0
+	if (!isNamespaced) {
+		throw new Error(createUnsupportedBridgeOperationErrorMessage(bindingName, operation))
+	}
+
+	// KV
+	if (operation === 'kv.get') return binding.get(params[0], params[1])
+	if (operation === 'kv.put') return binding.put(params[0], params[1], params[2])
+	if (operation === 'kv.delete') return binding.delete(params[0])
+	if (operation === 'kv.list') return binding.list(params[0])
+	if (operation === 'kv.getWithMetadata') return binding.getWithMetadata(params[0], params[1])
+
+	// DO get (returns DOStub reference)
+	if (operation === 'do.get') {
+		return { __type: 'DOStub', binding: bindingName, id: params[0] }
+	}
+
+	// R2
+	if (operation === 'r2.head') return serializeR2Object(await binding.head(params[0]))
+	if (operation === 'r2.get') {
+		const obj = await binding.get(params[0], params[1])
+		if (!obj) return null
+		const body = await obj.arrayBuffer()
+		return serializeR2ObjectBody(obj, arrayBufferToBase64(body))
+	}
+	if (operation === 'r2.put') {
+		let value = params[1]
+		if (value && typeof value === 'object') {
+			if (value.__type === 'ArrayBuffer' || value.__type === 'Uint8Array') {
+				value = base64ToArrayBuffer(value.data)
+			}
+		}
+		return serializeR2Object(await binding.put(params[0], value, params[2]))
+	}
+	if (operation === 'r2.delete') return binding.delete(params[0])
+	if (operation === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
+
+	// D1
+	if (operation === 'd1.exec') return binding.exec(params[0])
+	if (operation === 'd1.batch') {
+		const statements = params[0].map((s) => binding.prepare(s.sql).bind(...(s.bindings || [])))
+		return binding.batch(statements)
+	}
+	if (operation.indexOf('d1.stmt.') === 0) {
+		const mode = operation.split('.')[2]
+		const [sql, ...rest] = params
+		let bindings = rest
+		let extraParam
+		if (mode === 'first' || mode === 'raw') {
+			extraParam = rest[rest.length - 1]
+			bindings = rest.slice(0, -1)
+		}
+		let stmt = binding.prepare(sql)
+		if (bindings.length > 0) stmt = stmt.bind(...bindings)
+		if (mode === 'first') {
+			if (typeof extraParam === 'string' && extraParam.length > 0) return stmt.first(extraParam)
+			return stmt.first()
+		}
+		if (mode === 'all') return stmt.all()
+		if (mode === 'run') return stmt.run()
+		if (mode === 'raw') return stmt.raw(extraParam)
+		throw new Error('Unknown stmt mode: ' + mode)
+	}
+
+	// Durable Objects
+	if (operation === 'do.idFromName') {
+		const ns = resolveDoNamespace(binding, params[1])
+		const id = ns.idFromName(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (operation === 'do.idFromString') {
+		const id = binding.idFromString(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (operation === 'do.newUniqueId') {
+		const ns = resolveDoNamespace(binding, params[1])
+		const id = ns.newUniqueId(params[0])
+		return { __type: 'DOId', hex: id.toString() }
+	}
+	if (operation === 'do.fetch') {
+		const [, serializedId, serializedReq] = params
+		const id = binding.idFromString(serializedId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request(serializedReq.url, {
+			method: serializedReq.method,
+			headers: serializedReq.headers,
+			body: serializedReq.body?.type === 'bytes'
+				? base64ToArrayBuffer(serializedReq.body.data)
+				: undefined
+		}))
+		return serializeResponse(response)
+	}
+	if (operation === 'do.rpc') {
+		const [, serializedId, methodName, args] = params
+		const id = binding.idFromString(serializedId.hex)
+		const stub = binding.get(id)
+		const response = await stub.fetch(new Request('http://do/_rpc', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ method: methodName, params: args })
+		}))
+		const result = await response.json()
+		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
+		return result.result
+	}
+
+	// Service Bindings
+	if (operation === 'service.fetch') {
+		if (!binding || typeof binding.fetch !== 'function') {
+			throw new Error('Service binding ' + bindingName + ' does not support fetch()')
+		}
+		const response = await binding.fetch(deserializeRequest(params[0]))
+		return serializeResponse(response)
+	}
+	if (operation === 'service.rpc') {
+		const methodName = params[0]
+		if (typeof methodName !== 'string') {
+			throw new Error('Service binding ' + bindingName + ' RPC method name must be a string')
+		}
+		const args = Array.isArray(params[1]) ? params[1] : []
+		const method = binding && binding[methodName]
+		if (typeof method !== 'function') {
+			throw new Error('Service binding ' + bindingName + ' does not support ' + methodName + '()')
+		}
+		return method.apply(binding, args)
+	}
+
+	// Queues
+	if (operation === 'queue.send') return binding.send(params[0], params[1])
+	if (operation === 'queue.sendBatch') return binding.sendBatch(params[0], params[1])
+
+	// Send Email
+	if (operation === 'email.send') {
+		if (binding && typeof binding.send === 'function') {
+			const message = params[0]
+			if (message && typeof message === 'object' && 'from' in message && 'to' in message && 'raw' in message) {
+				return binding.send({
+					from: message.from,
+					to: message.to,
+					[RAW_EMAIL]: createEmailMessageRaw(message.raw)
+				})
+			}
+			return binding.send(message)
+		}
+		return { ok: true, simulated: true }
+	}
+
+	// Workflows
+	if (operation === 'workflow.create') {
+		return serializeWorkflowInstance(await binding.create(params[0]))
+	}
+	if (operation === 'workflow.get') {
+		return serializeWorkflowInstance(await binding.get(params[0]))
+	}
+	if (operation === 'workflow.status') {
+		return (await binding.get(params[0])).status()
+	}
+	if (operation === 'workflow.pause') {
+		return (await binding.get(params[0])).pause()
+	}
+	if (operation === 'workflow.resume') {
+		return (await binding.get(params[0])).resume()
+	}
+	if (operation === 'workflow.terminate') {
+		return (await binding.get(params[0])).terminate()
+	}
+	if (operation === 'workflow.restart') {
+		return (await binding.get(params[0])).restart()
+	}
+	if (operation === 'workflow.sendEvent') {
+		return (await binding.get(params[0])).sendEvent(params[1])
+	}
+
+	// AI / generic run()
+	if (operation === 'ai.run') {
+		if (typeof binding.run !== 'function') {
+			throw new Error('Binding ' + bindingName + ' does not support run(): ' + method)
+		}
+		return binding.run(params[0], params[1])
+	}
+
+	throw new Error('Unknown operation: ' + method)
+}
+
+function createUnsupportedBridgeOperationErrorMessage(bindingName, operation) {
+	const base = "[devflare][bridge] Unsupported bridge operation '" + operation + "' for binding '" + bindingName + "'."
+	if (operation === 'fetch') {
+		return base + ' Devflare could not dispatch fetch() for this binding through the local bridge. '
+			+ 'Expected Cloudflare API: env.' + bindingName + '.fetch(request). '
+			+ 'If this came from SvelteKit platform.env, make sure the binding is declared as a service binding; '
+			+ 'this is a Devflare local bridge issue when service bindings fall back to a bare fetch operation.'
+	}
+	if (operation === 'toString') {
+		return base + ' A platform.env value was coerced to a string through the bridge. '
+			+ 'For SvelteKit local dev, declared vars should be plain string values and missing env names should read as undefined.'
+	}
+	return base + ' Bare verbs and the legacy stmt.*/stub.* sub-prefixes are not supported; '
+		+ 'use the namespaced form (e.g. kv.get, r2.put, d1.stmt.first, do.fetch, service.fetch).'
+}
+
+function serializeWorkflowInstance(instance) {
+	return {
+		__type: 'WorkflowInstance',
+		id: instance.id
+	}
+}
+
+// ---------------------------------------------------------------------------
+// WebSocket bridge (shared with src/bridge/server.ts in shape)
+// ---------------------------------------------------------------------------
+// NOTE: wsProxies is intentionally created per handleBridgeWebSocket call so
+// state never leaks across connections or across gateway-script regenerations.
+
+async function handleBridgeRpcCall(msg, ws, env, ctx) {
+	try {
+		const result = await executeRpcMethod(msg.method, msg.params, env, ctx)
+		ws.send(JSON.stringify({ t: 'rpc.ok', id: msg.id, result }))
+	} catch (error) {
+		ws.send(JSON.stringify({
+			t: 'rpc.err',
+			id: msg.id,
+			error: {
+				code: error?.code || 'INTERNAL_ERROR',
+				message: error?.message || String(error)
+			}
+		}))
+	}
+}
+
+async function handleBridgeWsOpen(msg, ws, env, wsProxies) {
+	try {
+		const binding = env[msg.target.binding]
+		const id = binding.idFromString(msg.target.id)
+		const stub = binding.get(id)
+
+		const headers = new Headers(msg.target.headers || [])
+		headers.set('Upgrade', 'websocket')
+
+		const response = await stub.fetch(new Request(msg.target.url, { method: 'GET', headers }))
+		const doWs = response.webSocket
+
+		if (!doWs) {
+			ws.send(JSON.stringify({
+				t: 'rpc.err',
+				id: 'ws_' + msg.wid,
+				error: { code: 'WS_FAILED', message: 'No WebSocket returned' }
+			}))
+			return
+		}
+
+		doWs.accept()
+		wsProxies.set(msg.wid, { doWs })
+
+		doWs.addEventListener('message', (event) => {
+			const isText = typeof event.data === 'string'
+			const data = isText ? event.data : arrayBufferToBase64(event.data)
+			ws.send(JSON.stringify({ t: 'ws.data', wid: msg.wid, data, isText }))
+		})
+
+		doWs.addEventListener('close', (event) => {
+			ws.send(JSON.stringify({ t: 'ws.close', wid: msg.wid, code: event.code, reason: event.reason }))
+			wsProxies.delete(msg.wid)
+		})
+
+		ws.send(JSON.stringify({ t: 'ws.opened', wid: msg.wid }))
+	} catch (error) {
+		ws.send(JSON.stringify({
+			t: 'rpc.err',
+			id: 'ws_' + msg.wid,
+			error: { code: 'WS_FAILED', message: error.message }
+		}))
+	}
+}
+
+function handleBridgeWsClose(msg, wsProxies) {
+	const proxy = wsProxies.get(msg.wid)
+	if (proxy) {
+		proxy.doWs.close(msg.code, msg.reason)
+		wsProxies.delete(msg.wid)
+	}
+}
+
+async function handleBridgeJsonMessage(data, ws, env, ctx, wsProxies) {
+	const msg = JSON.parse(data)
+	switch (msg.t) {
+		case 'hello':
+			// v2 handshake — acknowledge with welcome echoing the negotiated
+			// capability intersection. Capabilities advertised by the gateway
+			// are kept in sync with src/bridge/client.ts (BRIDGE_CLIENT_CAPABILITIES).
+			ws.send(JSON.stringify({
+				t: 'welcome',
+				protocolVersion: 2,
+				capabilities: ['streams', 'ws-relay', 'http-transfer']
+					.filter((c) => Array.isArray(msg.capabilities) && msg.capabilities.includes(c))
+					.sort()
+			}))
+			break
+		case 'rpc.call':
+			await handleBridgeRpcCall(msg, ws, env, ctx)
+			break
+		case 'ws.open':
+			await handleBridgeWsOpen(msg, ws, env, wsProxies)
+			break
+		case 'ws.close':
+			handleBridgeWsClose(msg, wsProxies)
+			break
+	}
+}
+
+function handleBridgeWebSocket(request, env, ctx) {
+	const { 0: client, 1: server } = new WebSocketPair()
+	server.accept()
+
+	// Per-connection state: recreated for every bridge client so reloads and
+	// concurrent clients never share WS proxy entries.
+	const wsProxies = new Map()
+
+	server.addEventListener('message', async (event) => {
+		try {
+			if (typeof event.data === 'string') {
+				await handleBridgeJsonMessage(event.data, server, env, ctx, wsProxies)
+			}
+		} catch (error) {
+			console.error('[Gateway] Error:', error)
+		}
+	})
+
+	server.addEventListener('close', () => {
+		for (const proxy of wsProxies.values()) {
+			// Best-effort cleanup: the DO-side WS may already be closed or in an
+			// invalid state; any throw here would abort sibling closes. Surface
+			// the swallowed error when DEVFLARE_DEBUG_BRIDGE is enabled.
+			try { proxy.doWs.close() } catch (error) {
+				if (globalThis.DEVFLARE_DEBUG_BRIDGE) {
+					console.warn('[devflare:bridge] proxy.doWs.close() failed', error)
+				}
+			}
+		}
+		wsProxies.clear()
+	})
+
+	return new Response(null, { status: 101, webSocket: client })
+}
+
+// ---------------------------------------------------------------------------
+// HTTP transfer for R2 bodies (shared with src/bridge/server.ts in shape)
+// ---------------------------------------------------------------------------
+
+async function handleHttpTransfer(request, env, url) {
+	const transferIdEncoded = url.pathname.split('/').pop()
+	const transferId = decodeURIComponent(transferIdEncoded || '')
+	const [binding, ...keyParts] = transferId.split(':')
+	const key = keyParts.join(':')
+	const bucket = env[binding]
+
+	if (!bucket) return new Response('Bucket not found: ' + binding, { status: 404 })
+
+	if (request.method === 'PUT' || request.method === 'POST') {
+		const result = await bucket.put(key, request.body)
+		return new Response(JSON.stringify(serializeR2Object(result)), {
+			headers: { 'Content-Type': 'application/json' }
+		})
+	}
+
+	if (request.method === 'GET') {
+		const object = await bucket.get(key)
+		if (!object) return new Response('Not found', { status: 404 })
+		return new Response(object.body, {
+			headers: {
+				'Content-Type': object.httpMetadata?.contentType || 'application/octet-stream',
+				'Content-Length': String(object.size)
+			}
+		})
+	}
+
+	return new Response('Method not allowed', { status: 405 })
+}
+`;
+
+// src/bridge/miniflare.ts
+function isIgnorableMiniflareDisposeError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const details = error;
+  return details.code === "EBADF" && details.syscall === "kill";
+}
+
 // src/dev-server/dev-server-state.ts
 function createDevServerState(initial) {
   return {
@@ -363,7 +1261,7 @@ async function disposeDevServerState(state) {
 }
 
 // src/dev-server/miniflare-dev-config.ts
-import { resolve as resolve4 } from "pathe";
+import { resolve as resolve5 } from "pathe";
 
 // src/browser-shim/binding-worker.ts
 var MAX_CHUNK_SIZE = 1048575;
@@ -928,7 +1826,7 @@ async function handleDoWebSocket(request, env, url, route) {
 }
 
 // src/dev-server/miniflare-worker-config.ts
-import { resolve as resolve2 } from "pathe";
+import { resolve as resolve3 } from "pathe";
 var DEFAULT_MODULE_RULES = [
   { type: "ESModule", include: ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.mjs"] },
   { type: "CommonJS", include: ["**/*.js", "**/*.cjs"] },
@@ -1024,7 +1922,7 @@ function makeMiniflareWorker(context, options) {
   };
   if (options.scriptPath) {
     workerConfig.scriptPath = options.scriptPath;
-    workerConfig.modulesRoot = loadedConfig.baseDir ? resolve2(cwd, loadedConfig.baseDir) : cwd;
+    workerConfig.modulesRoot = loadedConfig.baseDir ? resolve3(cwd, loadedConfig.baseDir) : cwd;
     workerConfig.modulesRules = [
       ...loadedConfig.rules?.map(toMiniflareModuleRule) ?? [],
       ...DEFAULT_MODULE_RULES
@@ -1043,7 +1941,7 @@ function makeMiniflareWorker(context, options) {
 }
 
 // src/dev-server/worker-surface-paths.ts
-import { dirname, resolve as resolve3 } from "pathe";
+import { dirname as dirname2, resolve as resolve4 } from "pathe";
 var DEFAULT_TRANSPORT_ENTRY_FILES = [
   "src/transport.ts",
   "src/transport.js",
@@ -1056,18 +1954,18 @@ function addWorkerWatchRoots(roots, cwd, configuredPath, defaultEntries) {
     return;
   }
   if (typeof configuredPath === "string" && configuredPath) {
-    roots.add(dirname(resolve3(cwd, configuredPath)));
+    roots.add(dirname2(resolve4(cwd, configuredPath)));
     return;
   }
   for (const defaultEntry of defaultEntries) {
-    roots.add(dirname(resolve3(cwd, defaultEntry)));
+    roots.add(dirname2(resolve4(cwd, defaultEntry)));
   }
 }
 function collectWorkerWatchRoots(cwd, config, mainWorkerSurfacePaths) {
   const roots = new Set;
   for (const surfacePath of Object.values(mainWorkerSurfacePaths)) {
     if (surfacePath) {
-      roots.add(dirname(surfacePath));
+      roots.add(dirname2(surfacePath));
     }
   }
   addWorkerWatchRoots(roots, cwd, config.files?.fetch, DEFAULT_FETCH_ENTRY_FILES);
@@ -1104,7 +2002,7 @@ function buildMiniflareDevConfig(input) {
     logger
   } = input;
   const bindings = loadedConfig.bindings ?? {};
-  const persistPath = resolve4(cwd, ".devflare/data");
+  const persistPath = resolve5(cwd, ".devflare/data");
   const appWorkerName = loadedConfig.name;
   const shouldRunMainWorker = !enableVite && (hasWorkerSurfacePaths(mainWorkerSurfacePaths) || Boolean(mainWorkerRoutes?.routes.length));
   const queueProducers = buildQueueProducers(bindings);
@@ -1328,7 +2226,7 @@ function createRuntimeStdioForwarder(logger) {
 }
 
 // src/dev-server/server-startup-helpers.ts
-import { resolve as resolve5 } from "pathe";
+import { resolve as resolve6 } from "pathe";
 
 // src/browser-shim/server.ts
 import { existsSync } from "node:fs";
@@ -1336,7 +2234,7 @@ import {
   createServer
 } from "node:http";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import {
   Browser as BrowserType,
   detectBrowserPlatform,
@@ -1437,7 +2335,7 @@ function createBrowserShim(options = {}) {
     logger,
     verbose = false,
     keepAlive = 60000,
-    cacheDir = join(homedir(), ".devflare", "chrome"),
+    cacheDir = join2(homedir(), ".devflare", "chrome"),
     allowNoSandbox = false
   } = options;
   const chromeLaunchArgs = resolveChromeFlags({ allowNoSandbox });
@@ -1635,7 +2533,7 @@ function createBrowserShim(options = {}) {
     res.end("Not found");
   }
   function readBody(req) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const chunks = [];
       let totalBytes = 0;
       req.on("data", (chunk) => {
@@ -1647,7 +2545,7 @@ function createBrowserShim(options = {}) {
         }
         chunks.push(chunk);
       });
-      req.on("end", () => resolve5(Buffer.concat(chunks).toString()));
+      req.on("end", () => resolve6(Buffer.concat(chunks).toString()));
       req.on("error", reject);
     });
   }
@@ -1796,10 +2694,10 @@ function createBrowserShim(options = {}) {
         });
       });
     }
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       server.on("error", reject);
       server.listen(port, host, () => {
-        resolve5();
+        resolve6();
       });
     });
     logger?.success(`Browser shim server ready on http://${host}:${port}`);
@@ -1809,8 +2707,8 @@ function createBrowserShim(options = {}) {
       await closeSession(sessionId, 3, "ServerShutdown");
     }
     if (server) {
-      await new Promise((resolve5) => {
-        server.close(() => resolve5());
+      await new Promise((resolve6) => {
+        server.close(() => resolve6());
       });
       server = null;
     }
@@ -1868,7 +2766,7 @@ function formatErrorMessage(error) {
 }
 async function resolveWorkerConfigWatchPath(cwd, configPath) {
   if (configPath) {
-    const explicitPath = resolve5(cwd, configPath);
+    const explicitPath = resolve6(cwd, configPath);
     const fs = await import("node:fs/promises");
     try {
       await fs.access(explicitPath);
@@ -1939,7 +2837,7 @@ async function maybeStartDOBundler(config, options) {
   if (typeof doPattern !== "string" || !doPattern) {
     return { bundler: null, result: null };
   }
-  const outDir = resolve5(options.cwd, ".devflare/do-bundles");
+  const outDir = resolve6(options.cwd, ".devflare/do-bundles");
   const bundler = createDOBundler({
     cwd: options.cwd,
     pattern: doPattern,
@@ -2155,7 +3053,7 @@ function createDevServer(options) {
     state.bundledMainWorkerScriptPath = await bundleWorkerEntry({
       cwd,
       inputFile: state.mainWorkerScriptPath,
-      outFile: resolve6(cwd, ".devflare", "worker-entrypoints", "main.js"),
+      outFile: resolve7(cwd, ".devflare", "worker-entrypoints", "main.js"),
       rolldownOptions: state.config.rolldown?.options,
       sourcemap: state.config.rolldown?.sourcemap,
       minify: state.config.rolldown?.minify,
@@ -2273,11 +3171,11 @@ function createDevServer(options) {
       cwd,
       configPath: state.resolvedWorkerConfigPath ?? undefined
     });
-    state.serviceBindingResolution = state.config.bindings?.services ? await resolveServiceBindings(state.config, state.resolvedWorkerConfigPath ? dirname2(state.resolvedWorkerConfigPath) : cwd) : null;
+    state.serviceBindingResolution = state.config.bindings?.services ? await resolveServiceBindings(state.config, state.resolvedWorkerConfigPath ? dirname3(state.resolvedWorkerConfigPath) : cwd) : null;
   }
   async function waitForDotenvChange() {
     const configWatchPath = state.resolvedWorkerConfigPath ?? await resolveWorkerConfigWatchPath(cwd, configPath);
-    const startDir = configWatchPath ? dirname2(configWatchPath) : cwd;
+    const startDir = configWatchPath ? dirname3(configWatchPath) : cwd;
     const watchPaths = getDevflareDotenvPaths(startDir);
     const { watch } = await import("chokidar");
     await new Promise((resolveWait, rejectWait) => {
@@ -2434,11 +3332,11 @@ async function createLogWriter(cwd, options) {
   const fs = await import("node:fs");
   let logPath;
   if (options.logTemp) {
-    logPath = resolve7(cwd, ".log");
+    logPath = resolve8(cwd, ".log");
   } else {
     const now = new Date;
     const timestamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-    logPath = resolve7(cwd, `.log-${timestamp}`);
+    logPath = resolve8(cwd, `.log-${timestamp}`);
   }
   const fileStream = fs.createWriteStream(logPath, { flags: "w" });
   const ansiRegex = /\x1b\[[0-9;]*m/g;
@@ -2486,7 +3384,7 @@ async function runDevCommand(parsed, logger, options) {
     logTemp: logTempEnabled
   });
   if (logWriter) {
-    const logFile = relative(cwd, logWriter.path) || ".log";
+    const logFile = relative2(cwd, logWriter.path) || ".log";
     logLine(logger, `${dim("logging", theme)} ${logFile}`);
   }
   const devLogger = createConsola({