fix(sw): stop silently dropping pending events when no deliveryUrl

packages/core/src/service-worker/ServiceWorkerClient.ts

@@ -60,6 +60,7 @@ export class ServiceWorkerClient {
         config: {
           channelName: this.channelName,
           dbName: this.dbName,
+          deliveryUrl: this.config.deliveryUrl,
         },
       });
 

packages/core/src/service-worker/tabmesh-sw.ts

@@ -136,38 +136,39 @@ async function drainPendingEvents(): Promise<void> {
     // Sort by priority (desc), then createdAt (asc)
     pending.sort((a, b) => b.priority - a.priority || a.createdAt - b.createdAt);
 
+    // Without a delivery endpoint the SW has nothing to send to. Leave
+    // pending entries in the outbox so the next Hub session picks them up;
+    // we still GC TTL-expired entries below.
+    const canDeliver = Boolean(config.deliveryUrl);
+
     for (const entry of pending) {
       // Filter expired events
       if (entry.expiresAt !== undefined && entry.expiresAt <= now) {
         expiredIds.push(entry.id);
         continue;
       }
 
-      // Attempt delivery via fetch if deliveryUrl is configured
-      if (config.deliveryUrl) {
-        try {
-          const response = await fetch(config.deliveryUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-              type: entry.type,
-              payload: entry.payload,
-              id: entry.id,
-              sourceTabId: entry.sourceTabId,
-            }),
-          });
-
-          if (response.ok) {
-            deliveredIds.push(entry.id);
-          }
-          // Non-OK response: leave as pending for next sync
-        } catch {
-          // Network failure: leave as pending for next sync
+      if (!canDeliver) continue;
+
+      // Attempt delivery via fetch.
+      try {
+        const response = await fetch(config.deliveryUrl as string, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            type: entry.type,
+            payload: entry.payload,
+            id: entry.id,
+            sourceTabId: entry.sourceTabId,
+          }),
+        });
+
+        if (response.ok) {
+          deliveredIds.push(entry.id);
         }
-      } else {
-        // No delivery URL: mark as delivered (events will be picked up
-        // by the next Hub that starts)
-        deliveredIds.push(entry.id);
+        // Non-OK response: leave as pending for next sync
+      } catch {
+        // Network failure: leave as pending for next sync
       }
     }
 

packages/core/src/types.ts

@@ -251,6 +251,14 @@ export interface ServiceWorkerConfig {
   enabled: boolean;
   /** Service Worker script URL. @default '/tabmesh-sw.js' */
   scriptUrl: string;
+  /**
+   * HTTP endpoint the Service Worker POSTs pending events to during
+   * Background Sync. Required for the SW handoff to actually deliver
+   * events. When omitted, the SW leaves pending events in the outbox
+   * for the next Hub session to drain — it does NOT silently mark them
+   * delivered.
+   */
+  deliveryUrl?: string;
 }
 
 /**

packages/core/tests/ServiceWorkerClient.test.ts

@@ -63,6 +63,25 @@ describe('ServiceWorkerClient', () => {
       config: {
         channelName: 'test-app',
         dbName: 'tabmesh:test-app',
+        deliveryUrl: undefined,
+      },
+    });
+  });
+
+  it('forwards deliveryUrl to the service worker config', async () => {
+    const client = new ServiceWorkerClient('test-app', {
+      enabled: true,
+      deliveryUrl: 'https://api.example.com/events',
+    });
+
+    await client.register();
+
+    expect(mockRegistration.active?.postMessage).toHaveBeenCalledWith({
+      kind: 'tabmesh-sw-config',
+      config: {
+        channelName: 'test-app',
+        dbName: 'tabmesh:test-app',
+        deliveryUrl: 'https://api.example.com/events',
       },
     });
   });