devflare 1.0.0-next.2 → 1.0.0-next.21

package/dist/index-sx49e8x9.js

@@ -0,0 +1,884 @@
+import {
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses,
+  transformDurableObject
+} from "./index-vhqww6tt.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/bundler/worker-bundler.ts
+import { fileURLToPath } from "node:url";
+import { dirname, resolve as resolve2 } from "pathe";
+
+// src/bundler/rolldown-shared.ts
+import { existsSync } from "node:fs";
+import { resolve } from "pathe";
+
+// src/bundler/worker-compat.ts
+import MagicString from "magic-string";
+import ts from "typescript";
+var WORKER_DYNAMIC_IMPORT_ERROR = "Devflare worker bundles cannot contain unresolved dynamic import() expressions because Miniflare/workerd reject dynamic module specifiers";
+function getScriptKind(id) {
+  if (id.endsWith(".tsx")) {
+    return ts.ScriptKind.TSX;
+  }
+  if (id.endsWith(".ts") || id.endsWith(".mts") || id.endsWith(".cts")) {
+    return ts.ScriptKind.TS;
+  }
+  if (id.endsWith(".jsx")) {
+    return ts.ScriptKind.JSX;
+  }
+  return ts.ScriptKind.JS;
+}
+function createSourceFile(code, id) {
+  return ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true, getScriptKind(id));
+}
+function hasExportModifier(node) {
+  if (!ts.canHaveModifiers(node)) {
+    return false;
+  }
+  return ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isConstVariableStatement(statement) {
+  return ts.isVariableStatement(statement) && (statement.declarationList.flags & ts.NodeFlags.Const) !== 0;
+}
+function quoteString(value) {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, `\\'`)}'`;
+}
+function resolveLiteralImportSpecifier(expression, constStrings) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isParenthesizedExpression(expression)) {
+    return resolveLiteralImportSpecifier(expression.expression, constStrings);
+  }
+  if (ts.isIdentifier(expression)) {
+    return constStrings.get(expression.text) ?? null;
+  }
+  return null;
+}
+function collectTopLevelConstStrings(sourceFile) {
+  const constStrings = new Map;
+  for (const statement of sourceFile.statements) {
+    if (!isConstVariableStatement(statement)) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+        continue;
+      }
+      const literal = resolveLiteralImportSpecifier(declaration.initializer, constStrings);
+      if (literal !== null) {
+        constStrings.set(declaration.name.text, literal);
+      }
+    }
+  }
+  return constStrings;
+}
+function unwrapDynamicImportExpression(expression) {
+  if (ts.isParenthesizedExpression(expression)) {
+    return unwrapDynamicImportExpression(expression.expression);
+  }
+  if (ts.isAwaitExpression(expression)) {
+    return unwrapDynamicImportExpression(expression.expression);
+  }
+  if (!ts.isCallExpression(expression) || expression.expression.kind !== ts.SyntaxKind.ImportKeyword) {
+    return null;
+  }
+  return expression;
+}
+function getWrapperBodyExpression(body) {
+  if (!body) {
+    return null;
+  }
+  if (!ts.isBlock(body)) {
+    return body;
+  }
+  if (body.statements.length !== 1) {
+    return null;
+  }
+  const [statement] = body.statements;
+  if (!ts.isReturnStatement(statement) || !statement.expression) {
+    return null;
+  }
+  return statement.expression;
+}
+function createImportWrapper(name, parameterName, body, sourceFile) {
+  const bodyExpression = getWrapperBodyExpression(body);
+  if (!bodyExpression) {
+    return null;
+  }
+  const importExpression = unwrapDynamicImportExpression(bodyExpression);
+  if (!importExpression || importExpression.arguments.length < 1) {
+    return null;
+  }
+  const [importArgument] = importExpression.arguments;
+  if (!ts.isIdentifier(importArgument) || importArgument.text !== parameterName || !body) {
+    return null;
+  }
+  return {
+    name,
+    parameterName,
+    bodyStart: body.getStart(sourceFile),
+    bodyEnd: body.getEnd(),
+    specifiers: new Set,
+    hasUnsupportedCalls: false
+  };
+}
+function collectImportWrappers(sourceFile) {
+  const wrappers = new Map;
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name && !hasExportModifier(statement) && statement.parameters.length === 1 && ts.isIdentifier(statement.parameters[0]?.name)) {
+      const wrapper = createImportWrapper(statement.name.text, statement.parameters[0].name.text, statement.body, sourceFile);
+      if (wrapper) {
+        wrappers.set(wrapper.name, wrapper);
+      }
+    }
+    if (!isConstVariableStatement(statement) || hasExportModifier(statement)) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) {
+        continue;
+      }
+      if (!ts.isArrowFunction(declaration.initializer) && !ts.isFunctionExpression(declaration.initializer)) {
+        continue;
+      }
+      if (declaration.initializer.parameters.length !== 1 || !ts.isIdentifier(declaration.initializer.parameters[0]?.name)) {
+        continue;
+      }
+      const wrapper = createImportWrapper(declaration.name.text, declaration.initializer.parameters[0].name.text, declaration.initializer.body, sourceFile);
+      if (wrapper) {
+        wrappers.set(wrapper.name, wrapper);
+      }
+    }
+  }
+  return wrappers;
+}
+function collectWrapperCallSpecifiers(sourceFile, wrappers, constStrings) {
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const wrapper = wrappers.get(node.expression.text);
+      if (wrapper) {
+        if (node.arguments.length !== 1) {
+          wrapper.hasUnsupportedCalls = true;
+        } else {
+          const specifier = resolveLiteralImportSpecifier(node.arguments[0], constStrings);
+          if (specifier === null) {
+            wrapper.hasUnsupportedCalls = true;
+          } else {
+            wrapper.specifiers.add(specifier);
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+}
+function createImportIdentifier(specifierToIdentifier, specifier) {
+  const existing = specifierToIdentifier.get(specifier);
+  if (existing) {
+    return existing;
+  }
+  const identifier = `__devflareDynamicImport${specifierToIdentifier.size}`;
+  specifierToIdentifier.set(specifier, identifier);
+  return identifier;
+}
+function buildWrapperBody(wrapper, specifierToIdentifier) {
+  const cases = Array.from(wrapper.specifiers).sort((left, right) => left.localeCompare(right)).map((specifier) => {
+    const identifier = createImportIdentifier(specifierToIdentifier, specifier);
+    return `		case ${quoteString(specifier)}:
+			return Promise.resolve(${identifier})`;
+  }).join(`
+`);
+  return `{
+		switch (${wrapper.parameterName}) {
+${cases}
+			default:
+				return Promise.reject(new Error(\`Unsupported dynamic import in Devflare worker bundle: \${${wrapper.parameterName}}\`))
+		}
+	}`;
+}
+function findContainingWrapper(callExpression, wrappers, sourceFile) {
+  const start = callExpression.getStart(sourceFile);
+  const end = callExpression.getEnd();
+  for (const wrapper of wrappers) {
+    if (start >= wrapper.bodyStart && end <= wrapper.bodyEnd) {
+      return wrapper;
+    }
+  }
+  return null;
+}
+function transformWorkerDynamicImports(code, id) {
+  const sourceFile = createSourceFile(code, id);
+  const constStrings = collectTopLevelConstStrings(sourceFile);
+  const wrappers = collectImportWrappers(sourceFile);
+  collectWrapperCallSpecifiers(sourceFile, wrappers, constStrings);
+  const transformableWrappers = Array.from(wrappers.values()).filter((wrapper) => {
+    return !wrapper.hasUnsupportedCalls && wrapper.specifiers.size > 0;
+  });
+  const replacements = [];
+  const specifierToIdentifier = new Map;
+  function visit(node) {
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const containingWrapper = findContainingWrapper(node, transformableWrappers, sourceFile);
+      if (containingWrapper && node.arguments.length === 1 && ts.isIdentifier(node.arguments[0]) && node.arguments[0].text === containingWrapper.parameterName) {
+        return;
+      }
+      const [argument] = node.arguments;
+      if (!argument) {
+        return;
+      }
+      const specifier = resolveLiteralImportSpecifier(argument, constStrings);
+      if (specifier !== null) {
+        replacements.push({
+          start: node.getStart(sourceFile),
+          end: node.getEnd(),
+          text: `Promise.resolve(${createImportIdentifier(specifierToIdentifier, specifier)})`
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (replacements.length === 0 && transformableWrappers.length === 0) {
+    return null;
+  }
+  const s = new MagicString(code);
+  for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+    s.overwrite(replacement.start, replacement.end, replacement.text);
+  }
+  for (const wrapper of transformableWrappers.sort((left, right) => right.bodyStart - left.bodyStart)) {
+    s.overwrite(wrapper.bodyStart, wrapper.bodyEnd, buildWrapperBody(wrapper, specifierToIdentifier));
+  }
+  if (specifierToIdentifier.size > 0) {
+    const importBlock = Array.from(specifierToIdentifier.entries()).map(([specifier, identifier]) => `import * as ${identifier} from ${quoteString(specifier)}`).join(`
+`);
+    if (code.startsWith("#!")) {
+      const newlineIndex = code.indexOf(`
+`);
+      if (newlineIndex === -1) {
+        s.appendRight(code.length, `
+${importBlock}
+`);
+      } else {
+        s.appendLeft(newlineIndex + 1, `${importBlock}
+`);
+      }
+    } else {
+      s.appendLeft(0, `${importBlock}
+`);
+    }
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({
+      source: id,
+      file: `${id}.map`,
+      includeContent: true
+    })
+  };
+}
+function findDynamicImportCalls(sourceFile) {
+  const calls = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      calls.push(node);
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return calls;
+}
+async function assertWorkerBundleHasNoDynamicImports(bundlePath) {
+  const fs = await import("node:fs/promises");
+  const code = await fs.readFile(bundlePath, "utf-8");
+  const sourceFile = createSourceFile(code, bundlePath);
+  const dynamicImports = findDynamicImportCalls(sourceFile);
+  if (dynamicImports.length === 0) {
+    return;
+  }
+  const examples = dynamicImports.slice(0, 3).map((callExpression) => {
+    const start = callExpression.getStart(sourceFile);
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+    const snippet = code.slice(start, callExpression.getEnd()).replace(/\s+/g, " ").trim();
+    return `- ${line + 1}:${character + 1} ${snippet}`;
+  }).join(`
+`);
+  throw new Error([
+    WORKER_DYNAMIC_IMPORT_ERROR,
+    `Bundle: ${bundlePath}`,
+    `Examples:
+${examples}`,
+    "Devflare can normalize literal import() calls and simple helper wrappers whose call sites are literal strings, but truly runtime-computed specifiers must be converted to static imports for worker bundles."
+  ].join(`
+
+`));
+}
+function createWorkerDynamicImportPlugin() {
+  return {
+    name: "devflare-worker-dynamic-imports",
+    transform(code, id) {
+      const result = transformWorkerDynamicImports(code, id);
+      return result ?? null;
+    }
+  };
+}
+
+// src/bundler/rolldown-shared.ts
+var DEFAULT_EXTERNAL_MODULES = [
+  /^cloudflare:/,
+  /^node:/,
+  "buffer",
+  "crypto",
+  "events",
+  "http",
+  "https",
+  "net",
+  "os",
+  "path",
+  "stream",
+  "tls",
+  "url",
+  "util",
+  "zlib",
+  "fs",
+  "child_process",
+  "async_hooks",
+  "querystring",
+  "string_decoder",
+  "assert",
+  "dns"
+];
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function matchesExternalPattern(pattern, id) {
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(id);
+  }
+  return pattern === id;
+}
+function matchesExternalOption(option, id, parentId, isResolved) {
+  if (!option) {
+    return false;
+  }
+  if (typeof option === "function") {
+    return option(id, parentId, isResolved) ?? false;
+  }
+  return toArray(option).some((pattern) => matchesExternalPattern(pattern, id));
+}
+function mergeExternalOptions(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  if (typeof base !== "function" && typeof user !== "function") {
+    return [...toArray(base), ...toArray(user)];
+  }
+  return (id, parentId, isResolved) => {
+    return matchesExternalOption(base, id, parentId, isResolved) || matchesExternalOption(user, id, parentId, isResolved) || false;
+  };
+}
+function mergePluginOptions(base, user) {
+  if (!base) {
+    return user;
+  }
+  if (!user) {
+    return base;
+  }
+  return [base, user];
+}
+function aliasKey(find) {
+  return find instanceof RegExp ? `re:${find.source}:${find.flags}` : `str:${find}`;
+}
+function normalizeAliasEntries(input) {
+  if (!input) {
+    return [];
+  }
+  if (Array.isArray(input)) {
+    return input.filter((entry) => {
+      return Boolean(entry) && typeof entry.replacement === "string";
+    });
+  }
+  return Object.entries(input).filter(([, replacement]) => typeof replacement === "string").map(([find, replacement]) => ({ find, replacement }));
+}
+function mergeAliases(userAliases, frameworkDefaults) {
+  const userKeys = new Set(userAliases.map((entry) => aliasKey(entry.find)));
+  const frameworkFiltered = frameworkDefaults.filter((entry) => {
+    return !userKeys.has(aliasKey(entry.find));
+  });
+  const seenUserKeys = new Set;
+  const dedupedUser = [];
+  for (let index = userAliases.length - 1;index >= 0; index--) {
+    const entry = userAliases[index];
+    const key = aliasKey(entry.find);
+    if (seenUserKeys.has(key)) {
+      continue;
+    }
+    seenUserKeys.add(key);
+    dedupedUser.unshift(entry);
+  }
+  return [...frameworkFiltered, ...dedupedUser];
+}
+function aliasEntriesToRolldownRecord(entries) {
+  const record = {};
+  for (const entry of entries) {
+    if (entry.find instanceof RegExp) {
+      continue;
+    }
+    record[entry.find] = entry.replacement;
+  }
+  return record;
+}
+function mergeResolveOptions(base, user) {
+  if (!base && !user) {
+    return;
+  }
+  const frameworkEntries = normalizeAliasEntries(base?.alias);
+  const userEntries = normalizeAliasEntries(user?.alias);
+  const mergedEntries = mergeAliases(userEntries, frameworkEntries);
+  const mergedAlias = aliasEntriesToRolldownRecord(mergedEntries);
+  return {
+    ...user ?? {},
+    ...base ?? {},
+    ...mergedEntries.length > 0 ? { alias: mergedAlias } : {}
+  };
+}
+function resolveTsconfigOption(options) {
+  if (options.userTsconfig) {
+    return { tsconfig: options.userTsconfig };
+  }
+  const defaultTsconfigPath = resolve(options.cwd, "tsconfig.json");
+  if (options.defaultMode === "always" || existsSync(defaultTsconfigPath)) {
+    return { tsconfig: defaultTsconfigPath };
+  }
+  return {};
+}
+async function ensureDebugShim(outDir) {
+  const fs = await import("node:fs/promises");
+  const debugShimCode = `
+// Debug module shim for local development
+const createDebug = (namespace) => {
+	const logger = (...args) => {
+		if (createDebug.enabled) console.debug(\`[\${namespace}]\`, ...args)
+	}
+	logger.enabled = false
+	logger.namespace = namespace
+	logger.extend = (sub) => createDebug(\`\${namespace}:\${sub}\`)
+	return logger
+}
+createDebug.enabled = false
+createDebug.formatters = {}
+export default createDebug
+`;
+  const debugShimPath = resolve(outDir, "_debug_shim.js");
+  await fs.writeFile(debugShimPath, debugShimCode, "utf-8");
+  return debugShimPath;
+}
+function resolveWorkerCompatibleRolldownConfig(options) {
+  const {
+    output: userOutputOptions,
+    input: _ignoredInput,
+    cwd: _ignoredCwd,
+    platform: _ignoredPlatform,
+    target: _ignoredTarget,
+    watch: _ignoredWatch,
+    external: userExternal,
+    plugins: userPlugins,
+    resolve: userResolve,
+    tsconfig: userTsconfig,
+    ...userInputOptions
+  } = options.rolldownOptions ?? {};
+  const {
+    codeSplitting: _ignoredCodeSplitting,
+    dir: _ignoredDir,
+    file: _ignoredFile,
+    format: _ignoredFormat,
+    inlineDynamicImports: _ignoredInlineDynamicImports,
+    ...safeUserOutputOptions
+  } = userOutputOptions ?? {};
+  return {
+    inputOptions: {
+      ...userInputOptions,
+      input: options.inputFile,
+      cwd: options.cwd,
+      platform: options.platform,
+      ...resolveTsconfigOption({
+        cwd: options.cwd,
+        userTsconfig,
+        defaultMode: options.defaultTsconfigMode
+      }),
+      external: mergeExternalOptions(DEFAULT_EXTERNAL_MODULES, userExternal),
+      plugins: mergePluginOptions(createWorkerDynamicImportPlugin(), userPlugins),
+      resolve: mergeResolveOptions(options.alias ? {
+        alias: options.alias
+      } : undefined, userResolve)
+    },
+    outputOptions: {
+      ...safeUserOutputOptions,
+      file: options.outFile,
+      format: "esm",
+      sourcemap: safeUserOutputOptions.sourcemap ?? options.sourcemap ?? false,
+      minify: safeUserOutputOptions.minify ?? options.minify,
+      codeSplitting: false,
+      ...options.inlineDynamicImports !== undefined ? { inlineDynamicImports: options.inlineDynamicImports } : {}
+    }
+  };
+}
+async function writeWorkerCompatibleBundle(options) {
+  const { rolldown } = await import("rolldown");
+  const bundle = await rolldown(options.inputOptions);
+  try {
+    await bundle.write(options.outputOptions);
+    await assertWorkerBundleHasNoDynamicImports(options.outFile);
+  } finally {
+    await bundle.close();
+  }
+}
+
+// src/bundler/worker-bundler.ts
+async function resolveInternalModuleEntry(relativeCandidates) {
+  const fs = await import("node:fs/promises");
+  const currentFileDir = dirname(fileURLToPath(import.meta.url));
+  for (const candidate of relativeCandidates) {
+    const absolutePath = resolve2(currentFileDir, candidate);
+    try {
+      await fs.access(absolutePath);
+      return absolutePath;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function resolveInternalAliasMap(outDir) {
+  const debugShimPath = await ensureDebugShim(outDir);
+  const runtimeEntry = await resolveInternalModuleEntry([
+    "../runtime/index.ts",
+    "../runtime/index.js"
+  ]);
+  const packageEntry = await resolveInternalModuleEntry([
+    "../browser.ts",
+    "../browser.js"
+  ]);
+  return {
+    debug: debugShimPath,
+    ...runtimeEntry ? { "devflare/runtime": runtimeEntry } : {},
+    ...packageEntry ? { devflare: packageEntry } : {}
+  };
+}
+async function bundleWorkerEntry(options) {
+  const fs = await import("node:fs/promises");
+  const outDir = dirname(options.outFile);
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.rm(options.outFile, { force: true });
+  await fs.rm(`${options.outFile}.map`, { force: true });
+  const alias = await resolveInternalAliasMap(outDir);
+  const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
+    cwd: options.cwd,
+    inputFile: options.inputFile,
+    outFile: options.outFile,
+    alias,
+    platform: "browser",
+    rolldownOptions: options.rolldownOptions,
+    sourcemap: options.sourcemap,
+    minify: options.minify,
+    defaultTsconfigMode: "if-present"
+  });
+  options.logger?.debug(`Bundling main worker → ${options.outFile}`);
+  await writeWorkerCompatibleBundle({
+    inputOptions,
+    outputOptions,
+    outFile: options.outFile
+  });
+  return options.outFile;
+}
+
+// src/bundler/do-bundler.ts
+import { resolve as resolve3, dirname as dirname2, relative } from "pathe";
+import picomatch from "picomatch";
+function classToBindingName(className) {
+  return className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+async function discoverDOs(cwd, pattern) {
+  const fs = await import("node:fs/promises");
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findDurableObjectClasses(code);
+      for (const className of classNames) {
+        discovered.push({
+          filePath,
+          className,
+          bindingName: classToBindingName(className)
+        });
+      }
+    } catch {}
+  }
+  return discovered;
+}
+function stripDecoratorSyntax(code) {
+  let result = code;
+  result = result.replace(/@durableObject\s*\([^)]*\)\s*\n?\s*(?=export\s+class)/g, "");
+  result = result.replace(/import\s*\{([^}]*)\bdurableObject\b[^}]*\}\s*from\s*['"]devflare\/runtime['"]\s*;?/g, (match, imports) => {
+    const cleanedImports = imports.split(",").map((s) => s.trim()).filter((s) => !s.startsWith("durableObject")).join(", ");
+    if (cleanedImports.trim() === "") {
+      return "";
+    }
+    return `import { ${cleanedImports} } from 'devflare/runtime'`;
+  });
+  return result;
+}
+async function bundleDOFile(sourcePath, className, outDir, cwd, bundleOptions) {
+  const fs = await import("node:fs/promises");
+  await fs.mkdir(outDir, { recursive: true });
+  const sourceCode = await fs.readFile(sourcePath, "utf-8");
+  const transformedCode = (await transformDurableObject(sourceCode, sourcePath))?.code ?? stripDecoratorSyntax(sourceCode);
+  const entryCode = `${transformedCode}
+
+// Default export for worker (required by Miniflare)
+export default {
+	async fetch(request) {
+		return new Response('DO Worker for ${className}', { status: 200 });
+	}
+};
+`;
+  const virtualEntryId = resolve3(dirname2(sourcePath), `.devflare-do-${className}.virtual.ts`);
+  const classOutDir = resolve3(outDir, className);
+  try {
+    await fs.rm(classOutDir, { recursive: true, force: true });
+  } catch {}
+  await fs.mkdir(classOutDir, { recursive: true });
+  const debugShimPath = await ensureDebugShim(outDir);
+  const virtualEntryPlugin = {
+    name: "devflare-do-virtual-entry",
+    resolveId(id) {
+      if (id === virtualEntryId) {
+        return virtualEntryId;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === virtualEntryId) {
+        return entryCode;
+      }
+      return null;
+    }
+  };
+  const userRolldownOptions = bundleOptions?.rolldownOptions;
+  const userPlugins = userRolldownOptions?.plugins;
+  const mergedPlugins = userPlugins === undefined ? [virtualEntryPlugin] : Array.isArray(userPlugins) ? [virtualEntryPlugin, ...userPlugins] : [virtualEntryPlugin, userPlugins];
+  const outFile = resolve3(classOutDir, "index.js");
+  const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
+    cwd,
+    inputFile: virtualEntryId,
+    outFile,
+    platform: "neutral",
+    alias: {
+      debug: debugShimPath
+    },
+    rolldownOptions: {
+      ...userRolldownOptions,
+      plugins: mergedPlugins
+    },
+    sourcemap: bundleOptions?.sourcemap,
+    minify: bundleOptions?.minify,
+    inlineDynamicImports: true,
+    defaultTsconfigMode: "always"
+  });
+  await writeWorkerCompatibleBundle({
+    inputOptions,
+    outputOptions,
+    outFile
+  });
+  return resolve3(classOutDir, "index.js");
+}
+async function bundleAllDOs(discovered, outDir, cwd, logger, bundleOptions) {
+  const fs = await import("node:fs/promises");
+  const bundles = new Map;
+  const classes = new Map;
+  const sourceFiles = new Map;
+  const errors = [];
+  for (const do_ of discovered) {
+    const existing = sourceFiles.get(do_.filePath) || [];
+    existing.push(do_.className);
+    sourceFiles.set(do_.filePath, existing);
+  }
+  for (const do_ of discovered) {
+    try {
+      logger?.debug(`Bundling ${do_.className} from ${do_.filePath}`);
+      const outFile = await bundleDOFile(do_.filePath, do_.className, outDir, cwd, bundleOptions);
+      bundles.set(do_.bindingName, outFile);
+      classes.set(do_.bindingName, do_.className);
+      logger?.debug(`  → ${outFile}`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      errors.push(err);
+      logger?.error(`Failed to bundle ${do_.className}:`, err.message);
+    }
+  }
+  return { bundles, classes, sourceFiles, errors };
+}
+function createDOBundler(options) {
+  const { cwd, pattern, outDir, logger, onRebuild, rolldownOptions, sourcemap, minify } = options;
+  let result = {
+    bundles: new Map,
+    classes: new Map,
+    sourceFiles: new Map,
+    errors: []
+  };
+  let watcher = null;
+  let chokidarWatcher = null;
+  async function build() {
+    const discovered = await discoverDOs(cwd, pattern);
+    if (discovered.length === 0) {
+      logger?.debug("No DOs found matching pattern:", pattern);
+      return result;
+    }
+    logger?.info(`Found ${discovered.length} Durable Object(s)`);
+    for (const do_ of discovered) {
+      logger?.info(`  • ${do_.className} → ${do_.bindingName}`);
+    }
+    result = await bundleAllDOs(discovered, outDir, cwd, logger, {
+      rolldownOptions,
+      sourcemap,
+      minify
+    });
+    if (result.errors.length === 0) {
+      logger?.success(`Bundled ${result.bundles.size} DO(s) to ${outDir}`);
+    }
+    return result;
+  }
+  async function watch() {
+    const chokidar = await import("chokidar");
+    const files = await findFiles(pattern, { cwd });
+    let dirsToWatch;
+    if (files.length > 0) {
+      dirsToWatch = [...new Set(files.map((f) => dirname2(f)))];
+    } else {
+      const patternDir = dirname2(pattern);
+      const absolutePatternDir = resolve3(cwd, patternDir === "." ? "" : patternDir) || cwd;
+      dirsToWatch = [absolutePatternDir];
+      logger?.debug(`No DO files yet, watching pattern directory: ${absolutePatternDir}`);
+    }
+    logger?.info(`Watching ${files.length} DO file(s) in ${dirsToWatch.length} director(ies)...`);
+    const isWindows = process.platform === "win32";
+    chokidarWatcher = chokidar.watch(dirsToWatch, {
+      ignoreInitial: true,
+      usePolling: isWindows,
+      interval: isWindows ? 300 : undefined,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      },
+      depth: 0
+    });
+    const normalizePath = (p) => {
+      let normalized = p.replace(/\\/g, "/");
+      if (isWindows && /^[a-zA-Z]:/.test(normalized)) {
+        normalized = normalized[0].toLowerCase() + normalized.slice(1);
+      }
+      return normalized;
+    };
+    const isMatch = picomatch(pattern, {
+      dot: true,
+      matchBase: false
+    });
+    const matchesPattern = (filePath) => {
+      const normalizedPath = normalizePath(filePath);
+      const relativePath = relative(normalizePath(cwd), normalizedPath);
+      return isMatch(relativePath);
+    };
+    let isRebuilding = false;
+    let pendingRebuild = null;
+    let rebuildTimeout = null;
+    const scheduleRebuild = (changedPath) => {
+      if (rebuildTimeout) {
+        clearTimeout(rebuildTimeout);
+      }
+      rebuildTimeout = setTimeout(() => {
+        triggerRebuild(changedPath);
+      }, 150);
+    };
+    const triggerRebuild = async (changedPath) => {
+      if (isRebuilding) {
+        pendingRebuild = changedPath;
+        logger?.debug(`Rebuild already in progress, queuing: ${changedPath}`);
+        return;
+      }
+      isRebuilding = true;
+      try {
+        logger?.info(`DO file changed: ${changedPath}`);
+        logger?.info("Rebuilding DOs...");
+        const startTime = Date.now();
+        result = await build();
+        const elapsed = Date.now() - startTime;
+        logger?.success(`DO rebuild complete (${elapsed}ms)`);
+        await onRebuild?.(result);
+      } catch (error) {
+        logger?.error("DO rebuild failed:", error);
+      } finally {
+        isRebuilding = false;
+        if (pendingRebuild) {
+          const nextPath = pendingRebuild;
+          pendingRebuild = null;
+          triggerRebuild(nextPath);
+        }
+      }
+    };
+    chokidarWatcher.on("change", (filePath) => {
+      if (matchesPattern(filePath)) {
+        logger?.debug(`File changed: ${filePath}`);
+        scheduleRebuild(filePath);
+      }
+    });
+    chokidarWatcher.on("add", (filePath) => {
+      if (matchesPattern(filePath)) {
+        logger?.debug(`File added: ${filePath}`);
+        scheduleRebuild(filePath);
+      }
+    });
+    chokidarWatcher.on("unlink", (filePath) => {
+      if (matchesPattern(filePath)) {
+        logger?.debug(`File removed: ${filePath}`);
+        scheduleRebuild(filePath);
+      }
+    });
+    chokidarWatcher.on("ready", () => {
+      logger?.info("DO file watcher ready");
+    });
+    chokidarWatcher.on("error", (error) => {
+      logger?.error("DO file watcher error:", error);
+    });
+  }
+  async function close() {
+    if (watcher) {
+      await watcher.close();
+      watcher = null;
+    }
+    if (chokidarWatcher) {
+      await chokidarWatcher.close();
+      chokidarWatcher = null;
+    }
+  }
+  function getResult() {
+    return result;
+  }
+  return {
+    build,
+    watch,
+    close,
+    getResult
+  };
+}
+export { createDOBundler, bundleWorkerEntry };