@b9g/platform-cloudflare 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform-cloudflare",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Cloudflare Workers platform adapter for Shovel - already ServiceWorker-based!",
   "keywords": [
     "shovel",
@@ -11,11 +11,11 @@
     "serviceworker"
   ],
   "dependencies": {
-    "@b9g/assets": "^0.1.14",
-    "@b9g/cache": "^0.1.4",
-    "@b9g/platform": "^0.1.10",
-    "@cloudflare/workers-types": "^4.20241218.0",
+    "@b9g/assets": "^0.1.15",
+    "@b9g/cache": "^0.1.5",
+    "@b9g/platform": "^0.1.12",
     "@logtape/logtape": "^1.2.0",
+    "mime": "^4.0.4",
     "miniflare": "^4.20251118.1"
   },
   "devDependencies": {
@@ -46,6 +46,22 @@
     "./filesystem-assets.js": {
       "types": "./src/filesystem-assets.d.ts",
       "import": "./src/filesystem-assets.js"
+    },
+    "./cloudflare-runtime": {
+      "types": "./src/cloudflare-runtime.d.ts",
+      "import": "./src/cloudflare-runtime.js"
+    },
+    "./cloudflare-runtime.js": {
+      "types": "./src/cloudflare-runtime.d.ts",
+      "import": "./src/cloudflare-runtime.js"
+    },
+    "./filesystem-r2": {
+      "types": "./src/filesystem-r2.d.ts",
+      "import": "./src/filesystem-r2.js"
+    },
+    "./filesystem-r2.js": {
+      "types": "./src/filesystem-r2.d.ts",
+      "import": "./src/filesystem-r2.js"
     }
   }
 }

package/src/cloudflare-runtime.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cloudflare Worker Runtime - Browser-safe ServiceWorkerGlobals setup
+ *
+ * This module is BROWSER-SAFE and can be bundled into Cloudflare Workers.
+ * It only imports from browser-compatible modules:
+ * - @b9g/platform/runtime (no fs/path)
+ * - @b9g/filesystem (no fs/path in the index)
+ * - @b9g/async-context (browser-safe)
+ *
+ * DO NOT import from @b9g/platform (the index) - it pulls in Node-only code.
+ */
+import { ShovelServiceWorkerRegistration } from "@b9g/platform/runtime";
+/**
+ * Cloudflare's ExecutionContext - passed to each request handler
+ * Used for ctx.waitUntil() to extend request lifetime
+ */
+export interface ExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+/**
+ * Get the current request's Cloudflare env object
+ * Contains all bindings: KV namespaces, R2 buckets, D1 databases, etc.
+ */
+export declare function getEnv<T = Record<string, unknown>>(): T | undefined;
+/**
+ * Get the current request's Cloudflare ExecutionContext
+ * Used for ctx.waitUntil() and other lifecycle methods
+ */
+export declare function getCtx(): ExecutionContext | undefined;
+/**
+ * Initialize the Cloudflare runtime with ServiceWorkerGlobals
+ * Called once when the worker module loads (before user code runs)
+ */
+export declare function initializeRuntime(): ShovelServiceWorkerRegistration;
+/**
+ * Create the ES module fetch handler for Cloudflare Workers
+ */
+export declare function createFetchHandler(registration: ShovelServiceWorkerRegistration): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;

package/src/cloudflare-runtime.js

@@ -0,0 +1,102 @@
+/// <reference types="./cloudflare-runtime.d.ts" />
+// src/cloudflare-runtime.ts
+import {
+  ServiceWorkerGlobals,
+  ShovelServiceWorkerRegistration,
+  CustomLoggerStorage
+} from "@b9g/platform/runtime";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { AsyncContext } from "@b9g/async-context";
+import { getLogger } from "@logtape/logtape";
+import { R2FileSystemDirectoryHandle } from "./filesystem-r2.js";
+var envStorage = new AsyncContext.Variable();
+var ctxStorage = new AsyncContext.Variable();
+function getEnv() {
+  return envStorage.get();
+}
+function getCtx() {
+  return ctxStorage.get();
+}
+var _registration = null;
+var _globals = null;
+function initializeRuntime() {
+  if (_registration) {
+    return _registration;
+  }
+  _registration = new ShovelServiceWorkerRegistration();
+  const directories = new CustomDirectoryStorage(
+    createCloudflareR2DirectoryFactory()
+  );
+  _globals = new ServiceWorkerGlobals({
+    registration: _registration,
+    caches: globalThis.caches,
+    // Cloudflare's native Cache API
+    directories,
+    loggers: new CustomLoggerStorage((...cats) => getLogger(cats))
+  });
+  _globals.install();
+  return _registration;
+}
+function createFetchHandler(registration) {
+  return async (request, env, ctx) => {
+    return envStorage.run(
+      env,
+      () => ctxStorage.run(ctx, async () => {
+        try {
+          return await registration.handleRequest(request);
+        } catch (error) {
+          console.error("ServiceWorker error:", error);
+          const err = error instanceof Error ? error : new Error(String(error));
+          const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
+          if (isDev) {
+            return new Response(
+              `<!DOCTYPE html>
+<html>
+<head><title>500 Internal Server Error</title>
+<style>body{font-family:system-ui;padding:2rem;max-width:800px;margin:0 auto}h1{color:#c00}pre{background:#f5f5f5;padding:1rem;overflow-x:auto}</style>
+</head>
+<body>
+<h1>500 Internal Server Error</h1>
+<p>${escapeHtml(err.message)}</p>
+<pre>${escapeHtml(err.stack || "No stack trace")}</pre>
+</body></html>`,
+              { status: 500, headers: { "Content-Type": "text/html" } }
+            );
+          }
+          return new Response("Internal Server Error", { status: 500 });
+        }
+      })
+    );
+  };
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function createCloudflareR2DirectoryFactory() {
+  return async (name) => {
+    const env = getEnv();
+    if (!env) {
+      throw new Error(
+        `Cannot access directory "${name}": Cloudflare env not available. Are you accessing directories outside of a request context?`
+      );
+    }
+    const bindingName = `${name.toUpperCase()}_R2`;
+    const r2Bucket = env[bindingName];
+    if (!r2Bucket) {
+      throw new Error(
+        `R2 bucket binding "${bindingName}" not found. Configure in wrangler.toml:
+
+[[r2_buckets]]
+binding = "${bindingName}"
+bucket_name = "your-bucket-name"`
+      );
+    }
+    return new R2FileSystemDirectoryHandle(r2Bucket, "");
+  };
+}
+export {
+  createFetchHandler,
+  getCtx,
+  getEnv,
+  initializeRuntime
+};

package/src/env.d.ts

@@ -0,0 +1,9 @@
+// Vite-style import.meta.env declaration
+interface ImportMetaEnv {
+	MODE?: string;
+	[key: string]: string | undefined;
+}
+
+interface ImportMeta {
+	readonly env?: ImportMetaEnv;
+}

package/src/filesystem-r2.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Cloudflare R2 implementation of File System Access API
+ *
+ * Implements FileSystemDirectoryHandle and FileSystemFileHandle using Cloudflare R2 bindings
+ * to provide R2 cloud storage with File System Access API compatibility.
+ */
+import type { FileSystemConfig } from "@b9g/filesystem";
+/** R2 object metadata */
+export interface R2Object {
+    key: string;
+    uploaded: Date;
+    httpMetadata?: {
+        contentType?: string;
+    };
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+/** R2 list result */
+export interface R2Objects {
+    objects: Array<{
+        key: string;
+    }>;
+    delimitedPrefixes: string[];
+}
+/** R2 bucket interface */
+export interface R2Bucket {
+    get(key: string): Promise<R2Object | null>;
+    head(key: string): Promise<R2Object | null>;
+    put(key: string, value: ArrayBuffer | Uint8Array): Promise<R2Object>;
+    delete(key: string): Promise<void>;
+    list(options?: {
+        prefix?: string;
+        delimiter?: string;
+    }): Promise<R2Objects>;
+}
+/**
+ * Cloudflare R2 implementation of FileSystemWritableFileStream
+ */
+export declare class R2FileSystemWritableFileStream extends WritableStream<Uint8Array> {
+    #private;
+    constructor(r2Bucket: R2Bucket, key: string);
+}
+/**
+ * Cloudflare R2 implementation of FileSystemFileHandle
+ */
+export declare class R2FileSystemFileHandle implements FileSystemFileHandle {
+    #private;
+    readonly kind: "file";
+    readonly name: string;
+    constructor(r2Bucket: R2Bucket, key: string);
+    getFile(): Promise<File>;
+    createWritable(): Promise<FileSystemWritableFileStream>;
+    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+}
+/**
+ * Cloudflare R2 implementation of FileSystemDirectoryHandle
+ */
+export declare class R2FileSystemDirectoryHandle implements FileSystemDirectoryHandle {
+    #private;
+    readonly kind: "directory";
+    readonly name: string;
+    constructor(r2Bucket: R2Bucket, prefix: string);
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemFileHandle>;
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<FileSystemDirectoryHandle>;
+    removeEntry(name: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
+    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
+    keys(): AsyncIterableIterator<string>;
+    values(): AsyncIterableIterator<FileSystemHandle>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+}
+/**
+ * R2 filesystem adapter
+ */
+export declare class R2FileSystemAdapter {
+    #private;
+    constructor(r2Bucket: R2Bucket, config?: FileSystemConfig);
+    getFileSystemRoot(name?: string): Promise<FileSystemDirectoryHandle>;
+    getConfig(): FileSystemConfig;
+    dispose(): Promise<void>;
+}

package/src/filesystem-r2.js

@@ -0,0 +1,230 @@
+/// <reference types="./filesystem-r2.d.ts" />
+// src/filesystem-r2.ts
+import mime from "mime";
+var R2FileSystemWritableFileStream = class extends WritableStream {
+  #chunks;
+  #r2Bucket;
+  #key;
+  constructor(r2Bucket, key) {
+    const chunks = [];
+    super({
+      write: (chunk) => {
+        chunks.push(chunk);
+        return Promise.resolve();
+      },
+      close: async () => {
+        const totalLength = chunks.reduce(
+          (sum, chunk) => sum + chunk.length,
+          0
+        );
+        const buffer = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          buffer.set(chunk, offset);
+          offset += chunk.length;
+        }
+        await r2Bucket.put(key, buffer);
+      },
+      abort: async () => {
+        chunks.length = 0;
+      }
+    });
+    this.#chunks = chunks;
+    this.#r2Bucket = r2Bucket;
+    this.#key = key;
+  }
+};
+var R2FileSystemFileHandle = class _R2FileSystemFileHandle {
+  kind;
+  name;
+  #r2Bucket;
+  #key;
+  constructor(r2Bucket, key) {
+    this.kind = "file";
+    this.#r2Bucket = r2Bucket;
+    this.#key = key;
+    this.name = key.split("/").pop() || key;
+  }
+  async getFile() {
+    const r2Object = await this.#r2Bucket.get(this.#key);
+    if (!r2Object) {
+      throw new DOMException("File not found", "NotFoundError");
+    }
+    const arrayBuffer = await r2Object.arrayBuffer();
+    return new File([arrayBuffer], this.name, {
+      lastModified: r2Object.uploaded.getTime(),
+      type: r2Object.httpMetadata?.contentType || this.#getMimeType(this.#key)
+    });
+  }
+  async createWritable() {
+    return new R2FileSystemWritableFileStream(this.#r2Bucket, this.#key);
+  }
+  async createSyncAccessHandle() {
+    throw new DOMException(
+      "Synchronous access handles are not supported for R2 storage",
+      "InvalidStateError"
+    );
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "file")
+      return false;
+    if (!(other instanceof _R2FileSystemFileHandle))
+      return false;
+    return this.#key === other.#key;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+  #getMimeType(key) {
+    return mime.getType(key) || "application/octet-stream";
+  }
+};
+var R2FileSystemDirectoryHandle = class _R2FileSystemDirectoryHandle {
+  kind;
+  name;
+  #r2Bucket;
+  #prefix;
+  constructor(r2Bucket, prefix) {
+    this.kind = "directory";
+    this.#r2Bucket = r2Bucket;
+    this.#prefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+    this.name = this.#prefix.split("/").pop() || "root";
+  }
+  async getFileHandle(name, options) {
+    const key = this.#prefix ? `${this.#prefix}/${name}` : name;
+    const exists = await this.#r2Bucket.head(key);
+    if (!exists && options?.create) {
+      await this.#r2Bucket.put(key, new Uint8Array(0));
+    } else if (!exists) {
+      throw new DOMException("File not found", "NotFoundError");
+    }
+    return new R2FileSystemFileHandle(this.#r2Bucket, key);
+  }
+  async getDirectoryHandle(name, options) {
+    const newPrefix = this.#prefix ? `${this.#prefix}/${name}` : name;
+    if (options?.create) {
+      const markerKey = `${newPrefix}/.shovel_directory_marker`;
+      const exists = await this.#r2Bucket.head(markerKey);
+      if (!exists) {
+        await this.#r2Bucket.put(markerKey, new Uint8Array(0));
+      }
+    }
+    return new _R2FileSystemDirectoryHandle(this.#r2Bucket, newPrefix);
+  }
+  async removeEntry(name, options) {
+    const key = this.#prefix ? `${this.#prefix}/${name}` : name;
+    const fileExists = await this.#r2Bucket.head(key);
+    if (fileExists) {
+      await this.#r2Bucket.delete(key);
+      return;
+    }
+    if (options?.recursive) {
+      const dirPrefix = `${key}/`;
+      const listed = await this.#r2Bucket.list({ prefix: dirPrefix });
+      const deletePromises = listed.objects.map(
+        (object) => this.#r2Bucket.delete(object.key)
+      );
+      await Promise.all(deletePromises);
+      const markerKey = `${key}/.shovel_directory_marker`;
+      const markerExists = await this.#r2Bucket.head(markerKey);
+      if (markerExists) {
+        await this.#r2Bucket.delete(markerKey);
+      }
+    } else {
+      throw new DOMException(
+        "Directory is not empty",
+        "InvalidModificationError"
+      );
+    }
+  }
+  async resolve(_possibleDescendant) {
+    return null;
+  }
+  async *entries() {
+    const listPrefix = this.#prefix ? `${this.#prefix}/` : "";
+    try {
+      const result = await this.#r2Bucket.list({
+        prefix: listPrefix,
+        delimiter: "/"
+        // Only get immediate children
+      });
+      for (const object of result.objects) {
+        if (object.key !== listPrefix) {
+          const name = object.key.substring(listPrefix.length);
+          if (!name.includes("/") && !name.endsWith(".shovel_directory_marker")) {
+            yield [
+              name,
+              new R2FileSystemFileHandle(this.#r2Bucket, object.key)
+            ];
+          }
+        }
+      }
+      for (const prefix of result.delimitedPrefixes) {
+        const name = prefix.substring(listPrefix.length).replace(/\/$/, "");
+        if (name) {
+          yield [
+            name,
+            new _R2FileSystemDirectoryHandle(
+              this.#r2Bucket,
+              prefix.replace(/\/$/, "")
+            )
+          ];
+        }
+      }
+    } catch (error) {
+      throw new DOMException("Directory not found", "NotFoundError");
+    }
+  }
+  async *keys() {
+    for await (const [name] of this.entries()) {
+      yield name;
+    }
+  }
+  async *values() {
+    for await (const [, handle] of this.entries()) {
+      yield handle;
+    }
+  }
+  async isSameEntry(other) {
+    if (other.kind !== "directory")
+      return false;
+    if (!(other instanceof _R2FileSystemDirectoryHandle))
+      return false;
+    return this.#prefix === other.#prefix;
+  }
+  async queryPermission() {
+    return "granted";
+  }
+  async requestPermission() {
+    return "granted";
+  }
+};
+var R2FileSystemAdapter = class {
+  #config;
+  #r2Bucket;
+  constructor(r2Bucket, config = {}) {
+    this.#config = {
+      name: "r2",
+      ...config
+    };
+    this.#r2Bucket = r2Bucket;
+  }
+  async getFileSystemRoot(name = "default") {
+    const prefix = `filesystems/${name}`;
+    return new R2FileSystemDirectoryHandle(this.#r2Bucket, prefix);
+  }
+  getConfig() {
+    return { ...this.#config };
+  }
+  async dispose() {
+  }
+};
+export {
+  R2FileSystemAdapter,
+  R2FileSystemDirectoryHandle,
+  R2FileSystemFileHandle,
+  R2FileSystemWritableFileStream
+};

package/src/index.d.ts

@@ -2,23 +2,50 @@
  * @b9g/platform-cloudflare - Cloudflare Workers platform adapter for Shovel
  *
  * Provides ServiceWorker-native deployment for Cloudflare Workers with KV/R2/D1 integration.
+ *
+ * Architecture:
+ * - Uses ServiceWorkerGlobals from @b9g/platform for full feature parity with Node/Bun
+ * - AsyncContext provides per-request access to Cloudflare's env/ctx
+ * - Directories use R2 via lazy factory (accessed when directories.open() is called)
+ * - Caches use Cloudflare's native Cache API
  */
-import { BasePlatform, PlatformConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance } from "@b9g/platform";
+import { BasePlatform, PlatformConfig, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, EntryWrapperOptions, PlatformEsbuildConfig } from "@b9g/platform";
+import { CustomCacheStorage } from "@b9g/cache";
+import { ShovelServiceWorkerRegistration } from "@b9g/platform/runtime";
+import type { ExecutionContext } from "./cloudflare-runtime.js";
 export type { Platform, Handler, Server, ServerOptions, ServiceWorkerOptions, ServiceWorkerInstance, } from "@b9g/platform";
+/**
+ * Get the current request's Cloudflare env object
+ * Contains all bindings: KV namespaces, R2 buckets, D1 databases, etc.
+ */
+export declare function getEnv<T = Record<string, unknown>>(): T | undefined;
+/**
+ * Get the current request's Cloudflare ExecutionContext
+ * Used for ctx.waitUntil() and other lifecycle methods
+ */
+export declare function getCtx(): ExecutionContext | undefined;
 export interface CloudflarePlatformOptions extends PlatformConfig {
     /** Cloudflare Workers environment (production, preview, dev) */
     environment?: "production" | "preview" | "dev";
     /** Static assets directory for ASSETS binding (dev mode) */
     assetsDirectory?: string;
-    /** KV namespace bindings */
-    kvNamespaces?: Record<string, any>;
-    /** R2 bucket bindings */
-    r2Buckets?: Record<string, any>;
-    /** D1 database bindings */
-    d1Databases?: Record<string, any>;
-    /** Durable Object bindings */
-    durableObjects?: Record<string, any>;
+    /** Working directory for config file resolution */
+    cwd?: string;
 }
+/**
+ * Initialize the Cloudflare runtime with ServiceWorkerGlobals
+ * Called once when the worker module loads (before user code runs)
+ *
+ * This sets up:
+ * - ServiceWorkerGlobals (caches, directories, cookieStore, addEventListener, etc.)
+ * - Per-request env/ctx via AsyncContext
+ */
+export declare function initializeRuntime(): ShovelServiceWorkerRegistration;
+/**
+ * Create the ES module fetch handler for Cloudflare Workers
+ * This wraps requests with AsyncContext so env/ctx are available everywhere
+ */
+export declare function createFetchHandler(registration: ShovelServiceWorkerRegistration): (request: Request, env: unknown, ctx: ExecutionContext) => Promise<Response>;
 /**
  * Cloudflare Workers platform implementation
  */
@@ -27,28 +54,42 @@ export declare class CloudflarePlatform extends BasePlatform {
     readonly name: string;
     constructor(options?: CloudflarePlatformOptions);
     /**
-     * Create "server" for Cloudflare Workers (which is really just the handler)
+     * Create cache storage
+     * Uses Cloudflare's native Cache API
+     */
+    createCaches(): Promise<CustomCacheStorage>;
+    /**
+     * Create "server" for Cloudflare Workers (stub for Platform interface)
      */
     createServer(handler: Handler, _options?: ServerOptions): Server;
     /**
-     * Load ServiceWorker-style entrypoint in Cloudflare Workers
-     *
-     * In production: Uses the native CF Worker environment
-     * In dev mode: Uses miniflare (workerd) for true dev/prod parity
+     * Load ServiceWorker using miniflare (workerd) for dev mode
      */
     loadServiceWorker(entrypoint: string, _options?: ServiceWorkerOptions): Promise<ServiceWorkerInstance>;
+    dispose(): Promise<void>;
+    /**
+     * Get virtual entry wrapper for Cloudflare Workers
+     *
+     * Wraps user code with:
+     * 1. Config import (shovel:config virtual module)
+     * 2. Runtime initialization (ServiceWorkerGlobals)
+     * 3. User code import (registers fetch handlers)
+     * 4. ES module export for Cloudflare Workers format
+     *
+     * Note: Unlike Node/Bun, Cloudflare bundles user code inline, so the
+     * entryPath is embedded directly in the wrapper.
+     */
+    getEntryWrapper(entryPath: string, _options?: EntryWrapperOptions): string;
     /**
-     * Dispose of platform resources
+     * Get Cloudflare-specific esbuild configuration
+     *
+     * Note: Cloudflare Workers natively support import.meta.env, so no define alias
+     * is needed. The nodejs_compat flag enables node:* built-in modules at runtime,
+     * so we externalize them during bundling.
      */
-    dispose(): Promise<void>;
+    getEsbuildConfig(): PlatformEsbuildConfig;
 }
-/**
- * Create platform options from Wrangler environment
- */
 export declare function createOptionsFromEnv(env: any): CloudflarePlatformOptions;
-/**
- * Generate wrangler.toml configuration for a Shovel app from CLI flags
- */
 export declare function generateWranglerConfig(options: {
     name: string;
     entrypoint: string;
@@ -58,15 +99,4 @@ export declare function generateWranglerConfig(options: {
     r2Buckets?: string[];
     d1Databases?: string[];
 }): string;
-/**
- * Generate banner code for ServiceWorker → ES Module conversion
- */
-export declare const cloudflareWorkerBanner = "// Cloudflare Worker ES Module wrapper\nlet serviceWorkerGlobals = null;\n\n// Set up ServiceWorker environment\nif (typeof globalThis.self === 'undefined') {\n\tglobalThis.self = globalThis;\n}\n\n// Capture fetch event handlers\nconst fetchHandlers = [];\nconst originalAddEventListener = globalThis.addEventListener;\nglobalThis.addEventListener = function(type, handler, options) {\n\tif (type === 'fetch') {\n\t\tfetchHandlers.push(handler);\n\t} else {\n\t\toriginalAddEventListener?.call(this, type, handler, options);\n\t}\n};\n\n// Create a promise-based FetchEvent that can be awaited\nclass FetchEvent {\n\tconstructor(type, init) {\n\t\tthis.type = type;\n\t\tthis.request = init.request;\n\t\tthis._response = null;\n\t\tthis._responsePromise = new Promise((resolve) => {\n\t\t\tthis._resolveResponse = resolve;\n\t\t});\n\t}\n\t\n\trespondWith(response) {\n\t\tthis._response = response;\n\t\tthis._resolveResponse(response);\n\t}\n\t\n\tasync waitUntil(promise) {\n\t\tawait promise;\n\t}\n}";
-/**
- * Generate footer code for ServiceWorker → ES Module conversion
- */
-export declare const cloudflareWorkerFooter = "\n// Export ES Module for Cloudflare Workers\nexport default {\n\tasync fetch(request, env, ctx) {\n\t\ttry {\n\t\t\t// Set up ServiceWorker-like dirs API for bundled deployment\n\t\t\tif (!globalThis.self.dirs) {\n\t\t\t\t// For bundled deployment, assets are served via static middleware\n\t\t\t\t// not through the dirs API\n\t\t\t\tglobalThis.self.dirs = {\n\t\t\t\t\tasync open(directoryName) {\n\t\t\t\t\t\tif (directoryName === 'assets') {\n\t\t\t\t\t\t\t// Return a minimal interface that indicates no files available\n\t\t\t\t\t\t\t// The assets middleware will fall back to dev mode behavior\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tasync getFileHandle(fileName) {\n\t\t\t\t\t\t\t\t\tthrow new Error(`NotFoundError: ${fileName} not found in bundled assets`);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthrow new Error(`Directory ${directoryName} not available in bundled deployment`);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t}\n\t\t\t\n\t\t\t// Set up caches API\n\t\t\tif (!globalThis.self.caches) {\n\t\t\t\tglobalThis.self.caches = globalThis.caches;\n\t\t\t}\n\t\t\t\n\t\t\t// Ensure request.url is a string\n\t\t\tif (typeof request.url !== 'string') {\n\t\t\t\treturn new Response('Invalid request URL: ' + typeof request.url, { status: 500 });\n\t\t\t}\n\t\t\t\n\t\t\t// Create proper FetchEvent-like object\n\t\t\tlet responseReceived = null;\n\t\t\tconst event = { \n\t\t\t\trequest, \n\t\t\t\trespondWith: (response) => { responseReceived = response; }\n\t\t\t};\n\t\t\t\n\t\t\t// Helper for error responses\n\t\t\tconst createErrorResponse = (err) => {\n\t\t\t\tconst isDev = typeof import.meta !== \"undefined\" && import.meta.env?.MODE !== \"production\";\n\t\t\t\tif (isDev) {\n\t\t\t\t\tconst escapeHtml = (str) => str.replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\");\n\t\t\t\t\treturn new Response(`<!DOCTYPE html>\n<html>\n<head>\n  <title>500 Internal Server Error</title>\n  <style>\n    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }\n    h1 { color: #c00; }\n    .message { font-size: 1.2em; color: #333; }\n    pre { background: #f5f5f5; padding: 1rem; overflow-x: auto; border-radius: 4px; }\n  </style>\n</head>\n<body>\n  <h1>500 Internal Server Error</h1>\n  <p class=\"message\">${escapeHtml(err.message)}</p>\n  <pre>${escapeHtml(err.stack || \"No stack trace available\")}</pre>\n</body>\n</html>`, { status: 500, headers: { \"Content-Type\": \"text/html; charset=utf-8\" } });\n\t\t\t\t} else {\n\t\t\t\t\treturn new Response(\"Internal Server Error\", { status: 500, headers: { \"Content-Type\": \"text/plain\" } });\n\t\t\t\t}\n\t\t\t};\n\n\t\t\t// Dispatch to ServiceWorker fetch handlers\n\t\t\tfor (const handler of fetchHandlers) {\n\t\t\t\ttry {\n\t\t\t\t\tlogger.debug(\"Calling handler\", {url: request.url});\n\t\t\t\t\tawait handler(event);\n\t\t\t\t\tlogger.debug(\"Handler completed\", {hasResponse: !!responseReceived});\n\t\t\t\t\tif (responseReceived) {\n\t\t\t\t\t\treturn responseReceived;\n\t\t\t\t\t}\n\t\t\t\t} catch (error) {\n\t\t\t\t\tlogger.error(\"Handler error: {error}\", {error});\n\t\t\t\t\treturn createErrorResponse(error);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn new Response('No ServiceWorker handler', { status: 404 });\n\t\t} catch (topLevelError) {\n\t\t\tlogger.error(\"Top-level error: {error}\", {error: topLevelError});\n\t\t\tconst isDev = typeof import.meta !== \"undefined\" && import.meta.env?.MODE !== \"production\";\n\t\t\tif (isDev) {\n\t\t\t\tconst escapeHtml = (str) => String(str).replace(/&/g, \"&amp;\").replace(/</g, \"&lt;\").replace(/>/g, \"&gt;\").replace(/\"/g, \"&quot;\");\n\t\t\t\treturn new Response(`<!DOCTYPE html>\n<html>\n<head>\n  <title>500 Internal Server Error</title>\n  <style>\n    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }\n    h1 { color: #c00; }\n    .message { font-size: 1.2em; color: #333; }\n    pre { background: #f5f5f5; padding: 1rem; overflow-x: auto; border-radius: 4px; }\n  </style>\n</head>\n<body>\n  <h1>500 Internal Server Error</h1>\n  <p class=\"message\">${escapeHtml(topLevelError.message)}</p>\n  <pre>${escapeHtml(topLevelError.stack || \"No stack trace available\")}</pre>\n</body>\n</html>`, { status: 500, headers: { \"Content-Type\": \"text/html; charset=utf-8\" } });\n\t\t\t} else {\n\t\t\t\treturn new Response(\"Internal Server Error\", { status: 500, headers: { \"Content-Type\": \"text/plain\" } });\n\t\t\t}\n\t\t}\n\t}\n};";
-/**
- * Default export for easy importing
- */
 export default CloudflarePlatform;

package/src/index.js

@@ -3,33 +3,133 @@
 import {
   BasePlatform
 } from "@b9g/platform";
+import { CustomCacheStorage } from "@b9g/cache";
+import {
+  ServiceWorkerGlobals,
+  ShovelServiceWorkerRegistration,
+  CustomLoggerStorage
+} from "@b9g/platform/runtime";
+import { CustomDirectoryStorage } from "@b9g/filesystem";
+import { AsyncContext } from "@b9g/async-context";
 import { getLogger } from "@logtape/logtape";
-var logger = getLogger(["platform-cloudflare"]);
+import { R2FileSystemDirectoryHandle } from "./filesystem-r2.js";
+var logger = getLogger(["platform"]);
+var envStorage = new AsyncContext.Variable();
+var ctxStorage = new AsyncContext.Variable();
+function getEnv() {
+  return envStorage.get();
+}
+function getCtx() {
+  return ctxStorage.get();
+}
+var _registration = null;
+var _globals = null;
+function initializeRuntime() {
+  if (_registration) {
+    return _registration;
+  }
+  _registration = new ShovelServiceWorkerRegistration();
+  const directories = new CustomDirectoryStorage(
+    createCloudflareR2DirectoryFactory()
+  );
+  _globals = new ServiceWorkerGlobals({
+    registration: _registration,
+    caches: globalThis.caches,
+    // Use Cloudflare's native Cache API
+    directories,
+    loggers: new CustomLoggerStorage((...cats) => getLogger(cats))
+  });
+  _globals.install();
+  return _registration;
+}
+function createFetchHandler(registration) {
+  return async (request, env, ctx) => {
+    return envStorage.run(
+      env,
+      () => ctxStorage.run(ctx, async () => {
+        try {
+          return await registration.handleRequest(request);
+        } catch (error) {
+          console.error("ServiceWorker error:", error);
+          const err = error instanceof Error ? error : new Error(String(error));
+          const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
+          if (isDev) {
+            return new Response(
+              `<!DOCTYPE html>
+<html>
+<head><title>500 Internal Server Error</title>
+<style>body{font-family:system-ui;padding:2rem;max-width:800px;margin:0 auto}h1{color:#c00}pre{background:#f5f5f5;padding:1rem;overflow-x:auto}</style>
+</head>
+<body>
+<h1>500 Internal Server Error</h1>
+<p>${escapeHtml(err.message)}</p>
+<pre>${escapeHtml(err.stack || "No stack trace")}</pre>
+</body></html>`,
+              { status: 500, headers: { "Content-Type": "text/html" } }
+            );
+          }
+          return new Response("Internal Server Error", { status: 500 });
+        }
+      })
+    );
+  };
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function createCloudflareR2DirectoryFactory() {
+  return async (name) => {
+    const env = getEnv();
+    if (!env) {
+      throw new Error(
+        `Cannot access directory "${name}": Cloudflare env not available. This usually means you're trying to access directories outside of a request context.`
+      );
+    }
+    const bindingName = `${name.toUpperCase()}_R2`;
+    const r2Bucket = env[bindingName];
+    if (!r2Bucket) {
+      throw new Error(
+        `R2 bucket binding "${bindingName}" not found in env. Configure in wrangler.toml:
+
+[[r2_buckets]]
+binding = "${bindingName}"
+bucket_name = "your-bucket-name"`
+      );
+    }
+    return new R2FileSystemDirectoryHandle(r2Bucket, "");
+  };
+}
 var CloudflarePlatform = class extends BasePlatform {
   name;
   #options;
   #miniflare;
   #assetsMiniflare;
-  // Separate instance for ASSETS binding
-  #assetsBinding;
   constructor(options = {}) {
     super(options);
     this.#miniflare = null;
     this.#assetsMiniflare = null;
-    this.#assetsBinding = null;
     this.name = "cloudflare";
+    const cwd = options.cwd ?? ".";
     this.#options = {
-      environment: "production",
-      assetsDirectory: void 0,
-      kvNamespaces: {},
-      r2Buckets: {},
-      d1Databases: {},
-      durableObjects: {},
-      ...options
+      environment: options.environment ?? "production",
+      assetsDirectory: options.assetsDirectory,
+      cwd
     };
   }
   /**
-   * Create "server" for Cloudflare Workers (which is really just the handler)
+   * Create cache storage
+   * Uses Cloudflare's native Cache API
+   */
+  async createCaches() {
+    return new CustomCacheStorage(async (name) => {
+      if (globalThis.caches) {
+        return globalThis.caches.open(name);
+      }
+      throw new Error("Cloudflare caches not available in this context");
+    });
+  }
+  /**
+   * Create "server" for Cloudflare Workers (stub for Platform interface)
    */
   createServer(handler, _options = {}) {
     return {
@@ -48,55 +148,22 @@ var CloudflarePlatform = class extends BasePlatform {
       }
     };
   }
-  /**
-   * Load ServiceWorker-style entrypoint in Cloudflare Workers
-   *
-   * In production: Uses the native CF Worker environment
-   * In dev mode: Uses miniflare (workerd) for true dev/prod parity
-   */
-  async loadServiceWorker(entrypoint, _options = {}) {
-    const isCloudflareWorker = typeof globalThis.addEventListener === "function" && typeof globalThis.caches !== "undefined" && typeof globalThis.FetchEvent !== "undefined";
-    if (isCloudflareWorker) {
-      logger.info("Running in native ServiceWorker environment", {});
-      const instance = {
-        runtime: globalThis,
-        handleRequest: async (request) => {
-          const event = new FetchEvent("fetch", { request });
-          globalThis.dispatchEvent(event);
-          return new Response("Worker handler", { status: 200 });
-        },
-        install: () => Promise.resolve(),
-        activate: () => Promise.resolve(),
-        get ready() {
-          return true;
-        },
-        dispose: async () => {
-        }
-      };
-      await import(entrypoint);
-      return instance;
-    } else {
-      return this.#loadServiceWorkerWithMiniflare(entrypoint);
-    }
-  }
   /**
    * Load ServiceWorker using miniflare (workerd) for dev mode
    */
-  async #loadServiceWorkerWithMiniflare(entrypoint) {
+  async loadServiceWorker(entrypoint, _options = {}) {
     logger.info("Starting miniflare dev server", { entrypoint });
     const { Miniflare } = await import("miniflare");
     const miniflareOptions = {
-      modules: false,
-      // ServiceWorker format (not ES modules)
+      modules: true,
       scriptPath: entrypoint,
-      // Enable CF-compatible APIs
       compatibilityDate: "2024-09-23",
       compatibilityFlags: ["nodejs_compat"]
     };
     this.#miniflare = new Miniflare(miniflareOptions);
     await this.#miniflare.ready;
     if (this.#options.assetsDirectory) {
-      logger.info("Setting up separate ASSETS binding", {
+      logger.info("Setting up ASSETS binding", {
         directory: this.#options.assetsDirectory
       });
       this.#assetsMiniflare = new Miniflare({
@@ -108,11 +175,7 @@ var CloudflarePlatform = class extends BasePlatform {
         },
         compatibilityDate: "2024-09-23"
       });
-      const assetsEnv = await this.#assetsMiniflare.getBindings();
-      if (assetsEnv.ASSETS) {
-        this.#assetsBinding = assetsEnv.ASSETS;
-        logger.info("ASSETS binding available", {});
-      }
+      await this.#assetsMiniflare.ready;
     }
     const mf = this.#miniflare;
     const instance = {
@@ -142,9 +205,6 @@ var CloudflarePlatform = class extends BasePlatform {
     logger.info("Miniflare dev server ready", {});
     return instance;
   }
-  /**
-   * Dispose of platform resources
-   */
   async dispose() {
     if (this.#miniflare) {
       await this.#miniflare.dispose();
@@ -154,67 +214,75 @@ var CloudflarePlatform = class extends BasePlatform {
       await this.#assetsMiniflare.dispose();
       this.#assetsMiniflare = null;
     }
-    this.#assetsBinding = null;
+  }
+  /**
+   * Get virtual entry wrapper for Cloudflare Workers
+   *
+   * Wraps user code with:
+   * 1. Config import (shovel:config virtual module)
+   * 2. Runtime initialization (ServiceWorkerGlobals)
+   * 3. User code import (registers fetch handlers)
+   * 4. ES module export for Cloudflare Workers format
+   *
+   * Note: Unlike Node/Bun, Cloudflare bundles user code inline, so the
+   * entryPath is embedded directly in the wrapper.
+   */
+  getEntryWrapper(entryPath, _options) {
+    const safePath = JSON.stringify(entryPath);
+    return `// Cloudflare Worker Entry - uses ServiceWorkerGlobals for feature parity with Node/Bun
+import { initializeRuntime, createFetchHandler } from "@b9g/platform-cloudflare/cloudflare-runtime";
+import { configureLogging } from "@b9g/platform/runtime";
+import { config } from "shovel:config"; // Virtual module - resolved at build time
+
+// Configure logging before anything else
+await configureLogging(config.logging);
+
+// Initialize runtime BEFORE user code (installs globals like addEventListener)
+const registration = initializeRuntime();
+
+// Import user's ServiceWorker code (calls addEventListener('fetch', ...))
+import ${safePath};
+
+// Export ES module handler for Cloudflare Workers
+export default {
+	fetch: createFetchHandler(registration)
+};
+`;
+  }
+  /**
+   * Get Cloudflare-specific esbuild configuration
+   *
+   * Note: Cloudflare Workers natively support import.meta.env, so no define alias
+   * is needed. The nodejs_compat flag enables node:* built-in modules at runtime,
+   * so we externalize them during bundling.
+   */
+  getEsbuildConfig() {
+    return {
+      platform: "browser",
+      conditions: ["worker", "browser"],
+      // Externalize node:* builtins - available at runtime via nodejs_compat flag
+      external: ["node:*"],
+      // Cloudflare bundles user code inline via `import "user-entry"`
+      bundlesUserCodeInline: true
+    };
   }
 };
 function createOptionsFromEnv(env) {
   return {
-    environment: env.ENVIRONMENT || "production",
-    kvNamespaces: extractKVNamespaces(env),
-    r2Buckets: extractR2Buckets(env),
-    d1Databases: extractD1Databases(env),
-    durableObjects: extractDurableObjects(env)
+    environment: env.ENVIRONMENT || "production"
   };
 }
-function extractKVNamespaces(env) {
-  const kvNamespaces = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (key.endsWith("_KV") || key.includes("KV")) {
-      kvNamespaces[key] = value;
-    }
-  }
-  return kvNamespaces;
-}
-function extractR2Buckets(env) {
-  const r2Buckets = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (key.endsWith("_R2") || key.includes("R2")) {
-      r2Buckets[key] = value;
-    }
-  }
-  return r2Buckets;
-}
-function extractD1Databases(env) {
-  const d1Databases = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (key.endsWith("_D1") || key.includes("D1") || key.endsWith("_DB")) {
-      d1Databases[key] = value;
-    }
-  }
-  return d1Databases;
-}
-function extractDurableObjects(env) {
-  const durableObjects = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (key.endsWith("_DO") || key.includes("DURABLE")) {
-      durableObjects[key] = value;
-    }
-  }
-  return durableObjects;
-}
 function generateWranglerConfig(options) {
   const {
     name,
     entrypoint,
-    cacheAdapter: _cacheAdapter,
     filesystemAdapter,
     kvNamespaces = [],
     r2Buckets = [],
     d1Databases = []
   } = options;
-  const autoKVNamespaces = [];
   const autoR2Buckets = filesystemAdapter === "r2" ? ["STORAGE_R2"] : [];
-  const allKVNamespaces = [.../* @__PURE__ */ new Set([...kvNamespaces, ...autoKVNamespaces])];
+  const allKVNamespaces = [...new Set(kvNamespaces)];
   const allR2Buckets = [.../* @__PURE__ */ new Set([...r2Buckets, ...autoR2Buckets])];
   return `# Generated wrangler.toml for Shovel app
 name = "${name}"
@@ -222,189 +290,28 @@ main = "${entrypoint}"
 compatibility_date = "2024-09-23"
 compatibility_flags = ["nodejs_compat"]
 
-# ServiceWorker format (since Shovel apps are ServiceWorker-style)
-usage_model = "bundled"
-
-# KV bindings${allKVNamespaces.length > 0 ? "\n" + allKVNamespaces.map(
-    (kv) => `[[kv_namespaces]]
+${allKVNamespaces.length > 0 ? allKVNamespaces.map((kv) => `[[kv_namespaces]]
 binding = "${kv}"
-id = "your-kv-namespace-id"
-preview_id = "your-preview-kv-namespace-id"`
-  ).join("\n\n") : ""}
+id = "your-kv-id"`).join("\n\n") : "# No KV namespaces configured"}
 
-# R2 bindings${allR2Buckets.length > 0 ? "\n" + allR2Buckets.map(
-    (bucket) => `[[r2_buckets]]
+${allR2Buckets.length > 0 ? allR2Buckets.map((bucket) => `[[r2_buckets]]
 binding = "${bucket}"
-bucket_name = "your-bucket-name"`
-  ).join("\n\n") : ""}
+bucket_name = "your-bucket-name"`).join("\n\n") : "# No R2 buckets configured"}
 
-# D1 bindings
-${d1Databases.map(
-    (db) => `[[d1_databases]]
+${d1Databases.length > 0 ? d1Databases.map((db) => `[[d1_databases]]
 binding = "${db}"
-database_name = "your-database-name"
-database_id = "your-database-id"`
-  ).join("\n\n")}
+database_name = "your-db-name"
+database_id = "your-db-id"`).join("\n\n") : "# No D1 databases configured"}
 `;
 }
-var cloudflareWorkerBanner = `// Cloudflare Worker ES Module wrapper
-let serviceWorkerGlobals = null;
-
-// Set up ServiceWorker environment
-if (typeof globalThis.self === 'undefined') {
-	globalThis.self = globalThis;
-}
-
-// Capture fetch event handlers
-const fetchHandlers = [];
-const originalAddEventListener = globalThis.addEventListener;
-globalThis.addEventListener = function(type, handler, options) {
-	if (type === 'fetch') {
-		fetchHandlers.push(handler);
-	} else {
-		originalAddEventListener?.call(this, type, handler, options);
-	}
-};
-
-// Create a promise-based FetchEvent that can be awaited
-class FetchEvent {
-	constructor(type, init) {
-		this.type = type;
-		this.request = init.request;
-		this._response = null;
-		this._responsePromise = new Promise((resolve) => {
-			this._resolveResponse = resolve;
-		});
-	}
-	
-	respondWith(response) {
-		this._response = response;
-		this._resolveResponse(response);
-	}
-	
-	async waitUntil(promise) {
-		await promise;
-	}
-}`;
-var cloudflareWorkerFooter = `
-// Export ES Module for Cloudflare Workers
-export default {
-	async fetch(request, env, ctx) {
-		try {
-			// Set up ServiceWorker-like dirs API for bundled deployment
-			if (!globalThis.self.dirs) {
-				// For bundled deployment, assets are served via static middleware
-				// not through the dirs API
-				globalThis.self.dirs = {
-					async open(directoryName) {
-						if (directoryName === 'assets') {
-							// Return a minimal interface that indicates no files available
-							// The assets middleware will fall back to dev mode behavior
-							return {
-								async getFileHandle(fileName) {
-									throw new Error(\`NotFoundError: \${fileName} not found in bundled assets\`);
-								}
-							};
-						}
-						throw new Error(\`Directory \${directoryName} not available in bundled deployment\`);
-					}
-				};
-			}
-			
-			// Set up caches API
-			if (!globalThis.self.caches) {
-				globalThis.self.caches = globalThis.caches;
-			}
-			
-			// Ensure request.url is a string
-			if (typeof request.url !== 'string') {
-				return new Response('Invalid request URL: ' + typeof request.url, { status: 500 });
-			}
-			
-			// Create proper FetchEvent-like object
-			let responseReceived = null;
-			const event = { 
-				request, 
-				respondWith: (response) => { responseReceived = response; }
-			};
-			
-			// Helper for error responses
-			const createErrorResponse = (err) => {
-				const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
-				if (isDev) {
-					const escapeHtml = (str) => str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-					return new Response(\`<!DOCTYPE html>
-<html>
-<head>
-  <title>500 Internal Server Error</title>
-  <style>
-    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
-    h1 { color: #c00; }
-    .message { font-size: 1.2em; color: #333; }
-    pre { background: #f5f5f5; padding: 1rem; overflow-x: auto; border-radius: 4px; }
-  </style>
-</head>
-<body>
-  <h1>500 Internal Server Error</h1>
-  <p class="message">\${escapeHtml(err.message)}</p>
-  <pre>\${escapeHtml(err.stack || "No stack trace available")}</pre>
-</body>
-</html>\`, { status: 500, headers: { "Content-Type": "text/html; charset=utf-8" } });
-				} else {
-					return new Response("Internal Server Error", { status: 500, headers: { "Content-Type": "text/plain" } });
-				}
-			};
-
-			// Dispatch to ServiceWorker fetch handlers
-			for (const handler of fetchHandlers) {
-				try {
-					logger.debug("Calling handler", {url: request.url});
-					await handler(event);
-					logger.debug("Handler completed", {hasResponse: !!responseReceived});
-					if (responseReceived) {
-						return responseReceived;
-					}
-				} catch (error) {
-					logger.error("Handler error: {error}", {error});
-					return createErrorResponse(error);
-				}
-			}
-
-			return new Response('No ServiceWorker handler', { status: 404 });
-		} catch (topLevelError) {
-			logger.error("Top-level error: {error}", {error: topLevelError});
-			const isDev = typeof import.meta !== "undefined" && import.meta.env?.MODE !== "production";
-			if (isDev) {
-				const escapeHtml = (str) => String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-				return new Response(\`<!DOCTYPE html>
-<html>
-<head>
-  <title>500 Internal Server Error</title>
-  <style>
-    body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
-    h1 { color: #c00; }
-    .message { font-size: 1.2em; color: #333; }
-    pre { background: #f5f5f5; padding: 1rem; overflow-x: auto; border-radius: 4px; }
-  </style>
-</head>
-<body>
-  <h1>500 Internal Server Error</h1>
-  <p class="message">\${escapeHtml(topLevelError.message)}</p>
-  <pre>\${escapeHtml(topLevelError.stack || "No stack trace available")}</pre>
-</body>
-</html>\`, { status: 500, headers: { "Content-Type": "text/html; charset=utf-8" } });
-			} else {
-				return new Response("Internal Server Error", { status: 500, headers: { "Content-Type": "text/plain" } });
-			}
-		}
-	}
-};`;
 var src_default = CloudflarePlatform;
 export {
   CloudflarePlatform,
-  cloudflareWorkerBanner,
-  cloudflareWorkerFooter,
+  createFetchHandler,
   createOptionsFromEnv,
   src_default as default,
-  generateWranglerConfig
+  generateWranglerConfig,
+  getCtx,
+  getEnv,
+  initializeRuntime
 };