@seedprotocol/sdk 0.7.0 → 0.7.1

package/dist/cjs/{index-C66AfYDG.js → index-Cvvt0-5B.js}

@@ -377,9 +377,14 @@ let revokeExecutor = null;
 function getRevokeExecutor() {
     return revokeExecutor;
 }
+let getAdditionalSyncAddresses = null;
+function getGetAdditionalSyncAddresses() {
+    return getAdditionalSyncAddresses;
+}
 
 var publishConfig = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getGetAdditionalSyncAddresses: getGetAdditionalSyncAddresses,
     getPublisherForNewSeedsWithTimeout: getPublisherForNewSeedsWithTimeout,
     getRevokeExecutor: getRevokeExecutor,
     getUploadExecutor: getUploadExecutor
@@ -4421,6 +4426,22 @@ const convertTxIdToImage = async (txId) => {
     return URL.createObjectURL(imageBlob);
 };
 
+/**
+ * Common getters and utilities for entity classes
+ * These work with any entity that has a getService() method returning an XState actor
+ */
+/**
+ * Get the current state value from an entity's service
+ */
+/**
+ * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
+ * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
+ * events and XState warns about every one of them.
+ */
+function isActorStopped(actor) {
+    return actor.getSnapshot().status === 'stopped';
+}
+
 const logger$w = debug('seedSdk:model:actors:loadOrCreateModel');
 /**
  * Create ModelProperty instances for all property IDs to ensure they're cached
@@ -4432,7 +4453,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dv7AQfmQ.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$w('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -4463,7 +4484,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         // Don't throw - this is best-effort to pre-populate cache
     }
 };
-const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } }) => {
+const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, self }) => {
     const _loadOrCreateModel = async () => {
         const { modelName, schemaName, id, _idFromSchema } = context; // id is now the schemaFileId (string)
         if (!modelName || !schemaName) {
@@ -4602,7 +4623,9 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
                         .map((record) => record.schemaFileId)
                         .filter((id) => id !== null && id !== undefined);
                     if (propertyFileIds.length > 0) {
-                        await createPropertyInstances(propertyFileIds);
+                        // Not for a model stopped meanwhile (unloaded, or evicted with its schema)
+                        if (!isActorStopped(self))
+                            await createPropertyInstances(propertyFileIds);
                     }
                     // Generate schemaFileId if not set
                     if (!schemaFileId) {
@@ -4643,8 +4666,11 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         // 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 schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BHVp1g-M.js'); });
             const { Schema } = schemaMod;
+            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
+            if (isActorStopped(self))
+                return;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
             // Wait for schema to load if it's still loading
@@ -4885,10 +4911,12 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BHVp1g-M.js'); });
             const { Schema } = schemaMod;
-            const schema = Schema.create(schemaName, { waitForReady: false });
-            schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
+            if (!isActorStopped(self)) {
+                const schema = Schema.create(schemaName, { waitForReady: false });
+                schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
+            }
         }
         catch (err) {
             logger$w(`Failed to mark schema as draft after creating model: ${err}`);
@@ -4909,7 +4937,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
 const logger$v = debug('seedSdk:model:actors:validateModel');
 // Validation timeout in milliseconds (10 seconds)
 const VALIDATION_TIMEOUT_MS = 10000;
-const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) => {
+const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self }) => {
     let hasResponded = false;
     // Timeout handler to ensure we always respond
     const timeoutId = setTimeout(() => {
@@ -4929,10 +4957,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-BHVp1g-M.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -4947,6 +4975,9 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
             // If we have schema name, validate against schema
             // CRITICAL: Use validateModelAgainstSchema which doesn't require the model to be in schema context
             // This allows validation BEFORE registration, preventing update loops
+            // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
+            if (isActorStopped(self))
+                return;
             if (context.schemaName) {
                 try {
                     const schema = Schema.create(context.schemaName, {
@@ -5029,7 +5060,11 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
 });
 
 const logger$u = debug('seedSdk:model:actors:createModelProperties');
-const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
+const createModelProperties = xstate.fromCallback(({ sendBack, input, self }) => {
+    // The model was stopped (unloaded, or evicted with its schema by Schema.destroy / test cleanup) while
+    // this ran: stopping it stops this actor too, but can't cancel the awaits below. A stopped model
+    // creates no properties (they'd be cached for a model that's gone, and write rows under it).
+    const stopped = () => isActorStopped(self);
     const _createProperties = async () => {
         const { context, propertyDefinitions } = input;
         const { id, _dbId, modelName, schemaName } = context;
@@ -5042,7 +5077,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$u(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dv7AQfmQ.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$u('ModelProperty not available from dynamic import');
@@ -5096,6 +5131,10 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
                     // Continue without refModelId - it will be resolved later in _initializeOriginalValues
                 }
             }
+            if (stopped()) {
+                logger$u(`Model "${modelName}" was stopped while creating its properties; not creating the rest`);
+                return;
+            }
             // Create ModelProperty instance
             // This will load from DB if it exists, or create new instance
             // The property should already be in DB from writeModelToDb
@@ -5134,6 +5173,37 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
     };
 });
 
+/**
+ * Eviction epochs: lets work that was started before a schema's Model/ModelProperty instances were
+ * evicted (Schema.destroy, test cleanup) tell, when it finishes, that it must not put instances for
+ * that schema back in the caches. Stopping the evicted actors can't cancel such work (a DB lookup
+ * that ends in Model.create, a model's property creation), and finishing it after the eviction would
+ * rebuild instances from rows that are about to be deleted, which then write themselves again.
+ *
+ * Capture `currentEvictionEpoch()` when the work starts; before creating or caching an instance, skip
+ * it when `schemaEvictedSince(schemaName, epoch)`. Work started after an eviction is unaffected.
+ */
+let epoch = 0;
+const lastEvictionBySchema = new Map();
+function currentEvictionEpoch() {
+    return epoch;
+}
+/** Called by Model.evictForSchema. */
+function recordSchemaEviction(schemaName) {
+    epoch += 1;
+    lastEvictionBySchema.set(schemaName, epoch);
+}
+/** True when the schema's instances were evicted after `since` (an epoch from currentEvictionEpoch). */
+function schemaEvictedSince(schemaName, since) {
+    if (epoch === since || !schemaName)
+        return false;
+    return (lastEvictionBySchema.get(schemaName) ?? 0) > since;
+}
+/** True when any schema was evicted after `since` (cheap check before looking up which schemas apply). */
+function anyEvictionSince(since) {
+    return epoch !== since;
+}
+
 const logger$t = debug('seedSdk:write:validateEntity');
 // XState v5 type inference bug: fromPromise types are inverted
 // We use type assertion to work around this
@@ -5141,6 +5211,18 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     // Type assertion to fix XState v5 type inference bug
     // Convert through unknown to avoid type overlap error
     const entityInput = input;
+    // Validation awaits imports before looking up the schema; the entity can be evicted with its
+    // schema meanwhile (Schema.destroy, test cleanup). Schema.create would then load the evicted
+    // schema again, and its load re-creates the schema's models from rows being deleted.
+    const evictionEpoch = currentEvictionEpoch();
+    /** The schema to validate against; throws (validation then skips the schema check) once it was evicted. */
+    const schemaForValidation = async (schemaName) => {
+        const { Schema } = await Promise.resolve().then(function () { return require('./Schema-BHVp1g-M.js'); });
+        if (schemaEvictedSince(schemaName, evictionEpoch)) {
+            throw new Error(`Schema "${schemaName}" was evicted during validation`);
+        }
+        return Schema.create(schemaName, { waitForReady: false });
+    };
     const _validate = async () => {
         try {
             const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`;
@@ -5151,7 +5233,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 const structureMsg = `[validateEntity] Validating model structure`;
                 logger$t(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -5169,11 +5251,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$t(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
-                            const { Schema } = schemaMod;
-                            const schema = Schema.create(entityInput.entityData.schemaName, {
-                                waitForReady: false,
-                            });
+                            const schema = await schemaForValidation(entityInput.entityData.schemaName);
                             const schemaSnapshot = schema.getService().getSnapshot();
                             const schemaStatus = schemaSnapshot.value;
                             logger$t(`[validateEntity] Schema status: ${schemaStatus}`);
@@ -5205,7 +5283,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -5220,11 +5298,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
-                            const { Schema } = schemaMod;
-                            const schema = Schema.create(entityInput.entityData._schemaName, {
-                                waitForReady: false,
-                            });
+                            const schema = await schemaForValidation(entityInput.entityData._schemaName);
                             const schemaSnapshot = schema.getService().getSnapshot();
                             const schemaStatus = schemaSnapshot.value;
                             if (schemaStatus === 'idle') {
@@ -5249,7 +5323,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -5338,7 +5412,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-Dv7AQfmQ.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -5721,16 +5795,23 @@ const modelMachine = xstate.setup({
                     ({ context, event, self }) => {
                         if (event._liveQueryPropertyIds !== undefined) {
                             const newPropertyIds = event._liveQueryPropertyIds;
+                            // The model can be evicted with its schema (Schema.destroy, test cleanup) before the
+                            // timer and import below run: then create nothing, and drop lookups an eviction overtakes.
+                            const evictionEpoch = currentEvictionEpoch();
                             // Use setTimeout to check after assign has been applied
                             setTimeout(() => {
-                                self.getSnapshot();
+                                const snapshot = self.getSnapshot();
+                                if (snapshot.status === 'stopped')
+                                    return;
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-Dv7AQfmQ.js'); }).then(({ ModelProperty }) => {
+                                        if (self.getSnapshot().status === 'stopped')
+                                            return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
-                                                const property = await ModelProperty.createById(propertyFileId);
+                                                const property = await ModelProperty.createById(propertyFileId, { evictionEpoch });
                                                 if (property) {
                                                     logger$q(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
                                                 }
@@ -6455,7 +6536,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             const schemaNameToTry = schemaName ?? model$1?.schemaName;
             if (schemaNameToTry) {
                 try {
-                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-BHVp1g-M.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
@@ -6508,7 +6589,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -6525,7 +6606,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             }
         }
         // Fallbacks above may return schema-file shape ({ type, model, items }); normalize to dataType/ref/refValueType.
-        const { normalizePropertyRecordSchema } = await Promise.resolve().then(function () { return require('./property-BVJIP7SX.js'); });
+        const { normalizePropertyRecordSchema } = await Promise.resolve().then(function () { return require('./property-DbEPQ1m9.js'); });
         propertySchemas = Object.fromEntries(Object.entries(propertySchemas).map(([name, def]) => [name, normalizePropertyRecordSchema(def)]));
         // Collapse rows that map to the same instance key (e.g. authorIdentityIds + authors -> authors).
         // ItemProperty.create cache does not sync propertyValue on hit; processing order would otherwise
@@ -6558,7 +6639,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 // Infer propertyRecordSchema from metadata when schema is missing (enables persistence)
                 let propSchema = propertySchemas[propertyName];
                 if (!propSchema && isRefTypeFromMeta) {
-                    const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6825,14 +6906,23 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-B5Lq6q-_.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-Ctn5k1k6.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-D5-dYtNq.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CEP_e-Kv.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
             const executor = getUploadExecutor();
-            if (executor && uploads.length > 0) ;
+            if (executor && uploads.length > 0) {
+                for (const upload of uploads) {
+                    const { txId } = await executor(upload);
+                    uploadedTransactions.push({
+                        txId,
+                        seedLocalId: upload.seedLocalId,
+                        versionLocalId: upload.versionLocalId,
+                    });
+                }
+            }
             await getPublishPayload(item, uploadedTransactions);
             logger$o('runPublish: payload prepared (upload/EAS submit stubbed)');
             sendBack({ type: 'publishSuccess' });
@@ -7770,7 +7860,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -8264,7 +8354,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -8641,7 +8731,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         };
                         // Merge with schema from file/DB to get validation rules (enum, pattern, etc.) - properties table doesn't store these
                         try {
-                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-BVJIP7SX.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-DbEPQ1m9.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName, {
                                 modelFileId: modelRecord?.schemaFileId ?? modelFileId,
                             });
@@ -9062,9 +9152,9 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -9554,7 +9644,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CWEnZmOH.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-BSU9knjf.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -10136,7 +10226,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -11102,7 +11192,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-B3UDbm1C.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-DfGhF1dc.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -11763,6 +11853,29 @@ class ItemProperty {
             return result;
         return waitForEntityIdle(result, { timeout: readyTimeout }).then(() => result);
     }
+    /**
+     * The cached ItemProperty when it can be read right now (idle, not saving), the state
+     * `ItemProperty.find()` waits for. Otherwise undefined. Unlike `find`, it takes no cache hold, so
+     * React hooks can call it during render.
+     */
+    static peekReady({ propertyName, seedLocalId, seedUid, }) {
+        if (!propertyName)
+            return undefined;
+        // Same key order as find(), then the other id: instances are cached under both when both are known.
+        const keys = [seedUid, seedLocalId]
+            .filter((id) => typeof id === 'string' && id.length > 0)
+            .map((id) => this.cacheKey(id, propertyName));
+        for (const key of keys) {
+            const instance = this.instanceCache.get(key)?.instance;
+            if (!instance)
+                continue;
+            const snap = instance.getService().getSnapshot();
+            if (snap.status !== 'active' || snap.value !== 'idle' || snap.context?.isSaving)
+                return undefined;
+            return instance;
+        }
+        return undefined;
+    }
     static async find({ propertyName, seedLocalId, seedUid, modelName: modelNameOption, waitForReady = true, readyTimeout = 5000, }) {
         if ((!seedLocalId && !seedUid) || !propertyName) {
             return undefined;
@@ -12478,7 +12591,7 @@ class Item {
             const revokedAt = Math.floor(Date.now() / 1000);
             // The executor stamps the revoked version rows; the latest version is now the newest one left
             // (a local draft) or none, never a revoked one.
-            const { getLatestVersionRow } = await Promise.resolve().then(function () { return require('./getLatestVersionRow-DVizNNoI.js'); });
+            const { getLatestVersionRow } = await Promise.resolve().then(function () { return require('./getLatestVersionRow-CcaabxIW.js'); });
             const head = await getLatestVersionRow(this.seedLocalId);
             this._service.send({
                 type: 'updateContext',
@@ -12524,12 +12637,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-B5Lq6q-_.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-Ctn5k1k6.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this, [], undefined, options);
         };
         this.getPublishPayload = async (uploadedTransactions, options) => {
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-D5-dYtNq.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CEP_e-Kv.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -12546,7 +12659,7 @@ class Item {
                 });
                 // Publish has recorded the version it attested (updateVersionUid): reflect it here too, as
                 // the versions liveQuery does in the browser. After a republish this is the new version.
-                const { getLatestVersionRow } = await Promise.resolve().then(function () { return require('./getLatestVersionRow-DVizNNoI.js'); });
+                const { getLatestVersionRow } = await Promise.resolve().then(function () { return require('./getLatestVersionRow-CcaabxIW.js'); });
                 const head = await getLatestVersionRow(seedLocalId);
                 if (head?.localId) {
                     this._service.send({
@@ -12802,6 +12915,38 @@ class Item {
             }
         }
     }
+    /**
+     * Idle, and not the shell the item machine can be in when it reaches `idle` before
+     * `propertyInstances` is merged (an item with a version but no property instances yet).
+     */
+    static isItemSnapshotReadyForRead(snap) {
+        if (!snap || !('value' in snap) || snap.value !== 'idle') {
+            return false;
+        }
+        const ctx = snap.context || {};
+        const versionsCount = ctx.versionsCount ?? 0;
+        const hasHeadVersion = !!ctx.latestVersionLocalId;
+        if (versionsCount === 0 && !hasHeadVersion) {
+            return true;
+        }
+        return (ctx.propertyInstances?.size ?? 0) > 0;
+    }
+    /**
+     * The cached Item for a seedLocalId or seedUid when it can be read right now: idle and hydrated,
+     * so at least what `Item.find()` would wait for. Otherwise undefined. Unlike `getById`, it takes
+     * no cache hold, so React hooks can call it during render.
+     */
+    static peekReady(id) {
+        if (!id)
+            return undefined;
+        const instance = this.findItemInstanceCacheEntryById(id)?.instance;
+        if (!instance)
+            return undefined;
+        const snap = instance.getService().getSnapshot();
+        if (snap.status !== 'active')
+            return undefined;
+        return this.isItemSnapshotReadyForRead(snap) ? instance : undefined;
+    }
     /**
      * Item machine can reach `idle` before `propertyInstances` is merged (race) or while
      * child ItemProperty actors are still hydrating. useItems / Item.all must not return that shell.
@@ -12814,16 +12959,7 @@ class Item {
                 if ('value' in snap && snap.value === 'error') {
                     throw new Error('Entity failed to load');
                 }
-                if (!('value' in snap) || snap.value !== 'idle') {
-                    return false;
-                }
-                const ctx = snap.context || {};
-                const versionsCount = ctx.versionsCount ?? 0;
-                const hasHeadVersion = !!ctx.latestVersionLocalId;
-                if (versionsCount === 0 && !hasHeadVersion) {
-                    return true;
-                }
-                return (ctx.propertyInstances?.size ?? 0) > 0;
+                return Item.isItemSnapshotReadyForRead(snap);
             }, { timeout: readyTimeout });
         }
         catch (e) {
@@ -14313,7 +14449,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-Dk96sAG-.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-d1iOdTTI.js'); });
     try {
         // 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.
@@ -18976,22 +19112,6 @@ var ClientManager$1 = /*#__PURE__*/Object.freeze({
     getClient: getClient
 });
 
-/**
- * Common getters and utilities for entity classes
- * These work with any entity that has a getService() method returning an XState actor
- */
-/**
- * Get the current state value from an entity's service
- */
-/**
- * Whether an actor has been stopped (unload, destroy, or Schema eviction). Async work started by an
- * entity (DB lookups, retry timers) must check this before sending, since a stopped actor ignores
- * events and XState warns about every one of them.
- */
-function isActorStopped(actor) {
-    return actor.getSnapshot().status === 'stopped';
-}
-
 /**
  * Set up liveQuery subscription for an entity
  * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
@@ -19017,7 +19137,10 @@ function setupEntityLiveQuery(instance, config) {
                 const initialIds = config.extractEntityIds(initialRows);
                 if (initialIds.length > 0) {
                     logger(`Initial query returned ${initialIds.length} entities`);
-                    // Create child instances if provided
+                    // Create child instances if provided (not for a stopped entity: an unloaded or evicted
+                    // parent must not re-cache its children)
+                    if (isActorStopped(instance.getService()))
+                        return;
                     if (config.createChildInstances) {
                         await config.createChildInstances(initialIds);
                     }
@@ -19048,7 +19171,9 @@ function setupEntityLiveQuery(instance, config) {
                         }
                         logger(`Query returned ${rows.length} rows`);
                         const ids = config.extractEntityIds(rows);
-                        // Create child instances if provided (before updating context)
+                        // Create child instances if provided (before updating context; not for a stopped entity)
+                        if (isActorStopped(instance.getService()))
+                            return;
                         if (config.createChildInstances && ids.length > 0) {
                             await config.createChildInstances(ids);
                         }
@@ -19189,7 +19314,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 = Promise.resolve().then(function () { return require('./ModelProperty-BEsIHAjk.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-Dv7AQfmQ.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -19205,7 +19330,7 @@ function getModelProperty() {
     return ModelPropertyClass;
 }
 // Lazy import for Schema to avoid circular dependency
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-qEp5mH1N.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-BHVp1g-M.js'); })
     .then(module => module.Schema)
     .catch(() => null);
 // WeakMap to store mutable state per Model instance
@@ -19703,6 +19828,9 @@ class Model {
                             resolve();
                         }, 10000);
                     });
+                    // Unloaded or evicted (e.g. Schema.destroy) while it loaded: a stopped model never writes
+                    if (isActorStopped(proxiedInstance._service))
+                        return;
                     // Only write if validation passed (model is in idle state, not error)
                     const finalSnapshot = proxiedInstance._service.getSnapshot();
                     if (finalSnapshot.value === 'idle' && (!finalSnapshot.context._validationErrors || finalSnapshot.context._validationErrors.length === 0)) {
@@ -19826,8 +19954,8 @@ class Model {
                                 }
                                 logger$2(`WARNING: Could not verify schema exists in database: ${error}. Proceeding anyway.`);
                             }
-                            // Track pending write
-                            Model.trackPendingWrite(finalSnapshot.context.id, schemaId); // id is now the schemaFileId (string)
+                            const pendingModelFileId = finalSnapshot.context.id;
+                            const pendingSchemaId = schemaId;
                             // Wait for writeProcess to be spawned (it's spawned in idle state entry action)
                             // Retry a few times if writeProcess isn't available yet
                             let retries = 0;
@@ -19838,6 +19966,8 @@ class Model {
                                     return;
                                 const currentSnapshot = proxiedInstance._service.getSnapshot();
                                 if (currentSnapshot.context.writeProcess) {
+                                    // Track pending write (only once it really starts: a stopped model leaves none behind)
+                                    Model.trackPendingWrite(pendingModelFileId, pendingSchemaId); // id is now the schemaFileId (string)
                                     logger$2(`Triggering write process for model "${finalSnapshot.context.modelName}" (schemaId: ${schemaId})`);
                                     // Use pending property definitions if available, otherwise convert from ModelProperty instances
                                     let propertiesObject = {};
@@ -20058,6 +20188,7 @@ class Model {
         if (scope.modelFileId || scope.schemaName) {
             const db = BaseDb.getAppDb();
             if (db) {
+                const evictionEpoch = currentEvictionEpoch();
                 try {
                     const rows = await db
                         .select({
@@ -20074,6 +20205,9 @@ class Model {
                         .limit(1);
                     const record = rows[0];
                     if (record?.modelName && record.schemaName && record.modelFileId) {
+                        // Its schema was evicted while we read the row: don't bring the model back.
+                        if (schemaEvictedSince(record.schemaName, evictionEpoch))
+                            return undefined;
                         return this.create(record.modelName, record.schemaName, { id: record.modelFileId });
                     }
                 }
@@ -20092,7 +20226,7 @@ class Model {
      * @param schemaName - Optional schema name (will query DB if not provided)
      * @returns The Model instance if found, undefined otherwise
      */
-    static async getByNameAsync(modelName, schemaName) {
+    static async getByNameAsync(modelName, schemaName, options) {
         // First try cache
         const cached = this.getByName(modelName, schemaName);
         if (cached) {
@@ -20104,6 +20238,7 @@ class Model {
             if (!db) {
                 return undefined;
             }
+            const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
             try {
                 // Query model by name (throws AmbiguousModelError when several schemas define it)
                 const { resolveModelRecord } = await Promise.resolve().then(function () { return resolveModelRecord$1; });
@@ -20129,6 +20264,10 @@ class Model {
                 if (!record.modelName || !record.schemaName || !record.modelFileId) {
                     return undefined;
                 }
+                // Its schema was evicted while we read the row: don't bring the model back.
+                if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
+                    return undefined;
+                }
                 // Create model instance (will be cached)
                 return this.create(record.modelName, record.schemaName, {
                     id: record.modelFileId, // id is now the schemaFileId (string)
@@ -20150,7 +20289,7 @@ class Model {
      * @param modelFileId - The model file ID to look up
      * @returns The Model instance if found, undefined otherwise
      */
-    static async createById(modelFileId) {
+    static async createById(modelFileId, options) {
         if (!modelFileId) {
             return undefined;
         }
@@ -20166,6 +20305,7 @@ class Model {
             logger$2(`Model.createById: Database not available for ID "${modelFileId}"`);
             return undefined;
         }
+        const evictionEpoch = options?.evictionEpoch ?? currentEvictionEpoch();
         try {
             // Query model by schemaFileId and join to get schema name
             const modelRecords = await db
@@ -20188,6 +20328,12 @@ class Model {
                 logger$2(`Model.createById: Missing modelName or schemaName for ID "${modelFileId}"`);
                 return undefined;
             }
+            // Its schema was evicted while we read the row (e.g. a Schema live query in flight during
+            // Schema.destroy or test cleanup): don't bring the model back.
+            if (schemaEvictedSince(schemaName, evictionEpoch)) {
+                logger$2(`Model.createById: schema "${schemaName}" was evicted during the lookup of "${modelFileId}"`);
+                return undefined;
+            }
             // Step 3: Create model using existing create method (which will handle caching)
             logger$2(`Model.createById: Creating model "${modelName}" in schema "${schemaName}" from ID "${modelFileId}"`);
             return this.create(modelName, schemaName, {
@@ -20242,6 +20388,7 @@ class Model {
             logger$2(`Model.createBySchemaId: Database not available for schema "${schemaIdentifier}"`);
             return [];
         }
+        const evictionEpoch = currentEvictionEpoch();
         try {
             // Query all models for this schema - support both schemaFileId and schema name
             const modelRecords = await db
@@ -20264,6 +20411,10 @@ class Model {
                 if (!record.modelName || !record.schemaName || !record.modelFileId) {
                     continue;
                 }
+                // Its schema was evicted while we read the rows: don't bring its models back.
+                if (schemaEvictedSince(record.schemaName, evictionEpoch)) {
+                    continue;
+                }
                 // Check cache first
                 const cached = this.getById(record.modelFileId);
                 if (cached) {
@@ -20710,6 +20861,8 @@ class Model {
      * @returns names of the evicted models (so callers can evict their ModelProperty instances)
      */
     static evictForSchema(schemaName) {
+        // Work already running for this schema's models must not re-cache them when it finishes.
+        recordSchemaEviction(schemaName);
         const instances = new Set();
         for (const { instance } of this.instanceCacheById.values())
             instances.add(instance);
@@ -21242,7 +21395,7 @@ function resolveSdkDrizzleMigrationsDir(sdkRootDir) {
         })();
     // Also resolve relative to this module so temp-cwd tests / odd roots still find
     // packages/sdk/src/db/drizzle (or dist/db/drizzle after publish).
-    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-C66AfYDG.js', document.baseURI).href))));
+    const moduleDir = path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-Cvvt0-5B.js', document.baseURI).href))));
     const candidates = [
         path.join(root, 'db', 'drizzle'), // production: sdkRoot is dist/
         path.join(root, 'dist', 'db', 'drizzle'), // sdk package root with built dist
@@ -21312,10 +21465,10 @@ class NodeDb {
         logger$1('[Db.prepareDb] running migrations from %s', outDir);
         await migrator.migrate(db, { migrationsFolder: outDir });
         this.db = db;
-        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-tw8JGMT0.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-WIovQ_d8.js'); });
         await backfillMetadataPropertyIds();
         // One-time: clear item data whose model can't be determined (seeds.model_file_id, migration 0015)
-        const { resetAmbiguousLegacyItemData } = await Promise.resolve().then(function () { return require('./resetAmbiguousLegacyItemData-BaZqUui9.js'); });
+        const { resetAmbiguousLegacyItemData } = await Promise.resolve().then(function () { return require('./resetAmbiguousLegacyItemData-CfMhRHwK.js'); });
         await resetAmbiguousLegacyItemData();
         return this.db;
     }
@@ -21842,6 +21995,7 @@ exports.VERSION_SCHEMA_UID = VERSION_SCHEMA_UID;
 exports.ZERO_BYTES32 = ZERO_BYTES32;
 exports.addModelsToDb = addModelsToDb$1;
 exports.addSchemaToDb = addSchemaToDb;
+exports.anyEvictionSince = anyEvictionSince;
 exports.appState = appState;
 exports.arweaveL1FinalizeJobs = arweaveL1FinalizeJobs;
 exports.assertLocalDbChain = assertLocalDbChain;
@@ -21851,6 +22005,7 @@ exports.commandExists = commandExists;
 exports.config = config;
 exports.createModelsFromJson = createModelsFromJson;
 exports.createReactiveProxy = createReactiveProxy;
+exports.currentEvictionEpoch = currentEvictionEpoch;
 exports.db = db;
 exports.defaultAttestationData = defaultAttestationData;
 exports.easSyncProcesses = easSyncProcesses;
@@ -21866,6 +22021,7 @@ exports.getClient = getClient;
 exports.getContentHash = getContentHash;
 exports.getCorrectId = getCorrectId;
 exports.getEasSchemaUidForModel = getEasSchemaUidForModel;
+exports.getGetAdditionalSyncAddresses = getGetAdditionalSyncAddresses;
 exports.getItemData = getItemData;
 exports.getItemModelScope = getItemModelScope;
 exports.getItemStoragePropertiesForModel = getItemStoragePropertiesForModel;
@@ -21918,6 +22074,7 @@ exports.saveModelsFromMarkdown = saveModelsFromMarkdown;
 exports.scheduleBulkFilesDownloadFromEasSync = scheduleBulkFilesDownloadFromEasSync;
 exports.schema = schema$1;
 exports.schema$1 = schema;
+exports.schemaEvictedSince = schemaEvictedSince;
 exports.schemas = schemas;
 exports.seeds = seeds;
 exports.selectInBatches = selectInBatches;
@@ -21935,4 +22092,4 @@ exports.withSeed = withSeed;
 exports.writeInBatches = writeInBatches;
 exports.writeProcessMachine = writeProcessMachine;
 exports.writeToDatabase = writeToDatabase$1;
-//# sourceMappingURL=index-C66AfYDG.js.map
+//# sourceMappingURL=index-Cvvt0-5B.js.map