devflare 0.0.0 → 1.0.0-next.1

package/dist/index-tk6ej9dj.js

@@ -0,0 +1,94 @@
+import {
+  DEFAULT_ENTRYPOINT_PATTERN,
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/utils/entrypoint-discovery.ts
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
+function findEntrypointClasses(code) {
+  const classes = [];
+  ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = ENTRYPOINT_CLASS_PATTERN.exec(code)) !== null) {
+    classes.push(match[1]);
+  }
+  return classes;
+}
+var EP_FILE_PATTERN = /^ep\.[^.]+\.ts$/;
+function discoverEntrypointsSync(dir) {
+  const discovered = [];
+  try {
+    const files = readdirSync(dir, { withFileTypes: true });
+    for (const file of files) {
+      if (file.isFile() && EP_FILE_PATTERN.test(file.name)) {
+        const filePath = join(dir, file.name);
+        try {
+          const code = readFileSync(filePath, "utf-8");
+          const classNames = findEntrypointClasses(code);
+          for (const className of classNames) {
+            discovered.push({ className, filePath });
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  return discovered;
+}
+async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+  const fs = await import("node:fs/promises");
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findEntrypointClasses(code);
+      for (const className of classNames) {
+        discovered.push({ className, filePath });
+      }
+    } catch {}
+  }
+  return discovered;
+}
+
+// src/utils/resolve-package.ts
+import { resolve, dirname } from "pathe";
+import { readFileSync as readFileSync2, existsSync } from "node:fs";
+function resolvePackageSpecifier(specifier, fromDir) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) {
+    return resolve(fromDir, specifier);
+  }
+  try {
+    const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+    const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
+    const pkgJsonPath = __require.resolve(`${parts}/package.json`, { paths: [fromDir] });
+    const pkgDir = dirname(pkgJsonPath);
+    if (subpath) {
+      const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
+      const exportPath = pkgJson.exports?.[`./${subpath}`];
+      if (exportPath) {
+        const targetPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
+        return resolve(pkgDir, targetPath);
+      }
+      const directPath = resolve(pkgDir, `${subpath}.ts`);
+      if (existsSync(directPath))
+        return directPath;
+      const withExt = resolve(pkgDir, subpath);
+      if (existsSync(withExt))
+        return withExt;
+      if (existsSync(`${withExt}.ts`))
+        return `${withExt}.ts`;
+      if (existsSync(`${withExt}.js`))
+        return `${withExt}.js`;
+    }
+    return pkgDir;
+  } catch {
+    return resolve(fromDir, specifier);
+  }
+}
+
+export { discoverEntrypointsSync, discoverEntrypointsAsync, resolvePackageSpecifier };

package/dist/index-z14anrqp.js

@@ -0,0 +1,226 @@
+// src/transform/worker-entrypoint.ts
+import ts from "typescript";
+import MagicString from "magic-string";
+function findExportedFunctions(code) {
+  const functions = [];
+  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      const modifiers = ts.getModifiers(node);
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      if (isExported) {
+        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const funcName = isDefault ? "fetch" : node.name.text;
+        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
+        functions.push({
+          name: funcName,
+          isAsync,
+          params,
+          returnType,
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          isDefault
+        });
+      }
+    }
+    if (ts.isFunctionDeclaration(node) && !node.name) {
+      const modifiers = ts.getModifiers(node);
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      if (isExported && isDefault) {
+        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
+        functions.push({
+          name: "fetch",
+          isAsync,
+          params,
+          returnType,
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          isDefault: true
+        });
+      }
+    }
+    if (ts.isVariableStatement(node)) {
+      const modifiers = ts.getModifiers(node);
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      if (isExported) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.initializer) {
+            let funcExpr;
+            if (ts.isFunctionExpression(decl.initializer)) {
+              funcExpr = decl.initializer;
+            } else if (ts.isArrowFunction(decl.initializer)) {
+              funcExpr = decl.initializer;
+            }
+            if (funcExpr) {
+              const modifiersArr = ts.getModifiers(funcExpr);
+              const isAsync = modifiersArr?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? (ts.isArrowFunction(funcExpr) && funcExpr.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) ?? false;
+              const params = funcExpr.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
+              const returnType = funcExpr.type ? code.substring(funcExpr.type.getStart(sourceFile), funcExpr.type.getEnd()) : undefined;
+              functions.push({
+                name: decl.name.text,
+                isAsync,
+                params,
+                returnType,
+                start: node.getStart(sourceFile),
+                end: node.getEnd()
+              });
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return functions;
+}
+function shouldTransformWorker(code, filePath) {
+  if (!filePath.endsWith("worker.ts") && !filePath.endsWith("worker.js")) {
+    return false;
+  }
+  const functions = findExportedFunctions(code);
+  return functions.length > 0;
+}
+function transformWorkerEntrypoint(code, id, options = {}) {
+  const className = options.className ?? "Worker";
+  const injectContext = options.injectContext ?? true;
+  const functions = findExportedFunctions(code);
+  if (functions.length === 0) {
+    return null;
+  }
+  const fetchFn = functions.find((f) => f.name === "fetch");
+  const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  const s = new MagicString(code);
+  const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
+`;
+  if (injectContext) {
+    s.prepend(`import { runWithContext } from 'devflare/runtime'
+`);
+  }
+  s.prepend(importStatement);
+  for (const fn of functions) {
+    const fnCode = code.substring(fn.start, fn.end);
+    const internalName = fn.name === "fetch" ? "__originalFetch" : `__original_${fn.name}`;
+    if (fn.isDefault) {
+      const replacement = fnCode.replace(/^export\s+default\s+(async\s+)?function\s*/, (_, asyncKw) => `const ${internalName} = ${asyncKw || ""}function `);
+      s.overwrite(fn.start, fn.end, replacement);
+    } else if (fnCode.startsWith("export function") || fnCode.startsWith("export async function")) {
+      const replacement = fnCode.replace(/^export\s+(async\s+)?function\s+\w+/, (_, asyncKw) => `${asyncKw || ""}function ${internalName}`);
+      s.overwrite(fn.start, fn.end, replacement);
+    } else if (fnCode.startsWith("export const")) {
+      const replacement = fnCode.replace(/^export\s+const\s+\w+/, () => `const ${internalName}`);
+      s.overwrite(fn.start, fn.end, replacement);
+    }
+  }
+  let classBody = `
+
+// ============ Devflare WorkerEntrypoint ============
+class ${className} extends WorkerEntrypoint {
+`;
+  if (fetchFn) {
+    if (injectContext) {
+      classBody += `	async fetch(request: Request): Promise<Response> {
+`;
+      classBody += `		return runWithContext(
+`;
+      classBody += `			this.env,
+`;
+      classBody += `			this.ctx,
+`;
+      classBody += `			request,
+`;
+      classBody += `			() => __originalFetch(request, this.env, this.ctx),
+`;
+      classBody += `			'fetch'
+`;
+      classBody += `		)
+`;
+      classBody += `	}
+`;
+    } else {
+      classBody += `	async fetch(request: Request): Promise<Response> {
+`;
+      classBody += `		return __originalFetch(request, this.env, this.ctx)
+`;
+      classBody += `	}
+`;
+    }
+  }
+  for (const fn of rpcMethods) {
+    const asyncPrefix = fn.isAsync ? "async " : "";
+    const returnType = fn.returnType ? `: ${fn.returnType}` : "";
+    const paramNames = extractParamNames(fn.params);
+    classBody += `
+	${asyncPrefix}${fn.name}(${fn.params})${returnType} {
+`;
+    classBody += `		return __original_${fn.name}(${paramNames})
+`;
+    classBody += `	}
+`;
+  }
+  classBody += `}
+
+`;
+  classBody += `export { ${className} }
+`;
+  classBody += `export { ${className} as default }
+`;
+  classBody += `// ============ End Devflare WorkerEntrypoint ============
+`;
+  s.append(classBody);
+  return {
+    code: s.toString(),
+    map: s.generateMap({
+      source: id,
+      file: id + ".map",
+      includeContent: true
+    }),
+    rpcMethods: rpcMethods.map((fn) => fn.name),
+    className
+  };
+}
+function extractParamNames(params) {
+  if (!params.trim())
+    return "";
+  const tempCode = `function f(${params}) {}`;
+  const sourceFile = ts.createSourceFile("temp.ts", tempCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const names = [];
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node)) {
+      for (const param of node.parameters) {
+        if (ts.isIdentifier(param.name)) {
+          names.push(param.name.text);
+        } else if (ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)) {
+          names.push(tempCode.substring(param.name.getStart(sourceFile), param.name.getEnd()));
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return names.join(", ");
+}
+function generateRpcInterface(functions, interfaceName) {
+  const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  if (rpcMethods.length === 0) {
+    return "";
+  }
+  let output = `export interface ${interfaceName} {
+`;
+  for (const fn of rpcMethods) {
+    const returnType = fn.returnType ?? "unknown";
+    const promiseReturn = returnType.startsWith("Promise<") ? returnType : `Promise<${returnType}>`;
+    output += `	${fn.name}(${fn.params}): ${promiseReturn}
+`;
+  }
+  output += `}
+`;
+  return output;
+}
+
+export { findExportedFunctions, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { defineConfig, loadConfig, compileConfig, stringifyConfig, configSchema, ConfigNotFoundError, ConfigValidationError, type DevflareConfig, type DevflareConfigInput } from './config';
+export { ref, resolveRef, serviceBinding, type RefResult, type WorkerBinding, type WorkerBindingAccessor } from './config';
+export { workerName } from './workerName';
+export { durableObject, getDurableObjectOptions, type DurableObjectOptions } from './decorators';
+export { findDurableObjectClasses, findDurableObjectClassesDetailed, generateWrapper, transformDurableObject, type DOClassInfo, type WrapperOptions, type TransformResult } from './transform/durable-object';
+export { transformWorkerEntrypoint, findExportedFunctions, shouldTransformWorker, generateRpcInterface, type ExportedFunction, type WorkerTransformOptions, type WorkerTransformResult } from './transform';
+export { runCli, parseArgs } from './cli';
+export type { ParsedArgs, CliOptions, CliResult } from './cli';
+export { setBindingHints, createEnvProxy, initEnv, type EnvProxyOptions, type BindingHints, BridgeClient, getClient, type BridgeClientOptions, startMiniflare, startMiniflareFromConfig, getMiniflare, stopMiniflare, type MiniflareInstance, type MiniflareOptions, gateway } from './bridge';
+export { env } from './env';
+export { createTestContext, createMockTestContext, createMockKV, createMockD1, createMockR2, createMockQueue, createMockEnv, withTestContext, type TestContext, type TestContextOptions, type MockEnvOptions, createBridgeTestContext, stopBridgeTestContext, getBridgeTestContext, testEnv, type BridgeTestContext, type BridgeTestContextOptions } from './test';
+export { defineConfig as default } from './config';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EACN,YAAY,EACZ,UAAU,EACV,aAAa,EACb,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,MAAM,UAAU,CAAA;AAGjB,OAAO,EACN,GAAG,EACH,UAAU,EACV,cAAc,EACd,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAGzC,OAAO,EACN,aAAa,EACb,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,MAAM,cAAc,CAAA;AAGrB,OAAO,EACN,wBAAwB,EACxB,gCAAgC,EAChC,eAAe,EACf,sBAAsB,EACtB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EACN,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,MAAM,aAAa,CAAA;AAGpB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACzC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAG9D,OAAO,EAEN,eAAe,EACf,cAAc,EACd,OAAO,EACP,KAAK,eAAe,EACpB,KAAK,YAAY,EAGjB,YAAY,EACZ,SAAS,EACT,KAAK,mBAAmB,EAGxB,cAAc,EACd,wBAAwB,EACxB,YAAY,EACZ,aAAa,EACb,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAGrB,OAAO,EACP,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAG3B,OAAO,EACN,iBAAiB,EACjB,qBAAqB,EACrB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,aAAa,EACb,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,cAAc,EAGnB,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,OAAO,EACP,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,MAAM,QAAQ,CAAA;AAGf,OAAO,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1,298 @@
+import {
+  createBridgeTestContext,
+  createMockD1,
+  createMockEnv,
+  createMockKV,
+  createMockQueue,
+  createMockR2,
+  createMockTestContext,
+  createTestContext,
+  env,
+  getBridgeTestContext,
+  stopBridgeTestContext,
+  testEnv,
+  withTestContext
+} from "./index-ep3445yc.js";
+import {
+  findExportedFunctions,
+  generateRpcInterface,
+  shouldTransformWorker,
+  transformWorkerEntrypoint
+} from "./index-z14anrqp.js";
+import"./index-tk6ej9dj.js";
+import"./index-d8bdkx2h.js";
+import"./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses,
+  findDurableObjectClassesDetailed,
+  generateWrapper,
+  transformDurableObject
+} from "./index-gz1gndna.js";
+import {
+  server_default
+} from "./index-m2q41jwa.js";
+import {
+  BridgeClient,
+  createEnvProxy,
+  getClient,
+  getMiniflare,
+  initEnv,
+  setBindingHints,
+  startMiniflare,
+  startMiniflareFromConfig,
+  stopMiniflare
+} from "./index-pf5s73n9.js";
+import {
+  defineConfig,
+  ref,
+  resolveRef,
+  serviceBinding
+} from "./index-07q6yxyc.js";
+import {
+  compileConfig,
+  stringifyConfig
+} from "./index-67qcae0f.js";
+import {
+  ConfigNotFoundError,
+  ConfigValidationError,
+  configSchema,
+  loadConfig
+} from "./index-hcex3rgh.js";
+import"./index-tfyxa77h.js";
+import {
+  durableObject,
+  getDurableObjectOptions
+} from "./index-a855bdsx.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+// src/workerName.ts
+var workerName = (() => {
+  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
+    return __DEVFLARE_WORKER_NAME__;
+  }
+  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
+    return process.env.DEVFLARE_WORKER_NAME;
+  }
+  return "unknown";
+})();
+// src/cli/index.ts
+import { createConsola } from "consola";
+var COMMANDS = ["init", "dev", "build", "deploy", "types", "doctor", "account", "ai", "remote", "help", "version"];
+var VERSION = "0.1.0";
+function parseArgs(argv) {
+  const args = [];
+  const options = {};
+  let command = "help";
+  let unknownCommand;
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      return { command: "help", args: [], options: {} };
+    }
+    if (arg === "--version" || arg === "-v") {
+      return { command: "version", args: [], options: {} };
+    }
+    if (arg.startsWith("-") && !/^-\d/.test(arg)) {
+      const isLongFlag = arg.startsWith("--");
+      const key = isLongFlag ? arg.slice(2) : arg.slice(1);
+      const nextArg = argv[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        options[key] = nextArg;
+        i += 2;
+      } else {
+        options[key] = true;
+        i++;
+      }
+    } else if (!command || command === "help") {
+      if (COMMANDS.includes(arg)) {
+        command = arg;
+      } else {
+        command = "help";
+        unknownCommand = arg;
+      }
+      i++;
+    } else {
+      args.push(arg);
+      i++;
+    }
+  }
+  return { command, args, options, unknownCommand };
+}
+function getHelpText() {
+  return `
+devflare - Config Compiler + CLI Orchestrator for Cloudflare Workers
+
+Usage:
+  devflare <command> [options]
+
+Commands:
+  init [name]     Create a new devflare project
+  dev             Start unified development server
+  build           Build for production
+  deploy          Deploy to Cloudflare
+  types           Generate TypeScript types
+  doctor          Check project configuration
+  account         View Cloudflare account info
+  ai              View AI models and pricing
+  remote          Manage remote test mode (AI, Vectorize)
+
+Global Options:
+  -h, --help      Show help
+  -v, --version   Show version
+  --config <path> Path to config file
+  --debug         Enable debug mode
+
+Dev Command Options:
+  --port <port>   Vite dev server port (default: 5173)
+  --persist       Persist Miniflare storage data
+  --verbose       Enable verbose logging
+  --log           Log all output to .log-{datetime} file AND terminal
+  --log-temp      Log all output to .log file (overwritten) AND terminal
+
+Dev Server Features:
+  • Vite HMR for frontend (instant updates)
+  • Miniflare for ALL Cloudflare bindings (KV, D1, R2, DOs, Queues, AI)
+  • Rolldown for fast DO bundling with watch mode
+  • DO hot reload when files change (no restart needed)
+  • WebSocket bridge for seamless Node.js ↔ Miniflare communication
+
+Examples:
+  devflare init my-app
+  devflare dev                  # Start unified dev server
+  devflare dev --port 3000      # Custom Vite port
+  devflare dev --persist        # Persist storage between restarts
+  devflare dev --log-temp       # Log output to .log file
+  devflare build
+  devflare deploy --env production
+`.trim();
+}
+async function runCli(argv, options = {}) {
+  const logger = createConsola({
+    level: options.silent ? -999 : 3,
+    formatOptions: {
+      date: false
+    }
+  });
+  const parsed = parseArgs(argv);
+  if (parsed.unknownCommand) {
+    logger.error(`Unknown command: ${parsed.unknownCommand}`);
+    logger.info("Run `devflare --help` for available commands");
+    return { exitCode: 1 };
+  }
+  switch (parsed.command) {
+    case "help":
+      logger.info(getHelpText());
+      return { exitCode: 0, output: getHelpText() };
+    case "version":
+      logger.info(`devflare v${VERSION}`);
+      return { exitCode: 0, output: VERSION };
+    case "init":
+      return runInit(parsed, logger, options);
+    case "dev":
+      return runDev(parsed, logger, options);
+    case "build":
+      return runBuild(parsed, logger, options);
+    case "deploy":
+      return runDeploy(parsed, logger, options);
+    case "types":
+      return runTypes(parsed, logger, options);
+    case "doctor":
+      return runDoctor(parsed, logger, options);
+    case "account":
+      return runAccount(parsed, logger, options);
+    case "ai":
+      return runAI();
+    case "remote":
+      return runRemote(parsed, logger, options);
+    default:
+      logger.error(`Unknown command: ${parsed.command}`);
+      return { exitCode: 1 };
+  }
+}
+async function runInit(parsed, logger, options) {
+  const { runInitCommand } = await import("./init-f9mgmew3.js");
+  return runInitCommand(parsed, logger, options);
+}
+async function runDev(parsed, logger, options) {
+  const { runDevCommand } = await import("./dev-qnxet3j9.js");
+  return runDevCommand(parsed, logger, options);
+}
+async function runBuild(parsed, logger, options) {
+  const { runBuildCommand } = await import("./build-mnf6v8gd.js");
+  return runBuildCommand(parsed, logger, options);
+}
+async function runDeploy(parsed, logger, options) {
+  const { runDeployCommand } = await import("./deploy-nhceck39.js");
+  return runDeployCommand(parsed, logger, options);
+}
+async function runTypes(parsed, logger, options) {
+  const { runTypesCommand } = await import("./types-5nyrz1sz.js");
+  return runTypesCommand(parsed, logger, options);
+}
+async function runDoctor(parsed, logger, options) {
+  const { runDoctorCommand } = await import("./doctor-e8fy6fj5.js");
+  return runDoctorCommand(parsed, logger, options);
+}
+async function runAccount(parsed, logger, options) {
+  const { runAccountCommand } = await import("./account-rvrj687w.js");
+  return runAccountCommand(parsed, logger, options);
+}
+async function runAI() {
+  const { runAICommand } = await import("./ai-dx4fr9jh.js");
+  return runAICommand();
+}
+async function runRemote(parsed, logger, options) {
+  const { runRemoteCommand } = await import("./remote-q59qk463.js");
+  return runRemoteCommand(parsed, logger, options);
+}
+export {
+  workerName,
+  withTestContext,
+  transformWorkerEntrypoint,
+  transformDurableObject,
+  testEnv,
+  stringifyConfig,
+  stopMiniflare,
+  stopBridgeTestContext,
+  startMiniflareFromConfig,
+  startMiniflare,
+  shouldTransformWorker,
+  setBindingHints,
+  serviceBinding,
+  runCli,
+  resolveRef,
+  ref,
+  parseArgs,
+  loadConfig,
+  initEnv,
+  getMiniflare,
+  getDurableObjectOptions,
+  getClient,
+  getBridgeTestContext,
+  generateWrapper,
+  generateRpcInterface,
+  server_default as gateway,
+  findExportedFunctions,
+  findDurableObjectClassesDetailed,
+  findDurableObjectClasses,
+  env,
+  durableObject,
+  defineConfig,
+  defineConfig as default,
+  createTestContext,
+  createMockTestContext,
+  createMockR2,
+  createMockQueue,
+  createMockKV,
+  createMockEnv,
+  createMockD1,
+  createEnvProxy,
+  createBridgeTestContext,
+  configSchema,
+  compileConfig,
+  ConfigValidationError,
+  ConfigNotFoundError,
+  BridgeClient
+};