@seedprotocol/sdk 0.7.3-next.613.g79a8dfd → 0.7.3-next.654.g52217f6

package/dist/cjs/{index-usKaANAq.js → index-C4XlgCJ4.js}

@@ -12,12 +12,13 @@ var pluralize = require('pluralize');
 var typebox = require('@sinclair/typebox');
 var casing = require('drizzle-orm/casing');
 var lodashEs = require('lodash-es');
+var sha256 = require('@noble/hashes/sha256');
+var sha3 = require('@noble/hashes/sha3');
+var utils = require('@noble/hashes/utils');
 var nanoid = require('nanoid');
 var nanoidDictionary = require('nanoid-dictionary');
 var query = require('@seedprotocol/query');
 var rxjs = require('rxjs');
-var sha3 = require('@noble/hashes/sha3');
-var utils = require('@noble/hashes/utils');
 var fsAsync = require('fs/promises');
 var fs = require('fs');
 var path = require('path');
@@ -210,20 +211,17 @@ class BaseFileManager {
     static getContentUrlFromPath(path) {
         return BaseFileManager.requireImpl().getContentUrlFromPath(path);
     }
-    static downloadAllFiles({ transactionIds, arweaveHost, arweaveBaseUrls, excludedTransactions, }) {
-        return BaseFileManager.requireImpl().downloadAllFiles({
-            transactionIds,
-            arweaveHost,
-            arweaveBaseUrls,
-            excludedTransactions,
-        });
+    static downloadAllFiles(params) {
+        return BaseFileManager.requireImpl().downloadAllFiles(params);
     }
-    static downloadFileByTransactionId({ transactionId, arweaveHost, arweaveBaseUrls, excludedTransactions, }) {
+    static downloadFileByTransactionId({ transactionId, arweaveHost, arweaveBaseUrls, excludedTransactions, expectedContentHash, compositeChildPaths, }) {
         return BaseFileManager.requireImpl().downloadAllFiles({
             transactionIds: [transactionId],
             arweaveHost,
             arweaveBaseUrls,
             excludedTransactions,
+            expectedContentHashes: expectedContentHash ? { [transactionId]: expectedContentHash } : undefined,
+            compositeChildPaths: compositeChildPaths ? { [transactionId]: compositeChildPaths } : undefined,
         });
     }
     static resizeImage({ filePath, width, height }) {
@@ -1508,7 +1506,7 @@ function linkModelToSchema(db, modelId, schemaId) {
     return current;
 }
 
-const logger$A = debug('seedSdk:helpers:db');
+const logger$B = debug('seedSdk:helpers:db');
 /**
  * The `properties` storage columns for a property definition, in either the internal shape
  * (`storageType`, `localStorageDir`, `filenameSuffix`) or the schema-file shape
@@ -1614,7 +1612,7 @@ async function getItemStoragePropertiesForModel(modelNameOrType, scope = {}) {
 async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newPropertyName, propertySchemaFileId, scope = {}) {
     const db = BaseDb.getAppDb();
     if (!db) {
-        logger$A('[migrateMetadataForPropertyRename] Database not available, skipping');
+        logger$B('[migrateMetadataForPropertyRename] Database not available, skipping');
         return 0;
     }
     // Find the property row by schemaFileId (preferred) or by name
@@ -1626,7 +1624,7 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
         propertyId = await getPropertyIdForModelAndName(modelName, oldPropertyName, scope);
     }
     if (propertyId == null) {
-        logger$A(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
+        logger$B(`[migrateMetadataForPropertyRename] Property not found: ${modelName}.${oldPropertyName}, skipping`);
         return 0;
     }
     // Primary path: update metadata by propertyId
@@ -1655,11 +1653,11 @@ async function migrateMetadataForPropertyRename(modelName, oldPropertyName, newP
             .where(drizzleOrm.and(drizzleOrm.eq(metadata$1.propertyName, oldPropertyName), drizzleOrm.eq(metadata$1.modelType, modelType), drizzleOrm.isNull(metadata$1.propertyId)));
     }
     if (updatedByFallback > 0) {
-        logger$A(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
+        logger$B(`[migrateMetadataForPropertyRename] Fallback updated ${updatedByFallback} rows (propertyId was null)`);
     }
     const total = updatedByPropertyId + updatedByFallback;
     if (total > 0) {
-        logger$A(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
+        logger$B(`[migrateMetadataForPropertyRename] Migrated ${total} metadata rows for ${modelName}.${oldPropertyName} -> ${newPropertyName}`);
     }
     return total;
 }
@@ -1808,7 +1806,7 @@ const findOrCreateModelRecord = async (db, modelName, modelFileId, schemaId) =>
                 .set({ schemaFileId: modelFileId, isEdited: false })
                 .where(drizzleOrm.eq(models$1.id, chosen.id));
             chosen = { ...chosen, schemaFileId: modelFileId, isEdited: false };
-            logger$A(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
+            logger$B(`Adopted existing model "${modelName}" (id: ${chosen.id}) with schemaFileId "${modelFileId}"`);
         }
         if (chosen) {
             return chosen;
@@ -2079,7 +2077,7 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
             .limit(1);
         if (draftSchemas.length > 0) {
             // Found a draft - we'll update it to non-draft below
-            logger$A(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
+            logger$B(`Found draft schema "${schema.name}" with schemaFileId "${draftSchemas[0].schemaFileId}", will update to non-draft with schemaFileId "${schemaFileId}"`);
             existingSchemas = draftSchemas;
         }
     }
@@ -2099,11 +2097,11 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
                 !existingSchemas[0].schemaFileId ||
                 (isDraft === false && existingSchemas[0].isDraft === true);
             if (shouldUpdate) {
-                logger$A(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
+                logger$B(`Updating schemaFileId from "${existingSchemas[0].schemaFileId}" to "${schemaFileId}" for schema "${schema.name}"`);
                 updates.schemaFileId = schemaFileId;
             }
             else {
-                logger$A(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
+                logger$B(`Preserving existing schemaFileId "${existingSchemas[0].schemaFileId}" for non-draft schema "${schema.name}" (new schemaFileId "${schemaFileId}" would overwrite it)`);
             }
         }
         // Always update name if it's different (handles name changes)
@@ -2130,16 +2128,16 @@ const addSchemaToDb = async (schema, schemaFileId, schemaData, isDraft, isEdited
             updates.updatedAt = schema.updatedAt;
         }
         if (Object.keys(updates).length > 0) {
-            logger$A(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
+            logger$B(`Applying updates to schema "${schema.name}" (id: ${existingSchemas[0].id}):`, Object.keys(updates));
             await db
                 .update(schemas)
                 .set(updates)
                 .where(drizzleOrm.eq(schemas.id, existingSchemas[0].id));
             const updated = { ...existingSchemas[0], ...updates };
-            logger$A(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
+            logger$B(`Schema "${schema.name}" updated. New schemaFileId: "${updated.schemaFileId}", isDraft: ${updated.isDraft}`);
             return updated;
         }
-        logger$A(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
+        logger$B(`No updates needed for schema "${schema.name}" (id: ${existingSchemas[0].id})`);
         return existingSchemas[0];
     }
     const newSchema = await db.insert(schemas).values({
@@ -2322,7 +2320,7 @@ modelId) {
                         // Compare database value with schema file value
                         // If they differ, the property has been edited
                         if (dbProperty.dataType !== schemaFileValue.dataType) {
-                            logger$A(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
+                            logger$B(`Property ${modelName}:${propertyName} has been edited (dataType differs: DB=${dbProperty.dataType}, Schema=${schemaFileValue.dataType})`);
                             return true;
                         }
                         // Check refModelId if it's a relation
@@ -2331,19 +2329,19 @@ modelId) {
                             if (refModelRecord) {
                                 const expectedRefModelId = refModelRecord.id;
                                 if (dbProperty.refModelId !== expectedRefModelId) {
-                                    logger$A(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                                    logger$B(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                                     return true;
                                 }
                             }
                         }
                         else if (dbProperty.refModelId !== null) {
                             // Schema file has no ref, but DB has one
-                            logger$A(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
+                            logger$B(`Property ${modelName}:${propertyName} has been edited (refModelId differs)`);
                             return true;
                         }
                         // Check refValueType
                         if (dbProperty.refValueType !== (schemaFileValue.refValueType || null)) {
-                            logger$A(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
+                            logger$B(`Property ${modelName}:${propertyName} has been edited (refValueType differs)`);
                             return true;
                         }
                         // Check required (for Relation/Image properties)
@@ -2351,7 +2349,7 @@ modelId) {
                             const schemaRequired = !!schemaFileValue.required;
                             const dbRequired = dbProperty.required === true;
                             if (dbRequired !== schemaRequired) {
-                                logger$A(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
+                                logger$B(`Property ${modelName}:${propertyName} has been edited (required differs: DB=${dbRequired}, Schema=${schemaRequired})`);
                                 return true;
                             }
                         }
@@ -2367,7 +2365,7 @@ modelId) {
                             if (dbStorage.storageType !== fileStorage.storageType ||
                                 dbStorage.localStorageDir !== fileStorage.localStorageDir ||
                                 dbStorage.filenameSuffix !== fileStorage.filenameSuffix) {
-                                logger$A(`Property ${modelName}:${propertyName} has been edited (storage settings differ)`);
+                                logger$B(`Property ${modelName}:${propertyName} has been edited (storage settings differ)`);
                                 return true;
                             }
                         }
@@ -2379,7 +2377,7 @@ modelId) {
     }
     catch (error) {
         // If we can't check, assume it's not edited to be safe
-        logger$A('Error checking if property is edited:', error);
+        logger$B('Error checking if property is edited:', error);
         return false;
     }
 }
@@ -2404,11 +2402,11 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
         // SchemaType includes id, so check if it's set
         if (schema.id !== null && schema.id !== undefined) {
             schemaRecord = schema;
-            logger$A(`Using existing schema record with id: ${schemaRecord.id}`);
+            logger$B(`Using existing schema record with id: ${schemaRecord.id}`);
         }
         else {
             schemaRecord = await addSchemaToDb(schema, schemaFileData?.schemaFileId);
-            logger$A(`Created/found schema record with id: ${schemaRecord.id}`);
+            logger$B(`Created/found schema record with id: ${schemaRecord.id}`);
         }
     }
     // Handle model renames first if provided
@@ -2434,7 +2432,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                     .where(drizzleOrm.eq(models$1.schemaFileId, modelFileId))
                     .limit(1);
                 if (existingWithFileId.length > 0 && existingWithFileId[0].id !== modelRecord.id) {
-                    logger$A(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
+                    logger$B(`WARNING: Model "${modelName}" (id: ${modelRecord.id}) conflicts with existing model "${existingWithFileId[0].name}" (id: ${existingWithFileId[0].id}) both trying to use schemaFileId "${modelFileId}"`);
                     modelRecord = existingWithFileId[0];
                 }
                 else if (!modelRecord.schemaFileId) {
@@ -2492,7 +2490,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 if (!propertyFileId) {
                     const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
                     propertyFileId = generateId();
-                    logger$A(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
+                    logger$B(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
                 }
                 // First, try to find by schemaFileId (preferred for change tracking)
                 let existingProperty;
@@ -2559,7 +2557,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                     if (potentialMatches.length > 0) {
                         const matchedProperty = potentialMatches[0];
                         existingProperty = matchedProperty;
-                        logger$A(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
+                        logger$B(`Found renamed property: ${modelName}:${matchedProperty.name} -> ${propertyName} (matched by characteristics)`);
                     }
                 }
                 if (existingProperty) {
@@ -2580,7 +2578,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                         }, modelRecord.id);
                     if (isPropertyEdited) {
                         // Property has been locally edited - skip update to preserve local changes
-                        logger$A(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
+                        logger$B(`Skipping update for property ${modelName}:${existingProperty.name} -> ${propertyName} - it has been locally edited and will be preserved`);
                         continue;
                     }
                     // Property exists (possibly with different name) - update it with new values from schema file
@@ -2631,18 +2629,18 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                         if (existingByFileId.length > 0) {
                             const found = existingByFileId[0];
                             matchedDbPropertyIds.add(found.id);
-                            logger$A(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
+                            logger$B(`Property ${modelName}:${propertyName} already exists by schemaFileId "${propertyFileId}" (id: ${found.id}), skipping insert`);
                             continue;
                         }
                     }
-                    logger$A(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
+                    logger$B(`Creating new property ${modelName}:${propertyName} with schemaFileId: ${propertyData.schemaFileId}`);
                     try {
                         await db.insert(properties).values(propertyDataWithIsEdited);
                     }
                     catch (insertError) {
                         // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb call)
                         if (isSqliteUniqueConstraintError(insertError)) {
-                            logger$A(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
+                            logger$B(`Property ${modelName}:${propertyName} already exists (UNIQUE constraint), treating as success`);
                         }
                         else {
                             throw insertError;
@@ -2653,14 +2651,14 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
         }
         catch (error) {
             const errorMessage = error?.message || String(error);
-            logger$A(`Error processing model "${modelName}": ${errorMessage}`);
+            logger$B(`Error processing model "${modelName}": ${errorMessage}`);
             modelProcessingErrors.push({ modelName, error: errorMessage });
             // Continue processing other models even if one fails
         }
     }
     if (modelProcessingErrors.length > 0) {
         console.warn(`[addModelsToDb] Errors occurred while processing ${modelProcessingErrors.length} model(s):`, modelProcessingErrors.map(e => `${e.modelName}: ${e.error}`).join('; '));
-        logger$A(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).join(', ')}`);
+        logger$B(`Errors processing models: ${modelProcessingErrors.map(e => e.modelName).join(', ')}`);
     }
     // If schema was provided, create modelSchema join records to connect models to the schema
     if (schemaRecord && schemaRecord.id) {
@@ -2668,7 +2666,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
             .filter(([, r]) => r.id)
             .map(([name, r]) => ({ modelName: name, modelId: r.id }));
         if (modelIds.length === 0) {
-            logger$A('No model IDs to link, skipping schema linking');
+            logger$B('No model IDs to link, skipping schema linking');
         }
         else {
             // Single batch query: get all existing joins for this schema
@@ -2682,13 +2680,13 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 for (const { modelName, modelId } of toInsert) {
                     if (!(await linkModelToSchema(db, modelId, schemaRecord.id)))
                         continue;
-                    logger$A(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
+                    logger$B(`Created join table entry for model ${modelName} (id: ${modelId}) to schema (id: ${schemaRecord.id})`);
                 }
             }
         }
     }
     else if (schemaRecord && !schemaRecord.id) {
-        logger$A(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
+        logger$B(`Warning: schemaRecord provided but has no id, cannot create join table entries`);
     }
 };
 /**
@@ -2701,7 +2699,7 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
 const loadModelsFromDbForSchema = async (schemaId) => {
     const db = BaseDb.getAppDb();
     if (!db) {
-        logger$A('Database not found, cannot load models from DB');
+        logger$B('Database not found, cannot load models from DB');
         return {};
     }
     try {
@@ -2770,11 +2768,11 @@ const loadModelsFromDbForSchema = async (schemaId) => {
                 // or reconstructed from schemaData if available
             };
         }
-        logger$A(`Loaded ${Object.keys(models).length} models from database for schema ${schemaId}`);
+        logger$B(`Loaded ${Object.keys(models).length} models from database for schema ${schemaId}`);
         return models;
     }
     catch (error) {
-        logger$A(`Error loading models from database for schema ${schemaId}:`, error);
+        logger$B(`Error loading models from database for schema ${schemaId}:`, error);
         return {};
     }
 };
@@ -2891,34 +2889,34 @@ const savePropertyToDb = async (property) => {
     // Find existing property - try multiple strategies to handle name changes
     // 1. First try by schemaFileId (most reliable - doesn't change when name changes)
     let existingProperties = [];
-    logger$A(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
+    logger$B(`[savePropertyToDb] Looking for property ${property.modelName}:${property.name} (schemaFileId: ${schemaFileId}, originalName: ${property._originalValues?.name})`);
     if (schemaFileId) {
         existingProperties = await db
             .select()
             .from(properties)
             .where(drizzleOrm.and(drizzleOrm.eq(properties.schemaFileId, schemaFileId), drizzleOrm.eq(properties.modelId, modelRecord.id)))
             .limit(1);
-        logger$A(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
+        logger$B(`[savePropertyToDb] Found ${existingProperties.length} properties by schemaFileId`);
     }
     // 2. If not found by schemaFileId, try by original name (if name was changed)
     if (existingProperties.length === 0 && property._originalValues?.name && property._originalValues.name !== property.name) {
-        logger$A(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.name}`);
+        logger$B(`[savePropertyToDb] Trying to find by original name: ${property._originalValues.name}`);
         existingProperties = await db
             .select()
             .from(properties)
             .where(drizzleOrm.and(drizzleOrm.eq(properties.name, property._originalValues.name), drizzleOrm.eq(properties.modelId, modelRecord.id)))
             .limit(1);
-        logger$A(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
+        logger$B(`[savePropertyToDb] Found ${existingProperties.length} properties by original name`);
     }
     // 3. Fallback: try by current name
     if (existingProperties.length === 0) {
-        logger$A(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
+        logger$B(`[savePropertyToDb] Trying to find by current name: ${property.name}`);
         existingProperties = await db
             .select()
             .from(properties)
             .where(drizzleOrm.and(drizzleOrm.eq(properties.name, property.name), drizzleOrm.eq(properties.modelId, modelRecord.id)))
             .limit(1);
-        logger$A(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
+        logger$B(`[savePropertyToDb] Found ${existingProperties.length} properties by current name`);
     }
     // Prepare property data
     const propertyData = {
@@ -2967,7 +2965,7 @@ const savePropertyToDb = async (property) => {
             isEdited: true, // Mark as edited when saving changes
         })
             .where(drizzleOrm.eq(properties.id, existingProperty.id));
-        logger$A(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
+        logger$B(`Updated property ${property.modelName}:${property._originalValues?.name || 'unknown'} -> ${property.name} in database`);
     }
     else {
         // Property doesn't exist, create it
@@ -2977,12 +2975,12 @@ const savePropertyToDb = async (property) => {
                 ...propertyData,
                 isEdited: true, // Runtime-created properties are edited
             });
-            logger$A(`Created property ${property.modelName}:${property.name} in database`);
+            logger$B(`Created property ${property.modelName}:${property.name} in database`);
         }
         catch (insertError) {
             // Treat UNIQUE constraint as success - property already exists (e.g. from concurrent addModelsToDb or race)
             if (isSqliteUniqueConstraintError(insertError)) {
-                logger$A(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
+                logger$B(`Property ${property.modelName}:${property.name} already exists (UNIQUE constraint), treating as success`);
             }
             else {
                 throw insertError;
@@ -3099,7 +3097,7 @@ async function writeModelToDb(modelFileId, data) {
         if (doubleCheck.length > 0) {
             // Another process created it, use existing
             modelId = doubleCheck[0].id;
-            logger$A(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
+            logger$B(`Model with schemaFileId "${modelFileId}" was created by another process, using existing record (id: ${modelId})`);
         }
         else {
             try {
@@ -3113,7 +3111,7 @@ async function writeModelToDb(modelFileId, data) {
             catch (error) {
                 // Handle unique constraint violation
                 if (isSqliteUniqueConstraintError(error)) {
-                    logger$A(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
+                    logger$B(`Unique constraint violation for schemaFileId "${modelFileId}", attempting to find existing model`);
                     const existing = await db
                         .select()
                         .from(models$1)
@@ -3121,7 +3119,7 @@ async function writeModelToDb(modelFileId, data) {
                         .limit(1);
                     if (existing.length > 0) {
                         modelId = existing[0].id;
-                        logger$A(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
+                        logger$B(`Found existing model with schemaFileId "${modelFileId}" (id: ${modelId}) after constraint violation`);
                     }
                     else {
                         throw error;
@@ -3191,7 +3189,7 @@ async function writeModelToDb(modelFileId, data) {
             if (schemaCheck.length === 0) {
                 throw new Error(`Schema with id ${data.schemaId} does not exist in database. Cannot create join record.`);
             }
-            logger$A(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
+            logger$B(`Creating join record: modelId=${modelId}, schemaId=${data.schemaId} (both verified to exist)`);
             await linkModelToSchema(db, modelId, data.schemaId);
             // Notify React useModels so it can invalidate; live query over join often doesn't re-run when model_schemas is inserted.
             // Yield so the insert is visible to the refetch that will run when the broadcast is received.
@@ -3206,13 +3204,13 @@ async function writeModelToDb(modelFileId, data) {
                 }
                 catch (_) { }
             }
-            logger$A(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
+            logger$B(`Successfully created join record for model ${data.modelName} (id: ${modelId}) to schema (id: ${data.schemaId})`);
         }
         catch (error) {
             if (error?.code === 'SQLITE_CONSTRAINT_FOREIGNKEY') {
-                logger$A(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
-                logger$A(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
-                logger$A(`Error details:`, error);
+                logger$B(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}"`);
+                logger$B(`modelId: ${modelId}, schemaId: ${data.schemaId}`);
+                logger$B(`Error details:`, error);
                 // Re-throw with more context
                 throw new Error(`FOREIGN KEY constraint failed when creating join record for model "${data.modelName}" (modelId: ${modelId}, schemaId: ${data.schemaId}). ${error.message}`);
             }
@@ -3232,7 +3230,7 @@ async function writeModelToDb(modelFileId, data) {
             if (existingProps.length > 0 && existingProps[0].schemaFileId) {
                 // Use existing property's schemaFileId
                 propertyFileId = existingProps[0].schemaFileId;
-                logger$A(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+                logger$B(`Using existing propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
             else if (propData.id) {
                 // Use provided ID
@@ -3243,7 +3241,7 @@ async function writeModelToDb(modelFileId, data) {
                 // IDs should be generated in the import process before calling writeModelToDb
                 const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
                 propertyFileId = generateId();
-                logger$A(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
+                logger$B(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
             await writePropertyToDb(propertyFileId, {
                 modelId,
@@ -3252,7 +3250,7 @@ async function writeModelToDb(modelFileId, data) {
             });
         }
     }
-    logger$A(`Wrote model ${data.modelName} (${modelFileId}) to database`);
+    logger$B(`Wrote model ${data.modelName} (${modelFileId}) to database`);
 }
 /**
  * Write property to database
@@ -3327,7 +3325,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
             .update(properties)
             .set(propertyData)
             .where(drizzleOrm.eq(properties.id, existing.id));
-        logger$A(`Updated property ${data.name} (${propertyFileId}) in database`);
+        logger$B(`Updated property ${data.name} (${propertyFileId}) in database`);
     }
     else {
         // Property doesn't exist, create it
@@ -3343,17 +3341,17 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
                 .update(properties)
                 .set(propertyData)
                 .where(drizzleOrm.eq(properties.id, doubleCheck[0].id));
-            logger$A(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
+            logger$B(`Property with schemaFileId "${propertyFileId}" was created by another process, updated existing record`);
         }
         else {
             try {
                 await db.insert(properties).values({ required: false, ...propertyData });
-                logger$A(`Created property ${data.name} (${propertyFileId}) in database`);
+                logger$B(`Created property ${data.name} (${propertyFileId}) in database`);
             }
             catch (error) {
                 // Handle unique constraint violation
                 if (isSqliteUniqueConstraintError(error)) {
-                    logger$A(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
+                    logger$B(`Unique constraint violation for property schemaFileId "${propertyFileId}", attempting to find existing property`);
                     const existing = await db
                         .select()
                         .from(properties)
@@ -3364,7 +3362,7 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
                             .update(properties)
                             .set(propertyData)
                             .where(drizzleOrm.eq(properties.id, existing[0].id));
-                        logger$A(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
+                        logger$B(`Found existing property with schemaFileId "${propertyFileId}" (id: ${existing[0].id}) after constraint violation, updated it`);
                     }
                     else {
                         throw new Error(`Failed to create or find property "${data.name}" with schemaFileId "${propertyFileId}": ${error.message}`);
@@ -3637,7 +3635,114 @@ const supportsOpfsFileDownloads = () => {
     return isBrowser() || isElectronRenderer();
 };
 
-const logger$z = debug('seedSdk:files:download');
+/**
+ * Tag every Seed upload carries with the hex digest of its data. Producers: the SDK's
+ * `getPublishUploadData` / `getPublishUploads` (and through them both the L1 transaction path and
+ * the bundler / DataItem path in `@seedprotocol/publish`). Consumer: the files download
+ * (`events/files/download.ts` and the download worker), which verifies downloaded bytes against it
+ * and copies a verified value into `metadata.content_hash`.
+ */
+const CONTENT_SHA256_TAG = 'Content-SHA-256';
+const CONTENT_TYPE_TAG = 'Content-Type';
+/**
+ * Lowercase hex SHA-256 of `data`: the value of the {@link CONTENT_SHA256_TAG} tag.
+ *
+ * Uses @noble/hashes rather than WebCrypto so it also works outside secure contexts (WebCrypto's
+ * `crypto.subtle` is missing on plain-http origins); the digest is the same.
+ *
+ * In SDK 0.7.2 and earlier the L1 transaction path (`getPublishUploads`) wrote SHA3-256 under this tag name
+ * while the bundler path wrote SHA-256. Uploads from that path still carry SHA3-256 digests; use
+ * {@link contentSha256TagMatches} to check a tag value against bytes.
+ */
+const getContentSha256 = (data) => utils.bytesToHex(sha256.sha256(data));
+/**
+ * Tags for one upload, in the order every upload uses: content hash, content type, then any
+ * configured extra tags (e.g. App-Name from `arweaveUploadTags`).
+ */
+const buildArweaveContentTags = (contentHash, contentType, extra) => {
+    const tags = [];
+    if (contentHash)
+        tags.push({ name: CONTENT_SHA256_TAG, value: contentHash });
+    if (contentType)
+        tags.push({ name: CONTENT_TYPE_TAG, value: contentType });
+    if (extra?.length)
+        tags.push(...extra);
+    return tags;
+};
+
+/** Subdirectory of the files root that holds a storage seed's file, by its data type. */
+const getStorageSubdirForDataType = (dataType) => {
+    switch (normalizeDataType(dataType ?? undefined)) {
+        case 'Image':
+            return 'images';
+        case 'Html':
+            return 'html';
+        case 'Json':
+            return 'json';
+        case 'File':
+        default:
+            // Unknown types are generic files; `images/` is only for what the SDK knows is an image.
+            return 'files';
+    }
+};
+/** Absolute directory for a storage seed's file (`images/`, `files/`, `html/` or `json/` under the files root). */
+const getStorageDirForDataType = (dataType) => BaseFileManager.getFilesPath(getStorageSubdirForDataType(dataType));
+/**
+ * Subdirectory (relative to the files root, no leading slash) for an ItemStorage property's file:
+ * its model's `storage.path` (`localStorageDir`), else `files`.
+ */
+const getItemStorageSubdir = (localStorageDir) => (localStorageDir ?? '').replace(/^\/+/, '').replace(/\/+$/, '') || 'files';
+/**
+ * File name a local save gives an ItemStorage property: `<seedUid or seedLocalId><extension>`
+ * (see saveItemStorage). Downloaded content is named after its transaction instead
+ * (`<txId><extension>`, see syncDbWithEas), which is what the metadata row's refResolvedValue says.
+ */
+const getItemStorageLocalFileName = (seedId, filenameSuffix) => `${seedId}${filenameSuffix ?? ''}`;
+
+/** Rows per query: well under SQLite's bound-parameter limit. */
+const CHUNK_SIZE = 400;
+/**
+ * Where the download worker saves each child of a composite upload, by transaction id then child
+ * (property) name: a path relative to the files root.
+ *
+ * The paths come from the ItemStorage rows sync derives from a `storage_transaction_id`
+ * attestation (see `createMetadataRecordsForStorageTransactionId`): property value = the
+ * transaction id, `refResolvedValue` = `<txId><extension>`, `localStorageDir` = the model's storage
+ * directory. Those rows are what hydration reads, so a child saved here is found as that property's
+ * file. Transactions with no such rows are left out; the worker then falls back to the legacy
+ * html / json layout.
+ */
+const getCompositeChildPaths = async (transactionIds) => {
+    const out = {};
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || transactionIds.length === 0)
+        return out;
+    for (let i = 0; i < transactionIds.length; i += CHUNK_SIZE) {
+        const chunk = transactionIds.slice(i, i + CHUNK_SIZE);
+        const rows = await appDb
+            .select({
+            transactionId: metadata$1.propertyValue,
+            propertyName: metadata$1.propertyName,
+            refResolvedValue: metadata$1.refResolvedValue,
+            localStorageDir: metadata$1.localStorageDir,
+        })
+            .from(metadata$1)
+            .where(drizzleOrm.and(drizzleOrm.isNotNull(metadata$1.derivedFromUid), drizzleOrm.isNotNull(metadata$1.refResolvedValue), drizzleOrm.inArray(metadata$1.propertyValue, chunk)));
+        for (const row of rows) {
+            const { transactionId, propertyName, refResolvedValue } = row;
+            if (!transactionId || !propertyName || !refResolvedValue)
+                continue;
+            // A file name, never a path: anything else is not where the SDK would look.
+            if (refResolvedValue.includes('/') || refResolvedValue.includes('\\'))
+                continue;
+            const byName = (out[transactionId] ?? (out[transactionId] = {}));
+            byName[propertyName] ?? (byName[propertyName] = `${getItemStorageSubdir(row.localStorageDir)}/${refResolvedValue}`);
+        }
+    }
+    return out;
+};
+
+const logger$A = debug('seedSdk:files:download');
 const AUTO_BULK_DOWNLOAD_THROTTLE_MS = 10000;
 /** Avoid refetch-on-every-call: transient empty indexer responses were overwriting good cache (see trailing throttle ~10s after success). */
 const GET_FILES_METADATA_STALE_MS = 120000;
@@ -3647,7 +3752,7 @@ const lazyDownloadInFlightByTransactionId = new Map();
 const syncDbFiles = async (endpoints) => {
     // TODO: Implement syncDbFiles functionality if needed
     // This was previously in @/services/internal/helpers
-    logger$z('[download] syncDbFiles called but not yet implemented');
+    logger$A('[download] syncDbFiles called but not yet implemented');
     return Promise.resolve();
 };
 const getAppDbReady = async () => {
@@ -3787,76 +3892,117 @@ const parseTransactionIdsFromMetadata = (filesMetadata, excludedTransactions) =>
     }
     return transactionIds;
 };
-const downloadTransactionIds = async (rawTransactionIds, options) => {
-    if (!supportsOpfsFileDownloads()) {
-        return false;
+/** Content-SHA-256 tag values for the transactions that have one, from one batched tag lookup (cached). */
+const getExpectedContentHashes = async (transactionIds) => {
+    const queryClient = eas.BaseQueryClient.getQueryClient();
+    const tagsById = new Map();
+    const toFetch = [];
+    for (const transactionId of transactionIds) {
+        // Tags never change once a transaction is indexed, so a cached lookup stays good.
+        const cached = queryClient.getQueryData?.(['getTransactionTags', transactionId]);
+        if (cached)
+            tagsById.set(transactionId, cached);
+        else
+            toFetch.push(transactionId);
+    }
+    if (toFetch.length > 0) {
+        try {
+            const fetched = await arweave.getTransactionTagsByIds(toFetch, {
+                client: arweave.BaseArweaveClient.getArweaveClient(),
+                onError: (error) => logger$A('[download] transaction tags lookup failed', error),
+            });
+            for (const [transactionId, tags] of fetched) {
+                tagsById.set(transactionId, tags);
+                // Seed the per-transaction cache entry (the client interface has no setQueryData).
+                void queryClient
+                    .fetchQuery({ queryKey: ['getTransactionTags', transactionId], queryFn: async () => tags })
+                    .catch(() => { });
+            }
+        }
+        catch (error) {
+            logger$A('[download] transaction tags lookup failed', error);
+        }
     }
-    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
-    if (transactionIds.length === 0) {
-        return false;
+    const out = {};
+    for (const [transactionId, tags] of tagsById) {
+        const value = tags.find((tag) => tag.name === CONTENT_SHA256_TAG)?.value?.trim();
+        if (value)
+            out[transactionId] = value;
     }
-    const excludedTransactions = await getExcludedTransactions();
-    const queryClient = eas.BaseQueryClient.getQueryClient();
-    const transactionIdsToDownload = [];
-    await arweave.ensureReadGatewaySelected();
+    return out;
+};
+/** Store the (now verified) Content-SHA-256 of each downloaded transaction on its metadata row. */
+const recordVerifiedContentHashes = async (transactionIds, expectedContentHashes) => {
     for (const transactionId of transactionIds) {
-        if (excludedTransactions.has(transactionId)) {
+        const contentHash = expectedContentHashes[transactionId];
+        if (!contentHash)
             continue;
-        }
         try {
-            // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
-            // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
-            let tags = [];
-            try {
-                tags = await queryClient.fetchQuery({
-                    queryKey: ['getTransactionTags', transactionId],
-                    queryFn: async () => arweave.BaseArweaveClient.getTransactionTags(transactionId),
-                });
-            }
-            catch {
-                tags = [];
+            const metadataRecord = await getMetadata({ storageTransactionId: transactionId });
+            if (metadataRecord) {
+                await saveMetadata(metadataRecord, { contentHash });
             }
-            if (tags && tags.length > 0) {
-                for (const { name, value } of tags) {
-                    if (name !== 'Content-SHA-256')
-                        continue;
-                    const metadataRecord = await getMetadata({
-                        storageTransactionId: transactionId,
-                    });
-                    if (metadataRecord) {
-                        await saveMetadata(metadataRecord, {
-                            contentHash: value,
-                        });
-                    }
-                }
-            }
-            transactionIdsToDownload.push(transactionId);
         }
         catch (error) {
-            logger$z(error);
+            logger$A(error);
         }
     }
+};
+const downloadTransactionIds = async (rawTransactionIds, options) => {
+    if (!supportsOpfsFileDownloads()) {
+        return false;
+    }
+    const transactionIds = Array.from(new Set(rawTransactionIds.filter((tx) => !!tx && tx.trim().length > 0)));
+    if (transactionIds.length === 0) {
+        return false;
+    }
+    const excludedTransactions = await getExcludedTransactions();
+    await arweave.ensureReadGatewaySelected();
+    // Browser: do not call getTransactionStatus() — many gateways (e.g. g8way.io) redirect or omit
+    // CORS headers, so fetch() fails and we would wrongly exclude txs. The OPFS worker fetch decides success.
+    const transactionIdsToDownload = transactionIds.filter((id) => !excludedTransactions.has(id));
     if (transactionIdsToDownload.length === 0) {
         return false;
     }
+    // One batched lookup for every upload's Content-SHA-256 tag; downloads are verified against it.
+    // Missing tags (old uploads, or a just-published one not indexed yet) just mean no verification.
+    const expectedContentHashes = await getExpectedContentHashes(transactionIdsToDownload);
     // Preferred gateways first: a just-published item is only on the gateway it was uploaded through.
     const arweaveBaseUrls = arweave.getArweaveReadBaseUrls();
+    // Where each ItemStorage child of a composite goes (the worker cannot read the DB or the schema).
+    const compositeChildPaths = await getCompositeChildPaths(transactionIdsToDownload).catch((error) => {
+        logger$A('[download] composite child paths lookup failed', error);
+        return {};
+    });
+    let result;
     if (transactionIdsToDownload.length === 1) {
-        await BaseFileManager.downloadFileByTransactionId({
-            transactionId: transactionIdsToDownload[0],
+        const transactionId = transactionIdsToDownload[0];
+        result = await BaseFileManager.downloadFileByTransactionId({
+            transactionId,
             arweaveHost: arweave.BaseArweaveClient.getBaseUrl(),
             arweaveBaseUrls,
             excludedTransactions,
+            expectedContentHash: expectedContentHashes[transactionId],
+            compositeChildPaths: compositeChildPaths[transactionId],
         });
     }
     else {
-        await BaseFileManager.downloadAllFiles({
+        result = await BaseFileManager.downloadAllFiles({
             transactionIds: transactionIdsToDownload,
             arweaveHost: arweave.BaseArweaveClient.getBaseUrl(),
             arweaveBaseUrls,
             excludedTransactions,
+            expectedContentHashes,
+            compositeChildPaths,
         });
     }
+    if (result) {
+        for (const transactionId of result.hashMismatchTransactionIds) {
+            // Not saved by the worker; left for a later run (a gateway may serve the right bytes then).
+            logger$A(`[download] ${transactionId}: downloaded bytes do not match Content-SHA-256; skipped`);
+        }
+        await recordVerifiedContentHashes(result.verifiedTransactionIds, expectedContentHashes);
+    }
     if (options?.resizeAllImages !== false) {
         await BaseFileManager.resizeAllImages({
             width: 480,
@@ -3941,6 +4087,7 @@ const downloadAllFilesBinaryRequestHandler = async (addressesHintOrPayload) => {
     await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('html'));
     await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('json'));
     await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('images'));
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath('files'));
     const excludedTransactions = await getExcludedTransactions();
     const fromEas = parseTransactionIdsFromMetadata(filesMetadata ?? [], excludedTransactions);
     const fromLocal = await collectTransactionIdsFromLocalMetadata();
@@ -3970,7 +4117,7 @@ const downloadTransactionIdWithDedupe = async (transactionId) => {
 };
 const scheduleBulkFilesDownloadFromEasSyncThrottled = lodashEs.throttle((addressesHint) => {
     void downloadAllFilesBinaryRequestHandler(addressesHint).catch((error) => {
-        logger$z('[scheduleBulkFilesDownloadFromEasSync] failed', error);
+        logger$A('[scheduleBulkFilesDownloadFromEasSync] failed', error);
     });
 }, AUTO_BULK_DOWNLOAD_THROTTLE_MS, { leading: true, trailing: false });
 const scheduleBulkFilesDownloadFromEasSync = (addressesHint) => {
@@ -4122,7 +4269,7 @@ const INTERNAL_STORAGE_MODEL_FILE_IDS = {
     html: 'SEEDPROTOCOL_HTML',
 };
 
-const logger$y = debug('seedSdk:helpers:ensureImageLocal');
+const logger$z = debug('seedSdk:helpers:ensureImageLocal');
 /** Arweave transaction ids are 43 chars in the URL-safe base64 alphabet. */
 const ARWEAVE_TX_ID_RE = /^[a-z0-9_-]{43}$/i;
 const IMAGE_SIZES = [
@@ -4291,7 +4438,7 @@ const runEnsureImageLocal = async (params) => {
         };
     }
     catch (error) {
-        logger$y('ensureImageLocal failed', error);
+        logger$z('ensureImageLocal failed', error);
         return { status: 'failed' };
     }
 };
@@ -4348,7 +4495,7 @@ var generateId$1 = /*#__PURE__*/Object.freeze({
     generateId: generateId
 });
 
-const logger$x = debug('seedSdk:shared:helpers');
+const logger$y = debug('seedSdk:shared:helpers');
 const toSnakeCase = (str) => {
     return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
 };
@@ -4405,7 +4552,7 @@ const convertTxIdToImage = async (txId) => {
     const imageFilePath = BaseFileManager.getFilesPath('images', txId);
     const fileExists = await BaseFileManager.pathExists(imageFilePath);
     if (!fileExists) {
-        logger$x(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
+        logger$y(`[ItemView] [updateImage] ${imageFilePath} does not exist`);
         return;
     }
     const buffer = await BaseFileManager.readFileAsBuffer(imageFilePath);
@@ -4450,7 +4597,7 @@ function isActorStopped(actor) {
     return actor.getSnapshot().status === 'stopped';
 }
 
-const logger$w = debug('seedSdk:model:actors:loadOrCreateModel');
+const logger$x = debug('seedSdk:model:actors:loadOrCreateModel');
 /**
  * Create ModelProperty instances for all property IDs to ensure they're cached
  * This ensures that ModelProperty.getById() in Model.properties getter will find the instances
@@ -4461,10 +4608,10 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B-cZm1yU.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DXZ39Wyv.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
-            logger$w('createPropertyInstances: ModelProperty not available from dynamic import');
+            logger$x('createPropertyInstances: ModelProperty not available from dynamic import');
             return;
         }
         // Create instances for all property IDs in parallel
@@ -4473,22 +4620,22 @@ const createPropertyInstances = async (propertyFileIds) => {
             try {
                 const property = await ModelProperty.createById(propertyFileId);
                 if (property) {
-                    logger$w(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
+                    logger$x(`Created/cached ModelProperty instance for propertyFileId "${propertyFileId}"`);
                 }
                 else {
-                    logger$w(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
+                    logger$x(`ModelProperty.createById returned undefined for propertyFileId "${propertyFileId}" (may not exist in DB yet)`);
                 }
             }
             catch (error) {
-                logger$w(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                logger$x(`Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                 // Don't throw - continue with other properties
             }
         });
         await Promise.all(createPromises);
-        logger$w(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
+        logger$x(`Finished creating/caching ${propertyFileIds.length} ModelProperty instances`);
     }
     catch (error) {
-        logger$w(`Error in createPropertyInstances: ${error}`);
+        logger$x(`Error in createPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
 };
@@ -4518,7 +4665,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                     if (dbModels.length > 0) {
                         modelRecord = dbModels[0];
                         foundBySchemaFileId = true;
-                        logger$w(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
+                        logger$x(`Found model "${modelName}" in database by schemaFileId "${schemaFileId}"`);
                     }
                 }
                 // If not found by ID, try by name
@@ -4572,16 +4719,16 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                                 // Access instanceCacheById via type assertion since it's protected
                                 const cacheById = Model.instanceCacheById;
                                 if (cacheById.has(dbSchemaFileId)) {
-                                    logger$w(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
+                                    logger$x(`Model "${modelName}" found in database by name with schemaFileId "${dbSchemaFileId}", and a cached instance already exists. Updating current instance to use the same schemaFileId.`);
                                     // Update the current instance's schemaFileId to match the database
                                     // This ensures both instances point to the same cached instance
                                     modelRecord = foundModel;
                                     schemaFileId = dbSchemaFileId;
-                                    logger$w(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
+                                    logger$x(`Using existing cached instance with schemaFileId "${schemaFileId}" for model "${modelName}"`);
                                 }
                             }
                             catch (error) {
-                                logger$w(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
+                                logger$x(`Error checking Model cache for schemaFileId "${dbSchemaFileId}": ${error}`);
                                 // Fall through to normal processing
                             }
                         }
@@ -4589,31 +4736,31 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                         // this is a new model - don't use the existing model (will be renamed if duplicate)
                         // UNLESS we found a cached instance above (in which case modelRecord is already set)
                         if (!modelRecord && schemaFileId && dbSchemaFileId && schemaFileId !== dbSchemaFileId) {
-                            logger$w(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
+                            logger$x(`Model "${modelName}" found by name but has different schemaFileId (provided: "${schemaFileId}", db: "${dbSchemaFileId}"). Creating new model (will check for duplicates).`);
                             // Don't set modelRecord - we'll create a new model with potentially renamed name
                         }
                         else if (!modelRecord && schemaFileId && !dbSchemaFileId) {
                             // We have a schemaFileId but the found model doesn't have one - this is a new model
                             // Don't reuse the existing model, create a new one (will be renamed if duplicate)
-                            logger$w(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
+                            logger$x(`Model "${modelName}" found by name but found model has no schemaFileId. Creating new model with schemaFileId "${schemaFileId}" (will check for duplicates).`);
                             // Don't set modelRecord - we'll create a new model
                         }
                         else if (!modelRecord) {
                             // Only reuse existing model if:
                             // 1. No schemaFileId was provided (loading existing model), OR
                             // 2. schemaFileId matches (same model)
-                            logger$w(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
+                            logger$x(`Model "${modelName}" found by name, reusing existing model (schemaFileId: provided="${schemaFileId}", db="${dbSchemaFileId}")`);
                             modelRecord = foundModel;
                             // Only use database schemaFileId if no id was explicitly provided
                             // If an id was provided, we should use it (it might be creating a new model with a specific ID)
                             if (!id && dbSchemaFileId) {
                                 schemaFileId = dbSchemaFileId;
-                                logger$w(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
+                                logger$x(`Using database schemaFileId "${schemaFileId}" for model "${modelName}" (no ID was provided)`);
                             }
                             else if (id) {
-                                logger$w(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
+                                logger$x(`Preserving provided id (schemaFileId) "${schemaFileId}" for model "${modelName}" (ignoring database schemaFileId "${dbSchemaFileId}")`);
                             }
-                            logger$w(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
+                            logger$x(`Found model "${modelName}" in database by name, schemaFileId: "${schemaFileId}"`);
                         }
                     }
                 }
@@ -4638,7 +4785,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                     // Generate schemaFileId if not set
                     if (!schemaFileId) {
                         schemaFileId = generateId();
-                        logger$w(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
+                        logger$x(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
                     }
                     // Include _dbId from database record so properties can be created if needed
                     // Even if we found an existing model, we may still need to create properties
@@ -4667,14 +4814,14 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                 }
             }
             catch (error) {
-                logger$w(`Error loading model from database: ${error}`);
+                logger$x(`Error loading model from database: ${error}`);
                 // Fall through to create new model
             }
         }
         // 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-STP972Xw.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
             const { Schema } = schemaMod;
             // Stopped meanwhile (unloaded, or evicted with its schema): don't load the schema again
             if (isActorStopped(self))
@@ -4705,10 +4852,10 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                 const byName = schemaContext.models[modelName];
                 const schemaModelId = byName?.id ?? null;
                 if (schemaFileId === schemaModelId) {
-                    logger$w(`Found model "${modelName}" in Schema context (database fallback)`);
+                    logger$x(`Found model "${modelName}" in Schema context (database fallback)`);
                     if (!schemaFileId) {
                         schemaFileId = generateId();
-                        logger$w(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
+                        logger$x(`Generated id (schemaFileId) "${schemaFileId}" for model "${modelName}"`);
                     }
                     sendBack({
                         type: 'loadOrCreateModelSuccess',
@@ -4724,7 +4871,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                     // Schema context may not have model by name yet (e.g. still loading). If our id appears in any schema model, we're the schema model.
                     for (const def of Object.values(schemaContext.models)) {
                         if (def?.id === schemaFileId) {
-                            logger$w(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
+                            logger$x(`Found model in Schema context by id "${schemaFileId}" (database fallback)`);
                             sendBack({
                                 type: 'loadOrCreateModelSuccess',
                                 model: { id: schemaFileId },
@@ -4736,7 +4883,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
             }
         }
         catch (error) {
-            logger$w(`Error loading model from Schema context: ${error}`);
+            logger$x(`Error loading model from Schema context: ${error}`);
             // Fall through to create new model
         }
         // Step 3: Check for duplicate names in database before creating new model
@@ -4756,7 +4903,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
             // 3. This is an internal schema (internal schemas should preserve original names from schema files), OR
             // 4. This instance was created with modelFileId from schema (_idFromSchema) - schema models keep their name
             const shouldSkipDuplicateCheck = modelRecord !== null || foundBySchemaFileId || isInternal || !!_idFromSchema;
-            logger$w(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
+            logger$x(`Duplicate check: modelRecord=${modelRecord !== null}, foundBySchemaFileId=${foundBySchemaFileId}, isInternal=${isInternal}, _idFromSchema=${!!_idFromSchema}, schemaFileId=${schemaFileId}, shouldSkip=${shouldSkipDuplicateCheck}`);
             if (!shouldSkipDuplicateCheck) {
                 try {
                     const lowerModelName = modelName.toLowerCase();
@@ -4768,7 +4915,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                         // Check name-based cache for this schema
                         // Skip the current model (context.id): Model.create() adds the new instance to the cache
                         // before this callback runs, so we must not count it as a duplicate.
-                        logger$w(`Checking Model cache for duplicates in schema "${schemaName}"`);
+                        logger$x(`Checking Model cache for duplicates in schema "${schemaName}"`);
                         const currentModelFileId = schemaFileId ?? null;
                         const cacheByName = Model.instanceCacheByName;
                         for (const [nameKey, cachedModelFileId] of cacheByName.entries()) {
@@ -4779,7 +4926,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                                 const lowerCachedName = cachedModelName.toLowerCase();
                                 if (lowerCachedName === lowerModelName) {
                                     existingNumbers.add(0); // Base name exists
-                                    logger$w(`Found duplicate in Model cache: "${cachedModelName}" matches "${modelName}"`);
+                                    logger$x(`Found duplicate in Model cache: "${cachedModelName}" matches "${modelName}"`);
                                 }
                                 else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
                                     // Check if it's the base name followed by a space and a number
@@ -4787,7 +4934,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                                     const number = parseInt(suffix, 10);
                                     if (!isNaN(number) && suffix === number.toString()) {
                                         existingNumbers.add(number);
-                                        logger$w(`Found numbered variant in Model cache: "${cachedModelName}" (number: ${number})`);
+                                        logger$x(`Found numbered variant in Model cache: "${cachedModelName}" (number: ${number})`);
                                     }
                                 }
                             }
@@ -4803,7 +4950,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                                 const lowerCachedName = cachedModelName.toLowerCase();
                                 if (lowerCachedName === lowerModelName) {
                                     existingNumbers.add(0); // Base name exists
-                                    logger$w(`Found duplicate in Model legacy cache: "${cachedModelName}" matches "${modelName}"`);
+                                    logger$x(`Found duplicate in Model legacy cache: "${cachedModelName}" matches "${modelName}"`);
                                 }
                                 else if (lowerCachedName.startsWith(lowerModelName + ' ')) {
                                     // Check if it's the base name followed by a space and a number
@@ -4811,14 +4958,14 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                                     const number = parseInt(suffix, 10);
                                     if (!isNaN(number) && suffix === number.toString()) {
                                         existingNumbers.add(number);
-                                        logger$w(`Found numbered variant in Model legacy cache: "${cachedModelName}" (number: ${number})`);
+                                        logger$x(`Found numbered variant in Model legacy cache: "${cachedModelName}" (number: ${number})`);
                                     }
                                 }
                             }
                         }
                     }
                     catch (error) {
-                        logger$w(`Error checking Model cache for duplicates: ${error}`);
+                        logger$x(`Error checking Model cache for duplicates: ${error}`);
                         // Continue with database check
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
@@ -4828,7 +4975,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                         const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
                         const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
-                        logger$w(`Checking database for duplicate model names in schema "${schemaName}"`);
+                        logger$x(`Checking database for duplicate model names in schema "${schemaName}"`);
                         const allModelsForSchema = await db
                             .select({
                             name: models$1.name,
@@ -4837,16 +4984,16 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                             .innerJoin(modelSchemas, drizzleOrm.eq(models$1.id, modelSchemas.modelId))
                             .innerJoin(schemasTable, drizzleOrm.eq(modelSchemas.schemaId, schemasTable.id))
                             .where(drizzleOrm.eq(schemasTable.name, schemaName));
-                        logger$w(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
+                        logger$x(`Found ${allModelsForSchema.length} models in database for schema "${schemaName}": ${allModelsForSchema.map((m) => m.name).join(', ')}`);
                         if (allModelsForSchema.length === 0 && modelName.includes('Shared')) {
-                            logger$w(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
+                            logger$x(`[DEBUG] No models found in database for schema "${schemaName}" when checking for duplicate "${modelName}"`);
                         }
                         // Check for exact match (case-insensitive) or matches with number suffix
                         for (const dbModel of allModelsForSchema) {
                             const lowerDbName = dbModel.name.toLowerCase();
                             if (lowerDbName === lowerModelName) {
                                 existingNumbers.add(0); // Base name exists
-                                logger$w(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
+                                logger$x(`Found duplicate in database: "${dbModel.name}" matches "${modelName}"`);
                             }
                             else if (lowerDbName.startsWith(lowerModelName + ' ')) {
                                 // Check if it's the base name followed by a space and a number
@@ -4854,48 +5001,48 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
                                 const number = parseInt(suffix, 10);
                                 if (!isNaN(number) && suffix === number.toString()) {
                                     existingNumbers.add(number);
-                                    logger$w(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
+                                    logger$x(`Found numbered variant in database: "${dbModel.name}" (number: ${number})`);
                                 }
                             }
                         }
                     }
                     // If duplicates found, generate unique name
-                    logger$w(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
+                    logger$x(`Duplicate check results: existingNumbers=${Array.from(existingNumbers).join(', ')}, hasBaseName=${existingNumbers.has(0)}`);
                     if (existingNumbers.has(0)) {
                         let nextNumber = 1;
                         while (existingNumbers.has(nextNumber)) {
                             nextNumber++;
                         }
                         finalModelName = `${modelName} ${nextNumber}`;
-                        logger$w(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
+                        logger$x(`Found duplicate model name "${modelName}" in schema "${schemaName}", using unique name "${finalModelName}"`);
                     }
                     else {
-                        logger$w(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
+                        logger$x(`No duplicate found for model name "${modelName}" in schema "${schemaName}"`);
                     }
                 }
                 catch (error) {
-                    logger$w(`Error checking for duplicate model names: ${error}`);
+                    logger$x(`Error checking for duplicate model names: ${error}`);
                     // Continue with original name if check fails
                 }
             }
             else {
                 if (foundBySchemaFileId) {
-                    logger$w(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
+                    logger$x(`Preserving original model name "${modelName}" for model found by schemaFileId (schemaFileId: ${schemaFileId})`);
                 }
                 else if (modelRecord) {
-                    logger$w(`Using existing model name "${modelName}" from database (modelRecord found)`);
+                    logger$x(`Using existing model name "${modelName}" from database (modelRecord found)`);
                 }
                 else if (isInternal) {
-                    logger$w(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
+                    logger$x(`Preserving original model name "${modelName}" for internal schema "${schemaName}" (skipping duplicate check)`);
                 }
             }
         }
         // Step 4: Create new empty model (not found in database or Schema context)
-        logger$w(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
+        logger$x(`Creating new model "${finalModelName}" in schema "${schemaName}"`);
         // Generate schemaFileId for new model
         if (!schemaFileId) {
             schemaFileId = generateId();
-            logger$w(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
+            logger$x(`Generated id (schemaFileId) "${schemaFileId}" for new model "${finalModelName}"`);
         }
         // Runtime creates use a placeholder cache key in Model.create; move it to the final name. Skip when schema model (_idFromSchema).
         if (!_idFromSchema) {
@@ -4907,7 +5054,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
         // This avoids the issue where updateContext with modelName triggers validation and state transition
         // We use _pendingModelName (internal field) which won't trigger validation
         if (finalModelName !== modelName) {
-            logger$w(`Model name changed from "${modelName}" to "${finalModelName}", storing in _pendingModelName for loadOrCreateModelSuccess`);
+            logger$x(`Model name changed from "${modelName}" to "${finalModelName}", storing in _pendingModelName for loadOrCreateModelSuccess`);
             // Store the final name in a temporary internal field that will be picked up by loadOrCreateModelSuccess
             sendBack({
                 type: 'updateContext',
@@ -4915,11 +5062,11 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
             });
         }
         else {
-            logger$w(`Model name unchanged: "${modelName}"`);
+            logger$x(`Model name unchanged: "${modelName}"`);
         }
         // 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-STP972Xw.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
             const { Schema } = schemaMod;
             if (!isActorStopped(self)) {
                 const schema = Schema.create(schemaName, { waitForReady: false });
@@ -4927,7 +5074,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
             }
         }
         catch (err) {
-            logger$w(`Failed to mark schema as draft after creating model: ${err}`);
+            logger$x(`Failed to mark schema as draft after creating model: ${err}`);
         }
         sendBack({
             type: 'loadOrCreateModelSuccess',
@@ -4937,12 +5084,12 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context }, s
         });
     };
     _loadOrCreateModel().catch((error) => {
-        logger$w('Error loading or creating model:', error);
+        logger$x('Error loading or creating model:', error);
         sendBack({ type: 'loadOrCreateModelError', error });
     });
 });
 
-const logger$v = debug('seedSdk:model:actors:validateModel');
+const logger$w = debug('seedSdk:model:actors:validateModel');
 // Validation timeout in milliseconds (10 seconds)
 const VALIDATION_TIMEOUT_MS = 10000;
 const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self }) => {
@@ -4965,10 +5112,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CKNW1bKg.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-STP972Xw.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -5012,12 +5159,12 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self
                         }
                     }
                     else {
-                        logger$v(`Schema is in ${schemaStatus} state, skipping schema validation`);
+                        logger$w(`Schema is in ${schemaStatus} state, skipping schema validation`);
                         // Continue with structure validation only
                     }
                 }
                 catch (error) {
-                    logger$v('Error validating model against schema:', error);
+                    logger$w('Error validating model against schema:', error);
                     // Continue with structure validation only
                 }
             }
@@ -5032,7 +5179,7 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self
             if (!hasResponded) {
                 hasResponded = true;
                 clearTimeout(timeoutId);
-                logger$v('Error in validateModel:', error);
+                logger$w('Error in validateModel:', error);
                 sendBack({
                     type: 'validationError',
                     errors: [{
@@ -5049,7 +5196,7 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self
         if (!hasResponded) {
             hasResponded = true;
             clearTimeout(timeoutId);
-            logger$v('Error in validateModel:', error);
+            logger$w('Error in validateModel:', error);
             sendBack({
                 type: 'validationError',
                 errors: [{
@@ -5067,7 +5214,7 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context }, self
     };
 });
 
-const logger$u = debug('seedSdk:model:actors:createModelProperties');
+const logger$v = debug('seedSdk:model:actors:createModelProperties');
 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
@@ -5080,15 +5227,15 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input, self }) =>
             throw new Error('Model ID, file ID, and name are required to create properties');
         }
         if (!propertyDefinitions || Object.keys(propertyDefinitions).length === 0) {
-            logger$u('No property definitions provided, skipping property creation');
+            logger$v('No property definitions provided, skipping property creation');
             sendBack({ type: 'createModelPropertiesSuccess' });
             return;
         }
-        logger$u(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B-cZm1yU.js'); });
+        logger$v(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DXZ39Wyv.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
-            logger$u('ModelProperty not available from dynamic import');
+            logger$v('ModelProperty not available from dynamic import');
             sendBack({ type: 'createModelPropertiesError', error: new Error('ModelProperty not available') });
             return;
         }
@@ -5112,7 +5259,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input, self }) =>
             // IDs should be generated in the import process before creating properties
             const { generateId } = await Promise.resolve().then(function () { return generateId$1; });
             const propertyFileId = propData.id || propertyRecord?.schemaFileId || generateId();
-            logger$u(`Creating property "${propName}" with fileId "${propertyFileId}"`);
+            logger$v(`Creating property "${propName}" with fileId "${propertyFileId}"`);
             // Query database to get refModelId if the property has ref/refModelName
             // The property should already be in DB from addModelsToDb
             let refModelId = propData.refModelId;
@@ -5122,7 +5269,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input, self }) =>
                     // First try to get refModelId from the property record in the database
                     if (propertyRecord?.refModelId) {
                         refModelId = propertyRecord.refModelId;
-                        logger$u(`Found refModelId ${refModelId} from database for property "${propName}"`);
+                        logger$v(`Found refModelId ${refModelId} from database for property "${propName}"`);
                     }
                     else if (refModelName) {
                         // Fallback: resolve the ref by name within this model's schema
@@ -5130,17 +5277,17 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input, self }) =>
                         const refModelRecord = await resolveModelRecord(refModelName, { schemaName }, db);
                         if (refModelRecord?.id) {
                             refModelId = refModelRecord.id;
-                            logger$u(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
+                            logger$v(`Resolved refModelId ${refModelId} from model name "${refModelName}" for property "${propName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$u(`Error fetching refModelId for property "${propName}":`, error);
+                    logger$v(`Error fetching refModelId for property "${propName}":`, error);
                     // 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`);
+                logger$v(`Model "${modelName}" was stopped while creating its properties; not creating the rest`);
                 return;
             }
             // Create ModelProperty instance
@@ -5166,11 +5313,11 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input, self }) =>
                 _dbId: propertyRecord?.schemaFileId === propertyFileId ? propertyRecord.id : undefined, // Already persisted: skip the write
             }, { schemaName }); // Use 'as any' because _propertyFileId is not in TProperty type
         }
-        logger$u(`Successfully created all properties for model "${modelName}"`);
+        logger$v(`Successfully created all properties for model "${modelName}"`);
         sendBack({ type: 'createModelPropertiesSuccess' });
     };
     _createProperties().catch((error) => {
-        logger$u(`Error creating model properties: ${error}`);
+        logger$v(`Error creating model properties: ${error}`);
         sendBack({
             type: 'createModelPropertiesError',
             error: error instanceof Error ? error : new Error(String(error))
@@ -5212,7 +5359,7 @@ function anyEvictionSince(since) {
     return epoch !== since;
 }
 
-const logger$t = debug('seedSdk:write:validateEntity');
+const logger$u = debug('seedSdk:write:validateEntity');
 // XState v5 type inference bug: fromPromise types are inverted
 // We use type assertion to work around this
 const validateEntity = xstate.fromPromise(async ({ input }) => {
@@ -5225,7 +5372,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     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-STP972Xw.js'); });
+        const { Schema } = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
         if (schemaEvictedSince(schemaName, evictionEpoch)) {
             throw new Error(`Schema "${schemaName}" was evicted during validation`);
         }
@@ -5234,20 +5381,20 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     const _validate = async () => {
         try {
             const msg = `[validateEntity] Starting validation for ${entityInput.entityType}`;
-            logger$t(msg);
-            logger$t(`[validateEntity] Entity data:`, entityInput.entityData);
+            logger$u(msg);
+            logger$u(`[validateEntity] Entity data:`, entityInput.entityData);
             let result = { isValid: true, errors: [] };
             if (entityInput.entityType === 'model') {
                 const structureMsg = `[validateEntity] Validating model structure`;
-                logger$t(structureMsg);
+                logger$u(structureMsg);
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CKNW1bKg.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
                 const structureResult = validationService.validateModelStructure(entityInput.entityData);
                 const structureResultMsg = `[validateEntity] Structure validation result: isValid=${structureResult.isValid}, errors=${structureResult.errors?.length || 0}`;
-                logger$t(structureResultMsg);
+                logger$u(structureResultMsg);
                 if (!structureResult.isValid) {
                     result = {
                         isValid: false,
@@ -5258,16 +5405,16 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name provided, validate against schema
                     if (entityInput.entityData.schemaName) {
                         try {
-                            logger$t(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
+                            logger$u(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
                             const schema = await schemaForValidation(entityInput.entityData.schemaName);
                             const schemaSnapshot = schema.getService().getSnapshot();
                             const schemaStatus = schemaSnapshot.value;
-                            logger$t(`[validateEntity] Schema status: ${schemaStatus}`);
+                            logger$u(`[validateEntity] Schema status: ${schemaStatus}`);
                             if (schemaStatus === 'idle') {
                                 const schemaContext = schemaSnapshot.context;
-                                logger$t(`[validateEntity] Running validateModelAgainstSchema`);
+                                logger$u(`[validateEntity] Running validateModelAgainstSchema`);
                                 const schemaResult = validationService.validateModelAgainstSchema(schemaContext, entityInput.entityData.modelName, entityInput.entityData);
-                                logger$t(`[validateEntity] Schema validation result:`, schemaResult);
+                                logger$u(`[validateEntity] Schema validation result:`, schemaResult);
                                 if (!schemaResult.isValid) {
                                     result = {
                                         isValid: false,
@@ -5276,22 +5423,22 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                                 }
                             }
                             else {
-                                logger$t(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`);
+                                logger$u(`[validateEntity] Schema not in idle state (${schemaStatus}), skipping schema validation`);
                             }
                         }
                         catch (error) {
-                            logger$t('Error validating model against schema:', error);
+                            logger$u('Error validating model against schema:', error);
                             // Continue with structure validation only
                         }
                     }
                     else {
-                        logger$t(`[validateEntity] No schemaName provided, skipping schema validation`);
+                        logger$u(`[validateEntity] No schemaName provided, skipping schema validation`);
                     }
                 }
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CKNW1bKg.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -5323,7 +5470,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                             }
                         }
                         catch (error) {
-                            logger$t('Error validating property against schema:', error);
+                            logger$u('Error validating property against schema:', error);
                             // Continue with structure validation only
                         }
                     }
@@ -5331,7 +5478,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-CKNW1bKg.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -5344,14 +5491,14 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             // Return the result - fromPromise will automatically put this in event.output
             const completeMsg = `[validateEntity] Validation complete: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-            logger$t(completeMsg);
-            logger$t(`[validateEntity] Validation complete:`, result);
+            logger$u(completeMsg);
+            logger$u(`[validateEntity] Validation complete:`, result);
             return result;
         }
         catch (error) {
             const errorMsg = `[validateEntity] Error in validateEntity: ${error instanceof Error ? error.message : String(error)}`;
-            logger$t(errorMsg);
-            logger$t('Error in validateEntity:', error);
+            logger$u(errorMsg);
+            logger$u('Error in validateEntity:', error);
             // Throw error - fromPromise will automatically create error.platform event
             throw error;
         }
@@ -5360,7 +5507,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
     // @ts-ignore - XState v5 type inference bug: fromPromise incorrectly expects output type to match input type
 });
 
-const logger$s = debug('seedSdk:write:writeToDatabase');
+const logger$t = debug('seedSdk:write:writeToDatabase');
 // Writes that have started. Stopping a write process's actor can't cancel one, so code that deletes rows
 // under live instances (Schema.destroy, test cleanup) waits for these after evicting the instances.
 const inFlightWrites = new Set();
@@ -5387,8 +5534,8 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
             let output = input.entityData;
             if (input.entityType === 'model') {
                 const writeMsg = `Writing model to database: ${input.entityData.modelName} (schemaId: ${input.entityData.schemaId})`;
-                logger$s(writeMsg);
-                logger$s(`Writing model to database:`, {
+                logger$t(writeMsg);
+                logger$t(`Writing model to database:`, {
                     modelFileId: input.entityId,
                     modelName: input.entityData.modelName,
                     schemaId: input.entityData.schemaId,
@@ -5413,14 +5560,14 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                     output = input.entityData;
                 }
                 const successMsg = `Successfully wrote model "${input.entityData.modelName}" to database`;
-                logger$s(successMsg);
+                logger$t(successMsg);
             }
             else if (input.entityType === 'modelProperty') {
                 // Use current ModelProperty context when available so a user rename before the
                 // 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-B-cZm1yU.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DXZ39Wyv.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -5463,7 +5610,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
             });
         }
         catch (error) {
-            logger$s('Error in writeToDatabase:', error);
+            logger$t('Error in writeToDatabase:', error);
             sendBack({
                 type: 'writeError',
                 error: error instanceof Error ? error : new Error(String(error)),
@@ -5471,7 +5618,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
         }
     };
     const write = _write().catch((error) => {
-        logger$s('Error in writeToDatabase promise:', error);
+        logger$t('Error in writeToDatabase promise:', error);
         sendBack({
             type: 'writeError',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -5490,7 +5637,7 @@ var writeToDatabase$1 = /*#__PURE__*/Object.freeze({
     writeToDatabase: writeToDatabase
 });
 
-const logger$r = debug('seedSdk:write:writeProcessMachine');
+const logger$s = debug('seedSdk:write:writeProcessMachine');
 const writeProcessMachine = xstate.setup({
     types: {
         context: {},
@@ -5528,8 +5675,8 @@ const writeProcessMachine = xstate.setup({
                             writeStatus: 'validating',
                         }),
                         ({ event, context }) => {
-                            logger$r(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
-                            logger$r(`[startWrite] Data:`, event.data);
+                            logger$s(`[startWrite] Received startWrite for ${context.entityType} "${context.entityId}"`);
+                            logger$s(`[startWrite] Data:`, event.data);
                         },
                     ],
                 },
@@ -5538,14 +5685,14 @@ const writeProcessMachine = xstate.setup({
         validating: {
             entry: ({ context }) => {
                 const msg = `[validating] Entering validating state for ${context.entityType} "${context.entityId}"`;
-                logger$r(msg);
-                logger$r(`[validating] Entity data:`, context.pendingWrite?.data || context.entityData);
+                logger$s(msg);
+                logger$s(`[validating] Entity data:`, context.pendingWrite?.data || context.entityData);
             },
             invoke: {
                 src: 'validateEntity',
                 input: ({ context }) => {
                     const entityData = context.pendingWrite?.data || context.entityData;
-                    logger$r(`[validating] Invoking validateEntity with:`, { entityType: context.entityType, entityData });
+                    logger$s(`[validating] Invoking validateEntity with:`, { entityType: context.entityType, entityData });
                     return {
                         entityType: context.entityType,
                         entityData,
@@ -5573,8 +5720,8 @@ const writeProcessMachine = xstate.setup({
                                 return false;
                             }
                             const resultMsg = `[validating] Validation result: isValid=${result.isValid}, errors=${result.errors?.length || 0}`;
-                            logger$r(resultMsg);
-                            logger$r(`[validating] Validation result:`, result);
+                            logger$s(resultMsg);
+                            logger$s(`[validating] Validation result:`, result);
                             return result.isValid;
                         },
                         actions: [
@@ -5584,7 +5731,7 @@ const writeProcessMachine = xstate.setup({
                             }),
                             ({ context }) => {
                                 const msg = `[validating] Validation passed, transitioning to writing for ${context.entityType} "${context.entityId}"`;
-                                logger$r(msg);
+                                logger$s(msg);
                             },
                         ],
                     },
@@ -5604,7 +5751,7 @@ const writeProcessMachine = xstate.setup({
                             }),
                             ({ context, event }) => {
                                 const result = event.output;
-                                logger$r(`[validating] Validation failed for ${context.entityType} "${context.entityId}":`, result.errors);
+                                logger$s(`[validating] Validation failed for ${context.entityType} "${context.entityId}":`, result.errors);
                             },
                         ],
                     },
@@ -5618,7 +5765,7 @@ const writeProcessMachine = xstate.setup({
                         }),
                         ({ context, event }) => {
                             const errorMsg = `[validating] Validation error for ${context.entityType} "${context.entityId}": ${event.error}`;
-                            logger$r(errorMsg);
+                            logger$s(errorMsg);
                             console.error(errorMsg, event.error); // Always log to console
                         },
                     ],
@@ -5633,8 +5780,8 @@ const writeProcessMachine = xstate.setup({
                 src: 'writeToDatabase',
                 input: ({ context }) => {
                     const entityData = context.pendingWrite?.data || context.entityData;
-                    logger$r(`[writing] Calling writeToDatabase for ${context.entityType} "${context.entityId}"`);
-                    logger$r(`[writing] Entity data:`, entityData);
+                    logger$s(`[writing] Calling writeToDatabase for ${context.entityType} "${context.entityId}"`);
+                    logger$s(`[writing] Entity data:`, entityData);
                     return {
                         entityType: context.entityType,
                         entityId: context.entityId,
@@ -5655,7 +5802,7 @@ const writeProcessMachine = xstate.setup({
                             },
                         }),
                         ({ context }) => {
-                            logger$r(`[writing] Write successful for ${context.entityType} "${context.entityId}"`);
+                            logger$s(`[writing] Write successful for ${context.entityType} "${context.entityId}"`);
                         },
                     ],
                 },
@@ -5669,7 +5816,7 @@ const writeProcessMachine = xstate.setup({
                         }),
                         ({ context, event }) => {
                             const errorMsg = `[writing] Write error for ${context.entityType} "${context.entityId}": ${event.error}`;
-                            logger$r(errorMsg);
+                            logger$s(errorMsg);
                             // Nothing else reports a failed persist to the caller, so always log to console
                             console.error(errorMsg, event.error);
                         },
@@ -5712,7 +5859,7 @@ const writeProcessMachine = xstate.setup({
     },
 });
 
-const logger$q = debug('seedSdk:model:modelMachine');
+const logger$r = debug('seedSdk:model:modelMachine');
 const modelMachine = xstate.setup({
     types: {
         context: {},
@@ -5814,25 +5961,25 @@ const modelMachine = xstate.setup({
                                 // 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-B-cZm1yU.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-DXZ39Wyv.js'); }).then(({ ModelProperty }) => {
                                         if (self.getSnapshot().status === 'stopped')
                                             return;
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId, { evictionEpoch });
                                                 if (property) {
-                                                    logger$q(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
+                                                    logger$r(`[modelMachine] Created/cached ModelProperty instance for propertyFileId "${propertyFileId}" after _liveQueryPropertyIds update`);
                                                 }
                                             }
                                             catch (error) {
-                                                logger$q(`[modelMachine] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
+                                                logger$r(`[modelMachine] Error creating ModelProperty instance for propertyFileId "${propertyFileId}": ${error}`);
                                             }
                                         });
                                         Promise.all(createPromises).catch((error) => {
-                                            logger$q(`[modelMachine] Error creating property instances: ${error}`);
+                                            logger$r(`[modelMachine] Error creating property instances: ${error}`);
                                         });
                                     }).catch((error) => {
-                                        logger$q(`[modelMachine] Error importing ModelProperty: ${error}`);
+                                        logger$r(`[modelMachine] Error importing ModelProperty: ${error}`);
                                     });
                                 }
                             }, 0);
@@ -5910,11 +6057,11 @@ const modelMachine = xstate.setup({
                     target: 'idle',
                     actions: xstate.assign(({ context, event }) => {
                         const hasPendingProps = !!(context._pendingPropertyDefinitions && Object.keys(context._pendingPropertyDefinitions).length > 0);
-                        logger$q(`[loadOrCreateModelSuccess] Preserving _pendingPropertyDefinitions: ${hasPendingProps} (${Object.keys(context._pendingPropertyDefinitions || {}).length} properties)`);
+                        logger$r(`[loadOrCreateModelSuccess] Preserving _pendingPropertyDefinitions: ${hasPendingProps} (${Object.keys(context._pendingPropertyDefinitions || {}).length} properties)`);
                         // Check if there's a pending model name update (set before this event to avoid validation trigger)
                         const finalModelName = context._pendingModelName || context.modelName;
                         if (context._pendingModelName) {
-                            logger$q(`[loadOrCreateModelSuccess] Applying pending model name: "${context.modelName}" -> "${finalModelName}"`);
+                            logger$r(`[loadOrCreateModelSuccess] Applying pending model name: "${context.modelName}" -> "${finalModelName}"`);
                         }
                         return {
                             ...context,
@@ -5955,7 +6102,7 @@ const modelMachine = xstate.setup({
             entry: xstate.assign({
                 writeProcess: ({ context, spawn }) => {
                     if (!context.writeProcess && context.id) {
-                        logger$q(`[idle entry] Spawning writeProcess for model "${context.modelName}" (${context.id})`);
+                        logger$r(`[idle entry] Spawning writeProcess for model "${context.modelName}" (${context.id})`);
                         return spawn(writeProcessMachine, {
                             input: {
                                 entityType: 'model',
@@ -5976,7 +6123,7 @@ const modelMachine = xstate.setup({
                     actions: ({ self }) => {
                         // This event will be handled by the Model instance's subscription
                         // The Model will call _refreshPropertiesFromDb when it receives this event
-                        logger$q(`[idle] refreshProperties event received, will be handled by Model instance`);
+                        logger$r(`[idle] refreshProperties event received, will be handled by Model instance`);
                     },
                 },
                 validateModel: {
@@ -5988,14 +6135,14 @@ const modelMachine = xstate.setup({
                 requestWrite: {
                     actions: ({ context, event }) => {
                         if (context.writeProcess) {
-                            logger$q(`[requestWrite] Sending startWrite to writeProcess with data:`, event.data);
+                            logger$r(`[requestWrite] Sending startWrite to writeProcess with data:`, event.data);
                             context.writeProcess.send({
                                 type: 'startWrite',
                                 data: event.data,
                             });
                         }
                         else {
-                            logger$q(`[requestWrite] ERROR: writeProcess not available for model "${context.modelName}" (${context.id})`);
+                            logger$r(`[requestWrite] ERROR: writeProcess not available for model "${context.modelName}" (${context.id})`);
                         }
                     },
                 },
@@ -6004,18 +6151,18 @@ const modelMachine = xstate.setup({
                         guard: ({ context }) => {
                             // If we have pending property definitions, transition to creatingProperties
                             const hasPending = !!(context._pendingPropertyDefinitions && Object.keys(context._pendingPropertyDefinitions).length > 0);
-                            logger$q(`[writeSuccess guard] hasPending: ${hasPending}, _pendingPropertyDefinitions keys: ${context._pendingPropertyDefinitions ? Object.keys(context._pendingPropertyDefinitions).length : 0}`);
+                            logger$r(`[writeSuccess guard] hasPending: ${hasPending}, _pendingPropertyDefinitions keys: ${context._pendingPropertyDefinitions ? Object.keys(context._pendingPropertyDefinitions).length : 0}`);
                             return hasPending;
                         },
                         target: 'creatingProperties',
                         actions: xstate.assign(({ context, event }) => {
-                            logger$q(`[writeSuccess] Transitioning to creatingProperties for model "${context.modelName}"`);
+                            logger$r(`[writeSuccess] Transitioning to creatingProperties for model "${context.modelName}"`);
                             // Update _dbId from write output if available (writeToDatabase returns _dbId, not id)
                             const newContext = { ...context };
                             const dbId = event.output?._dbId ?? event.output?.id;
                             if (dbId != null) {
                                 newContext._dbId = dbId;
-                                logger$q(`[writeSuccess] Updated _dbId to ${dbId}`);
+                                logger$r(`[writeSuccess] Updated _dbId to ${dbId}`);
                             }
                             return newContext;
                         }),
@@ -6059,12 +6206,12 @@ const modelMachine = xstate.setup({
         },
         creatingProperties: {
             entry: ({ context }) => {
-                logger$q(`[creatingProperties entry] Starting property creation for model "${context.modelName}" with ${Object.keys(context._pendingPropertyDefinitions || {}).length} properties`);
+                logger$r(`[creatingProperties entry] Starting property creation for model "${context.modelName}" with ${Object.keys(context._pendingPropertyDefinitions || {}).length} properties`);
             },
             invoke: {
                 src: 'createModelProperties',
                 input: ({ context }) => {
-                    logger$q(`[creatingProperties invoke] Invoking createModelProperties with ${Object.keys(context._pendingPropertyDefinitions || {}).length} property definitions`);
+                    logger$r(`[creatingProperties invoke] Invoking createModelProperties with ${Object.keys(context._pendingPropertyDefinitions || {}).length} property definitions`);
                     return {
                         context,
                         propertyDefinitions: context._pendingPropertyDefinitions || {},
@@ -6096,7 +6243,7 @@ const modelMachine = xstate.setup({
                 createModelPropertiesError: {
                     target: 'error',
                     actions: ({ event }) => {
-                        logger$q('Error creating model properties:', event.error);
+                        logger$r('Error creating model properties:', event.error);
                     },
                 },
             },
@@ -6452,7 +6599,7 @@ var metadataLatest = /*#__PURE__*/Object.freeze({
     getMetadataLatest: getMetadataLatest
 });
 
-const logger$p = debug('seedSdk:item:actors:loadOrCreateItem');
+const logger$q = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
  * Maps metadata.property_name to the ItemProperty Map key (same rules as the instance loop below).
  */
@@ -6544,16 +6691,16 @@ 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-STP972Xw.js'); });
+                    const { Schema } = await Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); });
                     const schemaInstance = Schema.create(schemaNameToTry, { waitForReady: false });
                     const schemaContext = schemaInstance.getService().getSnapshot().context;
                     if (schemaContext.models?.[modelName]?.properties) {
                         propertySchemas = schemaContext.models[modelName].properties;
-                        logger$p(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
+                        logger$q(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from Schema context for ${modelName}`);
                     }
                 }
                 catch (err) {
-                    logger$p(`Fallback Schema context failed for ${modelName}: ${err}`);
+                    logger$q(`Fallback Schema context failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
@@ -6566,13 +6713,13 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                         const models = schemaFile.models;
                         if (models?.[modelName]?.properties) {
                             propertySchemas = models[modelName].properties;
-                            logger$p(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
+                            logger$q(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from loadAllSchemasFromDb for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$p(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
+                    logger$q(`Fallback loadAllSchemasFromDb failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
@@ -6587,17 +6734,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                             continue;
                         if (schemaFile.models?.[modelName]?.properties) {
                             propertySchemas = schemaFile.models[modelName].properties;
-                            logger$p(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
+                            logger$q(`Fallback: got ${Object.keys(propertySchemas).length} property schemas from schema file for ${modelName}`);
                             break;
                         }
                     }
                 }
                 catch (err) {
-                    logger$p(`Fallback schema file scan failed for ${modelName}: ${err}`);
+                    logger$q(`Fallback schema file scan failed for ${modelName}: ${err}`);
                 }
             }
             if (Object.keys(propertySchemas).length === 0) {
-                const schemaMod = await Promise.resolve().then(function () { return require('./index-nA5PxBSs.js'); });
+                const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
                 const { ModelPropertyDataTypes } = schemaMod;
                 const KNOWN_MODEL_FALLBACKS = {
                     Post: {
@@ -6609,12 +6756,12 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 };
                 if (KNOWN_MODEL_FALLBACKS[modelName]) {
                     propertySchemas = KNOWN_MODEL_FALLBACKS[modelName];
-                    logger$p(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
+                    logger$q(`Fallback: using known model schema for ${modelName} (${Object.keys(propertySchemas).length} properties)`);
                 }
             }
         }
         // 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-xMwPhQ5N.js'); });
+        const { normalizePropertyRecordSchema } = await Promise.resolve().then(function () { return require('./property-fa0iju0J.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
@@ -6627,7 +6774,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
             try {
                 let propertyName = metaRow.propertyName;
                 if (!propertyName) {
-                    logger$p(`Metadata row missing propertyName, skipping`);
+                    logger$q(`Metadata row missing propertyName, skipping`);
                     continue;
                 }
                 const listSchemaKey = resolveStorageNameToSchemaName(propertySchemas, propertyName);
@@ -6647,7 +6794,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-nA5PxBSs.js'); });
+                    const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
                     const { ModelPropertyDataTypes } = schemaMod;
                     propSchema = {
                         dataType: refSeedType === 'html' ? ModelPropertyDataTypes.Html
@@ -6677,14 +6824,14 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$p(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
+                    logger$q(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$p(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
+                    logger$q(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
-                logger$p(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
+                logger$q(`Error creating ItemProperty instance for propertyName "${metaRow.propertyName}": ${error}`);
             }
         }
         // Create placeholder ItemProperty instances for model schema properties without metadata
@@ -6707,17 +6854,17 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
                 const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
                     propertyInstances.set(propertyName, property);
-                    logger$p(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
+                    logger$q(`Created placeholder ItemProperty for model property "${propertyName}" (no metadata)`);
                 }
             }
             catch (error) {
-                logger$p(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
+                logger$q(`Error creating placeholder ItemProperty for "${propertyName}": ${error}`);
             }
         }
-        logger$p(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
+        logger$q(`Finished creating/caching ${propertyInstances.size} ItemProperty instances`);
     }
     catch (error) {
-        logger$p(`Error in createItemPropertyInstances: ${error}`);
+        logger$q(`Error in createItemPropertyInstances: ${error}`);
         // Don't throw - this is best-effort to pre-populate cache
     }
     return propertyInstances;
@@ -6725,7 +6872,7 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, m
 const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        logger$p(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$q(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -6755,7 +6902,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .limit(1);
         if (seedRecords.length === 0) {
             // Seed not found - this is a new item, will be created elsewhere
-            logger$p(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+            logger$q(`Seed not found in database for seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -6798,7 +6945,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .where(drizzleOrm.eq(seeds.localId, resolvedSeedLocalId))
             .limit(1);
         if (versionRecords.length === 0) {
-            logger$p(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$q(`No version data found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -6825,7 +6972,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
         // A seed whose versions are all revoked (fully unpublished) has no latest version but still has
         // its last property values; load those like any other item. Only a seed without versions stops here.
         if (!latestVersionLocalId && !versionRecord.versionsCount) {
-            logger$p(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
+            logger$q(`No latest version found for seedLocalId: ${resolvedSeedLocalId}`);
             sendBack({
                 type: 'loadOrCreateItemSuccess',
                 item: {
@@ -6857,7 +7004,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .select()
             .from(metadataLatest)
             .where(drizzleOrm.eq(metadataLatest.rowNum, 1));
-        logger$p(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
+        logger$q(`Found ${metadataRecords.length} latest-per-property metadata rows for seed ${resolvedSeedLocalId} (latestVersionLocalId=${latestVersionLocalId} used for placeholders only)`);
         // Step 4: Create ItemProperty instances from metadata records + placeholders for model schema properties
         // Always call when we have a valid version so placeholders are created for properties without metadata
         const propertyInstances = await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid, modelName, latestVersionLocalId, latestVersionUid, modelScope);
@@ -6890,7 +7037,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
         });
     };
     _loadOrCreateItem().catch((error) => {
-        logger$p(`Error in loadOrCreateItem: ${error}`);
+        logger$q(`Error in loadOrCreateItem: ${error}`);
         sendBack({
             type: 'loadOrCreateItemError',
             error: error instanceof Error ? error.message : String(error),
@@ -6898,7 +7045,7 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
     });
 });
 
-const logger$o = debug('seedSdk:Item:runPublish');
+const logger$p = debug('seedSdk:Item:runPublish');
 const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const { seedLocalId } = context;
     const _runPublish = async () => {
@@ -6914,9 +7061,9 @@ 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-BQr8aMVP.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DsXY9S4U.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BsZWiJ03.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CqlqRdot.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             const uploads = await getPublishUploads(item);
             let uploadedTransactions = [];
@@ -6932,12 +7079,12 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 }
             }
             await getPublishPayload(item, uploadedTransactions);
-            logger$o('runPublish: payload prepared (upload/EAS submit stubbed)');
+            logger$p('runPublish: payload prepared (upload/EAS submit stubbed)');
             sendBack({ type: 'publishSuccess' });
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
-            logger$o('runPublish error:', error);
+            logger$p('runPublish error:', error);
             sendBack({ type: 'publishError', error });
         }
     };
@@ -7212,7 +7359,7 @@ async function getLatestPublishedVersionRow(seedLocalId) {
     return null;
 }
 
-const logger$n = debug('seedSdk:db:read:getItemData');
+const logger$o = debug('seedSdk:db:read:getItemData');
 /**
  * Assemble flat ItemData for Item / liveQuery / draft-head authoring.
  *
@@ -7228,7 +7375,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     if (seedUid && !seedLocalId) {
         const seedData = await getSeedData({ seedUid });
         if (!seedData) {
-            logger$n('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$o('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId || undefined;
@@ -7255,9 +7402,9 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         .from(seeds)
         .where(drizzleOrm.and(...whereClauses))
         .limit(1);
-    logger$n('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
+    logger$o('[getItemData] Seed query result', { rowsCount: seedRows?.length || 0, firstRow: seedRows?.[0] });
     if (!seedRows || seedRows.length === 0) {
-        logger$n('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
+        logger$o('[db/queries] [getItemDataFromDb] no seedRows found', { modelName, seedLocalId, seedUid });
         return;
     }
     const seedRow = seedRows[0];
@@ -7283,7 +7430,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
             }
         }
         catch (error) {
-            logger$n('[getItemData] Error deriving schemaName:', error);
+            logger$o('[getItemData] Error deriving schemaName:', error);
         }
     }
     // Now get version data if it exists - query versions table directly
@@ -7539,8 +7686,9 @@ function isSeedRowOwned(row, ownedAddresses) {
     return publisherIsInOwnedSet(publisher, ownedAddresses);
 }
 /**
- * SQL for `addressFilter: 'owned' | 'watched'`. Empty list → no rows (`1=0`).
- * Compares `lower(publisher)` so checksummed rows match persisted lowercase owned.
+ * SQL for an address list on `publisher`. Empty list → no rows (`1=0`).
+ * Compares `lower(publisher)` so checksummed rows match persisted lowercase addresses.
+ * Used for `addressFilter: 'watched'`; `'owned'` uses {@link ownedSeedsSql}.
  */
 function publisherInAddressListSql(column, addresses) {
     const normalized = normalizeAddressList(addresses);
@@ -7549,6 +7697,30 @@ function publisherInAddressListSql(column, addresses) {
     }
     return drizzleOrm.inArray(drizzleOrm.sql `lower(${column})`, normalized);
 }
+/** SQL form of {@link isPlaceholderUid}: null, `''`, `'NULL'`, or zero bytes32 (trimmed, any case). */
+function placeholderUidSql(column) {
+    return drizzleOrm.or(drizzleOrm.isNull(column), drizzleOrm.eq(column, 'NULL'), drizzleOrm.sql `trim(${column}) = ''`, drizzleOrm.sql `lower(trim(${column})) = ${ZERO_BYTES32.toLowerCase()}`);
+}
+const isBlankSql = (column) => drizzleOrm.or(drizzleOrm.isNull(column), drizzleOrm.eq(column, ''));
+/** SQL form of {@link isLocalUnsealedDraft} on `seeds`. */
+function localUnsealedDraftSql() {
+    return drizzleOrm.and(isBlankSql(seeds.publisher), placeholderUidSql(seeds.uid), isBlankSql(seeds.attestationRaw));
+}
+/**
+ * SQL for `addressFilter: 'owned'`: a row passes exactly when {@link isSeedRowOwned} is true.
+ * - Empty owned → local unsealed drafts (pre-connect authoring), not every row.
+ * - Owned set → `lower(trim(publisher))` in the set, or, when publisher is blank, the
+ *   `attestationRaw.attester` ({@link resolvePublisherFromSeedRow}). `json_valid` guards
+ *   `json_extract`, which throws on malformed JSON.
+ */
+function ownedSeedsSql(ownedAddresses) {
+    const normalized = normalizeAddressList(ownedAddresses);
+    if (normalized.length === 0) {
+        return localUnsealedDraftSql();
+    }
+    const attester = drizzleOrm.sql `CASE WHEN json_valid(${seeds.attestationRaw}) THEN lower(trim(json_extract(${seeds.attestationRaw}, '$.attester'))) END`;
+    return drizzleOrm.or(drizzleOrm.inArray(drizzleOrm.sql `lower(trim(${seeds.publisher}))`, normalized), drizzleOrm.and(isBlankSql(seeds.publisher), drizzleOrm.inArray(attester, normalized)));
+}
 /**
  * Checks if the current user owns the item (publisher is in persisted owned addresses).
  *
@@ -7585,6 +7757,9 @@ var ownership = /*#__PURE__*/Object.freeze({
     isItemOwned: isItemOwned,
     isLocalUnsealedDraft: isLocalUnsealedDraft,
     isSeedRowOwned: isSeedRowOwned,
+    localUnsealedDraftSql: localUnsealedDraftSql,
+    ownedSeedsSql: ownedSeedsSql,
+    placeholderUidSql: placeholderUidSql,
     publisherInAddressListSql: publisherInAddressListSql,
     publisherIsInOwnedSet: publisherIsInOwnedSet,
     resolvePublisherFromSeedRow: resolvePublisherFromSeedRow
@@ -7604,7 +7779,7 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
     const appDb = BaseDb.getAppDb();
     const conditions = [];
     if (!includeEas) {
-        conditions.push(drizzleOrm.or(drizzleOrm.isNull(seeds.uid), drizzleOrm.eq(seeds.uid, ''), drizzleOrm.eq(seeds.uid, 'NULL'), drizzleOrm.eq(seeds.uid, ZERO_BYTES32)));
+        conditions.push(placeholderUidSql(seeds.uid));
     }
     if (modelName) {
         conditions.push(drizzleOrm.eq(seeds.type, casing.toSnakeCase(modelName)));
@@ -7620,7 +7795,7 @@ const getItemsData = async ({ modelName, modelFileId, schemaName, deleted, inclu
     }
     if (addressFilter === 'owned') {
         const ownedAddresses = await getAddressesForItemsFilter('owned');
-        conditions.push(publisherInAddressListSql(seeds.publisher, ownedAddresses));
+        conditions.push(ownedSeedsSql(ownedAddresses));
     }
     else if (addressFilter === 'watched') {
         const watchedAddresses = await getAddressesForItemsFilter('watched');
@@ -7697,12 +7872,12 @@ async function getLatestVersionRow(seedLocalId) {
     return rows[0] ?? null;
 }
 
-const logger$m = debug('seedSdk:ItemProperty:service:actors:waitForDb');
+const logger$n = debug('seedSdk:ItemProperty:service:actors:waitForDb');
 const waitForDb = xstate.fromCallback(({ sendBack }) => {
     // Check immediately first
     const appDb = BaseDb.getAppDb();
     if (appDb) {
-        logger$m('Database is ready (immediate check)');
+        logger$n('Database is ready (immediate check)');
         sendBack({ type: 'waitForDbSuccess' });
         return;
     }
@@ -7714,24 +7889,24 @@ const waitForDb = xstate.fromCallback(({ sendBack }) => {
             const appDb = BaseDb.getAppDb();
             if (appDb) {
                 clearInterval(interval);
-                logger$m('Database is ready (after polling)');
+                logger$n('Database is ready (after polling)');
                 resolve();
             }
             else if (Date.now() - startTime > timeout) {
                 clearInterval(interval);
                 const error = new Error('Database not available after timeout');
-                logger$m(`Database wait timeout: ${error.message}`);
+                logger$n(`Database wait timeout: ${error.message}`);
                 reject(error);
             }
         }, 100);
     });
     _waitForDb
         .then(() => {
-        logger$m('Sending waitForDbSuccess event');
+        logger$n('Sending waitForDbSuccess event');
         sendBack({ type: 'waitForDbSuccess' });
     })
         .catch((error) => {
-        logger$m(`Error waiting for database: ${error}`);
+        logger$n(`Error waiting for database: ${error}`);
         sendBack({ type: 'waitForDbError', error: error.message });
     });
 });
@@ -7883,7 +8058,7 @@ const getRelationValueData = async (propertyValue) => {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> resolveRelatedValue -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$l = debug('seedSdk:property:actors:resolveRelatedValue');
+const logger$m = debug('seedSdk:property:actors:resolveRelatedValue');
 const storageTransactionIdToContentUrl = new Map();
 const refResolvedValueToContentUrl = new Map();
 const seedUidToContentUrl = new Map();
@@ -7891,14 +8066,14 @@ 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-nA5PxBSs.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
         if (Array.isArray(propertyValue)) {
             // TODO: Handle array of seedUids
-            logger$l(`${propertyName} value is an array of seedUids`);
+            logger$m(`${propertyName} value is an array of seedUids`);
             return;
         }
         if (typeof propertyValue === 'object') {
@@ -7910,7 +8085,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
             parsedValue = JSON.parse(relationKey);
         }
         catch (error) {
-            logger$l(`${propertyName} value is not a JSON string.`);
+            logger$m(`${propertyName} value is not a JSON string.`);
         }
         if (!parsedValue && seedUidToContentUrl.has(relationKey)) {
             const contentUrl = seedUidToContentUrl.get(relationKey);
@@ -7925,7 +8100,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
             return true;
         }
         if (Array.isArray(parsedValue)) {
-            logger$l(`${propertyName} value is a stringified array of seedUids`);
+            logger$m(`${propertyName} value is a stringified array of seedUids`);
             return;
         }
         const storageTransactionId = await getStorageTransactionIdForSeedUid(relationKey);
@@ -8374,7 +8549,7 @@ async function readHtmlBodyForStorageSeedPropertyValue(propertyValue) {
 
 // Dynamic import to break circular dependency: schema/index -> ... -> hydrateFromDb -> schema/index
 // import { ModelPropertyDataTypes } from '@/schema'
-const logger$k = debug('seedSdk:property:actors:hydrateFromDb');
+const logger$l = debug('seedSdk:property:actors:hydrateFromDb');
 const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const { seedUid, seedLocalId, propertyName: propertyNameRaw, propertyRecordSchema, modelName, } = context;
     if (!propertyNameRaw) {
@@ -8385,7 +8560,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-nA5PxBSs.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -8491,7 +8666,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                     }
                 }
                 catch (e) {
-                    logger$k('[hydrateFromDb] Image file resolution error', e);
+                    logger$l('[hydrateFromDb] Image file resolution error', e);
                 }
             }
         }
@@ -8522,7 +8697,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                 }
             }
             catch (e) {
-                logger$k('[hydrateFromDb] File resolution error', e);
+                logger$l('[hydrateFromDb] File resolution error', e);
             }
         }
         if (propertyRecordSchema &&
@@ -8625,11 +8800,11 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     });
 });
 
-const logger$j = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
+const logger$k = debug('seedSdk:itemProperty:actors:loadOrCreateProperty');
 const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateProperty = async () => {
         const { seedLocalId, seedUid, propertyName, versionLocalId } = context;
-        logger$j(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
+        logger$k(`loadOrCreateProperty called for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
         }
@@ -8681,15 +8856,15 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         const schemas = modelPropertiesToObject(model$1.properties);
                         propertyRecordSchema = schemas[propertyName];
                         if (propertyRecordSchema) {
-                            logger$j(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                            logger$k(`Metadata not found: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                         }
                     }
                 }
                 catch (error) {
-                    logger$j(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
+                    logger$k(`Metadata not found: Model fallback failed for propertyName "${propertyName}": ${error}`);
                 }
             }
-            logger$j(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            logger$k(`Metadata not found in database for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             sendBack({
                 type: 'loadOrCreatePropertySuccess',
                 property: {
@@ -8762,7 +8937,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-xMwPhQ5N.js'); });
+                            const { getPropertySchema } = await Promise.resolve().then(function () { return require('./property-fa0iju0J.js'); });
                             let schemaFromFile = await getPropertySchema(normalizedModelName, propertyName, {
                                 modelFileId: modelRecord?.schemaFileId ?? modelFileId,
                             });
@@ -8802,7 +8977,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (error) {
-                logger$j(`Error loading propertyRecordSchema from database: ${error}`);
+                logger$k(`Error loading propertyRecordSchema from database: ${error}`);
                 // Continue without propertyRecordSchema
             }
         }
@@ -8820,12 +8995,12 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                     const schemas = modelPropertiesToObject(model$1.properties);
                     propertyRecordSchema = schemas[propertyName];
                     if (propertyRecordSchema) {
-                        logger$j(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                        logger$k(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
                     }
                 }
             }
             catch (error) {
-                logger$j(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+                logger$k(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
             }
         }
         // For Html: read file content for renderValue (propertyValue is seed ID; blob URLs in DB are invalid after reload)
@@ -8866,7 +9041,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (e) {
-                logger$j(`Failed to read Html file for ${propertyName}: ${e}`);
+                logger$k(`Failed to read Html file for ${propertyName}: ${e}`);
             }
         }
         // Covers missing ref row, wrong ref, or DB dataType casing "html" (handled by isHtml above).
@@ -8924,7 +9099,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                         });
                     }
                     catch (e) {
-                        logger$j(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
+                        logger$k(`loadOrCreateProperty: updateMetadata refResolvedValue failed for ${propertyName}:`, e);
                     }
                 }
             }
@@ -8946,7 +9121,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (e) {
-                logger$j(`Failed to resolve Image file for ${propertyName}: ${e}`);
+                logger$k(`Failed to resolve Image file for ${propertyName}: ${e}`);
             }
         }
         const isFile = refSeedType === 'file' ||
@@ -8964,7 +9139,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 }
             }
             catch (e) {
-                logger$j(`Failed to resolve File for ${propertyName}: ${e}`);
+                logger$k(`Failed to resolve File for ${propertyName}: ${e}`);
             }
         }
         let propertyValueOut = metadataRecord.propertyValue || undefined;
@@ -8997,7 +9172,7 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
         });
     };
     _loadOrCreateProperty().catch((error) => {
-        logger$j(`Error in loadOrCreateProperty: ${error}`);
+        logger$k(`Error in loadOrCreateProperty: ${error}`);
         sendBack({
             type: 'loadOrCreatePropertyError',
             error: error instanceof Error ? error.message : String(error),
@@ -9027,10 +9202,10 @@ const getVersionData = async ({ localId, seedLocalId, uid, }) => {
     return queryRows[0];
 };
 
-const logger$i = debug('seedSdk:write:updateItemPropertyValue');
+const logger$j = debug('seedSdk:write:updateItemPropertyValue');
 const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, localStorageDir, dataType, refValueType, }) => {
     if (!localIdParam && !seedLocalId) {
-        logger$i(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
+        logger$j(`[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`);
         return;
     }
     // Every write below binds parameters: store the value as given (no SQL escaping).
@@ -9082,7 +9257,7 @@ const updateItemPropertyValue = async ({ localId: localIdParam, propertyName, ne
             modelType === modelName?.toLowerCase() &&
             refSeedTypeFromDb === refSeedType &&
             refResolvedValueFromDb === refResolvedValue) {
-            logger$i(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
+            logger$j(`[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`);
             return;
         }
         // This means we already have a local-only record so we should just update that one
@@ -9183,9 +9358,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-nA5PxBSs.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CKNW1bKg.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -9446,7 +9621,11 @@ function waitForTurn(previous, name, timeoutMs) {
     return Promise.race([previous, timedOut]).finally(() => clearTimeout(timer));
 }
 
-const logger$h = debug('seedSdk:helpers:tabCoordinator');
+const logger$i = debug('seedSdk:helpers:tabCoordinator');
+/** Identifies this tab (this page's SDK instance) in the messages it sends. */
+const TAB_ID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+    ? crypto.randomUUID()
+    : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 let state;
 let leader = false;
 let leaderWaiters = [];
@@ -9465,6 +9644,10 @@ function startTabCoordination({ filesDir, mode = 'coordinate' }) {
     }
     const channel = new BroadcastChannel(`seed:tabs:${dbKey}`);
     channel.onmessage = (event) => {
+        // A BroadcastChannel never hears itself, but another channel object in this page would (a
+        // second channel opened by a test, or the same module loaded twice): skip our own messages.
+        if (event.data?.from === TAB_ID)
+            return;
         for (const handler of messageHandlers)
             handler(event.data);
     };
@@ -9485,7 +9668,7 @@ function becomeLeader() {
     if (leader)
         return;
     leader = true;
-    logger$h(`this tab leads ${state?.dbKey}`);
+    logger$i(`this tab leads ${state?.dbKey}`);
     const waiters = leaderWaiters;
     leaderWaiters = [];
     for (const resolve of waiters)
@@ -9502,7 +9685,7 @@ function whenLeaderTab() {
 }
 /** Sends to the other tabs of this database; a no-op when not coordinating. */
 function postTabMessage(message) {
-    state?.channel?.postMessage(message);
+    state?.channel?.postMessage({ ...message, from: TAB_ID });
 }
 function onTabMessage(handler) {
     messageHandlers.add(handler);
@@ -9513,7 +9696,7 @@ function withDbTabLock(scope, fn, options) {
     return state ? withTabLock(`seed:${scope}:${state.dbKey}`, fn, options) : fn();
 }
 
-const logger$g = debug('seedSdk:helpers:tabEvents');
+const logger$h = debug('seedSdk:helpers:tabEvents');
 /**
  * Keeps other tabs current (docs/MULTI_TAB.md). The event bus is per tab, so events that mean "the
  * shared database or OPFS changed" are also posted to the other tabs, which refresh their caches
@@ -9533,12 +9716,11 @@ function emitAcrossTabs(name, payload) {
     postTabMessage({ type: 'event', name, payload });
 }
 /**
- * A file saved through this tab's file system: emits `file-saved` here (as before) and tells other
- * tabs, whose caches don't see it.
+ * A file saved through this tab's file system: emits `file-saved` here. Other tabs hear about it
+ * from the file system itself (see queueFilesChangedNotice), once the write has reached OPFS.
  */
 function notifyFileSaved(filePath) {
     eventEmitter.emit('file-saved', filePath);
-    postTabMessage({ type: 'files-changed', paths: [filePath] });
 }
 /** Refreshes this tab's in-memory state for an event another tab emitted, before re-emitting it. */
 async function catchUpOn(name, payload) {
@@ -9566,7 +9748,7 @@ function listenForOtherTabsEvents() {
     onTabMessage((message) => {
         if (message.type === 'event' && RELAYED_EVENTS.has(message.name)) {
             void catchUpOn(message.name, message.payload)
-                .catch((error) => logger$g(`catching up on ${message.name} failed`, error))
+                .catch((error) => logger$h(`catching up on ${message.name} failed`, error))
                 .then(() => {
                 if (message.payload === undefined) {
                     eventEmitter.emit(message.name);
@@ -9577,8 +9759,9 @@ function listenForOtherTabsEvents() {
             });
         }
         else if (message.type === 'files-changed') {
+            // Only refreshes caches: never writes, so never sends files-changed back.
             void BaseFileManager.invalidateCachedPaths(message.paths)
-                .catch((error) => logger$g('refreshing changed files failed', error))
+                .catch((error) => logger$h('refreshing changed files failed', error))
                 .then(() => eventEmitter.emit(FILES_CHANGED_EVENT, message.paths));
         }
     });
@@ -9717,7 +9900,7 @@ const createMetadata = async (metadataValues, propertyRecordSchema, options) =>
         propertyRecordSchema?.validation &&
         metadataValues.propertyValue != null &&
         metadataValues.propertyValue !== '') {
-        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CKNW1bKg.js'); });
+        const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CSXxx7sQ.js'); });
         const validationService = new SchemaValidationService();
         const validationResult = validationService.validatePropertyValue(metadataValues.propertyValue, normalizeDataType(propertyRecordSchema.dataType), propertyRecordSchema.validation, propertyRecordSchema.refValueType
             ? normalizeDataType(String(propertyRecordSchema.refValueType))
@@ -10299,7 +10482,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-nA5PxBSs.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -10390,6 +10573,86 @@ const getItemPropertyData = async (props) => {
     return queryRows[0];
 };
 
+/** Absolute path of the file {@link writeItemStorageFile} writes for `target`. */
+const getItemStorageFilePath = (target) => BaseFileManager.getFilesPath(getItemStorageSubdir(target.localStorageDir), target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix));
+/**
+ * Write an ItemStorage property's content to its local file, where saveItemStorage, reads, publish
+ * (resolveItemStorageChildFile) and download all look for it. Returns what the metadata row records:
+ * `refResolvedValue` (the file name) and `localStorageDir` (with a leading slash).
+ *
+ * Callers that also update the file's metadata row hold {@link withItemStorageFileLock} around
+ * both, so another writer of the same file can't land in between.
+ */
+const writeItemStorageFile = async (target, content) => {
+    const dir = getItemStorageSubdir(target.localStorageDir);
+    const fileName = target.fileName || getItemStorageLocalFileName(target.seedId, target.filenameSuffix);
+    await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
+    const filePath = BaseFileManager.getFilesPath(dir, fileName);
+    await BaseFileManager.saveFile(filePath, content);
+    return { fileName, filePath, localStorageDir: target.localStorageDir || `/${dir}` };
+};
+/**
+ * Lock name for one ItemStorage file: `seed:item-storage:<absolute file path>`. The path starts
+ * with the files root, which also names the database (`<filesDir>/db/seed.db`), so the name is
+ * per database as well as per file.
+ */
+const itemStorageFileLockName = (filePath) => `seed:item-storage:${filePath}`;
+/**
+ * Runs `fn` holding the lock of one ItemStorage file, across tabs (Web Locks) and within this JS
+ * realm (an in-process queue where Web Locks are missing, e.g. Node < 24.5; see `withTabLock`).
+ *
+ * Writers of a local draft's file (saveItemStorage, convertVerbatimItemStorageRow, createNewItem)
+ * hold it across "read the row → write the file → update the row", so the file and the row end
+ * with the same writer's content. See docs/MULTI_TAB.md.
+ *
+ * Lock ordering: this lock is always the innermost. It may be taken while holding a broader lock
+ * (`seed:item-storage-migration:<db>`, `seed:publish:<seedLocalId>`), never the other way round,
+ * and no other lock (nor a second file lock) is requested while it is held. Keep the section to
+ * local DB and file I/O: no network. Not re-entrant.
+ */
+function withItemStorageFileLock(filePath, fn) {
+    return withTabLock(itemStorageFileLockName(filePath), fn);
+}
+/** Lock attempts before giving up when the row's target file keeps changing under us. */
+const ROW_LOCK_ATTEMPTS = 3;
+const readRow = async (localId) => {
+    const rows = await BaseDb.getAppDb()
+        .select()
+        .from(metadata$1)
+        .where(drizzleOrm.eq(metadata$1.localId, localId))
+        .limit(1);
+    return rows[0];
+};
+/**
+ * Runs `fn` with a fresh read of metadata row `localId`, holding the lock of the file that row's
+ * content goes to. `fileOf` names that file (absolute path) for a row, or returns undefined when
+ * there is nothing to write (then `fn` isn't called and the result is undefined).
+ *
+ * The file depends on the row, so the row is read once to pick the lock and again once it is held;
+ * if the row now points at another file (another writer changed it meanwhile), the lock is
+ * released and taken again for that file.
+ */
+async function withLockedItemStorageRow(localId, fileOf, fn) {
+    for (let attempt = 0; attempt < ROW_LOCK_ATTEMPTS; attempt++) {
+        const row = await readRow(localId);
+        const filePath = row && fileOf(row);
+        if (!filePath)
+            return undefined;
+        const outcome = await withItemStorageFileLock(filePath, async () => {
+            const fresh = await readRow(localId);
+            const freshPath = fresh && fileOf(fresh);
+            if (!freshPath)
+                return { done: true, value: undefined };
+            if (freshPath !== filePath)
+                return { done: false };
+            return { done: true, value: await fn(fresh, filePath) };
+        });
+        if (outcome.done)
+            return outcome.value;
+    }
+    throw new Error(`ItemStorage file of metadata row ${localId} kept changing; not written`);
+}
+
 /** A local edit: no attestation uid of its own and not derived from one. */
 const isLocalDraft = (row) => !row.uid && row.derivedFromUid == null;
 const saveItemStorage = xstate.fromCallback(({ sendBack, input: { context, event } }) => {
@@ -10443,22 +10706,25 @@ const saveItemStorage = xstate.fromCallback(({ sendBack, input: { context, event
             const latest = [...queryRows].sort(compareMetadataRowsLatestFirst)[0];
             propertyData = latest && isLocalDraft(latest) ? latest : undefined;
             if (!propertyData && newValue) {
-                const filename = `${draftSeedUid || draftSeedLocalId}${propertyRecordSchema.filenameSuffix}`;
-                const dir = propertyRecordSchema.localStorageDir?.replace(/^\//, '') || 'files';
-                await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
-                const writeToPath = BaseFileManager.getFilesPath(dir, filename);
-                await BaseFileManager.saveFile(writeToPath, newValue);
-                propertyData = await createMetadata({
-                    propertyName,
-                    propertyValue: filename,
-                    modelType: (modelName ?? knownRow?.modelType ?? '').toLowerCase() || undefined,
-                    seedLocalId: draftSeedLocalId,
-                    seedUid: draftSeedUid,
-                    versionLocalId,
-                    versionUid,
+                const target = {
+                    seedId: draftSeedUid || draftSeedLocalId,
                     localStorageDir: propertyRecordSchema.localStorageDir,
-                    refValueType: 'file',
-                }, propertyRecordSchema);
+                    filenameSuffix: propertyRecordSchema.filenameSuffix,
+                };
+                propertyData = await withItemStorageFileLock(getItemStorageFilePath(target), async () => {
+                    const { fileName: filename } = await writeItemStorageFile(target, newValue);
+                    return createMetadata({
+                        propertyName,
+                        propertyValue: filename,
+                        modelType: (modelName ?? knownRow?.modelType ?? '').toLowerCase() || undefined,
+                        seedLocalId: draftSeedLocalId,
+                        seedUid: draftSeedUid,
+                        versionLocalId,
+                        versionUid,
+                        localStorageDir: propertyRecordSchema.localStorageDir,
+                        refValueType: 'file',
+                    }, propertyRecordSchema);
+                });
             }
         }
         else if (propertyData && !isLocalDraft(propertyData)) {
@@ -10467,31 +10733,64 @@ const saveItemStorage = xstate.fromCallback(({ sendBack, input: { context, event
         if (!propertyData) {
             throw new Error(`No metadata row to save ${propertyName} to`);
         }
-        const localStorageDir = propertyRecordSchema.localStorageDir || propertyData.localStorageDir;
-        const fileName = propertyData.refResolvedValue ||
-            `${propertyData.seedUid || propertyData.seedLocalId}${propertyRecordSchema.filenameSuffix}`;
-        if (!localStorageDir || !fileName) {
-            throw new Error(`Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`);
-        }
-        const dir = localStorageDir.replace(/^\//, '');
-        await BaseFileManager.createDirIfNotExists(BaseFileManager.getFilesPath(dir));
-        const filePath = BaseFileManager.getFilesPath(dir, fileName);
-        try {
-            await BaseFileManager.saveFile(filePath, newValue);
-        }
-        catch (error) {
-            const fs = await BaseFileManager.getFs();
-            fs.writeFileSync(filePath, newValue);
-        }
-        await appDb
-            .update(metadata$1)
-            .set({
-            refResolvedValue: fileName,
-        })
-            .where(drizzleOrm.eq(metadata$1.localId, propertyData.localId));
+        // No storage.path: the `files` directory, as resolveItemStorageChildFile and download assume.
+        const localStorageDirOf = (row) => propertyRecordSchema.localStorageDir || row.localStorageDir || '/files';
+        const fileNameOf = (row) => {
+            if (row.refResolvedValue)
+                return row.refResolvedValue;
+            const seedId = row.seedUid || row.seedLocalId;
+            return seedId ? getItemStorageLocalFileName(seedId, propertyRecordSchema.filenameSuffix) : undefined;
+        };
+        if (!fileNameOf(propertyData)) {
+            throw new Error(`Missing a seed id to name the ${propertyName} file after`);
+        }
+        // Read the row, write the file and update the row under the file's lock, so a conversion of a
+        // legacy row (migration, publish) or another save of this file, in this tab or another, can't
+        // land in between and leave the file with older content than the row says.
+        const saved = await withLockedItemStorageRow(propertyData.localId, (row) => {
+            const fileName = fileNameOf(row);
+            return fileName && BaseFileManager.getFilesPath(getItemStorageSubdir(localStorageDirOf(row)), fileName);
+        }, async (row, filePath) => {
+            const localStorageDir = localStorageDirOf(row);
+            const fileName = fileNameOf(row);
+            try {
+                await writeItemStorageFile({ seedId: row.seedUid || row.seedLocalId || '', localStorageDir, fileName }, newValue);
+            }
+            catch (error) {
+                const fs = await BaseFileManager.getFs();
+                fs.writeFileSync(filePath, newValue);
+            }
+            // A legacy row (made before Item.create saved ItemStorage values) holds the old content itself
+            // in propertyValue. The file is the content now: drop it, or a fresh load shows the old text
+            // until the file is read. A row whose propertyValue is the file name keeps it.
+            const clearsVerbatimValue = !row.refResolvedValue &&
+                row.propertyValue != null &&
+                row.propertyValue !== '' &&
+                row.propertyValue !== fileName;
+            // The row says where the file is (read back by hydration, the browser's metadata live query
+            // and publish); without localStorageDir the live query would clear it from the context.
+            await appDb
+                .update(metadata$1)
+                .set({
+                refResolvedValue: fileName,
+                localStorageDir,
+                // Same shape as a row the migration or publish converted (convertVerbatimItemStorageRow).
+                ...(clearsVerbatimValue && { propertyValue: null, refValueType: 'file' }),
+            })
+                .where(drizzleOrm.eq(metadata$1.localId, row.localId));
+            return { fileName, localStorageDir };
+        });
+        // The row went away (or lost its seed ids) before the lock was granted.
+        if (!saved)
+            throw new Error(`No metadata row to save ${propertyName} to`);
+        const { fileName, localStorageDir } = saved;
         sendBack({
             type: 'updateContext',
             renderValue: newValue,
+            // Where the file is, right away: localStoragePath (and so publish uploads) must not wait for
+            // the browser's metadata live query, which Node does not have at all.
+            refResolvedValue: fileName,
+            localStorageDir,
             // Point the property at the draft row when the edit moved off a published row.
             ...(propertyData.localId !== localId && { localId: propertyData.localId }),
         });
@@ -11150,7 +11449,7 @@ hints = {}) => {
 };
 /** Convert modelType (snake_case from DB) to Model name (PascalCase). startCase adds spaces ("Test Post"); Model names are "TestPost". */
 const modelTypeToModelName = (modelType) => modelType ? lodashEs.upperFirst(lodashEs.camelCase(modelType)) : '';
-const logger$f = debug('seedSdk:property:class');
+const logger$g = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
 const TRACKED_PROPERTIES$2 = [
@@ -11242,7 +11541,7 @@ class ItemProperty {
                         serviceInput.propertyValue = JSON.parse(propertyValue);
                     }
                     catch (e) {
-                        logger$f('List property value is not JSON', e);
+                        logger$g('List property value is not JSON', e);
                     }
                 }
             }
@@ -11265,7 +11564,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-nA5PxBSs.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-BHaWOwNF.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -11359,7 +11658,7 @@ class ItemProperty {
                     }
                 }
                 catch (e) {
-                    logger$f(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    logger$g(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
                     renderValue = isHtml ? undefined : 'No file found';
                 }
             }
@@ -12425,13 +12724,38 @@ const createNewItem = async ({ modelName, modelFileId, ...propertyData }) => {
     for (const propertyName of allPropertyNames) {
         const propertyValue = propertyData[propertyName];
         const propertyRecordSchema = propertySchemas?.[propertyName];
-        await createMetadata({
+        // ItemStorage content lives in the property's file (`<seedLocalId><extension>`), as a save puts
+        // it; the row records where. Stored verbatim in the row, publish would never upload it.
+        const isItemStorageValue = propertyRecordSchema?.storageType === 'ItemStorage' &&
+            propertyValue != null &&
+            propertyValue !== '';
+        const insertRow = (storageFields) => createMetadata({
             seedLocalId: newSeedId,
             versionLocalId: newVersionId,
             propertyName,
-            propertyValue,
+            propertyValue: storageFields ? undefined : propertyValue,
+            ...storageFields,
             modelName,
         }, propertyRecordSchema, { skipValidation: true, modelFileId });
+        if (!isItemStorageValue) {
+            await insertRow();
+            continue;
+        }
+        // File and row under the file's lock, like every writer of a local draft's file (see
+        // withItemStorageFileLock). The seed is new, so nothing else should be writing it yet.
+        const target = {
+            seedId: newSeedId,
+            localStorageDir: propertyRecordSchema.localStorageDir,
+            filenameSuffix: propertyRecordSchema.filenameSuffix,
+        };
+        await withItemStorageFileLock(getItemStorageFilePath(target), async () => {
+            const written = await writeItemStorageFile(target, propertyValue);
+            await insertRow({
+                refResolvedValue: written.fileName,
+                localStorageDir: written.localStorageDir,
+                refValueType: 'file',
+            });
+        });
     }
     return {
         modelName,
@@ -12593,10 +12917,16 @@ const getModel = () => {
 };
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
-/** Raw File/Image/Html content (not already a storage seed reference) needs ItemProperty.save(). */
-function needsStorageSavePipeline(dataType, value) {
+/**
+ * Initial values that need ItemProperty.save() rather than a verbatim metadata row: raw File/Image/Html
+ * content (not already a storage seed reference) becomes a storage seed, and an ItemStorage property's
+ * content goes into its file (`<seedLocalId><extension>`), where publish and reads look for it.
+ */
+function needsStorageSavePipeline(dataType, value, storageType) {
     if (value == null || value === '')
         return false;
+    if (storageType === 'ItemStorage')
+        return true;
     const isStorageType = isDataType(dataType, exports.ModelPropertyDataTypes.File) ||
         isDataType(dataType, exports.ModelPropertyDataTypes.Image) ||
         isDataType(dataType, exports.ModelPropertyDataTypes.Html);
@@ -12709,12 +13039,12 @@ class Item {
         };
         this.getPublishUploads = async (options) => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-BQr8aMVP.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DsXY9S4U.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-BsZWiJ03.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CqlqRdot.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions, options);
         };
@@ -13244,6 +13574,7 @@ class Item {
         // Get property names directly from database to make Item independent from Model
         let propertyNames = [];
         const dataTypeByPropertyName = new Map();
+        const storageTypeByPropertyName = new Map();
         const db = BaseDb.getAppDb();
         if (db && props.modelName) {
             // Model names are only unique per schema: resolve the exact models row from the most specific scope.
@@ -13273,13 +13604,19 @@ class Item {
             }
             if (modelRecords.length > 0 && modelRecords[0].id) {
                 const propertyRecords = await db
-                    .select({ name: properties.name, dataType: properties.dataType })
+                    .select({
+                    name: properties.name,
+                    dataType: properties.dataType,
+                    storageType: properties.storageType,
+                })
                     .from(properties)
                     .where(drizzleOrm.eq(properties.modelId, modelRecords[0].id));
                 propertyNames = propertyRecords.map((r) => r.name).filter((name) => Boolean(name));
                 for (const r of propertyRecords) {
                     if (r.name && r.dataType)
                         dataTypeByPropertyName.set(r.name, r.dataType);
+                    if (r.name && r.storageType)
+                        storageTypeByPropertyName.set(r.name, r.storageType);
                 }
             }
         }
@@ -13288,7 +13625,8 @@ class Item {
             modelFileId: props.modelFileId,
         };
         // File/Image/Html values that are raw content (html string, data URI, URL, File) must go through
-        // the property's save pipeline to become storage seeds; createNewItem would store them verbatim.
+        // the property's save pipeline to become storage seeds, and ItemStorage values to be written to
+        // their file with the property context pointing at it (as `prop.value = v; await prop.save()`).
         const pipelineValues = [];
         // Only include properties that are in the model schema
         // Exclude modelInstance, modelName, and schemaName as they're metadata, not item properties
@@ -13298,7 +13636,7 @@ class Item {
                 continue;
             }
             if (propertyNames.length === 0 || propertyNames.includes(key)) {
-                if (needsStorageSavePipeline(dataTypeByPropertyName.get(key), value)) {
+                if (needsStorageSavePipeline(dataTypeByPropertyName.get(key), value, storageTypeByPropertyName.get(key))) {
                     pipelineValues.push([key, value]);
                     continue;
                 }
@@ -13430,7 +13768,7 @@ class Item {
         return proxiedInstance;
     }
     /**
-     * Run each File/Image/Html initial value through its ItemProperty save pipeline (sequentially, to
+     * Run each File/Image/Html/ItemStorage initial value through its ItemProperty save pipeline (sequentially, to
      * avoid SQLite write contention). Rejects on the first failure; the item itself has been created.
      */
     static async savePipelineValues(item, pipelineValues, timeout) {
@@ -14520,7 +14858,7 @@ const runEasSync = xstate.fromPromise(async ({ input, }) => {
         requestPayload: input.requestPayload,
         persistedSnapshot: input.runningSnapshot,
     });
-    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-DqRhV8o2.js'); });
+    const { runSyncFromEas } = await Promise.resolve().then(function () { return require('./syncDbWithEas-CrmxxmUW.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.
@@ -14696,7 +15034,7 @@ function newCorrelationId() {
     return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
 /** Requests deferred in this tab until it leads, by source; each runs once on takeover. */
-const deferredUntilLeader = new Set();
+const deferredUntilLeader$1 = new Set();
 /**
  * Automatic syncs run in the leader tab only (docs/MULTI_TAB.md). A tab that skips one runs it if
  * it later becomes leader, so closing the leader doesn't lose the catch-up sync.
@@ -14707,11 +15045,11 @@ function runInLeaderTab(source, request) {
         return;
     }
     log(`${source} sync skipped: another tab leads`);
-    if (deferredUntilLeader.has(source))
+    if (deferredUntilLeader$1.has(source))
         return;
-    deferredUntilLeader.add(source);
+    deferredUntilLeader$1.add(source);
     void whenLeaderTab().then(() => {
-        deferredUntilLeader.delete(source);
+        deferredUntilLeader$1.delete(source);
         request();
     });
 }
@@ -14785,10 +15123,10 @@ var easSyncManager = /*#__PURE__*/Object.freeze({
     startEasSyncActor: startEasSyncActor
 });
 
-const logger$e = debug('seedSdk:services:events');
+const logger$f = debug('seedSdk:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger$e(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$f(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
     // TODO: This is called from Node as well. Do we need it? If so, need to generalize this to all platforms.
     // localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state))
 };
@@ -14897,9 +15235,9 @@ function normalizeSeedConfigEndpoints(config) {
     return { ...config, endpoints: next };
 }
 
-const logger$d = debug('seedSdk:ClientManager:initialize');
+const logger$e = debug('seedSdk:ClientManager:initialize');
 const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, event } }) => {
-    logger$d('initialize from ClientManager');
+    logger$e('initialize from ClientManager');
     const { isInitialized } = context;
     if (!event || !('options' in event)) {
         throw new Error('Initialize event must include options');
@@ -15071,7 +15409,7 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
     };
 });
 
-const logger$c = debug('seedSdk:client:writeToDb');
+const logger$d = debug('seedSdk:client:writeToDb');
 const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) => {
     const _saveAppState = async () => {
         try {
@@ -15079,7 +15417,7 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$c('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
+                    logger$d('[client/actors] [saveAppState] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -15095,13 +15433,13 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
                     value: JSON.stringify(value),
                 },
             });
-            logger$c('result', result);
+            logger$d('result', result);
         }
         catch (error) {
-            logger$c('[client/actors] [saveAppState] Error saving app state:', error);
+            logger$d('[client/actors] [saveAppState] Error saving app state:', error);
             // In test environments, continue anyway
             if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                logger$c('[client/actors] [saveAppState] Continuing despite error in test environment');
+                logger$d('[client/actors] [saveAppState] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -15116,10 +15454,10 @@ const saveAppState = xstate.fromCallback(({ sendBack, input: { key, value } }) =
         });
     })
         .catch((error) => {
-        logger$c('[client/actors] [saveAppState] Error in promise chain:', error);
+        logger$d('[client/actors] [saveAppState] Error in promise chain:', error);
         // In test environments, still send success to allow state machine to progress
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$c('[client/actors] [saveAppState] Sending success despite error in test environment');
+            logger$d('[client/actors] [saveAppState] Sending success despite error in test environment');
             sendBack({
                 type: 'saveAppStateSuccess',
                 key,
@@ -15189,7 +15527,7 @@ const fileSystemInit = xstate.fromCallback(({ sendBack, input: { context }, }) =
     };
 });
 
-const logger$b = debug('seedSdk:client:actors:dbInit');
+const logger$c = debug('seedSdk:client:actors:dbInit');
 const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _dbInit = async () => {
         const { filesDir } = context;
@@ -15203,14 +15541,14 @@ const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
         if (!appDb) {
             throw new Error('Database not available after preparation');
         }
-        logger$b('[client/actors] [dbInit] Database prepared and ready');
+        logger$c('[client/actors] [dbInit] Database prepared and ready');
     };
     _dbInit()
         .then(() => {
         sendBack({ type: ClientManagerEvents.DB_READY });
     })
         .catch((error) => {
-        logger$b('Error in dbInit:', error);
+        logger$c('Error in dbInit:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error))
@@ -15218,7 +15556,7 @@ const dbInit = xstate.fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$a = debug('seedSdk:client:actors:addModelsToStore');
+const logger$b = debug('seedSdk:client:actors:addModelsToStore');
 const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _addModelsToStore = async () => {
         let { models } = context;
@@ -15232,7 +15570,7 @@ const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } })
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [key] of Object.entries(allModels)) {
-            logger$a('model available:', key);
+            logger$b('model available:', key);
         }
     };
     _addModelsToStore()
@@ -15240,7 +15578,7 @@ const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } })
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_STORE_SUCCESS });
     })
         .catch((error) => {
-        logger$a('[client/actors] [addModelsToStore] Error:', error);
+        logger$b('[client/actors] [addModelsToStore] Error:', error);
         sendBack({
             type: 'error',
             error: error instanceof Error ? error : new Error(String(error)),
@@ -15248,7 +15586,7 @@ const addModelsToStore = xstate.fromCallback(({ sendBack, input: { context } })
     });
 });
 
-const logger$9 = debug('seedSdk:client:actors:addModelsToDb');
+const logger$a = debug('seedSdk:client:actors:addModelsToDb');
 /**
  * Returns every `models` row named in `modelNames`, inserting a null-schemaFileId stub for each name
  * with no row yet (the schema import adopts stubs via findOrCreateModelRecord). Check-then-insert:
@@ -15271,7 +15609,7 @@ async function ensureModelStubs(appDb, modelNames, filesDir) {
                 .returning({ id: models$1.id, name: models$1.name, schemaFileId: models$1.schemaFileId }));
             rows.push(...newlyInserted);
             for (const name of modelsToInsert) {
-                logger$9('[client/actors] [addModelsToDb] inserted model:', name);
+                logger$a('[client/actors] [addModelsToDb] inserted model:', name);
             }
         }
         return rows;
@@ -15308,7 +15646,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
         for (const modelName of modelNames) {
             const foundModel = rowFor(modelName);
             if (!foundModel) {
-                logger$9('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
+                logger$a('[client/actors] [addModelsToDb] Warning: Could not find or create model:', modelName);
                 hasModelsInDb = false;
                 continue;
             }
@@ -15320,7 +15658,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
         }
         // If we have no models to process, still send success (empty models is valid)
         if (schemaDefsByModelName.size === 0) {
-            logger$9('[client/actors] [addModelsToDb] No models to process, but continuing');
+            logger$a('[client/actors] [addModelsToDb] No models to process, but continuing');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
             return;
         }
@@ -15363,15 +15701,15 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
                     requestEasSyncFromModelsInit();
                 }
                 else {
-                    logger$9('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
+                    logger$a('[client/actors] [addModelsToDb] No schemas found from EAS, but continuing');
                 }
             }
             catch (error) {
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$9('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
+                    logger$a('[client/actors] [addModelsToDb] Warning: Could not fetch schemas from EAS (background):', error.message);
                 }
                 else {
-                    logger$9('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
+                    logger$a('[client/actors] [addModelsToDb] Error fetching schemas (background):', error.message);
                 }
             }
         };
@@ -15383,10 +15721,10 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
         sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
     })
         .catch((error) => {
-        logger$9('[client/actors] [addModelsToDb] Error:', error);
+        logger$a('[client/actors] [addModelsToDb] Error:', error);
         // In test environments, still send success to allow initialization to complete
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$9('[client/actors] [addModelsToDb] Continuing despite error in test environment');
+            logger$a('[client/actors] [addModelsToDb] Continuing despite error in test environment');
             sendBack({ type: ClientManagerEvents.ADD_MODELS_TO_DB_SUCCESS });
         }
         else {
@@ -15399,7 +15737,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     return () => { };
 });
 
-const logger$8 = debug('seedSdk:helpers:localDbChain');
+const logger$9 = debug('seedSdk:helpers:localDbChain');
 /** appState key recording which EAS chain the local database holds attestations from. */
 const EAS_CHAIN_ID_APP_STATE_KEY = 'easChainId';
 /**
@@ -15469,7 +15807,7 @@ async function loadLocalDbChain() {
     const localChainId = await resolveLocalDbChainId(appDb);
     if (localChainId !== undefined) {
         eas.configureEasReadChain('localDb', { chainId: localChainId });
-        logger$8('local DB holds chain %d', localChainId);
+        logger$9('local DB holds chain %d', localChainId);
         return;
     }
     if (eas.isEasReadChainConfigured()) {
@@ -15495,7 +15833,7 @@ async function assertLocalDbChain() {
     eas.configureEasReadChain('localDb', { chainId: localChainId ?? chainId });
 }
 
-const logger$7 = debug('seedSdk:client:actors:saveConfig');
+const logger$8 = debug('seedSdk:client:actors:saveConfig');
 /**
  * Saves the addresses passed to init. Hosts pass `addresses: []` before a wallet connects. In the
  * first (leader) tab that clears stored addresses, as it always has, so drafts made before the
@@ -15515,13 +15853,13 @@ async function persistInitAddresses(appDb, { addresses, ownedAddresses, watchedA
         .onConflictDoUpdate({ target: appState.key, set: { value } });
 }
 const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
-    logger$7('saveConfig starting');
+    logger$8('saveConfig starting');
     const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain, uploadApiBaseUrl, gatewayTransport, gatewayHyperKey, gatewaySidecarHost, gatewaySidecarPort, gatewayProxyBaseUrl, } = context;
     // Validate endpoints - required for proper initialization
     // If endpoints are missing or invalid, initialization should fail
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
         const error = new Error('saveConfig called with invalid endpoints: endpoints must include both filePaths and files');
-        logger$7('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
+        logger$8('[internal/actors] [saveConfig] Invalid endpoints:', { endpoints });
         throw error;
     }
     const _saveConfig = async () => {
@@ -15530,7 +15868,7 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
             if (!appDb) {
                 // In test environments, continue anyway
                 if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                    logger$7('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
+                    logger$8('[internal/actors] [saveConfig] App DB not found, but continuing in test environment');
                     return;
                 }
                 throw new Error('App DB not found');
@@ -15585,10 +15923,10 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
             await loadLocalDbChain();
         }
         catch (error) {
-            logger$7('[internal/actors] [saveConfig] Error saving config:', error);
+            logger$8('[internal/actors] [saveConfig] Error saving config:', error);
             // In test environments, continue anyway
             if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-                logger$7('[internal/actors] [saveConfig] Continuing despite error in test environment');
+                logger$8('[internal/actors] [saveConfig] Continuing despite error in test environment');
                 return;
             }
             throw error;
@@ -15597,14 +15935,14 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
     // Init writes run one tab at a time (docs/MULTI_TAB.md).
     withSeedDbLock('init', context.filesDir, _saveConfig)
         .then(() => {
-        logger$7('[internal/actors] [saveConfig] saveConfig success');
+        logger$8('[internal/actors] [saveConfig] saveConfig success');
         return sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
     })
         .catch((error) => {
-        logger$7('[internal/actors] [saveConfig] Error in saveConfig promise chain:', error);
+        logger$8('[internal/actors] [saveConfig] Error in saveConfig promise chain:', error);
         // In test environments, still send success to allow state machine to progress
         if (process.env.NODE_ENV === 'test' || process.env.IS_SEED_DEV) {
-            logger$7('[internal/actors] [saveConfig] Sending success despite error in test environment');
+            logger$8('[internal/actors] [saveConfig] Sending success despite error in test environment');
             sendBack({ type: ClientManagerEvents.SAVE_CONFIG_SUCCESS });
         }
         else {
@@ -15617,7 +15955,7 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$6 = debug('seedSdk:helpers:schema');
+const logger$7 = debug('seedSdk:helpers:schema');
 /**
  * Sanitize a schema name to be filesystem-safe
  * Replaces all special characters (except alphanumeric, hyphens, underscores) with underscores
@@ -15813,7 +16151,7 @@ async function listCompleteSchemaFiles() {
         const dirExists = await BaseFileManager.pathExists(workingDir);
         if (!dirExists) {
             // Directory doesn't exist yet - return empty array (not an error condition)
-            logger$6(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
+            logger$7(`Working directory does not exist yet: ${workingDir}, returning empty schema list`);
             return [];
         }
         const files = await fs.promises.readdir(workingDir);
@@ -15949,7 +16287,7 @@ async function loadAllSchemasFromDb() {
             }
             catch (error) {
                 // If we can't list schema files (e.g., directory doesn't exist yet), continue without file-based loading
-                logger$6(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`);
+                logger$7(`Error listing complete schema files (continuing with DB data): ${error instanceof Error ? error.message : String(error)}`);
                 completeSchemaFiles = [];
             }
         }
@@ -16002,7 +16340,7 @@ async function loadAllSchemasFromDb() {
                 continue;
             }
             catch (error) {
-                logger$6(`Error parsing schemaData for ${schemaName}:`, error);
+                logger$7(`Error parsing schemaData for ${schemaName}:`, error);
                 // Fall through to file-based loading
             }
         }
@@ -16044,7 +16382,7 @@ async function loadAllSchemasFromDb() {
                     continue;
                 }
                 catch (error) {
-                    logger$6(`Error loading schema file for ${schemaName}:`, error);
+                    logger$7(`Error loading schema file for ${schemaName}:`, error);
                     // Fall through to try loading from schemaData if available
                 }
             }
@@ -16088,7 +16426,7 @@ async function loadAllSchemasFromDb() {
                     continue;
                 }
                 catch (error) {
-                    logger$6(`Error parsing schemaData for ${schemaName}:`, error);
+                    logger$7(`Error parsing schemaData for ${schemaName}:`, error);
                 }
             }
         }
@@ -16099,11 +16437,11 @@ async function loadAllSchemasFromDb() {
         // Only process if not already in result
         if (!processedSchemaNames.has(schemaFileInfo.name)) {
             if (isInternalSchema(schemaFileInfo.name, schemaFileInfo.schemaFileId)) {
-                logger$6(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
+                logger$7(`STEP 3: skipping internal schema file: ${schemaFileInfo.filePath}`);
                 continue;
             }
             try {
-                logger$6(`STEP 3: processing schema file: ${schemaFileInfo.name} from ${schemaFileInfo.filePath}`);
+                logger$7(`STEP 3: processing schema file: ${schemaFileInfo.name} from ${schemaFileInfo.filePath}`);
                 const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
                 const schemaFile = JSON.parse(content);
                 // Import this schema to database (mark as non-draft since it's in a file)
@@ -16123,7 +16461,7 @@ async function loadAllSchemasFromDb() {
                 processedSchemaNames.add(schemaFileInfo.name);
             }
             catch (error) {
-                logger$6(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
+                logger$7(`Error loading schema file ${schemaFileInfo.filePath}:`, error);
             }
         }
     }
@@ -16140,7 +16478,7 @@ async function migrateFileSchemasToDb() {
     if (!db) {
         throw new Error('Database not found');
     }
-    logger$6('Starting migration of file-based schemas to database');
+    logger$7('Starting migration of file-based schemas to database');
     // Get all complete schema files
     const completeSchemas = await listCompleteSchemaFiles();
     let migratedCount = 0;
@@ -16150,7 +16488,7 @@ async function migrateFileSchemasToDb() {
             const content = await BaseFileManager.readFileAsString(schemaFileInfo.filePath);
             const schemaFile = JSON.parse(content);
             if (!schemaFile.$schema || !schemaFile.metadata?.name) {
-                logger$6(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
+                logger$7(`Skipping invalid schema file: ${schemaFileInfo.filePath}`);
                 continue;
             }
             const schemaName = schemaFile.metadata.name;
@@ -16172,17 +16510,17 @@ async function migrateFileSchemasToDb() {
                 JSON.stringify(schemaFile, null, 2), // schemaData
                 false);
                 migratedCount++;
-                logger$6(`Migrated schema: ${schemaName} v${schemaFile.version}`);
+                logger$7(`Migrated schema: ${schemaName} v${schemaFile.version}`);
             }
             else {
-                logger$6(`Schema ${schemaName} already exists in database, skipping`);
+                logger$7(`Schema ${schemaName} already exists in database, skipping`);
             }
         }
         catch (error) {
-            logger$6(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
+            logger$7(`Error migrating schema file ${schemaFileInfo.filePath}:`, error);
         }
     }
-    logger$6(`Migration complete: ${migratedCount} schemas migrated`);
+    logger$7(`Migration complete: ${migratedCount} schemas migrated`);
     return migratedCount;
 }
 /**
@@ -16237,7 +16575,7 @@ const getDeterministicIdsWithPrefix = (prefix) => {
     return (suffix) => utils.bytesToHex(prefixHash.clone().update(utils.utf8ToBytes(suffix)).digest()).slice(0, 10);
 };
 
-const logger$5 = debug('seedSdk:imports:json');
+const logger$6 = debug('seedSdk:imports:json');
 /**
  * Get refValueType from a property object with case-insensitive key lookup.
  * Handles refValueType, refvaluetype, ref_value_type, elementType, and legacy items.type / items.Type.
@@ -16326,11 +16664,11 @@ const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10
             .where(eq(propertiesTable.modelId, modelId))
             .limit(1);
         if (props.length > 0) {
-            logger$5(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
+            logger$6(`Verified properties exist for model "${modelName}" (modelId: ${modelId}) after ${attempt + 1} attempt(s)`);
             return;
         }
         if (attempt < maxRetries - 1) {
-            logger$5(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
+            logger$6(`Properties not yet visible for model "${modelName}" (modelId: ${modelId}), retrying in ${retryDelay}ms (attempt ${attempt + 1}/${maxRetries})`);
             await new Promise(resolve => setTimeout(resolve, retryDelay));
         }
     }
@@ -16636,7 +16974,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             if (parsed.$schema && parsed.metadata) {
                 // It's already a complete schema format - preserve it (id may be missing, will be generated)
                 originalSchemaFile = parsed;
-                logger$5(`Input is complete schema format (${originalSchemaFile.id ? `preserving ID: ${originalSchemaFile.id}` : 'id will be generated'})`);
+                logger$6(`Input is complete schema format (${originalSchemaFile.id ? `preserving ID: ${originalSchemaFile.id}` : 'id will be generated'})`);
             }
         }
         catch {
@@ -16673,16 +17011,16 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 .limit(1);
             if (existingByName.length > 0 && existingByName[0].schemaData) {
                 const existing = existingByName[0];
-                logger$5(`Idempotency: found existing schema by name+version: ${schemaFile.metadata.name} v${schemaFile.version ?? version}`);
+                logger$6(`Idempotency: found existing schema by name+version: ${schemaFile.metadata.name} v${schemaFile.version ?? version}`);
                 const existingSchema = JSON.parse(existing.schemaData);
                 const contentMatches = compareSchemaContent(schemaFile, existingSchema);
-                logger$5(`Idempotency: compareSchemaContent=${contentMatches} for ${schemaFile.metadata.name}`);
+                logger$6(`Idempotency: compareSchemaContent=${contentMatches} for ${schemaFile.metadata.name}`);
                 if (contentMatches) {
                     if (existing.schemaFileId) {
                         const workingDir = BaseFileManager.getWorkingDir();
                         const existingFilePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, schemaFile.version ?? version, existing.schemaFileId);
                         if (await BaseFileManager.pathExists(existingFilePath)) {
-                            logger$5(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content, loading existing file`);
+                            logger$6(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content, loading existing file`);
                             return await loadSchemaFromFile(existingFilePath);
                         }
                         await BaseFileManager.createDirIfNotExists(workingDir);
@@ -16690,7 +17028,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                         await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
                         return await loadSchemaFromFile(existingFilePath);
                     }
-                    logger$5(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content (no schemaFileId), using DB`);
+                    logger$6(`Schema ${schemaFile.metadata.name} v${schemaFile.version} already exists with same content (no schemaFileId), using DB`);
                     return '';
                 }
             }
@@ -16706,7 +17044,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // processSchemaFiles runs multiple times (React StrictMode, app restarts).
         if (!schemaFile.id) {
             schemaFile.id = await getDeterministicSchemaFileId(schemaFile);
-            logger$5(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
+            logger$6(`Generated deterministic schema ID for ${schemaFile.metadata.name}:`, schemaFile.id);
         }
         // Before generating IDs, check if a file already exists with this schemaFileId
         // This handles the case where the schema was already loaded via loadSchemaFromFile
@@ -16716,7 +17054,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         const existingFileExists = await BaseFileManager.pathExists(existingFilePath);
         if (existingFileExists) {
             // File already exists with this schemaFileId - just load it instead of creating a new one
-            logger$5(`Schema file already exists with schemaFileId ${schemaFile.id}, loading it instead of creating new file`);
+            logger$6(`Schema file already exists with schemaFileId ${schemaFile.id}, loading it instead of creating new file`);
             return await loadSchemaFromFile(existingFilePath);
         }
         // Generate missing model and property IDs.
@@ -16727,12 +17065,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         for (const [modelName, model] of Object.entries(schemaFile.models || {})) {
             if (!model.id) {
                 model.id = getDeterministicId(modelName);
-                logger$5(`Generated deterministic model ID for ${modelName}:`, model.id);
+                logger$6(`Generated deterministic model ID for ${modelName}:`, model.id);
             }
             for (const [propName, prop] of Object.entries(model.properties || {})) {
                 if (!prop.id) {
                     prop.id = getDeterministicId(modelName + propName);
-                    logger$5(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$6(`Generated deterministic property ID for ${modelName}.${propName}:`, prop.id);
                 }
             }
         }
@@ -16766,14 +17104,14 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                                 const workingDir = BaseFileManager.getWorkingDir();
                                 const existingFilePath = getSchemaFilePath(workingDir, importData.name, version, existing.schemaFileId);
                                 if (await BaseFileManager.pathExists(existingFilePath)) {
-                                    logger$5(`Schema ${importData.name} v${version} already exists with same content, loading existing file`);
+                                    logger$6(`Schema ${importData.name} v${version} already exists with same content, loading existing file`);
                                     return await loadSchemaFromFile(existingFilePath);
                                 }
                                 // File missing but schemaData exists - restore file from schemaData
                                 await BaseFileManager.createDirIfNotExists(workingDir);
                                 await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
                                 await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
-                                logger$5(`Restored schema file from schemaData for ${importData.name} v${version}`);
+                                logger$6(`Restored schema file from schemaData for ${importData.name} v${version}`);
                                 return await loadSchemaFromFile(existingFilePath);
                             }
                             // No schemaFileId - restore file from schemaData using id from parsed schema
@@ -16784,10 +17122,10 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                                 await BaseFileManager.createDirIfNotExists(workingDir);
                                 await BaseFileManager.saveFile(existingFilePath, existing.schemaData);
                                 await BaseFileManager.waitForFileWithContent(existingFilePath, 100, 5000);
-                                logger$5(`Restored schema file from schemaData for ${importData.name} v${version}`);
+                                logger$6(`Restored schema file from schemaData for ${importData.name} v${version}`);
                                 return await loadSchemaFromFile(existingFilePath);
                             }
-                            logger$5(`Schema ${importData.name} v${version} already exists with same content (no id), using DB`);
+                            logger$6(`Schema ${importData.name} v${version} already exists with same content (no id), using DB`);
                             return '';
                         }
                         // Content differs - create new version
@@ -16798,7 +17136,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                             .orderBy(desc(schemasTable.version))
                             .limit(1);
                         const newVersion = latestVersionRows.length > 0 ? latestVersionRows[0].version + 1 : version;
-                        logger$5(`Schema ${importData.name} content changed, creating new version v${newVersion}`);
+                        logger$6(`Schema ${importData.name} content changed, creating new version v${newVersion}`);
                         schemaFile = transformImportToSchemaFile(importData, newVersion);
                         version = newVersion;
                     }
@@ -16822,7 +17160,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
     // Check if this is an internal SDK schema (should not create files in app directory)
     const isInternal = isInternalSchema(schemaFile.metadata.name, schemaFile.id);
     if (isInternal) {
-        logger$5(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
+        logger$6(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
         // For internal schemas, just load to database and store, don't create file
         // Extract schema name and version
         const schemaName = schemaFile.metadata?.name;
@@ -16879,7 +17217,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         // Use fixed internal schema ID if missing (never generate for internal)
         if (!schemaFile.id) {
             schemaFile.id = INTERNAL_SCHEMA_IDS[0];
-            logger$5('Using fixed internal schema ID:', schemaFile.id);
+            logger$6('Using fixed internal schema ID:', schemaFile.id);
         }
         // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
         // This ensures Model instances are created with correct IDs
@@ -16889,7 +17227,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             // Generate model ID if missing
             if (!model.id) {
                 model.id = generateId();
-                logger$5(`Generated model ID for ${modelName}:`, model.id);
+                logger$6(`Generated model ID for ${modelName}:`, model.id);
                 // Update the schemaFile object so it's included in schemaData
                 schemaFile.models[modelName].id = model.id;
             }
@@ -16899,7 +17237,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 // Generate property ID if missing
                 if (!prop.id) {
                     prop.id = generateId();
-                    logger$5(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$6(`Generated property ID for ${modelName}.${propName}:`, prop.id);
                     // Update the schemaFile object so it's included in schemaData
                     schemaFile.models[modelName].properties[propName].id = prop.id;
                 }
@@ -16911,7 +17249,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         }
         // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
         const modelDefinitions = await createModelsFromJson(importDataForInternal, modelFileIds, propertyFileIds);
-        logger$5('loadSchemaFromFile (internal) - modelDefinitions length:', Object.keys(modelDefinitions).length);
+        logger$6('loadSchemaFromFile (internal) - modelDefinitions length:', Object.keys(modelDefinitions).length);
         // Convert schema file metadata to schema input for database
         const schemaInput = {
             name: schemaName,
@@ -17031,12 +17369,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         }
         catch (dbError) {
             // Database not available - log warning but continue
-            logger$5('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
+            logger$6('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
         }
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [modelName] of Object.entries(modelDefinitions)) {
-            logger$5('loadSchemaFromFile (internal) - model available:', modelName);
+            logger$6('loadSchemaFromFile (internal) - model available:', modelName);
         }
         // Schema is now saved to database
         // useSchemas hook will pick it up via database queries
@@ -17047,7 +17385,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
     // Ensure schema ID is defined (should always be set by this point, but check for safety)
     if (!schemaFile.id) {
         schemaFile.id = generateId();
-        logger$5('Generated schema ID before file path creation:', schemaFile.id);
+        logger$6('Generated schema ID before file path creation:', schemaFile.id);
     }
     // Get the target file path using ID-based naming (preferred)
     const filePath = getSchemaFilePath(workingDir, schemaFile.metadata.name, version, schemaFile.id);
@@ -17066,7 +17404,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     const data = JSON.parse(content);
                     if (data.$schema) {
                         // File is already a complete schema, just load it
-                        logger$5(`Schema file ${filePath} already exists and is complete, loading it`);
+                        logger$6(`Schema file ${filePath} already exists and is complete, loading it`);
                         return await loadSchemaFromFile(filePath);
                     }
                 }
@@ -17084,7 +17422,7 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                 // Compare schemas structurally
                 if (compareSchemasStructurally(schemaFile, existingSchema)) {
                     // Schemas match - just load the existing file
-                    logger$5(`Schema ${schemaFile.metadata.name} v${version} already exists with matching content, loading it`);
+                    logger$6(`Schema ${schemaFile.metadata.name} v${version} already exists with matching content, loading it`);
                     return await loadSchemaFromFile(filePath);
                 }
                 else {
@@ -17259,7 +17597,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         // Generate schema ID if missing (before creating schemaInput)
         if (!schemaFile.id) {
             schemaFile.id = generateId();
-            logger$5('Generated schema ID for schema file:', schemaFile.id);
+            logger$6('Generated schema ID for schema file:', schemaFile.id);
         }
         // Extract schemaFileIds from JSON file and generate missing ones BEFORE creating models
         // This ensures Model instances are created with correct IDs
@@ -17269,7 +17607,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             // Generate model ID if missing
             if (!model.id) {
                 model.id = generateId();
-                logger$5(`Generated model ID for ${modelName}:`, model.id);
+                logger$6(`Generated model ID for ${modelName}:`, model.id);
                 // Update the schemaFile object so it's included in schemaData
                 schemaFile.models[modelName].id = model.id;
             }
@@ -17279,7 +17617,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                 // Generate property ID if missing
                 if (!prop.id) {
                     prop.id = generateId();
-                    logger$5(`Generated property ID for ${modelName}.${propName}:`, prop.id);
+                    logger$6(`Generated property ID for ${modelName}.${propName}:`, prop.id);
                     // Update the schemaFile object so it's included in schemaData
                     schemaFile.models[modelName].properties[propName].id = prop.id;
                 }
@@ -17291,7 +17629,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
         }
         // Convert JSON models to Model classes, passing modelFileIds and propertyFileIds so Model instances use correct IDs
         const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
-        logger$5('loadSchemaFromFile - modelDefinitions length:', Object.keys(modelDefinitions).length);
+        logger$6('loadSchemaFromFile - modelDefinitions length:', Object.keys(modelDefinitions).length);
         // Try to add schema and models to database if database is available
         try {
             const db = BaseDb.getAppDb();
@@ -17346,17 +17684,17 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                             await new Promise(resolve => setTimeout(resolve, 100));
                         }
                     }
-                    logger$5(`Verifying properties: found ${modelLinks.length} model links for schema ${schemaName} (id: ${schemaRecord.id})`);
+                    logger$6(`Verifying properties: found ${modelLinks.length} model links for schema ${schemaName} (id: ${schemaRecord.id})`);
                     // If we didn't verify via direct lookup, verify via join table
                     if (!seedModelId || (seedModel.length === 0 || !seedModel[0].id)) {
                         const seedModelLink = modelLinks.find((link) => link.modelName === 'Seed');
                         if (seedModelLink && seedModelLink.modelId) {
-                            logger$5(`Verifying properties for Seed model via join table (modelId: ${seedModelLink.modelId})`);
+                            logger$6(`Verifying properties for Seed model via join table (modelId: ${seedModelLink.modelId})`);
                             await verifyPropertiesPersisted(db, seedModelLink.modelId, 'Seed', 10, 100);
                         }
                         else if (modelLinks.length > 0 && modelLinks[0].modelId) {
                             // Fallback to first model if Seed not found
-                            logger$5(`Verifying properties for ${modelLinks[0].modelName} model via join table (modelId: ${modelLinks[0].modelId})`);
+                            logger$6(`Verifying properties for ${modelLinks[0].modelName} model via join table (modelId: ${modelLinks[0].modelId})`);
                             await verifyPropertiesPersisted(db, modelLinks[0].modelId, modelLinks[0].modelName || 'unknown', 10, 100);
                         }
                     }
@@ -17387,7 +17725,7 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                                 const currentId = schemaFile.models[modelName].properties[propRecord.name].id;
                                 if (currentId !== propRecord.schemaFileId) {
                                     schemaFile.models[modelName].properties[propRecord.name].id = propRecord.schemaFileId;
-                                    logger$5(`Updated schemaFile property ID for ${modelName}.${propRecord.name} from ${currentId} to ${propRecord.schemaFileId}`);
+                                    logger$6(`Updated schemaFile property ID for ${modelName}.${propRecord.name} from ${currentId} to ${propRecord.schemaFileId}`);
                                     schemaFileUpdated = true;
                                 }
                             }
@@ -17405,21 +17743,21 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     .set({ schemaData: updatedSchemaData })
                     .where(eq(schemasTable.id, schemaRecord.id));
                 if (schemaFileUpdated) {
-                    logger$5(`Updated schemaData in database with actual property IDs for schema "${schemaName}"`);
+                    logger$6(`Updated schemaData in database with actual property IDs for schema "${schemaName}"`);
                 }
                 else {
-                    logger$5(`Verified schemaData in database matches schemaFile for schema "${schemaName}"`);
+                    logger$6(`Verified schemaData in database matches schemaFile for schema "${schemaName}"`);
                 }
             }
         }
         catch (dbError) {
             // Database not available - log warning but continue
-            logger$5('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
+            logger$6('Database not available, skipping database operations:', dbError instanceof Error ? dbError.message : String(dbError));
         }
         // Models are now Model instances, no registration needed
         // They should be created via Model.create() and are accessible via Model static methods
         for (const [modelName] of Object.entries(modelDefinitions)) {
-            logger$5('loadSchemaFromFile - model available:', modelName);
+            logger$6('loadSchemaFromFile - model available:', modelName);
         }
         return schemaFilePath;
     }
@@ -17504,10 +17842,10 @@ propertyFileIds) => {
     // Pass id (schemaFileId) if provided to ensure Model instance uses correct ID
     // Note: indexes and description are ignored - they remain in JSON for schema file format compliance but are not used by Model instances
     if (modelFileId) {
-        logger$5(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
+        logger$6(`Creating schema model "${modelName}" with modelFileId: ${modelFileId}`);
     }
     else {
-        logger$5(`Warning: Creating schema model "${modelName}" without modelFileId - it will be renamed if duplicates exist`);
+        logger$6(`Warning: Creating schema model "${modelName}" without modelFileId - it will be renamed if duplicates exist`);
     }
     const modelInstance = Model.create(modelName, schemaName, {
         modelFileId: modelFileId, // Pass modelFileId (preferred) as id (schemaFileId) from JSON file
@@ -17533,7 +17871,7 @@ const createModelsFromJson = async (importData, modelFileIds, propertyFileIds) =
         // Use modelFileId from map (no fallback to modelDef.id as JsonImportSchema doesn't have id property)
         const finalModelFileId = modelFileId;
         if (!finalModelFileId) {
-            logger$5(`Warning: No modelFileId found for model "${modelName}" - model will be created without ID`);
+            logger$6(`Warning: No modelFileId found for model "${modelName}" - model will be created without ID`);
         }
         // Get propertyFileIds for this model if available
         const modelPropertyFileIds = propertyFileIds?.get(modelName);
@@ -17723,7 +18061,7 @@ var SEEDPROTOCOL_Seed_Protocol_v1 = /*#__PURE__*/Object.freeze({
     version: version
 });
 
-const logger$4 = debug('seedSdk:client:actors:processSchemaFiles');
+const logger$5 = debug('seedSdk:client:actors:processSchemaFiles');
 let processSchemaFilesChain = Promise.resolve();
 function resolveSchemaFilePath(schemaFile) {
     const path = BaseFileManager.getPathModule();
@@ -17751,7 +18089,7 @@ async function resolveSchemaNameFromSource(source) {
             }
         }
         catch (error) {
-            logger$4('Could not resolve schema name from path:', source, error);
+            logger$5('Could not resolve schema name from path:', source, error);
         }
     }
     return null;
@@ -17760,7 +18098,7 @@ async function resolveSchemaNameFromSource(source) {
 // Schema processing can be slow with syncSchemaFromSource, loadAllSchemasFromDb, and OPFS file I/O
 const PROCESS_SCHEMA_FILES_TIMEOUT_MS = 120000;
 const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }) => {
-    logger$4('processSchemaFiles started');
+    logger$5('processSchemaFiles started');
     let hasResponded = false;
     let timeoutId = null;
     const reportError = (error) => {
@@ -17770,7 +18108,7 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
-            logger$4('processSchemaFiles error:', error);
+            logger$5('processSchemaFiles error:', error);
             sendBack({
                 type: 'error',
                 error: error instanceof Error ? error : new Error(String(error))
@@ -17784,7 +18122,7 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                 clearTimeout(timeoutId);
                 timeoutId = null;
             }
-            logger$4('processSchemaFiles completed');
+            logger$5('processSchemaFiles completed');
             sendBack({ type: ClientManagerEvents.PROCESS_SCHEMA_FILES_SUCCESS });
         }
     };
@@ -17796,7 +18134,7 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
         // Schemas written (or confirmed present) this run — skip redundant loadSchemaFromFile later
         const schemasWrittenThisRun = new Set();
         // First, load the internal seed-protocol schema
-        logger$4('Loading internal seed-protocol schema');
+        logger$5('Loading internal seed-protocol schema');
         const internalSchemaData = internalSchema;
         const db = BaseDb.getAppDb();
         const internalSchemaExists = db
@@ -17805,21 +18143,21 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
         // Always mark internal schema as written so the DB/file loop does not re-apply it
         schemasWrittenThisRun.add(SEED_PROTOCOL_SCHEMA_NAME);
         if (internalSchemaExists) {
-            logger$4('Internal seed-protocol schema already in DB, skipping import');
+            logger$5('Internal seed-protocol schema already in DB, skipping import');
         }
         else {
             try {
                 // Import the internal schema to database (will create models and add to store)
                 await importJsonSchema({ contents: JSON.stringify(internalSchemaData) }, internalSchemaData.version);
-                logger$4(`Loaded internal seed-protocol schema v${internalSchemaData.version}`);
+                logger$5(`Loaded internal seed-protocol schema v${internalSchemaData.version}`);
             }
             catch (error) {
                 // If schema already exists, that's fine - it means it was already loaded
                 if (error?.message?.includes('already exists')) {
-                    logger$4('Internal seed-protocol schema already loaded');
+                    logger$5('Internal seed-protocol schema already loaded');
                 }
                 else {
-                    logger$4('Error loading internal seed-protocol schema:', error);
+                    logger$5('Error loading internal seed-protocol schema:', error);
                     // Don't fail if internal schema can't be loaded - it might already be in DB
                 }
             }
@@ -17832,7 +18170,7 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                 : '';
             const schemaId = typeof context.schema === 'object' && context.schema?.id ? String(context.schema.id) : undefined;
             if (isInternalSchema(schemaName, schemaId)) {
-                logger$4('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
+                logger$5('Schema is internal (Seed Protocol), already loaded - skipping syncSchemaFromSource');
             }
             else {
                 try {
@@ -17841,10 +18179,10 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                     if (syncedName) {
                         schemasWrittenThisRun.add(syncedName);
                     }
-                    logger$4(`Synced canonical schema from ${typeof context.schema === 'string' ? context.schema : 'object'}`);
+                    logger$5(`Synced canonical schema from ${typeof context.schema === 'string' ? context.schema : 'object'}`);
                 }
                 catch (error) {
-                    logger$4(`Error syncing canonical schema:`, error);
+                    logger$5(`Error syncing canonical schema:`, error);
                     // Don't fail init - schema might already be in DB
                 }
             }
@@ -17859,23 +18197,23 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                 if (parsed?.metadata?.name) {
                     schemasWrittenThisRun.add(String(parsed.metadata.name));
                 }
-                logger$4(`Loaded schema from ${resolvedPath}`);
+                logger$5(`Loaded schema from ${resolvedPath}`);
             }
             catch (error) {
-                logger$4(`Error loading schema file ${context.schemaFile}:`, error);
+                logger$5(`Error loading schema file ${context.schemaFile}:`, error);
                 // Don't fail init - schema might already be in DB
             }
         }
         // Process minimal import files (files without $schema) - skip when canonical schema is set
         if (!context.schema) {
-            logger$4('Listing schema files');
+            logger$5('Listing schema files');
             let schemaFiles = [];
             try {
                 schemaFiles = await listSchemaFiles();
-                logger$4(`Found ${schemaFiles.length} schema files to process`);
+                logger$5(`Found ${schemaFiles.length} schema files to process`);
             }
             catch (error) {
-                logger$4('Error listing schema files (continuing anyway):', error);
+                logger$5('Error listing schema files (continuing anyway):', error);
                 schemaFiles = [];
             }
             for (const schemaFile of schemaFiles) {
@@ -17886,19 +18224,19 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                     }
                 }
                 catch (error) {
-                    logger$4(`Error importing schema file ${schemaFile.filePath}:`, error);
+                    logger$5(`Error importing schema file ${schemaFile.filePath}:`, error);
                 }
             }
         }
         // Then, load all schemas using the unified database-first approach
-        logger$4('Loading schemas from database and files');
+        logger$5('Loading schemas from database and files');
         let allSchemasData = [];
         try {
             allSchemasData = await loadAllSchemasFromDb();
-            logger$4(`Loaded ${allSchemasData.length} schemas (${allSchemasData.filter(s => s.isDraft).length} drafts, ${allSchemasData.filter(s => !s.isDraft).length} published)`);
+            logger$5(`Loaded ${allSchemasData.length} schemas (${allSchemasData.filter(s => s.isDraft).length} drafts, ${allSchemasData.filter(s => !s.isDraft).length} published)`);
         }
         catch (error) {
-            logger$4('Error loading schemas from database (continuing anyway):', error);
+            logger$5('Error loading schemas from database (continuing anyway):', error);
             // Continue with empty array - this is not critical for initialization
             // Schemas can be loaded on-demand later
             allSchemasData = [];
@@ -17919,13 +18257,13 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                 }
             }
             catch (error) {
-                logger$4('Error counting linked models (re-applying all schema files):', error);
+                logger$5('Error counting linked models (re-applying all schema files):', error);
             }
         }
         for (const schemaData of allSchemasData) {
             const schema = schemaData.schema;
             const schemaName = schema.metadata?.name || 'unknown';
-            logger$4(`Processing schema: ${schemaName} v${schema.version} (${schemaData.isDraft ? 'draft' : 'published'}, source: ${schemaData.source})`);
+            logger$5(`Processing schema: ${schemaName} v${schema.version} (${schemaData.isDraft ? 'draft' : 'published'}, source: ${schemaData.source})`);
             // For published schemas (not drafts), load models from file if available
             if (!schemaData.isDraft && schema.id) {
                 // loadAllSchemasFromDb already picked the latest file for this schema (and read it)
@@ -17955,7 +18293,7 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                         }
                     }
                     catch (error) {
-                        logger$4(`Error loading schema file for ${schemaName}:`, error);
+                        logger$5(`Error loading schema file for ${schemaName}:`, error);
                     }
                 }
                 else {
@@ -18004,11 +18342,11 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                             };
                             const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
                             Object.assign(allModels, modelDefinitions);
-                            logger$4(`Loaded ${Object.keys(modelDefinitions).length} models from schema data for ${schemaName}`);
+                            logger$5(`Loaded ${Object.keys(modelDefinitions).length} models from schema data for ${schemaName}`);
                         }
                     }
                     catch (error) {
-                        logger$4(`Error creating models from schema data for ${schemaName}:`, error);
+                        logger$5(`Error creating models from schema data for ${schemaName}:`, error);
                     }
                 }
             }
@@ -18058,11 +18396,11 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
                         };
                         const modelDefinitions = await createModelsFromJson(importData, modelFileIds, propertyFileIds);
                         Object.assign(allModels, modelDefinitions);
-                        logger$4(`Loaded ${Object.keys(modelDefinitions).length} models from draft schema ${schemaName}`);
+                        logger$5(`Loaded ${Object.keys(modelDefinitions).length} models from draft schema ${schemaName}`);
                     }
                 }
                 catch (error) {
-                    logger$4(`Error creating models from draft schema ${schemaName}:`, error);
+                    logger$5(`Error creating models from draft schema ${schemaName}:`, error);
                 }
             }
             // Schemas are now loaded on-demand via database queries (useSchemas hook uses loadAllSchemasFromDb)
@@ -18080,7 +18418,7 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
         // Its schema and model inserts check for rows first, so tabs take turns (docs/MULTI_TAB.md).
         .then(() => withSeedDbLock('init', context.filesDir, _processSchemaFiles))
         .catch((err) => {
-        logger$4('processSchemaFiles chain error:', err);
+        logger$5('processSchemaFiles chain error:', err);
         throw err;
     });
     processSchemaFilesChain.then(reportSuccess).catch((error) => {
@@ -18095,6 +18433,285 @@ const processSchemaFiles = xstate.fromCallback(({ sendBack, input: { context } }
     };
 });
 
+/**
+ * A legacy ItemStorage draft row: a local edit (no attestation uid, not derived from one) that holds
+ * the content itself in property_value, with no file reference. Item.create / createNewItem stored
+ * ItemStorage values like this before they went through the save pipeline.
+ */
+const isVerbatimItemStorageDraftRow = (row) => !row.uid &&
+    row.derivedFromUid == null &&
+    !row.refResolvedValue &&
+    typeof row.propertyValue === 'string' &&
+    row.propertyValue !== '';
+/**
+ * Convert one legacy ItemStorage draft row (see {@link isVerbatimItemStorageDraftRow}) into the
+ * shape saveItemStorage gives a row: the content goes to the file a save would write
+ * (`<seedUid or seedLocalId><extension>` in the property's storage directory), and the row records
+ * `refResolvedValue`, `localStorageDir` and `refValueType: 'file'` with property_value cleared.
+ * Used by publish (resolveItemStorageChildFile) and the one-time migration (migrateLegacyItemStorageRows).
+ *
+ * Reading the row, writing the file and updating the row happen under the file's lock
+ * ({@link withItemStorageFileLock}), which saveItemStorage holds too: a save in this or another tab
+ * either finishes before (the row, read again once the lock is held, is no longer legacy and is
+ * left alone) or starts after (and overwrites the file and row with its content). Without the lock
+ * a save landing between the read and the file write would have its file overwritten with the old
+ * content. The row update also stays conditional on the row being unchanged, for writers that
+ * don't take the lock (a tab still running an older SDK).
+ *
+ * Returns undefined when there was nothing to convert. Throws when the file can't be written; the
+ * row is then unchanged.
+ */
+const convertVerbatimItemStorageRow = async (localId, storage = {}) => {
+    const appDb = BaseDb.getAppDb();
+    if (!appDb || !localId)
+        return undefined;
+    const targetOf = (row) => {
+        if (!isVerbatimItemStorageDraftRow(row))
+            return undefined;
+        const seedId = storage.seedId || row.seedUid || row.seedLocalId;
+        if (!seedId)
+            return undefined;
+        return {
+            seedId,
+            localStorageDir: storage.localStorageDir || row.localStorageDir,
+            filenameSuffix: storage.filenameSuffix,
+        };
+    };
+    return withLockedItemStorageRow(localId, (row) => {
+        const target = targetOf(row);
+        return target && getItemStorageFilePath(target);
+    }, async (row) => {
+        const content = row.propertyValue;
+        const { fileName, filePath, localStorageDir } = await writeItemStorageFile(targetOf(row), content);
+        await appDb
+            .update(metadata$1)
+            .set({ refResolvedValue: fileName, localStorageDir, refValueType: 'file', propertyValue: null })
+            .where(drizzleOrm.and(drizzleOrm.eq(metadata$1.localId, localId), drizzleOrm.isNull(metadata$1.refResolvedValue), drizzleOrm.eq(metadata$1.propertyValue, content)));
+        // Changed between the read and the update by a writer outside the lock: that change stands.
+        const after = await appDb
+            .select({ refResolvedValue: metadata$1.refResolvedValue, propertyValue: metadata$1.propertyValue })
+            .from(metadata$1)
+            .where(drizzleOrm.eq(metadata$1.localId, localId))
+            .limit(1);
+        if (after[0]?.refResolvedValue !== fileName || after[0]?.propertyValue != null)
+            return undefined;
+        return { fileName, filePath, localStorageDir, content };
+    });
+};
+
+const logger$4 = debug('seedSdk:db:migrateLegacyItemStorageRows');
+/** appState key recording that legacy ItemStorage rows have been written to their files. */
+const LEGACY_ITEM_STORAGE_MIGRATION_KEY = 'legacyItemStorageFiles:v1';
+/** Runs in a row that left rows unconverted because a file write failed, before giving up. */
+const LEGACY_ITEM_STORAGE_MIGRATION_MAX_ATTEMPTS = 3;
+const readMarker = async () => {
+    const db = BaseDb.getAppDb();
+    const rows = await db
+        .select({ value: appState.value })
+        .from(appState)
+        .where(drizzleOrm.eq(appState.key, LEGACY_ITEM_STORAGE_MIGRATION_KEY))
+        .limit(1);
+    if (!rows.length)
+        return undefined;
+    try {
+        return JSON.parse(rows[0].value ?? '');
+    }
+    catch {
+        return null;
+    }
+};
+const writeMarker = async (marker) => {
+    const db = BaseDb.getAppDb();
+    const now = Date.now();
+    const value = JSON.stringify(marker);
+    await db
+        .insert(appState)
+        .values({ key: LEGACY_ITEM_STORAGE_MIGRATION_KEY, value, createdAt: now, updatedAt: now })
+        .onConflictDoUpdate({ target: appState.key, set: { value, updatedAt: now } });
+};
+/**
+ * The storage settings of a metadata row's property: by its property_id, else by name in the
+ * seed's own model (model names are only unique per schema). Undefined when it can't be told.
+ */
+const createStorageResolver = () => {
+    const db = BaseDb.getAppDb();
+    const byPropertyId = new Map();
+    const byModelAndName = new Map();
+    return async (row) => {
+        if (row.propertyId != null) {
+            if (!byPropertyId.has(row.propertyId)) {
+                const found = await db
+                    .select({
+                    storageType: properties.storageType,
+                    localStorageDir: properties.localStorageDir,
+                    filenameSuffix: properties.filenameSuffix,
+                })
+                    .from(properties)
+                    .where(drizzleOrm.eq(properties.id, row.propertyId))
+                    .limit(1);
+                byPropertyId.set(row.propertyId, found[0]);
+            }
+            const fromId = byPropertyId.get(row.propertyId);
+            if (fromId)
+                return fromId;
+        }
+        const modelFileId = await resolveItemModelFileId({ seedLocalId: row.seedLocalId, seedUid: row.seedUid });
+        if (!modelFileId || !row.propertyName)
+            return undefined;
+        const key = `${modelFileId}\u0000${row.propertyName}`;
+        if (!byModelAndName.has(key)) {
+            const found = await db
+                .select({
+                storageType: properties.storageType,
+                localStorageDir: properties.localStorageDir,
+                filenameSuffix: properties.filenameSuffix,
+            })
+                .from(properties)
+                .innerJoin(models$1, drizzleOrm.eq(properties.modelId, models$1.id))
+                .where(drizzleOrm.and(drizzleOrm.eq(models$1.schemaFileId, modelFileId), drizzleOrm.eq(properties.name, row.propertyName)))
+                .limit(1);
+            byModelAndName.set(key, found[0]);
+        }
+        return byModelAndName.get(key);
+    };
+};
+/** True if `row` is the row readers show for its property: the newest of its seed's rows by that name. */
+const isNewestRowOfProperty = async (row) => {
+    if (!row.seedLocalId || !row.propertyName)
+        return false;
+    const db = BaseDb.getAppDb();
+    const siblings = await db
+        .select()
+        .from(metadata$1)
+        .where(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedLocalId, row.seedLocalId), drizzleOrm.eq(metadata$1.propertyName, row.propertyName)));
+    return [...siblings].sort(compareMetadataRowsLatestFirst)[0]?.localId === row.localId;
+};
+/**
+ * One-time data migration: writes the content of legacy ItemStorage draft rows to their files.
+ *
+ * Before Item.create / createNewItem saved ItemStorage values through the save pipeline, a value
+ * given at creation was stored verbatim in metadata.property_value with no file. Publish converts
+ * such a row lazily (resolveItemStorageChildFile); this converts them all up front, with the same
+ * code ({@link convertVerbatimItemStorageRow}), so every ItemStorage draft has the shape a save
+ * gives it: the content in `<seedUid or seedLocalId><extension>`, the row holding
+ * refResolvedValue / localStorageDir / refValueType 'file' and no property_value.
+ *
+ * Only local drafts (no uid, not derived from an attestation) of properties whose properties row
+ * says `storage_type = 'ItemStorage'` are touched, and of those only the newest row of each
+ * seed's property: that is the row reads show and saves write to, and older rows sharing the one
+ * file name would overwrite it with older content. Published and synced rows are never changed.
+ *
+ * A row that fails is logged and left as it was (publish still converts it). The run is recorded
+ * in appState under {@link LEGACY_ITEM_STORAGE_MIGRATION_KEY}; a run with failed rows is retried
+ * on the next start, up to {@link LEGACY_ITEM_STORAGE_MIGRATION_MAX_ATTEMPTS} runs. Safe to run
+ * again regardless: a converted row no longer matches.
+ *
+ * @param options.force run even when the marker says it is done
+ */
+async function migrateLegacyItemStorageRows(options = {}) {
+    const result = {
+        alreadyDone: false,
+        candidates: 0,
+        converted: 0,
+        failed: 0,
+        skipped: 0,
+    };
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return { ...result, alreadyDone: true };
+    const marker = await readMarker();
+    const previousAttempts = marker?.status === 'retry' ? marker.attempts : 0;
+    if (!options.force && marker && marker.status === 'done') {
+        return { ...result, alreadyDone: true };
+    }
+    const itemStorageNames = (await db
+        .selectDistinct({ name: properties.name })
+        .from(properties)
+        .where(drizzleOrm.eq(properties.storageType, 'ItemStorage'))).map((r) => r.name);
+    const candidates = itemStorageNames.length
+        ? await db
+            .select()
+            .from(metadata$1)
+            .where(drizzleOrm.and(drizzleOrm.inArray(metadata$1.propertyName, itemStorageNames), drizzleOrm.or(drizzleOrm.isNull(metadata$1.uid), drizzleOrm.eq(metadata$1.uid, '')), drizzleOrm.isNull(metadata$1.derivedFromUid), drizzleOrm.isNull(metadata$1.refResolvedValue), drizzleOrm.isNotNull(metadata$1.propertyValue), drizzleOrm.ne(metadata$1.propertyValue, '')))
+        : [];
+    const resolveStorage = createStorageResolver();
+    for (const row of candidates) {
+        if (!row.localId || !isVerbatimItemStorageDraftRow(row))
+            continue;
+        try {
+            const storage = await resolveStorage(row);
+            if (storage?.storageType !== 'ItemStorage')
+                continue;
+            result.candidates++;
+            if (!(await isNewestRowOfProperty(row))) {
+                result.skipped++;
+                continue;
+            }
+            const converted = await convertVerbatimItemStorageRow(row.localId, {
+                localStorageDir: storage.localStorageDir,
+                filenameSuffix: storage.filenameSuffix,
+            });
+            if (converted) {
+                result.converted++;
+                logger$4(`wrote ${row.propertyName} of ${row.seedLocalId} to ${converted.filePath}`);
+            }
+            else {
+                result.skipped++;
+            }
+        }
+        catch (error) {
+            result.failed++;
+            logger$4(`converting ${row.propertyName} of ${row.seedLocalId} (${row.localId}) failed; left as is`, error);
+        }
+    }
+    const attempts = previousAttempts + 1;
+    await writeMarker({
+        status: result.failed > 0 && attempts < LEGACY_ITEM_STORAGE_MIGRATION_MAX_ATTEMPTS ? 'retry' : 'done',
+        attempts,
+        converted: result.converted,
+        failed: result.failed,
+        at: Date.now(),
+    });
+    if (result.candidates > 0) {
+        logger$4(`legacy ItemStorage rows: ${result.converted} converted, ${result.failed} failed, ` +
+            `${result.skipped} skipped of ${result.candidates}`);
+    }
+    return result;
+}
+let running;
+let deferredUntilLeader = false;
+const runInBackground = () => {
+    running ?? (running = withDbTabLock('item-storage-migration', () => migrateLegacyItemStorageRows())
+        .then(() => undefined)
+        .catch((error) => {
+        // Never fails init: rows stay as they were and publish converts them lazily.
+        logger$4('legacy ItemStorage migration failed', error);
+    })
+        .finally(() => {
+        running = undefined;
+    }));
+    return running;
+};
+/**
+ * Starts {@link migrateLegacyItemStorageRows} in the background once client init has finished
+ * (the properties table then holds the current storage settings). It runs in the leader tab only
+ * (docs/MULTI_TAB.md), under a `seed:item-storage-migration:<db>` lock in case several tabs lead
+ * (`multiTab: 'off'`); a tab that isn't leader runs it if it takes over. Never throws.
+ */
+function startLegacyItemStorageMigration() {
+    if (isLeaderTab()) {
+        void runInBackground();
+        return;
+    }
+    if (deferredUntilLeader)
+        return;
+    deferredUntilLeader = true;
+    void whenLeaderTab().then(() => {
+        deferredUntilLeader = false;
+        void runInBackground();
+    });
+}
+
 const { UNINITIALIZED, PLATFORM_CLASSES_INIT, FILE_SYSTEM_INIT, DB_INIT, SAVE_CONFIG, PROCESS_SCHEMA_FILES, ADD_MODELS_TO_STORE, ADD_MODELS_TO_DB, IDLE, INIT_FAILED, } = exports.ClientManagerState;
 const { UPDATE_CONTEXT, PLATFORM_CLASSES_READY, FILE_SYSTEM_READY, DB_READY, SAVE_CONFIG_SUCCESS, SAVE_APP_STATE_SUCCESS, SAVE_APP_STATE_ERROR, SET_ADDRESSES, ADD_MODELS_TO_STORE_SUCCESS, ADD_MODELS_TO_DB_SUCCESS, PROCESS_SCHEMA_FILES_SUCCESS, } = ClientManagerEvents;
 const logSyncAfterAddressSave = debug("seedSdk:client:clientManagerMachine:syncAfterAddressSave");
@@ -18315,9 +18932,15 @@ const clientManagerMachine = xstate.setup({
             },
         },
         [IDLE]: {
-            entry: xstate.assign({
-                isInitialized: true,
-            }),
+            entry: [
+                xstate.assign({
+                    isInitialized: true,
+                }),
+                // One-time data migration that writes files, so it can't be a SQL migration in prepareDb.
+                // In the background after init: the app is usable at once, the properties table holds the
+                // current storage settings by now, and a failure never fails init.
+                () => startLegacyItemStorageMigration(),
+            ],
             on: {
                 [SAVE_APP_STATE_SUCCESS]: {
                     actions: [
@@ -19391,7 +20014,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-B-cZm1yU.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-DXZ39Wyv.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -19407,7 +20030,7 @@ function getModelProperty() {
     return ModelPropertyClass;
 }
 // Lazy import for Schema to avoid circular dependency
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-STP972Xw.js'); })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-DdP109QD.js'); })
     .then(module => module.Schema)
     .catch(() => null);
 // WeakMap to store mutable state per Model instance
@@ -21472,7 +22095,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-usKaANAq.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-C4XlgCJ4.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
@@ -21542,10 +22165,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-CP3y1skt.js'); });
+        const { backfillMetadataPropertyIds } = await Promise.resolve().then(function () { return require('./backfillMetadataPropertyIds-CPYoaMl4.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-8nfkj9rz.js'); });
+        const { resetAmbiguousLegacyItemData } = await Promise.resolve().then(function () { return require('./resetAmbiguousLegacyItemData-Bu_MBBYt.js'); });
         await resetAmbiguousLegacyItemData();
         return this.db;
     }
@@ -22076,10 +22699,13 @@ exports.anyEvictionSince = anyEvictionSince;
 exports.appState = appState;
 exports.arweaveL1FinalizeJobs = arweaveL1FinalizeJobs;
 exports.assertLocalDbChain = assertLocalDbChain;
+exports.buildArweaveContentTags = buildArweaveContentTags;
 exports.chunkValues = chunkValues;
 exports.clearDestroySubscriptions = clearDestroySubscriptions;
 exports.commandExists = commandExists;
+exports.compareMetadataRowsLatestFirst = compareMetadataRowsLatestFirst;
 exports.config = config;
+exports.convertVerbatimItemStorageRow = convertVerbatimItemStorageRow;
 exports.createModelsFromJson = createModelsFromJson;
 exports.createReactiveProxy = createReactiveProxy;
 exports.currentEvictionEpoch = currentEvictionEpoch;
@@ -22095,13 +22721,15 @@ exports.forceRemoveFromCaches = forceRemoveFromCaches;
 exports.generateId = generateId;
 exports.getAllAddressesFromDb = getAllAddressesFromDb;
 exports.getClient = getClient;
-exports.getContentHash = getContentHash;
+exports.getContentSha256 = getContentSha256;
 exports.getCorrectId = getCorrectId;
 exports.getEasSchemaUidForModel = getEasSchemaUidForModel;
 exports.getGetAdditionalSyncAddresses = getGetAdditionalSyncAddresses;
 exports.getItemData = getItemData;
 exports.getItemModelScope = getItemModelScope;
+exports.getItemStorageLocalFileName = getItemStorageLocalFileName;
 exports.getItemStoragePropertiesForModel = getItemStoragePropertiesForModel;
+exports.getItemStorageSubdir = getItemStorageSubdir;
 exports.getLatestPublishedVersionRow = getLatestPublishedVersionRow;
 exports.getLatestSchemaVersion = getLatestSchemaVersion;
 exports.getModelId = getModelId;
@@ -22109,6 +22737,7 @@ exports.getModelIdByFileId = getModelIdByFileId;
 exports.getPropertyData = getPropertyData$1;
 exports.getPropertyIdForModelAndName = getPropertyIdForModelAndName;
 exports.getRefValueType = getRefValueType;
+exports.getStorageDirForDataType = getStorageDirForDataType;
 exports.htmlEmbeddedImageCoPublish = htmlEmbeddedImageCoPublish;
 exports.importJsonSchema = importJsonSchema;
 exports.isActorStopped = isActorStopped;
@@ -22116,6 +22745,7 @@ exports.isDataType = isDataType;
 exports.isInternalSchema = isInternalSchema;
 exports.isPublishedSeedRef = isPublishedSeedRef;
 exports.isStorageSeedRef = isStorageSeedRef;
+exports.isVerbatimItemStorageDraftRow = isVerbatimItemStorageDraftRow;
 exports.isVersionRevoked = isVersionRevoked;
 exports.listCompleteSchemaFiles = listCompleteSchemaFiles;
 exports.listRelationEasPropertyName = listRelationEasPropertyName;
@@ -22168,4 +22798,4 @@ exports.withSeed = withSeed;
 exports.writeInBatches = writeInBatches;
 exports.writeProcessMachine = writeProcessMachine;
 exports.writeToDatabase = writeToDatabase$1;
-//# sourceMappingURL=index-usKaANAq.js.map
+//# sourceMappingURL=index-C4XlgCJ4.js.map