@seedprotocol/sdk 0.7.9-next.1177.ga3e08ed → 0.7.9-next.1306.g4ff6582

package/dist/{syncDbWithEas-DUu_wjUG.js → syncDbWithEas-CA7PvBgu.js}

@@ -1,28 +1,24 @@
-import { n as normalizeDataType, a5 as INTERNAL_DATA_TYPES, L as BaseDb, o as modelUids, p as models, O as nameMatchLevels, a8 as normalizePublisher, s as seeds, a9 as getAllAddressesFromDb, aa as loadNameMatchLevels, ab as scheduleBulkFilesDownloadFromEasSync, ac as EAS_SEED_DATA_SYNCED_TO_DB_EVENT, ad as generateId, ae as normalizeHexAddress, v as versions, m as metadata, S as getPropertyIdForModelAndName, U as resolveItemModelFileId, a6 as listRelationEasPropertyName, a7 as easPropertyNameForPublish, af as toMetadataPropertyName, ag as getItemStoragePropertiesForModel } from './index-Dx_GTdyQ.js';
-import { r as resolveModelForSyncedSeed, s as skipSeedOnAmbiguousModel } from './resolveModelForSyncedSeed-4gO9Hfn2.js';
+import { n as normalizeDataType, v as INTERNAL_DATA_TYPES, x as normalizePublisher, y as chunkValues, z as rowsPerInsert, B as getAllAddressesFromDb, C as loadNameMatchLevels, E as scheduleBulkFilesDownloadFromEasSync, F as isBrowser, G as emitAcrossTabs, H as findSeedRowsByUid, m as generateId, J as normalizeHexAddress, K as selectInBatches, w as writeInBatches, L as nameMatchLevels, N as getItemStoragePropertiesForModel, O as resolveItemModelFileId, Q as EAS_SEED_DATA_SYNCED_TO_DB_EVENT } from './tabEvents-CaVmngqr.js';
+import { u as updateSeedRevokedAt, r as resolveModelForSyncedSeed, s as skipSeedOnAmbiguousModel } from './updateSeedRevokedAt-BL9Bg-G7.js';
 import { camelCase } from 'lodash-es';
-import { decodeEasNumber, isNumericEasType, easName, matchEasName, getSeedsFromSchemaUids, getItemVersionsFromEas, partitionByRefAttester, getItemPropertiesFromEas, BaseEasClient, GET_SEEDS, pickLatestPropertyAttestationsByRefAndSchema, setSchemaUidForSchemaDefinition, isNameMatchLevel } from '@seedprotocol/eas';
-import pluralize from 'pluralize';
-import { eq, inArray, and, or, isNull, ne, isNotNull } from 'drizzle-orm';
-import { modelPropertiesToObject } from './model-oHA3YhOd.js';
+import { decodeEasNumber, isNumericEasType, matchEasModelSchemas, getSeedsFromSchemaUids, getItemVersionsFromEas, partitionByRefAttester, getItemPropertiesFromEas, BaseEasClient, GET_SEEDS, easName, pickLatestPropertyAttestationsByRefAndSchema, isEasEmptyValue, setSchemaUidForSchemaDefinition, isNameMatchLevel, matchEasName } from '@seedprotocol/eas';
+import 'pluralize';
+import { a6 as getGetAdditionalSyncAddresses, a7 as modelPropertiesToObject, a8 as listRelationEasPropertyName, a9 as easPropertyNameForPublish, aa as metadataStorageName, ab as resolveMetadataPropertyId } from './Item-Bf4kWKpH.js';
+import { B as BaseDb, s as seeds, v as versions, m as metadata } from './BaseFileManager-BAlySv8w.js';
 import { parseEasPropertyMetadata, parseEasRelationPropertyName } from '@seedprotocol/query';
-import { G as chunkValues, H as rowsPerInsert, J as getGetAdditionalSyncAddresses, z as selectInBatches, y as writeInBatches } from './Item-0oDoTPhi.js';
-import { f as findSeedRowsByUid } from './findSeedRowsByUid-CT3sOXXw.js';
-import { u as updateSeedRevokedAt } from './updateSeedRevokedAt-CP606vKs.js';
-import { getModelSchemasFromEas } from './eas-dyepi5jz.js';
-import { w as waitForEasReadChain, o as assertLocalDbChain } from './ClientManager-GZfXErDX.js';
-import { e as emitAcrossTabs } from './changeFeed-DKdVlUmt.js';
-import 'debug';
+import { inArray, eq, and, or, isNull, ne, isNotNull } from 'drizzle-orm';
 import '@seedprotocol/arweave';
+import { A as waitForEasReadChain, B as assertLocalDbChain, k as localModelSchemaLookups, D as writeModelUids } from './errors-DLSoqSHG.js';
+import { getModelSchemasFromEas } from './eas-wB_fQ8Tc.js';
+import 'debug';
 import 'xstate';
-import '@sinclair/typebox';
 import 'drizzle-orm/sqlite-core';
+import '@sinclair/typebox';
 import 'nanoid';
 import 'nanoid-dictionary';
 import '@noble/hashes/sha256';
 import '@noble/hashes/sha3';
 import '@noble/hashes/utils';
-import './eventBus-7vxTCc3a.js';
 import 'rxjs';
 
 /**
@@ -64,76 +60,10 @@ function syncedPropertyValue(dataType, easType, value) {
     return value;
 }
 
-// Dynamic import to break circular dependency: Model -> BaseItem -> ... -> getModelSchemas -> Model
-// import { Model } from '@/Model/Model'
-const schemaStringToModelRecord = new Map();
-const getModelSchemas = async () => {
-    // Dynamic import to break circular dependency
-    const _mod_0 = await import('./errors-D1zHAqjr.js');
-    const _ns_0 = _mod_0.i;
-    const modelMod = _ns_0;
-    const { Model } = modelMod;
-    const allModels = await Model.all();
-    const modelRecords = [];
-    const appDb = BaseDb.getAppDb();
-    for (const model of allModels) {
-        const modelName = model.modelName;
-        if (!modelName)
-            continue;
-        const foundModelQuery = await appDb
-            .select({
-            id: models.id,
-            name: models.name,
-            uid: modelUids.uid,
-        })
-            .from(models)
-            .leftJoin(modelUids, eq(models.id, modelUids.modelId))
-            // Model names are only unique per schema: use this model's own row
-            .where(model.id ? eq(models.schemaFileId, model.id) : eq(models.name, modelName))
-            .limit(1);
-        if (!foundModelQuery[0]) {
-            console.error(`[item/events] [syncDbWithEas] model ${modelName} not found in SDK DB`);
-            continue;
-        }
-        const foundModel = {
-            id: foundModelQuery[0].id,
-            name: foundModelQuery[0].name,
-            uid: foundModelQuery[0].uid,
-            tableName: pluralize(foundModelQuery[0].name).toLowerCase(),
-        };
-        modelRecords.push(foundModel);
-        if (modelName === 'Seed') {
-            continue;
-        }
-        const schemaString = `bytes32 ${easName(modelName)}`;
-        schemaStringToModelRecord.set(schemaString, foundModel);
-    }
-    // One candidate per name: same-named models in several schemas share one EAS schema.
-    const byName = new Map();
-    for (const record of modelRecords) {
-        if (record.name !== 'Seed')
-            byName.set(record.name, record);
-    }
-    // ADR 0009: each model's name matches at its own nameMatch level.
-    const levels = await nameMatchLevels(appDb);
-    const candidates = [...byName.values()].map((record) => ({
-        value: record,
-        name: record.name,
-        level: levels.model(record.name),
-    }));
-    const matchModelRecord = (schemaString) => {
-        if (!schemaString.startsWith('bytes32 '))
-            return undefined;
-        const match = matchEasName(schemaString.slice('bytes32 '.length), candidates);
-        return match.kind === 'match' ? match.value : undefined;
-    };
-    return {
-        schemaStringToModelRecord,
-        modelRecords,
-        matchModelRecord,
-    };
-};
-
+/**
+ * Inserts seed rows. A row whose uid another row already has (seeds.uid is unique for attested
+ * uids) is not inserted. Returns the local ids of the rows inserted.
+ */
 const createSeeds = async (newSeeds) => {
     const appDb = BaseDb.getAppDb();
     const values = newSeeds.map((row) => {
@@ -143,10 +73,19 @@ const createSeeds = async (newSeeds) => {
             ...(publisher ? { publisher } : {}),
         };
     });
+    const inserted = new Set();
     // Sync can create thousands of seeds at once: keep each INSERT under SQLite's parameter limit.
     for (const chunk of chunkValues(values, rowsPerInsert(seeds))) {
-        await appDb.insert(seeds).values(chunk);
-    }
+        const rows = await appDb
+            .insert(seeds)
+            .values(chunk)
+            .onConflictDoNothing()
+            .returning({ localId: seeds.localId });
+        for (const row of rows)
+            if (row.localId)
+                inserted.add(row.localId);
+    }
+    return inserted;
 };
 
 /**
@@ -182,6 +121,13 @@ const syncedRevokedAt = (attestation, stored) => {
 const relationValuesToExclude = [
     '0x0000000000000000000000000000000000000000000000000000000000000020',
 ];
+/** A property attestation revoked while its seed is live: a retraction (ADR 0021), stored as no value. */
+const isRetracted = (property, itemSeeds, state) => {
+    if (!property.revoked)
+        return false;
+    const seedUid = state.versionUidToSeedUid.get(property.refUID);
+    return !itemSeeds.find((seed) => seed.id === seedUid)?.revoked;
+};
 const createSyncRunState = () => ({
     seedUidToLocalId: new Map(),
     seedUidToModelType: new Map(),
@@ -234,17 +180,16 @@ const resolveSyncedPropertyName = (easPropertyName, value, modelSchema, easType)
                 console.warn(`[item/events] [syncDbWithEas] EAS property "${easPropertyName}" is ${easType}, which doesn't fit local property "${key}" (${def?.dataType}); skipping it`);
                 return undefined;
             }
+            // Stored under the property's storage name, as local writers store it (decision D4)
+            const propertyName = metadataStorageName(key, def);
+            const definitionId = typeof def?.id === 'string' && def.id ? def.id : undefined;
             if (isListRelation) {
-                return { propertyName: key, isRelation: true, isList: true, refSeedType: def?.ref ? easName(def.ref) : undefined };
+                return { propertyName, isRelation: true, isList: true, refSeedType: def?.ref ? easName(def.ref) : undefined, definitionId };
             }
             if (isSingleRef) {
-                return {
-                    propertyName: toMetadataPropertyName(key, def?.dataType, def?.refValueType),
-                    isRelation: true,
-                    isList: false,
-                };
+                return { propertyName, isRelation: true, isList: false, definitionId };
             }
-            return { propertyName: key, isRelation: false, isList: false, dataType: normalizeDataType(def?.dataType) };
+            return { propertyName, isRelation: false, isList: false, dataType: normalizeDataType(def?.dataType), definitionId };
         }
         // A name one of the model's properties would match at a looser level than its nameMatch
         // allows is that property's, refused (ADR 0009): don't store it under a name of its own.
@@ -289,9 +234,9 @@ const modelSchemaForSyncedProperty = async (Model, property, state) => {
  * only newly stored ones, so related seeds are refreshed (new versions, revocations) on each sync.
  */
 const collectRelatedSeedUids = async (properties, state) => {
-    const _mod_1 = await import('./errors-D1zHAqjr.js');
-    const _ns_1 = _mod_1.i;
-    const { Model } = _ns_1;
+    const _mod_0 = await import('./errors-DLSoqSHG.js');
+    const _ns_0 = _mod_0.a4;
+    const { Model } = _ns_0;
     for (const property of properties) {
         const parsed = parseEasPropertyMetadata(property.decodedDataJson);
         if (!parsed.ok)
@@ -304,8 +249,9 @@ const collectRelatedSeedUids = async (properties, state) => {
             continue;
         const values = Array.isArray(value) ? value : [value];
         for (const v of values) {
-            if (typeof v === 'string' && v && !relationValuesToExclude.includes(v))
+            if (typeof v === 'string' && v && !relationValuesToExclude.includes(v) && !isEasEmptyValue('bytes32', v)) {
                 state.relatedSeedUids.add(v);
+            }
         }
     }
 };
@@ -315,9 +261,9 @@ const collectRelatedSeedUids = async (properties, state) => {
  * of HTMLPage have. A name matching no local model, or several, is kept as it is.
  */
 const localModelType = async (easModelName) => {
-    const _mod_2 = await import('./errors-D1zHAqjr.js');
-    const _ns_2 = _mod_2.i;
-    const { Model } = _ns_2;
+    const _mod_1 = await import('./errors-DLSoqSHG.js');
+    const _ns_1 = _mod_1.a4;
+    const { Model } = _ns_1;
     try {
         const model = Model.findByModelType(easModelName);
         return model?.modelName ? easName(model.modelName) : easModelName;
@@ -382,7 +328,17 @@ const saveEasSeedsToDb = async ({ itemSeeds, state }) => {
             ...(revokedAt !== undefined && { revokedAt }),
         });
     }
-    await createSeeds(newSeedsData);
+    const inserted = await createSeeds(newSeedsData);
+    // A row another writer stored for the uid since the lookup above (publish recording it) is the seed.
+    const raced = newSeedsData.filter((row) => !inserted.has(row.localId)).map((row) => row.uid);
+    if (raced.length > 0) {
+        for (const [uid, row] of await findSeedRowsByUid(raced)) {
+            if (row.localId)
+                seedUidToLocalId.set(uid, row.localId);
+            if (row.type)
+                seedUidToModelType.set(uid, row.type);
+        }
+    }
     // All fetched seeds, not only the new ones: existing seeds can have new versions on EAS.
     return { seedUids };
 };
@@ -449,8 +405,30 @@ const saveEasVersionsToDb = async ({ itemVersions, state }) => {
         });
     }
     // Bound parameters: keep each statement well under SQLite's host-parameter limit.
+    // A uid another writer stored since the lookup above is not inserted again (versions.uid is
+    // unique): its row is the version.
+    const insertedLocalIds = new Set();
     for (let i = 0; i < rows.length; i += VERSION_INSERT_BATCH) {
-        await appDb.insert(versions).values(rows.slice(i, i + VERSION_INSERT_BATCH));
+        const inserted = await appDb
+            .insert(versions)
+            .values(rows.slice(i, i + VERSION_INSERT_BATCH))
+            .onConflictDoNothing()
+            .returning({ localId: versions.localId });
+        for (const row of inserted)
+            if (row.localId)
+                insertedLocalIds.add(row.localId);
+    }
+    const raced = rows.filter((row) => !insertedLocalIds.has(row.localId)).map((row) => row.uid);
+    if (raced.length > 0) {
+        const stored = await selectInBatches(raced, (chunk) => appDb.select().from(versions).where(inArray(versions.uid, chunk)));
+        for (const row of stored) {
+            if (!row.uid)
+                continue;
+            if (row.localId)
+                versionUidToLocalId.set(row.uid, row.localId);
+            if (row.seedUid)
+                versionUidToSeedUid.set(row.uid, row.seedUid);
+        }
     }
     // Only versions that are stored locally: properties of a skipped version would have no version row.
     return { versionUids: versionUids.filter((uid) => storedVersionUids.has(uid)) };
@@ -518,12 +496,13 @@ const createMetadataRecordsForStorageTransactionId = async (storageTransactionId
         if (existingMetadataRecordRows && existingMetadataRecordRows.length > 0) {
             continue;
         }
-        const propertyId = propertyDef.id ??
-            (modelType != null
-                ? ((await skipSeedOnAmbiguousModel({ seedLocalId, seedUid }, 'easSync.storageTransactionId', async () => getPropertyIdForModelAndName(modelType, _propertyName, {
-                    modelFileId: await resolveItemModelFileId({ seedLocalId, seedUid }),
-                }))) ?? null)
-                : null);
+        const propertyId = (await skipSeedOnAmbiguousModel({ seedLocalId, seedUid }, 'easSync.storageTransactionId', async () => resolveMetadataPropertyId({
+            definitionId: propertyDef.id,
+            propertyName: _propertyName,
+            modelName: modelType,
+            seedLocalId,
+            seedUid,
+        }))) ?? null;
         const propertyLocalId = generateId();
         await appDb.insert(metadata).values({
             localId: propertyLocalId,
@@ -575,6 +554,8 @@ const saveEasPropertiesToDbBody = async ({ fetchedProperties, itemSeeds, state,
     const existingPropertyRecordsUids = new Set();
     const staleUids = new Set();
     const revokedAtUpdates = new Map();
+    // Rows whose attestation EAS now reports revoked while the seed is live: retracted (ADR 0021)
+    const retractedUids = new Set();
     for (const row of storedRows) {
         if (!row.uid)
             continue;
@@ -589,6 +570,8 @@ const saveEasPropertiesToDbBody = async ({ fetchedProperties, itemSeeds, state,
         const revokedAt = syncedRevokedAt(canonical, row.revokedAt);
         if ((row.revokedAt ?? null) !== revokedAt) {
             revokedAtUpdates.set(row.uid, revokedAt);
+            if (revokedAt != null && isRetracted(canonical, itemSeeds, state))
+                retractedUids.add(row.uid);
         }
     }
     const newProperties = itemProperties.filter((property) => !existingPropertyRecordsUids.has(property.id));
@@ -602,7 +585,15 @@ const saveEasPropertiesToDbBody = async ({ fetchedProperties, itemSeeds, state,
     for (const [uid, revokedAt] of revokedAtUpdates) {
         await appDb
             .update(metadata)
-            .set({ revokedAt })
+            .set({
+            revokedAt,
+            ...(retractedUids.has(uid) && {
+                propertyValue: null,
+                refSeedType: null,
+                refResolvedValue: null,
+                refResolvedDisplayValue: null,
+            }),
+        })
             .where(eq(metadata.uid, uid));
     }
     await syncDerivedStorageRows({ fetchedProperties, canonicalProperties: itemProperties });
@@ -691,9 +682,9 @@ const resolveSyncedSeedModel = async (Model, modelType, seed) => {
 const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
     const { seedUidToLocalId, seedUidToModelType, versionUidToLocalId, versionUidToSeedUid } = state;
     // Dynamic import to break circular dependency
-    const _mod_3 = await import('./errors-D1zHAqjr.js');
-    const _ns_3 = _mod_3.i;
-    const modelMod = _ns_3;
+    const _mod_2 = await import('./errors-DLSoqSHG.js');
+    const _ns_2 = _mod_2.a4;
+    const modelMod = _ns_2;
     const { Model } = modelMod;
     // Loads every model into Model's cache, where resolveSyncedSeedModel looks them up.
     await Model.all();
@@ -749,21 +740,25 @@ const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
         if (isRelation && !isList && relationValuesToExclude.includes(propertyMetadata.value)) {
             continue;
         }
+        // A removal or a retraction (ADR 0021) is stored as no value, so it is the property's newest row
+        const cleared = isEasEmptyValue(easDataType, propertyMetadata.value) || isRetracted(property, itemSeeds, state);
         // ADR 0010: numeric values decoded (Number as a decimal string, Date as ISO).
-        const decodedValue = syncedPropertyValue(resolvedName.dataType, easDataType, propertyMetadata.value);
+        const decodedValue = cleared
+            ? null
+            : syncedPropertyValue(resolvedName.dataType, easDataType, propertyMetadata.value);
         if (decodedValue === undefined) {
             console.warn(`[item/events] [syncDbWithEas] EAS property "${propertyNameSnake}" has a value that isn't a valid ${resolvedName.dataType}; skipping it`);
             continue;
         }
-        const propertyValue = typeof decodedValue === 'string' ? decodedValue : JSON.stringify(decodedValue);
-        if (isRelation && !isList) {
+        const propertyValue = decodedValue === null ? null : typeof decodedValue === 'string' ? decodedValue : JSON.stringify(decodedValue);
+        if (isRelation && !isList && !cleared) {
             const relatedSeed = itemSeeds.find((seed) => seed.id === propertyMetadata.value);
             if (relatedSeed && relatedSeed.schema && relatedSeed.schema.schemaNames) {
                 refSeedType = relatedSeed.schema.schemaNames[0].name;
                 refSchemaUid = relatedSeed.schemaId;
             }
         }
-        if (isRelation && isList) {
+        if (isRelation && isList && !cleared) {
             const relatedSeeds = itemSeeds.filter((seed) => propertyMetadata.value.includes(seed.id));
             if (relatedSeeds && relatedSeeds.length > 0) {
                 refSeedType = relatedSeeds[0].schema.schemaNames[0].name;
@@ -773,12 +768,14 @@ const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
         if (propertyNameSnake === 'storage_transaction_id') {
             await createMetadataRecordsForStorageTransactionId(property, modelSchema, state);
         }
-        const propertyId = modelType != null
-            ? ((await skipSeedOnAmbiguousModel({ seedLocalId, seedUid }, 'easSync.metadata', async () => getPropertyIdForModelAndName(modelType, propertyName, {
-                // EAS identifies models by name only; a locally-created seed still knows its model.
-                modelFileId: await resolveItemModelFileId({ seedLocalId, seedUid }),
-            }))) ?? null)
-            : null;
+        const propertyId = (await skipSeedOnAmbiguousModel({ seedLocalId, seedUid }, 'easSync.metadata', async () => resolveMetadataPropertyId({
+            definitionId: resolvedName.definitionId,
+            propertyName,
+            // EAS identifies models by name only; a locally-created seed still knows its model.
+            modelName: modelType,
+            seedLocalId,
+            seedUid,
+        }))) ?? null;
         rows.push({
             localId: propertyLocalId,
             uid: property.id,
@@ -808,9 +805,9 @@ const insertSyncedProperties = async ({ newProperties, itemSeeds, state, }) => {
         await appDb.insert(metadata).values(rows.slice(i, i + batchSize));
     }
     // A local draft of a synced property stays its value, and the conflict is recorded (ADR 0019)
-    const _mod_4 = await import('./ClientManager-GZfXErDX.js');
-    const _ns_4 = _mod_4.U;
-    const { keepLocalDraftsOverSyncedRows } = _ns_4;
+    const _mod_3 = await import('./Item-Bf4kWKpH.js');
+    const _ns_3 = _mod_3.b3;
+    const { keepLocalDraftsOverSyncedRows } = _ns_3;
     await keepLocalDraftsOverSyncedRows(rows);
 };
 const saveEasPropertiesToDb = (params) => {
@@ -910,38 +907,13 @@ const runSyncFromEas = async (options) => {
     const appDb = BaseDb.getAppDb();
     // ADR 0009: this run matches names at the levels the stored schema files set now.
     await loadNameMatchLevels(appDb);
-    const { matchModelRecord } = await getModelSchemas();
-    const modelSchemas = await getModelSchemasFromEas();
-    const schemaUids = [];
-    for (const modelSchema of modelSchemas) {
-        // ADR 0008: matched by name, so seeds published under an older SDK's name are found too.
-        const foundModel = matchModelRecord(modelSchema.schema);
-        if (!foundModel) {
-            // Skip schemas that don't have a corresponding model in the user's config
-            // This can happen with "bytes32 image" if there's no Image model defined
-            console.warn(`[item/events] [syncDbWithEas] Model not found for schema ${modelSchema.schema}, skipping`);
-            continue;
-        }
-        try {
-            await appDb
-                .insert(modelUids)
-                .values({
-                modelId: foundModel.id,
-                uid: modelSchema.id,
-            })
-                .onConflictDoNothing();
-        }
-        catch (err) {
-            // Model may have been deleted by test teardown or another process; skip to avoid unhandled rejection
-            const e = err;
-            const code = e?.code ?? e?.rawCode ?? e?.cause?.code ?? e?.cause?.rawCode;
-            if (code === 'SQLITE_CONSTRAINT_FOREIGNKEY' || code === 787) {
-                continue;
-            }
-            throw err;
-        }
-        schemaUids.push(modelSchema.id);
-    }
+    // ADR 0008: matched by name, so seeds published under an older SDK's name are found too. Schemas
+    // that match no local model (e.g. "bytes32 image" with no Image model) aren't fetched.
+    const modelSchemaLookups = await localModelSchemaLookups();
+    const modelSchemaMatches = matchEasModelSchemas(await getModelSchemasFromEas(modelSchemaLookups), modelSchemaLookups);
+    // The same rule as init: only each model's exact schema goes into model_uids.
+    await writeModelUids(modelSchemaMatches, appDb);
+    const schemaUids = [...new Set(modelSchemaMatches.map((match) => match.schema.id))];
     // If no schemas were found, skip the rest of the sync process
     // This can happen when models exist but don't have schemas registered in EAS yet
     if (schemaUids.length === 0) {
@@ -960,18 +932,20 @@ const runSyncFromEas = async (options) => {
     await syncVersionsAndPropertiesForSeeds({ seedUids, itemSeeds, state });
     await getRelatedSeedsAndVersions(state);
     scheduleBulkFilesDownloadFromEasSync(addresses);
-    try {
-        const _mod_5 = await import('./Item-0oDoTPhi.js');
-        const _ns_5 = _mod_5.au;
-        const itemMod = _ns_5;
-        await itemMod.Item.rehydrateCachedItemsFromDbAfterEasSync();
-    }
-    catch (err) {
-        console.warn('[item/events] [syncDbWithEas] rehydrateCachedItemsFromDbAfterEasSync:', err);
+    // Loaded items in the browser see sync's writes through the change feed (ADR 0020); Node has none.
+    if (!isBrowser()) {
+        try {
+            const _mod_4 = await import('./Item-Bf4kWKpH.js');
+            const _ns_4 = _mod_4.b5;
+            const itemMod = _ns_4;
+            await itemMod.Item.rehydrateCachedItemsFromDbAfterEasSync();
+        }
+        catch (err) {
+            console.warn('[item/events] [syncDbWithEas] rehydrateCachedItemsFromDbAfterEasSync:', err);
+        }
     }
-    // Other tabs reload their cached Items too (docs/MULTI_TAB.md).
     emitAcrossTabs(EAS_SEED_DATA_SYNCED_TO_DB_EVENT);
 };
 
 export { VERSION_INSERT_BATCH, runSyncFromEas };
-//# sourceMappingURL=syncDbWithEas-DUu_wjUG.js.map
+//# sourceMappingURL=syncDbWithEas-CA7PvBgu.js.map