devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/_chunks/types-BLGfxIq-.js

@@ -0,0 +1,484 @@
+import { r as loadConfig } from "./loader-BC0skbnH.js";
+import { o as normalizeDOBinding } from "./schema-normalization-CTdiY17P.js";
+import { n as bold, o as dim, r as createCliTheme } from "./ui-BhCdDC2N.js";
+import { n as findDurableObjectClasses } from "./durable-object-DuMPM8re.js";
+import { i as findFiles, n as DEFAULT_ENTRYPOINT_PATTERN, t as DEFAULT_DO_PATTERN } from "./glob-DRw9sbfF.js";
+import { n as discoverEntrypointsAsync, t as resolvePackageSpecifier } from "./resolve-package-DeJUGxoE.js";
+import { t as getDependencies } from "./dependencies-wKqrxKV_.js";
+import { r as resolveConfigCandidatePath } from "./config-path-CYGlwKDs.js";
+import { dirname, relative, resolve } from "pathe";
+import { readFile } from "node:fs/promises";
+//#region src/cli/commands/type-generation/discovery.ts
+const DEFAULT_INTERFACE_LOOKUP_KEYS = new Set([
+	"Worker",
+	"Default",
+	"MathService"
+]);
+const interfaceTypeCache = /* @__PURE__ */ 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("\0");
+}
+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;
+	for (const match of getPatternMatches(/export\s+interface\s+(\w+(?:Interface|Rpc))\s*\{/g, 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
+	};
+	for (const match of getPatternMatches(/const\s+(\w+)\s*=\s*ref\s*\(\s*(?:'[^']*'\s*,\s*)?(?:\(\s*\)\s*=>\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g, code)) refs.push({
+		varName: match[1],
+		importPath: match[2]
+	});
+	for (const match of getPatternMatches(/(\w+)\s*:\s*(\w+)\.worker(?:\s*\(\s*['"](\w+)['"]\s*\))?/g, code)) serviceBindings.push({
+		bindingName: match[1],
+		varName: match[2],
+		entrypoint: match[3]
+	});
+	for (const match of getPatternMatches(/(\w+)\s*:\s*(\w+)\.([A-Z][A-Z0-9_]*)\s*[,\n\r}]/g, 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+	for (const ref of refs) {
+		const refConfigPath = await resolveConfigCandidatePath(resolvePackageSpecifier(ref.importPath, configDir));
+		if (!refConfigPath) continue;
+		try {
+			let referencedConfigDetails = referencedConfigDetailsByPath.get(refConfigPath);
+			if (!referencedConfigDetails) {
+				referencedConfigDetails = (async () => {
+					const refDir = dirname(refConfigPath);
+					return {
+						refDir,
+						entrypoints: await discoverEntrypointsAsync(refDir, DEFAULT_ENTRYPOINT_PATTERN),
+						refDOs: await discoverDurableObjects(refDir, DEFAULT_DO_PATTERN),
+						interfaceMap: await getCachedInterfaceTypes([configDir, refDir])
+					};
+				})();
+				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) : void 0);
+				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;
+				return {
+					bindingName: doBinding.bindingName,
+					doName: doBinding.doName,
+					className: matchingDO.className,
+					filePath: matchingDO.filePath
+				};
+			}).filter((item) => item !== null);
+			referenced.push({
+				varName: ref.varName,
+				importPath: ref.importPath,
+				refDir,
+				entrypoints,
+				serviceBindings: bindings,
+				durableObjects: crossWorkerDOs
+			});
+		} catch {}
+	}
+	return referenced;
+}
+//#endregion
+//#region 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.stream) for (const binding of Object.keys(config.bindings.stream)) lines.push(`${indent}${binding}: StreamBinding`);
+		if (config.bindings.flagship) for (const binding of Object.keys(config.bindings.flagship)) lines.push(`${indent}${binding}: Flagship`);
+		if (config.bindings.vpcServices) for (const binding of Object.keys(config.bindings.vpcServices)) lines.push(`${indent}${binding}: Fetcher`);
+		if (config.bindings.vpcNetworks) for (const binding of Object.keys(config.bindings.vpcNetworks)) lines.push(`${indent}${binding}: Fetcher`);
+		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 = /* @__PURE__ */ new Set();
+	const typeByRuleType = {
+		Text: "string",
+		Data: "ArrayBuffer",
+		CompiledWasm: "WebAssembly.Module"
+	};
+	for (const rule of config.rules ?? []) {
+		const valueType = rule.type ? typeByRuleType[rule.type] : void 0;
+		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(`\tconst value: ${valueType}`);
+			declarations.push("	export default value");
+			declarations.push("}");
+			declarations.push("");
+		}
+	}
+	return declarations;
+}
+function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd, options = {}) {
+	const doClassMap = /* @__PURE__ */ new Map();
+	for (const doInfo of discoveredDOs) doClassMap.set(doInfo.className, {
+		importPath: generateImportPath(cwd, doInfo.filePath),
+		className: doInfo.className
+	});
+	const crossWorkerDOMap = /* @__PURE__ */ new Map();
+	for (const ref of referencedConfigs) for (const doInfo of ref.durableObjects) crossWorkerDOMap.set(doInfo.bindingName, doInfo);
+	const serviceBindingMap = /* @__PURE__ */ new Map();
+	for (const ref of referencedConfigs) for (const serviceBinding of ref.serviceBindings) serviceBindingMap.set(serviceBinding.bindingName, serviceBinding);
+	const usedTypes = /* @__PURE__ */ 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.stream && Object.keys(config.bindings.stream).length > 0) usedTypes.add("StreamBinding");
+		if (config.bindings.flagship && Object.keys(config.bindings.flagship).length > 0) usedTypes.add("Flagship");
+		if (config.bindings.vpcServices && Object.keys(config.bindings.vpcServices).length > 0) usedTypes.add("Fetcher");
+		if (config.bindings.vpcNetworks && Object.keys(config.bindings.vpcNetworks).length > 0) usedTypes.add("Fetcher");
+		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) {
+			if (Object.keys(config.bindings.services).some((name) => !serviceBindingMap.get(name)?.interfaceType)) 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, "		", { includeVarsAsMembers: !hasConfigVars });
+	const uniqueImports = [...new Set(serviceImports)];
+	if (uniqueImports.length > 0) {
+		lines.push(...uniqueImports);
+		lines.push("");
+	}
+	lines.push("declare global {");
+	if (hasConfigVars) {
+		lines.push("	interface DevflareVars extends __DevflareConfigVars {}");
+		lines.push("	interface DevflareEnv extends __DevflareConfigVars {");
+	} else lines.push("	interface DevflareEnv {");
+	lines.push(...bindingMembers);
+	lines.push("	}");
+	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("\n");
+}
+//#endregion
+//#region 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 actualConfigPath = await resolveConfigCandidatePath(configPath ? resolve(cwd, configPath) : cwd);
+		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;
+			if (discoveredDOs.find((doInfo) => doInfo.className === className)) 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 types = generateBindingTypes({
+			...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
+					}];
+				})) : void 0
+			} : void 0
+		}, 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 };
+	}
+}
+//#endregion
+export { runTypesCommand };

package/dist/_chunks/ui-BhCdDC2N.js

@@ -0,0 +1,103 @@
+import { a as DIM, c as RESET, i as CYAN_BOLD, l as WHITE, n as BOLD, o as GREEN, r as CYAN, s as RED, u as YELLOW } from "./colors-D0NVzAFN.js";
+//#region src/cli/ui.ts
+const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function createCliTheme(options = {}) {
+	if (options["no-color"] === true) return { useColor: false };
+	if (process.env.NO_COLOR?.trim()) return { useColor: false };
+	if (process.env.TERM === "dumb") return { useColor: false };
+	return { useColor: process.stdout?.isTTY === true };
+}
+function paint(value, code, theme) {
+	return theme.useColor ? `${code}${value}${RESET}` : value;
+}
+function dim(value, theme) {
+	return paint(value, DIM, theme);
+}
+function bold(value, theme) {
+	return paint(value, BOLD, theme);
+}
+function cyan(value, theme) {
+	return paint(value, CYAN, theme);
+}
+function cyanBold(value, theme) {
+	return paint(value, CYAN_BOLD, theme);
+}
+function green(value, theme) {
+	return paint(value, GREEN, theme);
+}
+function yellow(value, theme) {
+	return paint(value, YELLOW, theme);
+}
+function yellowBold(value, theme) {
+	return paint(value, `${BOLD}${YELLOW}`, theme);
+}
+function red(value, theme) {
+	return paint(value, RED, theme);
+}
+function whiteDim(value, theme) {
+	return paint(value, `${DIM}${WHITE}`, theme);
+}
+function accent(value, theme, kind = "cyan") {
+	switch (kind) {
+		case "yellow": return yellowBold(value, theme);
+		case "green": return green(value, theme);
+		case "red": return red(value, theme);
+		case "dim": return dim(value, theme);
+		case "bold": return bold(value, theme);
+		case "white-dim": return whiteDim(value, theme);
+		default: return cyanBold(value, theme);
+	}
+}
+function logLine(logger, message = "") {
+	logger.log(message);
+}
+function stripAnsi(value) {
+	return value.replace(ANSI_REGEX, "");
+}
+function truncateCell(value, width) {
+	if (value.length <= width) return value;
+	if (width <= 1) return "…";
+	return `${value.slice(0, width - 1)}…`;
+}
+function truncateStyledCell(value, width) {
+	const plainValue = stripAnsi(value);
+	if (plainValue.length <= width) return value;
+	const truncatedPlainValue = truncateCell(plainValue, width);
+	const prefixMatch = value.match(/^((?:\x1b\[[0-9;]*m)+)/);
+	const suffixMatch = value.match(/((?:\x1b\[[0-9;]*m)+)$/);
+	const prefix = prefixMatch?.[1] ?? "";
+	return `${prefix}${truncatedPlainValue}${prefix ? RESET : suffixMatch?.[1] ?? ""}`;
+}
+function padStyledCell(value, width) {
+	const truncatedValue = truncateStyledCell(value, width);
+	const visibleLength = stripAnsi(truncatedValue).length;
+	return `${truncatedValue}${" ".repeat(Math.max(width - visibleLength, 0))}`;
+}
+function formatTableLine(values, widths) {
+	return values.map((value, index) => {
+		const width = widths[index];
+		if (width === void 0 || index === values.length - 1) return value;
+		return padStyledCell(value, width);
+	}).join("  ");
+}
+function renderTable(rows, columns, theme) {
+	if (rows.length === 0) return [];
+	const widths = columns.map((column) => column.width);
+	return [formatTableLine(columns.map((column) => dim(column.label, theme)), widths), ...rows.map((row) => formatTableLine(columns.map((column) => column.value(row)), widths))];
+}
+function logTable(logger, options) {
+	if (options.rows.length === 0) return;
+	logLine(logger, `${accent(options.title, options.theme, options.titleAccent)} ${dim(`(${options.rows.length})`, options.theme)}`);
+	for (const line of renderTable(options.rows, options.columns, options.theme)) logLine(logger, line);
+}
+function formatLabelValue(label, value, theme, labelWidth = 12) {
+	return `${dim(label.padEnd(labelWidth), theme)} ${value}`;
+}
+function formatCommand(command, description, theme) {
+	return `  ${cyan(command, theme)}${dim(" — ", theme)}${description}`;
+}
+function formatBullet(text, theme, bullet = "•") {
+	return `  ${dim(bullet, theme)} ${text}`;
+}
+//#endregion
+export { yellowBold as _, cyanBold as a, formatCommand as c, green as d, logLine as f, yellow as g, whiteDim as h, cyan as i, formatLabelValue as l, red as m, bold as n, dim as o, logTable as p, createCliTheme as r, formatBullet as s, accent as t, formatTableLine as u };