@seedprotocol/sdk 0.4.5 → 0.4.6

package/dist/{index-DPll6EAp.js → index-Dk73a7JE.js}

@@ -424,6 +424,30 @@ const generateId = () => {
 const toSnakeCase = (str) => {
     return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
 };
+const identifyString = (str) => {
+    try {
+        JSON.parse(str);
+        return 'json';
+    }
+    catch (e) {
+        // Not JSON
+    }
+    if (!str) {
+        return;
+    }
+    if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+        return 'html';
+    }
+    // Simple markdown checks (very naive)
+    if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+        return 'markdown';
+    }
+    if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+        return 'base64';
+    }
+    // Default to plain text if unsure
+    return 'text';
+};
 const getMimeType = (base64) => {
     if (!base64) {
         return null;
@@ -510,6 +534,12 @@ const convertTxIdToImage = async (txId) => {
 const getArweaveUrlForTransaction = (storageTransactionId) => {
     return BaseArweaveClient.getRawUrl(storageTransactionId);
 };
+const getExecutionTime = async (task, args) => {
+    const start = Date.now();
+    await task(...args);
+    return Date.now() - start;
+};
+const capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
 const parseEasRelationPropertyName = (easPropertyName) => {
     // Split the input string on the first underscore
     const [singularProperty, modelName, idSegment] = easPropertyName.split('_');
@@ -525,6 +555,25 @@ const parseEasRelationPropertyName = (easPropertyName) => {
         isList, // True if the property is a list (e.g., 'ids' is present)
     };
 };
+const isBinary = (arrayBuffer) => {
+    const view = new Uint8Array(arrayBuffer);
+    let nonTextCount = 0;
+    const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
+    for (let i = 0; i < view.length; i++) {
+        const byte = view[i];
+        // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
+        if ((byte >= 32 && byte <= 126) || // Printable ASCII
+            byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
+        ) {
+            continue;
+        }
+        nonTextCount++;
+        if (nonTextCount / view.length > threshold) {
+            return true; // More than threshold are non-text bytes
+        }
+    }
+    return false; // Fewer than threshold are non-text bytes
+};
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -532,12 +581,16 @@ var index = /*#__PURE__*/Object.freeze({
     BaseEasClient: BaseEasClient,
     BaseFileManager: BaseFileManager,
     BaseQueryClient: BaseQueryClient,
+    capitalizeFirstLetter: capitalizeFirstLetter,
     convertTxIdToImage: convertTxIdToImage,
     generateId: generateId,
     getArweaveUrlForTransaction: getArweaveUrlForTransaction,
     getCorrectId: getCorrectId,
     getDataTypeFromString: getDataTypeFromString,
+    getExecutionTime: getExecutionTime,
     getMimeType: getMimeType,
+    identifyString: identifyString,
+    isBinary: isBinary,
     parseEasRelationPropertyName: parseEasRelationPropertyName,
     toSnakeCase: toSnakeCase,
     waitForEntityIdle: waitForEntityIdle
@@ -554,7 +607,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-CGdkocQ8.js');
+        const mod = await import('./ModelProperty-Cpd9xiIM.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$s('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -637,7 +690,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                         // schemaFileId to match the database, both will point to the same cached instance.
                         if (dbSchemaFileId) {
                             try {
-                                const { Model } = await Promise.resolve().then(function () { return Model$1; });
+                                const modelMod = await Promise.resolve().then(function () { return Model$1; });
+                                const { Model } = modelMod;
                                 // Access instanceCacheById via type assertion since it's protected
                                 const cacheById = Model.instanceCacheById;
                                 if (cacheById.has(dbSchemaFileId)) {
@@ -742,7 +796,10 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+            const _mod_0 = await import('./Schema-BZKBy5Tx.js');
+            const _ns_0 = _mod_0.b;
+            const schemaMod = _ns_0;
+            const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
             // Wait for schema to load if it's still loading
@@ -813,7 +870,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         let finalModelName = modelName;
         if (db) {
             // Check if this is an internal schema (Seed Protocol)
-            const { isInternalSchema } = await Promise.resolve().then(function () { return constants; });
+            const constantsMod = await Promise.resolve().then(function () { return constants; });
+            const { isInternalSchema } = constantsMod;
             const isInternal = isInternalSchema(schemaName);
             // Only skip duplicate check if:
             // 1. We found a model record to use (modelRecord is set), OR
@@ -828,7 +886,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                     const existingNumbers = new Set(existingNumbersFromSchemaContext ?? []);
                     // First, check Model cache for models (includes models from imported schemas that may not be in DB yet)
                     try {
-                        const { Model } = await Promise.resolve().then(function () { return Model$1; });
+                        const modelMod = await Promise.resolve().then(function () { return Model$1; });
+                        const { Model } = modelMod;
                         // 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.
@@ -887,8 +946,10 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                        const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                        const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                        const { modelSchemas } = modelSchemaSchemaMod;
+                        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$s(`Checking database for duplicate model names in schema "${schemaName}"`);
                         const allModelsForSchema = await db
@@ -961,7 +1022,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Runtime creates use a placeholder cache key in Model.create; move it to the final name. Skip when schema model (_idFromSchema).
         if (!_idFromSchema) {
-            const { Model } = await Promise.resolve().then(function () { return Model$1; });
+            const modelMod = await Promise.resolve().then(function () { return Model$1; });
+            const { Model } = modelMod;
             Model.updateNameIndex('__pending__' + schemaFileId, finalModelName, schemaName, schemaFileId);
         }
         // If model name was changed, store it in a temporary internal field so loadOrCreateModelSuccess can apply it
@@ -980,7 +1042,10 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+            const _mod_1 = await import('./Schema-BZKBy5Tx.js');
+            const _ns_1 = _mod_1.b;
+            const schemaMod = _ns_1;
+            const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
         }
@@ -1023,9 +1088,13 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+            const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+            const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+            const _mod_2 = await import('./Schema-BZKBy5Tx.js');
+            const _ns_2 = _mod_2.b;
+            const schemaMod = _ns_2;
+            const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
             if (!structureResult.isValid) {
@@ -1136,19 +1205,21 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$q(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-CGdkocQ8.js');
+        const mod = await import('./ModelProperty-Cpd9xiIM.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$q('ModelProperty not available from dynamic import');
             sendBack({ type: 'createModelPropertiesError', error: new Error('ModelProperty not available') });
             return;
         }
-        const { eq } = await import('drizzle-orm');
+        const drizzleMod = await import('drizzle-orm');
+        const { eq } = drizzleMod;
         const db = BaseDb.getAppDb();
         for (const [propName, propData] of Object.entries(propertyDefinitions)) {
             // Use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
-            const { generateId } = await Promise.resolve().then(function () { return index; });
+            const helpersMod = await Promise.resolve().then(function () { return index; });
+            const { generateId } = helpersMod;
             const propertyFileId = propData.id || generateId();
             logger$q(`Creating property "${propName}" with fileId "${propertyFileId}"`);
             // Query database to get refModelId if the property has ref/refModelName
@@ -1239,7 +1310,8 @@ const validateEntity = fromPromise(async ({ input }) => {
                 logger$p(structureMsg);
                 console.log(structureMsg); // Always log to console
                 // Use existing Model validation
-                const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+                const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
                 const structureResult = validationService.validateModelStructure(entityInput.entityData);
@@ -1257,7 +1329,10 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$p(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+                            const _mod_3 = await import('./Schema-BZKBy5Tx.js');
+                            const _ns_3 = _mod_3.b;
+                            const schemaMod = _ns_3;
+                            const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
                             });
@@ -1292,7 +1367,8 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+                const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
                 const structureResult = validationService.validatePropertyStructure(entityInput.entityData);
@@ -1306,7 +1382,10 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+                            const _mod_4 = await import('./Schema-BZKBy5Tx.js');
+                            const _ns_4 = _mod_4.b;
+                            const schemaMod = _ns_4;
+                            const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
                             });
@@ -1334,7 +1413,8 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+                const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
                 if (!schemaResult.isValid) {
@@ -1493,6 +1573,42 @@ const escapeSqliteString = (value) => {
     }
     return value.replace(/'/g, "''");
 };
+const getObjectForRow = (row) => {
+    const obj = {};
+    row.columnNames.forEach((colName, index) => {
+        const value = row.row[index];
+        if (typeof value !== 'string') {
+            obj[colName] = row.row[index];
+            return;
+        }
+        // Try to parse the value as JSON
+        try {
+            obj[colName] = JSON.parse(value);
+        }
+        catch (e) {
+            // If it fails, just set the value as a string
+            obj[colName] = value;
+        }
+    });
+    return obj;
+};
+const getSqlResultObject = (queryResult) => {
+    if (!queryResult || !queryResult.rows || queryResult.rows.length === 0) {
+        return;
+    }
+    let obj;
+    if (queryResult.rows.length === 1) {
+        obj = getObjectForRow(queryResult.rows[0]);
+    }
+    if (queryResult.rows.length > 1) {
+        obj = queryResult.rows.reduce((acc, row) => {
+            const rowObj = getObjectForRow(row);
+            acc.push(rowObj);
+            return acc;
+        }, []);
+    }
+    return obj;
+};
 const createOrUpdate = async (db, table, values) => {
     const valueFilters = [];
     const propertiesToExcludeFromDb = ['ref'];
@@ -1828,7 +1944,7 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
         const cacheKey = `${modelName}:${propertyName}`;
         // First, check the in-memory cache (for current session edits)
         // Robust dynamic import for consumer re-bundling (named or default export)
-        const mod = await import('./ModelProperty-CGdkocQ8.js');
+        const mod = await import('./ModelProperty-Cpd9xiIM.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$o('ModelProperty not available from dynamic import');
@@ -2071,7 +2187,8 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 schema = pendingProperties;
             }
             else {
-                const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+                const modelHelpersMod = await Promise.resolve().then(function () { return model; });
+                const { modelPropertiesToObject } = modelHelpersMod;
                 const modelProperties = modelClass.properties || [];
                 schema = modelPropertiesToObject(modelProperties);
             }
@@ -2091,7 +2208,8 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 // If no propertyFileId from map, generate a random ID
                 // IDs should be generated in the import process before calling addModelsToDb
                 if (!propertyFileId) {
-                    const { generateId } = await Promise.resolve().then(function () { return index; });
+                    const helpersIndexMod = await Promise.resolve().then(function () { return index; });
+                    const { generateId } = helpersIndexMod;
                     propertyFileId = generateId();
                     logger$o(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
                 }
@@ -2636,7 +2754,8 @@ async function writeModelToDb(modelFileId, data) {
                 throw new Error(`Model with id ${modelId} does not exist in database. Cannot create join record.`);
             }
             // Verify schemaId exists and get name/fileId for invalidation broadcast
-            const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+            const { schemas: schemasTable } = schemaSchemaMod;
             const schemaCheck = await db
                 .select({
                 id: schemasTable.id,
@@ -2702,7 +2821,8 @@ async function writeModelToDb(modelFileId, data) {
             else {
                 // Generate random propertyFileId
                 // IDs should be generated in the import process before calling writeModelToDb
-                const { generateId } = await Promise.resolve().then(function () { return index; });
+                const helpersIndexMod = await Promise.resolve().then(function () { return index; });
+                const { generateId } = helpersIndexMod;
                 propertyFileId = generateId();
                 logger$o(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
@@ -2828,6 +2948,68 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
         }
     }
 }
+/**
+ * Get schema database ID from schema name or schemaFileId
+ * @param schemaNameOrFileId - Schema name (string) or schemaFileId (string)
+ * @returns Schema database ID
+ * @throws Error if schema not found
+ */
+async function getSchemaId(schemaNameOrFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+    const { schemas: schemasTable } = schemaSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, desc } = drizzleMod;
+    // Try to find by schemaFileId first (more reliable)
+    let records = await db
+        .select()
+        .from(schemasTable)
+        .where(eq(schemasTable.schemaFileId, schemaNameOrFileId))
+        .orderBy(desc(schemasTable.version))
+        .limit(1);
+    // If not found by schemaFileId, try by name
+    if (records.length === 0) {
+        records = await db
+            .select()
+            .from(schemasTable)
+            .where(eq(schemasTable.name, schemaNameOrFileId))
+            .orderBy(desc(schemasTable.version))
+            .limit(1);
+    }
+    if (records.length === 0) {
+        throw new Error(`Schema "${schemaNameOrFileId}" not found in database`);
+    }
+    return records[0].id;
+}
+/**
+ * Get schema database ID from schemaFileId
+ * @param schemaFileId - The schema file ID
+ * @returns Schema database ID
+ * @throws Error if schema not found
+ */
+async function getSchemaIdByFileId(schemaFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+    const { schemas: schemasTable } = schemaSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, desc } = drizzleMod;
+    const records = await db
+        .select()
+        .from(schemasTable)
+        .where(eq(schemasTable.schemaFileId, schemaFileId))
+        .orderBy(desc(schemasTable.version))
+        .limit(1);
+    if (records.length === 0) {
+        throw new Error(`Schema with file ID "${schemaFileId}" not found in database`);
+    }
+    return records[0].id;
+}
 /**
  * Get model database ID from model name or modelFileId
  * @param modelNameOrFileId - Model name (string) or modelFileId (string)
@@ -2840,8 +3022,10 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-    const { eq, and, or } = await import('drizzle-orm');
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+    const { models: modelsTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, and, or } = drizzleMod;
     // Try to find by modelFileId first (more reliable)
     let records = await db
         .select()
@@ -2853,8 +3037,10 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
         [eq(modelsTable.name, modelNameOrFileId)];
         // If schema is provided, narrow the search
         if (schemaNameOrId !== undefined) {
-            const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-            const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+            const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+            const { modelSchemas } = modelSchemaSchemaMod;
+            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+            const { schemas: schemasTable } = schemaSchemaMod;
             if (typeof schemaNameOrId === 'number') {
                 // schemaNameOrId is schemaId
                 records = await db
@@ -2901,8 +3087,10 @@ async function getModelIdByFileId(modelFileId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-    const { eq } = await import('drizzle-orm');
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+    const { models: modelsTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq } = drizzleMod;
     const records = await db
         .select()
         .from(modelsTable)
@@ -2924,7 +3112,11 @@ var db = /*#__PURE__*/Object.freeze({
     getModelId: getModelId,
     getModelIdByFileId: getModelIdByFileId,
     getModelNameByModelId: getModelNameByModelId,
+    getObjectForRow: getObjectForRow,
     getPropertyModelNameAndDataType: getPropertyModelNameAndDataType,
+    getSchemaId: getSchemaId,
+    getSchemaIdByFileId: getSchemaIdByFileId,
+    getSqlResultObject: getSqlResultObject,
     loadModelsFromDbForSchema: loadModelsFromDbForSchema,
     renameModelInDb: renameModelInDb,
     savePropertyToDb: savePropertyToDb,
@@ -2978,7 +3170,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-CGdkocQ8.js');
+                    const mod = await import('./ModelProperty-Cpd9xiIM.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -3369,7 +3561,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-CGdkocQ8.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-Cpd9xiIM.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4215,7 +4407,8 @@ const fetchDataFromEas = fromCallback(({ sendBack, input: { context } }) => {
         }
         else if (modelName) {
             // Dynamic import to break circular dependency
-            const { Model } = await Promise.resolve().then(function () { return Model$1; });
+            const modelMod = await Promise.resolve().then(function () { return Model$1; });
+            const { Model } = modelMod;
             const model = Model.getByName(modelName);
             modelSchema = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
         }
@@ -4346,7 +4539,8 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) =
         return propertyInstances;
     }
     try {
-        const { ItemProperty } = await Promise.resolve().then(function () { return ItemProperty$1; });
+        const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
+        const { ItemProperty } = itemPropertyMod;
         // Create instances for all metadata records in parallel
         const createPromises = metadataRows.map(async (metaRow) => {
             try {
@@ -4539,14 +4733,17 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
             return;
         }
         try {
-            const { Item } = await Promise.resolve().then(function () { return Item$1; });
+            const itemMod = await Promise.resolve().then(function () { return Item$1; });
+            const { Item } = itemMod;
             const item = await Item.find({ seedLocalId });
             if (!item) {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const { getPublishUploads } = await import('./getPublishUploads-Dc-HqhO8.js');
-            const { getPublishPayload } = await import('./getPublishPayload-uLm0AqN_.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-DhvcKD_9.js');
+            const { getPublishUploads } = getPublishUploadsMod;
+            const getPublishPayloadMod = await import('./getPublishPayload-CWiLI1yd.js');
+            const { getPublishPayload } = getPublishPayloadMod;
             await getPublishUploads(item);
             // For first iteration: no Arweave sign/upload - pass empty uploadedTransactions.
             // Real upload/submit can be wired in later.
@@ -5276,7 +5473,8 @@ const getModelSchemasFromEas = async () => {
     const queryClient = BaseQueryClient.getQueryClient();
     const easClient = BaseEasClient.getEasClient();
     // Dynamic import to break circular dependency
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     const allModels = await Model.all();
     const modelNames = allModels.map(m => m.modelName).filter((name) => !!name);
     // If there are no models, return empty array instead of querying
@@ -5630,7 +5828,8 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-LfXKx_PE.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
@@ -5968,7 +6167,8 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-LfXKx_PE.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
         // Re-check types with dynamically imported ModelPropertyDataTypes
@@ -6120,7 +6320,8 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = await Promise.resolve().then(function () { return Item$1; });
+            const itemMod = await Promise.resolve().then(function () { return Item$1; });
+            const { Item } = itemMod;
             const item = await Item.find({
                 seedLocalId: seedLocalId ?? undefined,
                 modelName,
@@ -6440,7 +6641,8 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-LfXKx_PE.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -6797,7 +6999,8 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-LfXKx_PE.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
         }
@@ -7595,7 +7798,8 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+            const schemaMod = await import('./index-LfXKx_PE.js');
+            const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
             if (context.seedLocalId && context.propertyName) {
@@ -7708,9 +7912,14 @@ class ItemProperty {
             setupState.subscriptionSetUp = true;
             logger(`[ItemProperty._setupLiveQuerySubscription] Setting up liveQuery for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             try {
-                const { metadata } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
-                const { eq, and, isNotNull } = await import('drizzle-orm');
-                const { getMetadataLatest } = await Promise.resolve().then(function () { return metadataLatest; });
+                const _mod_5 = await import('./index-DBy53qbb.js');
+                const _ns_5 = _mod_5.s;
+                const seedSchemaMod = _ns_5;
+                const { metadata } = seedSchemaMod;
+                const drizzleMod = await import('drizzle-orm');
+                const { eq, and, isNotNull } = drizzleMod;
+                const metadataLatestMod = await Promise.resolve().then(function () { return metadataLatest; });
+                const { getMetadataLatest } = metadataLatestMod;
                 const db = BaseDb.getAppDb();
                 if (!db) {
                     logger('[ItemProperty._setupLiveQuerySubscription] Database not available');
@@ -8223,8 +8432,12 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const { metadata } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
-                    const { and, eq, or } = await import('drizzle-orm');
+                    const _mod_6 = await import('./index-DBy53qbb.js');
+                    const _ns_6 = _mod_6.s;
+                    const seedSchemaMod = _ns_6;
+                    const { metadata } = seedSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { and, eq, or } = drizzleMod;
                     const conditions = [eq(metadata.propertyName, propertyName)];
                     if (seedLocalId && seedUid) {
                         conditions.push(or(eq(metadata.seedLocalId, seedLocalId), eq(metadata.seedUid, seedUid)));
@@ -8239,7 +8452,8 @@ class ItemProperty {
                         await db.delete(metadata).where(and(...conditions));
                     }
                 }
-                const { Item } = await Promise.resolve().then(function () { return Item$1; });
+                const itemMod = await Promise.resolve().then(function () { return Item$1; });
+                const { Item } = itemMod;
                 const item = Item.getById((seedLocalId || seedUid));
                 if (item) {
                     item.getService().send({ type: 'removePropertyInstance', propertyName });
@@ -8265,7 +8479,8 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
     const newSeedId = await createSeed({ type: seedType });
     const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase$1(modelName) });
     // Dynamic import to break circular dependency
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     const model = await Model.getByNameAsync(modelName);
     const propertySchemas = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
     for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
@@ -8473,12 +8688,14 @@ class Item {
         };
         this.getPublishUploads = async () => {
             // Use dynamic import to break circular dependency
-            const { getPublishUploads } = await import('./getPublishUploads-Dc-HqhO8.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-DhvcKD_9.js');
+            const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this);
         };
         this.getPublishPayload = async (uploadedTransactions) => {
             // Use dynamic import to break circular dependency
-            const { getPublishPayload } = await import('./getPublishPayload-uLm0AqN_.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-CWiLI1yd.js');
+            const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions);
         };
         this.persistSeedUid = async () => {
@@ -8753,8 +8970,10 @@ class Item {
             let modelRecords;
             // If we have a schema name, join with modelSchemas to filter by schema
             if (schemaName) {
-                const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                const { modelSchemas } = modelSchemaSchemaMod;
+                const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+                const { schemas: schemasTable } = schemaSchemaMod;
                 modelRecords = await db
                     .select({ id: models$1.id })
                     .from(models$1)
@@ -9344,9 +9563,14 @@ class Item {
             setupState.subscriptionSetUp = true;
             logger(`[Item._setupLiveQuerySubscription] Setting up liveQuery for seedLocalId: ${seedLocalId}`);
             try {
-                const { seeds, versions, metadata } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
-                const { eq, and } = await import('drizzle-orm');
-                const { getVersionData } = await Promise.resolve().then(function () { return versionData; });
+                const _mod_7 = await import('./index-DBy53qbb.js');
+                const _ns_7 = _mod_7.s;
+                const seedSchemaMod = _ns_7;
+                const { seeds, versions, metadata } = seedSchemaMod;
+                const drizzleMod = await import('drizzle-orm');
+                const { eq, and } = drizzleMod;
+                const versionDataMod = await Promise.resolve().then(function () { return versionData; });
+                const { getVersionData } = versionDataMod;
                 const db = BaseDb.getAppDb();
                 if (!db) {
                     logger('[Item._setupLiveQuerySubscription] Database not available');
@@ -9389,7 +9613,8 @@ class Item {
                 // CRITICAL: Create ItemProperty instances BEFORE updating context
                 if (initialMetadataIds.length > 0) {
                     try {
-                        const { ItemProperty } = await Promise.resolve().then(function () { return ItemProperty$1; });
+                        const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
+                        const { ItemProperty } = itemPropertyMod;
                         const itemModelName = this._service.getSnapshot().context.modelName;
                         const createPromises = initialMetadata.map(async (metaRow) => {
                             try {
@@ -9497,7 +9722,8 @@ class Item {
                             // CRITICAL: Create ItemProperty instances BEFORE updating context
                             if (metadataRows.length > 0) {
                                 try {
-                                    const { ItemProperty } = await Promise.resolve().then(function () { return ItemProperty$1; });
+                                    const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
+                                    const { ItemProperty } = itemPropertyMod;
                                     const itemModelName = this._service.getSnapshot().context.modelName;
                                     const createPromises = metadataRows.map(async (metaRow) => {
                                         try {
@@ -9695,7 +9921,8 @@ const setupServicesEventHandlers = () => {
 const schemaStringToModelRecord = new Map();
 const getModelSchemas = async () => {
     // Dynamic import to break circular dependency
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     const allModels = await Model.all();
     const modelRecords = [];
     const appDb = BaseDb.getAppDb();
@@ -9930,7 +10157,8 @@ const saveEasPropertiesToDb = async ({ itemProperties, itemSeeds, }) => {
     isSavingToDb = true;
     const propertyUids = itemProperties.map((property) => property.id);
     // Dynamic import to break circular dependency
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     const allModels = await Model.all();
     const models = Object.fromEntries(allModels.map(m => [m.modelName, m]));
     const appDb = BaseDb.getAppDb();
@@ -10254,21 +10482,21 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         let PathResolver;
         let EasClient;
         if (isBrowser()) {
-            FileManager = (await import('./FileManager-C9zr4AJe.js')).FileManager;
-            Db = (await import('./Db-DjFdIdR9.js')).Db;
-            QueryClient = (await import('./QueryClient-ByKPdRmE.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-CgWK-JgT.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-CX6GHoTS.js')).PathResolver;
-            EasClient = (await import('./EasClient-Aojewp6P.js')).EasClient;
+            FileManager = (await import('./FileManager-BohtoKYo.js')).FileManager;
+            Db = (await import('./Db-C9fppVRl.js')).Db;
+            QueryClient = (await import('./QueryClient-BUoz2Vb0.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-Caio37h1.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-CLZUWoX2.js')).PathResolver;
+            EasClient = (await import('./EasClient-DQGAIj-b.js')).EasClient;
         }
         else if (isNode()) {
             console.log('isNode');
-            FileManager = (await import('./FileManager-CxGJLw5C.js')).FileManager;
-            Db = (await import('./Db-DjofXdeU.js')).Db;
-            QueryClient = (await import('./QueryClient-Cb1iJO-x.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-WcG8CZAE.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-z_WX47_o.js')).PathResolver;
-            EasClient = (await import('./EasClient-BVFXp2O6.js')).EasClient;
+            FileManager = (await import('./FileManager-d64CkqXy.js')).FileManager;
+            Db = (await import('./Db-DJAG-5Di.js')).Db;
+            QueryClient = (await import('./QueryClient-COQ_Rs4-.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-DLKAaS3K.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-D6M0rzKV.js')).PathResolver;
+            EasClient = (await import('./EasClient-T7Nx9185.js')).EasClient;
         }
         else {
             throw new Error(`Unable to determine environment. isBrowser()=${isBrowser()}, isNode()=${isNode()}. Platform-specific implementations could not be loaded.`);
@@ -10520,7 +10748,8 @@ const downloadAllFilesBinaryRequestHandler = async () => {
     }
     if (!BaseDb.isAppDbReady()) {
         // Wait for ClientManager to be ready (DB_INIT state or later)
-        const { getClient } = await Promise.resolve().then(function () { return ClientManager$1; });
+        const clientManagerMod = await Promise.resolve().then(function () { return ClientManager$1; });
+        const { getClient } = clientManagerMod;
         const clientManager = getClient();
         const clientService = clientManager.getService();
         await waitFor(clientService, (snapshot) => {
@@ -11458,8 +11687,10 @@ const logger$3 = debug('seedSdk:imports:json');
  * @returns Promise that resolves when properties are found, or rejects if not found after max retries
  */
 const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const { properties: propertiesTable } = await Promise.resolve().then(function () { return ModelSchema; });
-    const { eq } = await import('drizzle-orm');
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+    const { properties: propertiesTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq } = drizzleMod;
     console.log(`[verifyPropertiesPersisted] Starting verification for model "${modelName}" (modelId: ${modelId})`);
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         const props = await db
@@ -11775,7 +12006,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         schemaFile = transformImportToSchemaFile(importData, version);
     }
     // Check if this is an internal SDK schema (should not create files in app directory)
-    const { isInternalSchema } = await Promise.resolve().then(function () { return constants; });
+    const constantsMod = await Promise.resolve().then(function () { return constants; });
+    const { isInternalSchema } = constantsMod;
     const isInternal = isInternalSchema(schemaFile.metadata.name, schemaFile.id);
     if (isInternal) {
         logger$3(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
@@ -11869,7 +12101,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const { addSchemaToDb, addModelsToDb } = await Promise.resolve().then(function () { return db; });
+        const dbMod = await Promise.resolve().then(function () { return db; });
+        const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
             const db = BaseDb.getAppDb();
@@ -11890,9 +12123,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     // CRITICAL: Verify all expected models are linked via join table
                     // Retry querying until all models are visible (browser environments may have delays)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-                    const { eq, and } = await import('drizzle-orm');
+                    const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                    const { modelSchemas } = modelSchemaSchemaMod;
+                    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { models: modelsTable } = modelSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { eq, and } = drizzleMod;
                     let allModelsLinked = false;
                     for (let attempt = 0; attempt < 10; attempt++) {
                         const modelLinks = await db
@@ -12063,10 +12299,11 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                             }
                         }
                     }
-                    // After properties are created, ensure schemaFile has the correct IDs from database
+                    // After properties are created (internal schema path), ensure schemaFile has the correct IDs from database
                     // Query the database to get the actual schemaFileId values that were used
                     // This ensures schemaData matches what's actually in the database
-                    const { properties: propertiesTable } = await Promise.resolve().then(function () { return ModelSchema; });
+                    const modelSchemaMod1 = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { properties: propertiesTable } = modelSchemaMod1;
                     let schemaFileUpdated = false;
                     for (const [modelName, modelFileId] of modelFileIds.entries()) {
                         // Get model record to find modelId
@@ -12099,7 +12336,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     // This is important even if nothing changed, to ensure consistency
                     const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                     // Update the schema record in the database with current schemaData
-                    const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const schemaSchemaMod1 = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const { schemas: schemasTable } = schemaSchemaMod1;
                     await db
                         .update(schemasTable)
                         .set({ schemaData: updatedSchemaData })
@@ -12313,7 +12551,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const { addSchemaToDb, addModelsToDb } = await Promise.resolve().then(function () { return db; });
+        const dbMod = await Promise.resolve().then(function () { return db; });
+        const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
             const db = BaseDb.getAppDb();
@@ -12335,9 +12574,12 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     await new Promise(resolve => setTimeout(resolve, 200));
                     console.log(`[importJsonSchema] Starting property verification for schema "${schemaName}" (schemaRecord.id: ${schemaRecord.id})`);
                     // Query the database to get model IDs that were just created
-                    const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-                    const { eq } = await import('drizzle-orm');
+                    const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                    const { modelSchemas } = modelSchemaSchemaMod;
+                    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { models: modelsTable } = modelSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { eq } = drizzleMod;
                     // Try to find models directly by schemaFileId first (more reliable than join table)
                     const seedModelId = modelFileIds.get('Seed');
                     let seedModel = [];
@@ -12399,10 +12641,11 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                             }
                         }
                     }
-                    // After properties are created, ensure schemaFile has the correct IDs from database
+                    // After properties are created (file path), ensure schemaFile has the correct IDs from database
                     // Query the database to get the actual schemaFileId values that were used
                     // This ensures schemaData matches what's actually in the database
-                    const { properties: propertiesTable } = await Promise.resolve().then(function () { return ModelSchema; });
+                    const modelSchemaMod2 = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { properties: propertiesTable } = modelSchemaMod2;
                     let schemaFileUpdated = false;
                     for (const [modelName, modelFileId] of modelFileIds.entries()) {
                         // Get model record to find modelId
@@ -12435,7 +12678,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     // This is important even if nothing changed, to ensure consistency
                     const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                     // Update the schema record in the database with current schemaData
-                    const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const { schemas: schemasTable } = schemaSchemaMod;
                     await db
                         .update(schemasTable)
                         .set({ schemaData: updatedSchemaData })
@@ -12476,7 +12720,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
  */
 const createModelFromJson = async (modelName, modelDef, schemaName, modelFileId, // Optional modelFileId from JSON file
 propertyFileIds) => {
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     // Convert JSON properties to schema format
     const convertedProperties = {};
     if (modelDef.properties) {
@@ -13327,7 +13572,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-CGdkocQ8.js')
+const modelPropertyImportPromise = import('./ModelProperty-Cpd9xiIM.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -13344,7 +13589,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; })
+const schemaImportPromise = (async () => { const _mod_8 = await import('./Schema-BZKBy5Tx.js'); return _mod_8.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -14845,7 +15090,8 @@ class Model {
             doDestroy: async () => {
                 const db = BaseDb.getAppDb();
                 if (db && modelFileId) {
-                    const { eq } = await import('drizzle-orm');
+                    const drizzleMod = await import('drizzle-orm');
+                    const { eq } = drizzleMod;
                     const modelRecords = await db
                         .select()
                         .from(models$1)
@@ -15177,4 +15423,4 @@ Type.Record(Type.String(), Type.Any());
 Type.Record(Type.String(), TProperty);
 
 export { getItemData as $, config as A, Boolean$1 as B, metadata$1 as C, Date$1 as D, EAS_ENDPOINT as E, modelRelations as F, modelSchemas as G, modelUids as H, Image as I, Json as J, modelsRelations as K, List as L, Model as M, Number$1 as N, propertiesRelations as O, Property as P, propertyUidRelations as Q, Relation as R, SEED_CONFIG_FILE as S, TPropertyDataType as T, propertyUids as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, schemas as W, seeds as X, versions as Y, ZERO_BYTES32 as Z, graphql as _, ModelPropertyDataTypes as a, Item as a0, saveAppState as a1, addModelsToDb$1 as a2, SCHEMA_NJK as a3, ItemProperty as a4, eventEmitter as a5, ClientManager as a6, INIT_SCRIPT_SUCCESS_MESSAGE as a7, SCHEMA_TS as a8, importJsonSchema as a9, SeedModels as aA, getArweaveUrlForTransaction as aB, createSchema as aC, readSchema as aD, listCompleteSchemaFiles as aE, getSchemaNameFromId as aF, getLatestSchemaVersion as aG, createModelsFromJson as aH, SEED_PROTOCOL_SCHEMA_NAME as aI, addSchemaToDb as aJ, loadModelsFromDbForSchema as aK, isInternalSchema as aL, createModelFromJson as aM, ConflictError as aN, unloadEntity as aO, clearDestroySubscriptions as aP, setupEntityLiveQuery as aQ, ModelSchema as aR, BaseFileManager$1 as aS, db as aT, schema as aU, SEEDPROTOCOL_Seed_Protocol_v1 as aV, Model$1 as aW, loadSchemaFromFile as aa, readJsonImportFile as ab, transformImportToSchemaFile as ac, writeProcessMachine as ad, generateId as ae, waitForEntityIdle as af, createReactiveProxy as ag, findEntity as ah, forceRemoveFromCaches as ai, runDestroyLifecycle as aj, getModelIdByFileId as ak, getModelId as al, getClient as am, ClientManagerState as an, getVersionData$1 as ao, createNewItem as ap, loadAllSchemasFromDb as aq, getSeedsBySchemaName as ar, GET_SEEDS as as, getItemVersionsFromEas as at, getItemPropertiesFromEas as au, setSchemaUidForSchemaDefinition as av, parseEasRelationPropertyName as aw, getModelSchemasFromEas as ax, getSchemaUidBySchemaName as ay, getSeedsFromSchemaUids as az, TStorageType as b, TProperty as c, TPropertyConstructor as d, PropertyMetadataKey as e, PropertyConstructor as f, Text as g, TValidationRules as h, getSchemaUidForModel as i, getCorrectId as j, defaultAttestationData as k, INTERNAL_DATA_TYPES as l, getSchemaUidForSchemaDefinition as m, getSchemaForItemProperty as n, modelPropertiesToObject as o, BaseDb as p, models$1 as q, properties as r, BaseQueryClient as s, toSnakeCase as t, BaseArweaveClient as u, BasePathResolver as v, BaseEasClient as w, BaseFileManager as x, appState as y, SEED_CONFIG_FALLBACKS as z };
-//# sourceMappingURL=index-DPll6EAp.js.map
+//# sourceMappingURL=index-Dk73a7JE.js.map