@nebulr-group/bridge-svelte 0.8.0-beta.0 → 0.8.0-beta.1

package/dist/core/bridge-runtime.js

@@ -45,7 +45,7 @@ import { RealtimeClient, useBridge, } from '@nebulr-group/bridge-auth-core';
 import { getConfig } from '../client/stores/config.store.js';
 import { getBridgeAuth, tokenStore } from './bridge-instance.js';
 import { wrapFetchWithBridgeAuth } from './bridge-fetch.js';
-import { applySessionSnapshot } from './snapshot-stores.js';
+import { applyEntitlementsChanged, applySessionSnapshot, applySubscriptionPlanChanged, } from './snapshot-stores.js';
 import { bridgeEvents } from './events.js';
 import { _setRealtimeStatus, _setRealtimeStatusDetail } from './realtime-status.js';
 let _realtime;
@@ -247,8 +247,21 @@ export function startBridgeRuntime(options = {}) {
     useBridge().attachToRealtimeClient(_realtime);
     // Phase 5 (TBP-331) + TBP-360 — billing-family events flow through the
     // unified bridge events surface via `useBridge().handle({...})`.
+    //
+    // TBP-644 — the two pushes that carry the complete new value also move the
+    // `bridge.tenant.*` stores, which were otherwise written only by
+    // `session.snapshot`. A plan change never re-sends a snapshot, so without
+    // this an upgraded app kept rendering the old plan until a reload. The store
+    // is patched BEFORE dispatch so a `bridge.events` handler that reads
+    // `bridge.tenant.subscription` already sees the new plan.
     useBridge().handle({
-        'subscription.plan_changed': (msg) => bridgeEvents._dispatch(msg),
+        'subscription.plan_changed': (msg) => {
+            try {
+                applySubscriptionPlanChanged(msg);
+            }
+            catch { /* store updates shouldn't throw, defensive */ }
+            bridgeEvents._dispatch(msg);
+        },
         'payment.failed': (msg) => bridgeEvents._dispatch(msg),
         'payment.succeeded': (msg) => bridgeEvents._dispatch(msg),
         'subscription.created': (msg) => bridgeEvents._dispatch(msg),
@@ -264,7 +277,14 @@ export function startBridgeRuntime(options = {}) {
         'dunning.recovered': (msg) => bridgeEvents._dispatch(msg),
         'dunning.exhausted': (msg) => bridgeEvents._dispatch(msg),
         'quota.updated': (msg) => bridgeEvents._dispatch(msg),
-        'entitlements.changed': (msg) => bridgeEvents._dispatch(msg),
+        'entitlements.changed': (msg) => {
+            // Only the payload-carrying variant has a map; the signal-only one is a no-op here.
+            try {
+                applyEntitlementsChanged(msg);
+            }
+            catch { /* defensive */ }
+            bridgeEvents._dispatch(msg);
+        },
     });
     // Token store subscription — owns realtime channel scoping + quotas HTTP
     // options + reauthorize on token-only refresh. Capability-specific subs

package/dist/core/bridge-runtime.test.js

@@ -59,8 +59,12 @@ vi.mock('./bridge-instance.js', () => ({
 vi.mock('../client/stores/config.store.js', () => ({
     getConfig: () => ({ appId: 'app-1', apiBaseUrl: 'http://test' }),
 }));
+// The billing-family handler table the runtime registers via useBridge().handle().
+let _billingHandlers;
 vi.mock('./snapshot-stores.js', () => ({
     applySessionSnapshot: vi.fn(),
+    applySubscriptionPlanChanged: vi.fn(),
+    applyEntitlementsChanged: vi.fn(),
 }));
 vi.mock('./events.js', () => ({
     bridgeEvents: { _dispatch: vi.fn() },
@@ -89,7 +93,10 @@ vi.mock('@nebulr-group/bridge-auth-core', () => {
         useBridge: () => ({
             quotas: { configure: vi.fn() },
             attachToRealtimeClient: vi.fn(),
-            handle: vi.fn(() => () => { }),
+            handle: vi.fn((handlers) => {
+                _billingHandlers = handlers;
+                return () => { };
+            }),
         }),
     };
 });
@@ -443,3 +450,58 @@ describe('full realtime status reaches the public API (TBP-644)', () => {
         expect(handler).not.toHaveBeenCalled();
     });
 });
+// Regression: `subscription.plan_changed` and `entitlements.changed` were only
+// dispatched as events, so `bridge.tenant.*` kept the old plan / entitlements
+// until a reload (TBP-644, reproduced end to end on stage 2026-09-14).
+describe('billing pushes patch the bridge.tenant stores before dispatch (TBP-644)', () => {
+    const planChanged = {
+        kind: 'subscription.plan_changed',
+        tenantId: 'ws-1',
+        from: { slug: 'free' },
+        to: { slug: 'pro', name: 'Pro' },
+        status: 'active',
+        effectiveAt: '2026-09-14T15:56:31.654Z',
+    };
+    const entitlementsChanged = {
+        kind: 'entitlements.changed',
+        tenantId: 'ws-1',
+        effectiveAt: '2026-09-14T15:56:31.605Z',
+        entitlements: { app_active: true },
+    };
+    it('subscription.plan_changed patches the tenant subscription store, then dispatches', async () => {
+        const { bridgeEvents } = await import('./events.js');
+        const { applySubscriptionPlanChanged } = await import('./snapshot-stores.js');
+        const order = [];
+        vi.mocked(applySubscriptionPlanChanged).mockImplementationOnce(() => { order.push('store'); });
+        vi.mocked(bridgeEvents._dispatch).mockImplementationOnce(() => { order.push('dispatch'); });
+        _billingHandlers = undefined;
+        startBridgeRuntime();
+        _billingHandlers['subscription.plan_changed'](planChanged);
+        expect(applySubscriptionPlanChanged).toHaveBeenCalledWith(planChanged);
+        expect(bridgeEvents._dispatch).toHaveBeenCalledWith(planChanged);
+        expect(order).toEqual(['store', 'dispatch']);
+    });
+    it('entitlements.changed replaces the tenant entitlements store, then dispatches', async () => {
+        const { bridgeEvents } = await import('./events.js');
+        const { applyEntitlementsChanged } = await import('./snapshot-stores.js');
+        const order = [];
+        vi.mocked(applyEntitlementsChanged).mockImplementationOnce(() => { order.push('store'); });
+        vi.mocked(bridgeEvents._dispatch).mockImplementationOnce(() => { order.push('dispatch'); });
+        _billingHandlers = undefined;
+        startBridgeRuntime();
+        _billingHandlers['entitlements.changed'](entitlementsChanged);
+        expect(applyEntitlementsChanged).toHaveBeenCalledWith(entitlementsChanged);
+        expect(bridgeEvents._dispatch).toHaveBeenCalledWith(entitlementsChanged);
+        expect(order).toEqual(['store', 'dispatch']);
+    });
+    it('a failing store patch still dispatches the event to app handlers', async () => {
+        const { bridgeEvents } = await import('./events.js');
+        const { applySubscriptionPlanChanged } = await import('./snapshot-stores.js');
+        vi.mocked(applySubscriptionPlanChanged).mockImplementationOnce(() => { throw new Error('boom'); });
+        _billingHandlers = undefined;
+        startBridgeRuntime();
+        const msg = { ...planChanged, effectiveAt: 'throwing-case' };
+        expect(() => _billingHandlers['subscription.plan_changed'](msg)).not.toThrow();
+        expect(bridgeEvents._dispatch).toHaveBeenCalledWith(msg);
+    });
+});

package/dist/core/bridge.d.ts

@@ -38,7 +38,8 @@ export interface BridgeTenantSurface {
     name: Readable<string | null>;
     /**
      * Canonical subscription (plan + status + endsAt). Live via `session.snapshot`
-     * when the realtime channel is active; otherwise transparently falls back to
+     * and every `subscription.plan_changed` push when the realtime channel is
+     * active; otherwise transparently falls back to
      * the REST subscription endpoint (fetched lazily on first read).
      */
     subscription: Readable<SubscriptionSnapshot | null>;

package/dist/core/bridge.test.js

@@ -13,7 +13,7 @@
 //      previous values wholesale.
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { get } from 'svelte/store';
-import { applySessionSnapshot, __resetSnapshotStores, } from './snapshot-stores.js';
+import { applyEntitlementsChanged, applySessionSnapshot, applySubscriptionPlanChanged, __resetSnapshotStores, } from './snapshot-stores.js';
 import { bridge, _allSnapshotSlices, __resetBridgeLazySlices } from './bridge.js';
 const fullSnapshot = {
     app: {
@@ -230,3 +230,79 @@ describe('bridge.app.plans lazy slice (Phase 4, TBP-321/322)', () => {
         expect(get(bridge.app.plans)).toEqual([{ key: 'enterprise', name: 'Enterprise', prices: [] }]);
     });
 });
+// Regression: a workspace upgrade reached the page as `subscription.plan_changed`
+// but `bridge.tenant.subscription` kept the old plan until a reload, because
+// only `session.snapshot` wrote it and a plan change never re-sends one
+// (TBP-644, reproduced end to end on stage 2026-09-14).
+describe('live pushes move bridge.tenant.* without a new snapshot (TBP-644)', () => {
+    const planChanged = (to, status = 'active') => ({
+        kind: 'subscription.plan_changed',
+        tenantId: 'ws-1',
+        from: { slug: 'free' },
+        to,
+        status,
+        effectiveAt: '2026-09-14T15:56:31.654Z',
+    });
+    function snapshotOnFree(extra = {}) {
+        applySessionSnapshot({
+            ...fullSnapshot,
+            tenant: {
+                ...fullSnapshot.tenant,
+                subscription: { plan: { slug: 'free', name: 'Free' }, status: 'active', ...extra },
+            },
+        });
+    }
+    it('subscription.plan_changed replaces plan + status on bridge.tenant.subscription', () => {
+        snapshotOnFree();
+        applySubscriptionPlanChanged(planChanged({ slug: 'pro', name: 'Pro' }));
+        expect(get(bridge.tenant.subscription)).toEqual({ plan: { slug: 'pro', name: 'Pro' }, status: 'active' });
+    });
+    it('a subscriber sees free → pro live, with no further snapshot', () => {
+        snapshotOnFree();
+        const seen = [];
+        const unsub = bridge.tenant.subscription.subscribe((s) => seen.push(s?.plan.slug));
+        applySubscriptionPlanChanged(planChanged({ slug: 'pro', name: 'Pro' }));
+        unsub();
+        expect(seen).toEqual(['free', 'pro']);
+    });
+    it('keeps the fields the push does not carry (endsAt, gateEngaged)', () => {
+        snapshotOnFree({ endsAt: '2026-10-01T00:00:00.000Z', gateEngaged: false });
+        applySubscriptionPlanChanged(planChanged({ slug: 'pro', name: 'Pro' }));
+        expect(get(bridge.tenant.subscription)).toEqual({
+            plan: { slug: 'pro', name: 'Pro' },
+            status: 'active',
+            endsAt: '2026-10-01T00:00:00.000Z',
+            gateEngaged: false,
+        });
+    });
+    it('the pushed status wins over the snapshot status', () => {
+        snapshotOnFree({ status: 'trialing' });
+        applySubscriptionPlanChanged(planChanged({ slug: 'pro', name: 'Pro' }, 'active'));
+        expect(get(bridge.tenant.subscription)?.status).toBe('active');
+    });
+    it('works when no snapshot ever landed (the push alone populates the slice)', () => {
+        applySubscriptionPlanChanged(planChanged({ slug: 'pro', name: 'Pro' }));
+        expect(get(bridge.tenant.subscription)).toEqual({ plan: { slug: 'pro', name: 'Pro' }, status: 'active' });
+    });
+    it('ignores a push without a plan slug and never throws', () => {
+        snapshotOnFree();
+        expect(() => applySubscriptionPlanChanged(undefined)).not.toThrow();
+        expect(() => applySubscriptionPlanChanged({ to: null, status: 'active' })).not.toThrow();
+        expect(() => applySubscriptionPlanChanged({ to: { slug: '' } })).not.toThrow();
+        expect(get(bridge.tenant.subscription)?.plan.slug).toBe('free');
+    });
+    it('entitlements.changed with a map replaces the entitlements slice wholesale', () => {
+        applySessionSnapshot(fullSnapshot);
+        expect(bridge.tenant.entitlements.can('ai_completions')).toBe(true);
+        applyEntitlementsChanged({ entitlements: { app_active: true, projects: true } });
+        expect(get(bridge.tenant.entitlements.snapshot)).toEqual({ app_active: true, projects: true });
+        expect(bridge.tenant.entitlements.can('ai_completions')).toBe(false);
+        expect(bridge.tenant.entitlements.can('projects')).toBe(true);
+    });
+    it('the signal-only entitlements.changed (no map) leaves the slice untouched', () => {
+        applySessionSnapshot(fullSnapshot);
+        applyEntitlementsChanged({});
+        applyEntitlementsChanged(undefined);
+        expect(get(bridge.tenant.entitlements.snapshot)).toEqual(fullSnapshot.tenant.entitlements);
+    });
+});

package/dist/core/snapshot-stores.d.ts

@@ -65,5 +65,34 @@ export interface SessionSnapshotData {
  * with `null`.
  */
 export declare function applySessionSnapshot(data: SessionSnapshotData): void;
+/**
+ * TBP-644 — move `bridge.tenant.subscription` on a `subscription.plan_changed`
+ * push. Until now this store was written only by `session.snapshot`, and a plan
+ * change never re-sends one, so an upgraded workspace kept rendering its old
+ * plan until a reload — while auth-core's `useBridge().subscription`, hydrated
+ * from the very same push, already had the new one.
+ *
+ * The push is authoritative for plan and status (auth-core's contract for it:
+ * "consumers hydrate their cached state on receipt; no refetch required").
+ * Fields it does not carry (`endsAt`, `gateEngaged`) keep their current value.
+ * A payload without a plan slug is ignored. Never throws.
+ */
+export declare function applySubscriptionPlanChanged(msg: {
+    to?: {
+        slug?: unknown;
+        name?: unknown;
+    } | null;
+    status?: unknown;
+} | null | undefined): void;
+/**
+ * TBP-644 — replace `bridge.tenant.entitlements` from an `entitlements.changed`
+ * push that carries the map (the slice is documented as "replaced wholesale on
+ * every entitlements.changed push", but only `session.snapshot` ever wrote it).
+ * The signal-only lifecycle variant of the same kind carries no map and leaves
+ * the store untouched. Never throws.
+ */
+export declare function applyEntitlementsChanged(msg: {
+    entitlements?: unknown;
+} | null | undefined): void;
 /** Test-only: reset every snapshot store to `null`. Vitest hook. */
 export declare function __resetSnapshotStores(): void;

package/dist/core/snapshot-stores.js

@@ -53,6 +53,43 @@ export function applySessionSnapshot(data) {
     if (data?.user)
         _user.set(data.user);
 }
+/**
+ * TBP-644 — move `bridge.tenant.subscription` on a `subscription.plan_changed`
+ * push. Until now this store was written only by `session.snapshot`, and a plan
+ * change never re-sends one, so an upgraded workspace kept rendering its old
+ * plan until a reload — while auth-core's `useBridge().subscription`, hydrated
+ * from the very same push, already had the new one.
+ *
+ * The push is authoritative for plan and status (auth-core's contract for it:
+ * "consumers hydrate their cached state on receipt; no refetch required").
+ * Fields it does not carry (`endsAt`, `gateEngaged`) keep their current value.
+ * A payload without a plan slug is ignored. Never throws.
+ */
+export function applySubscriptionPlanChanged(msg) {
+    const slug = msg?.to?.slug;
+    if (typeof slug !== 'string' || slug === '')
+        return;
+    const name = typeof msg?.to?.name === 'string' ? msg.to.name : slug;
+    const status = typeof msg?.status === 'string' ? msg.status : undefined;
+    _tenantSubscription.update((current) => ({
+        ...(current ?? {}),
+        plan: { slug, name },
+        status: status ?? current?.status ?? '',
+    }));
+}
+/**
+ * TBP-644 — replace `bridge.tenant.entitlements` from an `entitlements.changed`
+ * push that carries the map (the slice is documented as "replaced wholesale on
+ * every entitlements.changed push", but only `session.snapshot` ever wrote it).
+ * The signal-only lifecycle variant of the same kind carries no map and leaves
+ * the store untouched. Never throws.
+ */
+export function applyEntitlementsChanged(msg) {
+    const map = msg?.entitlements;
+    if (!map || typeof map !== 'object' || Array.isArray(map))
+        return;
+    _tenantEntitlements.set({ ...map });
+}
 /** Test-only: reset every snapshot store to `null`. Vitest hook. */
 export function __resetSnapshotStores() {
     _appBranding.set(null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nebulr-group/bridge-svelte",
-  "version": "0.8.0-beta.0",
+  "version": "0.8.0-beta.1",
   "description": "Bridge Svelte library, This library helps you to add bridge authentication and feature flags, and payments to your svelte application.",
   "author": "Iman Pouya",
   "license": "MIT",