@b9g/platform 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "ServiceWorker-first universal deployment platform. Write ServiceWorker apps once, deploy anywhere (Node/Bun/Cloudflare). Registry-based multi-app orchestration.",
   "keywords": [
     "serviceworker",
@@ -17,7 +17,7 @@
   "dependencies": {
     "@b9g/async-context": "^0.1.1",
     "@b9g/cache": "^0.1.4",
-    "@b9g/filesystem": "^0.1.5",
+    "@b9g/filesystem": "^0.1.6",
     "@logtape/logtape": "^1.2.0"
   },
   "devDependencies": {

package/src/runtime.js

@@ -817,7 +817,7 @@ var scope = null;
 var _workerSelf = null;
 var currentApp = null;
 var serviceWorkerReady = false;
-var loadedVersion = null;
+var loadedEntrypoint = null;
 var caches;
 var buckets;
 async function handleFetchEvent(request) {
@@ -832,27 +832,23 @@ async function handleFetchEvent(request) {
     return response;
   } catch (error) {
     logger.error("[Worker] ServiceWorker request failed", { error });
+    console.error("[Worker] ServiceWorker request failed:", error);
     const response = new Response("ServiceWorker request failed", {
       status: 500
     });
     return response;
   }
 }
-async function loadServiceWorker(version, entrypoint) {
+async function loadServiceWorker(entrypoint) {
   try {
     logger.debug("loadServiceWorker called", {
-      version,
-      loadedVersion
+      entrypoint,
+      loadedEntrypoint
     });
-    if (!entrypoint) {
-      throw new Error(
-        "ServiceWorker entrypoint must be provided via loadServiceWorker() call"
-      );
-    }
     logger.info("[Worker] Loading from", { entrypoint });
-    if (loadedVersion !== null && loadedVersion !== version) {
+    if (loadedEntrypoint !== null && loadedEntrypoint !== entrypoint) {
       logger.info(
-        `[Worker] Hot reload detected: ${loadedVersion} -> ${version}`
+        `[Worker] Hot reload detected: ${loadedEntrypoint} -> ${entrypoint}`
       );
       logger.info("[Worker] Creating completely fresh ServiceWorker context");
       registration = new ShovelServiceWorkerRegistration();
@@ -869,14 +865,14 @@ async function loadServiceWorker(version, entrypoint) {
       currentApp = null;
       serviceWorkerReady = false;
     }
-    if (loadedVersion === version) {
-      logger.info("[Worker] ServiceWorker already loaded for version", {
-        version
+    if (loadedEntrypoint === entrypoint) {
+      logger.info("[Worker] ServiceWorker already loaded for entrypoint", {
+        entrypoint
       });
       return;
     }
-    const appModule = await import(`${entrypoint}?v=${version}`);
-    loadedVersion = version;
+    const appModule = await import(entrypoint);
+    loadedEntrypoint = entrypoint;
     currentApp = appModule;
     if (!registration) {
       throw new Error("ServiceWorker runtime not initialized");
@@ -885,7 +881,7 @@ async function loadServiceWorker(version, entrypoint) {
     await registration.activate();
     serviceWorkerReady = true;
     logger.info(
-      `[Worker] ServiceWorker loaded and activated (v${version}) from ${entrypoint}`
+      `[Worker] ServiceWorker loaded and activated from ${entrypoint}`
     );
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -932,8 +928,8 @@ async function handleMessage(message) {
       sendMessage({ type: "initialized" });
     } else if (message.type === "load") {
       const loadMsg = message;
-      await loadServiceWorker(loadMsg.version, loadMsg.entrypoint);
-      sendMessage({ type: "ready", version: loadMsg.version });
+      await loadServiceWorker(loadMsg.entrypoint);
+      sendMessage({ type: "ready", entrypoint: loadMsg.entrypoint });
     } else if (message.type === "request") {
       const reqMsg = message;
       const request = new Request(reqMsg.request.url, {
@@ -943,12 +939,16 @@ async function handleMessage(message) {
       });
       const response = await handleFetchEvent(request);
       const body = await response.arrayBuffer();
+      const headers = Object.fromEntries(response.headers.entries());
+      if (!headers["Content-Type"] && !headers["content-type"]) {
+        headers["Content-Type"] = "text/plain; charset=utf-8";
+      }
       const responseMsg = {
         type: "response",
         response: {
           status: response.status,
           statusText: response.statusText,
-          headers: Object.fromEntries(response.headers.entries()),
+          headers,
           body
         },
         requestID: reqMsg.requestID

package/src/single-threaded.d.ts

@@ -31,12 +31,14 @@ export declare class SingleThreadedRuntime {
     init(): Promise<void>;
     /**
      * Load and run a ServiceWorker entrypoint
+     * @param entrypoint - Path to the new entrypoint (hashed filename for cache busting)
      */
-    reloadWorkers(version?: number | string): Promise<void>;
+    reloadWorkers(entrypoint: string): Promise<void>;
     /**
      * Load a ServiceWorker entrypoint for the first time
+     * @param entrypoint - Path to the entrypoint file (content-hashed filename)
      */
-    loadEntrypoint(entrypoint: string, version?: number | string): Promise<void>;
+    loadEntrypoint(entrypoint: string): Promise<void>;
     /**
      * Handle an HTTP request
      * This is the key method - direct call, no postMessage!

package/src/single-threaded.js

@@ -39,32 +39,30 @@ var SingleThreadedRuntime = class {
   }
   /**
    * Load and run a ServiceWorker entrypoint
+   * @param entrypoint - Path to the new entrypoint (hashed filename for cache busting)
    */
-  async reloadWorkers(version) {
-    if (!this.#entrypoint) {
-      throw new Error("No entrypoint set - call loadEntrypoint first");
-    }
+  async reloadWorkers(entrypoint) {
     logger.info("Reloading ServiceWorker", {
-      version,
-      entrypoint: this.#entrypoint
+      oldEntrypoint: this.#entrypoint,
+      newEntrypoint: entrypoint
     });
-    const importPath = version ? `${this.#entrypoint}?v=${version}` : this.#entrypoint;
+    this.#entrypoint = entrypoint;
     this.#registration._serviceWorker._setState("parsed");
     this.#ready = false;
-    await import(importPath);
+    await import(entrypoint);
     await this.#registration.install();
     await this.#registration.activate();
     this.#ready = true;
-    logger.info("ServiceWorker loaded and activated", { version });
+    logger.info("ServiceWorker loaded and activated", { entrypoint });
   }
   /**
    * Load a ServiceWorker entrypoint for the first time
+   * @param entrypoint - Path to the entrypoint file (content-hashed filename)
    */
-  async loadEntrypoint(entrypoint, version) {
+  async loadEntrypoint(entrypoint) {
     this.#entrypoint = entrypoint;
-    logger.info("Loading ServiceWorker entrypoint", { entrypoint, version });
-    const importPath = version ? `${entrypoint}?v=${version}` : entrypoint;
-    await import(importPath);
+    logger.info("Loading ServiceWorker entrypoint", { entrypoint });
+    await import(entrypoint);
     await this.#registration.install();
     await this.#registration.activate();
     this.#ready = true;

package/src/worker-pool.d.ts

@@ -38,12 +38,11 @@ export interface WorkerResponse extends WorkerMessage {
 }
 export interface WorkerLoadMessage extends WorkerMessage {
     type: "load";
-    version: number | string;
-    entrypoint?: string;
+    entrypoint: string;
 }
 export interface WorkerReadyMessage extends WorkerMessage {
     type: "ready" | "worker-ready";
-    version?: number | string;
+    entrypoint?: string;
 }
 export interface WorkerErrorMessage extends WorkerMessage {
     type: "error";
@@ -75,9 +74,10 @@ export declare class ServiceWorkerPool {
      */
     handleRequest(request: Request): Promise<Response>;
     /**
-     * Reload ServiceWorker with new version (hot reload simulation)
+     * Reload ServiceWorker with new entrypoint (hot reload)
+     * The entrypoint path contains a content hash for cache busting
      */
-    reloadWorkers(version?: number | string): Promise<void>;
+    reloadWorkers(entrypoint: string): Promise<void>;
     /**
      * Graceful shutdown of all workers
      */

package/src/worker-pool.js

@@ -251,7 +251,7 @@ var ServiceWorkerPool = class {
   }
   #handleReady(message) {
     if (message.type === "ready") {
-      logger.info("ServiceWorker ready", { version: message.version });
+      logger.info("ServiceWorker ready", { entrypoint: message.entrypoint });
     } else if (message.type === "worker-ready") {
       logger.info("Worker initialized", {});
     }
@@ -303,10 +303,12 @@ var ServiceWorkerPool = class {
     }
   }
   /**
-   * Reload ServiceWorker with new version (hot reload simulation)
+   * Reload ServiceWorker with new entrypoint (hot reload)
+   * The entrypoint path contains a content hash for cache busting
    */
-  async reloadWorkers(version = Date.now()) {
-    logger.info("Reloading ServiceWorker", { version });
+  async reloadWorkers(entrypoint) {
+    logger.info("Reloading ServiceWorker", { entrypoint });
+    this.#appEntrypoint = entrypoint;
     const loadPromises = this.#workers.map((worker) => {
       return new Promise((resolve, reject) => {
         let timeoutId;
@@ -319,7 +321,7 @@ var ServiceWorkerPool = class {
         };
         const handleReady = (event) => {
           const message = event.data || event;
-          if (message.type === "ready" && message.version === version) {
+          if (message.type === "ready" && message.entrypoint === entrypoint) {
             cleanup();
             resolve();
           } else if (message.type === "error") {
@@ -340,30 +342,27 @@ var ServiceWorkerPool = class {
           cleanup();
           reject(
             new Error(
-              `Worker failed to load ServiceWorker within 30000ms (version ${version})`
+              `Worker failed to load ServiceWorker within 30000ms (entrypoint ${entrypoint})`
             )
           );
         }, 3e4);
         logger.info("Sending load message", {
-          version,
-          entrypoint: this.#appEntrypoint
+          entrypoint
         });
         worker.addEventListener("message", handleReady);
         worker.addEventListener("error", handleError);
         const loadMessage = {
           type: "load",
-          version,
-          entrypoint: this.#appEntrypoint
+          entrypoint
         };
         logger.debug("[WorkerPool] Sending load message", {
-          entrypoint: this.#appEntrypoint,
-          version
+          entrypoint
         });
         worker.postMessage(loadMessage);
       });
     });
     await Promise.all(loadPromises);
-    logger.info("All workers reloaded", { version });
+    logger.info("All workers reloaded", { entrypoint });
   }
   /**
    * Graceful shutdown of all workers