@seedprotocol/sdk 0.6.10 → 0.7.0

package/dist/{index-280bL-n4.js → tabEvents-DYI2GU7i.js}

@@ -1,10 +1,10 @@
 import debug from 'debug';
-import { a as BaseDb, b as metadata, B as BaseFileManager, c as appState, C as ImageSize } from './BasePathResolver-B6CKqoKw.js';
+import { B as BaseDb, b as metadata, a as BaseFileManager, c as appState, D as ImageSize, E as EAS_SEED_DATA_SYNCED_TO_DB_EVENT } from './BasePathResolver-ndE8XTpw.js';
 import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls } from '@seedprotocol/arweave';
 import { BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
 import { waitFor } from 'xstate';
 import 'pluralize';
-import { p as getAllAddressesFromDb } from './db-WbrzEf7c.js';
+import { t as getAllAddressesFromDb, o as eventEmitter } from './db-BJZN0a0a.js';
 import { and, eq, or, isNotNull } from 'drizzle-orm';
 import 'nanoid';
 import 'nanoid-dictionary';
@@ -97,7 +97,7 @@ const getStorageTransactionIdForSeedUid = async (seedUid) => {
     return results[0].storageTransactionId;
 };
 
-const logger$3 = debug('seedSdk:helpers:mediaRef');
+const logger$5 = debug('seedSdk:helpers:mediaRef');
 /** Typical Arweave transaction id: 43 URL-safe base64 characters. */
 const ARWEAVE_TX_ID = /^[a-zA-Z0-9_-]{43}$/;
 function trimOrEmpty(raw) {
@@ -183,7 +183,7 @@ async function tryLocalBlobUrlFromTxId(txId) {
     const imageFilePath = BaseFileManager.getFilesPath('images', txId);
     const fileExists = await BaseFileManager.pathExists(imageFilePath);
     if (!fileExists) {
-        logger$3(`[tryLocalBlobUrlFromTxId] ${imageFilePath} does not exist`);
+        logger$5(`[tryLocalBlobUrlFromTxId] ${imageFilePath} does not exist`);
         return undefined;
     }
     const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
@@ -331,58 +331,6 @@ function normalizeFeedItemFields(item, manifest) {
     return out;
 }
 
-class SeedEventEmitter {
-    constructor() {
-        this.listeners = new Map();
-    }
-    on(event, listener) {
-        const set = this.listeners.get(event) ?? new Set();
-        set.add(listener);
-        this.listeners.set(event, set);
-        return this;
-    }
-    addListener(event, listener) {
-        return this.on(event, listener);
-    }
-    once(event, listener) {
-        const wrapped = (...args) => {
-            this.off(event, wrapped);
-            listener(...args);
-        };
-        return this.on(event, wrapped);
-    }
-    off(event, listener) {
-        const set = this.listeners.get(event);
-        if (!set)
-            return this;
-        set.delete(listener);
-        if (set.size === 0)
-            this.listeners.delete(event);
-        return this;
-    }
-    removeListener(event, listener) {
-        return this.off(event, listener);
-    }
-    removeAllListeners(event) {
-        if (typeof event === 'undefined') {
-            this.listeners.clear();
-            return this;
-        }
-        this.listeners.delete(event);
-        return this;
-    }
-    emit(event, ...args) {
-        const set = this.listeners.get(event);
-        if (!set || set.size === 0)
-            return false;
-        for (const listener of [...set]) {
-            listener(...args);
-        }
-        return true;
-    }
-}
-const eventEmitter = new SeedEventEmitter();
-
 const getMetadata = async (props) => {
     const appDb = BaseDb.getAppDb();
     let storageTransactionId;
@@ -461,7 +409,7 @@ const supportsOpfsFileDownloads = () => {
     return isBrowser() || isElectronRenderer();
 };
 
-const logger$2 = debug('seedSdk:files:download');
+const logger$4 = debug('seedSdk:files:download');
 const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
 /** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
 const GET_FILES_METADATA_STALE_MS = 120000;
@@ -471,14 +419,14 @@ const lazyDownloadInFlightByTransactionId = new Map();
 const syncDbFiles = async (endpoints) => {
     // TODO: Implement syncDbFiles functionality if needed
     // This was previously in @/services/internal/helpers
-    logger$2('[download] syncDbFiles called but not yet implemented');
+    logger$4('[download] syncDbFiles called but not yet implemented');
     return Promise.resolve();
 };
 const getAppDbReady = async () => {
     if (!BaseDb.isAppDbReady()) {
         // Wait for ClientManager to be ready (DB_INIT state or later)
-        const _mod_0 = await import('./ClientManager-ChcmUL47.js');
-        const _ns_0 = _mod_0.ap;
+        const _mod_0 = await import('./ClientManager-DLleL_2e.js');
+        const _ns_0 = _mod_0.H;
         const clientManagerMod = _ns_0;
         const { getClient } = clientManagerMod;
         const clientManager = getClient();
@@ -659,7 +607,7 @@ const downloadTransactionIds = async (rawTransactionIds, options) => {
             transactionIdsToDownload.push(transactionId);
         }
         catch (error) {
-            logger$2(error);
+            logger$4(error);
         }
     }
     if (transactionIdsToDownload.length === 0) {
@@ -796,7 +744,7 @@ const downloadTransactionIdWithDedupe = async (transactionId) => {
 };
 const scheduleBulkFilesDownloadFromEasSyncThrottled = throttle((addressesHint) => {
     void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
-        logger$2('[scheduleBulkFilesDownloadFromEasSync] failed', error);
+        logger$4('[scheduleBulkFilesDownloadFromEasSync] failed', error);
     });
 }, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
 const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
@@ -814,7 +762,7 @@ var download = /*#__PURE__*/Object.freeze({
     scheduleBulkFilesDownloadFromEasSync: scheduleBulkFilesDownloadFromEasSync
 });
 
-const logger$1 = debug('seedSdk:helpers:ensureImageLocal');
+const logger$3 = debug('seedSdk:helpers:ensureImageLocal');
 /** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
 const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
 const IMAGE_SIZES = [
@@ -983,7 +931,7 @@ const runEnsureImageLocal = async (params) => {
         };
     }
     catch (error) {
-        logger$1('ensureImageLocal failed', error);
+        logger$3('ensureImageLocal failed', error);
         return { status: 'failed' };
     }
 };
@@ -1023,7 +971,7 @@ const ensureImageLocal = async (params) => {
     return inFlight;
 };
 
-const logger = debug('seedSdk:shared:helpers');
+const logger$2 = debug('seedSdk:shared:helpers');
 const toSnakeCase = (str) => {
     return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
 };
@@ -1080,7 +1028,7 @@ const convertTxIdToImage = async (txId) => {
     const imageFilePath = BaseFileManager.getFilesPath('images', txId);
     const fileExists = await BaseFileManager.pathExists(imageFilePath);
     if (!fileExists) {
-        logger(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
+        logger$2(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
         return;
     }
     const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
@@ -1118,5 +1066,220 @@ const getArweaveUrlForTransaction = (storageTransactionId) => {
     return BaseArweaveClient.getRawUrl(storageTransactionId);
 };
 
-export { isStorageSeedRef as a, getArweaveUrlForTransaction as b, classifyMediaRef as c, closestImageSize as d, eventEmitter as e, ensureImageLocal as f, getCorrectId as g, getFeedItemStringField as h, isPublishedSeedRef as i, normalizeArweaveTxIdForEnsure as j, normalizeFeedItemFields as k, resolveMediaRef as l, getStorageTransactionIdForSeedUid as m, normalizeRelationPropertyValue as n, convertTxIdToImage as o, downloadTransactionIdWithDedupe as p, getDataTypeFromString as q, resolveSeedIdsFromRefString as r, scheduleBulkFilesDownloadFromEasSync as s, toSnakeCase as t, getMimeType as u, isNode as v, isBrowser as w, downloadAllFilesRequestHandler as x, downloadAllFilesBinaryRequestHandler as y, download as z };
-//# sourceMappingURL=index-280bL-n4.js.map
+/** Emitted by the client manager after `app_state.addresses` is written (post-`setAddresses`). */
+const ADDRESSES_PERSISTED_EVENT = 'addresses.persisted';
+/** Emitted after hard-deleting local on-chain seed copies for publisher addresses. */
+const LOCAL_COPIES_REMOVED_EVENT = 'localCopies.removed';
+function parseAddressesPersistedPayload(value) {
+    if (!value || typeof value !== 'object') {
+        return { owned: [], watched: [] };
+    }
+    const v = value;
+    const owned = Array.isArray(v.owned)
+        ? v.owned.filter((a) => typeof a === 'string')
+        : [];
+    const watched = Array.isArray(v.watched)
+        ? v.watched.filter((a) => typeof a === 'string')
+        : [];
+    return { owned, watched };
+}
+
+/**
+ * Cross-tab exclusive sections, using the Web Locks API. All tabs of an origin share one SQLite
+ * database and OPFS tree; the browser releases a tab's locks when it closes or crashes, so a lock
+ * can't go stale. See docs/MULTI_TAB.md.
+ *
+ * Where Web Locks are missing, `fn` runs directly. (Node has them too, scoped to the process.)
+ * Not re-entrant: requesting a name the caller already holds waits forever, so take each lock
+ * only at the outermost call site.
+ */
+/** Long enough for a slow init in another tab; short enough that a hung tab doesn't block forever. */
+const TAB_LOCK_WAIT_TIMEOUT_MS = 60000;
+function seedDbLockName(scope, filesDir) {
+    return `seed:${scope}:${filesDir}/db/seed.db`;
+}
+/** `withTabLock` on the database under `filesDir`; runs `fn` directly when there's no `filesDir` yet. */
+function withSeedDbLock(scope, filesDir, fn) {
+    return filesDir ? withTabLock(seedDbLockName(scope, filesDir), fn) : fn();
+}
+class TabLockTimeoutError extends Error {
+    constructor(lockName, timeoutMs) {
+        super(`Timed out after ${timeoutMs}ms waiting for another tab to release "${lockName}".`);
+        this.lockName = lockName;
+        this.code = 'TAB_LOCK_TIMEOUT';
+        this.name = 'TabLockTimeoutError';
+    }
+}
+async function withTabLock(name, fn, { timeoutMs = TAB_LOCK_WAIT_TIMEOUT_MS } = {}) {
+    const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
+    if (!locks)
+        return fn();
+    try {
+        // The timeout bounds the wait only; once granted, fn runs to completion. Infinity waits for as
+        // long as the holder runs (it can't outlive its tab).
+        const signal = Number.isFinite(timeoutMs) ? AbortSignal.timeout(timeoutMs) : undefined;
+        return await locks.request(name, { mode: 'exclusive', signal }, fn);
+    }
+    catch (error) {
+        if (error?.name === 'TimeoutError') {
+            throw new TabLockTimeoutError(name, timeoutMs);
+        }
+        throw error;
+    }
+}
+
+const logger$1 = debug('seedSdk:helpers:tabCoordinator');
+let state;
+let leader = false;
+let leaderWaiters = [];
+const messageHandlers = new Set();
+/** Starts once per page; later calls (re-init) keep the first database. */
+function startTabCoordination({ filesDir, mode = 'coordinate' }) {
+    if (state)
+        return;
+    const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
+    const dbKey = `${filesDir}/db/seed.db`;
+    const coordinating = mode === 'coordinate' && isBrowser() && !!locks && typeof BroadcastChannel !== 'undefined';
+    state = { dbKey, coordinating };
+    if (!coordinating) {
+        becomeLeader();
+        return;
+    }
+    const channel = new BroadcastChannel(`seed:tabs:${dbKey}`);
+    channel.onmessage = (event) => {
+        for (const handler of messageHandlers)
+            handler(event.data);
+    };
+    state.channel = channel;
+    const current = state;
+    void locks.request(`seed:leader:${dbKey}`, () => {
+        // Reset (tests) before the grant: hand the lock straight back.
+        if (state !== current)
+            return undefined;
+        becomeLeader();
+        // Held until the tab closes (or a test resets coordination).
+        return new Promise((release) => {
+            current.releaseLeadership = release;
+        });
+    });
+}
+function becomeLeader() {
+    if (leader)
+        return;
+    leader = true;
+    logger$1(`this tab leads ${state?.dbKey}`);
+    const waiters = leaderWaiters;
+    leaderWaiters = [];
+    for (const resolve of waiters)
+        resolve();
+}
+function isLeaderTab() {
+    return !state || leader;
+}
+/** Resolves when this tab leads (at once if it already does). */
+function whenLeaderTab() {
+    if (isLeaderTab())
+        return Promise.resolve();
+    return new Promise((resolve) => leaderWaiters.push(resolve));
+}
+/** Sends to the other tabs of this database; a no-op when not coordinating. */
+function postTabMessage(message) {
+    state?.channel?.postMessage(message);
+}
+function onTabMessage(handler) {
+    messageHandlers.add(handler);
+    return () => messageHandlers.delete(handler);
+}
+/** `withTabLock` named for this database (`seed:<scope>:<db>`); runs `fn` directly before init. */
+function withDbTabLock(scope, fn, options) {
+    return state ? withTabLock(`seed:${scope}:${state.dbKey}`, fn, options) : fn();
+}
+
+const logger = debug('seedSdk:helpers:tabEvents');
+/**
+ * Keeps other tabs current (docs/MULTI_TAB.md). The event bus is per tab, so events that mean "the
+ * shared database or OPFS changed" are also posted to the other tabs, which refresh their caches
+ * and emit the same event locally. Events are posted only where they originate, so a relayed event
+ * is never relayed again.
+ */
+/** Emitted with the changed paths when files change outside this tab's file-system cache. */
+const FILES_CHANGED_EVENT = 'fs.files.changed';
+/** Emits on this tab's event bus and in every other tab of this database. */
+function emitAcrossTabs(name, payload) {
+    if (payload === undefined) {
+        eventEmitter.emit(name);
+    }
+    else {
+        eventEmitter.emit(name, payload);
+    }
+    postTabMessage({ type: 'event', name, payload });
+}
+/**
+ * A file saved through this tab's file system: emits `file-saved` here (as before) and tells other
+ * tabs, whose caches don't see it.
+ */
+function notifyFileSaved(filePath) {
+    eventEmitter.emit('file-saved', filePath);
+    postTabMessage({ type: 'files-changed', paths: [filePath] });
+}
+/**
+ * Files written straight to OPFS by a worker: refreshes this tab's file-system cache, emits
+ * FILES_CHANGED_EVENT, and tells other tabs to do the same.
+ */
+async function notifyFilesWrittenOutsideCache(paths) {
+    if (paths.length === 0)
+        return;
+    await BaseFileManager.invalidateCachedPaths(paths);
+    eventEmitter.emit(FILES_CHANGED_EVENT, paths);
+    postTabMessage({ type: 'files-changed', paths });
+}
+/** Refreshes this tab's in-memory state for an event another tab emitted, before re-emitting it. */
+async function catchUpOn(name, payload) {
+    if (name === EAS_SEED_DATA_SYNCED_TO_DB_EVENT) {
+        const _mod_1 = await import('./Item-zBFWQDU9.js');
+        const _ns_1 = _mod_1.Z;
+        const { Item } = _ns_1;
+        await Item.rehydrateCachedItemsFromDbAfterEasSync();
+    }
+    else if (name === LOCAL_COPIES_REMOVED_EVENT) {
+        const { removedSeedLocalIds = [], removedSeedUids = [] } = (payload ?? {});
+        const _mod_2 = await import('./Item-zBFWQDU9.js');
+        const _ns_2 = _mod_2.Z;
+        const { Item } = _ns_2;
+        Item.dropCachedInstancesForSeedIds([...removedSeedLocalIds, ...removedSeedUids]);
+    }
+}
+const RELAYED_EVENTS = new Set([
+    EAS_SEED_DATA_SYNCED_TO_DB_EVENT,
+    ADDRESSES_PERSISTED_EVENT,
+    LOCAL_COPIES_REMOVED_EVENT,
+]);
+let listening = false;
+/** Applies other tabs' events and file changes in this tab. */
+function listenForOtherTabsEvents() {
+    if (listening)
+        return;
+    listening = true;
+    onTabMessage((message) => {
+        if (message.type === 'event' && RELAYED_EVENTS.has(message.name)) {
+            void catchUpOn(message.name, message.payload)
+                .catch((error) => logger(`catching up on ${message.name} failed`, error))
+                .then(() => {
+                if (message.payload === undefined) {
+                    eventEmitter.emit(message.name);
+                }
+                else {
+                    eventEmitter.emit(message.name, message.payload);
+                }
+            });
+        }
+        else if (message.type === 'files-changed') {
+            void BaseFileManager.invalidateCachedPaths(message.paths)
+                .catch((error) => logger('refreshing changed files failed', error))
+                .then(() => eventEmitter.emit(FILES_CHANGED_EVENT, message.paths));
+        }
+    });
+}
+
+export { ADDRESSES_PERSISTED_EVENT as A, isBrowser as B, startTabCoordination as C, downloadAllFilesRequestHandler as D, downloadAllFilesBinaryRequestHandler as E, FILES_CHANGED_EVENT as F, getStorageTransactionIdForSeedUid as G, convertTxIdToImage as H, downloadTransactionIdWithDedupe as I, getDataTypeFromString as J, getMimeType as K, LOCAL_COPIES_REMOVED_EVENT as L, notifyFileSaved as M, download as N, TabLockTimeoutError as T, isStorageSeedRef as a, getArweaveUrlForTransaction as b, classifyMediaRef as c, closestImageSize as d, emitAcrossTabs as e, ensureImageLocal as f, getCorrectId as g, getFeedItemStringField as h, isPublishedSeedRef as i, isLeaderTab as j, normalizeArweaveTxIdForEnsure as k, normalizeFeedItemFields as l, resolveMediaRef as m, normalizeRelationPropertyValue as n, withDbTabLock as o, parseAddressesPersistedPayload as p, notifyFilesWrittenOutsideCache as q, resolveSeedIdsFromRefString as r, scheduleBulkFilesDownloadFromEasSync as s, toSnakeCase as t, withSeedDbLock as u, postTabMessage as v, whenLeaderTab as w, onTabMessage as x, listenForOtherTabsEvents as y, isNode as z };
+//# sourceMappingURL=tabEvents-DYI2GU7i.js.map