@seedprotocol/sdk 0.7.2 → 0.7.3-next.654.g52217f6

package/dist/{tabEvents-C9qUKx_z.js → tabEvents-DguZpCCv.js}

@@ -1,14 +1,17 @@
 import debug from 'debug';
-import { a as BaseDb, m as metadata, B as BaseFileManager, b as appState, D as ImageSize, E as EAS_SEED_DATA_SYNCED_TO_DB_EVENT } from './BasePathResolver-BdxCSIzn.js';
-import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls } from '@seedprotocol/arweave';
+import { B as BaseDb, m as metadata, t as BaseFileManager, a as appState, D as ImageSize, E as EAS_SEED_DATA_SYNCED_TO_DB_EVENT } from './BasePathResolver-CfSfMW5_.js';
+import { isEasAttestationExplorerUrl, BaseArweaveClient, ensureReadGatewaySelected, getArweaveReadBaseUrls, getTransactionTagsByIds } from '@seedprotocol/arweave';
 import { BaseQueryClient, BaseEasClient, GET_FILES_METADATA } from '@seedprotocol/eas';
 import { waitFor } from 'xstate';
 import 'pluralize';
-import { t as getAllAddressesFromDb, m as eventEmitter } from './db-W1g29qsM.js';
-import { and, eq, or, isNotNull } from 'drizzle-orm';
+import { n as normalizeDataType, t as getAllAddressesFromDb, m as eventEmitter } from './db-D9K_f5cF.js';
+import { and, eq, isNotNull, inArray, or } from 'drizzle-orm';
 import { customAlphabet } from 'nanoid';
 import { alphanumeric } from 'nanoid-dictionary';
 import '@seedprotocol/query';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha3_256 } from '@noble/hashes/sha3';
+import { bytesToHex } from '@noble/hashes/utils';
 import { throttle } from 'lodash-es';
 
 /** Same rules as getCorrectId in helpers/index (avoid barrel circular import). */
@@ -409,6 +412,124 @@ const supportsOpfsFileDownloads = () => {
     return isBrowser() || isElectronRenderer();
 };
 
+/**
+ * Tag every Seed upload carries with the hex digest of its data. Producers: the SDK's
+ * `getPublishUploadData` / `getPublishUploads` (and through them both the L1 transaction path and
+ * the bundler / DataItem path in `@seedprotocol/publish`). Consumer: the files download
+ * (`events/files/download.ts` and the download worker), which verifies downloaded bytes against it
+ * and copies a verified value into `metadata.content_hash`.
+ */
+const CONTENT_SHA256_TAG = 'Content-SHA-256';
+const CONTENT_TYPE_TAG = 'Content-Type';
+/**
+ * Lowercase hex SHA-256 of `data`: the value of the {@link CONTENT_SHA256_TAG} tag.
+ *
+ * Uses @noble/hashes rather than WebCrypto so it also works outside secure contexts (WebCrypto's
+ * `crypto.subtle` is missing on plain-http origins); the digest is the same.
+ *
+ * In SDK 0.7.2 and earlier the L1 transaction path (`getPublishUploads`) wrote SHA3-256 under this tag name
+ * while the bundler path wrote SHA-256. Uploads from that path still carry SHA3-256 digests; use
+ * {@link contentSha256TagMatches} to check a tag value against bytes.
+ */
+const getContentSha256 = (data) => bytesToHex(sha256(data));
+/**
+ * True when `tagValue` (a {@link CONTENT_SHA256_TAG} value read from Arweave) is the digest of
+ * `data`. Accepts SHA-256 and, for uploads made by SDK 0.7.2 and earlier through the L1 transaction path,
+ * SHA3-256.
+ */
+const contentSha256TagMatches = (data, tagValue) => {
+    const expected = tagValue.trim().toLowerCase();
+    if (!expected)
+        return false;
+    return getContentSha256(data) === expected || bytesToHex(sha3_256(data)) === expected;
+};
+/**
+ * Tags for one upload, in the order every upload uses: content hash, content type, then any
+ * configured extra tags (e.g. App-Name from `arweaveUploadTags`).
+ */
+const buildArweaveContentTags = (contentHash, contentType, extra) => {
+    const tags = [];
+    if (contentHash)
+        tags.push({ name: CONTENT_SHA256_TAG, value: contentHash });
+    if (contentType)
+        tags.push({ name: CONTENT_TYPE_TAG, value: contentType });
+    if (extra?.length)
+        tags.push(...extra);
+    return tags;
+};
+
+/** Subdirectory of the files root that holds a storage seed's file, by its data type. */
+const getStorageSubdirForDataType = (dataType) => {
+    switch (normalizeDataType(dataType ?? undefined)) {
+        case 'Image':
+            return 'images';
+        case 'Html':
+            return 'html';
+        case 'Json':
+            return 'json';
+        case 'File':
+        default:
+            // Unknown types are generic files; `images/` is only for what the SDK knows is an image.
+            return 'files';
+    }
+};
+/** Absolute directory for a storage seed's file (`images/`, `files/`, `html/` or `json/` under the files root). */
+const getStorageDirForDataType = (dataType) => BaseFileManager.getFilesPath(getStorageSubdirForDataType(dataType));
+/**
+ * Subdirectory (relative to the files root, no leading slash) for an ItemStorage property's file:
+ * its model's `storage.path` (`localStorageDir`), else `files`.
+ */
+const getItemStorageSubdir = (localStorageDir) => (localStorageDir ?? '').replace(/^\/+/, '').replace(/\/+$/, '') || 'files';
+/**
+ * File name a local save gives an ItemStorage property: `<seedUid or seedLocalId><extension>`
+ * (see saveItemStorage). Downloaded content is named after its transaction instead
+ * (`<txId><extension>`, see syncDbWithEas), which is what the metadata row's refResolvedValue says.
+ */
+const getItemStorageLocalFileName = (seedId, filenameSuffix) => `${seedId}${filenameSuffix ?? ''}`;
+
+/** Rows per query: well under SQLite's bound-parameter limit. */
+const CHUNK_SIZE = 400;
+/**
+ * Where the download worker saves each child of a composite upload, by transaction id then child
+ * (property) name: a path relative to the files root.
+ *
+ * The paths come from the ItemStorage rows sync derives from a `storage_transaction_id`
+ * attestation (see `createMetadataRecordsForStorageTransactionId`): property value = the
+ * transaction id, `refResolvedValue` = `<txId><extension>`, `localStorageDir` = the model's storage
+ * directory. Those rows are what hydration reads, so a child saved here is found as that property's
+ * file. Transactions with no such rows are left out; the worker then falls back to the legacy
+ * html / json layout.
+ */
+const getCompositeChildPaths = async (transactionIds) => {
+    const out = {};
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || transactionIds.length === 0)
+        return out;
+    for (let i = 0; i < transactionIds.length; i += CHUNK_SIZE) {
+        const chunk = transactionIds.slice(i, i + CHUNK_SIZE);
+        const rows = await appDb
+            .select({
+            transactionId: metadata.propertyValue,
+            propertyName: metadata.propertyName,
+            refResolvedValue: metadata.refResolvedValue,
+            localStorageDir: metadata.localStorageDir,
+        })
+            .from(metadata)
+            .where(and(isNotNull(metadata.derivedFromUid), isNotNull(metadata.refResolvedValue), inArray(metadata.propertyValue, chunk)));
+        for (const row of rows) {
+            const { transactionId, propertyName, refResolvedValue } = row;
+            if (!transactionId || !propertyName || !refResolvedValue)
+                continue;
+            // A file name, never a path: anything else is not where the SDK would look.
+            if (refResolvedValue.includes('/') || refResolvedValue.includes('\\'))
+                continue;
+            const byName = (out[transactionId] ?? (out[transactionId] = {}));
+            byName[propertyName] ?? (byName[propertyName] = `${getItemStorageSubdir(row.localStorageDir)}/${refResolvedValue}`);
+        }
+    }
+    return out;
+};
+
 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). */
@@ -425,8 +546,8 @@ const syncDbFiles = async (endpoints) => {
 const getAppDbReady = async () => {
     if (!BaseDb.isAppDbReady()) {
         // Wait for ClientManager to be ready (DB_INIT state or later)
-        const _mod_0 = await import('./ClientManager-ClCwwhwo.js');
-        const _ns_0 = _mod_0.H;
+        const _mod_0 = await import('./ClientManager-C-QXqUK9.js');
+        const _ns_0 = _mod_0.J;
         const clientManagerMod = _ns_0;
         const { getClient } = clientManagerMod;
         const clientManager = getClient();
@@ -561,76 +682,117 @@ const parseTransactionIdsFromMetadata = (filesMetadata, excludedTransactions) =>
     }
     return transactionIds;
 };
-const downloadTransactionIds = async (rawTransactionIds, options) => {
-    if (!supportsOpfsFileDownloads()) {
-        return false;
+/** Content-SHA-256 tag values for the transactions that have one, from one batched tag lookup (cached). */
+const getExpectedContentHashes = async (transactionIds) => {
+    const queryClient = BaseQueryClient.getQueryClient();
+    const tagsById = new Map();
+    const toFetch = [];
+    for (const transactionId of transactionIds) {
+        // Tags never change once a transaction is indexed, so a cached lookup stays good.
+        const cached = queryClient.getQueryData?.(['getTransactionTags', transactionId]);
+        if (cached)
+            tagsById.set(transactionId, cached);
+        else
+            toFetch.push(transactionId);
+    }
+    if (toFetch.length > 0) {
+        try {
+            const fetched = await getTransactionTagsByIds(toFetch, {
+                client: BaseArweaveClient.getArweaveClient(),
+                onError: (error) => logger$4('[download] transaction tags lookup failed', error),
+            });
+            for (const [transactionId, tags] of fetched) {
+                tagsById.set(transactionId, tags);
+                // Seed the per-transaction cache entry (the client interface has no setQueryData).
+                void queryClient
+                    .fetchQuery({ queryKey: ['getTransactionTags', transactionId], queryFn: async () => tags })
+                    .catch(() => { });
+            }
+        }
+        catch (error) {
+            logger$4('[download] transaction tags lookup failed', error);
+        }
     }
-    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
-    if (transactionIds.length === 0) {
-        return false;
+    const out = {};
+    for (const [transactionId, tags] of tagsById) {
+        const value = tags.find((tag) => tag.name === CONTENT_SHA256_TAG)?.value?.trim();
+        if (value)
+            out[transactionId] = value;
     }
-    const excludedTransactions = await getExcludedTransactions();
-    const queryClient = BaseQueryClient.getQueryClient();
-    const transactionIdsToDownload = [];
-    await ensureReadGatewaySelected();
+    return out;
+};
+/** Store the (now verified) Content-SHA-256 of each downloaded transaction on its metadata row. */
+const recordVerifiedContentHashes = async (transactionIds, expectedContentHashes) => {
     for (const transactionId of transactionIds) {
-        if (excludedTransactions.has(transactionId)) {
+        const contentHash = expectedContentHashes[transactionId];
+        if (!contentHash)
             continue;
-        }
         try {
-            // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
-            // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
-            let tags = [];
-            try {
-                tags = await queryClient.fetchQuery({
-                    queryKey: ['getTransactionTags', transactionId],
-                    queryFn: async () => BaseArweaveClient.getTransactionTags(transactionId),
-                });
-            }
-            catch {
-                tags = [];
-            }
-            if (tags && tags.length > 0) {
-                for (const { name, value } of tags) {
-                    if (name !== 'Content-SHA-256')
-                        continue;
-                    const metadataRecord = await getMetadata({
-                        storageTransactionId: transactionId,
-                    });
-                    if (metadataRecord) {
-                        await saveMetadata(metadataRecord, {
-                            contentHash: value,
-                        });
-                    }
-                }
+            const metadataRecord = await getMetadata({ storageTransactionId: transactionId });
+            if (metadataRecord) {
+                await saveMetadata(metadataRecord, { contentHash });
             }
-            transactionIdsToDownload.push(transactionId);
         }
         catch (error) {
             logger$4(error);
         }
     }
+};
+const downloadTransactionIds = async (rawTransactionIds, options) => {
+    if (!supportsOpfsFileDownloads()) {
+        return false;
+    }
+    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
+    if (transactionIds.length === 0) {
+        return false;
+    }
+    const excludedTransactions = await getExcludedTransactions();
+    await ensureReadGatewaySelected();
+    // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
+    // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
+    const transactionIdsToDownload = transactionIds.filter((id) => !excludedTransactions.has(id));
     if (transactionIdsToDownload.length === 0) {
         return false;
     }
+    // One batched lookup for every upload's Content-SHA-256 tag; downloads are verified against it.
+    // Missing tags (old uploads, or a just-published one not indexed yet) just mean no verification.
+    const expectedContentHashes = await getExpectedContentHashes(transactionIdsToDownload);
     // Preferred gateways first: a just-published item is only on the gateway it was uploaded through.
     const arweaveBaseUrls = getArweaveReadBaseUrls();
+    // Where each ItemStorage child of a composite goes (the worker cannot read the DB or the schema).
+    const compositeChildPaths = await getCompositeChildPaths(transactionIdsToDownload).catch((error) => {
+        logger$4('[download] composite child paths lookup failed', error);
+        return {};
+    });
+    let result;
     if (transactionIdsToDownload.length === 1) {
-        await BaseFileManager.downloadFileByTransactionId({
-            transactionId: transactionIdsToDownload[0],
+        const transactionId = transactionIdsToDownload[0];
+        result = await BaseFileManager.downloadFileByTransactionId({
+            transactionId,
             arweaveHost: BaseArweaveClient.getBaseUrl(),
             arweaveBaseUrls,
             excludedTransactions,
+            expectedContentHash: expectedContentHashes[transactionId],
+            compositeChildPaths: compositeChildPaths[transactionId],
         });
     }
     else {
-        await BaseFileManager.downloadAllFiles({
+        result = await BaseFileManager.downloadAllFiles({
             transactionIds: transactionIdsToDownload,
             arweaveHost: BaseArweaveClient.getBaseUrl(),
             arweaveBaseUrls,
             excludedTransactions,
+            expectedContentHashes,
+            compositeChildPaths,
         });
     }
+    if (result) {
+        for (const transactionId of result.hashMismatchTransactionIds) {
+            // Not saved by the worker; left for a later run (a gateway may serve the right bytes then).
+            logger$4(`[download] ${transactionId}: downloaded bytes do not match Content-SHA-256; skipped`);
+        }
+        await recordVerifiedContentHashes(result.verifiedTransactionIds, expectedContentHashes);
+    }
     if (options?.resizeAllImages !== false) {
         await BaseFileManager.resizeAllImages({
             width: 480,
@@ -715,6 +877,7 @@ const downloadAllFilesBinaryRequestHandler = async (addressesHintOrPayload) => {
     await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
     await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
     await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('files'));
     const excludedTransactions = await getExcludedTransactions();
     const fromEas = parseTransactionIdsFromMetadata(filesMetadata ?? [], excludedTransactions);
     const fromLocal = await collectTransactionIdsFromLocalMetadata();
@@ -1106,7 +1269,9 @@ function parseAddressesPersistedPayload(value) {
  * 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.)
+ * Node has Web Locks from 24.5, scoped to the process. Where they're missing (older Node, old
+ * browsers), sections still run one at a time within this JS realm (see `withProcessLock`), which
+ * covers a single Node process but not other tabs or worker threads.
  * Not re-entrant: requesting a name the caller already holds waits forever, so take each lock
  * only at the outermost call site.
  */
@@ -1130,7 +1295,7 @@ class TabLockTimeoutError extends Error {
 async function withTabLock(name, fn, { timeoutMs = TAB_LOCK_WAIT_TIMEOUT_MS } = {}) {
     const locks = typeof navigator !== 'undefined' ? navigator.locks : undefined;
     if (!locks)
-        return fn();
+        return withProcessLock(name, fn, { timeoutMs });
     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).
@@ -1144,8 +1309,52 @@ async function withTabLock(name, fn, { timeoutMs = TAB_LOCK_WAIT_TIMEOUT_MS } =
         throw error;
     }
 }
+/** Tail of each name's queue: resolves once every section queued so far has finished or given up. */
+const processLockTails = new Map();
+/**
+ * The `withTabLock` fallback without Web Locks: an exclusive, first-come-first-served lock per name
+ * within this JS realm. Like Web Locks, `timeoutMs` bounds the wait only, and a waiter that times
+ * out doesn't let later waiters in before the current holder finishes.
+ */
+async function withProcessLock(name, fn, { timeoutMs = TAB_LOCK_WAIT_TIMEOUT_MS } = {}) {
+    const previous = processLockTails.get(name) ?? Promise.resolve();
+    let release;
+    const done = new Promise((resolve) => (release = resolve));
+    const tail = previous.then(() => done);
+    processLockTails.set(name, tail);
+    void tail.then(() => {
+        if (processLockTails.get(name) === tail)
+            processLockTails.delete(name);
+    });
+    try {
+        await waitForTurn(previous, name, timeoutMs);
+    }
+    catch (error) {
+        release();
+        throw error;
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
+function waitForTurn(previous, name, timeoutMs) {
+    if (!Number.isFinite(timeoutMs))
+        return previous;
+    let timer;
+    const timedOut = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new TabLockTimeoutError(name, timeoutMs)), timeoutMs);
+    });
+    return Promise.race([previous, timedOut]).finally(() => clearTimeout(timer));
+}
 
 const logger$1 = debug('seedSdk:helpers:tabCoordinator');
+/** Identifies this tab (this page's SDK instance) in the messages it sends. */
+const TAB_ID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+    ? crypto.randomUUID()
+    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 let state;
 let leader = false;
 let leaderWaiters = [];
@@ -1164,6 +1373,10 @@ function startTabCoordination({ filesDir, mode = 'coordinate' }) {
     }
     const channel = new BroadcastChannel(`seed:tabs:${dbKey}`);
     channel.onmessage = (event) => {
+        // A BroadcastChannel never hears itself, but another channel object in this page would (a
+        // second channel opened by a test, or the same module loaded twice): skip our own messages.
+        if (event.data?.from === TAB_ID)
+            return;
         for (const handler of messageHandlers)
             handler(event.data);
     };
@@ -1201,7 +1414,11 @@ function whenLeaderTab() {
 }
 /** Sends to the other tabs of this database; a no-op when not coordinating. */
 function postTabMessage(message) {
-    state?.channel?.postMessage(message);
+    state?.channel?.postMessage({ ...message, from: TAB_ID });
+}
+/** Whether postTabMessage reaches other tabs (a browser tab coordinating with Web Locks). */
+function isPostingTabMessages() {
+    return !!state?.channel;
 }
 function onTabMessage(handler) {
     messageHandlers.add(handler);
@@ -1232,12 +1449,11 @@ function emitAcrossTabs(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.
+ * A file saved through this tab's file system: emits `file-saved` here. Other tabs hear about it
+ * from the file system itself (see queueFilesChangedNotice), once the write has reached OPFS.
  */
 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
@@ -1248,20 +1464,68 @@ async function notifyFilesWrittenOutsideCache(paths) {
         return;
     await BaseFileManager.invalidateCachedPaths(paths);
     eventEmitter.emit(FILES_CHANGED_EVENT, paths);
-    postTabMessage({ type: 'files-changed', paths });
+    queueFilesChangedNotice(paths);
+}
+/**
+ * How long changed paths gather before one `files-changed` message goes out. Counted from the
+ * first queued path, so a steady stream of writes still sends once per window, never later.
+ */
+const FILES_CHANGED_FLUSH_MS = 25;
+/** Keeps a message for a huge batch (a bulk download) from being one giant structured clone. */
+const FILES_CHANGED_MAX_PATHS = 500;
+let pendingChangedPaths = new Set();
+let flushTimer;
+let flushOnPageHide = false;
+/**
+ * Tells other tabs that these absolute ZenFS paths changed in OPFS, so they drop and re-read their
+ * cached copies (the sync API's in-memory copy in particular). The browser file system calls this
+ * for every file it writes, truncates or removes (`TolerantWebAccessFS.onOpfsChange`, wired in
+ * `BrowserFileManager.initializeFileSystem`), after the change reached OPFS. Paths are coalesced
+ * for FILES_CHANGED_FLUSH_MS, so bulk writes (migrations, schema processing, downloads) send a few
+ * messages rather than one per write.
+ *
+ * Defense in depth only: a tab that misses a message still sees the change on its next async
+ * stat() (see TolerantWebAccessFS.stat). A no-op unless this tab coordinates with others.
+ */
+function queueFilesChangedNotice(paths) {
+    if (!isPostingTabMessages())
+        return;
+    for (const path of paths)
+        pendingChangedPaths.add(path);
+    if (flushTimer !== undefined || pendingChangedPaths.size === 0)
+        return;
+    flushTimer = setTimeout(flushFilesChangedNotices, FILES_CHANGED_FLUSH_MS);
+    if (!flushOnPageHide && typeof addEventListener === 'function') {
+        flushOnPageHide = true;
+        // A tab closing inside the window still sends what it wrote.
+        addEventListener('pagehide', flushFilesChangedNotices);
+    }
+}
+/** Sends the queued paths now (page hide, tests). */
+function flushFilesChangedNotices() {
+    if (flushTimer !== undefined)
+        clearTimeout(flushTimer);
+    flushTimer = undefined;
+    if (pendingChangedPaths.size === 0)
+        return;
+    const paths = [...pendingChangedPaths];
+    pendingChangedPaths = new Set();
+    for (let i = 0; i < paths.length; i += FILES_CHANGED_MAX_PATHS) {
+        postTabMessage({ type: 'files-changed', paths: paths.slice(i, i + FILES_CHANGED_MAX_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-B9Y4VuK1.js');
-        const _ns_1 = _mod_1.Y;
+        const _mod_1 = await import('./Item-C7sUUu2B.js');
+        const _ns_1 = _mod_1.a2;
         const { Item } = _ns_1;
         await Item.rehydrateCachedItemsFromDbAfterEasSync();
     }
     else if (name === LOCAL_COPIES_REMOVED_EVENT) {
         const { removedSeedLocalIds = [], removedSeedUids = [] } = (payload ?? {});
-        const _mod_2 = await import('./Item-B9Y4VuK1.js');
-        const _ns_2 = _mod_2.Y;
+        const _mod_2 = await import('./Item-C7sUUu2B.js');
+        const _ns_2 = _mod_2.a2;
         const { Item } = _ns_2;
         Item.dropCachedInstancesForSeedIds([...removedSeedLocalIds, ...removedSeedUids]);
     }
@@ -1291,6 +1555,7 @@ function listenForOtherTabsEvents() {
             });
         }
         else if (message.type === 'files-changed') {
+            // Only refreshes caches: never writes, so never sends files-changed back.
             void BaseFileManager.invalidateCachedPaths(message.paths)
                 .catch((error) => logger('refreshing changed files failed', error))
                 .then(() => eventEmitter.emit(FILES_CHANGED_EVENT, message.paths));
@@ -1298,5 +1563,18 @@ function listenForOtherTabsEvents() {
     });
 }
 
-export { ADDRESSES_PERSISTED_EVENT as A, isNode as B, isBrowser as C, startTabCoordination as D, downloadAllFilesRequestHandler as E, FILES_CHANGED_EVENT as F, downloadAllFilesBinaryRequestHandler as G, getStorageTransactionIdForSeedUid as H, convertTxIdToImage as I, downloadTransactionIdWithDedupe as J, getDataTypeFromString as K, LOCAL_COPIES_REMOVED_EVENT as L, getMimeType as M, notifyFileSaved as N, download as O, generateId$1 as P, TabLockTimeoutError as T, isStorageSeedRef as a, generateId as b, getArweaveUrlForTransaction as c, classifyMediaRef as d, emitAcrossTabs as e, closestImageSize as f, getCorrectId as g, ensureImageLocal as h, isPublishedSeedRef as i, getFeedItemStringField as j, isLeaderTab as k, normalizeArweaveTxIdForEnsure as l, normalizeFeedItemFields as m, normalizeRelationPropertyValue as n, resolveMediaRef as o, parseAddressesPersistedPayload as p, withDbTabLock as q, resolveSeedIdsFromRefString as r, scheduleBulkFilesDownloadFromEasSync as s, toSnakeCase as t, notifyFilesWrittenOutsideCache as u, withSeedDbLock as v, whenLeaderTab as w, postTabMessage as x, onTabMessage as y, listenForOtherTabsEvents as z };
-//# sourceMappingURL=tabEvents-C9qUKx_z.js.map
+var tabEvents = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FILES_CHANGED_EVENT: FILES_CHANGED_EVENT,
+    FILES_CHANGED_FLUSH_MS: FILES_CHANGED_FLUSH_MS,
+    FILES_CHANGED_MAX_PATHS: FILES_CHANGED_MAX_PATHS,
+    emitAcrossTabs: emitAcrossTabs,
+    flushFilesChangedNotices: flushFilesChangedNotices,
+    listenForOtherTabsEvents: listenForOtherTabsEvents,
+    notifyFileSaved: notifyFileSaved,
+    notifyFilesWrittenOutsideCache: notifyFilesWrittenOutsideCache,
+    queueFilesChangedNotice: queueFilesChangedNotice
+});
+
+export { ADDRESSES_PERSISTED_EVENT as A, whenLeaderTab as B, CONTENT_SHA256_TAG as C, withDbTabLock as D, notifyFilesWrittenOutsideCache as E, FILES_CHANGED_EVENT as F, withSeedDbLock as G, postTabMessage as H, onTabMessage as I, listenForOtherTabsEvents as J, isNode as K, LOCAL_COPIES_REMOVED_EVENT as L, isBrowser as M, startTabCoordination as N, downloadAllFilesRequestHandler as O, downloadAllFilesBinaryRequestHandler as P, getStorageTransactionIdForSeedUid as Q, convertTxIdToImage as R, downloadTransactionIdWithDedupe as S, TabLockTimeoutError as T, getDataTypeFromString as U, getMimeType as V, notifyFileSaved as W, withTabLock as X, download as Y, generateId$1 as Z, tabEvents as _, getItemStorageSubdir as a, buildArweaveContentTags as b, getItemStorageLocalFileName as c, getContentSha256 as d, getCorrectId as e, isStorageSeedRef as f, getStorageDirForDataType as g, emitAcrossTabs as h, isPublishedSeedRef as i, generateId as j, getArweaveUrlForTransaction as k, CONTENT_TYPE_TAG as l, classifyMediaRef as m, normalizeRelationPropertyValue as n, closestImageSize as o, contentSha256TagMatches as p, ensureImageLocal as q, resolveSeedIdsFromRefString as r, scheduleBulkFilesDownloadFromEasSync as s, toSnakeCase as t, getFeedItemStringField as u, isLeaderTab as v, normalizeArweaveTxIdForEnsure as w, normalizeFeedItemFields as x, parseAddressesPersistedPayload as y, resolveMediaRef as z };
+//# sourceMappingURL=tabEvents-DguZpCCv.js.map