devflare 1.0.0-next.5 → 1.0.0-next.51

package/dist/_chunks/routes-B6XiI8Sa.js

@@ -0,0 +1,851 @@
+import { d as configSchema } from "./loader-OQ2AWpqm.js";
+import { _ as normalizeSecretsStoreBinding, c as normalizeFlagshipBinding, f as normalizeMediaBinding, g as normalizeR2Binding, h as normalizeQueueProducer, i as normalizeArtifactsBinding, l as normalizeHyperdriveBinding, m as normalizePipelineBinding, n as getLocalKVNamespaceIdentifier, o as normalizeDOBinding, p as normalizeMtlsCertificateBinding, s as normalizeDispatchNamespaceBinding, t as getLocalD1DatabaseIdentifier, u as normalizeImagesBinding, v as normalizeStreamBinding, x as normalizeWorkflowBinding } from "./schema-normalization-GjhTATHL.js";
+import { n as findDurableObjectClasses } from "./durable-object-DMtH0XYX.js";
+import { r as SUPPORTED_WORKER_EXTENSIONS, t as transformWorkerEntrypoint } from "./worker-entrypoint-CQW77lG8.js";
+import { a as findFilesSync, i as findFiles, t as DEFAULT_DO_PATTERN } from "./glob-CmQOvunB.js";
+import { r as discoverEntrypointsSync, t as resolvePackageSpecifier } from "./resolve-package-qizBfCIm.js";
+import { relative, resolve } from "pathe";
+import { existsSync, readFileSync } from "fs";
+import { dirname as dirname$1, join as join$1, resolve as resolve$1 } from "path";
+//#region src/dev-server/miniflare-bindings.ts
+function buildQueueProducers(bindings) {
+	if (!bindings.queues?.producers) return;
+	const producers = {};
+	for (const [bindingName, producer] of Object.entries(bindings.queues.producers)) {
+		const normalized = normalizeQueueProducer(producer);
+		producers[bindingName] = {
+			queueName: normalized.queue,
+			...normalized.deliveryDelay !== void 0 && { deliveryDelay: normalized.deliveryDelay }
+		};
+	}
+	return producers;
+}
+function buildQueueConsumers(bindings) {
+	if (!bindings.queues?.consumers || bindings.queues.consumers.length === 0) return;
+	const consumers = {};
+	for (const consumer of bindings.queues.consumers) consumers[consumer.queue] = {
+		...consumer.maxBatchSize !== void 0 && { maxBatchSize: consumer.maxBatchSize },
+		...consumer.maxBatchTimeout !== void 0 && { maxBatchTimeout: consumer.maxBatchTimeout },
+		...consumer.maxRetries !== void 0 && { maxRetries: consumer.maxRetries },
+		...consumer.deadLetterQueue && { deadLetterQueue: consumer.deadLetterQueue },
+		...consumer.maxConcurrency !== void 0 && { maxConcurrency: consumer.maxConcurrency },
+		...consumer.retryDelay !== void 0 && { retryDelay: consumer.retryDelay }
+	};
+	return consumers;
+}
+function buildRateLimitsConfig(bindings) {
+	if (!bindings.rateLimits) return;
+	return Object.fromEntries(Object.entries(bindings.rateLimits).map(([name, binding]) => [name, { simple: {
+		limit: binding.simple.limit,
+		period: binding.simple.period
+	} }]));
+}
+function buildVersionMetadataConfig(bindings) {
+	return bindings.versionMetadata?.binding;
+}
+function buildWorkerLoadersConfig(bindings) {
+	if (!bindings.workerLoaders) return;
+	return Object.fromEntries(Object.keys(bindings.workerLoaders).map((bindingName) => [bindingName, {}]));
+}
+function buildMtlsCertificatesConfig(bindings) {
+	if (!bindings.mtlsCertificates) return;
+	return Object.fromEntries(Object.entries(bindings.mtlsCertificates).map(([bindingName, binding]) => {
+		const normalized = normalizeMtlsCertificateBinding(binding);
+		return [bindingName, {
+			certificate_id: normalized.certificateId,
+			...normalized.remote !== void 0 && { remote: normalized.remote }
+		}];
+	}));
+}
+function buildDispatchNamespacesConfig(bindings) {
+	if (!bindings.dispatchNamespaces) return;
+	return Object.fromEntries(Object.entries(bindings.dispatchNamespaces).map(([bindingName, binding]) => {
+		return [bindingName, { namespace: normalizeDispatchNamespaceBinding(binding).namespace }];
+	}));
+}
+function buildWorkflowsConfig(bindings) {
+	if (!bindings.workflows) return;
+	return Object.fromEntries(Object.entries(bindings.workflows).map(([bindingName, binding]) => {
+		const normalized = normalizeWorkflowBinding(binding);
+		return [bindingName, {
+			name: normalized.name,
+			className: normalized.className,
+			...normalized.scriptName && { scriptName: normalized.scriptName },
+			...normalized.limits && { stepLimit: normalized.limits.steps }
+		}];
+	}));
+}
+function buildPipelinesConfig(bindings) {
+	if (!bindings.pipelines) return;
+	return Object.fromEntries(Object.entries(bindings.pipelines).map(([bindingName, binding]) => {
+		const normalized = normalizePipelineBinding(binding);
+		return [bindingName, typeof binding === "string" ? normalized.pipeline : { pipeline: normalized.pipeline }];
+	}));
+}
+function getHyperdriveLocalConnectionString(bindingName, binding) {
+	const cloudflareEnvName = `CLOUDFLARE_HYPERDRIVE_LOCAL_CONNECTION_STRING_${bindingName}`;
+	const wranglerEnvName = `WRANGLER_HYPERDRIVE_LOCAL_CONNECTION_STRING_${bindingName}`;
+	const envValue = process.env[cloudflareEnvName] ?? process.env[wranglerEnvName];
+	if (envValue?.trim()) return envValue;
+	return normalizeHyperdriveBinding(binding).localConnectionString;
+}
+function buildHyperdrivesConfig(bindings) {
+	if (!bindings.hyperdrive) return;
+	const hyperdrives = Object.fromEntries(Object.entries(bindings.hyperdrive).map(([bindingName, binding]) => {
+		const localConnectionString = getHyperdriveLocalConnectionString(bindingName, binding);
+		return localConnectionString ? [bindingName, localConnectionString] : null;
+	}).filter((entry) => entry !== null));
+	return Object.keys(hyperdrives).length > 0 ? hyperdrives : void 0;
+}
+function buildImagesConfig(bindings) {
+	if (!bindings.images) return;
+	const [entry] = Object.entries(bindings.images);
+	if (!entry) return;
+	const [bindingName, binding] = entry;
+	return { binding: normalizeImagesBinding(bindingName, binding).binding };
+}
+function buildMediaConfig(bindings) {
+	if (!bindings.media) return;
+	const [entry] = Object.entries(bindings.media);
+	if (!entry) return;
+	const [bindingName, binding] = entry;
+	return { binding: normalizeMediaBinding(bindingName, binding).binding };
+}
+function buildStreamConfig(bindings) {
+	if (!bindings.stream) return;
+	const [entry] = Object.entries(bindings.stream);
+	if (!entry) return;
+	const [bindingName, binding] = entry;
+	return { binding: normalizeStreamBinding(bindingName, binding).binding };
+}
+function buildFlagshipConfig(bindings) {
+	if (!bindings.flagship) return;
+	return Object.fromEntries(Object.entries(bindings.flagship).map(([bindingName, binding]) => {
+		return [bindingName, { app_id: normalizeFlagshipBinding(binding).appId }];
+	}));
+}
+function buildAnalyticsEngineConfig(bindings) {
+	if (!bindings.analyticsEngine) return;
+	return Object.fromEntries(Object.entries(bindings.analyticsEngine).map(([bindingName, binding]) => [bindingName, { dataset: binding.dataset }]));
+}
+function buildArtifactsConfig(bindings) {
+	if (!bindings.artifacts) return;
+	return Object.fromEntries(Object.entries(bindings.artifacts).map(([bindingName, binding]) => {
+		return [bindingName, { namespace: normalizeArtifactsBinding(binding).namespace }];
+	}));
+}
+function buildAiSearchNamespacesConfig(bindings) {
+	if (!bindings.aiSearchNamespaces) return;
+	return Object.fromEntries(Object.entries(bindings.aiSearchNamespaces).map(([bindingName, binding]) => [bindingName, { namespace: binding.namespace }]));
+}
+function buildAiSearchInstancesConfig(bindings) {
+	if (!bindings.aiSearch) return;
+	return Object.fromEntries(Object.entries(bindings.aiSearch).map(([bindingName, binding]) => [bindingName, { instance_name: binding.instanceName }]));
+}
+function buildSecretsStoreConfig(bindings, defaultSecretsStoreId, excludedBindingNames = /* @__PURE__ */ new Set()) {
+	if (!bindings.secretsStore) return;
+	const entries = Object.entries(bindings.secretsStore).flatMap(([bindingName, binding]) => {
+		if (excludedBindingNames.has(bindingName)) return [];
+		const normalized = normalizeSecretsStoreBinding(binding, defaultSecretsStoreId, bindingName);
+		return [[bindingName, {
+			store_id: normalized.storeId,
+			secret_name: normalized.secretName
+		}]];
+	});
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function buildSendEmailConfig(bindings) {
+	if (!bindings.sendEmail) return;
+	return { send_email: Object.entries(bindings.sendEmail).map(([name, binding]) => ({
+		name,
+		...binding.destinationAddress && { destination_address: binding.destinationAddress },
+		...binding.allowedDestinationAddresses && { allowed_destination_addresses: binding.allowedDestinationAddresses },
+		...binding.allowedSenderAddresses && { allowed_sender_addresses: binding.allowedSenderAddresses },
+		...binding.remote !== void 0 && { remote: binding.remote }
+	})) };
+}
+/**
+* Translate the top-level `tailConsumers` config into Miniflare's per-worker
+* `tails` option (an array of service designators). Each tail consumer points
+* at ANOTHER Worker by service name; Miniflare delivers tail events to that
+* Worker only when it is present in the same Miniflare `workers` array. In
+* single-worker local dev the consumer Worker is typically absent, in which
+* case the designator simply resolves to nothing — local delivery degrades
+* cleanly (no crash) and live delivery works only when the consumer Worker is
+* also run locally. The tail *handler* on a Worker is wired separately and is
+* always testable (`cf.tail.trigger()`).
+*/
+function buildTailConsumersConfig(config) {
+	if (!config.tailConsumers || config.tailConsumers.length === 0) return;
+	const tails = config.tailConsumers.map((consumer) => typeof consumer === "string" ? consumer : consumer.service);
+	return tails.length > 0 ? tails : void 0;
+}
+/**
+* Translate the top-level `streamingTailConsumers` config into Miniflare's
+* per-worker `streamingTails` option (an array of service designators). This is
+* the streaming twin of {@link buildTailConsumersConfig}; the same
+* present-only-when-the-consumer-Worker-is-run-locally delivery semantics apply.
+*/
+function buildStreamingTailConsumersConfig(config) {
+	if (!config.streamingTailConsumers || config.streamingTailConsumers.length === 0) return;
+	const streamingTails = config.streamingTailConsumers.map((consumer) => typeof consumer === "string" ? consumer : consumer.service);
+	return streamingTails.length > 0 ? streamingTails : void 0;
+}
+//#endregion
+//#region src/test/resolve-service-bindings.ts
+function getBunRuntime() {
+	const g = globalThis;
+	if (typeof g.Bun === "object" && g.Bun !== null) return g.Bun;
+}
+/**
+* Discover DO files matching do.*.ts/js pattern recursively in a directory
+* Uses the same glob pattern as the rest of the codebase for consistency.
+* Returns map of className -> filePath
+*/
+function discoverDOFilesSync(dir, pattern = DEFAULT_DO_PATTERN) {
+	const classToPath = /* @__PURE__ */ new Map();
+	try {
+		const files = findFilesSync(pattern, { cwd: dir });
+		for (const filePath of files) try {
+			const classNames = findDurableObjectClasses(readFileSync(filePath, "utf-8"));
+			for (const className of classNames) if (!classToPath.has(className)) classToPath.set(className, filePath);
+		} catch {}
+	} catch {}
+	return classToPath;
+}
+/**
+* Cache for bundled worker scripts to avoid re-bundling in repeated test runs.
+* Key: entryPath + entrypoint, Value: bundled script code
+*/
+const bundleCache = /* @__PURE__ */ new Map();
+/**
+* Clear the bundle cache (useful between test suites)
+*/
+function clearBundleCache() {
+	bundleCache.clear();
+}
+function findDefaultServiceWorkerEntrypoint(refConfigDir) {
+	for (const candidate of [
+		"worker.ts",
+		"worker.js",
+		"src/worker.ts",
+		"src/worker.js"
+	]) {
+		const absolutePath = resolve$1(refConfigDir, candidate);
+		if (existsSync(absolutePath)) return absolutePath;
+	}
+	return null;
+}
+function buildRawServiceBindings(services) {
+	if (!services || Object.keys(services).length === 0) return;
+	return Object.fromEntries(Object.entries(services).map(([bindingName, binding]) => [bindingName, {
+		name: binding.service,
+		...binding.entrypoint && { entrypoint: binding.entrypoint }
+	}]));
+}
+function buildReferencedWorkerRuntimeConfig(config) {
+	const bindings = config.bindings ?? {};
+	const queueProducers = buildQueueProducers(bindings);
+	const queueConsumers = buildQueueConsumers(bindings);
+	const rateLimits = buildRateLimitsConfig(bindings);
+	const versionMetadata = buildVersionMetadataConfig(bindings);
+	const workerLoaders = buildWorkerLoadersConfig(bindings);
+	const mtlsCertificates = buildMtlsCertificatesConfig(bindings);
+	const dispatchNamespaces = buildDispatchNamespacesConfig(bindings);
+	const workflows = buildWorkflowsConfig(bindings);
+	const pipelines = buildPipelinesConfig(bindings);
+	const hyperdrives = buildHyperdrivesConfig(bindings);
+	const media = buildMediaConfig(bindings);
+	const artifacts = buildArtifactsConfig(bindings);
+	const aiSearchNamespaces = buildAiSearchNamespacesConfig(bindings);
+	const aiSearchInstances = buildAiSearchInstancesConfig(bindings);
+	const secretsStoreSecrets = buildSecretsStoreConfig(bindings, config.secretsStoreId);
+	const email = buildSendEmailConfig(bindings);
+	const serviceBindings = buildRawServiceBindings(bindings.services);
+	return {
+		...config.compatibilityFlags && { compatibilityFlags: config.compatibilityFlags },
+		...config.vars && { bindings: config.vars },
+		...bindings.kv && { kvNamespaces: Object.fromEntries(Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => [bindingName, getLocalKVNamespaceIdentifier(bindingConfig)])) },
+		...bindings.r2 && { r2Buckets: Object.fromEntries(Object.entries(bindings.r2).map(([bindingName, bindingConfig]) => [bindingName, normalizeR2Binding(bindingConfig).bucketName])) },
+		...bindings.d1 && { d1Databases: Object.fromEntries(Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => [bindingName, getLocalD1DatabaseIdentifier(bindingConfig)])) },
+		...queueProducers && { queueProducers },
+		...queueConsumers && { queueConsumers },
+		...rateLimits && { ratelimits: rateLimits },
+		...versionMetadata && { versionMetadata },
+		...workerLoaders && { workerLoaders },
+		...mtlsCertificates && { mtlsCertificates },
+		...dispatchNamespaces && { dispatchNamespaces },
+		...workflows && { workflows },
+		...pipelines && { pipelines },
+		...hyperdrives && { hyperdrives },
+		...media && { media },
+		...artifacts && { artifacts },
+		...aiSearchNamespaces && { aiSearchNamespaces },
+		...aiSearchInstances && { aiSearchInstances },
+		...secretsStoreSecrets && { secretsStoreSecrets },
+		...email && { email },
+		...serviceBindings && { serviceBindings }
+	};
+}
+function normalizeReferencedConfig(config) {
+	return configSchema.parse(config);
+}
+function resolveReferencedConfigDir(ref, parentConfigDir) {
+	const configPath = ref.configPath;
+	if (!configPath || configPath === "<resolved>") return null;
+	return dirname$1(resolvePackageSpecifier(configPath, parentConfigDir));
+}
+async function resolveReferencedLocalDurableObjects(config, configDir, workerName, serviceBindings = {}) {
+	const doPattern = config.files?.durableObjects;
+	const dosConfig = config.bindings?.durableObjects;
+	if (typeof doPattern !== "string" || !dosConfig || Object.keys(dosConfig).length === 0) return {
+		workers: [],
+		bindings: {}
+	};
+	const discoveredDOs = discoverDOFilesSync(configDir, doPattern);
+	const doClasses = [];
+	for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
+		const doConfig = normalizeDOBinding(rawDoConfig);
+		if (doConfig.kind !== "local") continue;
+		const scriptPath = discoveredDOs.get(doConfig.className);
+		if (!scriptPath) {
+			console.warn(`[devflare] DO "${bindingName}" (class: ${doConfig.className}) not found in files.durableObjects for "${workerName}"`);
+			continue;
+		}
+		doClasses.push({
+			bindingName,
+			className: doConfig.className,
+			scriptPath
+		});
+	}
+	if (doClasses.length === 0) return {
+		workers: [],
+		bindings: {}
+	};
+	const doWorkerName = `${workerName}-durable-objects`;
+	const script = await bundleDOClasses(doClasses, doWorkerName);
+	if (!script) return {
+		workers: [],
+		bindings: {}
+	};
+	const durableObjects = Object.fromEntries(doClasses.map((do_) => [do_.bindingName, do_.className]));
+	const runtimeConfig = buildReferencedWorkerRuntimeConfig(config);
+	const doRuntimeConfig = { ...runtimeConfig };
+	delete doRuntimeConfig.queueConsumers;
+	const mergedServiceBindings = {
+		...runtimeConfig.serviceBindings ?? {},
+		...serviceBindings
+	};
+	return {
+		workers: [{
+			name: doWorkerName,
+			script,
+			modules: true,
+			compatibilityDate: config.compatibilityDate,
+			...doRuntimeConfig,
+			...Object.keys(mergedServiceBindings).length > 0 && { serviceBindings: mergedServiceBindings },
+			durableObjects
+		}],
+		bindings: Object.fromEntries(doClasses.map((do_) => [do_.bindingName, {
+			className: do_.className,
+			scriptName: doWorkerName
+		}]))
+	};
+}
+/**
+* Check if a config has service bindings that need multi-worker setup
+*/
+function hasServiceBindings(config) {
+	const services = config.bindings?.services;
+	if (!services) return false;
+	return Object.keys(services).length > 0;
+}
+/**
+* Resolve service bindings from a config
+* Returns the workers array and service bindings for Miniflare setup
+*/
+async function resolveServiceBindings(config, configDir, seenWorkers = /* @__PURE__ */ new Set()) {
+	const services = config.bindings?.services;
+	if (!services) return {
+		workers: [],
+		primaryServiceBindings: {}
+	};
+	const workersByName = /* @__PURE__ */ new Map();
+	const primaryServiceBindings = {};
+	for (const [bindingName, binding] of Object.entries(services)) {
+		const workerBinding = binding;
+		const ref = workerBinding.__ref;
+		if (ref) {
+			if ("__import" in ref && typeof ref.__import === "function") await ref.resolve();
+			const workerName = ref.name;
+			const entrypoint = workerBinding.entrypoint;
+			if (!workersByName.has(workerName) && !seenWorkers.has(workerName)) {
+				const refConfig = normalizeReferencedConfig(ref.config);
+				const worker = await resolveRefWorker(ref, entrypoint, configDir, refConfig);
+				if (worker) {
+					const refConfigDir = resolveReferencedConfigDir(ref, configDir);
+					if (ref.config && refConfigDir) {
+						const nested = await resolveServiceBindings(refConfig, refConfigDir, new Set([...seenWorkers, workerName]));
+						worker.serviceBindings = {
+							...worker.serviceBindings ?? {},
+							...nested.primaryServiceBindings
+						};
+						for (const nestedWorker of nested.workers) if (!workersByName.has(nestedWorker.name)) workersByName.set(nestedWorker.name, nestedWorker);
+						const localDOs = await resolveReferencedLocalDurableObjects(refConfig, refConfigDir, workerName, nested.primaryServiceBindings);
+						worker.durableObjects = {
+							...worker.durableObjects ?? {},
+							...localDOs.bindings
+						};
+						for (const doWorker of localDOs.workers) if (!workersByName.has(doWorker.name)) workersByName.set(doWorker.name, doWorker);
+					}
+					workersByName.set(workerName, worker);
+				}
+			}
+			primaryServiceBindings[bindingName] = {
+				name: workerName,
+				...entrypoint && { entrypoint }
+			};
+		} else primaryServiceBindings[bindingName] = {
+			name: workerBinding.service,
+			...workerBinding.entrypoint && { entrypoint: workerBinding.entrypoint }
+		};
+	}
+	return {
+		workers: [...workersByName.values()],
+		primaryServiceBindings
+	};
+}
+/**
+* Resolve a referenced worker config to a bundled script.
+* Bundles the default `worker.{ts,js}` (root) or `src/worker.{ts,js}` RPC
+* surface plus any named entrypoints discovered from `files.entrypoints` into a
+* single script.
+*/
+async function resolveRefWorker(ref, _entrypoint, parentConfigDir, resolvedConfig) {
+	const config = resolvedConfig ?? normalizeReferencedConfig(ref.config);
+	if (!config) return null;
+	const refConfigDir = resolveReferencedConfigDir(ref, parentConfigDir);
+	if (!refConfigDir) {
+		console.warn(`[devflare] Cannot resolve worker "${ref.name}" - configPath not available`);
+		return null;
+	}
+	const entrypoints = [];
+	const workerEntrypointPath = findDefaultServiceWorkerEntrypoint(refConfigDir);
+	if (workerEntrypointPath) entrypoints.push({
+		path: workerEntrypointPath,
+		className: "Worker",
+		isWorkerTs: true
+	});
+	if (config.files?.entrypoints !== false) {
+		const discoveredEntrypoints = discoverEntrypointsSync(refConfigDir, typeof config.files?.entrypoints === "string" ? config.files.entrypoints : void 0);
+		for (const ep of discoveredEntrypoints) entrypoints.push({
+			path: ep.filePath,
+			className: ep.className,
+			isWorkerTs: false
+		});
+	}
+	if (entrypoints.length === 0) {
+		console.warn(`[devflare] Worker "${ref.name}" has no entry points`);
+		return null;
+	}
+	const script = await bundleAllEntrypoints(entrypoints, ref.name);
+	if (!script) return null;
+	return {
+		name: ref.name,
+		script,
+		modules: true,
+		compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+		...buildReferencedWorkerRuntimeConfig(config)
+	};
+}
+/**
+* Bundle multiple entrypoints into a single worker script
+*/
+async function bundleAllEntrypoints(entrypoints, workerName) {
+	const cacheKey = entrypoints.map((ep) => `${ep.path}::${ep.className}`).join("|");
+	const cached = bundleCache.get(cacheKey);
+	if (cached) return cached;
+	const bun = getBunRuntime();
+	if (!bun) {
+		console.warn(`[devflare] Cannot bundle service worker "${workerName}" — the Bun runtime is required to bundle worker scripts, but this process is not running under Bun. The service binding will be left unresolved. Run your tests with \`bun test\` (or the devflare test runner) to enable multi-worker service bindings.`);
+		return null;
+	}
+	try {
+		const { readFileSync, writeFileSync, mkdirSync, unlinkSync } = await import("fs");
+		const imports = [];
+		const exports = [];
+		let defaultExportClass = null;
+		for (let i = 0; i < entrypoints.length; i++) {
+			const ep = entrypoints[i];
+			const sourceCode = readFileSync(ep.path, "utf-8");
+			if (ep.isWorkerTs) {
+				const result = transformWorkerEntrypoint(sourceCode, ep.path, {
+					className: ep.className,
+					injectContext: false
+				});
+				if (result) {
+					const tempDir = join$1(dirname$1(ep.path), ".devflare");
+					mkdirSync(tempDir, { recursive: true });
+					const tempPath = join$1(tempDir, `__${ep.className}_${i}.ts`);
+					writeFileSync(tempPath, result.code);
+					imports.push(`import { ${ep.className} } from '${tempPath.replace(/\\/g, "/")}'`);
+					exports.push(ep.className);
+					if (!defaultExportClass) defaultExportClass = ep.className;
+				}
+			} else {
+				imports.push(`import { ${ep.className} } from '${ep.path.replace(/\\/g, "/")}'`);
+				exports.push(ep.className);
+			}
+		}
+		const defaultExport = defaultExportClass ? `\nexport default ${defaultExportClass}` : "";
+		const entryCode = `
+${imports.join("\n")}
+export { ${exports.join(", ")} }${defaultExport}
+`;
+		const tempDir = join$1(dirname$1(entrypoints[0].path), ".devflare");
+		mkdirSync(tempDir, { recursive: true });
+		const entryPath = join$1(tempDir, `__entry_${workerName}.ts`);
+		writeFileSync(entryPath, entryCode);
+		try {
+			const result = await bun.build({
+				entrypoints: [entryPath],
+				target: "browser",
+				format: "esm",
+				minify: false,
+				external: ["cloudflare:workers", "cloudflare:*"]
+			});
+			if (!result.success) {
+				console.warn(`[devflare] Failed to bundle worker "${workerName}": ${result.logs.join("\n")}`);
+				return null;
+			}
+			const bundledCode = await result.outputs[0].text();
+			bundleCache.set(cacheKey, bundledCode);
+			return bundledCode;
+		} finally {
+			try {
+				unlinkSync(entryPath);
+			} catch {}
+		}
+	} catch (error) {
+		console.warn(`[devflare] Error bundling worker "${workerName}":`, error);
+		return null;
+	}
+}
+/**
+* Check if a config has cross-worker DO bindings
+*/
+function hasCrossWorkerDOs(config) {
+	const dos = config.bindings?.durableObjects;
+	if (!dos) return false;
+	for (const doConfig of Object.values(dos)) if (normalizeDOBinding(doConfig).__ref) return true;
+	return false;
+}
+/**
+* Resolve cross-worker DO bindings
+* Returns workers to set up and DO bindings for the primary worker
+*/
+async function resolveDOBindings(config, configDir) {
+	const dos = config.bindings?.durableObjects;
+	if (!dos) return {
+		workers: [],
+		crossWorkerDOBindings: {}
+	};
+	const workersByName = /* @__PURE__ */ new Map();
+	const crossWorkerDOBindings = {};
+	for (const [bindingName, rawDoConfig] of Object.entries(dos)) {
+		if (!(typeof rawDoConfig === "object" && "__ref" in rawDoConfig)) continue;
+		const ref = rawDoConfig.__ref;
+		if ("__import" in ref && typeof ref.__import === "function") await ref.resolve();
+		const doConfig = normalizeDOBinding(rawDoConfig);
+		const workerName = ref.name;
+		if (!workersByName.has(workerName)) {
+			const worker = await resolveDORefWorker(ref, configDir);
+			if (worker) workersByName.set(workerName, worker);
+		}
+		crossWorkerDOBindings[bindingName] = {
+			className: doConfig.className,
+			scriptName: workerName
+		};
+	}
+	return {
+		workers: [...workersByName.values()],
+		crossWorkerDOBindings
+	};
+}
+/**
+* Resolve a referenced worker for DO hosting
+* Bundles the DO classes with RPC wrappers
+*/
+async function resolveDORefWorker(ref, parentConfigDir) {
+	const config = ref.config;
+	if (!config) return null;
+	const configPath = ref.configPath;
+	if (!configPath || configPath === "<resolved>") {
+		console.warn(`[devflare] Cannot resolve DO worker "${ref.name}" - configPath not available`);
+		return null;
+	}
+	const refConfigDir = dirname$1(resolvePackageSpecifier(configPath, parentConfigDir));
+	const dosConfig = config.bindings?.durableObjects;
+	if (!dosConfig || Object.keys(dosConfig).length === 0) {
+		console.warn(`[devflare] Referenced worker "${ref.name}" has no Durable Objects`);
+		return null;
+	}
+	const discoveredDOs = discoverDOFilesSync(refConfigDir);
+	const doClasses = [];
+	for (const [bindingName, rawDoConfig] of Object.entries(dosConfig)) {
+		const doConfig = normalizeDOBinding(rawDoConfig);
+		const className = doConfig.className;
+		const scriptName = doConfig.scriptName;
+		if (scriptName) {
+			const scriptPath = resolve$1(refConfigDir, "src", scriptName);
+			if (!existsSync(scriptPath)) {
+				const altPath = resolve$1(refConfigDir, scriptName);
+				if (!existsSync(altPath)) {
+					console.warn(`[devflare] DO script not found: ${scriptPath} or ${altPath}`);
+					continue;
+				}
+				doClasses.push({
+					bindingName,
+					className,
+					scriptPath: altPath
+				});
+			} else doClasses.push({
+				bindingName,
+				className,
+				scriptPath
+			});
+		} else {
+			const discoveredPath = discoveredDOs.get(className);
+			if (discoveredPath) doClasses.push({
+				bindingName,
+				className,
+				scriptPath: discoveredPath
+			});
+			else console.warn(`[devflare] DO "${bindingName}" (class: ${className}) not found in do.*.ts files in "${ref.name}"`);
+		}
+	}
+	if (doClasses.length === 0) {
+		console.warn(`[devflare] No valid DO classes found in "${ref.name}"`);
+		return null;
+	}
+	const script = await bundleDOClasses(doClasses, ref.name);
+	if (!script) return null;
+	const durableObjects = {};
+	for (const do_ of doClasses) durableObjects[do_.bindingName] = do_.className;
+	return {
+		name: ref.name,
+		script,
+		modules: true,
+		compatibilityDate: config.compatibilityDate ?? "2025-01-01",
+		durableObjects
+	};
+}
+/**
+* Bundle DO classes with RPC wrappers for Miniflare
+*/
+async function bundleDOClasses(doClasses, workerName) {
+	const cacheKey = `do:${doClasses.map((d) => `${d.scriptPath}::${d.className}`).join("|")}`;
+	const cached = bundleCache.get(cacheKey);
+	if (cached) return cached;
+	const bun = getBunRuntime();
+	if (!bun) {
+		console.warn(`[devflare] Cannot bundle Durable Object worker "${workerName}" — the Bun runtime is required to bundle DO classes, but this process is not running under Bun. The Durable Object binding will be left unresolved. Run your tests with \`bun test\` (or the devflare test runner) to enable cross-worker Durable Objects.`);
+		return null;
+	}
+	try {
+		const { writeFileSync, mkdirSync, unlinkSync } = await import("fs");
+		const entryCode = `
+${doClasses.map((d) => `import { ${d.className} } from '${d.scriptPath.replace(/\\/g, "/")}'`).join("\n")}
+
+// Re-export DO classes for Miniflare binding
+export { ${doClasses.map((d) => d.className).join(", ")} }
+
+// Default export with fetch handler
+export default {
+	async fetch(request, env) {
+		return new Response('DO Worker: ${workerName}')
+	}
+}
+`;
+		const tempDir = join$1(dirname$1(doClasses[0].scriptPath), ".devflare");
+		mkdirSync(tempDir, { recursive: true });
+		const entryPath = join$1(tempDir, `__do_entry_${workerName}.ts`);
+		writeFileSync(entryPath, entryCode);
+		try {
+			const result = await bun.build({
+				entrypoints: [entryPath],
+				target: "browser",
+				format: "esm",
+				minify: false,
+				external: ["cloudflare:workers", "cloudflare:*"]
+			});
+			if (!result.success) {
+				console.warn(`[devflare] Failed to bundle DO worker "${workerName}": ${result.logs.join("\n")}`);
+				return null;
+			}
+			const bundledCode = await result.outputs[0].text();
+			bundleCache.set(cacheKey, bundledCode);
+			return bundledCode;
+		} finally {
+			try {
+				unlinkSync(entryPath);
+			} catch {}
+		}
+	} catch (error) {
+		console.warn(`[devflare] Error bundling DO worker "${workerName}":`, error);
+		return null;
+	}
+}
+const DEFAULT_ROUTE_FILE_PATTERNS = SUPPORTED_WORKER_EXTENSIONS.map((ext) => `**/*${ext}`);
+function normalizeRoutePrefix(prefix) {
+	if (!prefix || prefix === "/") return "";
+	return (prefix.startsWith("/") ? prefix : `/${prefix}`).replace(/\/+$/g, "");
+}
+function createStaticSegmentsFromPrefix(prefix) {
+	if (!prefix) return [];
+	return prefix.split("/").filter(Boolean).map((value) => ({
+		type: "static",
+		value
+	}));
+}
+function shouldIgnoreRouteFile(relativePath) {
+	return relativePath.split("/").some((segment) => segment.startsWith("_"));
+}
+function toRoutePath(segments) {
+	if (segments.length === 0) return "/";
+	return `/${segments.map((segment) => {
+		if (segment.type === "static") return segment.value;
+		if (segment.type === "param") return `[${segment.name}]`;
+		if (segment.type === "rest") return `[...${segment.name}]`;
+		return `[[...${segment.name}]]`;
+	}).join("/")}`;
+}
+function getRouteSignature(segments) {
+	if (segments.length === 0) return "/";
+	return segments.map((segment) => {
+		if (segment.type === "static") return `static:${segment.value}`;
+		if (segment.type === "param") return "param";
+		if (segment.type === "rest") return "rest";
+		return "optional-rest";
+	}).join("/");
+}
+function getSegmentPriority(segment) {
+	if (segment.type === "static") return 4;
+	if (segment.type === "param") return 3;
+	if (segment.type === "rest") return 1;
+	return 0;
+}
+function compareRoutes(a, b) {
+	const maxLength = Math.max(a.segments.length, b.segments.length);
+	for (let index = 0; index < maxLength; index += 1) {
+		const left = a.segments[index];
+		const right = b.segments[index];
+		if (!left && !right) break;
+		if (!left) return 1;
+		if (!right) return -1;
+		const priorityDifference = getSegmentPriority(right) - getSegmentPriority(left);
+		if (priorityDifference !== 0) return priorityDifference;
+		if (left.type === "static" && right.type === "static") {
+			const lexicalDifference = left.value.localeCompare(right.value);
+			if (lexicalDifference !== 0) return lexicalDifference;
+		}
+	}
+	return a.filePath.localeCompare(b.filePath);
+}
+function parseRouteSegments(relativePath, prefixSegments) {
+	const rawSegments = relativePath.replace(/\.[^.]+$/u, "").split("/").filter(Boolean);
+	const routeSegments = [...prefixSegments];
+	for (let index = 0; index < rawSegments.length; index += 1) {
+		const segment = rawSegments[index];
+		const isLastSegment = index === rawSegments.length - 1;
+		if (segment === "index" && isLastSegment) continue;
+		const optionalRestMatch = segment.match(/^\[\[\.\.\.(.+)\]\]$/u);
+		if (optionalRestMatch) {
+			if (!isLastSegment) throw new Error(`Optional rest segment must be the final segment: ${relativePath}`);
+			routeSegments.push({
+				type: "optional-rest",
+				name: optionalRestMatch[1]
+			});
+			continue;
+		}
+		const restMatch = segment.match(/^\[\.\.\.(.+)\]$/u);
+		if (restMatch) {
+			if (!isLastSegment) throw new Error(`Rest segment must be the final segment: ${relativePath}`);
+			routeSegments.push({
+				type: "rest",
+				name: restMatch[1]
+			});
+			continue;
+		}
+		const dynamicMatch = segment.match(/^\[(.+)\]$/u);
+		if (dynamicMatch) {
+			routeSegments.push({
+				type: "param",
+				name: dynamicMatch[1]
+			});
+			continue;
+		}
+		routeSegments.push({
+			type: "static",
+			value: segment
+		});
+	}
+	return routeSegments;
+}
+async function directoryExists(dirPath) {
+	const fs = await import("node:fs/promises");
+	try {
+		return (await fs.stat(dirPath)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function getRouteDirectoryCandidate(cwd, config) {
+	const routesConfig = config.files?.routes;
+	if (routesConfig === false) return null;
+	const dir = routesConfig?.dir ?? "src/routes";
+	return {
+		dir,
+		absoluteDir: resolve(cwd, dir),
+		prefix: normalizeRoutePrefix(routesConfig?.prefix)
+	};
+}
+async function discoverRoutes(cwd, config) {
+	const routeDirectory = getRouteDirectoryCandidate(cwd, config);
+	if (!routeDirectory) return null;
+	if (!await directoryExists(routeDirectory.absoluteDir)) return null;
+	const prefixSegments = createStaticSegmentsFromPrefix(routeDirectory.prefix);
+	const files = await findFiles(DEFAULT_ROUTE_FILE_PATTERNS, {
+		cwd: routeDirectory.absoluteDir,
+		absolute: true
+	});
+	const discoveredRoutes = [];
+	const routeSignatures = /* @__PURE__ */ new Map();
+	for (const absolutePath of files) {
+		const relativeToRouteDir = relative(routeDirectory.absoluteDir, absolutePath).replace(/\\/g, "/");
+		if (shouldIgnoreRouteFile(relativeToRouteDir)) continue;
+		const segments = parseRouteSegments(relativeToRouteDir, prefixSegments);
+		const routePath = toRoutePath(segments);
+		const filePath = relative(cwd, absolutePath).replace(/\\/g, "/");
+		const signature = getRouteSignature(segments);
+		const existingFilePath = routeSignatures.get(signature);
+		if (existingFilePath) throw new Error(`Conflicting file routes detected for "${routePath}". Both "${existingFilePath}" and "${filePath}" resolve to the same route.`);
+		routeSignatures.set(signature, filePath);
+		discoveredRoutes.push({
+			absolutePath,
+			filePath,
+			routePath,
+			segments
+		});
+	}
+	if (discoveredRoutes.length === 0) return null;
+	discoveredRoutes.sort(compareRoutes);
+	return {
+		dir: routeDirectory.dir,
+		absoluteDir: routeDirectory.absoluteDir,
+		prefix: routeDirectory.prefix,
+		routes: discoveredRoutes
+	};
+}
+//#endregion
+export { buildSendEmailConfig as C, buildVersionMetadataConfig as D, buildTailConsumersConfig as E, buildWorkerLoadersConfig as O, buildSecretsStoreConfig as S, buildStreamingTailConsumersConfig as T, buildMtlsCertificatesConfig as _, hasServiceBindings as a, buildQueueProducers as b, buildAiSearchInstancesConfig as c, buildArtifactsConfig as d, buildDispatchNamespacesConfig as f, buildMediaConfig as g, buildImagesConfig as h, hasCrossWorkerDOs as i, buildWorkflowsConfig as k, buildAiSearchNamespacesConfig as l, buildHyperdrivesConfig as m, getRouteDirectoryCandidate as n, resolveDOBindings as o, buildFlagshipConfig as p, clearBundleCache as r, resolveServiceBindings as s, discoverRoutes as t, buildAnalyticsEngineConfig as u, buildPipelinesConfig as v, buildStreamConfig as w, buildRateLimitsConfig as x, buildQueueConsumers as y };