lopata 0.0.1

package/runtime/vite-plugin/globals-plugin.ts

@@ -0,0 +1,94 @@
+import type { Plugin } from "vite";
+
+let initialized = false;
+
+/**
+ * Sets up global Cloudflare-compatible APIs in the Bun process:
+ * caches, HTMLRewriter, WebSocketPair, IdentityTransformStream, FixedLengthStream,
+ * navigator.userAgent, scheduler.wait(), crypto extensions.
+ *
+ * Runs once on configureServer (before middleware), idempotent.
+ * Imports are lazy because the plugin is externalized by Vite's config bundler —
+ * dynamic imports run at dev server startup time through Bun's native loader.
+ */
+export function globalsPlugin(): Plugin {
+  return {
+    name: "bunflare:globals",
+
+    async configureServer() {
+      if (initialized) return;
+      initialized = true;
+
+      const { SqliteCacheStorage } = await import("../bindings/cache.ts");
+      const { HTMLRewriter } = await import("../bindings/html-rewriter.ts");
+      const { WebSocketPair } = await import("../bindings/websocket-pair.ts");
+      const { IdentityTransformStream, FixedLengthStream } = await import("../bindings/cf-streams.ts");
+      const { patchGlobalCrypto } = await import("../bindings/crypto-extras.ts");
+      const { getDatabase } = await import("../db.ts");
+      const { instrumentBinding } = await import("../tracing/instrument.ts");
+
+      // Global caches (CacheStorage)
+      const cacheMethods = ["match", "put", "delete"];
+      const rawCacheStorage = new SqliteCacheStorage(getDatabase());
+      rawCacheStorage.default = instrumentBinding(rawCacheStorage.default, {
+        type: "cache", name: "default", methods: cacheMethods,
+      }) as typeof rawCacheStorage.default;
+
+      const originalOpen = rawCacheStorage.open.bind(rawCacheStorage);
+      rawCacheStorage.open = async (cacheName: string) => {
+        const cache = await originalOpen(cacheName);
+        return instrumentBinding(cache, {
+          type: "cache", name: cacheName, methods: cacheMethods,
+        });
+      };
+
+      Object.defineProperty(globalThis, "caches", {
+        value: rawCacheStorage,
+        writable: false,
+        configurable: true,
+      });
+
+      Object.defineProperty(globalThis, "HTMLRewriter", {
+        value: HTMLRewriter,
+        writable: false,
+        configurable: true,
+      });
+
+      Object.defineProperty(globalThis, "WebSocketPair", {
+        value: WebSocketPair,
+        writable: false,
+        configurable: true,
+      });
+
+      Object.defineProperty(globalThis, "IdentityTransformStream", {
+        value: IdentityTransformStream,
+        writable: false,
+        configurable: true,
+      });
+
+      Object.defineProperty(globalThis, "FixedLengthStream", {
+        value: FixedLengthStream,
+        writable: false,
+        configurable: true,
+      });
+
+      patchGlobalCrypto();
+
+      Object.defineProperty(globalThis.navigator, "userAgent", {
+        value: "Cloudflare-Workers",
+        writable: false,
+        configurable: true,
+      });
+
+      Object.defineProperty(globalThis, "scheduler", {
+        value: {
+          wait(ms: number): Promise<void> {
+            return new Promise((resolve) => setTimeout(resolve, ms));
+          },
+        },
+        writable: false,
+        configurable: true,
+      });
+    },
+  };
+}

package/runtime/vite-plugin/index.ts

@@ -0,0 +1,43 @@
+import type { Plugin } from "vite";
+import { configPlugin } from "./config-plugin.ts";
+import { modulesPlugin } from "./modules-plugin.ts";
+import { globalsPlugin } from "./globals-plugin.ts";
+import { devServerPlugin } from "./dev-server-plugin.ts";
+import { reactRouterPlugin } from "./react-router-plugin.ts";
+
+export interface BunflarePluginConfig {
+  /** Path to wrangler.jsonc/.json/.toml config. Auto-detected if not specified. */
+  configPath?: string;
+  /** Vite environment name for SSR. Default: "ssr" */
+  viteEnvironment?: { name?: string };
+  /** Auxiliary workers loaded via native Bun import (not through Vite). */
+  auxiliaryWorkers?: { configPath: string }[];
+}
+
+/**
+ * Bunflare Vite plugin — drop-in replacement for `@cloudflare/vite-plugin`.
+ *
+ * Provides Cloudflare Worker compatibility in Vite dev mode:
+ * - CF module resolution (cloudflare:workers, cloudflare:workflows, @cloudflare/containers)
+ * - Global CF APIs (caches, HTMLRewriter, WebSocketPair, etc.)
+ * - Bindings (KV, R2, D1, DO, Workflows, Queues, etc.) backed by SQLite/FS
+ * - SSR middleware that calls worker.fetch() with the built env
+ *
+ * Install as a dependency (or link:) so Vite externalizes it at config bundle time.
+ * Runtime imports then go through Bun's native module loader.
+ */
+export function bunflare(config?: BunflarePluginConfig): Plugin[] {
+  const envName = config?.viteEnvironment?.name ?? "ssr";
+
+  return [
+    configPlugin(envName),
+    modulesPlugin(envName),
+    globalsPlugin(),
+    devServerPlugin({
+      configPath: config?.configPath,
+      envName,
+      auxiliaryWorkers: config?.auxiliaryWorkers,
+    }),
+    reactRouterPlugin(),
+  ];
+}

package/runtime/vite-plugin/modules-plugin.ts

@@ -0,0 +1,88 @@
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Plugin } from "vite";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const VIRTUAL_MODULES: Record<string, string> = {
+  "cloudflare:workers": "\0cloudflare:workers",
+  "cloudflare:workflows": "\0cloudflare:workflows",
+  "@cloudflare/containers": "\0@cloudflare/containers",
+};
+
+function resolvePath(relativePath: string): string {
+  return resolve(__dirname, "..", relativePath);
+}
+
+/**
+ * Resolves Cloudflare virtual modules (cloudflare:workers, cloudflare:workflows,
+ * @cloudflare/containers) to re-exports from Bunflare runtime binding implementations.
+ *
+ * Only active in the SSR environment.
+ */
+export function modulesPlugin(envName: string): Plugin {
+  return {
+    name: "bunflare:modules",
+
+    resolveId(id: string) {
+      if (this.environment?.name !== envName) return;
+      if (id in VIRTUAL_MODULES) {
+        return VIRTUAL_MODULES[id];
+      }
+    },
+
+    load(id: string) {
+      if (id === "\0cloudflare:workers") {
+        const durableObject = resolvePath("bindings/durable-object");
+        const workflow = resolvePath("bindings/workflow");
+        const websocketPair = resolvePath("bindings/websocket-pair");
+
+        // env is a proxy to globalThis.__bunflare_env so it works across
+        // Vite SSR runner and native Bun module graphs (which are separate
+        // module instances — a direct re-export of globalEnv would be empty
+        // in the SSR runner because setGlobalEnv() writes to the native instance).
+        return `
+export { DurableObjectBase as DurableObject } from "${durableObject}";
+export { WorkflowEntrypointBase as WorkflowEntrypoint } from "${workflow}";
+export { WebSocketRequestResponsePair } from "${durableObject}";
+export { WebSocketPair } from "${websocketPair}";
+export const env = new Proxy({}, {
+  get(_, prop) { return globalThis.__bunflare_env?.[prop]; },
+  set(_, prop, value) { if (globalThis.__bunflare_env) globalThis.__bunflare_env[prop] = value; return true; },
+  has(_, prop) { return prop in (globalThis.__bunflare_env ?? {}); },
+  ownKeys() { return Object.keys(globalThis.__bunflare_env ?? {}); },
+  getOwnPropertyDescriptor(_, prop) {
+    const target = globalThis.__bunflare_env;
+    if (target && prop in target) return { configurable: true, enumerable: true, value: target[prop] };
+  },
+});
+export class WorkerEntrypoint {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+    this[Symbol.for("bunflare.RpcTarget")] = true;
+  }
+}
+export class RpcTarget {
+  constructor() {
+    this[Symbol.for("bunflare.RpcTarget")] = true;
+  }
+}
+`;
+      }
+
+      if (id === "\0cloudflare:workflows") {
+        const workflow = resolvePath("bindings/workflow");
+        return `export { NonRetryableError } from "${workflow}";`;
+      }
+
+      if (id === "\0@cloudflare/containers") {
+        const container = resolvePath("bindings/container");
+        return `
+export { ContainerBase as Container } from "${container}";
+export { getContainer, getRandom } from "${container}";
+`;
+      }
+    },
+  };
+}

package/runtime/vite-plugin/react-router-plugin.ts

@@ -0,0 +1,95 @@
+import type { Plugin } from "vite";
+
+const SERVER_BUILD_ID = "\0virtual:react-router/server-build";
+
+/**
+ * Instruments React Router loaders, actions, and SSR rendering with
+ * Bunflare tracing spans via the `unstable_instrumentations` API.
+ *
+ * Works by transforming React Router's `virtual:react-router/server-build`
+ * virtual module to inject an `unstable_ServerInstrumentation` and wrap
+ * the `handleRequest` (default export) with a render span.
+ *
+ * Uses the `globalThis.__bunflare_startSpan` bridge set up by
+ * `dev-server-plugin.ts` to call into the tracing runtime, which lives
+ * in Bun's native module graph (separate from Vite's SSR runner).
+ *
+ * If React Router is not used, this plugin is a no-op.
+ */
+export function reactRouterPlugin(): Plugin {
+  return {
+    name: "bunflare:react-router",
+
+    transform(code, id) {
+      if (id !== SERVER_BUILD_ID) return;
+
+      // Replace the `export const entry = { module: entryServer };` line
+      // with our instrumented version that adds tracing.
+      const entryPattern = /export const entry\s*=\s*\{\s*module:\s*entryServer\s*\};/;
+
+      if (!entryPattern.test(code)) return;
+
+      const injected = `
+const __bf_instr = {
+  route({ id, path, instrument }) {
+    instrument({
+      loader: async (callHandler, info) => {
+        const startSpan = globalThis.__bunflare_startSpan;
+        if (!startSpan) { await callHandler(); return; }
+        await startSpan({
+          name: "loader " + id,
+          kind: "internal",
+          attributes: {
+            "rr.type": "loader",
+            "rr.route.id": id,
+            "rr.route.pattern": info?.unstable_pattern,
+          },
+        }, async () => {
+          const result = await callHandler();
+          if (result.status === "error") throw result.error;
+        });
+      },
+      action: async (callHandler, info) => {
+        const startSpan = globalThis.__bunflare_startSpan;
+        if (!startSpan) { await callHandler(); return; }
+        await startSpan({
+          name: "action " + id,
+          kind: "internal",
+          attributes: {
+            "rr.type": "action",
+            "rr.route.id": id,
+            "rr.route.pattern": info?.unstable_pattern,
+          },
+        }, async () => {
+          const result = await callHandler();
+          if (result.status === "error") throw result.error;
+        });
+      },
+    });
+  },
+};
+
+const __bf_entry = {
+  ...entryServer,
+  default: async function(...args) {
+    const startSpan = globalThis.__bunflare_startSpan;
+    if (!startSpan) return entryServer.default(...args);
+    return startSpan({
+      name: "react-router.render",
+      kind: "internal",
+      attributes: { "rr.type": "render" },
+    }, () => entryServer.default(...args));
+  },
+  unstable_instrumentations: [
+    ...(entryServer.unstable_instrumentations || []),
+    __bf_instr,
+  ],
+};
+export const entry = { module: __bf_entry };
+`;
+
+      const transformed = code.replace(entryPattern, injected);
+      return { code: transformed, map: null };
+    },
+  };
+}

package/runtime/worker-registry.ts

@@ -0,0 +1,52 @@
+import type { GenerationManager } from "./generation-manager";
+
+/**
+ * Central registry holding all worker GenerationManagers, keyed by worker name.
+ * Used to resolve cross-worker service bindings.
+ */
+export class WorkerRegistry {
+  private managers = new Map<string, GenerationManager>();
+  private mainName: string | null = null;
+
+  /** Register a worker's GenerationManager */
+  register(name: string, manager: GenerationManager, isMain = false): void {
+    this.managers.set(name, manager);
+    if (isMain) {
+      this.mainName = name;
+    }
+  }
+
+  /** Get manager by worker name */
+  getManager(name: string): GenerationManager | undefined {
+    return this.managers.get(name);
+  }
+
+  /** Get the main (HTTP entrypoint) worker's manager */
+  getMainManager(): GenerationManager {
+    if (!this.mainName) throw new Error("No main worker registered");
+    const manager = this.managers.get(this.mainName);
+    if (!manager) throw new Error("Main worker manager not found");
+    return manager;
+  }
+
+  /**
+   * Lazily resolve a target worker's module and env from its active generation.
+   * Called on each service binding invocation so hot-reloaded workers are picked up.
+   */
+  resolveTarget(workerName: string): { workerModule: Record<string, unknown>; env: Record<string, unknown> } {
+    const manager = this.managers.get(workerName);
+    if (!manager) {
+      throw new Error(`Worker "${workerName}" is not registered in the worker registry`);
+    }
+    const gen = manager.active;
+    if (!gen) {
+      throw new Error(`Worker "${workerName}" has no active generation (failed to load?)`);
+    }
+    return { workerModule: gen.workerModule, env: gen.env };
+  }
+
+  /** List all registered managers (for dashboard) */
+  listManagers(): Map<string, GenerationManager> {
+    return this.managers;
+  }
+}