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

package/dist/index-5hy7jmv3.js

@@ -1,890 +0,0 @@
-import {
-  discoverDurableObjectFiles
-} from "./index-cv4cvrxe.js";
-import {
-  findFiles
-} from "./index-5dkjffqz.js";
-import {
-  transformDurableObject
-} from "./index-4mmpccrb.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/defaults.ts
-function createWorkerdBundlerDefaults() {
-  return {
-    platform: "browser",
-    defaultTsconfigMode: "if-present",
-    sourcemap: false,
-    minify: false
-  };
-}
-
-// 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 {}
-  }
-  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 defaults = createWorkerdBundlerDefaults();
-  const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
-    cwd: options.cwd,
-    inputFile: options.inputFile,
-    outFile: options.outFile,
-    alias,
-    ...defaults,
-    platform: "browser",
-    rolldownOptions: options.rolldownOptions,
-    sourcemap: options.sourcemap ?? defaults.sourcemap,
-    minify: options.minify ?? defaults.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 { dirname as dirname2, relative, resolve as resolve3 } 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 discovered = [];
-  const files = await discoverDurableObjectFiles(cwd, pattern);
-  for (const [filePath, classNames] of files) {
-    for (const className of classNames) {
-      discovered.push({
-        filePath,
-        className,
-        bindingName: classToBindingName(className)
-      });
-    }
-  }
-  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 defaults = createWorkerdBundlerDefaults();
-  const { inputOptions, outputOptions } = resolveWorkerCompatibleRolldownConfig({
-    cwd,
-    inputFile: virtualEntryId,
-    outFile,
-    ...defaults,
-    platform: "neutral",
-    alias: {
-      debug: debugShimPath
-    },
-    rolldownOptions: {
-      ...userRolldownOptions,
-      plugins: mergedPlugins
-    },
-    sourcemap: bundleOptions?.sourcemap ?? defaults.sourcemap,
-    minify: bundleOptions?.minify ?? defaults.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 };