@seedprotocol/sdk 0.4.5 → 0.4.6

package/dist/cjs/{index-BeKPbbk0.js → index-CXI4VF1H.js}

@@ -464,6 +464,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;
@@ -541,6 +565,21 @@ const convertTxIdToImage = async (txId) => {
     const imageBlob = new Blob([uint]);
     return URL.createObjectURL(imageBlob);
 };
+/**
+ * Constructs an Arweave URL for a storage transaction ID
+ * @param storageTransactionId - The Arweave transaction ID
+ * @returns The full URL to access the transaction data on Arweave (e.g., https://arweave.net/raw/{transactionId})
+ * @deprecated Use BaseArweaveClient.getRawUrl() instead for better consistency and testability
+ */
+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('_');
@@ -556,6 +595,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,
@@ -563,11 +621,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
@@ -584,7 +647,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$x('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -667,7 +730,8 @@ const loadOrCreateModel = xstate.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)) {
@@ -772,7 +836,8 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CVs9J6eP.js'); }).then(function (n) { return n.Schema$1; });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+            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
@@ -843,7 +908,8 @@ const loadOrCreateModel = xstate.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
@@ -858,7 +924,8 @@ const loadOrCreateModel = xstate.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.
@@ -917,8 +984,10 @@ const loadOrCreateModel = xstate.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$x(`Checking database for duplicate model names in schema "${schemaName}"`);
                         const allModelsForSchema = await db
@@ -991,7 +1060,8 @@ const loadOrCreateModel = xstate.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
@@ -1010,7 +1080,8 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CVs9J6eP.js'); }).then(function (n) { return n.Schema$1; });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+            const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
         }
@@ -1053,9 +1124,11 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CDKcVRFQ.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+            const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CVs9J6eP.js'); }).then(function (n) { return n.Schema$1; });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+            const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
             if (!structureResult.isValid) {
@@ -1166,19 +1239,21 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$v(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$v('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$v(`Creating property "${propName}" with fileId "${propertyFileId}"`);
             // Query database to get refModelId if the property has ref/refModelName
@@ -1269,7 +1344,8 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 logger$u(structureMsg);
                 console.log(structureMsg); // Always log to console
                 // Use existing Model validation
-                const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CDKcVRFQ.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
                 const structureResult = validationService.validateModelStructure(entityInput.entityData);
@@ -1287,7 +1363,8 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$u(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CVs9J6eP.js'); }).then(function (n) { return n.Schema$1; });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+                            const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
                             });
@@ -1322,7 +1399,8 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CDKcVRFQ.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
                 const structureResult = validationService.validatePropertyStructure(entityInput.entityData);
@@ -1336,7 +1414,8 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const { Schema } = await Promise.resolve().then(function () { return require('./Schema-CVs9J6eP.js'); }).then(function (n) { return n.Schema$1; });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+                            const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
                             });
@@ -1364,7 +1443,8 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const { SchemaValidationService } = await Promise.resolve().then(function () { return require('./SchemaValidationService-CDKcVRFQ.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
                 if (!schemaResult.isValid) {
@@ -1542,6 +1622,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'];
@@ -1877,7 +1993,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 Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -2120,7 +2236,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);
             }
@@ -2140,7 +2257,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$t(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
                 }
@@ -2685,7 +2803,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,
@@ -2751,7 +2870,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$t(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
@@ -2877,6 +2997,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)
@@ -2889,8 +3071,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()
@@ -2902,8 +3086,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
@@ -2950,8 +3136,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)
@@ -2973,7 +3161,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,
@@ -3027,7 +3219,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-BeJvgKMw.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -3418,7 +3610,7 @@ 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-BeJvgKMw.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4264,7 +4456,8 @@ const fetchDataFromEas = xstate.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;
         }
@@ -4395,7 +4588,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 {
@@ -4588,14 +4782,17 @@ const runPublish = xstate.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 Promise.resolve().then(function () { return require('./getPublishUploads-CnC9aYxs.js'); });
-            const { getPublishPayload } = await Promise.resolve().then(function () { return require('./getPublishPayload-BD1qRob1.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-5_oXzwol.js'); });
+            const { getPublishUploads } = getPublishUploadsMod;
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BcjCN_bD.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.
@@ -5325,7 +5522,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
@@ -5654,7 +5852,8 @@ 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 { ModelPropertyDataTypes } = await Promise.resolve().then(function () { return require('./index-Dnywap_P.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
@@ -5992,7 +6191,8 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await Promise.resolve().then(function () { return require('./index-Dnywap_P.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
         // Re-check types with dynamically imported ModelPropertyDataTypes
@@ -6144,7 +6344,8 @@ const hydrateFromDb = xstate.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,
@@ -6464,7 +6665,8 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await Promise.resolve().then(function () { return require('./index-Dnywap_P.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -6821,7 +7023,8 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await Promise.resolve().then(function () { return require('./index-Dnywap_P.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
         }
@@ -7619,7 +7822,8 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const { ModelPropertyDataTypes } = await Promise.resolve().then(function () { return require('./index-Dnywap_P.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+            const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
             if (context.seedLocalId && context.propertyName) {
@@ -7732,9 +7936,12 @@ class ItemProperty {
             setupState.subscriptionSetUp = true;
             logger(`[ItemProperty._setupLiveQuerySubscription] Setting up liveQuery for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             try {
-                const { metadata } = await Promise.resolve().then(function () { return schema$1; });
-                const { eq, and, isNotNull } = await import('drizzle-orm');
-                const { getMetadataLatest } = await Promise.resolve().then(function () { return metadataLatest; });
+                const seedSchemaMod = await Promise.resolve().then(function () { return schema$1; });
+                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');
@@ -8247,8 +8454,10 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const { metadata } = await Promise.resolve().then(function () { return schema$1; });
-                    const { and, eq, or } = await import('drizzle-orm');
+                    const seedSchemaMod = await Promise.resolve().then(function () { return schema$1; });
+                    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)));
@@ -8263,7 +8472,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 });
@@ -8289,7 +8499,8 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
     const newSeedId = await createSeed({ type: seedType });
     const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: casing.toSnakeCase(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)) {
@@ -8497,12 +8708,14 @@ class Item {
         };
         this.getPublishUploads = async () => {
             // Use dynamic import to break circular dependency
-            const { getPublishUploads } = await Promise.resolve().then(function () { return require('./getPublishUploads-CnC9aYxs.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-5_oXzwol.js'); });
+            const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this);
         };
         this.getPublishPayload = async (uploadedTransactions) => {
             // Use dynamic import to break circular dependency
-            const { getPublishPayload } = await Promise.resolve().then(function () { return require('./getPublishPayload-BD1qRob1.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BcjCN_bD.js'); });
+            const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions);
         };
         this.persistSeedUid = async () => {
@@ -8777,8 +8990,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)
@@ -9368,9 +9583,12 @@ class Item {
             setupState.subscriptionSetUp = true;
             logger(`[Item._setupLiveQuerySubscription] Setting up liveQuery for seedLocalId: ${seedLocalId}`);
             try {
-                const { seeds, versions, metadata } = await Promise.resolve().then(function () { return schema$1; });
-                const { eq, and } = await import('drizzle-orm');
-                const { getVersionData } = await Promise.resolve().then(function () { return versionData; });
+                const seedSchemaMod = await Promise.resolve().then(function () { return schema$1; });
+                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');
@@ -9413,7 +9631,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 {
@@ -9521,7 +9740,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 {
@@ -9719,7 +9939,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();
@@ -9954,7 +10175,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();
@@ -10544,7 +10766,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 xstate.waitFor(clientService, (snapshot) => {
@@ -11374,8 +11597,10 @@ const logger$8 = 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
@@ -11691,7 +11916,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$8(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
@@ -11785,7 +12011,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();
@@ -11806,9 +12033,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
@@ -11979,10 +12209,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
@@ -12015,7 +12246,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 })
@@ -12229,7 +12461,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();
@@ -12251,9 +12484,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 = [];
@@ -12315,10 +12551,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
@@ -12351,7 +12588,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 })
@@ -12392,7 +12630,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) {
@@ -13243,7 +13482,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-BeJvgKMw.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -13260,7 +13499,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-CVs9J6eP.js'); }).then(function (n) { return n.Schema$1; })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -14761,7 +15000,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)
@@ -15244,7 +15484,8 @@ var FileManager$1 = /*#__PURE__*/Object.freeze({
 const logger$4 = debug('seedSdk:node:db:Db');
 const getConfig = async (dotSeedDir, config) => {
     // Create config inline - config values can be passed in or use defaults
-    const { defineConfig } = await import('drizzle-kit');
+    const drizzleKitMod = await import('drizzle-kit');
+    const { defineConfig } = drizzleKitMod;
     const appSchemaDir = config?.schemaDir || path.join(dotSeedDir, 'schema');
     const outDir = config?.outDir || `${dotSeedDir}/db`;
     const dbUrl = config?.dbUrl || `${dotSeedDir}/db/seed.db`;
@@ -15460,7 +15701,8 @@ class Db extends BaseDb {
             // In drizzle-kit, migrations are generated in the 'out' directory (which is pathToDbDir)
             // migrate(this.db, { migrationsFolder: pathToDbDir })
             // NEW CODE: Use libsql migrator
-            const { migrate } = await import('drizzle-orm/libsql/migrator');
+            const migratorMod = await import('drizzle-orm/libsql/migrator');
+            const { migrate } = migratorMod;
             // migrationsFolder should point to the directory containing migration SQL files
             // In drizzle-kit, migrations are generated in the 'out' directory (which is pathToDbDir)
             await migrate(this.db, { migrationsFolder: pathToDbDir });
@@ -16008,7 +16250,7 @@ const getTsImport = async (filePath) => {
 
 // Get the directory of this file to resolve relative paths
 // @ts-ignore - rollup plugin-typescript doesn't recognize import.meta with module: "preserve"
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-BeKPbbk0.js', document.baseURI).href)));
+const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-CXI4VF1H.js', document.baseURI).href)));
 path.dirname(__filename$1);
 const commandExists = (command) => {
     try {
@@ -16559,4 +16801,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-BeKPbbk0.js.map
+//# sourceMappingURL=index-CXI4VF1H.js.map