@zappdev/vite 0.5.0-alpha.3 → 0.6.0-alpha.0

package/dist/index.js

@@ -73,19 +73,37 @@ async function bundleWorker(entry, outDir, aliases) {
     return false;
   }
 }
+function resolveHeadlessEntries(root, headless) {
+  if (!headless)
+    return [];
+  const entries = [];
+  for (const [id, srcPath] of Object.entries(headless)) {
+    const abs = path.resolve(root, srcPath);
+    if (!existsSync(abs)) {
+      console.warn(`[zapp] headless worker "${id}" not found at ${srcPath}`);
+      continue;
+    }
+    entries.push({
+      specifier: srcPath,
+      sourcePath: abs,
+      outputName: `_headless_${id}.mjs`,
+      outputUrl: `/_workers/_headless_${id}.mjs`
+    });
+  }
+  return entries;
+}
 function zappWorkers(options) {
   let root = "";
   let srcDir = "";
   let workers = [];
-  let backendEntry = null;
+  let headlessEntries = [];
   let aliases = {};
   let isDev = false;
   let outDir = "";
-  let backendFromConfig = options?.backend;
   return {
     name: "zapp-workers",
     enforce: "pre",
-    async configResolved(config) {
+    configResolved(config) {
       root = config.root;
       srcDir = path.join(root, "src");
       outDir = path.join(root, "dist", "_workers");
@@ -94,33 +112,15 @@ function zappWorkers(options) {
       if (resolvedAlias && typeof resolvedAlias === "object" && !Array.isArray(resolvedAlias)) {
         aliases = resolvedAlias;
       }
-      if (!backendFromConfig) {
-        try {
-          const configPath = path.join(root, "zapp.config.ts");
-          const mod = await import(configPath);
-          const zappConfig = typeof mod.default === "function" ? mod.default() : mod.default;
-          if (zappConfig?.backend) {
-            backendFromConfig = zappConfig.backend;
-          }
-        } catch {}
-      }
     },
     async buildStart() {
       workers = await discoverWorkers(srcDir);
-      const backendSrc = backendFromConfig ? path.resolve(root, backendFromConfig) : path.join(srcDir, "backend.ts");
-      if (existsSync(backendSrc)) {
-        backendEntry = {
-          specifier: path.relative(srcDir, backendSrc),
-          sourcePath: backendSrc,
-          outputName: "backend.mjs",
-          outputUrl: "/_workers/backend.mjs"
-        };
-      }
+      headlessEntries = resolveHeadlessEntries(root, options?.headless);
       if (workers.length > 0) {
         console.log(`[zapp] discovered ${workers.length} worker(s)`);
       }
-      if (backendEntry) {
-        console.log(`[zapp] backend worker: ${path.relative(root, backendSrc)}`);
+      for (const entry of headlessEntries) {
+        console.log(`[zapp] headless worker: ${path.relative(root, entry.sourcePath)}`);
       }
     },
     transform(code, id) {
@@ -145,18 +145,8 @@ function zappWorkers(options) {
       const devOutDir = path.join(root, ".zapp", "workers");
       await mkdir(devOutDir, { recursive: true });
       workers = await discoverWorkers(srcDir);
-      const backendSrc = backendFromConfig ? path.resolve(root, backendFromConfig) : path.join(srcDir, "backend.ts");
-      if (existsSync(backendSrc)) {
-        backendEntry = {
-          specifier: path.relative(srcDir, backendSrc),
-          sourcePath: backendSrc,
-          outputName: "backend.mjs",
-          outputUrl: "/_workers/backend.mjs"
-        };
-      }
-      const allEntries = [...workers];
-      if (backendEntry)
-        allEntries.push(backendEntry);
+      headlessEntries = resolveHeadlessEntries(root, options?.headless);
+      const allEntries = [...workers, ...headlessEntries];
       for (const entry of allEntries) {
         const ok = await bundleWorker(entry, devOutDir, aliases);
         if (ok)
@@ -181,9 +171,7 @@ function zappWorkers(options) {
       if (isDev)
         return;
       await mkdir(outDir, { recursive: true });
-      const allEntries = [...workers];
-      if (backendEntry)
-        allEntries.push(backendEntry);
+      const allEntries = [...workers, ...headlessEntries];
       for (const entry of allEntries) {
         const ok = await bundleWorker(entry, outDir, aliases);
         if (ok) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zappdev/vite",
-  "version": "0.5.0-alpha.3",
+  "version": "0.6.0-alpha.0",
   "type": "module",
   "exports": {
     ".": {

package/src/index.ts

@@ -105,25 +105,47 @@ async function bundleWorker(entry: WorkerEntry, outDir: string, aliases: Record<
 }
 
 interface ZappWorkersOptions {
-  /** Path to backend worker source, relative to project root. Overrides zapp.config.ts. */
-  backend?: string;
+  /**
+   * Headless workers to bundle, keyed by ID. Values are source paths relative
+   * to project root. Output URL is `/_workers/_headless_<id>.mjs` — the native
+   * runtime loads these at app startup via generated Zen-C code.
+   */
+  headless?: Record<string, string>;
+}
+
+function resolveHeadlessEntries(root: string, headless?: Record<string, string>): WorkerEntry[] {
+  if (!headless) return [];
+  const entries: WorkerEntry[] = [];
+  for (const [id, srcPath] of Object.entries(headless)) {
+    const abs = path.resolve(root, srcPath);
+    if (!existsSync(abs)) {
+      console.warn(`[zapp] headless worker "${id}" not found at ${srcPath}`);
+      continue;
+    }
+    entries.push({
+      specifier: srcPath,
+      sourcePath: abs,
+      outputName: `_headless_${id}.mjs`,
+      outputUrl: `/_workers/_headless_${id}.mjs`,
+    });
+  }
+  return entries;
 }
 
 export function zappWorkers(options?: ZappWorkersOptions): Plugin {
   let root = "";
   let srcDir = "";
   let workers: WorkerEntry[] = [];
-  let backendEntry: WorkerEntry | null = null;
+  let headlessEntries: WorkerEntry[] = [];
   let aliases: Record<string, string> = {};
   let isDev = false;
   let outDir = "";
-  let backendFromConfig = options?.backend;
 
   return {
     name: "zapp-workers",
     enforce: "pre",
 
-    async configResolved(config) {
+    configResolved(config) {
       root = config.root;
       srcDir = path.join(root, "src");
       outDir = path.join(root, "dist", "_workers");
@@ -134,44 +156,20 @@ export function zappWorkers(options?: ZappWorkersOptions): Plugin {
       if (resolvedAlias && typeof resolvedAlias === "object" && !Array.isArray(resolvedAlias)) {
         aliases = resolvedAlias as Record<string, string>;
       }
-
-      // Auto-read backend path from zapp.config.ts if not passed as option
-      if (!backendFromConfig) {
-        try {
-          const configPath = path.join(root, "zapp.config.ts");
-          const mod = await import(configPath);
-          const zappConfig = typeof mod.default === "function" ? mod.default() : mod.default;
-          if (zappConfig?.backend) {
-            backendFromConfig = zappConfig.backend;
-          }
-        } catch {
-          // No zapp.config.ts or no backend field — that's fine
-        }
-      }
     },
 
     async buildStart() {
-      // Discover workers from source
+      // Webview-spawned workers: discovered by scanning source.
       workers = await discoverWorkers(srcDir);
 
-      // Backend worker — path from config, or fall back to src/backend.ts convention
-      const backendSrc = backendFromConfig
-        ? path.resolve(root, backendFromConfig)
-        : path.join(srcDir, "backend.ts");
-      if (existsSync(backendSrc)) {
-        backendEntry = {
-          specifier: path.relative(srcDir, backendSrc),
-          sourcePath: backendSrc,
-          outputName: "backend.mjs",
-          outputUrl: "/_workers/backend.mjs",
-        };
-      }
+      // Headless workers: declared in zapp.config.ts.
+      headlessEntries = resolveHeadlessEntries(root, options?.headless);
 
       if (workers.length > 0) {
         console.log(`[zapp] discovered ${workers.length} worker(s)`);
       }
-      if (backendEntry) {
-        console.log(`[zapp] backend worker: ${path.relative(root, backendSrc)}`);
+      for (const entry of headlessEntries) {
+        console.log(`[zapp] headless worker: ${path.relative(root, entry.sourcePath)}`);
       }
     },
 
@@ -198,9 +196,10 @@ export function zappWorkers(options?: ZappWorkersOptions): Plugin {
     },
 
     // Dev: bundle workers eagerly so they exist on disk before the native
-    // binary launches. The backend worker is loaded directly by native code
-    // and never goes through HTTP, so a lazy-on-request middleware would never
-    // bundle it. Eager bundling also lets native fall back to filesystem.
+    // binary launches. Headless workers are loaded directly by native code
+    // via the generated .zapp/zapp_headless_workers.zc, so a lazy-on-request
+    // middleware would never bundle them. Eager bundling also lets native
+    // fall back to filesystem.
     //
     // configureServer runs before buildStart, so we re-discover workers here
     // (buildStart's results aren't yet available).
@@ -209,21 +208,9 @@ export function zappWorkers(options?: ZappWorkersOptions): Plugin {
       await mkdir(devOutDir, { recursive: true });
 
       workers = await discoverWorkers(srcDir);
-      const backendSrc = backendFromConfig
-        ? path.resolve(root, backendFromConfig)
-        : path.join(srcDir, "backend.ts");
-      if (existsSync(backendSrc)) {
-        backendEntry = {
-          specifier: path.relative(srcDir, backendSrc),
-          sourcePath: backendSrc,
-          outputName: "backend.mjs",
-          outputUrl: "/_workers/backend.mjs",
-        };
-      }
-
-      const allEntries = [...workers];
-      if (backendEntry) allEntries.push(backendEntry);
+      headlessEntries = resolveHeadlessEntries(root, options?.headless);
 
+      const allEntries = [...workers, ...headlessEntries];
       for (const entry of allEntries) {
         const ok = await bundleWorker(entry, devOutDir, aliases);
         if (ok) console.log(`[zapp] dev-bundled worker: ${entry.outputName}`);
@@ -254,8 +241,7 @@ export function zappWorkers(options?: ZappWorkersOptions): Plugin {
 
       await mkdir(outDir, { recursive: true });
 
-      const allEntries = [...workers];
-      if (backendEntry) allEntries.push(backendEntry);
+      const allEntries = [...workers, ...headlessEntries];
 
       for (const entry of allEntries) {
         const ok = await bundleWorker(entry, outDir, aliases);