@seedprotocol/sdk 0.7.9 → 0.7.10-next.1344.g3828e8a

package/dist/{eas-wB_fQ8Tc.js → eas-DpHg66jR.js}

@@ -1,11 +1,11 @@
 import { fetchEasModelSchemas } from '@seedprotocol/eas';
 export { getItemPropertiesFromEas, getItemVersionsFromEas, getSeedsFromSchemaUids } from '@seedprotocol/eas';
-import { k as localModelSchemaLookups } from './errors-DLSoqSHG.js';
+import { k as localModelSchemaLookups } from './errors-DpC9W4i3.js';
 import 'xstate';
-import './Item-Bf4kWKpH.js';
-import './tabEvents-CaVmngqr.js';
+import './Item-CXLcIHsi.js';
+import './tabEvents-BHPY5I08.js';
 import 'debug';
-import './BaseFileManager-BAlySv8w.js';
+import './BaseFileManager-DLou1TZS.js';
 import 'drizzle-orm/sqlite-core';
 import 'drizzle-orm';
 import 'pluralize';
@@ -29,4 +29,4 @@ import '@seedprotocol/query';
 const getModelSchemasFromEas = async (lookups) => fetchEasModelSchemas(lookups ?? (await localModelSchemaLookups()));
 
 export { getModelSchemasFromEas };
-//# sourceMappingURL=eas-wB_fQ8Tc.js.map
+//# sourceMappingURL=eas-DpHg66jR.js.map

package/dist/{eas-wB_fQ8Tc.js.map → eas-DpHg66jR.js.map}

@@ -1 +1 @@
-{"version":3,"file":"eas-wB_fQ8Tc.js","sources":["../../src/eas.ts"],"sourcesContent":["// Sync reads EAS through this module so tests can replace these with one `vi.mock('@/eas')`.\nexport {\n  getItemVersionsFromEas,\n  getItemPropertiesFromEas,\n  getSeedsFromSchemaUids,\n} from '@seedprotocol/eas'\n\nimport { fetchEasModelSchemas } from '@seedprotocol/eas'\nimport type { EASSchema, ModelSchemaLookup } from '@seedprotocol/eas'\nimport { localModelSchemaLookups } from '@/db/read/localModelSchemaLookups'\n\n/**\n * The EAS model schemas the local models (or `lookups`) can match; see fetchEasModelSchemas.\n * Init and sync match the result with matchEasModelSchemas and record `model_uids` from it with\n * writeModelUids. Throws when the request fails.\n */\nexport const getModelSchemasFromEas = async (lookups?: readonly ModelSchemaLookup[]): Promise<EASSchema[]> =>\n  fetchEasModelSchemas(lookups ?? (await localModelSchemaLookups())) as Promise<EASSchema[]>\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAWA;;;;AAIG;MACU,sBAAsB,GAAG,OAAO,OAAsC,KACjF,oBAAoB,CAAC,OAAO,KAAK,MAAM,uBAAuB,EAAE,CAAC;;"}
+{"version":3,"file":"eas-DpHg66jR.js","sources":["../../src/eas.ts"],"sourcesContent":["// Sync reads EAS through this module so tests can replace these with one `vi.mock('@/eas')`.\nexport {\n  getItemVersionsFromEas,\n  getItemPropertiesFromEas,\n  getSeedsFromSchemaUids,\n} from '@seedprotocol/eas'\n\nimport { fetchEasModelSchemas } from '@seedprotocol/eas'\nimport type { EASSchema, ModelSchemaLookup } from '@seedprotocol/eas'\nimport { localModelSchemaLookups } from '@/db/read/localModelSchemaLookups'\n\n/**\n * The EAS model schemas the local models (or `lookups`) can match; see fetchEasModelSchemas.\n * Init and sync match the result with matchEasModelSchemas and record `model_uids` from it with\n * writeModelUids. Throws when the request fails.\n */\nexport const getModelSchemasFromEas = async (lookups?: readonly ModelSchemaLookup[]): Promise<EASSchema[]> =>\n  fetchEasModelSchemas(lookups ?? (await localModelSchemaLookups())) as Promise<EASSchema[]>\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAWA;;;;AAIG;MACU,sBAAsB,GAAG,OAAO,OAAsC,KACjF,oBAAoB,CAAC,OAAO,KAAK,MAAM,uBAAuB,EAAE,CAAC;;"}

package/dist/{errors-DLSoqSHG.js → errors-DpC9W4i3.js}

@@ -1,8 +1,8 @@
 import { fromCallback, setup, assign, createActor, waitFor, fromPromise } from 'xstate';
-import { aj as isActorStopped, T as applyContextUpdate, U as isInternalUpdate, ak as differsFromOriginals, X as isEntityTornDown, al as onEntityTeardown, V as evictionLog, Y as sameEntity, Z as DEFAULT_READY_TIMEOUT_MS, _ as waitForEntityReady, $ as createReactiveProxy, a0 as runEntityLoad, a2 as entityStatus, I as Item, a1 as evictEntities, a3 as releaseEntity, a4 as destroyEntity, a7 as modelPropertiesToObject, a5 as EntityCache, a9 as easPropertyNameForPublish, ae as matchMetadataProperty, aQ as getSeedPublisher, af as metadataRowsOfProperty, ag as METADATA_LATEST_FIRST_ORDER_SQL, aR as deleteStagedFile, aS as storageFileName, aT as STORAGE_SUBDIR, aU as resolveNewSeedFields, aV as lookupPropertySchemaUid, aW as stageStorageContent, aX as requireStagedFile, aY as createSeed, aZ as createMetadata, H as compareMetadataRowsLatestFirst, a_ as storageValueRowOf, t as registerOutboxApplier, r as outboxOpValue, a$ as findSetConflict, b0 as recordPropertyEdit, h as OutboxOpDeferredError, u as startOutbox, i as OutboxOpFailedError, y as OwnershipError, B as isItemOwned, R as getLatestVersionRow, S as parseListPropertyValueFromStorage, ar as resolvePublisherFromSeedRow, aB as isLocalUnsealedDraft } from './Item-Bf4kWKpH.js';
+import { aj as isActorStopped, T as applyContextUpdate, U as isInternalUpdate, ak as differsFromOriginals, X as isEntityTornDown, al as onEntityTeardown, V as evictionLog, Y as sameEntity, Z as DEFAULT_READY_TIMEOUT_MS, _ as waitForEntityReady, $ as createReactiveProxy, a0 as runEntityLoad, a2 as entityStatus, I as Item, a1 as evictEntities, a3 as releaseEntity, a4 as destroyEntity, a7 as modelPropertiesToObject, a5 as EntityCache, a9 as easPropertyNameForPublish, ae as matchMetadataProperty, aT as getSeedPublisher, af as metadataRowsOfProperty, ag as METADATA_LATEST_FIRST_ORDER_SQL, aU as deleteStagedFile, aV as storageFileName, aW as STORAGE_SUBDIR, aX as resolveNewSeedFields, aY as lookupPropertySchemaUid, aZ as stageStorageContent, a_ as requireStagedFile, a$ as createSeed, b0 as createMetadata, H as compareMetadataRowsLatestFirst, b1 as storageValueRowOf, t as registerOutboxApplier, r as outboxOpValue, b2 as findSetConflict, b3 as recordPropertyEdit, h as OutboxOpDeferredError, u as startOutbox, i as OutboxOpFailedError, y as OwnershipError, B as isItemOwned, R as getLatestVersionRow, S as parseListPropertyValueFromStorage, at as resolvePublisherFromSeedRow, aE as isLocalUnsealedDraft, b4 as setEntityUnloadGraceMs, b5 as stopOutbox, b6 as evictAllEntities } from './Item-CXLcIHsi.js';
 import debug from 'debug';
-import { B as BaseDb, l as properties, d as models$1, j as modelSchemas, t as schemas, f as easSyncProcesses, a as appState, w as BaseFileManager, b as modelUids, s as seeds, v as versions, m as metadata$1, p as pendingWrites, h as htmlEmbeddedImageCoPublish, e as arweaveL1FinalizeJobs, r as publishProcesses } from './BaseFileManager-BAlySv8w.js';
-import { aH as writeModelToDb, aI as writePropertyToDb, m as generateId, p as isInternalSchema, A as AmbiguousModelError, aJ as currentNameMatchLevels, aK as renameModelInDb, s as isClientReady, a as TProperty, ay as withDbTabLock, af as MachineIds, ap as isLeaderTab, aL as postTabMessage, aM as onTabMessage, ax as whenLeaderTab, aN as listenForOtherTabsEvents, F as isBrowser, $ as isNode, aO as startTabCoordination, aq as normalizeAddressConfig, aP as isTestOrSeedDev, L as nameMatchLevels, C as loadNameMatchLevels, aD as withSeedDbLock, q as inDefinitionsTransaction, aQ as insertModelStubs, G as emitAcrossTabs, a8 as ADDRESSES_PERSISTED_EVENT, ar as normalizeAddressList, aR as warnOnInvalidNameMatch, u as upsertSchemaRow, aS as refreshCachedProperties, g as normalizePropertyRecordSchema, M as ModelPropertyDataTypes, j as findSeedRow, aT as tryWithTabLock, Y as getItemStorageSubdir, _ as getItemStorageLocalFileName, aU as notifyFileSaved, ad as ImageSize, n as normalizeDataType, ab as ClientManagerState, aV as ClientManagerEvents, at as parseAddressesPersistedPayload, x as normalizePublisher, w as writeInBatches, K as selectInBatches, ae as LOCAL_COPIES_REMOVED_EVENT, aW as getWatchedAddressesFromDb, aX as getOwnedAddressesFromDb, aY as CLIENT_NOT_INITIALIZED, aZ as registerClientActor } from './tabEvents-CaVmngqr.js';
+import { B as BaseDb, l as properties, d as models$1, j as modelSchemas, t as schemas, f as easSyncProcesses, a as appState, w as BaseFileManager, b as modelUids, s as seeds, v as versions, m as metadata$1, p as pendingWrites, h as htmlEmbeddedImageCoPublish, e as arweaveL1FinalizeJobs, r as publishProcesses } from './BaseFileManager-DLou1TZS.js';
+import { aI as writeModelToDb, aJ as writePropertyToDb, m as generateId, p as isInternalSchema, A as AmbiguousModelError, aK as currentNameMatchLevels, aL as renameModelInDb, s as isClientReady, a as TProperty, ay as withDbTabLock, af as MachineIds, ap as isLeaderTab, aM as postTabMessage, aN as onTabMessage, ax as whenLeaderTab, aO as listenForOtherTabsEvents, F as isBrowser, $ as isNode, aP as startTabCoordination, aq as normalizeAddressConfig, aQ as isTestOrSeedDev, L as nameMatchLevels, C as loadNameMatchLevels, aD as withSeedDbLock, q as inDefinitionsTransaction, aR as insertModelStubs, G as emitAcrossTabs, a8 as ADDRESSES_PERSISTED_EVENT, ar as normalizeAddressList, aS as warnOnInvalidNameMatch, u as upsertSchemaRow, aT as refreshCachedProperties, g as normalizePropertyRecordSchema, M as ModelPropertyDataTypes, j as findSeedRow, aU as tryWithTabLock, Y as getItemStorageSubdir, _ as getItemStorageLocalFileName, aV as notifyFileSaved, ad as ImageSize, n as normalizeDataType, ab as ClientManagerState, aW as ClientManagerEvents, at as parseAddressesPersistedPayload, x as normalizePublisher, w as writeInBatches, K as selectInBatches, ae as LOCAL_COPIES_REMOVED_EVENT, aX as getWatchedAddressesFromDb, aY as getOwnedAddressesFromDb, aZ as CLIENT_NOT_INITIALIZED, a_ as stopTabCoordination, a$ as registerClientActor } from './tabEvents-BHPY5I08.js';
 import { seedGatewayConfigFromSeedConfig, setPreferredArweaveReadBaseUrls, resolveSeedGatewayEndpoints, setResolvedSeedGatewayEndpoints, BaseArweaveClient, ensureReadGatewaySelected, DEFAULT_ARWEAVE_HOST } from '@seedprotocol/arweave';
 import 'pluralize';
 import { localNamesInBestMatchTier, configureEasReadChain, matchEasModelSchemas, whenEasReadChainSettled, getEasReadChainId, DEFAULT_EAS_CHAIN_ID, isEasReadChainConfigured, easName, isValidEasAttestationUid } from '@seedprotocol/eas';
@@ -36,10 +36,10 @@ const validateModel = fromCallback(({ sendBack, input: { context }, self }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-CnmKyzR-.js');
+            const validationServiceMod = await import('./SchemaValidationService-C1xqJFxI.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_0 = await import('./Schema-J_1f6p0c.js');
+            const _mod_0 = await import('./Schema-BeUyEmte.js');
             const _ns_0 = _mod_0.a;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -320,7 +320,7 @@ async function createModelProperties(model, propertyDefinitions) {
         throw new Error('Model ID, file ID, and name are required to create properties');
     }
     logger$f(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-    const { ModelProperty } = await import('./ModelProperty-BlaEgb_U.js');
+    const { ModelProperty } = await import('./ModelProperty-B3mfR6u4.js');
     const { and, eq } = await import('drizzle-orm');
     const db = BaseDb.getAppDb();
     for (const [propName, propData] of Object.entries(propertyDefinitions)) {
@@ -338,8 +338,8 @@ async function createModelProperties(model, propertyDefinitions) {
             : undefined;
         // Otherwise use provided ID or generate a random one
         // IDs should be generated in the import process before creating properties
-        const _mod_1 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_1 = _mod_1.bi;
+        const _mod_1 = await import('./tabEvents-BHPY5I08.js');
+        const _ns_1 = _mod_1.bl;
         const { generateId } = _ns_1;
         const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
         logger$f(`Creating property "${propName}" with fileId "${propertyFileId}"`);
@@ -356,8 +356,8 @@ async function createModelProperties(model, propertyDefinitions) {
                 }
                 else if (refModelName) {
                     // Fallback: resolve the ref by name within this model's schema
-                    const _mod_2 = await import('./tabEvents-CaVmngqr.js');
-                    const _ns_2 = _mod_2.be;
+                    const _mod_2 = await import('./tabEvents-BHPY5I08.js');
+                    const _ns_2 = _mod_2.bh;
                     const { resolveModelRecord } = _ns_2;
                     const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                     if (refModelRecord?.id) {
@@ -452,7 +452,7 @@ const write = async (input) => {
         });
     }
     // Imported here: the validation service imports the Schema barrel, which imports this module's callers
-    const { SchemaValidationService } = await import('./SchemaValidationService-CnmKyzR-.js');
+    const { SchemaValidationService } = await import('./SchemaValidationService-C1xqJFxI.js');
     const data = input.data();
     const { errors } = new SchemaValidationService().validatePropertyStructure(data);
     if (errors.length > 0) {
@@ -613,7 +613,7 @@ const createPropertyInstances = async (propertyFileIds, since) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-BlaEgb_U.js');
+        const mod = await import('./ModelProperty-B3mfR6u4.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$d('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -684,10 +684,10 @@ async function loadModel(context, isStopped) {
             if (!modelRecord) {
                 // Model names are only unique per schema: prefer this schema's row, and otherwise only
                 // consider same-name rows that no schema claims yet (never another schema's model).
-                const _mod_3 = await import('./BaseFileManager-BAlySv8w.js');
+                const _mod_3 = await import('./BaseFileManager-DLou1TZS.js');
                 const _ns_3 = _mod_3.M;
                 const { modelSchemas } = _ns_3;
-                const _mod_4 = await import('./BaseFileManager-BAlySv8w.js');
+                const _mod_4 = await import('./BaseFileManager-DLou1TZS.js');
                 const _ns_4 = _mod_4.z;
                 const { schemas: schemasTable } = _ns_4;
                 let dbModels = await db
@@ -827,7 +827,7 @@ async function loadModel(context, isStopped) {
     // Step 2: Fallback to Schema context (only if database doesn't have the model)
     // This handles the case where model exists in schema file but not yet in database
     try {
-        const _mod_5 = await import('./Schema-J_1f6p0c.js');
+        const _mod_5 = await import('./Schema-BeUyEmte.js');
         const _ns_5 = _mod_5.a;
         const { Schema } = _ns_5;
         // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
@@ -912,11 +912,11 @@ async function loadModel(context, isStopped) {
                 }
                 // Also check database for models (in case they're persisted but not in Schema context)
                 if (db) {
-                    const _mod_6 = await import('./BaseFileManager-BAlySv8w.js');
+                    const _mod_6 = await import('./BaseFileManager-DLou1TZS.js');
                     const _ns_6 = _mod_6.M;
                     const modelSchemaSchemaMod = _ns_6;
                     const { modelSchemas } = modelSchemaSchemaMod;
-                    const _mod_7 = await import('./BaseFileManager-BAlySv8w.js');
+                    const _mod_7 = await import('./BaseFileManager-DLou1TZS.js');
                     const _ns_7 = _mod_7.z;
                     const schemaSchemaMod = _ns_7;
                     const { schemas: schemasTable } = schemaSchemaMod;
@@ -995,7 +995,7 @@ async function loadModel(context, isStopped) {
     }
     // Mark schema as draft when a new model is created so saveNewVersion() can persist it
     try {
-        const _mod_8 = await import('./Schema-J_1f6p0c.js');
+        const _mod_8 = await import('./Schema-BeUyEmte.js');
         const _ns_8 = _mod_8.a;
         const { Schema } = _ns_8;
         if (!isStopped()) {
@@ -1089,7 +1089,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-BlaEgb_U.js')
+const modelPropertyImportPromise = import('./ModelProperty-B3mfR6u4.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -1579,8 +1579,8 @@ class Model {
             if (db) {
                 const since = evictionLog.now();
                 try {
-                    const _mod_9 = await import('./tabEvents-CaVmngqr.js');
-                    const _ns_9 = _mod_9.be;
+                    const _mod_9 = await import('./tabEvents-BHPY5I08.js');
+                    const _ns_9 = _mod_9.bh;
                     const { resolveModelRecord, getModelSchemaName } = _ns_9;
                     const resolved = scope.modelFileId
                         ? await resolveModelRecord(undefined, { modelFileId: scope.modelFileId }, db)
@@ -1626,8 +1626,8 @@ class Model {
         }
         const since = options?.since ?? evictionLog.now();
         try {
-            const _mod_10 = await import('./tabEvents-CaVmngqr.js');
-            const _ns_10 = _mod_10.be;
+            const _mod_10 = await import('./tabEvents-BHPY5I08.js');
+            const _ns_10 = _mod_10.bh;
             const { resolveModelRecord, getModelSchemaName } = _ns_10;
             const resolved = await resolveModelRecord(modelName, schemaName ? { schemaName, strict: true } : {}, db);
             if (!resolved?.schemaFileId) {
@@ -2099,9 +2099,9 @@ class Model {
                         .limit(1);
                     if (modelRecord) {
                         const modelId = modelRecord.id;
-                        const { detachModelRows } = await import('./detachRowsBeforeDelete-sEaUwlOU.js');
-                        const _mod_11 = await import('./tabEvents-CaVmngqr.js');
-                        const _ns_11 = _mod_11.bg;
+                        const { detachModelRows } = await import('./detachRowsBeforeDelete-BZr_0iZU.js');
+                        const _mod_11 = await import('./tabEvents-BHPY5I08.js');
+                        const _ns_11 = _mod_11.bj;
                         const { inDefinitionsTransaction } = _ns_11;
                         // The model's rows go together or not at all
                         await inDefinitionsTransaction(async (tx) => {
@@ -2117,7 +2117,7 @@ class Model {
                 getModelProperty()?.evictForModel({ modelName, schemaName, modelId: dbId });
                 if (schemaName && modelName) {
                     // Imported here, not at module load: Model and Schema import each other.
-                    const _mod_12 = await import('./Schema-J_1f6p0c.js');
+                    const _mod_12 = await import('./Schema-BeUyEmte.js');
                     const _ns_12 = _mod_12.a;
                     const { Schema } = _ns_12;
                     const schema = await Schema.find({ schemaName, waitForReady: false, hold: false });
@@ -2156,8 +2156,8 @@ class Model {
                             return undefined;
                         }
                         // Model names are only unique per schema: find this model's row by its id (schemaFileId).
-                        const _mod_13 = await import('./tabEvents-CaVmngqr.js');
-                        const _ns_13 = _mod_13.be;
+                        const _mod_13 = await import('./tabEvents-BHPY5I08.js');
+                        const _ns_13 = _mod_13.bh;
                         const { resolveModelRecord } = _ns_13;
                         const modelRecord = await resolveModelRecord(modelName, { modelFileId: context.id, schemaName: context.schemaName }, db);
                         if (!modelRecord?.id) {
@@ -2534,7 +2534,7 @@ function toRunSyncArg(options) {
     return undefined;
 }
 const runEasSync = fromPromise(async ({ input, }) => {
-    const { runSyncFromEas } = await import('./syncDbWithEas-CA7PvBgu.js');
+    const { runSyncFromEas } = await import('./syncDbWithEas-CDjSNrVR.js');
     // Sync checks for rows and then inserts the rest (no unique index on uids), so syncs in
     // different tabs take turns. A sync can run for minutes, so wait without a timeout.
     await withDbTabLock('eas-sync', async () => {
@@ -2867,7 +2867,7 @@ async function platformClassesInit({ event }) {
     if (!config) {
         throw new Error('client.init requires a config');
     }
-    const { configurePlatform } = await import('./configurePlatform-CiOJ1R3q.js');
+    const { configurePlatform } = await import('./configurePlatform-WkmvqeTO.js');
     if (isBrowser()) {
         const { createPlatformServices } = await import('./platform.browser.js');
         configurePlatform(createPlatformServices());
@@ -3154,7 +3154,7 @@ async function addModelsToDb(context) {
                     timeout = setTimeout(() => reject(new Error('EAS query timeout after 10 seconds')), 10000);
                 });
                 // The lookup and the model_uids rule sync uses too (each name at its nameMatch level).
-                const { getModelSchemasFromEas } = await import('./eas-wB_fQ8Tc.js');
+                const { getModelSchemasFromEas } = await import('./eas-DpHg66jR.js');
                 const lookups = await localModelSchemaLookups([...modelNamesWithRows]);
                 // Cleared, so a finished lookup doesn't keep a Node process alive for 10 s.
                 const schemas = await Promise.race([getModelSchemasFromEas(lookups), timeoutPromise]).finally(() => clearTimeout(timeout));
@@ -3737,7 +3737,7 @@ function schemaFilePropertyDefinition(modelName, propName, prop) {
         dataType: def.dataType,
         ref: hasRef ? def.ref : undefined,
         refModelName: hasRef ? def.refModelName : undefined,
-        refValueType: isList ? def.refValueType : undefined,
+        refValueType: hasRef ? def.refValueType : undefined,
         storageType: def.storageType,
         localStorageDir: def.localStorageDir,
         filenameSuffix: def.filenameSuffix,
@@ -3871,8 +3871,8 @@ async function applySchemaFile(source, options = {}) {
     if (!schemaRecord) {
         warnOnEasNameCollisions(file);
         warnOnInvalidNameMatch(file);
-        const _mod_14 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_14 = _mod_14.bh;
+        const _mod_14 = await import('./tabEvents-BHPY5I08.js');
+        const _ns_14 = _mod_14.bk;
         const { addModelsToDb, broadcastSchemasInvalidate } = _ns_14;
         const modelFileIds = new Map(Object.entries(file.models).map(([name, model]) => [name, model.id]));
         const propertyDefinitions = schemaFilePropertyDefinitions(file);
@@ -4023,8 +4023,8 @@ async function resolveSchemaRow(row, db = BaseDb.getAppDb()) {
         metadata: { ...schema.metadata, name: row.name },
     };
     if (row.id && db) {
-        const _mod_15 = await import('./tabEvents-CaVmngqr.js');
-        const _ns_15 = _mod_15.bh;
+        const _mod_15 = await import('./tabEvents-BHPY5I08.js');
+        const _ns_15 = _mod_15.bk;
         const { loadModelsFromDbForSchema, mergeDbModelsIntoSchemaModels } = _ns_15;
         const dbModels = await loadModelsFromDbForSchema(row.id, db);
         if (Object.keys(dbModels).length > 0) {
@@ -4603,6 +4603,10 @@ function startCanonicalizeModelTypes() {
         void runInBackground();
     });
 }
+/** Resolves when a background run has finished (at once if none is running). */
+function whenCanonicalizeModelTypesSettled() {
+    return running ?? Promise.resolve();
+}
 
 const getVersionData = async ({ localId, seedLocalId, uid, }, db = BaseDb.getAppDb()) => {
     const appDb = db;
@@ -4955,8 +4959,8 @@ async function applyStorageValue(seedLocalId, propertyName, value, db, prepared)
     const row = prepared
         ? { ...stored, refResolvedValue: prepared.fileName, schemaUid: prepared.schemaUid, refModelUid: prepared.refModelUid }
         : stored;
-    const _mod_16 = await import('./Item-Bf4kWKpH.js');
-    const _ns_16 = _mod_16.b1;
+    const _mod_16 = await import('./Item-CXLcIHsi.js');
+    const _ns_16 = _mod_16.b7;
     const { currentPropertyRow } = _ns_16;
     const existing = await currentPropertyRow({ seedLocalId }, {
         propertyName,
@@ -5269,8 +5273,8 @@ function startItemOutbox() {
                     return {};
                 // Cached, shared with item creation, so a save doesn't wait on the EAS indexer each time.
                 // Not required for the row; publish resolves the schema again.
-                const _mod_17 = await import('./Item-Bf4kWKpH.js');
-                const _ns_17 = _mod_17.b4;
+                const _mod_17 = await import('./Item-CXLcIHsi.js');
+                const _ns_17 = _mod_17.ba;
                 const { lookupPropertySchemaUid } = _ns_17;
                 return {
                     schemaUid: await lookupPropertySchemaUid(op.propertyName, value.propertyRecordSchema),
@@ -6251,23 +6255,52 @@ const ensureInitialized = () => {
 };
 const CLIENT_ALREADY_STOPPED_WARNING = 'client.stop() or client.unload() was called after the client had already stopped; this call does nothing. ' +
     'Remove the extra call, or call client.init() before stopping again.';
-/** Shared by stop() and unload(). A repeat call after a stop warns and does nothing. */
-const stopClient = ({ unsubscribe }) => {
+/** Set while a stop releases the client's resources; init waits for it. */
+let stopping;
+/**
+ * Shared by stop() and unload(). Stops the client in any state, including after a failed or
+ * unfinished init, then releases what it holds: the outbox drain, cached entities, this tab's
+ * leadership and the database (closed, so its file is released). A repeat call after a stop warns
+ * and does nothing.
+ */
+const stopClient = async ({ unsubscribe }) => {
     if (clientManager.getSnapshot().status === 'stopped') {
         console.warn(CLIENT_ALREADY_STOPPED_WARNING);
         return;
     }
-    ensureInitialized();
     activeInitConfig = undefined;
     cancelAllRetriesWhenOnline();
     unregisterSeedQueryLocalSource();
     resetAddressesPersistedAnnouncement();
+    // The next init sets its own period. Instances waiting out this one are evicted with the rest
+    // (releaseClientResources), which cancels their timers.
+    setEntityUnloadGraceMs(undefined);
     clientManager.stop();
     if (unsubscribe)
         subscription.unsubscribe();
     notifyServiceListeners();
+    const releasing = releaseClientResources();
+    stopping = releasing;
+    try {
+        await releasing;
+    }
+    finally {
+        if (stopping === releasing)
+            stopping = undefined;
+    }
+};
+const releaseClientResources = async () => {
+    await stopOutbox();
+    await whenCanonicalizeModelTypesSettled();
+    // Before the database closes, so their live queries end first.
+    evictAllEntities();
+    stopTabCoordination();
+    await BaseDb.close();
 };
 const coalescedInit = createCoalescedAsync(async (options) => {
+    // A stop still closing the database: open it again only once that's done.
+    if (stopping)
+        await stopping;
     // If the actor is stopped (e.g., from a previous failed test), restart it
     const snapshot = clientManager.getSnapshot();
     const currentState = snapshot.value;
@@ -6302,6 +6335,7 @@ const coalescedInit = createCoalescedAsync(async (options) => {
             }
         });
     }
+    setEntityUnloadGraceMs(options?.config?.entityCache?.unloadGraceMs);
     // The root-level init handler moves to PLATFORM_CLASSES_INIT (stopping any running step) as
     // send() returns; the platformClassesInit step fills the context from options.
     clientManager.send({ type: 'init', options });
@@ -6487,7 +6521,12 @@ const clientInstance = {
         });
         return () => subscription.unsubscribe();
     },
+    /**
+     * Stops the client, from any state (a failed init too), and closes the database. Resolves once
+     * everything is released; `init` may be called right away and waits for that.
+     */
     stop: () => stopClient({ unsubscribe: false }),
+    /** As `stop`, and also ends the client's internal state subscription. */
     unload: () => stopClient({ unsubscribe: true }),
 };
 // Export the singleton instance
@@ -6547,4 +6586,4 @@ var errors = /*#__PURE__*/Object.freeze({
 });
 
 export { sendEasSyncClientRequest as $, waitForEasReadChain as A, assertLocalDbChain as B, ConflictError as C, writeModelUids as D, getContentHash as E, saveDefinition as F, EAS_CHAIN_ID_APP_STATE_KEY as G, INIT_CONFIG_CONFLICT_MESSAGE as H, ItemCreateValidationError as I, ItemCreateError as J, claimUnpublishedDrafts as K, createLocalQueryDataSource as L, Model as M, easSyncActor as N, getClient as O, getPublishedSeedRecord as P, getSchemaNameFromId as Q, RelationTargetError as R, SCHEMA_FILE_FORMAT as S, TModelSchema as T, UnknownModelError as U, isSeedQueryLocalSourceRegistered as V, listCompleteSchemaFiles as W, mergeEasSyncRequestIntents as X, registerSeedQueryLocalSource as Y, requestEasSyncFromAddressChange as Z, requestEasSyncFromModelsInit as _, applyCreateItem as a, setRetriesWhenOnlineEnabled as a0, startEasSyncActor as a1, unregisterSeedQueryLocalSource as a2, saveDefinition$1 as a3, Model$1 as a4, schema as a5, SEEDPROTOCOL_Seed_Protocol_v1 as a6, itemAppliers as a7, errors as a8, applyDelete as b, applyItemStorageValue as c, deleteFiles as d, applyStorageValue as e, TModelValues as f, ClientManager as g, syncSchemaFromSource as h, importJsonSchema as i, transformImportToSchemaFile as j, localModelSchemaLookups as k, loadSchemaFromFile as l, listLatestSchemaFiles as m, readSchemaFile as n, applySchemaFile as o, resolveSchemaRow as p, loadAllSchemasFromDb as q, readJsonImportFile as r, startItemOutbox as s, throwItemWriteError as t, getDraftSaveError as u, queueDraftSave as v, writeNextSchemaVersion as w, setupEntityLiveQuery as x, mergeSchemaFiles as y, trackDraftSave as z };
-//# sourceMappingURL=errors-DLSoqSHG.js.map
+//# sourceMappingURL=errors-DpC9W4i3.js.map