devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/types-15yv4cj3.js

@@ -1,701 +0,0 @@
-import {
-  resolveConfigCandidatePath
-} from "./index-a8pnvg3r.js";
-import {
-  getDependencies
-} from "./index-z9gy8w6b.js";
-import {
-  bold,
-  createCliTheme,
-  dim
-} from "./index-maw0jjnn.js";
-import"./index-3t6rypgc.js";
-import {
-  discoverEntrypointsAsync,
-  resolvePackageSpecifier
-} from "./index-3cpzsr47.js";
-import {
-  DEFAULT_DO_PATTERN,
-  DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles
-} from "./index-5dkjffqz.js";
-import"./index-mek9msfv.js";
-import {
-  loadConfig,
-  normalizeDOBinding
-} from "./index-x8s9rwfh.js";
-import"./index-h7r11y4a.js";
-import"./index-04wh9bxx.js";
-import {
-  findDurableObjectClasses
-} from "./index-4mmpccrb.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
-};