sliftutils 1.1.49 → 1.1.51

package/index.d.ts

@@ -953,11 +953,6 @@ declare module "sliftutils/storage/BulkDatabase2/syncClient" {
 
 }
 
-declare module "sliftutils/storage/BulkDatabase2/syncWorker" {
-    export {};
-
-}
-
 declare module "sliftutils/storage/CBORStorage" {
     /// <reference types="node" />
     /// <reference types="node" />

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.1.49",
+    "version": "1.1.51",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -51,7 +51,7 @@
         "mobx": "^6.13.3",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.1.40",
+        "socket-function": "^1.1.41",
         "typenode": "*",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/storage/BulkDatabase2/BulkDatabaseBase.ts

@@ -215,10 +215,11 @@ export class BulkDatabaseBase<T extends { key: string }> {
         return joined;
     });
 
-    // Connects to the SharedWorker (browser only) so writes in other tabs of this collection update
-    // our overlay. Runs once; no-op in Node / where SharedWorker is unavailable. We wait for the reader
-    // (and thus streamTimes) first so conflict resolution can see disk timestamps, then apply the
-    // worker's buffered recent writes (which may not be on disk yet).
+    // Connects to the cross-tab BroadcastChannel (browser only) so writes in other tabs of this
+    // collection update our overlay. Runs once; no-op in Node / where BroadcastChannel is unavailable.
+    // We wait for the reader (and thus streamTimes) first so conflict resolution can see disk
+    // timestamps, then peers reply to our hello with recent writes that may not be on disk yet (applied
+    // through the same applyRemote callback).
     private syncSetup = lazy(async () => {
         if (!isSyncSupported()) return;
         await this.reader();

package/storage/BulkDatabase2/syncClient.ts

@@ -1,62 +1,81 @@
-// Browser-side client for the BulkDatabase2 SharedWorker (syncWorker). One SharedWorker connection
-// per tab, multiplexed across collections. No-op when SharedWorker is unavailable (Node / unsupported
-// browsers), so BulkDatabase2 can call these unconditionally.
+import { isNode } from "typesafecss";
+
+// Browser-side cross-tab write sync for BulkDatabase2, over BroadcastChannel (one channel per
+// collection, same-origin tabs). It does NOT persist anything — each tab writes to disk itself; this
+// just relays live writes to other open tabs and, when a tab starts up, asks peers for writes they've
+// made recently that may not be on disk yet. No-op in Node / where BroadcastChannel is unavailable, so
+// BulkDatabase2 can call these unconditionally. This is an optional feature, so there is no fallback.
 
 export type RemoteWrite = { key: string; time: number; deleted?: boolean; value?: unknown };
 
-// Path the worker bundle is served from (alongside the page bundles).
-const WORKER_URL = "/syncWorker.js";
+// Writes older than this are assumed already flushed to disk (a freshly-opened tab gets those by
+// reading disk), so a tab only replays writes newer than this when a peer says hello.
+const RECENT_WINDOW_MS = 60_000;
+
+type Channel = {
+    bc: BroadcastChannel;
+    subscribers: ((write: RemoteWrite) => void)[];
+    // This tab's own recent writes, kept so it can answer another tab's "hello".
+    recent: RemoteWrite[];
+};
 
-let port: MessagePort | undefined;
-let initialized = false;
-const subscribers = new Map<string, ((write: RemoteWrite) => void)[]>();
-const recentResolvers = new Map<string, ((writes: RemoteWrite[]) => void)[]>();
+const channels = new Map<string, Channel>();
 
 export function isSyncSupported(): boolean {
-    if (typeof SharedWorker === "undefined") return false;
-    // Under file:// the SharedWorker constructor throws a SecurityError (cross-origin / opaque
-    // origin), so skip it rather than logging that error on every load.
-    if (typeof location !== "undefined" && location.protocol === "file:") return false;
-    return true;
+    return !isNode() && typeof BroadcastChannel !== "undefined";
+}
+
+function pruneRecent(channel: Channel) {
+    const cutoff = Date.now() - RECENT_WINDOW_MS;
+    channel.recent = channel.recent.filter(w => w.time >= cutoff);
+}
+
+function deliver(channel: Channel, write: RemoteWrite) {
+    for (const sub of channel.subscribers) sub(write);
 }
 
-function ensure() {
-    if (initialized) return;
-    initialized = true;
-    if (!isSyncSupported()) return;
-    let worker = new SharedWorker(WORKER_URL);
-    port = worker.port;
-    port.onmessage = (ev: MessageEvent) => {
-        let msg = ev.data as { type: string; collection: string; writes?: RemoteWrite[] } & RemoteWrite;
-        if (msg.type === "recent") {
-            let resolvers = recentResolvers.get(msg.collection) || [];
-            recentResolvers.set(msg.collection, []);
-            for (let resolve of resolvers) resolve(msg.writes || []);
-        } else if (msg.type === "write") {
-            for (let cb of subscribers.get(msg.collection) || []) cb(msg);
+function ensure(collection: string): Channel | undefined {
+    if (!isSyncSupported()) return undefined;
+    let channel = channels.get(collection);
+    if (channel) return channel;
+    // BroadcastChannel never delivers a message back to the instance that sent it, so a tab never
+    // hears its own writes — only the other open tabs do.
+    const bc = new BroadcastChannel(`bulkDatabase2:${collection}`);
+    const created: Channel = { bc, subscribers: [], recent: [] };
+    bc.onmessage = (event: MessageEvent) => {
+        const msg = event.data as { type: string; write?: RemoteWrite; writes?: RemoteWrite[] };
+        if (!msg) return;
+        if (msg.type === "write" && msg.write) {
+            deliver(created, msg.write);
+        } else if (msg.type === "recent" && msg.writes) {
+            for (const write of msg.writes) deliver(created, write);
+        } else if (msg.type === "hello") {
+            // Another tab just started; replay our recent writes so it doesn't miss any. The reply goes
+            // to every tab, but peers that already have a write ignore it (its timestamp isn't newer
+            // than what they hold), so the redundant broadcast is harmless.
+            pruneRecent(created);
+            if (created.recent.length) created.bc.postMessage({ type: "recent", writes: created.recent });
         }
     };
-    port.start();
+    channels.set(collection, created);
+    return created;
 }
 
-// Subscribe to remote writes for a collection and return the worker's buffered recent writes (so we
-// catch writes another tab broadcast but hasn't flushed to disk yet).
+// Subscribe to remote writes for a collection. Recent writes from already-open tabs arrive through the
+// same onWrite callback (as the reply to our hello), so the returned array is always empty — it's kept
+// only for API compatibility with callers that await it.
 export function connect(collection: string, onWrite: (write: RemoteWrite) => void): Promise<RemoteWrite[]> {
-    ensure();
-    if (!port) return Promise.resolve([]);
-    let subs = subscribers.get(collection);
-    if (!subs) { subs = []; subscribers.set(collection, subs); }
-    subs.push(onWrite);
-    return new Promise(resolve => {
-        let resolvers = recentResolvers.get(collection);
-        if (!resolvers) { resolvers = []; recentResolvers.set(collection, resolvers); }
-        resolvers.push(resolve);
-        port!.postMessage({ type: "hello", collection });
-    });
+    const channel = ensure(collection);
+    if (!channel) return Promise.resolve([]);
+    channel.subscribers.push(onWrite);
+    channel.bc.postMessage({ type: "hello" });
+    return Promise.resolve([]);
 }
 
-export function broadcast(collection: string, write: RemoteWrite) {
-    ensure();
-    if (!port) return;
-    port.postMessage({ type: "write", collection, key: write.key, time: write.time, deleted: write.deleted, value: write.value });
+export function broadcast(collection: string, write: RemoteWrite): void {
+    const channel = ensure(collection);
+    if (!channel) return;
+    channel.recent.push(write);
+    pruneRecent(channel);
+    channel.bc.postMessage({ type: "write", write });
 }

package/yarn.lock

@@ -1940,10 +1940,10 @@ slash@^3.0.0:
   resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
-socket-function@^1.1.40:
-  version "1.1.40"
-  resolved "https://registry.yarnpkg.com/socket-function/-/socket-function-1.1.40.tgz#0994aa018b3fcc64a131d29e5926377b7baff280"
-  integrity sha512-PtU8csq90nbjM/Jr/irRHzj2PojUgcMXTctfBMDEHJrLKmeOM4flf87svn0M8ad5iwNiSyav8SdxCzCl9IwZJw==
+socket-function@^1.1.41:
+  version "1.1.41"
+  resolved "https://registry.yarnpkg.com/socket-function/-/socket-function-1.1.41.tgz#03e7c187d16e8353f90cff511bb3432a4e297050"
+  integrity sha512-d/c5wUKk/WEhvH7d4M7jtYEPcZifqulG/OkP3EkyYypS34cL0a40i2x9gqqYVxo6AYosJC2IuO7NR9fNgqfIKA==
   dependencies:
     "@types/pako" "^2.0.3"
     "@types/ws" "^8.5.3"

package/storage/BulkDatabase2/syncWorker.d.ts

@@ -1 +0,0 @@
-export {};

package/storage/BulkDatabase2/syncWorker.ts

@@ -1,65 +0,0 @@
-import { isNode } from "typesafecss";
-
-// SharedWorker that synchronizes BulkDatabase2 writes between tabs of the same origin. It does NOT
-// persist anything (each tab still writes to disk itself); it just relays writes to other tabs and
-// buffers the recent ones so a freshly-opened tab can catch writes that haven't been flushed to disk
-// yet. Per collection it keeps the latest write per key, pruned to a short recency window (older
-// writes are already on disk, so a new tab gets them from there).
-
-type RemoteWrite = { key: string; time: number; deleted?: boolean; value?: unknown };
-type Collection = { ports: Set<MessagePort>; recent: Map<string, RemoteWrite> };
-
-const RECENT_WINDOW_MS = 60_000;
-const collections = new Map<string, Collection>();
-
-function getCollection(name: string): Collection {
-    let c = collections.get(name);
-    if (!c) {
-        c = { ports: new Set(), recent: new Map() };
-        collections.set(name, c);
-    }
-    return c;
-}
-
-function prune(c: Collection) {
-    let cutoff = Date.now() - RECENT_WINDOW_MS;
-    for (let [key, write] of c.recent) {
-        if (write.time < cutoff) c.recent.delete(key);
-    }
-}
-
-function post(port: MessagePort, message: unknown) {
-    try {
-        port.postMessage(message);
-    } catch {
-        // Port closed (tab gone); it'll be dropped on the next failed send.
-    }
-}
-
-function main() {
-    if (isNode()) return;
-    (self as unknown as { onconnect: (e: MessageEvent) => void }).onconnect = (event: MessageEvent) => {
-        let port = (event as unknown as { ports: MessagePort[] }).ports[0];
-        port.onmessage = (ev: MessageEvent) => {
-            let msg = ev.data as { type: string; collection: string } & RemoteWrite;
-            let c = getCollection(msg.collection);
-            if (msg.type === "hello") {
-                c.ports.add(port);
-                prune(c);
-                port.postMessage({ type: "recent", collection: msg.collection, writes: [...c.recent.values()] });
-            } else if (msg.type === "write") {
-                prune(c);
-                let existing = c.recent.get(msg.key);
-                if (!existing || msg.time > existing.time) {
-                    c.recent.set(msg.key, { key: msg.key, time: msg.time, deleted: msg.deleted, value: msg.value });
-                }
-                for (let other of c.ports) {
-                    if (other !== port) post(other, msg);
-                }
-            }
-        };
-        port.start();
-    };
-}
-
-main();