devflare 1.0.0-next.16 → 1.0.0-next.18

package/dist/index-p8nmkrgw.js

@@ -0,0 +1,470 @@
+import {
+  mergeConfigForEnvironment
+} from "./index-tmmcf4m6.js";
+import {
+  createD1Database,
+  createKVNamespace,
+  createQueue,
+  createR2Bucket,
+  createVectorizeIndex,
+  deleteD1Database,
+  deleteHyperdrive,
+  deleteKVNamespace,
+  deleteQueue,
+  deleteR2Bucket,
+  deleteVectorizeIndex,
+  getEffectiveAccountId,
+  getPrimaryAccount,
+  listD1Databases,
+  listHyperdrives,
+  listKVNamespaces,
+  listQueues,
+  listR2Buckets,
+  listVectorizeIndexes
+} from "./index-gba371j7.js";
+import {
+  isPreviewScopedName,
+  materializePreviewScopedConfig,
+  materializePreviewScopedString
+} from "./index-p296ban8.js";
+
+// src/config/preview-resources.ts
+var defaultPreviewScopedResourceLifecycleApi = {
+  getPrimaryAccount,
+  getEffectiveAccountId,
+  listKVNamespaces,
+  createKVNamespace,
+  deleteKVNamespace,
+  listD1Databases,
+  createD1Database,
+  deleteD1Database,
+  listR2Buckets,
+  createR2Bucket,
+  deleteR2Bucket,
+  listQueues,
+  createQueue,
+  deleteQueue,
+  listVectorizeIndexes,
+  createVectorizeIndex,
+  deleteVectorizeIndex,
+  listHyperdrives,
+  deleteHyperdrive
+};
+function resolvePreviewScopedResourceLifecycleApi(overrides) {
+  return {
+    ...defaultPreviewScopedResourceLifecycleApi,
+    ...overrides ?? {}
+  };
+}
+function createEmptyPreviewScopedResourceNames() {
+  return {
+    kv: [],
+    d1: [],
+    r2: [],
+    queues: [],
+    vectorize: [],
+    hyperdrive: [],
+    analyticsEngine: [],
+    browser: []
+  };
+}
+function createEmptyPreviewScopedResourcePlan() {
+  return {
+    kv: [],
+    d1: [],
+    r2: [],
+    queues: [],
+    vectorize: [],
+    hyperdrive: [],
+    analyticsEngine: [],
+    browser: []
+  };
+}
+function createPreviewScopedResourceRef(value, bindingName, options) {
+  if (!isPreviewScopedName(value)) {
+    return null;
+  }
+  const baseName = materializePreviewScopedString(value, {
+    env: {}
+  });
+  const previewName = materializePreviewScopedString(value, options);
+  if (!baseName || !previewName || baseName === previewName) {
+    return null;
+  }
+  return {
+    ...bindingName ? { bindingName } : {},
+    baseName,
+    previewName
+  };
+}
+function upsertPreviewScopedQueueRef(queueRefs, value, options) {
+  const ref = createPreviewScopedResourceRef(value, undefined, options);
+  if (!ref) {
+    return;
+  }
+  if (!queueRefs.has(ref.previewName)) {
+    queueRefs.set(ref.previewName, ref);
+  }
+}
+function applyHyperdriveBindingFallbacks(config, hyperdriveBindingFallbacks) {
+  if (!config.bindings?.hyperdrive || Object.keys(hyperdriveBindingFallbacks).length === 0) {
+    return config;
+  }
+  return {
+    ...config,
+    bindings: {
+      ...config.bindings,
+      hyperdrive: Object.fromEntries(Object.entries(config.bindings.hyperdrive).map(([bindingName, bindingConfig]) => {
+        const fallbackName = hyperdriveBindingFallbacks[bindingName];
+        if (!fallbackName) {
+          return [bindingName, bindingConfig];
+        }
+        return [bindingName, fallbackName];
+      }))
+    }
+  };
+}
+function resolvePreviewScopedResourceLifecycleWarnings(plan) {
+  const warnings = [];
+  if (plan.analyticsEngine.length > 0) {
+    warnings.push("Workers Analytics Engine datasets are created automatically on first write, so Devflare does not provision or delete preview-scoped analytics datasets.");
+  }
+  if (plan.browser.length > 0) {
+    warnings.push("Browser Rendering bindings do not own account-scoped resources, so Devflare does not provision or delete preview-scoped browser bindings.");
+  }
+  return warnings;
+}
+function hasPreviewScopedLifecycleResources(plan) {
+  return plan.kv.length > 0 || plan.d1.length > 0 || plan.r2.length > 0 || plan.queues.length > 0 || plan.vectorize.length > 0 || plan.hyperdrive.length > 0;
+}
+async function resolveLifecycleAccountId(config, options, cloudflareApi) {
+  if (options.accountId?.trim()) {
+    return options.accountId.trim();
+  }
+  if (config.accountId?.trim()) {
+    return config.accountId.trim();
+  }
+  const primaryAccount = await cloudflareApi.getPrimaryAccount();
+  if (!primaryAccount) {
+    throw new Error("Could not resolve a Cloudflare account for preview-scoped resource lifecycle management. Set accountId in devflare.config.ts, pass --account, or authenticate with Wrangler.");
+  }
+  const effective = await cloudflareApi.getEffectiveAccountId(primaryAccount.id);
+  return effective.accountId;
+}
+async function loadPreviewScopedResourceLifecycleState(accountId, plan, cloudflareApi) {
+  const [namespaces, databases, buckets, queues, vectorizeIndexes, hyperdrives] = await Promise.all([
+    plan.kv.length > 0 ? cloudflareApi.listKVNamespaces(accountId) : Promise.resolve([]),
+    plan.d1.length > 0 ? cloudflareApi.listD1Databases(accountId) : Promise.resolve([]),
+    plan.r2.length > 0 ? cloudflareApi.listR2Buckets(accountId) : Promise.resolve([]),
+    plan.queues.length > 0 ? cloudflareApi.listQueues(accountId) : Promise.resolve([]),
+    plan.vectorize.length > 0 ? cloudflareApi.listVectorizeIndexes(accountId) : Promise.resolve([]),
+    plan.hyperdrive.length > 0 ? cloudflareApi.listHyperdrives(accountId) : Promise.resolve([])
+  ]);
+  return {
+    namespaces,
+    databases,
+    buckets,
+    queues,
+    vectorizeIndexes,
+    hyperdrives
+  };
+}
+function createPreviewScopedResourceResolutionCloudflareApi(state) {
+  return {
+    listKVNamespaces: async () => state.namespaces,
+    listD1Databases: async () => state.databases,
+    listHyperdrives: async () => state.hyperdrives
+  };
+}
+function findVectorizeIndexByName(indexes, name) {
+  return indexes.find((index) => index.name === name);
+}
+function findKVNamespaceByName(namespaces, name) {
+  return namespaces.find((namespace) => namespace.name === name);
+}
+function findD1DatabaseByName(databases, name) {
+  return databases.find((database) => database.name === name);
+}
+function findR2BucketByName(buckets, name) {
+  return buckets.find((bucket) => bucket.name === name);
+}
+function findQueueByName(queues, name) {
+  return queues.find((queue) => queue.name === name);
+}
+function findHyperdriveByName(hyperdrives, name) {
+  return hyperdrives.find((hyperdrive) => hyperdrive.name === name);
+}
+function collectPreviewScopedResourcePlan(config, options = {}) {
+  const mergedConfig = mergeConfigForEnvironment(config, options.environment);
+  const plan = createEmptyPreviewScopedResourcePlan();
+  const bindings = mergedConfig.bindings;
+  if (!bindings) {
+    return plan;
+  }
+  if (bindings.kv) {
+    plan.kv = Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => {
+      return typeof bindingConfig === "string" ? createPreviewScopedResourceRef(bindingConfig, bindingName, options) : null;
+    }).filter((ref) => ref !== null);
+  }
+  if (bindings.d1) {
+    plan.d1 = Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
+      return typeof bindingConfig === "string" ? createPreviewScopedResourceRef(bindingConfig, bindingName, options) : null;
+    }).filter((ref) => ref !== null);
+  }
+  if (bindings.r2) {
+    plan.r2 = Object.entries(bindings.r2).map(([bindingName, bindingConfig]) => {
+      return createPreviewScopedResourceRef(bindingConfig, bindingName, options);
+    }).filter((ref) => ref !== null);
+  }
+  if (bindings.queues) {
+    const queueRefs = new Map;
+    for (const queueName of Object.values(bindings.queues.producers ?? {})) {
+      upsertPreviewScopedQueueRef(queueRefs, queueName, options);
+    }
+    for (const consumer of bindings.queues.consumers ?? []) {
+      upsertPreviewScopedQueueRef(queueRefs, consumer.queue, options);
+      if (consumer.deadLetterQueue) {
+        upsertPreviewScopedQueueRef(queueRefs, consumer.deadLetterQueue, options);
+      }
+    }
+    plan.queues = Array.from(queueRefs.values());
+  }
+  if (bindings.vectorize) {
+    plan.vectorize = Object.entries(bindings.vectorize).map(([bindingName, bindingConfig]) => {
+      return createPreviewScopedResourceRef(bindingConfig.indexName, bindingName, options);
+    }).filter((ref) => ref !== null);
+  }
+  if (bindings.hyperdrive) {
+    plan.hyperdrive = Object.entries(bindings.hyperdrive).map(([bindingName, bindingConfig]) => {
+      if (typeof bindingConfig === "string") {
+        return createPreviewScopedResourceRef(bindingConfig, bindingName, options);
+      }
+      if (bindingConfig && typeof bindingConfig === "object" && "name" in bindingConfig && typeof bindingConfig.name === "string") {
+        const ref = createPreviewScopedResourceRef(bindingConfig.name, bindingName, options);
+        if (ref && bindingConfig.previewFallback === "base") {
+          ref.allowBaseFallback = true;
+        }
+        return ref;
+      }
+      return null;
+    }).filter((ref) => ref !== null);
+  }
+  if (bindings.analyticsEngine) {
+    plan.analyticsEngine = Object.entries(bindings.analyticsEngine).map(([bindingName, bindingConfig]) => {
+      return createPreviewScopedResourceRef(bindingConfig.dataset, bindingName, options);
+    }).filter((ref) => ref !== null);
+  }
+  if (bindings.browser) {
+    plan.browser = Object.entries(bindings.browser).map(([bindingName, bindingConfig]) => {
+      return createPreviewScopedResourceRef(bindingConfig, bindingName, options);
+    }).filter((ref) => ref !== null);
+  }
+  return plan;
+}
+async function preparePreviewScopedResourcesForDeploy(config, options = {}) {
+  const mergedConfig = mergeConfigForEnvironment(config, options.environment);
+  const plan = collectPreviewScopedResourcePlan(config, options);
+  const created = createEmptyPreviewScopedResourceNames();
+  const existing = createEmptyPreviewScopedResourceNames();
+  const warnings = resolvePreviewScopedResourceLifecycleWarnings(plan);
+  if (!hasPreviewScopedLifecycleResources(plan)) {
+    return {
+      config: materializePreviewScopedConfig(mergedConfig, options),
+      plan,
+      created,
+      existing,
+      warnings
+    };
+  }
+  const cloudflareApi = resolvePreviewScopedResourceLifecycleApi(options.cloudflare);
+  const accountId = await resolveLifecycleAccountId(config, options, cloudflareApi);
+  const {
+    namespaces,
+    databases,
+    buckets,
+    queues,
+    vectorizeIndexes,
+    hyperdrives
+  } = await loadPreviewScopedResourceLifecycleState(accountId, plan, cloudflareApi);
+  for (const ref of plan.kv) {
+    if (findKVNamespaceByName(namespaces, ref.previewName)) {
+      existing.kv.push(ref.previewName);
+      continue;
+    }
+    const namespace = await cloudflareApi.createKVNamespace(accountId, ref.previewName);
+    created.kv.push(ref.previewName);
+    namespaces.push(namespace);
+  }
+  for (const ref of plan.d1) {
+    if (findD1DatabaseByName(databases, ref.previewName)) {
+      existing.d1.push(ref.previewName);
+      continue;
+    }
+    const database = await cloudflareApi.createD1Database(accountId, ref.previewName);
+    created.d1.push(ref.previewName);
+    databases.push(database);
+  }
+  for (const ref of plan.r2) {
+    if (findR2BucketByName(buckets, ref.previewName)) {
+      existing.r2.push(ref.previewName);
+      continue;
+    }
+    const bucket = await cloudflareApi.createR2Bucket(accountId, ref.previewName);
+    created.r2.push(ref.previewName);
+    buckets.push(bucket);
+  }
+  for (const ref of plan.queues) {
+    if (findQueueByName(queues, ref.previewName)) {
+      existing.queues.push(ref.previewName);
+      continue;
+    }
+    const queue = await cloudflareApi.createQueue(accountId, ref.previewName);
+    created.queues.push(ref.previewName);
+    queues.push(queue);
+  }
+  for (const ref of plan.vectorize) {
+    if (findVectorizeIndexByName(vectorizeIndexes, ref.previewName)) {
+      existing.vectorize.push(ref.previewName);
+      continue;
+    }
+    const baseIndex = findVectorizeIndexByName(vectorizeIndexes, ref.baseName);
+    if (!baseIndex) {
+      throw new Error(`Could not provision preview Vectorize index "${ref.previewName}" because the base index "${ref.baseName}" was not found.`);
+    }
+    const createdIndex = await cloudflareApi.createVectorizeIndex(accountId, {
+      name: ref.previewName,
+      dimensions: baseIndex.dimensions,
+      metric: baseIndex.metric,
+      description: baseIndex.description
+    });
+    created.vectorize.push(ref.previewName);
+    vectorizeIndexes.push(createdIndex);
+  }
+  const hyperdriveBindingFallbacks = {};
+  for (const ref of plan.hyperdrive) {
+    if (findHyperdriveByName(hyperdrives, ref.previewName)) {
+      existing.hyperdrive.push(ref.previewName);
+      continue;
+    }
+    if (!findHyperdriveByName(hyperdrives, ref.baseName)) {
+      throw new Error(`Could not resolve preview Hyperdrive "${ref.previewName}" because neither the preview config nor the base config "${ref.baseName}" exists in this account.`);
+    }
+    if (!ref.allowBaseFallback) {
+      const bindingLabel = ref.bindingName ? `"${ref.bindingName}"` : `for preview name "${ref.previewName}"`;
+      throw new Error(`Preview Hyperdrive binding ${bindingLabel} has no dedicated preview Hyperdrive configuration "${ref.previewName}" in this account. ` + "Either provision a dedicated preview Hyperdrive (or set `previewId` / `previewLocalConnectionString` on the binding), " + "or opt in to reusing the base Hyperdrive by setting `previewFallback: 'base'` on the binding.");
+    }
+    if (ref.bindingName) {
+      hyperdriveBindingFallbacks[ref.bindingName] = ref.baseName;
+    }
+    warnings.push(`Preview Hyperdrive "${ref.previewName}" is not auto-provisioned because Cloudflare does not expose stored Hyperdrive credentials for cloning. Devflare will reuse the base Hyperdrive "${ref.baseName}" for binding ${ref.bindingName ?? ref.previewName}.`);
+  }
+  const preparedConfig = applyHyperdriveBindingFallbacks(mergedConfig, hyperdriveBindingFallbacks);
+  return {
+    accountId,
+    config: materializePreviewScopedConfig(preparedConfig, options),
+    resourceResolutionCloudflare: createPreviewScopedResourceResolutionCloudflareApi({
+      namespaces,
+      databases,
+      hyperdrives
+    }),
+    plan,
+    created,
+    existing,
+    warnings
+  };
+}
+async function cleanupPreviewScopedResources(config, options = {}) {
+  const plan = collectPreviewScopedResourcePlan(config, options);
+  const candidates = createEmptyPreviewScopedResourceNames();
+  const deleted = createEmptyPreviewScopedResourceNames();
+  const warnings = resolvePreviewScopedResourceLifecycleWarnings(plan);
+  if (!hasPreviewScopedLifecycleResources(plan)) {
+    return {
+      plan,
+      candidates,
+      deleted,
+      warnings
+    };
+  }
+  const cloudflareApi = resolvePreviewScopedResourceLifecycleApi(options.cloudflare);
+  const accountId = await resolveLifecycleAccountId(config, options, cloudflareApi);
+  const apply = options.apply === true;
+  const {
+    namespaces,
+    databases,
+    buckets,
+    queues,
+    vectorizeIndexes,
+    hyperdrives
+  } = await loadPreviewScopedResourceLifecycleState(accountId, plan, cloudflareApi);
+  const kvCandidates = plan.kv.map((ref) => findKVNamespaceByName(namespaces, ref.previewName)).filter((namespace) => namespace !== undefined);
+  for (const namespace of kvCandidates) {
+    candidates.kv.push(namespace.name);
+    if (!apply) {
+      continue;
+    }
+    await cloudflareApi.deleteKVNamespace(accountId, namespace.id);
+    deleted.kv.push(namespace.name);
+  }
+  const d1Candidates = plan.d1.map((ref) => findD1DatabaseByName(databases, ref.previewName)).filter((database) => database !== undefined);
+  for (const database of d1Candidates) {
+    candidates.d1.push(database.name);
+    if (!apply) {
+      continue;
+    }
+    await cloudflareApi.deleteD1Database(accountId, database.id);
+    deleted.d1.push(database.name);
+  }
+  const r2Candidates = plan.r2.map((ref) => findR2BucketByName(buckets, ref.previewName)).filter((bucket) => bucket !== undefined);
+  for (const bucket of r2Candidates) {
+    candidates.r2.push(bucket.name);
+    if (!apply) {
+      continue;
+    }
+    await cloudflareApi.deleteR2Bucket(accountId, bucket.name);
+    deleted.r2.push(bucket.name);
+  }
+  const queueCandidates = plan.queues.map((ref) => findQueueByName(queues, ref.previewName)).filter((queue) => queue !== undefined);
+  for (const queue of queueCandidates) {
+    candidates.queues.push(queue.name);
+    if (!apply) {
+      continue;
+    }
+    if (!queue.id) {
+      warnings.push(`Skipping queue deletion for "${queue.name}" because Cloudflare did not return a queue id.`);
+      continue;
+    }
+    await cloudflareApi.deleteQueue(accountId, queue.id);
+    deleted.queues.push(queue.name);
+  }
+  const vectorizeCandidates = plan.vectorize.map((ref) => findVectorizeIndexByName(vectorizeIndexes, ref.previewName)).filter((index) => index !== undefined);
+  for (const index of vectorizeCandidates) {
+    candidates.vectorize.push(index.name);
+    if (!apply) {
+      continue;
+    }
+    await cloudflareApi.deleteVectorizeIndex(accountId, index.name);
+    deleted.vectorize.push(index.name);
+  }
+  const hyperdriveCandidates = plan.hyperdrive.map((ref) => findHyperdriveByName(hyperdrives, ref.previewName)).filter((hyperdrive) => hyperdrive !== undefined);
+  for (const hyperdrive of hyperdriveCandidates) {
+    candidates.hyperdrive.push(hyperdrive.name);
+    if (!apply) {
+      continue;
+    }
+    await cloudflareApi.deleteHyperdrive(accountId, hyperdrive.id);
+    deleted.hyperdrive.push(hyperdrive.name);
+  }
+  if (plan.hyperdrive.length > 0) {
+    warnings.push("Preview-scoped Hyperdrive cleanup only deletes preview configs that already exist. Devflare does not auto-provision preview Hyperdrives because Cloudflare does not expose stored Hyperdrive credentials for cloning.");
+  }
+  return {
+    accountId,
+    plan,
+    candidates,
+    deleted,
+    warnings
+  };
+}
+
+export { preparePreviewScopedResourcesForDeploy, cleanupPreviewScopedResources };

package/dist/{index-yqbxjysa.js → index-p97s12vf.js}

@@ -14,16 +14,15 @@ import {
   isolateViteBuildOutputPaths,
   rebaseWranglerConfigPaths,
   writeWranglerConfig
-} from "./index-11m5a8wd.js";
+} from "./index-n8k8chde.js";
 import {
   loadConfig,
   loadResolvedConfig,
   normalizeDOBinding,
   resolveConfigForEnvironment,
   resolveConfigForLocalRuntime,
-  resolveConfigPath,
-  resolveConfigResources
-} from "./index-yzddwp02.js";
+  resolveConfigPath
+} from "./index-dmbdj6va.js";
 import {
   __require
 } from "./index-37x76zdn.js";
@@ -170,7 +169,9 @@ function needsComposedWorkerEntrypoint(cwd, surfacePaths, config, routeDiscovery
   return Boolean(surfacePaths.fetch);
 }
 function getComposedWorkerEntrypointSource(surfaceImportPaths, configuredLocalSendEmailBindings = {}, durableObjectExports = [], routeImports = [], options = {}) {
-  const importLines = [`import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`];
+  const importLines = [
+    `import { createEmailEvent, createFetchEvent, createQueueEvent, createRouteResolve, createScheduledEvent, invokeFetchModule, matchFetchRoute, runWithEventContext, setLocalSendEmailBindings } from 'devflare/runtime'`
+  ];
   const moduleFallbackLines = [];
   const durableObjectExportLines = durableObjectExports.map(({ classNames, importPath }) => `export { ${classNames.join(", ")} } from '${importPath}'`);
   const localSendEmailBindings = JSON.stringify(configuredLocalSendEmailBindings);
@@ -397,15 +398,23 @@ async function prepareComposedWorkerEntrypoint(cwd, config, environment, options
 var CONFIG_DIR = ".devflare";
 var VIRTUAL_DO_ENTRY = "virtual:devflare-do-entry";
 var RESOLVED_VIRTUAL_DO_ENTRY = "\x00" + VIRTUAL_DO_ENTRY;
-var pluginContext = {
-  wranglerConfig: null,
-  cloudflareConfig: null,
-  projectRoot: process.cwd(),
-  auxiliaryWorkerConfig: null,
-  durableObjects: null
-};
+function createPluginState() {
+  return {
+    context: {
+      wranglerConfig: null,
+      cloudflareConfig: null,
+      projectRoot: process.cwd(),
+      auxiliaryWorkerConfig: null,
+      durableObjects: null
+    },
+    projectRoot: process.cwd(),
+    devflareConfig: null,
+    resolvedPluginConfigPath: null
+  };
+}
+var lastPluginContext = createPluginState().context;
 function getPluginContext() {
-  return pluginContext;
+  return lastPluginContext;
 }
 async function discoverDurableObjects(projectRoot, pattern, workerName) {
   const files = new Map;
@@ -474,7 +483,7 @@ function logDiscoveredDurableObjects(projectRoot, discovery) {
   }
 }
 async function buildPluginContextState(projectRoot, devflareConfig, environment, mode = "serve") {
-  const effectiveConfig = mode === "build" ? await resolveConfigResources(devflareConfig, { environment }) : resolveConfigForLocalRuntime(devflareConfig, environment);
+  const effectiveConfig = resolveConfigForLocalRuntime(devflareConfig, environment);
   const compiledWranglerConfig = compileConfig(effectiveConfig);
   const wranglerConfig = mode === "build" ? isolateViteBuildOutputPaths(projectRoot, compiledWranglerConfig) : compiledWranglerConfig;
   const cloudflareConfig = {
@@ -548,9 +557,7 @@ function devflarePlugin(options = {}) {
     bridgePort = process.env.DEVFLARE_BRIDGE_PORT ? parseInt(process.env.DEVFLARE_BRIDGE_PORT, 10) : undefined,
     wsProxyPatterns = []
   } = options;
-  let projectRoot;
-  let devflareConfig;
-  let resolvedPluginConfigPath = null;
+  const state = createPluginState();
   return {
     name: "devflare",
     enforce: "pre",
@@ -615,30 +622,31 @@ function devflarePlugin(options = {}) {
     },
     async load(id) {
       if (id === RESOLVED_VIRTUAL_DO_ENTRY) {
-        if (!pluginContext.durableObjects) {
+        if (!state.context.durableObjects) {
           return `// No Durable Objects configured
 export default { fetch: () => new Response("No DOs") }`;
         }
-        return generateVirtualDOEntry(pluginContext.durableObjects);
+        return generateVirtualDOEntry(state.context.durableObjects);
       }
       return null;
     },
     async configResolved(config) {
-      projectRoot = config.root;
-      pluginContext.projectRoot = projectRoot;
-      resolvedPluginConfigPath = await resolvePluginConfigPath(projectRoot, configPath);
+      state.projectRoot = config.root;
+      state.context.projectRoot = state.projectRoot;
+      state.resolvedPluginConfigPath = await resolvePluginConfigPath(state.projectRoot, configPath);
       try {
-        devflareConfig = await loadConfig({
-          cwd: projectRoot,
+        state.devflareConfig = await loadConfig({
+          cwd: state.projectRoot,
           configFile: configPath
         });
-        const pluginState = await buildPluginContextState(projectRoot, devflareConfig, environment, config.command === "build" ? "build" : "serve");
-        Object.assign(pluginContext, {
-          projectRoot,
+        const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, environment, config.command === "build" ? "build" : "serve");
+        Object.assign(state.context, {
+          projectRoot: state.projectRoot,
           ...pluginState
         });
-        logDiscoveredDurableObjects(projectRoot, pluginState.durableObjects);
-        await writeGeneratedWranglerConfig(projectRoot, pluginState.wranglerConfig);
+        lastPluginContext = state.context;
+        logDiscoveredDurableObjects(state.projectRoot, pluginState.durableObjects);
+        await writeGeneratedWranglerConfig(state.projectRoot, pluginState.wranglerConfig);
         if (config.command === "serve") {
           console.log("[devflare] Config generated to .devflare/wrangler.jsonc");
           if (pluginState.auxiliaryWorkerConfig) {
@@ -658,23 +666,24 @@ export default { fetch: () => new Response("No DOs") }`;
     configureServer(server) {
       if (!watchConfig)
         return;
-      const fullConfigPath = resolvedPluginConfigPath ?? resolve3(projectRoot, configPath || "devflare.config.ts");
+      const fullConfigPath = state.resolvedPluginConfigPath ?? resolve3(state.projectRoot, configPath || "devflare.config.ts");
       server.watcher.add(fullConfigPath);
       server.watcher.on("change", async (changedPath) => {
         if (changedPath === fullConfigPath) {
           console.log("[devflare] Config changed, reloading...");
           try {
-            devflareConfig = await loadConfig({
-              cwd: projectRoot,
+            state.devflareConfig = await loadConfig({
+              cwd: state.projectRoot,
               configFile: configPath
             });
-            const pluginState = await buildPluginContextState(projectRoot, devflareConfig, environment, "serve");
-            Object.assign(pluginContext, {
-              projectRoot,
+            const pluginState = await buildPluginContextState(state.projectRoot, state.devflareConfig, environment, "serve");
+            Object.assign(state.context, {
+              projectRoot: state.projectRoot,
               ...pluginState
             });
-            logDiscoveredDurableObjects(projectRoot, pluginState.durableObjects);
-            await writeGeneratedWranglerConfig(projectRoot, pluginState.wranglerConfig);
+            lastPluginContext = state.context;
+            logDiscoveredDurableObjects(state.projectRoot, pluginState.durableObjects);
+            await writeGeneratedWranglerConfig(state.projectRoot, pluginState.wranglerConfig);
             console.log("[devflare] Config reloaded");
             server.ws.send({
               type: "full-reload",
@@ -842,8 +851,7 @@ async function ensureGeneratedConfigDir2(cwd) {
 }
 async function resolveDevflarePackageRoot(currentFilePath) {
   const fs = await import("node:fs/promises");
-  const { dirname: dirname2 } = await import("node:path");
-  const { resolve: resolve4 } = await import("pathe");
+  const { dirname: dirname2, resolve: resolve4 } = await import("pathe");
   let currentDir = dirname2(currentFilePath);
   while (true) {
     const packageJsonPath = resolve4(currentDir, "package.json");
@@ -862,13 +870,12 @@ async function resolveDevflarePackageRoot(currentFilePath) {
   throw new Error("Could not resolve the devflare package root for generated Vite config imports.");
 }
 async function resolveGeneratedViteImportPath(configDir) {
-  const { extname, sep } = await import("node:path");
   const { fileURLToPath } = await import("node:url");
-  const { relative: relative3, resolve: resolve4 } = await import("pathe");
-  const currentFilePath = fileURLToPath(import.meta.url);
+  const { extname, normalize, relative: relative3, resolve: resolve4 } = await import("pathe");
+  const currentFilePath = normalize(fileURLToPath(import.meta.url));
   const currentExtension = extname(currentFilePath);
   const packageRoot = await resolveDevflarePackageRoot(currentFilePath);
-  const viteEntryPath = currentFilePath.includes(`${sep}dist${sep}`) ? resolve4(packageRoot, "dist/src/vite/index.js") : resolve4(packageRoot, `src/vite/index${currentExtension}`);
+  const viteEntryPath = currentFilePath.includes("/dist/") ? resolve4(packageRoot, "dist/vite/index.js") : resolve4(packageRoot, `src/vite/index${currentExtension}`);
   const relativeImportPath = relative3(configDir, viteEntryPath);
   return relativeImportPath.startsWith(".") ? relativeImportPath : `./${relativeImportPath}`;
 }