devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/types-6vc02evc.js

@@ -0,0 +1,705 @@
+import {
+  resolveConfigCandidatePath
+} from "./index-vez803pp.js";
+import {
+  getDependencies
+} from "./index-z9gy8w6b.js";
+import {
+  bold,
+  createCliTheme,
+  dim
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import {
+  discoverEntrypointsAsync,
+  resolvePackageSpecifier
+} from "./index-3edvz3hs.js";
+import {
+  DEFAULT_DO_PATTERN,
+  DEFAULT_ENTRYPOINT_PATTERN,
+  findFiles
+} from "./index-qwgr4q7s.js";
+import {
+  findDurableObjectClasses
+} from "./index-vhqww6tt.js";
+import"./index-hjjfxv02.js";
+import {
+  loadConfig,
+  normalizeDOBinding
+} from "./index-dfcp9hsd.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import"./index-c8p4njqy.js";
+import"./index-q8f4kawk.js";
+import"./index-37x76zdn.js";
+
+// src/cli/commands/types.ts
+import { resolve } from "pathe";
+
+// src/cli/commands/type-generation/discovery.ts
+import { readFile } from "node:fs/promises";
+import { dirname, relative } from "pathe";
+var DEFAULT_INTERFACE_LOOKUP_KEYS = new Set(["Worker", "Default", "MathService"]);
+var interfaceTypeCache = new Map;
+async function readFileIfAvailable(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getInterfaceSearchKey(searchDirs) {
+  return [...new Set(searchDirs)].sort((left, right) => left.localeCompare(right)).join("\x00");
+}
+function getPatternMatches(pattern, code) {
+  const matches = [];
+  pattern.lastIndex = 0;
+  let nextMatch = pattern.exec(code);
+  while (nextMatch !== null) {
+    matches.push(nextMatch);
+    nextMatch = pattern.exec(code);
+  }
+  return matches;
+}
+function getInterfaceBaseName(interfaceName) {
+  if (interfaceName.endsWith("Interface")) {
+    return interfaceName.slice(0, -9);
+  }
+  if (interfaceName.endsWith("Rpc")) {
+    return interfaceName.slice(0, -3);
+  }
+  return null;
+}
+function registerInterfaceType(interfaces, baseName, interfaceInfo) {
+  if (!interfaces.has(baseName)) {
+    interfaces.set(baseName, interfaceInfo);
+  }
+  if (!interfaces.has("__default__") && DEFAULT_INTERFACE_LOOKUP_KEYS.has(baseName)) {
+    interfaces.set("__default__", interfaceInfo);
+  }
+}
+async function collectInterfaceTypesFromFile(interfaces, filePath) {
+  const code = await readFileIfAvailable(filePath);
+  if (!code) {
+    return;
+  }
+  const interfacePattern = /export\s+interface\s+(\w+(?:Interface|Rpc))\s*\{/g;
+  for (const match of getPatternMatches(interfacePattern, code)) {
+    const interfaceName = match[1];
+    const baseName = getInterfaceBaseName(interfaceName);
+    if (!baseName) {
+      continue;
+    }
+    registerInterfaceType(interfaces, baseName, {
+      filePath,
+      interfaceName
+    });
+  }
+}
+async function parseConfigForRefs(configPath) {
+  const refs = [];
+  const serviceBindings = [];
+  const doBindings = [];
+  const code = await readFileIfAvailable(configPath);
+  if (!code) {
+    return {
+      refs,
+      serviceBindings,
+      doBindings
+    };
+  }
+  const refPattern = /const\s+(\w+)\s*=\s*ref\s*\(\s*(?:'[^']*'\s*,\s*)?(?:\(\s*\)\s*=>\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of getPatternMatches(refPattern, code)) {
+    refs.push({
+      varName: match[1],
+      importPath: match[2]
+    });
+  }
+  const servicePattern = /(\w+)\s*:\s*(\w+)\.worker(?:\s*\(\s*['"](\w+)['"]\s*\))?/g;
+  for (const match of getPatternMatches(servicePattern, code)) {
+    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;
+  for (const match of getPatternMatches(doPattern, code)) {
+    if (match[3] === "worker") {
+      continue;
+    }
+    doBindings.push({
+      bindingName: match[1],
+      varName: match[2],
+      doName: match[3]
+    });
+  }
+  return {
+    refs,
+    serviceBindings,
+    doBindings
+  };
+}
+async function findInterfaceTypes(searchDirs) {
+  const interfaces = new Map;
+  for (const dir of [...new Set(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) {
+      await collectInterfaceTypesFromFile(interfaces, filePath);
+    }
+  }
+  return interfaces;
+}
+async function getCachedInterfaceTypes(searchDirs) {
+  const cacheKey = getInterfaceSearchKey(searchDirs);
+  const cached = interfaceTypeCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const pending = findInterfaceTypes(searchDirs);
+  interfaceTypeCache.set(cacheKey, pending);
+  try {
+    return await pending;
+  } catch (error) {
+    interfaceTypeCache.delete(cacheKey);
+    throw error;
+  }
+}
+async function discoverDurableObjects(cwd, pattern = DEFAULT_DO_PATTERN) {
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    const code = await readFileIfAvailable(filePath);
+    if (!code) {
+      continue;
+    }
+    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
+      });
+    }
+  }
+  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;
+}
+async function resolveReferencedConfigs(configPath, cwd) {
+  const referenced = [];
+  const { refs, serviceBindings, doBindings } = await parseConfigForRefs(configPath);
+  if (refs.length === 0) {
+    return referenced;
+  }
+  const configDir = dirname(configPath);
+  const referencedConfigDetailsByPath = new Map;
+  for (const ref of refs) {
+    const refImportPath = resolvePackageSpecifier(ref.importPath, configDir);
+    const refConfigPath = await resolveConfigCandidatePath(refImportPath);
+    if (!refConfigPath) {
+      continue;
+    }
+    try {
+      let referencedConfigDetails = referencedConfigDetailsByPath.get(refConfigPath);
+      if (!referencedConfigDetails) {
+        referencedConfigDetails = (async () => {
+          const refDir2 = dirname(refConfigPath);
+          return {
+            refDir: refDir2,
+            entrypoints: await discoverEntrypointsAsync(refDir2, DEFAULT_ENTRYPOINT_PATTERN),
+            refDOs: await discoverDurableObjects(refDir2, DEFAULT_DO_PATTERN),
+            interfaceMap: await getCachedInterfaceTypes([configDir, refDir2])
+          };
+        })();
+        referencedConfigDetailsByPath.set(refConfigPath, referencedConfigDetails);
+      }
+      const {
+        refDir,
+        entrypoints,
+        refDOs,
+        interfaceMap
+      } = await referencedConfigDetails;
+      const bindings = serviceBindings.filter((serviceBinding) => serviceBinding.varName === ref.varName).map((serviceBinding) => {
+        const info = {
+          bindingName: serviceBinding.bindingName,
+          entrypoint: serviceBinding.entrypoint
+        };
+        const lookupKey = serviceBinding.entrypoint || "__default__";
+        const interfaceInfo = interfaceMap.get(lookupKey) || (serviceBinding.entrypoint ? interfaceMap.get(serviceBinding.entrypoint) : undefined);
+        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((doInfo) => doInfo.bindingName === doBinding.doName);
+        if (!matchingDO) {
+          return null;
+        }
+        const crossWorkerDO = {
+          bindingName: doBinding.bindingName,
+          doName: doBinding.doName,
+          className: matchingDO.className,
+          filePath: matchingDO.filePath
+        };
+        return crossWorkerDO;
+      }).filter((item) => item !== null);
+      referenced.push({
+        varName: ref.varName,
+        importPath: ref.importPath,
+        refDir,
+        entrypoints,
+        serviceBindings: bindings,
+        durableObjects: crossWorkerDOs
+      });
+    } catch {}
+  }
+  return referenced;
+}
+
+// src/cli/commands/type-generation/generator.ts
+function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, indent, options = {}) {
+  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.rateLimits) {
+      for (const binding of Object.keys(config.bindings.rateLimits)) {
+        lines.push(`${indent}${binding}: RateLimit`);
+      }
+    }
+    if (config.bindings.versionMetadata?.binding) {
+      lines.push(`${indent}${config.bindings.versionMetadata.binding}: WorkerVersionMetadata`);
+    }
+    if (config.bindings.workerLoaders) {
+      for (const binding of Object.keys(config.bindings.workerLoaders)) {
+        lines.push(`${indent}${binding}: WorkerLoader`);
+      }
+    }
+    if (config.bindings.mtlsCertificates) {
+      for (const binding of Object.keys(config.bindings.mtlsCertificates)) {
+        lines.push(`${indent}${binding}: Fetcher`);
+      }
+    }
+    if (config.bindings.dispatchNamespaces) {
+      for (const binding of Object.keys(config.bindings.dispatchNamespaces)) {
+        lines.push(`${indent}${binding}: DispatchNamespace`);
+      }
+    }
+    if (config.bindings.workflows) {
+      for (const binding of Object.keys(config.bindings.workflows)) {
+        lines.push(`${indent}${binding}: Workflow`);
+      }
+    }
+    if (config.bindings.pipelines) {
+      imports.push("import type { Pipeline } from 'cloudflare:pipelines'");
+      for (const binding of Object.keys(config.bindings.pipelines)) {
+        lines.push(`${indent}${binding}: Pipeline`);
+      }
+    }
+    if (config.bindings.images) {
+      for (const binding of Object.keys(config.bindings.images)) {
+        lines.push(`${indent}${binding}: ImagesBinding`);
+      }
+    }
+    if (config.bindings.media) {
+      for (const binding of Object.keys(config.bindings.media)) {
+        lines.push(`${indent}${binding}: MediaBinding`);
+      }
+    }
+    if (config.bindings.artifacts) {
+      for (const binding of Object.keys(config.bindings.artifacts)) {
+        lines.push(`${indent}${binding}: Artifacts`);
+      }
+    }
+    if (config.bindings.secretsStore) {
+      for (const binding of Object.keys(config.bindings.secretsStore)) {
+        lines.push(`${indent}${binding}: SecretsStoreSecret`);
+      }
+    }
+    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}`);
+          continue;
+        }
+        lines.push(`${indent}${binding}: Fetcher`);
+      }
+    }
+    if (config.bindings.ai) {
+      lines.push(`${indent}${config.bindings.ai.binding}: Ai`);
+    }
+    if (config.bindings.aiSearchNamespaces) {
+      for (const binding of Object.keys(config.bindings.aiSearchNamespaces)) {
+        lines.push(`${indent}${binding}: AiSearchNamespace`);
+      }
+    }
+    if (config.bindings.aiSearch) {
+      for (const binding of Object.keys(config.bindings.aiSearch)) {
+        lines.push(`${indent}${binding}: AiSearchInstance`);
+      }
+    }
+    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) {
+      for (const binding of Object.keys(config.bindings.browser)) {
+        lines.push(`${indent}${binding}: Fetcher`);
+      }
+    }
+    if (config.bindings.analyticsEngine) {
+      for (const binding of Object.keys(config.bindings.analyticsEngine)) {
+        lines.push(`${indent}${binding}: AnalyticsEngineDataset`);
+      }
+    }
+    if (config.bindings.sendEmail) {
+      for (const binding of Object.keys(config.bindings.sendEmail)) {
+        lines.push(`${indent}${binding}: SendEmail`);
+      }
+    }
+  }
+  if (options.includeVarsAsMembers !== false && 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 normalizeModuleDeclarationGlob(glob) {
+  return glob.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\*\*\//, "");
+}
+function generateModuleRuleDeclarations(config) {
+  const declarations = [];
+  const seen = new Set;
+  const typeByRuleType = {
+    Text: "string",
+    Data: "ArrayBuffer",
+    CompiledWasm: "WebAssembly.Module"
+  };
+  for (const rule of config.rules ?? []) {
+    const valueType = rule.type ? typeByRuleType[rule.type] : undefined;
+    if (!valueType) {
+      continue;
+    }
+    for (const glob of rule.globs ?? []) {
+      const specifier = normalizeModuleDeclarationGlob(glob);
+      const key = `${specifier}:${valueType}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      declarations.push(`declare module '${specifier}' {`);
+      declarations.push(`	const value: ${valueType}`);
+      declarations.push("\texport default value");
+      declarations.push("}");
+      declarations.push("");
+    }
+  }
+  return declarations;
+}
+function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd, options = {}) {
+  const doClassMap = new Map;
+  for (const doInfo of discoveredDOs) {
+    doClassMap.set(doInfo.className, {
+      importPath: generateImportPath(cwd, doInfo.filePath),
+      className: doInfo.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 serviceBinding of ref.serviceBindings) {
+      serviceBindingMap.set(serviceBinding.bindingName, serviceBinding);
+    }
+  }
+  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.rateLimits && Object.keys(config.bindings.rateLimits).length > 0)
+      usedTypes.add("RateLimit");
+    if (config.bindings.versionMetadata?.binding)
+      usedTypes.add("WorkerVersionMetadata");
+    if (config.bindings.workerLoaders && Object.keys(config.bindings.workerLoaders).length > 0)
+      usedTypes.add("WorkerLoader");
+    if (config.bindings.mtlsCertificates && Object.keys(config.bindings.mtlsCertificates).length > 0)
+      usedTypes.add("Fetcher");
+    if (config.bindings.dispatchNamespaces && Object.keys(config.bindings.dispatchNamespaces).length > 0)
+      usedTypes.add("DispatchNamespace");
+    if (config.bindings.workflows && Object.keys(config.bindings.workflows).length > 0)
+      usedTypes.add("Workflow");
+    if (config.bindings.images && Object.keys(config.bindings.images).length > 0)
+      usedTypes.add("ImagesBinding");
+    if (config.bindings.media && Object.keys(config.bindings.media).length > 0)
+      usedTypes.add("MediaBinding");
+    if (config.bindings.artifacts && Object.keys(config.bindings.artifacts).length > 0)
+      usedTypes.add("Artifacts");
+    if (config.bindings.secretsStore && Object.keys(config.bindings.secretsStore).length > 0)
+      usedTypes.add("SecretsStoreSecret");
+    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.aiSearchNamespaces && Object.keys(config.bindings.aiSearchNamespaces).length > 0) {
+      usedTypes.add("AiSearchNamespace");
+    }
+    if (config.bindings.aiSearch && Object.keys(config.bindings.aiSearch).length > 0) {
+      usedTypes.add("AiSearchInstance");
+    }
+    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 && Object.keys(config.bindings.browser).length > 0)
+      usedTypes.add("Fetcher");
+    if (config.bindings.analyticsEngine && Object.keys(config.bindings.analyticsEngine).length > 0)
+      usedTypes.add("AnalyticsEngineDataset");
+    if (config.bindings.sendEmail && Object.keys(config.bindings.sendEmail).length > 0)
+      usedTypes.add("SendEmail");
+  }
+  const lines = [
+    "// Generated by devflare - DO NOT EDIT",
+    "// Run `devflare types` to regenerate",
+    ""
+  ];
+  const hasConfigVars = Boolean(config.vars && Object.keys(config.vars).length > 0);
+  const hasLocalDOsWithClasses = Boolean(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("");
+  }
+  if (hasConfigVars) {
+    const configImportPath = options.configImportPath ?? "./devflare.config";
+    lines.push("import type { InferConfigVars } from 'devflare/config'");
+    lines.push(`type __DevflareConfigVars = InferConfigVars<Awaited<typeof import('${configImportPath}').default>>`);
+    lines.push("");
+  }
+  const { lines: bindingMembers, imports: serviceImports } = generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, "\t\t", { includeVarsAsMembers: !hasConfigVars });
+  const uniqueImports = [...new Set(serviceImports)];
+  if (uniqueImports.length > 0) {
+    lines.push(...uniqueImports);
+    lines.push("");
+  }
+  lines.push("declare global {");
+  if (hasConfigVars) {
+    lines.push("\tinterface DevflareVars extends __DevflareConfigVars {}");
+    lines.push("\tinterface DevflareEnv extends __DevflareConfigVars {");
+  } else {
+    lines.push("\tinterface DevflareEnv {");
+  }
+  lines.push(...bindingMembers);
+  lines.push("\t}");
+  lines.push("}");
+  lines.push("");
+  lines.push(...generateModuleRuleDeclarations(config));
+  if (discoveredEntrypoints.length > 0) {
+    const entrypointNames = discoveredEntrypoints.map((entrypoint) => `'${entrypoint.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(`
+`);
+}
+
+// src/cli/commands/types.ts
+function logTypesLine(logger, message = "") {
+  if (typeof logger.log === "function") {
+    logger.log(message);
+    return;
+  }
+  if (typeof logger.info === "function") {
+    logger.info(message);
+  }
+}
+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";
+  const theme = createCliTheme(parsed.options);
+  logTypesLine(logger);
+  logTypesLine(logger, `${bold("types", theme)} ${dim("Generating TypeScript bindings", theme)}`);
+  try {
+    const config = await loadConfig({ cwd, configFile: configPath });
+    const requestedConfigPath = configPath ? resolve(cwd, configPath) : cwd;
+    const actualConfigPath = await resolveConfigCandidatePath(requestedConfigPath);
+    if (!actualConfigPath) {
+      throw new Error("Could not resolve the loaded devflare config file path");
+    }
+    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) {
+        logTypesLine(logger, `Discovered ${discoveredDOs.length} Durable Object class(es):`);
+        for (const doInfo of discoveredDOs) {
+          logTypesLine(logger, `  • ${doInfo.className} → ${doInfo.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((doInfo) => doInfo.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 entrypointPattern = typeof config.files?.entrypoints === "string" ? config.files.entrypoints : DEFAULT_ENTRYPOINT_PATTERN;
+    let discoveredEntrypoints = [];
+    if (config.files?.entrypoints !== false) {
+      discoveredEntrypoints = await discoverEntrypointsAsync(cwd, entrypointPattern);
+      if (discoveredEntrypoints.length > 0) {
+        logTypesLine(logger, `Discovered ${discoveredEntrypoints.length} entrypoint class(es):`);
+        for (const entrypoint of discoveredEntrypoints) {
+          logTypesLine(logger, `  • ${entrypoint.className}`);
+        }
+      }
+    }
+    const referencedConfigs = await resolveReferencedConfigs(actualConfigPath, cwd);
+    if (referencedConfigs.length > 0) {
+      logTypesLine(logger, `Found ${referencedConfigs.length} referenced worker(s):`);
+      for (const ref of referencedConfigs) {
+        const typedBindings = ref.serviceBindings.filter((serviceBinding) => serviceBinding.interfaceType);
+        if (typedBindings.length > 0) {
+          logTypesLine(logger, `  • ${ref.varName}: ${typedBindings.map((serviceBinding) => `${serviceBinding.bindingName} → ${serviceBinding.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, { configImportPath: generateImportPath(cwd, actualConfigPath) });
+    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
+};