devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-zt22fe2j.js

@@ -0,0 +1,54 @@
+import {
+  DEFAULT_ENTRYPOINT_PATTERN,
+  findFiles,
+  findFilesSync
+} from "./index-rbht7m9r.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/utils/entrypoint-discovery.ts
+import { readFileSync } from "fs";
+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;
+}
+function discoverEntrypointsSync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
+  const discovered = [];
+  try {
+    const files = findFilesSync(pattern, { cwd });
+    for (const file of files) {
+      try {
+        const code = readFileSync(file, "utf-8");
+        const classNames = findEntrypointClasses(code);
+        for (const className of classNames) {
+          discovered.push({ className, filePath: file });
+        }
+      } 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;
+}
+
+export { discoverEntrypointsSync, discoverEntrypointsAsync };

package/dist/index-zxhc6sb0.js

@@ -0,0 +1,192 @@
+import {
+  DEVFLARE_KV_NAMESPACE_TITLE,
+  getEffectiveAccountId,
+  getOrCreateNamedKVNamespace,
+  getPrimaryAccount
+} from "./index-nte9n8w9.js";
+import {
+  isAuthenticated,
+  kvGet,
+  kvPut
+} from "./index-z9fjnwa8.js";
+
+// src/cloudflare/usage.ts
+var USAGE_KEY_PREFIX = "usage:";
+var LIMITS_KEY = "limits";
+var DEFAULT_LIMITS = {
+  aiTokensPerDay: 1e4,
+  aiRequestsPerDay: 100,
+  vectorizeOpsPerDay: 1000,
+  enabled: true
+};
+async function getOrCreateUsageNamespace(accountId) {
+  return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
+}
+function getTodayDate() {
+  return new Date().toISOString().split("T")[0];
+}
+function buildUsageKey(service, date) {
+  return `${USAGE_KEY_PREFIX}${service}:${date}`;
+}
+async function getUsage(accountId, service, date) {
+  const targetDate = date ?? getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, targetDate);
+  const value = await kvGet(accountId, namespaceId, key);
+  if (value === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+async function recordUsage(accountId, service, count = 1) {
+  const today = getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, today);
+  const existing = await getUsage(accountId, service, today);
+  const currentCount = existing?.count ?? 0;
+  const record = {
+    service,
+    date: today,
+    count: currentCount + count,
+    updatedAt: new Date().toISOString()
+  };
+  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+  return record;
+}
+async function resetUsage(accountId, service) {
+  const today = getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, today);
+  const record = {
+    service,
+    date: today,
+    count: 0,
+    updatedAt: new Date().toISOString()
+  };
+  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+}
+async function getLimits(accountId) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const value = await kvGet(accountId, namespaceId, LIMITS_KEY);
+  if (value === null) {
+    return DEFAULT_LIMITS;
+  }
+  try {
+    return { ...DEFAULT_LIMITS, ...JSON.parse(value) };
+  } catch {
+    return DEFAULT_LIMITS;
+  }
+}
+async function setLimits(accountId, limits) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const current = await getLimits(accountId);
+  const updated = {
+    ...current,
+    ...limits
+  };
+  await kvPut(accountId, namespaceId, LIMITS_KEY, JSON.stringify(updated));
+  return updated;
+}
+async function setLimitsEnabled(accountId, enabled) {
+  return setLimits(accountId, { enabled });
+}
+async function isWithinLimits(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return true;
+  }
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  switch (service) {
+    case "ai":
+      if (limits.aiRequestsPerDay && currentCount >= limits.aiRequestsPerDay) {
+        return false;
+      }
+      return true;
+    case "vectorize":
+      if (limits.vectorizeOpsPerDay && currentCount >= limits.vectorizeOpsPerDay) {
+        return false;
+      }
+      return true;
+    default:
+      return true;
+  }
+}
+async function getUsageSummary(accountId, service) {
+  const limits = await getLimits(accountId);
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  let limit;
+  switch (service) {
+    case "ai":
+      limit = limits.aiRequestsPerDay;
+      break;
+    case "vectorize":
+      limit = limits.vectorizeOpsPerDay;
+      break;
+  }
+  const withinLimit = limit === undefined || currentCount < limit;
+  const percentUsed = limit ? currentCount / limit * 100 : undefined;
+  return {
+    service,
+    today: currentCount,
+    limit,
+    withinLimit,
+    percentUsed
+  };
+}
+async function getAllUsageSummaries(accountId) {
+  const trackedServices = ["ai", "vectorize"];
+  return Promise.all(trackedServices.map((s) => getUsageSummary(accountId, s)));
+}
+async function canProceedWithTest(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return { allowed: true };
+  }
+  const withinLimits = await isWithinLimits(accountId, service);
+  if (!withinLimits) {
+    const summary = await getUsageSummary(accountId, service);
+    return {
+      allowed: false,
+      reason: `Daily limit exceeded for ${service}: ${summary.today}/${summary.limit} (${summary.percentUsed?.toFixed(1)}%)`
+    };
+  }
+  return { allowed: true };
+}
+async function recordTestUsage(accountId, service, count = 1) {
+  await recordUsage(accountId, service, count);
+}
+async function shouldSkip(service) {
+  try {
+    const isAuth = await isAuthenticated();
+    if (!isAuth) {
+      console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login`);
+      return true;
+    }
+    const primary = await getPrimaryAccount();
+    if (!primary) {
+      console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found`);
+      return true;
+    }
+    const { accountId } = await getEffectiveAccountId(primary.id);
+    try {
+      const { allowed, reason } = await canProceedWithTest(accountId, service);
+      if (!allowed) {
+        console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
+        return true;
+      }
+    } catch {}
+    return false;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
+    return true;
+  }
+}
+
+export { getUsage, recordUsage, resetUsage, getLimits, setLimits, setLimitsEnabled, isWithinLimits, getUsageSummary, getAllUsageSummaries, canProceedWithTest, recordTestUsage, shouldSkip };

package/dist/index.d.ts

@@ -1,13 +1,9 @@
-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 { defineConfig, preview, loadConfig, loadResolvedConfig, compileConfig, stringifyConfig, configSchema, ConfigNotFoundError, ConfigValidationError, ConfigResourceResolutionError, type DevflareConfig, type DevflareConfigInput, type PreviewScopeFn, type PreviewScopeOptions, type PreviewScopedName, type PreviewScopedNameOptions, type LoadResolvedConfigOptions } from './config';
+export { ref, 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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EACN,YAAY,EACZ,OAAO,EACP,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,6BAA6B,EAC7B,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,MAAM,UAAU,CAAA;AAGjB,OAAO,EACN,GAAG,EACH,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,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACzC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAG9D,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAG3B,OAAO,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -1,298 +1,61 @@
 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";
+  workerName
+} from "./index-62b3gt2g.js";
 import {
-  findDurableObjectClasses,
-  findDurableObjectClassesDetailed,
-  generateWrapper,
-  transformDurableObject
-} from "./index-gz1gndna.js";
-import {
-  server_default
-} from "./index-m2q41jwa.js";
+  parseArgs,
+  runCli
+} from "./index-pt49cgjv.js";
+import"./index-627srx16.js";
+import"./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
 import {
-  BridgeClient,
-  createEnvProxy,
-  getClient,
-  getMiniflare,
-  initEnv,
-  setBindingHints,
-  startMiniflare,
-  startMiniflareFromConfig,
-  stopMiniflare
-} from "./index-pf5s73n9.js";
+  env
+} from "./index-nxkesg55.js";
 import {
-  defineConfig,
-  ref,
-  resolveRef,
-  serviceBinding
-} from "./index-07q6yxyc.js";
+  durableObject,
+  getDurableObjectOptions
+} from "./index-a855bdsx.js";
+import"./index-tknbyxzn.js";
+import"./index-hpwa6vsw.js";
 import {
   compileConfig,
   stringifyConfig
-} from "./index-67qcae0f.js";
+} from "./index-c3nxftnp.js";
 import {
   ConfigNotFoundError,
+  ConfigResourceResolutionError,
   ConfigValidationError,
   configSchema,
-  loadConfig
-} from "./index-hcex3rgh.js";
-import"./index-tfyxa77h.js";
+  loadConfig,
+  loadResolvedConfig
+} from "./index-syscwrjp.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
 import {
-  durableObject,
-  getDurableObjectOptions
-} from "./index-a855bdsx.js";
+  preview
+} from "./index-z40mjts9.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);
-}
+  defineConfig,
+  ref
+} from "./index-q8f4kawk.js";
+import"./index-37x76zdn.js";
 export {
   workerName,
-  withTestContext,
-  transformWorkerEntrypoint,
-  transformDurableObject,
-  testEnv,
   stringifyConfig,
-  stopMiniflare,
-  stopBridgeTestContext,
-  startMiniflareFromConfig,
-  startMiniflare,
-  shouldTransformWorker,
-  setBindingHints,
-  serviceBinding,
   runCli,
-  resolveRef,
   ref,
+  preview,
   parseArgs,
+  loadResolvedConfig,
   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
+  ConfigResourceResolutionError,
+  ConfigNotFoundError
 };