@cloudwerk/vite-plugin 0.4.1 → 0.6.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Plugin } from 'vite';
-import { CloudwerkConfig, RouteManifest, ScanResult } from '@cloudwerk/core/build';
+import { CloudwerkConfig, RouteManifest, ScanResult, QueueManifest, ServiceManifest } from '@cloudwerk/core/build';
 
 /**
  * @cloudwerk/vite-plugin - Types
@@ -150,6 +150,15 @@ declare function cloudwerkPlugin(options?: CloudwerkVitePluginOptions): Plugin;
  * a Hono app with all routes registered from the file-based routing manifest.
  */
 
+/**
+ * Options for generating server entry.
+ */
+interface GenerateServerEntryOptions {
+    /** Queue manifest if queues are configured */
+    queueManifest?: QueueManifest | null;
+    /** Service manifest if services are configured */
+    serviceManifest?: ServiceManifest | null;
+}
 /**
  * Generate the server entry module code.
  *
@@ -165,7 +174,7 @@ declare function cloudwerkPlugin(options?: CloudwerkVitePluginOptions): Plugin;
  * @param options - Resolved plugin options
  * @returns Generated TypeScript/JavaScript code
  */
-declare function generateServerEntry(manifest: RouteManifest, scanResult: ScanResult, options: ResolvedCloudwerkOptions): string;
+declare function generateServerEntry(manifest: RouteManifest, scanResult: ScanResult, options: ResolvedCloudwerkOptions, entryOptions?: GenerateServerEntryOptions): string;
 
 /**
  * Client Entry Virtual Module Generator

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/plugin.ts
-import * as path2 from "path";
-import * as fs from "fs";
+import * as path3 from "path";
+import * as fs2 from "fs";
 import {
   scanRoutes,
   buildRouteManifest,
@@ -12,7 +12,14 @@ import {
   resolveRoutesPath,
   hasUseClientDirective,
   generateComponentId,
-  ROUTE_FILE_NAMES
+  ROUTE_FILE_NAMES,
+  scanQueues,
+  buildQueueManifest,
+  QUEUES_DIR,
+  scanServices,
+  buildServiceManifest,
+  SERVICES_DIR,
+  SERVICE_FILE_NAME
 } from "@cloudwerk/core/build";
 
 // src/types.ts
@@ -29,7 +36,9 @@ var RESOLVED_VIRTUAL_IDS = {
 
 // src/virtual-modules/server-entry.ts
 import * as path from "path";
-function generateServerEntry(manifest, scanResult, options) {
+function generateServerEntry(manifest, scanResult, options, entryOptions) {
+  const queueManifest = entryOptions?.queueManifest;
+  const serviceManifest = entryOptions?.serviceManifest;
   const imports = [];
   const pageRegistrations = [];
   const routeRegistrations = [];
@@ -532,8 +541,137 @@ app.onError(async (err, c) => {
 // ============================================================================
 
 export default app
+${generateQueueExports(queueManifest)}
+${generateServiceRegistration(serviceManifest)}
 `;
 }
+function generateQueueExports(queueManifest) {
+  if (!queueManifest || queueManifest.queues.length === 0) {
+    return "";
+  }
+  const lines = [];
+  const imports = [];
+  const queueHandlers = [];
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Queue Consumer Handlers");
+  lines.push("// ============================================================================");
+  lines.push("");
+  for (let i = 0; i < queueManifest.queues.length; i++) {
+    const queue = queueManifest.queues[i];
+    const varName = `queueDef_${i}`;
+    imports.push(`import ${varName} from '${queue.absolutePath}'`);
+    queueHandlers.push(`
+/**
+ * Queue consumer handler for '${queue.name}'
+ */
+async function handle_${queue.name}_queue(batch, env, ctx) {
+  const definition = ${varName}
+
+  // Create message wrappers
+  const messages = batch.messages.map((msg) => ({
+    id: msg.id,
+    body: msg.body,
+    timestamp: new Date(msg.timestamp),
+    attempts: msg.attempts,
+    ack: () => msg.ack(),
+    retry: (options) => msg.retry(options),
+    deadLetter: (reason) => {
+      // Mark for DLQ if configured
+      if (definition.config?.deadLetterQueue) {
+        msg.retry({ delaySeconds: 0 })
+      }
+    },
+  }))
+
+  // Validate messages if schema is defined
+  if (definition.schema) {
+    for (const message of messages) {
+      const result = definition.schema.safeParse(message.body)
+      if (!result.success) {
+        console.error('Queue message validation failed:', result.error)
+        message.retry({ delaySeconds: 60 })
+        return
+      }
+    }
+  }
+
+  try {
+    // Use batch processor if available
+    if (definition.processBatch) {
+      await definition.processBatch(messages)
+    } else if (definition.process) {
+      // Process messages individually
+      for (const message of messages) {
+        try {
+          await definition.process(message)
+        } catch (error) {
+          if (definition.onError) {
+            await definition.onError(error, message)
+          } else {
+            throw error
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Queue processing error:', error)
+    // Retry all messages
+    batch.retryAll()
+  }
+}`);
+  }
+  lines.push(imports.join("\n"));
+  lines.push(queueHandlers.join("\n"));
+  lines.push("");
+  lines.push("/**");
+  lines.push(" * Main queue handler that routes to specific queue handlers.");
+  lines.push(" * Export this as the `queue` handler in your worker.");
+  lines.push(" */");
+  lines.push("export async function queue(batch, env, ctx) {");
+  lines.push("  const queueName = batch.queue");
+  lines.push("");
+  for (const queue of queueManifest.queues) {
+    lines.push(`  if (queueName === '${queue.queueName}') {`);
+    lines.push(`    return handle_${queue.name}_queue(batch, env, ctx)`);
+    lines.push("  }");
+    lines.push("");
+  }
+  lines.push("  console.warn(\\`Unknown queue: \\${queueName}\\`)");
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateServiceRegistration(serviceManifest) {
+  if (!serviceManifest || serviceManifest.services.length === 0) {
+    return "";
+  }
+  const lines = [];
+  const imports = [];
+  const registrations = [];
+  lines.push("");
+  lines.push("// ============================================================================");
+  lines.push("// Service Registration");
+  lines.push("// ============================================================================");
+  lines.push("");
+  imports.push("import { registerLocalService } from '@cloudwerk/core/bindings'");
+  for (let i = 0; i < serviceManifest.services.length; i++) {
+    const service = serviceManifest.services[i];
+    const varName = `serviceDef_${i}`;
+    imports.push(`import ${varName} from '${service.absolutePath}'`);
+    if (service.mode === "local") {
+      registrations.push(`registerLocalService('${service.name}', ${varName})`);
+    }
+  }
+  lines.push(imports.join("\n"));
+  lines.push("");
+  if (registrations.length > 0) {
+    lines.push("// Register local services");
+    for (const reg of registrations) {
+      lines.push(reg);
+    }
+  }
+  return lines.join("\n");
+}
 
 // src/virtual-modules/client-entry.ts
 function generateClientEntry(clientComponents, options) {
@@ -1037,25 +1175,358 @@ export default __WrappedComponent
   }
 }
 
+// src/wrangler-watcher.ts
+import * as fs from "fs";
+import * as path2 from "path";
+var TYPE_MAPPINGS = {
+  d1: "D1Database",
+  kv: "KVNamespace",
+  r2: "R2Bucket",
+  queue: "Queue",
+  do: "DurableObjectNamespace",
+  service: "Fetcher",
+  secret: "string",
+  ai: "Ai",
+  vectorize: "VectorizeIndex",
+  hyperdrive: "Hyperdrive"
+};
+function parseSimpleToml(content) {
+  const result = {};
+  const d1Matches = content.matchAll(/\[\[d1_databases\]\]\s*\n([^[]*)/g);
+  for (const match of d1Matches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.d1_databases) result.d1_databases = [];
+      result.d1_databases.push({ binding: bindingMatch[1] });
+    }
+  }
+  const kvMatches = content.matchAll(/\[\[kv_namespaces\]\]\s*\n([^[]*)/g);
+  for (const match of kvMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.kv_namespaces) result.kv_namespaces = [];
+      result.kv_namespaces.push({ binding: bindingMatch[1] });
+    }
+  }
+  const r2Matches = content.matchAll(/\[\[r2_buckets\]\]\s*\n([^[]*)/g);
+  for (const match of r2Matches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.r2_buckets) result.r2_buckets = [];
+      result.r2_buckets.push({ binding: bindingMatch[1] });
+    }
+  }
+  const queueMatches = content.matchAll(/\[\[queues\.producers\]\]\s*\n([^[]*)/g);
+  for (const match of queueMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.queues) result.queues = {};
+      if (!result.queues.producers) result.queues.producers = [];
+      result.queues.producers.push({ binding: bindingMatch[1] });
+    }
+  }
+  const doMatches = content.matchAll(/\[\[durable_objects\.bindings\]\]\s*\n([^[]*)/g);
+  for (const match of doMatches) {
+    const nameMatch = match[1].match(/name\s*=\s*["']([^"']+)["']/);
+    if (nameMatch) {
+      if (!result.durable_objects) result.durable_objects = {};
+      if (!result.durable_objects.bindings) result.durable_objects.bindings = [];
+      result.durable_objects.bindings.push({ name: nameMatch[1] });
+    }
+  }
+  const serviceMatches = content.matchAll(/\[\[services\]\]\s*\n([^[]*)/g);
+  for (const match of serviceMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.services) result.services = [];
+      result.services.push({ binding: bindingMatch[1] });
+    }
+  }
+  const varsMatch = content.match(/\[vars\]\s*\n([^[]*)/s);
+  if (varsMatch) {
+    const varsSection = varsMatch[1];
+    const varMatches = varsSection.matchAll(/(\w+)\s*=\s*["']([^"']*)["']/g);
+    result.vars = {};
+    for (const match of varMatches) {
+      result.vars[match[1]] = match[2];
+    }
+  }
+  const aiMatch = content.match(/\[ai\]\s*\n([^[]*)/s);
+  if (aiMatch) {
+    const bindingMatch = aiMatch[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      result.ai = { binding: bindingMatch[1] };
+    }
+  }
+  const vectorizeMatches = content.matchAll(/\[\[vectorize\]\]\s*\n([^[]*)/g);
+  for (const match of vectorizeMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.vectorize) result.vectorize = [];
+      result.vectorize.push({ binding: bindingMatch[1] });
+    }
+  }
+  const hyperdriveMatches = content.matchAll(/\[\[hyperdrive\]\]\s*\n([^[]*)/g);
+  for (const match of hyperdriveMatches) {
+    const bindingMatch = match[1].match(/binding\s*=\s*["']([^"']+)["']/);
+    if (bindingMatch) {
+      if (!result.hyperdrive) result.hyperdrive = [];
+      result.hyperdrive.push({ binding: bindingMatch[1] });
+    }
+  }
+  return result;
+}
+function extractBindings(config) {
+  const bindings = [];
+  if (config.d1_databases) {
+    for (const db of config.d1_databases) {
+      bindings.push({ type: "d1", name: db.binding });
+    }
+  }
+  if (config.kv_namespaces) {
+    for (const kv of config.kv_namespaces) {
+      bindings.push({ type: "kv", name: kv.binding });
+    }
+  }
+  if (config.r2_buckets) {
+    for (const r2 of config.r2_buckets) {
+      bindings.push({ type: "r2", name: r2.binding });
+    }
+  }
+  if (config.queues?.producers) {
+    for (const queue of config.queues.producers) {
+      bindings.push({ type: "queue", name: queue.binding });
+    }
+  }
+  if (config.durable_objects?.bindings) {
+    for (const doBinding of config.durable_objects.bindings) {
+      bindings.push({ type: "do", name: doBinding.name });
+    }
+  }
+  if (config.services) {
+    for (const service of config.services) {
+      bindings.push({ type: "service", name: service.binding });
+    }
+  }
+  if (config.vars) {
+    for (const name of Object.keys(config.vars)) {
+      bindings.push({ type: "secret", name });
+    }
+  }
+  if (config.ai) {
+    bindings.push({ type: "ai", name: config.ai.binding });
+  }
+  if (config.vectorize) {
+    for (const vec of config.vectorize) {
+      bindings.push({ type: "vectorize", name: vec.binding });
+    }
+  }
+  if (config.hyperdrive) {
+    for (const hd of config.hyperdrive) {
+      bindings.push({ type: "hyperdrive", name: hd.binding });
+    }
+  }
+  return bindings;
+}
+function getSectionName(type) {
+  switch (type) {
+    case "d1":
+      return "D1 Databases";
+    case "kv":
+      return "KV Namespaces";
+    case "r2":
+      return "R2 Buckets";
+    case "queue":
+      return "Queues";
+    case "do":
+      return "Durable Objects";
+    case "service":
+      return "Services";
+    case "secret":
+      return "Environment Variables";
+    case "ai":
+      return "AI";
+    case "vectorize":
+      return "Vectorize Indexes";
+    case "hyperdrive":
+      return "Hyperdrive";
+    default:
+      return "Other";
+  }
+}
+function groupBindingsByType(bindings) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const binding of bindings) {
+    const existing = grouped.get(binding.type) || [];
+    existing.push(binding);
+    grouped.set(binding.type, existing);
+  }
+  return grouped;
+}
+function generateBindingsDts(bindings) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk - DO NOT EDIT");
+  lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("//");
+  lines.push("// This file provides type information for @cloudwerk/core/bindings");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/bindings' {");
+  const bindingsByType = groupBindingsByType(bindings);
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  let firstSection = true;
+  for (const type of typeOrder) {
+    const typeBindings = bindingsByType.get(type);
+    if (!typeBindings || typeBindings.length === 0) continue;
+    const tsType = TYPE_MAPPINGS[type];
+    const sectionName = getSectionName(type);
+    if (!firstSection) {
+      lines.push("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  export const ${binding.name}: ${tsType}`);
+    }
+  }
+  lines.push("");
+  lines.push("  // Bindings proxy object (for dynamic access)");
+  lines.push("  export const bindings: Record<string, unknown>");
+  lines.push("");
+  lines.push("  // Helper functions");
+  lines.push("  export function getBinding<T = unknown>(name: string): T");
+  lines.push("  export function hasBinding(name: string): boolean");
+  lines.push("  export function getBindingNames(): string[]");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function generateContextDts(bindings) {
+  const lines = [];
+  lines.push("// Auto-generated by cloudwerk - DO NOT EDIT");
+  lines.push(`// Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("//");
+  lines.push("// This file provides type information for @cloudwerk/core/context");
+  lines.push("");
+  lines.push("interface CloudwerkEnv {");
+  const bindingsByType = groupBindingsByType(bindings);
+  const typeOrder = [
+    "d1",
+    "kv",
+    "r2",
+    "queue",
+    "do",
+    "service",
+    "ai",
+    "vectorize",
+    "hyperdrive",
+    "secret"
+  ];
+  let firstSection = true;
+  for (const type of typeOrder) {
+    const typeBindings = bindingsByType.get(type);
+    if (!typeBindings || typeBindings.length === 0) continue;
+    const tsType = TYPE_MAPPINGS[type];
+    const sectionName = getSectionName(type);
+    if (!firstSection) {
+      lines.push("");
+    }
+    lines.push(`  // ${sectionName}`);
+    firstSection = false;
+    for (const binding of typeBindings) {
+      lines.push(`  ${binding.name}: ${tsType}`);
+    }
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("declare module '@cloudwerk/core/context' {");
+  lines.push("  export const params: Record<string, string>");
+  lines.push("  export const request: Request");
+  lines.push("  export const env: CloudwerkEnv");
+  lines.push("  export const executionCtx: {");
+  lines.push("    waitUntil(promise: Promise<unknown>): void");
+  lines.push("    passThroughOnException(): void");
+  lines.push("  }");
+  lines.push("  export function getRequestId(): string");
+  lines.push("  export function get<T>(key: string): T | undefined");
+  lines.push("  export function set<T>(key: string, value: T): void");
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function findWranglerTomlPath(root) {
+  const tomlPath = path2.join(root, "wrangler.toml");
+  if (fs.existsSync(tomlPath)) {
+    return tomlPath;
+  }
+  const jsonPath = path2.join(root, "wrangler.json");
+  if (fs.existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+function regenerateCloudwerkTypes(root) {
+  const wranglerPath = findWranglerTomlPath(root);
+  if (!wranglerPath) {
+    return null;
+  }
+  const content = fs.readFileSync(wranglerPath, "utf-8");
+  let config;
+  if (wranglerPath.endsWith(".json")) {
+    config = JSON.parse(content);
+  } else {
+    config = parseSimpleToml(content);
+  }
+  const bindings = extractBindings(config);
+  if (bindings.length === 0) {
+    return null;
+  }
+  const typesDir = path2.join(root, ".cloudwerk", "types");
+  fs.mkdirSync(typesDir, { recursive: true });
+  const bindingsPath = path2.join(typesDir, "bindings.d.ts");
+  const bindingsContent = generateBindingsDts(bindings);
+  fs.writeFileSync(bindingsPath, bindingsContent, "utf-8");
+  const contextPath = path2.join(typesDir, "context.d.ts");
+  const contextContent = generateContextDts(bindings);
+  fs.writeFileSync(contextPath, contextContent, "utf-8");
+  return {
+    bindingCount: bindings.length,
+    files: {
+      bindings: bindingsPath,
+      context: contextPath
+    }
+  };
+}
+
 // src/plugin.ts
 async function scanClientComponents(root, state) {
-  const appDir = path2.resolve(root, state.options.appDir);
+  const appDir = path3.resolve(root, state.options.appDir);
   try {
-    await fs.promises.access(appDir);
+    await fs2.promises.access(appDir);
   } catch {
     return;
   }
   async function scanDir(dir) {
-    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
     await Promise.all(
       entries.map(async (entry) => {
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path3.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
             await scanDir(fullPath);
           }
         } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
-          const content = await fs.promises.readFile(fullPath, "utf-8");
+          const content = await fs2.promises.readFile(fullPath, "utf-8");
           if (hasUseClientDirective(content)) {
             const componentId = generateComponentId(fullPath, root);
             const bundlePath = `${state.options.hydrationEndpoint}/${componentId}.js`;
@@ -1104,14 +1575,82 @@ function cloudwerkPlugin(options = {}) {
       console.log(`[cloudwerk] Found ${state.manifest.routes.length} routes`);
     }
   }
+  async function buildQueueManifestIfExists(root) {
+    if (!state) {
+      throw new Error("Plugin state not initialized");
+    }
+    const queuesPath = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+    try {
+      await fs2.promises.access(queuesPath);
+    } catch {
+      state.queueScanResult = null;
+      state.queueManifest = null;
+      return;
+    }
+    state.queueScanResult = await scanQueues(
+      path3.resolve(root, state.options.appDir),
+      { extensions: state.options.config.extensions }
+    );
+    state.queueManifest = buildQueueManifest(
+      state.queueScanResult,
+      root,
+      { appName: "cloudwerk" }
+    );
+    if (state.options.verbose && state.queueManifest.queues.length > 0) {
+      console.log(`[cloudwerk] Found ${state.queueManifest.queues.length} queue(s)`);
+    }
+  }
+  async function buildServiceManifestIfExists(root) {
+    if (!state) {
+      throw new Error("Plugin state not initialized");
+    }
+    const servicesPath = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+    try {
+      await fs2.promises.access(servicesPath);
+    } catch {
+      state.serviceScanResult = null;
+      state.serviceManifest = null;
+      return;
+    }
+    state.serviceScanResult = await scanServices(
+      path3.resolve(root, state.options.appDir),
+      { extensions: state.options.config.extensions }
+    );
+    state.serviceManifest = buildServiceManifest(
+      state.serviceScanResult,
+      root
+    );
+    if (state.options.verbose && state.serviceManifest.services.length > 0) {
+      console.log(`[cloudwerk] Found ${state.serviceManifest.services.length} service(s)`);
+    }
+  }
   function isRouteFile(filePath) {
     if (!state) return false;
-    const appDir = path2.resolve(state.options.root, state.options.appDir);
+    const appDir = path3.resolve(state.options.root, state.options.appDir);
     if (!filePath.startsWith(appDir)) return false;
-    const basename2 = path2.basename(filePath);
+    const basename2 = path3.basename(filePath);
     const nameWithoutExt = basename2.replace(/\.(ts|tsx|js|jsx)$/, "");
     return ROUTE_FILE_NAMES.includes(nameWithoutExt);
   }
+  function isQueueFile(filePath) {
+    if (!state) return false;
+    const queuesDir = path3.resolve(state.options.root, state.options.appDir, QUEUES_DIR);
+    if (!filePath.startsWith(queuesDir)) return false;
+    const relativePath = path3.relative(queuesDir, filePath);
+    if (relativePath.includes(path3.sep)) return false;
+    const ext = path3.extname(filePath);
+    return state.options.config.extensions.includes(ext);
+  }
+  function isServiceFile(filePath) {
+    if (!state) return false;
+    const servicesDir = path3.resolve(state.options.root, state.options.appDir, SERVICES_DIR);
+    if (!filePath.startsWith(servicesDir)) return false;
+    const basename2 = path3.basename(filePath);
+    const ext = path3.extname(filePath);
+    const nameWithoutExt = basename2.replace(ext, "");
+    if (nameWithoutExt !== SERVICE_FILE_NAME) return false;
+    return state.options.config.extensions.includes(ext);
+  }
   function invalidateVirtualModules() {
     if (!server) return;
     const idsToInvalidate = [
@@ -1148,16 +1687,16 @@ function cloudwerkPlugin(options = {}) {
      */
     async configResolved(config) {
       const root = config.root;
-      let detectedServerEntry = options.serverEntry ? path2.resolve(root, options.serverEntry) : null;
+      let detectedServerEntry = options.serverEntry ? path3.resolve(root, options.serverEntry) : null;
       if (!detectedServerEntry) {
         const conventionalPaths = [
-          path2.resolve(root, "app/server.ts"),
-          path2.resolve(root, "app/server.tsx"),
-          path2.resolve(root, "src/server.ts"),
-          path2.resolve(root, "src/server.tsx")
+          path3.resolve(root, "app/server.ts"),
+          path3.resolve(root, "app/server.tsx"),
+          path3.resolve(root, "src/server.ts"),
+          path3.resolve(root, "src/server.tsx")
         ];
         for (const p of conventionalPaths) {
-          if (fs.existsSync(p)) {
+          if (fs2.existsSync(p)) {
             detectedServerEntry = p;
             if (options.verbose) {
               console.log(`[cloudwerk] Detected custom server entry: ${p}`);
@@ -1202,11 +1741,17 @@ function cloudwerkPlugin(options = {}) {
           errors: [],
           notFound: []
         },
+        queueManifest: null,
+        queueScanResult: null,
+        serviceManifest: null,
+        serviceScanResult: null,
         clientComponents: /* @__PURE__ */ new Map(),
         serverEntryCache: null,
         clientEntryCache: null
       };
       await buildManifest(root);
+      await buildQueueManifestIfExists(root);
+      await buildServiceManifestIfExists(root);
       await scanClientComponents(root, state);
     },
     /**
@@ -1215,34 +1760,98 @@ function cloudwerkPlugin(options = {}) {
     configureServer(devServer) {
       server = devServer;
       if (!state) return;
-      const appDir = path2.resolve(state.options.root, state.options.appDir);
+      const appDir = path3.resolve(state.options.root, state.options.appDir);
+      const root = state.options.root;
+      const verbose = state.options.verbose;
       devServer.watcher.on("add", async (filePath) => {
         if (isRouteFile(filePath)) {
           if (state?.options.verbose) {
-            console.log(`[cloudwerk] Route added: ${path2.relative(appDir, filePath)}`);
+            console.log(`[cloudwerk] Route added: ${path3.relative(appDir, filePath)}`);
           }
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        if (isQueueFile(filePath)) {
+          const queuesDir = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Queue added: ${path3.relative(queuesDir, filePath)}`);
+          }
+          await buildQueueManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        if (isServiceFile(filePath)) {
+          const servicesDir = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Service added: ${path3.relative(servicesDir, filePath)}`);
+          }
+          await buildServiceManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
       });
       devServer.watcher.on("unlink", async (filePath) => {
         if (isRouteFile(filePath)) {
           if (state?.options.verbose) {
-            console.log(`[cloudwerk] Route removed: ${path2.relative(appDir, filePath)}`);
+            console.log(`[cloudwerk] Route removed: ${path3.relative(appDir, filePath)}`);
           }
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        if (isQueueFile(filePath)) {
+          const queuesDir = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Queue removed: ${path3.relative(queuesDir, filePath)}`);
+          }
+          await buildQueueManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        if (isServiceFile(filePath)) {
+          const servicesDir = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Service removed: ${path3.relative(servicesDir, filePath)}`);
+          }
+          await buildServiceManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
       });
       devServer.watcher.on("change", async (filePath) => {
         if (isRouteFile(filePath)) {
           if (state?.options.verbose) {
-            console.log(`[cloudwerk] Route changed: ${path2.relative(appDir, filePath)}`);
+            console.log(`[cloudwerk] Route changed: ${path3.relative(appDir, filePath)}`);
           }
           await buildManifest(state.options.root);
           invalidateVirtualModules();
         }
+        if (isQueueFile(filePath)) {
+          const queuesDir = path3.resolve(root, state.options.appDir, QUEUES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Queue changed: ${path3.relative(queuesDir, filePath)}`);
+          }
+          await buildQueueManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        if (isServiceFile(filePath)) {
+          const servicesDir = path3.resolve(root, state.options.appDir, SERVICES_DIR);
+          if (state?.options.verbose) {
+            console.log(`[cloudwerk] Service changed: ${path3.relative(servicesDir, filePath)}`);
+          }
+          await buildServiceManifestIfExists(state.options.root);
+          invalidateVirtualModules();
+        }
+        const wranglerPath2 = findWranglerTomlPath(root);
+        if (wranglerPath2 && filePath === wranglerPath2) {
+          if (verbose) {
+            console.log(`[cloudwerk] wrangler.toml changed, regenerating types...`);
+          }
+          const result = regenerateCloudwerkTypes(root);
+          if (result && verbose) {
+            console.log(`[cloudwerk] Regenerated .cloudwerk/types/ with ${result.bindingCount} binding(s)`);
+          }
+        }
       });
+      const wranglerPath = findWranglerTomlPath(root);
+      if (wranglerPath) {
+        devServer.watcher.add(wranglerPath);
+      }
     },
     /**
      * Resolve virtual module IDs.
@@ -1272,7 +1881,11 @@ function cloudwerkPlugin(options = {}) {
           state.serverEntryCache = generateServerEntry(
             state.manifest,
             state.scanResult,
-            state.options
+            state.options,
+            {
+              queueManifest: state.queueManifest,
+              serviceManifest: state.serviceManifest
+            }
           );
         }
         return state.serverEntryCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudwerk/vite-plugin",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Vite plugin for Cloudwerk file-based routing with virtual entry generation",
   "repository": {
     "type": "git",
@@ -19,8 +19,8 @@
   ],
   "dependencies": {
     "@swc/core": "^1.3.100",
-    "@cloudwerk/core": "^0.11.0",
-    "@cloudwerk/ui": "^0.11.0"
+    "@cloudwerk/core": "^0.13.0",
+    "@cloudwerk/ui": "^0.13.0"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0",