devflare 1.0.0-next.3 → 1.0.0-next.30

package/dist/vite/plugin-transform.d.ts

@@ -0,0 +1,41 @@
+interface TransformResult {
+    code: string;
+    map?: any;
+}
+export interface RunDevflareTransformOptions {
+    doTransforms: boolean;
+}
+/**
+ * Returns `true` when devflare may rewrite the given module. Skips
+ * `node_modules` and any file that isn't a `.ts`/`.tsx`/`.js`.
+ */
+export declare function isTransformCandidate(id: string): boolean;
+/**
+ * Worker-entrypoint instrumentation step.
+ *
+ * Only handles `worker.ts` / `worker.js` files and only when
+ * `shouldTransformWorker` accepts them. Returns `null` when this step does
+ * not apply, so the caller can fall through to other transforms.
+ */
+export declare function runWorkerEntryTransform(code: string, id: string): Promise<TransformResult | null>;
+/**
+ * Durable Object class transform step.
+ *
+ * Only runs when the user opted in via `doTransforms` and the source mentions
+ * `DurableObject` or the `@durableObject` decorator. Returns `null` when this
+ * step does not apply.
+ */
+export declare function runDurableObjectTransform(code: string, id: string, options: RunDevflareTransformOptions): Promise<TransformResult | null>;
+/**
+ * Apply devflare's source-level transforms to a single module.
+ *
+ * Order:
+ * 1. Worker-entrypoint instrumentation (`runWorkerEntryTransform`)
+ * 2. Durable Object class transform (`runDurableObjectTransform`)
+ *
+ * Returns `null` when no transform applies, mirroring Vite's transform-hook
+ * contract.
+ */
+export declare function runDevflareTransform(code: string, id: string, options: RunDevflareTransformOptions): Promise<TransformResult | null>;
+export {};
+//# sourceMappingURL=plugin-transform.d.ts.map

package/dist/vite/plugin-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-transform.d.ts","sourceRoot":"","sources":["../../src/vite/plugin-transform.ts"],"names":[],"mappings":"AAQA,UAAU,eAAe;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,GAAG,CAAA;CACT;AAED,MAAM,WAAW,2BAA2B;IAC3C,YAAY,EAAE,OAAO,CAAA;CACrB;AAID;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC5C,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACR,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAqBjC;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC9C,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,2BAA2B,GAClC,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAQjC;AAED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACzC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,2BAA2B,GAClC,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAOjC"}

package/dist/vite/plugin.d.ts

@@ -1,5 +1,7 @@
 import type { Plugin } from 'vite';
-import { type WranglerConfig } from '../config/compiler';
+import type { WranglerConfig } from '../config/compiler';
+import { type AuxiliaryWorkerConfig, type DODiscoveryResult } from './plugin-durable-objects';
+export type { AuxiliaryWorkerConfig, DODiscoveryResult };
 export interface DevflarePluginOptions {
     /**
      * Path to devflare.config.ts
@@ -52,20 +54,13 @@ export interface DevflarePluginContext {
      * Pass to @cloudflare/vite-plugin's auxiliaryWorkers option
      */
     auxiliaryWorkerConfig: AuxiliaryWorkerConfig | null;
+    auxiliaryWorkerConfigs: AuxiliaryWorkerConfig[];
+    serviceWorkerVirtualModules: Map<string, string>;
     /**
      * Discovered DO files and their classes
      */
     durableObjects: DODiscoveryResult | null;
 }
-export interface DODiscoveryResult {
-    /** Map of file path → array of class names */
-    files: Map<string, string[]>;
-    /** Worker name for the auxiliary DO worker */
-    workerName: string;
-}
-export interface AuxiliaryWorkerConfig {
-    config: Record<string, unknown>;
-}
 /**
  * Get the compiled config context
  * Can be used by other plugins or CLI commands
@@ -93,8 +88,8 @@ export declare function getPluginContext(): DevflarePluginContext;
  *       // Access context after configResolved
  *       cloudflare({
  *         config: getPluginContext().cloudflareConfig,
- *         auxiliaryWorkers: getPluginContext().auxiliaryWorkerConfig
- *           ? [getPluginContext().auxiliaryWorkerConfig]
+ *         auxiliaryWorkers: getPluginContext().auxiliaryWorkerConfigs.length > 0
+ *           ? getPluginContext().auxiliaryWorkerConfigs
  *           : undefined
  *       })
  *     ]
@@ -104,35 +99,9 @@ export declare function getPluginContext(): DevflarePluginContext;
  */
 export declare function devflarePlugin(options?: DevflarePluginOptions): Plugin;
 /**
- * Get cloudflare config for programmatic use with @cloudflare/vite-plugin
- * Call this in vite.config.ts before setting up plugins
- */
-export declare function getCloudflareConfig(options?: {
-    cwd?: string;
-    configPath?: string;
-    environment?: string;
-}): Promise<Record<string, unknown>>;
-/**
- * Get auxiliary worker configs for Durable Objects
- * Use this when configuring @cloudflare/vite-plugin's auxiliaryWorkers option
- *
- * @example
- * ```ts
- * const { cloudflareConfig, auxiliaryWorkers } = await getDevflareConfigs()
- *
- * cloudflare({
- *   config: cloudflareConfig,
- *   auxiliaryWorkers
- * })
- * ```
+ * Get cloudflare config for programmatic use with @cloudflare/vite-plugin.
+ * Re-exported from `./plugin-programmatic`.
  */
-export declare function getDevflareConfigs(options?: {
-    cwd?: string;
-    configPath?: string;
-    environment?: string;
-}): Promise<{
-    cloudflareConfig: Record<string, unknown>;
-    auxiliaryWorkers: AuxiliaryWorkerConfig[];
-}>;
+export { getCloudflareConfig, getDevflareConfigs } from './plugin-programmatic';
 export default devflarePlugin;
 //# sourceMappingURL=plugin.d.ts.map

package/dist/vite/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vite/plugin.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAA;AAGjE,OAAO,EAIN,KAAK,cAAc,EACnB,MAAM,oBAAoB,CAAA;AAW3B,MAAM,WAAW,qBAAqB;IACrC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,cAAc,EAAE,cAAc,GAAG,IAAI,CAAA;IAErC;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAEhD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAA;IAEnD;;OAEG;IACH,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACxC;AAED,MAAM,WAAW,iBAAiB;IACjC,gDAA8C;IAC9C,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC5B,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAWD;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD;AA8FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAmR1E;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,GAAE;IAClD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,GAAE;IACjD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,gBAAgB,EAAE,qBAAqB,EAAE,CAAA;CACzC,CAAC,CAiCD;AAGD,eAAe,cAAc,CAAA"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vite/plugin.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,MAAM,CAAA;AAGjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAKN,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,MAAM,0BAA0B,CAAA;AAejC,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,CAAA;AAKxD,MAAM,WAAW,qBAAqB;IACrC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IAEtB;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IAErB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,cAAc,EAAE,cAAc,GAAG,IAAI,CAAA;IAErC;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAEhD;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IAEnB;;;OAGG;IACH,qBAAqB,EAAE,qBAAqB,GAAG,IAAI,CAAA;IACnD,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;IAC/C,2BAA2B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEhD;;OAEG;IACH,cAAc,EAAE,iBAAiB,GAAG,IAAI,CAAA;CACxC;AAqED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,qBAAqB,CAExD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CA8H1E;AAED;;;GAGG;AACH,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;eAGhE,cAAc"}

package/dist/worker-55q6b8nc.js

@@ -0,0 +1,513 @@
+import {
+  findConfigPathsUnderDirectory,
+  formatSupportedConfigFilenames,
+  resolveConfigCandidatePath
+} from "./index-706k4606.js";
+import {
+  asOptionalString,
+  resolveCloudflareAccountId
+} from "./index-thwacc28.js";
+import {
+  account
+} from "./index-qmmqww7h.js";
+import"./index-11p28kxx.js";
+import"./index-3jme4hgw.js";
+import {
+  bold,
+  createCliTheme,
+  dim,
+  green,
+  logLine,
+  whiteDim,
+  yellow
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import"./index-15fpa5tx.js";
+import"./index-qwgr4q7s.js";
+import"./index-5yvpk954.js";
+import {
+  loadConfig,
+  normalizeDOBinding
+} from "./index-2sc756r1.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import"./index-c8p4njqy.js";
+import"./index-q8f4kawk.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/cli/commands/worker.ts
+import MagicString from "magic-string";
+import { basename, dirname, relative, resolve } from "pathe";
+function formatPathForLog(cwd, filePath) {
+  const relativePath = relative(cwd, filePath).replace(/\\/g, "/");
+  return relativePath && !relativePath.startsWith("..") ? relativePath : filePath;
+}
+async function loadConfigFromPath(configPath) {
+  return {
+    configPath,
+    config: await loadConfig({
+      cwd: dirname(configPath),
+      configFile: basename(configPath)
+    })
+  };
+}
+async function loadDiscoveredConfigs(cwd, explicitConfigPath) {
+  const candidatePaths = new Set;
+  const discoveredPaths = await findConfigPathsUnderDirectory(cwd);
+  for (const configPath of discoveredPaths) {
+    candidatePaths.add(configPath);
+  }
+  if (explicitConfigPath) {
+    candidatePaths.add(explicitConfigPath);
+  }
+  const loadedConfigs = [];
+  for (const configPath of [...candidatePaths].sort((left, right) => left.localeCompare(right))) {
+    try {
+      loadedConfigs.push(await loadConfigFromPath(configPath));
+    } catch (error) {
+      if (explicitConfigPath && explicitConfigPath === configPath) {
+        throw error;
+      }
+    }
+  }
+  return loadedConfigs;
+}
+function formatConfigChoices(matches, cwd) {
+  return matches.map((match) => `  - ${formatPathForLog(cwd, match.configPath)} (${match.config.name})`).join(`
+`);
+}
+function selectTargetConfig(loadedConfigs, cwd, oldName, newName, explicitConfigPath) {
+  if (loadedConfigs.length === 0) {
+    throw new Error(`Could not find ${formatSupportedConfigFilenames()} under ${cwd}.`);
+  }
+  if (explicitConfigPath) {
+    const target = loadedConfigs.find((candidate) => candidate.configPath === explicitConfigPath);
+    if (!target) {
+      throw new Error(`Could not load the selected config: ${explicitConfigPath}`);
+    }
+    if (target.config.name === oldName) {
+      return {
+        target,
+        localConfigAlreadyUpdated: false,
+        allConfigs: loadedConfigs
+      };
+    }
+    if (target.config.name === newName) {
+      return {
+        target,
+        localConfigAlreadyUpdated: true,
+        allConfigs: loadedConfigs
+      };
+    }
+    throw new Error(`The selected config uses \`${target.config.name}\`, not \`${oldName}\` or \`${newName}\`.`);
+  }
+  const matchingConfigs = loadedConfigs.filter((candidate) => {
+    return candidate.config.name === oldName || candidate.config.name === newName;
+  });
+  const oldMatches = matchingConfigs.filter((candidate) => candidate.config.name === oldName);
+  const newMatches = matchingConfigs.filter((candidate) => candidate.config.name === newName);
+  if (oldMatches.length === 1 && matchingConfigs.length === 1) {
+    return {
+      target: oldMatches[0],
+      localConfigAlreadyUpdated: false,
+      allConfigs: loadedConfigs
+    };
+  }
+  if (newMatches.length === 1 && matchingConfigs.length === 1) {
+    return {
+      target: newMatches[0],
+      localConfigAlreadyUpdated: true,
+      allConfigs: loadedConfigs
+    };
+  }
+  if (matchingConfigs.length === 0) {
+    throw new Error(`Could not find a matching devflare config under ${cwd}. Expected a config whose \`name\` is \`${oldName}\` or \`${newName}\`.`);
+  }
+  throw new Error(`Multiple matching devflare configs were found. Use --config to pick one explicitly.
+${formatConfigChoices(matchingConfigs, cwd)}`);
+}
+async function resolveAccountId(parsed, config) {
+  return resolveCloudflareAccountId({
+    explicitAccountId: asOptionalString(parsed.options.account),
+    configuredAccountId: config.accountId
+  });
+}
+function skipWhitespaceAndComments(source, start, end) {
+  let index = start;
+  while (index < end) {
+    const char = source[index];
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+    const nextIndex = consumeComment(source, index, end);
+    if (nextIndex !== null) {
+      index = nextIndex;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+function consumeQuotedLiteral(source, start, end) {
+  const quote = source[start];
+  let index = start + 1;
+  while (index < end) {
+    const char = source[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      return index + 1;
+    }
+    index++;
+  }
+  throw new Error("Unterminated string literal in devflare config.");
+}
+function consumeComment(source, start, end) {
+  if (source[start] !== "/") {
+    return null;
+  }
+  if (source[start + 1] === "/") {
+    let index = start + 2;
+    while (index < end && source[index] !== `
+`) {
+      index++;
+    }
+    return index;
+  }
+  if (source[start + 1] === "*") {
+    let index = start + 2;
+    while (index < end && !(source[index] === "*" && source[index + 1] === "/")) {
+      index++;
+    }
+    return Math.min(index + 2, end);
+  }
+  return null;
+}
+function findConfigObjectStart(source) {
+  const defineConfigIndex = source.indexOf("defineConfig");
+  if (defineConfigIndex >= 0) {
+    const parenIndex = source.indexOf("(", defineConfigIndex);
+    if (parenIndex >= 0) {
+      const objectIndex = source.indexOf("{", parenIndex);
+      if (objectIndex >= 0) {
+        return objectIndex;
+      }
+    }
+  }
+  const exportDefaultIndex = source.indexOf("export default");
+  if (exportDefaultIndex >= 0) {
+    const objectIndex = source.indexOf("{", exportDefaultIndex);
+    if (objectIndex >= 0) {
+      return objectIndex;
+    }
+  }
+  return -1;
+}
+function getRootPropertySlices(source, objectStart) {
+  const slices = [];
+  let curlyDepth = 1;
+  let squareDepth = 0;
+  let parenDepth = 0;
+  let propertyStart = objectStart + 1;
+  let index = objectStart + 1;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "'" || char === '"' || char === "`") {
+      index = consumeQuotedLiteral(source, index, source.length);
+      continue;
+    }
+    const nextIndex = consumeComment(source, index, source.length);
+    if (nextIndex !== null) {
+      index = nextIndex;
+      continue;
+    }
+    if (char === "{") {
+      curlyDepth++;
+      index++;
+      continue;
+    }
+    if (char === "}") {
+      curlyDepth--;
+      if (curlyDepth === 0) {
+        slices.push({ start: propertyStart, end: index });
+        return slices;
+      }
+      index++;
+      continue;
+    }
+    if (char === "[") {
+      squareDepth++;
+      index++;
+      continue;
+    }
+    if (char === "]") {
+      squareDepth--;
+      index++;
+      continue;
+    }
+    if (char === "(") {
+      parenDepth++;
+      index++;
+      continue;
+    }
+    if (char === ")") {
+      parenDepth--;
+      index++;
+      continue;
+    }
+    if (char === "," && curlyDepth === 1 && squareDepth === 0 && parenDepth === 0) {
+      slices.push({ start: propertyStart, end: index });
+      propertyStart = index + 1;
+    }
+    index++;
+  }
+  throw new Error("Could not parse the root object in devflare config.");
+}
+function findTopLevelColon(source, start, end) {
+  let curlyDepth = 0;
+  let squareDepth = 0;
+  let parenDepth = 0;
+  let index = start;
+  while (index < end) {
+    const char = source[index];
+    if (char === "'" || char === '"' || char === "`") {
+      index = consumeQuotedLiteral(source, index, end);
+      continue;
+    }
+    const nextIndex = consumeComment(source, index, end);
+    if (nextIndex !== null) {
+      index = nextIndex;
+      continue;
+    }
+    if (char === "{") {
+      curlyDepth++;
+      index++;
+      continue;
+    }
+    if (char === "}") {
+      curlyDepth--;
+      index++;
+      continue;
+    }
+    if (char === "[") {
+      squareDepth++;
+      index++;
+      continue;
+    }
+    if (char === "]") {
+      squareDepth--;
+      index++;
+      continue;
+    }
+    if (char === "(") {
+      parenDepth++;
+      index++;
+      continue;
+    }
+    if (char === ")") {
+      parenDepth--;
+      index++;
+      continue;
+    }
+    if (char === ":" && curlyDepth === 0 && squareDepth === 0 && parenDepth === 0) {
+      return index;
+    }
+    index++;
+  }
+  return -1;
+}
+function normalizePropertyKey(rawKey) {
+  const trimmed = rawKey.trim();
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function findRootNameLiteralRange(source) {
+  const objectStart = findConfigObjectStart(source);
+  if (objectStart < 0) {
+    return null;
+  }
+  for (const slice of getRootPropertySlices(source, objectStart)) {
+    const keyStart = skipWhitespaceAndComments(source, slice.start, slice.end);
+    const colonIndex = findTopLevelColon(source, keyStart, slice.end);
+    if (colonIndex < 0) {
+      continue;
+    }
+    const key = normalizePropertyKey(source.slice(keyStart, colonIndex));
+    if (key !== "name") {
+      continue;
+    }
+    const valueStart = skipWhitespaceAndComments(source, colonIndex + 1, slice.end);
+    const quote = source[valueStart];
+    if (quote !== "'" && quote !== '"') {
+      throw new Error("The top-level `name` property must be a string literal to be updated automatically.");
+    }
+    return {
+      start: valueStart,
+      end: consumeQuotedLiteral(source, valueStart, slice.end),
+      quote
+    };
+  }
+  return null;
+}
+function quoteWorkerName(value, quote) {
+  const escapedValue = value.replace(/\\/g, "\\\\").replace(new RegExp(`\\${quote}`, "g"), `\\${quote}`);
+  return `${quote}${escapedValue}${quote}`;
+}
+async function updateConfigName(configPath, newName) {
+  const fs = await import("node:fs/promises");
+  const source = await fs.readFile(configPath, "utf-8");
+  const literalRange = findRootNameLiteralRange(source);
+  if (!literalRange) {
+    throw new Error("Could not locate a top-level string literal `name` property in the selected devflare config.");
+  }
+  const magicString = new MagicString(source);
+  magicString.overwrite(literalRange.start, literalRange.end, quoteWorkerName(newName, literalRange.quote));
+  await fs.writeFile(configPath, magicString.toString(), "utf-8");
+}
+function collectReferenceHitsFromConfig(configPath, configLike, oldName, scope) {
+  if (!configLike?.bindings) {
+    return [];
+  }
+  const hits = [];
+  for (const [bindingName, bindingConfig] of Object.entries(configLike.bindings.services ?? {})) {
+    if (bindingConfig.service === oldName) {
+      hits.push({
+        configPath,
+        scope,
+        kind: "service",
+        bindingName
+      });
+    }
+  }
+  for (const [bindingName, bindingConfig] of Object.entries(configLike.bindings.durableObjects ?? {})) {
+    const normalized = normalizeDOBinding(bindingConfig);
+    if (normalized.scriptName === oldName) {
+      hits.push({
+        configPath,
+        scope,
+        kind: "durable-object",
+        bindingName
+      });
+    }
+  }
+  return hits;
+}
+function collectReferenceHits(loadedConfigs, oldName) {
+  const hits = [];
+  for (const record of loadedConfigs) {
+    hits.push(...collectReferenceHitsFromConfig(record.configPath, record.config, oldName, "root"));
+    for (const [envName, envConfig] of Object.entries(record.config.env ?? {})) {
+      hits.push(...collectReferenceHitsFromConfig(record.configPath, envConfig, oldName, `env.${envName}`));
+    }
+  }
+  return hits;
+}
+async function runWorkerCommand(parsed, logger, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const theme = createCliTheme(parsed.options);
+  const subcommand = parsed.args[0];
+  const oldName = parsed.args[1]?.trim();
+  const newName = asOptionalString(parsed.options.to);
+  const explicitConfigPath = asOptionalString(parsed.options.config);
+  if (subcommand !== "rename") {
+    logger.error(`Unknown worker subcommand: ${subcommand ?? "<none>"}`);
+    logLine(logger, dim("Usage: devflare worker rename <old-name> --to <new-name> [--config <path>]", theme));
+    return { exitCode: 1 };
+  }
+  if (!oldName) {
+    logger.error("A current Worker name is required.");
+    logLine(logger, dim("Usage: devflare worker rename <old-name> --to <new-name> [--config <path>]", theme));
+    return { exitCode: 1 };
+  }
+  if (!newName) {
+    logger.error("The new Worker name must be provided with --to.");
+    return { exitCode: 1 };
+  }
+  if (oldName === newName) {
+    logger.error("The new Worker name must be different from the current name.");
+    return { exitCode: 1 };
+  }
+  logLine(logger);
+  logLine(logger, `${yellow("worker", theme)} ${dim("Renaming Worker identity", theme)}`);
+  logLine(logger, `${dim("from", theme)} ${whiteDim(oldName, theme)}`);
+  logLine(logger, `${dim("to", theme)} ${green(newName, theme)}`);
+  if (!await account.isAuthenticated()) {
+    logger.error("Not authenticated with Cloudflare");
+    logLine(logger, dim("Run `devflare login` first.", theme));
+    return { exitCode: 1 };
+  }
+  let remoteRenamed = false;
+  try {
+    const explicitResolvedConfigPath = explicitConfigPath ? await resolveConfigCandidatePath(resolve(cwd, explicitConfigPath)) : null;
+    if (explicitConfigPath && !explicitResolvedConfigPath) {
+      throw new Error(`${formatSupportedConfigFilenames()} not found for --config ${explicitConfigPath}.`);
+    }
+    const selection = selectTargetConfig(await loadDiscoveredConfigs(cwd, explicitResolvedConfigPath ?? undefined), cwd, oldName, newName, explicitResolvedConfigPath ?? undefined);
+    const { target, localConfigAlreadyUpdated, allConfigs } = selection;
+    const accountId = await resolveAccountId(parsed, target.config);
+    if (!accountId) {
+      logger.error("No Cloudflare account could be resolved for this config.");
+      logLine(logger, dim("Set accountId in devflare.config.ts, pass --account, or configure a default account.", theme));
+      return { exitCode: 1 };
+    }
+    logLine(logger, `${dim("config", theme)} ${whiteDim(formatPathForLog(cwd, target.configPath), theme)}`);
+    logLine(logger, `${dim("account", theme)} ${whiteDim(accountId, theme)}`);
+    logLine(logger);
+    const workers = await account.workers(accountId);
+    const hasOldWorker = workers.some((worker) => worker.name === oldName);
+    const hasNewWorker = workers.some((worker) => worker.name === newName);
+    if (hasOldWorker && hasNewWorker) {
+      logger.error(`Both \`${oldName}\` and \`${newName}\` already exist in Cloudflare.`);
+      logLine(logger, dim("Refusing to rename because the target Worker name is already taken.", theme));
+      return { exitCode: 1 };
+    }
+    if (!hasOldWorker && !hasNewWorker) {
+      logger.error(`Neither \`${oldName}\` nor \`${newName}\` exists in Cloudflare for account ${accountId}.`);
+      return { exitCode: 1 };
+    }
+    if (hasOldWorker && !hasNewWorker) {
+      await account.renameWorker(accountId, oldName, newName);
+      remoteRenamed = true;
+      logger.success(`Renamed remote Worker ${oldName} → ${newName}`);
+    } else {
+      logLine(logger, `${dim("remote", theme)} ${green(newName, theme)} ${dim("is already the active Worker name in Cloudflare", theme)}`);
+    }
+    if (!localConfigAlreadyUpdated) {
+      await updateConfigName(target.configPath, newName);
+      logger.success(`Updated ${formatPathForLog(cwd, target.configPath)}`);
+    } else {
+      logLine(logger, `${dim("config", theme)} ${green("already updated locally", theme)}`);
+    }
+    const referenceHits = collectReferenceHits(allConfigs, oldName);
+    if (referenceHits.length > 0) {
+      logger.warn(`Found ${referenceHits.length} local reference(s) that still use \`${oldName}\`.`);
+      for (const hit of referenceHits) {
+        logLine(logger, `  ${formatPathForLog(cwd, hit.configPath)} ${dim(`(${hit.scope})`, theme)} ${dim("—", theme)} ${hit.kind === "service" ? "service binding" : "durable object binding"} ${bold(hit.bindingName, theme)}`);
+      }
+    }
+    logLine(logger);
+    logLine(logger, `${yellow("preview urls", theme)} ${dim("Existing preview URLs and registry entries may continue using the old Worker name until you upload fresh previews for the renamed Worker.", theme)}`);
+    logLine(logger, dim("Future deploys and preview uploads from this config will target the new Worker name.", theme));
+    return { exitCode: 0 };
+  } catch (error) {
+    if (remoteRenamed) {
+      logger.warn("The remote Worker rename succeeded, but the local config update did not complete.");
+      logLine(logger, dim("Update devflare.config.ts manually so future deploys target the renamed Worker.", theme));
+    }
+    if (error instanceof Error) {
+      logger.error(error.message);
+      return { exitCode: 1 };
+    }
+    throw error;
+  }
+}
+export {
+  runWorkerCommand
+};

package/dist/worker-entry/composed-worker.d.ts

@@ -0,0 +1,7 @@
+import type { DevflareConfig } from '../config';
+export interface PrepareComposedWorkerEntrypointOptions {
+    devInternalEmail?: boolean;
+    includeDevOnlyHooks?: boolean;
+}
+export declare function prepareComposedWorkerEntrypoint(cwd: string, config: DevflareConfig, environment?: string, options?: PrepareComposedWorkerEntrypointOptions): Promise<string | null>;
+//# sourceMappingURL=composed-worker.d.ts.map

package/dist/worker-entry/composed-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composed-worker.d.ts","sourceRoot":"","sources":["../../src/worker-entry/composed-worker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AA0B/C,MAAM,WAAW,sCAAsC;IACtD,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAmdD,wBAAsB,+BAA+B,CACpD,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,cAAc,EACtB,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,GAAE,sCAA2C,GAClD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAiExB"}

package/dist/worker-entry/durable-object-discovery.d.ts

@@ -0,0 +1,20 @@
+export interface DODiscoveryResult {
+    /** Map of file path → array of DO class names found in that file */
+    files: Map<string, string[]>;
+    /** Worker name for the auxiliary DO worker */
+    workerName: string;
+}
+/**
+ * Walk the glob `pattern` under `cwd` and return a map of file path →
+ * Durable Object class names declared in that file. Files that fail to read
+ * or contain no DO classes are omitted. Respects `.gitignore` automatically
+ * (via `findFiles`).
+ */
+export declare function discoverDurableObjectFiles(cwd: string, pattern: string): Promise<Map<string, string[]>>;
+/**
+ * Vite-plugin-shaped wrapper around `discoverDurableObjectFiles`. Returns a
+ * `DODiscoveryResult` carrying the discovered file map plus the auxiliary
+ * worker name.
+ */
+export declare function discoverDurableObjects(projectRoot: string, pattern: string, workerName: string): Promise<DODiscoveryResult>;
+//# sourceMappingURL=durable-object-discovery.d.ts.map

package/dist/worker-entry/durable-object-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object-discovery.d.ts","sourceRoot":"","sources":["../../src/worker-entry/durable-object-discovery.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,iBAAiB;IACjC,oEAAoE;IACpE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC5B,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAA;CAClB;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC/C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,GACb,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAkBhC;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC3C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAChB,OAAO,CAAC,iBAAiB,CAAC,CAG5B"}