@b9g/platform 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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/config.d.ts

@@ -56,10 +56,19 @@ export interface BucketConfig {
     region?: string | number;
     endpoint?: string | number;
 }
+/** Log level for filtering */
+export type LogLevel = "debug" | "info" | "warning" | "error";
+export interface LoggingConfig {
+    /** Default log level. Defaults to "error" */
+    level?: LogLevel;
+    /** Per-category log levels (overrides default) */
+    categories?: Record<string, LogLevel>;
+}
 export interface ShovelConfig {
     port?: number | string;
     host?: string;
     workers?: number | string;
+    logging?: LoggingConfig;
     caches?: Record<string, CacheConfig>;
     buckets?: Record<string, BucketConfig>;
 }
@@ -67,6 +76,7 @@ export interface ProcessedShovelConfig {
     port: number;
     host: string;
     workers: number;
+    logging: Required<LoggingConfig>;
     caches: Record<string, CacheConfig>;
     buckets: Record<string, BucketConfig>;
 }
@@ -76,6 +86,17 @@ export interface ProcessedShovelConfig {
  * @param cwd - Current working directory (must be provided by runtime adapter)
  */
 export declare function loadConfig(cwd: string): ProcessedShovelConfig;
+/**
+ * Configure LogTape logging based on Shovel config.
+ * Call this in both main thread and workers.
+ *
+ * @param loggingConfig - The logging configuration from ProcessedShovelConfig.logging
+ * @param options - Additional options
+ * @param options.reset - Whether to reset existing LogTape config (default: true)
+ */
+export declare function configureLogging(loggingConfig: Required<LoggingConfig>, options?: {
+    reset?: boolean;
+}): Promise<void>;
 /**
  * Get cache config for a specific cache name (with pattern matching)
  */

package/src/config.js

@@ -3,6 +3,7 @@
 import { readFileSync } from "fs";
 import { resolve } from "path";
 import { Cache } from "@b9g/cache";
+import { configure, getConsoleSink } from "@logtape/logtape";
 function getEnv() {
   if (typeof import.meta !== "undefined" && import.meta.env) {
     return import.meta.env;
@@ -395,11 +396,52 @@ function loadConfig(cwd) {
     port: typeof processed.port === "number" ? processed.port : 3e3,
     host: processed.host || "localhost",
     workers: typeof processed.workers === "number" ? processed.workers : 1,
+    logging: {
+      level: processed.logging?.level || "error",
+      categories: processed.logging?.categories || {}
+    },
     caches: processed.caches || {},
     buckets: processed.buckets || {}
   };
   return config;
 }
+var SHOVEL_CATEGORIES = [
+  "cli",
+  "watcher",
+  "worker",
+  "single-threaded",
+  "assets",
+  "platform-node",
+  "platform-bun",
+  "platform-cloudflare",
+  "cache",
+  "cache-redis",
+  "router"
+];
+async function configureLogging(loggingConfig, options = {}) {
+  const { level, categories } = loggingConfig;
+  const reset = options.reset !== false;
+  const loggers = SHOVEL_CATEGORIES.map((category) => {
+    const categoryLevel = categories[category] || level;
+    return {
+      category: [category],
+      level: categoryLevel,
+      sinks: ["console"]
+    };
+  });
+  loggers.push({
+    category: ["logtape", "meta"],
+    level: "warning",
+    sinks: []
+  });
+  await configure({
+    reset,
+    sinks: {
+      console: getConsoleSink()
+    },
+    loggers
+  });
+}
 function getCacheConfig(config, name) {
   return matchPattern(name, config.caches) || {};
 }
@@ -506,6 +548,7 @@ For redis: npm install @b9g/cache-redis`
   };
 }
 export {
+  configureLogging,
   createBucketFactory,
   createCacheFactory,
   getBucketConfig,

package/src/index.d.ts

@@ -192,4 +192,4 @@ export { SingleThreadedRuntime, type SingleThreadedRuntimeOptions, } from "./sin
 export { ShovelServiceWorkerRegistration, ShovelGlobalScope, FetchEvent, InstallEvent, ActivateEvent, ExtendableEvent, } from "./runtime.js";
 export { RequestCookieStore, type CookieListItem, type CookieInit, type CookieStoreGetOptions, type CookieStoreDeleteOptions, type CookieSameSite, type CookieList, parseCookieHeader, serializeCookie, parseSetCookieHeader, } from "./cookie-store.js";
 export { CustomBucketStorage } from "@b9g/filesystem";
-export { loadConfig, getCacheConfig, getBucketConfig, parseConfigExpr, processConfigValue, matchPattern, createBucketFactory, createCacheFactory, type ShovelConfig, type CacheConfig, type BucketConfig, type BucketFactoryOptions, type CacheFactoryOptions, type ProcessedShovelConfig, } from "./config.js";
+export { loadConfig, configureLogging, getCacheConfig, getBucketConfig, parseConfigExpr, processConfigValue, matchPattern, createBucketFactory, createCacheFactory, type ShovelConfig, type CacheConfig, type BucketConfig, type LoggingConfig, type LogLevel, type BucketFactoryOptions, type CacheFactoryOptions, type ProcessedShovelConfig, } from "./config.js";

package/src/index.js

@@ -27,6 +27,7 @@ import {
 import { CustomBucketStorage } from "@b9g/filesystem";
 import {
   loadConfig,
+  configureLogging,
   getCacheConfig,
   getBucketConfig,
   parseConfigExpr,
@@ -237,6 +238,7 @@ export {
   ShovelGlobalScope,
   ShovelServiceWorkerRegistration,
   SingleThreadedRuntime,
+  configureLogging,
   createBucketFactory,
   createCacheFactory,
   createPlatform,

package/src/runtime.js

@@ -6,6 +6,7 @@ import { CustomBucketStorage } from "@b9g/filesystem";
 import { CustomCacheStorage } from "@b9g/cache";
 import { createBucketFactory, createCacheFactory } from "./config.js";
 import { getLogger } from "@logtape/logtape";
+import { configureLogging } from "./config.js";
 if (import.meta.env && !import.meta.env.MODE && import.meta.env.NODE_ENV) {
   import.meta.env.MODE = import.meta.env.NODE_ENV;
 }
@@ -817,7 +818,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 +833,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 +866,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 +882,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);
@@ -903,6 +900,9 @@ var workerId = Math.random().toString(36).substring(2, 8);
 var sendMessage;
 async function initializeRuntime(config, baseDir) {
   try {
+    if (config?.logging) {
+      await configureLogging(config.logging);
+    }
     logger.info(`[Worker-${workerId}] Initializing runtime with config`, {
       config,
       baseDir
@@ -932,8 +932,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, {

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

@@ -5,6 +5,7 @@ import { ShovelGlobalScope, ShovelServiceWorkerRegistration } from "./runtime.js
 import { CustomBucketStorage } from "@b9g/filesystem";
 import { CustomCacheStorage } from "@b9g/cache";
 import {
+  configureLogging,
   createBucketFactory,
   createCacheFactory
 } from "./config.js";
@@ -34,37 +35,38 @@ var SingleThreadedRuntime = class {
    * Initialize the runtime (install scope as globalThis.self)
    */
   async init() {
+    if (this.#config?.logging) {
+      await configureLogging(this.#config.logging);
+    }
     this.#scope.install();
     logger.info("SingleThreadedRuntime initialized - scope installed");
   }
   /**
    * 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