devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/test/multi-worker-context.d.ts

@@ -1,114 +0,0 @@
-import type { Miniflare } from 'miniflare';
-/**
- * Configuration for a worker in a multi-worker test
- */
-export interface WorkerConfig {
-    /** Worker name (used for service binding references) */
-    name: string;
-    /** Worker script code as string */
-    script: string;
-    /** Whether the script uses ES modules (default: true) */
-    modules?: boolean;
-    /** Compatibility date (default: '2025-01-01') */
-    compatibilityDate?: string;
-    /**
-     * Service bindings to other workers
-     * Key: binding name, Value: worker name or { name, entrypoint }
-     */
-    serviceBindings?: Record<string, string | {
-        name: string;
-        entrypoint: string;
-    }>;
-}
-/**
- * Options for creating a multi-worker test context
- */
-export interface MultiWorkerContextOptions {
-    /** Array of worker configurations */
-    workers: WorkerConfig[];
-    /**
-     * Name of the primary worker (receives HTTP requests)
-     * Defaults to first worker in the array
-     */
-    primary?: string;
-}
-/**
- * Result of creating a multi-worker test context
- */
-export interface MultiWorkerContext<TEnv = Record<string, unknown>> {
-    /** Miniflare instance */
-    mf: Miniflare;
-    /** Environment bindings from the primary worker */
-    env: TEnv;
-    /** Dispatch a fetch request to the primary worker */
-    fetch: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-    /** Dispose of the context (cleanup) */
-    dispose: () => Promise<void>;
-}
-/**
- * @deprecated Use `createTestContext()` instead. It now automatically detects service bindings
- * from `ref()` metadata in your devflare.config.ts and sets up multi-worker Miniflare.
- *
- * Create a multi-worker test context for testing RPC between workers.
- *
- * @example
- * ```ts
- * const gatewayScript = `
- * export default {
- *   async fetch(request, env) {
- *     const sum = await env.MATH.add(1, 2)
- *     return Response.json({ sum })
- *   }
- * }
- * `
- *
- * const mathScript = `
- * import { WorkerEntrypoint } from 'cloudflare:workers'
- * export class MathService extends WorkerEntrypoint {
- *   add(a, b) { return a + b }
- * }
- * `
- *
- * const ctx = await createMultiWorkerContext({
- *   workers: [
- *     { name: 'gateway', script: gatewayScript, serviceBindings: { MATH: { name: 'math', entrypoint: 'MathService' } } },
- *     { name: 'math', script: mathScript }
- *   ],
- *   primary: 'gateway'
- * })
- *
- * // Direct RPC test
- * const sum = await ctx.env.MATH.add(1, 2)
- * expect(sum).toBe(3)
- *
- * // HTTP test (gateway using RPC internally)
- * const response = await ctx.fetch('http://localhost/')
- * const data = await response.json()
- * expect(data.sum).toBe(3)
- *
- * await ctx.dispose()
- * ```
- */
-export declare function createMultiWorkerContext<TEnv = Record<string, unknown>>(options: MultiWorkerContextOptions): Promise<MultiWorkerContext<TEnv>>;
-/**
- * @deprecated Use `worker.ts` files with exported functions instead. devflare automatically
- * transforms these into WorkerEntrypoint classes during bundling.
- *
- * Helper to create a WorkerEntrypoint class script from exported functions.
- * Use this when you want to test against the transformed version of a worker.ts file.
- *
- * @example
- * ```ts
- * const script = createEntrypointScript('MathService', {
- *   add: '(a, b) { return a + b }',
- *   multiply: '(a, b) { return a * b }'
- * })
- * // Result: import { WorkerEntrypoint } from 'cloudflare:workers'
- * //         export class MathService extends WorkerEntrypoint {
- * //           add(a, b) { return a + b }
- * //           multiply(a, b) { return a * b }
- * //         }
- * ```
- */
-export declare function createEntrypointScript(className: string, methods: Record<string, string>): string;
-//# sourceMappingURL=multi-worker-context.d.ts.map

package/dist/test/multi-worker-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multi-worker-context.d.ts","sourceRoot":"","sources":["../../src/test/multi-worker-context.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAM1C;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAA;IAEZ,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAA;IAEd,yDAAyD;IACzD,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB,iDAAiD;IACjD,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC/E;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACzC,qCAAqC;IACrC,OAAO,EAAE,YAAY,EAAE,CAAA;IAEvB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACjE,yBAAyB;IACzB,EAAE,EAAE,SAAS,CAAA;IAEb,mDAAmD;IACnD,GAAG,EAAE,IAAI,CAAA;IAET,qDAAqD;IACrD,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAE/E,uCAAuC;IACvC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC5B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,wBAAwB,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5E,OAAO,EAAE,yBAAyB,GAChC,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAiEnC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAWR"}

package/dist/types-5nyrz1sz.js

@@ -1,454 +0,0 @@
-import {
-  discoverEntrypointsAsync,
-  resolvePackageSpecifier
-} from "./index-tk6ej9dj.js";
-import {
-  DEFAULT_DO_PATTERN,
-  DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles
-} from "./index-rbht7m9r.js";
-import {
-  findDurableObjectClasses
-} from "./index-gz1gndna.js";
-import"./index-07q6yxyc.js";
-import"./index-67qcae0f.js";
-import {
-  loadConfig,
-  normalizeDOBinding
-} from "./index-hcex3rgh.js";
-import {
-  getDependencies
-} from "./index-1xpj0m4r.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/commands/types.ts
-import { resolve, relative, dirname } from "pathe";
-async function parseConfigForRefs(configPath) {
-  const fs = await import("node:fs/promises");
-  const refs = [];
-  const serviceBindings = [];
-  const doBindings = [];
-  try {
-    const code = await fs.readFile(configPath, "utf-8");
-    const refPattern = /const\s+(\w+)\s*=\s*ref\s*\(\s*(?:'[^']*'\s*,\s*)?(?:\(\s*\)\s*=>\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-    while ((match = refPattern.exec(code)) !== null) {
-      refs.push({
-        varName: match[1],
-        importPath: match[2]
-      });
-    }
-    const servicePattern = /(\w+)\s*:\s*(\w+)\.worker(?:\s*\(\s*['"](\w+)['"]\s*\))?/g;
-    while ((match = servicePattern.exec(code)) !== null) {
-      serviceBindings.push({
-        bindingName: match[1],
-        varName: match[2],
-        entrypoint: match[3]
-      });
-    }
-    const doPattern = /(\w+)\s*:\s*(\w+)\.([A-Z][A-Z0-9_]*)\s*[,\n\r}]/g;
-    while ((match = doPattern.exec(code)) !== null) {
-      if (match[3] === "worker")
-        continue;
-      doBindings.push({
-        bindingName: match[1],
-        varName: match[2],
-        doName: match[3]
-      });
-    }
-  } catch {}
-  return { refs, serviceBindings, doBindings };
-}
-async function findInterfaceTypes(searchDirs) {
-  const fs = await import("node:fs/promises");
-  const interfaces = new Map;
-  for (const dir of searchDirs) {
-    const typeFiles = await findFiles("**/*.types.ts", { cwd: dir });
-    const srcFiles = await findFiles("src/**/*.ts", { cwd: dir });
-    const allFiles = [...new Set([...typeFiles, ...srcFiles])];
-    for (const filePath of allFiles) {
-      try {
-        const code = await fs.readFile(filePath, "utf-8");
-        const interfacePattern = /export\s+interface\s+(\w+(?:Interface|Rpc))\s*\{/g;
-        let match;
-        while ((match = interfacePattern.exec(code)) !== null) {
-          const interfaceName = match[1];
-          let baseName;
-          if (interfaceName.endsWith("Interface")) {
-            baseName = interfaceName.slice(0, -9);
-          } else if (interfaceName.endsWith("Rpc")) {
-            baseName = interfaceName.slice(0, -3);
-          } else {
-            continue;
-          }
-          if (!interfaces.has(baseName)) {
-            interfaces.set(baseName, { filePath, interfaceName });
-          }
-          if (!interfaces.has("__default__")) {
-            if (baseName === "Worker" || baseName === "Default" || baseName === "MathService") {
-              interfaces.set("__default__", { filePath, interfaceName });
-            }
-          }
-        }
-      } catch {}
-    }
-  }
-  return interfaces;
-}
-async function resolveReferencedConfigs(configPath, cwd) {
-  const fs = await import("node:fs/promises");
-  const referenced = [];
-  const { refs, serviceBindings, doBindings } = await parseConfigForRefs(configPath);
-  if (refs.length === 0) {
-    return referenced;
-  }
-  const configDir = dirname(configPath);
-  for (const ref of refs) {
-    let refConfigPath = resolvePackageSpecifier(ref.importPath, configDir);
-    if (!refConfigPath.endsWith(".ts") && !refConfigPath.endsWith(".js")) {
-      refConfigPath += ".ts";
-    }
-    try {
-      await fs.access(refConfigPath);
-      const refDir = dirname(refConfigPath);
-      const entrypoints = await discoverEntrypointsAsync(refDir, DEFAULT_ENTRYPOINT_PATTERN);
-      const refDOs = await discoverDurableObjects(refDir, DEFAULT_DO_PATTERN);
-      const interfaceMap = await findInterfaceTypes([configDir, refDir]);
-      const bindings = serviceBindings.filter((sb) => sb.varName === ref.varName).map((sb) => {
-        const info = {
-          bindingName: sb.bindingName,
-          entrypoint: sb.entrypoint
-        };
-        const lookupKey = sb.entrypoint || "__default__";
-        const interfaceInfo = interfaceMap.get(lookupKey) || sb.entrypoint && interfaceMap.get(sb.entrypoint);
-        if (interfaceInfo) {
-          info.interfaceImport = generateImportPath(cwd, interfaceInfo.filePath);
-          info.interfaceType = interfaceInfo.interfaceName;
-        }
-        return info;
-      });
-      const crossWorkerDOs = doBindings.filter((doBinding) => doBinding.varName === ref.varName).map((doBinding) => {
-        const matchingDO = refDOs.find((do_) => do_.bindingName === doBinding.doName);
-        if (matchingDO) {
-          return {
-            bindingName: doBinding.bindingName,
-            doName: doBinding.doName,
-            className: matchingDO.className,
-            filePath: matchingDO.filePath
-          };
-        }
-        return null;
-      }).filter((item) => item !== null);
-      referenced.push({
-        varName: ref.varName,
-        importPath: ref.importPath,
-        refDir,
-        entrypoints,
-        serviceBindings: bindings,
-        durableObjects: crossWorkerDOs
-      });
-    } catch {}
-  }
-  return referenced;
-}
-async function discoverDurableObjects(cwd, 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 = findDurableObjectClasses(code);
-      for (const className of classNames) {
-        const bindingName = className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
-        discovered.push({
-          className,
-          filePath,
-          bindingName
-        });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-function generateImportPath(cwd, filePath) {
-  let relativePath = relative(cwd, filePath);
-  relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
-  if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) {
-    relativePath = "./" + relativePath;
-  }
-  return relativePath;
-}
-function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, indent) {
-  const lines = [];
-  const imports = [];
-  if (config.bindings) {
-    if (config.bindings.kv) {
-      for (const binding of Object.keys(config.bindings.kv)) {
-        lines.push(`${indent}${binding}: KVNamespace`);
-      }
-    }
-    if (config.bindings.d1) {
-      for (const binding of Object.keys(config.bindings.d1)) {
-        lines.push(`${indent}${binding}: D1Database`);
-      }
-    }
-    if (config.bindings.r2) {
-      for (const binding of Object.keys(config.bindings.r2)) {
-        lines.push(`${indent}${binding}: R2Bucket`);
-      }
-    }
-    if (config.bindings.durableObjects) {
-      for (const [binding, doConfig] of Object.entries(config.bindings.durableObjects)) {
-        const crossWorkerDO = crossWorkerDOMap.get(binding);
-        if (crossWorkerDO) {
-          const importPath = generateImportPath(cwd, crossWorkerDO.filePath);
-          lines.push(`${indent}${binding}: DurableObjectNamespace<Rpc.DurableObjectBranded & import('${importPath}').${crossWorkerDO.className}>`);
-          continue;
-        }
-        const className = doConfig.className;
-        if (className) {
-          const classInfo = doClassMap.get(className);
-          if (classInfo) {
-            lines.push(`${indent}${binding}: DurableObjectNamespace<Rpc.DurableObjectBranded & import('${classInfo.importPath}').${classInfo.className}>`);
-            continue;
-          }
-        }
-        lines.push(`${indent}${binding}: DurableObjectNamespace`);
-      }
-    }
-    if (config.bindings.queues?.producers) {
-      for (const binding of Object.keys(config.bindings.queues.producers)) {
-        lines.push(`${indent}${binding}: Queue`);
-      }
-    }
-    if (config.bindings.services) {
-      for (const binding of Object.keys(config.bindings.services)) {
-        const serviceInfo = serviceBindingMap.get(binding);
-        if (serviceInfo?.interfaceType && serviceInfo.interfaceImport) {
-          imports.push(`import type { ${serviceInfo.interfaceType} } from '${serviceInfo.interfaceImport}'`);
-          lines.push(`${indent}${binding}: ${serviceInfo.interfaceType}`);
-        } else {
-          lines.push(`${indent}${binding}: Fetcher`);
-        }
-      }
-    }
-    if (config.bindings.ai) {
-      lines.push(`${indent}${config.bindings.ai.binding}: Ai`);
-    }
-    if (config.bindings.vectorize) {
-      for (const binding of Object.keys(config.bindings.vectorize)) {
-        lines.push(`${indent}${binding}: VectorizeIndex`);
-      }
-    }
-    if (config.bindings.hyperdrive) {
-      for (const binding of Object.keys(config.bindings.hyperdrive)) {
-        lines.push(`${indent}${binding}: Hyperdrive`);
-      }
-    }
-    if (config.bindings.browser) {
-      lines.push(`${indent}${config.bindings.browser.binding}: Fetcher`);
-    }
-    if (config.bindings.analyticsEngine) {
-      for (const binding of Object.keys(config.bindings.analyticsEngine)) {
-        lines.push(`${indent}${binding}: AnalyticsEngineDataset`);
-      }
-    }
-  }
-  if (config.vars) {
-    for (const key of Object.keys(config.vars)) {
-      lines.push(`${indent}${key}: string`);
-    }
-  }
-  if (config.secrets) {
-    for (const secret of Object.keys(config.secrets)) {
-      lines.push(`${indent}${secret}: string`);
-    }
-  }
-  return { lines, imports };
-}
-function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd) {
-  const doClassMap = new Map;
-  for (const do_ of discoveredDOs) {
-    doClassMap.set(do_.className, {
-      importPath: generateImportPath(cwd, do_.filePath),
-      className: do_.className
-    });
-  }
-  const crossWorkerDOMap = new Map;
-  for (const ref of referencedConfigs) {
-    for (const doInfo of ref.durableObjects) {
-      crossWorkerDOMap.set(doInfo.bindingName, doInfo);
-    }
-  }
-  const serviceBindingMap = new Map;
-  for (const ref of referencedConfigs) {
-    for (const sb of ref.serviceBindings) {
-      serviceBindingMap.set(sb.bindingName, sb);
-    }
-  }
-  const usedTypes = new Set;
-  if (config.bindings) {
-    if (config.bindings.kv && Object.keys(config.bindings.kv).length > 0)
-      usedTypes.add("KVNamespace");
-    if (config.bindings.d1 && Object.keys(config.bindings.d1).length > 0)
-      usedTypes.add("D1Database");
-    if (config.bindings.r2 && Object.keys(config.bindings.r2).length > 0)
-      usedTypes.add("R2Bucket");
-    if (config.bindings.durableObjects && Object.keys(config.bindings.durableObjects).length > 0)
-      usedTypes.add("DurableObjectNamespace");
-    if (config.bindings.queues?.producers && Object.keys(config.bindings.queues.producers).length > 0)
-      usedTypes.add("Queue");
-    if (config.bindings.services) {
-      const hasUntypedServices = Object.keys(config.bindings.services).some((name) => !serviceBindingMap.get(name)?.interfaceType);
-      if (hasUntypedServices)
-        usedTypes.add("Fetcher");
-    }
-    if (config.bindings.ai)
-      usedTypes.add("Ai");
-    if (config.bindings.vectorize && Object.keys(config.bindings.vectorize).length > 0)
-      usedTypes.add("VectorizeIndex");
-    if (config.bindings.hyperdrive && Object.keys(config.bindings.hyperdrive).length > 0)
-      usedTypes.add("Hyperdrive");
-    if (config.bindings.browser)
-      usedTypes.add("Fetcher");
-    if (config.bindings.analyticsEngine && Object.keys(config.bindings.analyticsEngine).length > 0)
-      usedTypes.add("AnalyticsEngineDataset");
-  }
-  const lines = [
-    "// Generated by devflare - DO NOT EDIT",
-    "// Run `devflare types` to regenerate",
-    ""
-  ];
-  const hasLocalDOsWithClasses = config.bindings?.durableObjects && Object.values(config.bindings.durableObjects).some((doConfig) => doConfig.className && doClassMap.has(doConfig.className));
-  const hasCrossWorkerDOs = crossWorkerDOMap.size > 0;
-  const hasDOsWithClasses = hasLocalDOsWithClasses || hasCrossWorkerDOs;
-  if (usedTypes.size > 0) {
-    const sortedTypes = [...usedTypes].sort();
-    if (hasDOsWithClasses) {
-      lines.push(`import type { ${sortedTypes.join(", ")}, Rpc } from '@cloudflare/workers-types'`);
-    } else {
-      lines.push(`import type { ${sortedTypes.join(", ")} } from '@cloudflare/workers-types'`);
-    }
-    lines.push("");
-  }
-  const { lines: bindingMembers, imports: serviceImports } = generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, "\t\t");
-  const uniqueImports = [...new Set(serviceImports)];
-  if (uniqueImports.length > 0) {
-    lines.push(...uniqueImports);
-    lines.push("");
-  }
-  lines.push("declare global {");
-  lines.push("\tinterface DevflareEnv {");
-  lines.push(...bindingMembers);
-  lines.push("\t}");
-  lines.push("}");
-  lines.push("");
-  if (discoveredEntrypoints.length > 0) {
-    const entrypointNames = discoveredEntrypoints.map((ep) => `'${ep.className}'`).join(" | ");
-    lines.push("/**");
-    lines.push(" * Named entrypoints discovered from ep.*.ts files.");
-    lines.push(" * Use with defineConfig<Entrypoints>() for type-safe cross-worker references.");
-    lines.push(" */");
-    lines.push(`export type Entrypoints = ${entrypointNames}`);
-  } else {
-    lines.push("/**");
-    lines.push(" * Named entrypoints (none discovered - add ep.*.ts files to enable).");
-    lines.push(" * Use with defineConfig<Entrypoints>() for type-safe cross-worker references.");
-    lines.push(" */");
-    lines.push("export type Entrypoints = string");
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-async function runTypesCommand(parsed, logger, options) {
-  const cwd = options.cwd || process.cwd();
-  const configPath = parsed.options.config;
-  const outputPath = parsed.options.output || "env.d.ts";
-  logger.info("Generating TypeScript types...");
-  try {
-    const actualConfigPath = configPath ? resolve(cwd, configPath) : resolve(cwd, "devflare.config.ts");
-    const config = await loadConfig({ cwd, configFile: configPath });
-    const doPattern = typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN;
-    let discoveredDOs = [];
-    if (config.files?.durableObjects !== false) {
-      discoveredDOs = await discoverDurableObjects(cwd, doPattern);
-      if (discoveredDOs.length > 0) {
-        logger.info(`Discovered ${discoveredDOs.length} Durable Object class(es):`);
-        for (const do_ of discoveredDOs) {
-          logger.info(`  • ${do_.className} → ${do_.bindingName}`);
-        }
-      }
-    }
-    if (config.bindings?.durableObjects) {
-      for (const [bindingName, doConfig] of Object.entries(config.bindings.durableObjects)) {
-        const normalized = normalizeDOBinding(doConfig);
-        const className = normalized.className;
-        if (!className)
-          continue;
-        const existing = discoveredDOs.find((d) => d.className === className);
-        if (existing)
-          continue;
-        if (normalized.scriptName && (normalized.scriptName.endsWith(".ts") || normalized.scriptName.endsWith(".js"))) {
-          const filePath = resolve(cwd, "src", normalized.scriptName);
-          discoveredDOs.push({
-            className,
-            filePath,
-            bindingName
-          });
-        }
-      }
-    }
-    const epPattern = typeof config.files?.entrypoints === "string" ? config.files.entrypoints : DEFAULT_ENTRYPOINT_PATTERN;
-    let discoveredEntrypoints = [];
-    if (config.files?.entrypoints !== false) {
-      discoveredEntrypoints = await discoverEntrypointsAsync(cwd, epPattern);
-      if (discoveredEntrypoints.length > 0) {
-        logger.info(`Discovered ${discoveredEntrypoints.length} entrypoint class(es):`);
-        for (const ep of discoveredEntrypoints) {
-          logger.info(`  • ${ep.className}`);
-        }
-      }
-    }
-    const referencedConfigs = await resolveReferencedConfigs(actualConfigPath, cwd);
-    if (referencedConfigs.length > 0) {
-      logger.info(`Found ${referencedConfigs.length} referenced worker(s):`);
-      for (const ref of referencedConfigs) {
-        const typedBindings = ref.serviceBindings.filter((sb) => sb.interfaceType);
-        if (typedBindings.length > 0) {
-          logger.info(`  • ${ref.varName}: ${typedBindings.map((sb) => `${sb.bindingName} → ${sb.interfaceType}`).join(", ")}`);
-        }
-      }
-    }
-    const normalizedConfig = {
-      ...config,
-      bindings: config.bindings ? {
-        ...config.bindings,
-        durableObjects: config.bindings.durableObjects ? Object.fromEntries(Object.entries(config.bindings.durableObjects).map(([name, doConfig]) => {
-          const normalized = normalizeDOBinding(doConfig);
-          return [name, { className: normalized.className, scriptName: normalized.scriptName }];
-        })) : undefined
-      } : undefined
-    };
-    const types = generateBindingTypes(normalizedConfig, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd);
-    const { fs } = await getDependencies();
-    const fullPath = resolve(cwd, outputPath);
-    await fs.writeFile(fullPath, types, "utf-8");
-    logger.success(`Generated types: ${outputPath}`);
-    return { exitCode: 0 };
-  } catch (error) {
-    if (error instanceof Error) {
-      logger.error("Type generation failed:", error.message);
-      if (parsed.options.debug) {
-        logger.error(error.stack);
-      }
-    }
-    return { exitCode: 1 };
-  }
-}
-export {
-  runTypesCommand
-};

package/dist/worker-entrypoint-m9th0rg0.js

@@ -1,13 +0,0 @@
-import {
-  findExportedFunctions,
-  generateRpcInterface,
-  shouldTransformWorker,
-  transformWorkerEntrypoint
-} from "./index-z14anrqp.js";
-import"./index-37x76zdn.js";
-export {
-  transformWorkerEntrypoint,
-  shouldTransformWorker,
-  generateRpcInterface,
-  findExportedFunctions
-};