@b9g/platform 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/platform",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "The portable meta-framework built on web standards.",
   "keywords": [
     "service-worker",

package/src/globals.d.ts

@@ -124,10 +124,7 @@ declare global {
 	interface Window {
 		addEventListener<K extends keyof WorkerGlobalScopeEventMap>(
 			type: K,
-			listener: (
-				this: Window,
-				ev: WorkerGlobalScopeEventMap[K],
-			) => any,
+			listener: (this: Window, ev: WorkerGlobalScopeEventMap[K]) => any,
 			options?: boolean | AddEventListenerOptions,
 		): void;
 	}

package/src/index.d.ts

@@ -238,3 +238,4 @@ export declare class ServiceWorkerPool {
 export { CustomLoggerStorage, type LoggerStorage };
 export type { LoggerFactory } from "./runtime.js";
 export { CustomDatabaseStorage, createDatabaseFactory, type DatabaseStorage, type DatabaseConfig, type DatabaseFactory, type DatabaseUpgradeEvent, } from "./runtime.js";
+export type { BroadcastChannelBackend } from "./internal/broadcast-channel-backend.js";

package/src/index.js

@@ -230,6 +230,16 @@ var ServiceWorkerPool = class {
               });
             }
           }
+        } else if (message.type === "broadcast:post") {
+          for (const w of this.#workers) {
+            if (w !== worker) {
+              w.postMessage({
+                type: "broadcast:deliver",
+                channel: message.channel,
+                data: message.data
+              });
+            }
+          }
         }
         break;
     }

package/src/internal/broadcast-channel-backend.d.ts

@@ -0,0 +1,15 @@
+/**
+ * BroadcastChannel Backend Interface
+ *
+ * Pluggable backend for cross-process/cross-machine BroadcastChannel relay.
+ * When configured, replaces the postMessage relay (the backend handles both
+ * cross-worker and cross-process pub/sub).
+ */
+export interface BroadcastChannelBackend {
+    /** Publish a message to a channel (called when local BC posts) */
+    publish(channelName: string, data: unknown): void;
+    /** Subscribe to a channel (called when first BC instance for a name is created) */
+    subscribe(channelName: string, callback: (data: unknown) => void): () => void;
+    /** Cleanup connections */
+    dispose(): Promise<void>;
+}

package/src/internal/broadcast-channel.d.ts

@@ -0,0 +1,36 @@
+/// <reference path="../globals.d.ts" />
+/// <reference path="../shovel-config.d.ts" />
+/**
+ * BroadcastChannel - WHATWG standard for cross-context pub/sub
+ * https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
+ *
+ * In-memory implementation with cross-worker relay and pluggable backend support.
+ * - Local fan-out: messages delivered to all same-name channels in this process
+ * - Relay: messages forwarded to other workers via postMessage (set by startWorkerMessageLoop)
+ * - Backend: messages published to external pub/sub (e.g. Redis) for cross-process delivery
+ */
+import type { BroadcastChannelBackend } from "./broadcast-channel-backend.js";
+/**
+ * Set the relay function for cross-worker message forwarding.
+ * Called by startWorkerMessageLoop or Bun worker template.
+ */
+export declare function setBroadcastChannelRelay(fn: (channelName: string, data: unknown) => void): void;
+/**
+ * Deliver a message from relay/backend to all local instances on a channel.
+ * Does NOT re-relay — prevents infinite loops.
+ */
+export declare function deliverBroadcastMessage(channelName: string, data: unknown): void;
+/**
+ * Set a pluggable backend for cross-process BroadcastChannel relay.
+ * When set, publish goes through the backend instead of postMessage relay.
+ */
+export declare function setBroadcastChannelBackend(b: BroadcastChannelBackend): void;
+export declare class ShovelBroadcastChannel extends EventTarget {
+    #private;
+    readonly name: string;
+    onmessage: ((ev: MessageEvent) => any) | null;
+    onmessageerror: ((ev: MessageEvent) => any) | null;
+    constructor(name: string);
+    postMessage(message: unknown): void;
+    close(): void;
+}

package/src/runtime.d.ts

@@ -13,6 +13,7 @@
  */
 import { CustomDirectoryStorage } from "@b9g/filesystem";
 import { CustomCacheStorage, Cache } from "@b9g/cache";
+import type { BroadcastChannelBackend } from "./internal/broadcast-channel-backend.js";
 declare global {
     interface CookieListItem {
         domain?: string;
@@ -626,7 +627,7 @@ export declare class DedicatedWorkerGlobalScope extends WorkerGlobalScope {
  *
  * Use restore() to revert all patches (useful for testing).
  */
-export declare class ServiceWorkerGlobals implements ServiceWorkerGlobalScope {
+export declare class ServiceWorkerGlobals {
     #private;
     readonly self: any;
     readonly registration: ServiceWorkerRegistration;
@@ -725,6 +726,10 @@ export interface ShovelConfig {
     caches?: Record<string, CacheConfig>;
     directories?: Record<string, DirectoryConfig>;
     databases?: Record<string, DatabaseConfig>;
+    broadcastChannel?: {
+        impl?: (new (options: Record<string, unknown>) => BroadcastChannelBackend) | ((options: Record<string, unknown>) => BroadcastChannelBackend);
+        [key: string]: unknown;
+    };
 }
 /**
  * Creates a directory factory function for CustomDirectoryStorage.
@@ -882,4 +887,5 @@ export interface ProcessedLoggingConfig {
  * @param loggingConfig - The logging configuration
  */
 export declare function configureLogging(loggingConfig: LoggingConfig): Promise<void>;
-export {};
+export { ShovelBroadcastChannel, setBroadcastChannelRelay, deliverBroadcastMessage, setBroadcastChannelBackend, } from "./internal/broadcast-channel.js";
+export type { BroadcastChannelBackend } from "./internal/broadcast-channel-backend.js";

package/src/runtime.js

@@ -5,6 +5,117 @@ import { getLogger, getConsoleSink } from "@logtape/logtape";
 import { CustomDirectoryStorage } from "@b9g/filesystem";
 import { CustomCacheStorage } from "@b9g/cache";
 import { handleCacheResponse, PostMessageCache } from "@b9g/cache/postmessage";
+
+// src/internal/broadcast-channel.ts
+var channels = /* @__PURE__ */ new Map();
+var relayFn = null;
+var backend = null;
+var backendSubscriptions = /* @__PURE__ */ new Map();
+function setBroadcastChannelRelay(fn) {
+  relayFn = fn;
+}
+function deliverBroadcastMessage(channelName, data) {
+  const set = channels.get(channelName);
+  if (!set)
+    return;
+  for (const ch of set) {
+    queueMicrotask(() => {
+      const cloned = structuredClone(data);
+      const event = new MessageEvent("message", { data: cloned });
+      ch.dispatchEvent(event);
+      ch.onmessage?.call(ch, event);
+    });
+  }
+}
+function setBroadcastChannelBackend(b) {
+  backend = b;
+}
+var ShovelBroadcastChannel = class extends EventTarget {
+  name;
+  #closed;
+  // Event handler properties (Web API compat)
+  onmessage;
+  onmessageerror;
+  constructor(name) {
+    super();
+    this.name = name;
+    this.#closed = false;
+    this.onmessage = null;
+    this.onmessageerror = null;
+    let set = channels.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      channels.set(name, set);
+    }
+    set.add(this);
+    if (backend && !backendSubscriptions.has(name)) {
+      const unsub = backend.subscribe(name, (data) => {
+        deliverBroadcastMessage(name, data);
+      });
+      backendSubscriptions.set(name, unsub);
+    }
+  }
+  postMessage(message) {
+    if (this.#closed) {
+      throw new DOMException("BroadcastChannel is closed", "InvalidStateError");
+    }
+    let data;
+    try {
+      data = structuredClone(message);
+    } catch (error) {
+      const set2 = channels.get(this.name);
+      if (!set2)
+        return;
+      for (const ch of set2) {
+        if (ch !== this && !ch.#closed) {
+          queueMicrotask(() => {
+            const event = new MessageEvent("messageerror");
+            ch.dispatchEvent(event);
+            ch.onmessageerror?.call(ch, event);
+          });
+        }
+      }
+      return;
+    }
+    const set = channels.get(this.name);
+    if (set) {
+      for (const ch of set) {
+        if (ch !== this && !ch.#closed) {
+          queueMicrotask(() => {
+            const cloned = structuredClone(data);
+            const event = new MessageEvent("message", { data: cloned });
+            ch.dispatchEvent(event);
+            ch.onmessage?.call(ch, event);
+          });
+        }
+      }
+    }
+    if (backend) {
+      backend.publish(this.name, data);
+    } else if (relayFn) {
+      relayFn(this.name, data);
+    }
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    const set = channels.get(this.name);
+    if (set) {
+      set.delete(this);
+      if (set.size === 0) {
+        channels.delete(this.name);
+        const unsub = backendSubscriptions.get(this.name);
+        if (unsub) {
+          unsub();
+          backendSubscriptions.delete(this.name);
+        }
+      }
+    }
+  }
+};
+
+// src/runtime.ts
 import {
   configure
 } from "@logtape/logtape";
@@ -368,7 +479,8 @@ var PATCHED_KEYS = [
   "dispatchEvent",
   "WorkerGlobalScope",
   "DedicatedWorkerGlobalScope",
-  "cookieStore"
+  "cookieStore",
+  "BroadcastChannel"
 ];
 function promiseWithTimeout(promise, timeoutMs, errorMessage) {
   return Promise.race([
@@ -1202,6 +1314,7 @@ var ServiceWorkerGlobals = class {
       get: () => cookieStoreStorage.get(),
       configurable: true
     });
+    g.BroadcastChannel = ShovelBroadcastChannel;
   }
   /**
    * Restore original globals (for testing)
@@ -1313,6 +1426,14 @@ async function initWorkerRuntime(options) {
     loggers
   });
   scope.install();
+  if (config?.broadcastChannel?.impl) {
+    const { impl, ...bcOptions } = config.broadcastChannel;
+    const opts = bcOptions;
+    const bcBackend = isClass(impl) ? new impl(opts) : impl(
+      opts
+    );
+    setBroadcastChannelBackend(bcBackend);
+  }
   runtimeLogger.debug("Worker runtime initialized");
   return { registration, scope, caches, directories, databases, loggers };
 }
@@ -1383,6 +1504,10 @@ function startWorkerMessageLoop(options) {
       });
       return;
     }
+    if (message?.type === "broadcast:deliver") {
+      deliverBroadcastMessage(message.channel, message.data);
+      return;
+    }
     if (message?.type === "shutdown") {
       messageLogger.debug(`[Worker-${workerId}] Received shutdown signal`);
       (async () => {
@@ -1409,6 +1534,9 @@ function startWorkerMessageLoop(options) {
     }
   }
   self.addEventListener("message", handleMessage);
+  setBroadcastChannelRelay((channelName, data) => {
+    sendMessage({ type: "broadcast:post", channel: channelName, data });
+  });
   sendMessage({ type: "ready" });
   messageLogger.debug(`[Worker-${workerId}] Message loop started`);
 }
@@ -1490,6 +1618,7 @@ export {
   RequestCookieStore,
   ServiceWorkerGlobals,
   ShovelActivateEvent,
+  ShovelBroadcastChannel,
   ShovelClient,
   ShovelClients,
   ShovelExtendableEvent,
@@ -1507,6 +1636,7 @@ export {
   createCacheFactory,
   createDatabaseFactory,
   createDirectoryFactory,
+  deliverBroadcastMessage,
   dispatchRequest,
   initWorkerRuntime,
   kDispatchActivate,
@@ -1516,5 +1646,7 @@ export {
   parseSetCookieHeader,
   runLifecycle,
   serializeCookie,
+  setBroadcastChannelBackend,
+  setBroadcastChannelRelay,
   startWorkerMessageLoop
 };