mnfst 0.5.255 → 0.5.256

package/lib/manifest.appwrite.data.js

@@ -2,7 +2,7 @@
 
 (function () {
 
-const MANIFEST_BUILD_VERSION = '0.5.255';
+const MANIFEST_BUILD_VERSION = '0.5.256';
 
 /* Manifest Data Sources - Appwrite Integration */
 
@@ -10,6 +10,22 @@ const MANIFEST_BUILD_VERSION = '0.5.255';
 let appwriteClientCache = null;
 let appwriteClientPromise = null;
 
+// Auth plugin's client, polled while configured (script order isn't guaranteed)
+async function resolveAuthPluginClient(authConfigured) {
+    const deadline = Date.now() + (authConfigured ? 5000 : 0);
+    while (true) {
+        if (window.ManifestAppwriteAuthConfig) {
+            try {
+                const services = await window.ManifestAppwriteAuthConfig.getAppwriteClient();
+                if (services?.client) return services.client;
+            } catch (e) {
+            }
+        }
+        if (Date.now() >= deadline) return null;
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+}
+
 // Initialize Appwrite client (supports both auth plugin and standalone)
 async function initializeAppwriteClient() {
     // Return cached client if available
@@ -30,17 +46,21 @@ async function initializeAppwriteClient() {
 
     appwriteClientPromise = (async () => {
         try {
-            // Try to get client from auth plugin first (if available)
-            if (window.ManifestAppwriteAuthConfig) {
-                try {
-                    const { client } = await window.ManifestAppwriteAuthConfig.getAppwriteClient();
-                    if (client) {
-                        appwriteClientCache = client;
-                        return client;
-                    }
-                } catch (e) {
-                }
+            // When appwrite.auth is configured the auth plugin's client is
+            // canonical: wait (bounded) for its module instead of splitting onto
+            // a second Client — a split flips the hub's single Realtime memo
+            // back and forth (socket churn on every cross-plugin subscribe)
+            let manifest = null;
+            let manifestError = null;
+            if (window.ManifestDataConfig) {
+                try { manifest = await window.ManifestDataConfig.ensureManifest(); } catch (e) { manifestError = e; }
+            }
+            const authClient = await resolveAuthPluginClient(!!manifest?.appwrite?.auth);
+            if (authClient) {
+                appwriteClientCache = authClient;
+                return authClient;
             }
+            if (manifestError) throw manifestError; // outer catch logs + resets the promise
 
             // Fallback: Initialize client from manifest config
             if (!window.ManifestDataConfig) {
@@ -48,7 +68,6 @@ async function initializeAppwriteClient() {
                 return null;
             }
 
-            const manifest = await window.ManifestDataConfig.ensureManifest();
             if (!manifest?.appwrite) {
                 console.warn('[Manifest Data] Appwrite config not found in manifest');
                 return null;
@@ -91,18 +110,12 @@ async function initializeAppwriteClient() {
     return appwriteClientPromise;
 }
 
-// Shared Realtime: ONE instance (one socket) per tab, keyed to the client it
-// wraps. Auth identity events drop it (below) so the next use rebuilds against
-// the current session; manifest.data.realtime.js re-binds live channels.
-let realtimeCache = null;
-let realtimeClient = null;
+// Shared Realtime: ONE instance (one socket) per tab, via the cross-plugin
+// hub (defined in manifest.data.realtime.js and the auth/presences carriers).
+// Auth identity events drop the hub's memo so the next use rebuilds against
+// the current session; the hub re-binds live channels.
 function getSharedRealtime(client) {
-    if (!client || !window.Appwrite?.Realtime) return null;
-    if (!realtimeCache || realtimeClient !== client) {
-        realtimeCache = new window.Appwrite.Realtime(client);
-        realtimeClient = client;
-    }
-    return realtimeCache;
+    return window.ManifestRealtimeHub ? window.ManifestRealtimeHub.acquire(client) : null;
 }
 
 // Get Appwrite data services (TablesDB, Storage, Realtime)
@@ -125,8 +138,7 @@ let authCheck = null;
 let authVerified = false;
 ['manifest:auth:login', 'manifest:auth:logout', 'manifest:auth:anonymous', 'manifest:auth:session-cleared', 'manifest:auth:initialized']
     .forEach(type => window.addEventListener(type, () => {
-        authCheck = null; authVerified = false;
-        realtimeCache = null; realtimeClient = null; // socket re-authenticates as the new identity
+        authCheck = null; authVerified = false; // the hub drops its own Realtime memo on these events
     }));
 
 async function verifyAuthenticated() {
@@ -683,8 +695,10 @@ window.ManifestDataAppwrite = {
 
 
 /* Manifest Data Sources - Real-time Subscriptions
-   One shared Realtime client per tab; subscriptions ref-counted by
-   (channel + canonical server-filter set) across sources.
+   One shared Realtime client per tab — via window.ManifestRealtimeHub, shared
+   with the auth and presences plugins so N data sources + auth entities +
+   presence ride ONE socket. Subscriptions ref-counted by (channel + canonical
+   server-filter set) across sources.
 
    Appwrite Realtime queries (server-side event filtering), verified against
    the Web SDK and server source 2026-10:
@@ -706,200 +720,311 @@ window.ManifestDataAppwrite = {
      expressible filter server-side (such rows then correct on the next load);
      false sends none. The client matcher stays on in every mode. */
 
-// Map<subKey, { channel, queries, refs, unsubscribe, handlers: Map<sourceName, handler> }>
-const entries = new Map();
-// Map<sourceName, { subKey, channel, token, handler, getFilters }> — token guards a stale unsubscribe closure
-const sources = new Map();
-// Map<sourceName, fn(eventType, row)> — pre-filters, run per event per source
-const filters = new Map();
-// Back-compat/debug surface: Map<sourceName, unsubscribeFunction>
-const subscriptions = new Map();
-// Map<sourceName, n> — explicit teardowns; aborts a subscribe in flight
-const tombstones = new Map();
-// Instance the current subscriptions live on
-let activeRealtime = null;
-
-function classify(event) {
-    if (typeof event !== 'string') return null;
-    if (event.includes('create')) return 'create';
-    if (event.includes('update')) return 'update';
-    if (event.includes('delete')) return 'delete';
-    return null;
-}
+// mnfst:realtime.hub:start
+/* Shared Appwrite Realtime hub — ONE Realtime instance (one socket) per tab
+   across the data, auth and presences plugins. The first carrier to load
+   defines it; the build syncs this block byte-identical into each carrier
+   from scripts/snippets/manifest.realtime.hub.js.
+
+   Subscriptions are keyed by a caller-chosen name and ref-counted by
+   (channel + canonical server-filter key); server-side realtime queries ride
+   per subscription where the instance supports them (verified SDK/server
+   contract: see the manifest.data.realtime.js header). Messages are
+   classified ONCE — Appwrite sends ~20 event-name variants per change —
+   so each handler gets one (action, payload, response) call per message. */
+if (!window.ManifestRealtimeHub) {
+    window.ManifestRealtimeHub = (function () {
+        // Identity events drop the instance memo (the socket re-authenticates
+        // as the new session) and re-bind live subscriptions
+        const AUTH_EVENTS = ['manifest:auth:login', 'manifest:auth:logout', 'manifest:auth:anonymous', 'manifest:auth:session-cleared', 'manifest:auth:initialized'];
+
+        // One Realtime (one socket) per tab, keyed to the client it wraps
+        let realtimeCache = null;
+        let realtimeClient = null;
+        function acquire(client) {
+            if (!client || !window.Appwrite?.Realtime) return null;
+            if (!realtimeCache || realtimeClient !== client) {
+                realtimeCache = new window.Appwrite.Realtime(client);
+                realtimeClient = client;
+            }
+            return realtimeCache;
+        }
 
-// Query-capable Realtime service (see header): detect per instance, never assume
-function supportsQueries(realtime) {
-    return !!(realtime && (realtime.pendingSubscribes || realtime.slotToSubscriptionId));
-}
+        // Map<subKey, { channel, queries, refs, unsubscribe, handlers: Map<name, handler> }>
+        const entries = new Map();
+        // Map<name, { subKey, channel, token, handler, getFilters, getRealtime }>
+        const sources = new Map();
+        // Map<name, fn(action, payload, response)> — pre-filters, run once per message per name
+        const filters = new Map();
+        // Map<name, n> — explicit teardowns; aborts a subscribe in flight
+        const tombstones = new Map();
+        // Instance the current subscriptions live on
+        let activeRealtime = null;
+
+        // Reduce a message's event-name variants to the single most specific
+        // action: delete > update (upsert counts: presences) > create
+        function classify(events) {
+            const list = Array.isArray(events) ? events : (events ? [events] : []);
+            let action = null;
+            for (const event of list) {
+                if (typeof event !== 'string') continue;
+                // Verbs match as path segments only — event names embed
+                // user-chosen ids (a table named deleted_posts is not a delete)
+                const parts = event.split('.');
+                if (parts.includes('delete')) return 'delete';
+                if (parts.includes('update') || parts.includes('upsert')) action = 'update';
+                else if (!action && parts.includes('create')) action = 'create';
+            }
+            return action;
+        }
 
-// (channel, resolved filter set) → stable subscription key; resolved.key is
-// already canonical (sorted) so equivalent filter sets share one subscription
-function subKeyFor(channel, resolved) {
-    if (!resolved || !resolved.key) return channel;
-    return `${channel}\u001f${resolved.key}`;
-}
+        // Query-capable Realtime service: detect per instance, never assume
+        function supportsQueries(realtime) {
+            return !!(realtime && (realtime.pendingSubscribes || realtime.slotToSubscriptionId));
+        }
 
-// Fan one SDK message out: each registered source handler gets each event once,
-// after that source's pre-filter (setFilter) — before any merge/dedup work
-function dispatch(subKey, response) {
-    const entry = entries.get(subKey);
-    if (!entry || !response || !response.events) return;
-    const events = Array.isArray(response.events) ? response.events : [response.events];
-    let payload = response.payload;
-    if (!payload || (!payload.$id && !payload.row)) payload = response;
-    for (const event of events) {
-        const type = classify(event);
-        if (!type) continue;
-        for (const [name, handler] of entry.handlers) {
-            const filter = filters.get(name);
-            if (filter && filter(type, payload) === false) continue;
-            handler(type, payload);
+        // (channel, resolved filter set) → stable subscription key; resolved.key
+        // is already canonical so equivalent filter sets share one subscription
+        function subKeyFor(channel, resolved) {
+            if (!resolved || !resolved.key) return channel;
+            return `${channel}\u001f${resolved.key}`;
         }
-    }
-}
 
-// subscribe() returns an unsubscribe function (legacy client) or a
-// Promise<RealtimeSubscription> (Realtime service): normalize teardown
-function dropSub(sub) {
-    if (typeof sub === 'function') sub();
-    else if (sub && typeof sub.unsubscribe === 'function') sub.unsubscribe(); // per-subscription; never risks the shared socket
-    else if (sub && typeof sub.close === 'function') sub.close();
-}
+        // Fan one SDK message out, classified once: each registered handler gets
+        // ONE (action, payload, response) call per message, after that name's
+        // pre-filter (setFilter) — before any merge/dedup work
+        function dispatch(subKey, response) {
+            const entry = entries.get(subKey);
+            if (!entry || !response || !response.events) return;
+            const action = classify(response.events);
+            if (!action) return;
+            let payload = response.payload;
+            if (!payload || (!payload.$id && !payload.row)) payload = response;
+            for (const [name, handler] of entry.handlers) {
+                const filter = filters.get(name);
+                if (filter && filter(action, payload, response) === false) continue;
+                handler(action, payload, response);
+            }
+        }
 
-function makeUnsubscriber(result) {
-    if (!result || typeof result.then !== 'function') {
-        return () => { try { dropSub(result); } catch (e) { /* socket already gone */ } };
-    }
-    const settled = result.catch(() => null);
-    return () => { settled.then(dropSub).catch(() => { /* socket already gone */ }); };
-}
+        // subscribe() returns an unsubscribe function (legacy client) or a
+        // Promise<RealtimeSubscription> (Realtime service): normalize teardown
+        function dropSub(sub) {
+            if (typeof sub === 'function') sub();
+            else if (sub && typeof sub.unsubscribe === 'function') sub.unsubscribe(); // per-subscription; never risks the shared socket
+            else if (sub && typeof sub.close === 'function') sub.close();
+        }
 
-function sdkSubscribe(realtime, subKey, channel, queries) {
-    const cb = response => dispatch(subKey, response);
-    const result = (queries && queries.length)
-        ? realtime.subscribe(channel, cb, queries)
-        : realtime.subscribe(channel, cb);
-    return makeUnsubscriber(result);
-}
+        function makeUnsubscriber(result) {
+            if (!result || typeof result.then !== 'function') {
+                return () => { try { dropSub(result); } catch (e) { /* socket already gone */ } };
+            }
+            const settled = result.catch(() => null);
+            return () => { settled.then(dropSub).catch(() => { /* socket already gone */ }); };
+        }
 
-// Get or create the shared entry for (channel, filters); registered in the map
-// before the SDK call so an event arriving mid-subscribe already dispatches
-function ensureEntry(realtime, subKey, channel, queries) {
-    let entry = entries.get(subKey);
-    if (entry) return entry;
-    entry = { channel, queries: queries || [], refs: 0, unsubscribe: null, handlers: new Map() };
-    entries.set(subKey, entry);
-    try {
-        entry.unsubscribe = sdkSubscribe(realtime, subKey, channel, queries);
-    } catch (error) {
-        entries.delete(subKey);
-        throw error;
-    }
-    return entry;
-}
+        function sdkSubscribe(realtime, subKey, channel, queries) {
+            const cb = response => dispatch(subKey, response);
+            const result = (queries && queries.length)
+                ? realtime.subscribe(channel, cb, queries)
+                : realtime.subscribe(channel, cb);
+            return makeUnsubscriber(result);
+        }
 
-function removeFromEntry(name, subKey) {
-    const entry = entries.get(subKey);
-    if (!entry) return;
-    entry.handlers.delete(name);
-    entry.refs = entry.handlers.size;
-    if (entry.refs === 0) {
-        entries.delete(subKey);
-        if (typeof entry.unsubscribe === 'function') {
-            try { entry.unsubscribe(); } catch (e) { /* socket already gone */ }
+        // Get or create the shared entry for (channel, filters); registered in the
+        // map before the SDK call so an event arriving mid-subscribe already dispatches
+        function ensureEntry(realtime, subKey, channel, queries) {
+            let entry = entries.get(subKey);
+            if (entry) return entry;
+            entry = { channel, queries: queries || [], refs: 0, unsubscribe: null, handlers: new Map() };
+            entries.set(subKey, entry);
+            try {
+                entry.unsubscribe = sdkSubscribe(realtime, subKey, channel, queries);
+            } catch (error) {
+                entries.delete(subKey);
+                throw error;
+            }
+            return entry;
         }
-    }
-}
 
-// Drop a source's registration; tear the subscription down when the last source leaves
-function detach(name, token) {
-    const cur = sources.get(name);
-    if (!cur || (token && cur.token !== token)) return;
-    sources.delete(name);
-    removeFromEntry(name, cur.subKey);
-}
+        function removeFromEntry(name, subKey) {
+            const entry = entries.get(subKey);
+            if (!entry) return;
+            entry.handlers.delete(name);
+            entry.refs = entry.handlers.size;
+            if (entry.refs === 0) {
+                entries.delete(subKey);
+                if (typeof entry.unsubscribe === 'function') {
+                    try { entry.unsubscribe(); } catch (e) { /* socket already gone */ }
+                }
+            }
+        }
 
-// Instance changed (client rebuilt on identity change): re-resolve each source's
-// filters ($auth. values are stale) and regroup subscriptions on the new instance.
-// Chained so overlapping rebuilds run in order; a superseded rebuild stops.
-let syncChain = Promise.resolve();
-function syncInstance(realtime) {
-    if (activeRealtime === realtime) return syncChain;
-    activeRealtime = realtime;
-    syncChain = syncChain
-        .then(() => rebindAll(realtime))
-        .catch(error => console.error('[Manifest Data] Realtime rebind failed:', error));
-    return syncChain;
-}
+        // Drop a name's registration; tear the subscription down when the last one leaves
+        function detach(name, token) {
+            const cur = sources.get(name);
+            if (!cur || (token && cur.token !== token)) return;
+            sources.delete(name);
+            removeFromEntry(name, cur.subKey);
+        }
 
-async function rebindAll(realtime) {
-    for (const [, entry] of entries) {
-        if (typeof entry.unsubscribe === 'function') {
-            try { entry.unsubscribe(); } catch (e) { /* old instance */ }
+        // Instance changed (rebuilt on identity change): re-resolve each name's
+        // filters ($auth. values are stale) and regroup subscriptions on the new
+        // instance. Chained so overlapping rebuilds run in order; superseded stops.
+        let syncChain = Promise.resolve();
+        function syncInstance(realtime) {
+            if (activeRealtime === realtime) return syncChain;
+            activeRealtime = realtime;
+            syncChain = syncChain
+                .then(() => rebindAll(realtime))
+                .catch(error => console.error('[Manifest Realtime] Rebind failed:', error));
+            return syncChain;
         }
-    }
-    entries.clear();
-    const canQuery = supportsQueries(realtime);
-    for (const [name, src] of sources) {
-        if (activeRealtime !== realtime) return; // superseded by a newer instance
-        const resolved = (canQuery && src.getFilters) ? await src.getFilters() : null;
-        const subKey = subKeyFor(src.channel, resolved);
-        try {
-            const entry = ensureEntry(realtime, subKey, src.channel, resolved?.queries);
-            entry.handlers.set(name, src.handler);
+
+        async function rebindAll(realtime) {
+            for (const [, entry] of entries) {
+                if (typeof entry.unsubscribe === 'function') {
+                    try { entry.unsubscribe(); } catch (e) { /* old instance */ }
+                }
+            }
+            entries.clear();
+            const canQuery = supportsQueries(realtime);
+            for (const [name, src] of sources) {
+                if (activeRealtime !== realtime) return; // superseded by a newer instance
+                try {
+                    // Inside the try: one source's failing getFilters must not
+                    // strand the sources after it unsubscribed
+                    const resolved = (canQuery && src.getFilters) ? await src.getFilters() : null;
+                    if (activeRealtime !== realtime) return;
+                    const subKey = subKeyFor(src.channel, resolved);
+                    const entry = ensureEntry(realtime, subKey, src.channel, resolved?.queries);
+                    entry.handlers.set(name, src.handler);
+                    entry.refs = entry.handlers.size;
+                    src.subKey = subKey;
+                } catch (error) {
+                    console.error('[Manifest Realtime] Failed to re-subscribe channel:', src.channel, error);
+                }
+            }
+        }
+
+        // One SDK subscribe per distinct (channel, filter set); names sharing both
+        // share it. getRealtime: async () => instance (re-run on identity rebuilds).
+        // isCurrent: false once the requesting load is superseded — skip, never
+        // touch a newer entry. getFilters: async () => ({ queries, key }) | null,
+        // re-run per (re)subscribe; null → channel-only subscribe. A replaced
+        // registration detaches only after the new subscription is live (no event
+        // gap); overlap double-delivery is the consumer's dedupe to absorb.
+        async function subscribe({ name, channel, onEvent, isCurrent, getFilters, getRealtime }) {
+            const epoch = tombstones.get(name) || 0;
+            const realtime = getRealtime ? await getRealtime() : null;
+            if (isCurrent && !isCurrent()) return null;
+            if (!realtime) {
+                detach(name);
+                return null;
+            }
+            await syncInstance(realtime);
+            if (isCurrent && !isCurrent()) return null;
+
+            const resolved = (supportsQueries(realtime) && getFilters) ? await getFilters() : null;
+            if (isCurrent && !isCurrent()) return null;
+            // Torn down while resolving: land nothing
+            if ((tombstones.get(name) || 0) !== epoch) return null;
+            // Instance replaced while resolving (identity rebuild): re-run against the live one
+            if (activeRealtime !== realtime) return subscribe({ name, channel, onEvent, isCurrent, getFilters, getRealtime });
+            const subKey = subKeyFor(channel, resolved);
+
+            const prev = sources.get(name);
+            let entry;
+            try {
+                entry = ensureEntry(realtime, subKey, channel, resolved?.queries);
+            } catch (error) {
+                console.error('[Manifest Realtime] Failed to subscribe:', channel, error);
+                detach(name);
+                return null;
+            }
+            const token = Symbol(name);
+            entry.handlers.set(name, onEvent);
             entry.refs = entry.handlers.size;
-            src.subKey = subKey;
-        } catch (error) {
-            console.error('[Manifest Data] Failed to re-subscribe channel:', src.channel, error);
+            sources.set(name, { subKey, channel, token, handler: onEvent, getFilters, getRealtime });
+            if (prev && prev.subKey !== subKey) removeFromEntry(name, prev.subKey);
+
+            return () => detach(name, token);
         }
-    }
+
+        // Explicit teardown by name; also aborts a subscribe in flight and
+        // drops the name's pre-filter (a replacement re-registers its own)
+        function unsubscribe(name) {
+            tombstones.set(name, (tombstones.get(name) || 0) + 1);
+            filters.delete(name);
+            detach(name);
+        }
+
+        // Programmatic pre-filter: fn(action, payload, response) runs once per
+        // message per name BEFORE the handler; false drops it. null clears.
+        function setFilter(name, fn) {
+            if (fn == null) filters.delete(name);
+            else if (typeof fn === 'function') filters.set(name, fn);
+        }
+
+        // Identity events: drop the memo, then re-bind live subscriptions on a
+        // fresh instance from any registered source's getter
+        if (typeof window !== 'undefined') {
+            AUTH_EVENTS.forEach(type => window.addEventListener(type, async () => {
+                realtimeCache = null;
+                realtimeClient = null;
+                if (!sources.size) return;
+                try {
+                    const src = [...sources.values()].find(s => s.getRealtime);
+                    const realtime = src ? await src.getRealtime() : null;
+                    if (realtime) syncInstance(realtime);
+                } catch (error) {
+                    console.error('[Manifest Realtime] Identity rebuild failed:', error);
+                }
+            }));
+        }
+
+        return {
+            AUTH_EVENTS,
+            acquire,
+            subscribe,
+            unsubscribe,
+            setFilter,
+            classify,
+            supportsQueries,
+            _entries: entries, // Expose for debugging (keyed by channel + filter set)
+            _sources: sources
+        };
+    })();
 }
+// mnfst:realtime.hub:end
+
+// Back-compat/debug surface: Map<sourceName, unsubscribeFunction>
+const subscriptions = new Map();
 
-// One SDK subscribe per distinct (channel, filter set); sources sharing both share it.
-// isCurrent: false once the requesting load is superseded (logout) — skip, never touch a newer entry.
-// getFilters: async () => ({ queries, key }) | null, re-run per (re)subscribe so
+// One SDK subscribe per distinct (channel, filter set), delegated to the hub;
+// names are the data-source names. getFilters re-runs per (re)subscribe so
 // $auth. values resolve at subscribe time; null → channel-only (0.5.248 path).
-// A replaced registration detaches only after the new subscription is live (no
-// event gap); overlap double-delivery is absorbed by the per-source event dedupe.
 async function subscribeChannel(dataSourceName, channel, onEvent, isCurrent, getFilters) {
-    const epoch = tombstones.get(dataSourceName) || 0;
-    const services = await window.ManifestDataAppwrite.getAppwriteDataServices();
-    if (isCurrent && !isCurrent()) return null;
-    if (!services?.realtime) {
-        console.warn('[Manifest Data] Realtime service not available for', dataSourceName);
-        detach(dataSourceName);
-        subscriptions.delete(dataSourceName);
-        return null;
-    }
-    const realtime = services.realtime;
-    await syncInstance(realtime);
-    if (isCurrent && !isCurrent()) return null;
-
-    const resolved = (supportsQueries(realtime) && getFilters) ? await getFilters() : null;
-    if (isCurrent && !isCurrent()) return null;
-    // Torn down while resolving: land nothing
-    if ((tombstones.get(dataSourceName) || 0) !== epoch) return null;
-    // Instance replaced while resolving (identity rebuild): re-run against the live one
-    if (activeRealtime !== realtime) return subscribeChannel(dataSourceName, channel, onEvent, isCurrent, getFilters);
-    const subKey = subKeyFor(channel, resolved);
-
-    const prev = sources.get(dataSourceName);
-    let entry;
-    try {
-        entry = ensureEntry(realtime, subKey, channel, resolved?.queries);
-    } catch (error) {
-        console.error('[Manifest Data] Failed to subscribe:', channel, error);
-        detach(dataSourceName);
+    const getRealtime = async () => {
+        const services = await window.ManifestDataAppwrite.getAppwriteDataServices();
+        if (!services?.realtime) {
+            console.warn('[Manifest Data] Realtime service not available for', dataSourceName);
+            return null;
+        }
+        return services.realtime;
+    };
+    const unsubscribe = await window.ManifestRealtimeHub.subscribe({
+        name: dataSourceName,
+        channel,
+        onEvent,
+        isCurrent,
+        getFilters,
+        getRealtime
+    });
+    if (!unsubscribe) {
         subscriptions.delete(dataSourceName);
         return null;
     }
-    const token = Symbol(dataSourceName);
-    entry.handlers.set(dataSourceName, onEvent);
-    entry.refs = entry.handlers.size;
-    sources.set(dataSourceName, { subKey, channel, token, handler: onEvent, getFilters });
-    if (prev && prev.subKey !== subKey) removeFromEntry(dataSourceName, prev.subKey);
-
-    const unsubscribe = () => detach(dataSourceName, token);
     subscriptions.set(dataSourceName, unsubscribe);
     return unsubscribe;
 }
@@ -924,36 +1049,22 @@ function subscribeToTable(dataSourceName, databaseId, tableId, scope, onEvent, i
 
 // Unsubscribe from a data source
 function unsubscribeFromDataSource(dataSourceName) {
-    tombstones.set(dataSourceName, (tombstones.get(dataSourceName) || 0) + 1);
-    detach(dataSourceName);
+    window.ManifestRealtimeHub.unsubscribe(dataSourceName);
     subscriptions.delete(dataSourceName);
 }
 
-// Unsubscribe from all data sources
+// Unsubscribe from all data sources (never touches auth/presence registrations)
 function unsubscribeAll() {
-    for (const name of [...sources.keys()]) {
-        tombstones.set(name, (tombstones.get(name) || 0) + 1);
-        detach(name);
+    for (const name of [...subscriptions.keys()]) {
+        window.ManifestRealtimeHub.unsubscribe(name);
     }
     subscriptions.clear();
 }
 
-// Programmatic pre-filter: fn(eventType, row) runs per event per source BEFORE
-// any merge/dedup work; returning false drops the event. null clears it.
+// Programmatic pre-filter: fn(action, row) runs once per message per source
+// BEFORE any merge/dedup work; returning false drops the event. null clears it.
 function setFilter(sourceName, fn) {
-    if (fn == null) filters.delete(sourceName);
-    else if (typeof fn === 'function') filters.set(sourceName, fn);
-}
-
-// Identity events rebuild the shared Realtime (manifest.data.appwrite.js drops
-// its memo on the same events); re-bind live subscriptions to the new instance
-if (typeof window !== 'undefined') {
-    ['manifest:auth:login', 'manifest:auth:logout', 'manifest:auth:anonymous', 'manifest:auth:session-cleared', 'manifest:auth:initialized']
-        .forEach(type => window.addEventListener(type, async () => {
-            if (!sources.size) return;
-            const services = await window.ManifestDataAppwrite?.getAppwriteDataServices?.();
-            if (services?.realtime) syncInstance(services.realtime);
-        }));
+    window.ManifestRealtimeHub.setFilter(sourceName, fn);
 }
 
 // Export functions
@@ -964,7 +1075,7 @@ window.ManifestDataRealtime = {
     unsubscribeAll,
     setFilter,
     subscriptions, // Expose for debugging
-    _channels: entries // Expose for debugging (keyed by channel + filter set)
+    _channels: window.ManifestRealtimeHub._entries // Expose for debugging (keyed by channel + filter set)
 };