@seedprotocol/sdk 0.4.5 → 0.4.7

package/dist/cjs/{index-BeKPbbk0.js → index-B95Ng80C.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-DpjD0o0E.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-DkSBMBwz.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-DkSBMBwz.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-O3FCMROl.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-DkSBMBwz.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-DpjD0o0E.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-O3FCMROl.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-DkSBMBwz.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-O3FCMROl.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-DkSBMBwz.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-O3FCMROl.js'); });
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
                 if (!schemaResult.isValid) {
@@ -1400,6 +1480,7 @@ const seeds = sqliteCore.sqliteTable('seeds', {
     uid: sqliteCore.text('uid'),
     schemaUid: sqliteCore.text('schema_uid'),
     type: sqliteCore.text('type'),
+    publisher: sqliteCore.text('publisher'),
     attestationRaw: sqliteCore.text('attestation_raw'),
     attestationCreatedAt: sqliteCore.int('attestation_created_at'),
     createdAt: sqliteCore.int('created_at'),
@@ -1542,6 +1623,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 +1994,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-DpjD0o0E.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -2120,7 +2237,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 +2258,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)`);
                 }
@@ -2555,13 +2674,49 @@ const savePropertyToDb = async (property) => {
         logger$t(`Created property ${property.modelName}:${property.name} in database`);
     }
 };
-const getAddressesFromDb = async () => {
+function parseAddressConfig(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+            return { owned: parsed, watched: [] };
+        }
+        if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
+            return {
+                owned: parsed.owned,
+                watched: Array.isArray(parsed.watched) ? parsed.watched : [],
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+const getOwnedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
+};
+const getWatchedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.watched ?? [];
+};
+/**
+ * Returns owned + watched addresses. Use for EAS sync and file download.
+ */
+const getAllAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config)
+        return [];
+    return [...config.owned, ...config.watched];
+};
+async function getAddressConfigFromDb() {
     const appDb = BaseDb.getAppDb();
     if (!appDb) {
         return new Promise((resolve) => {
             setTimeout(async () => {
-                const addresses = await getAddressesFromDb();
-                resolve(addresses);
+                resolve(await getAddressConfigFromDb());
             }, 500);
         });
     }
@@ -2571,14 +2726,25 @@ const getAddressesFromDb = async () => {
         .where(drizzleOrm.eq(appState.key, 'addresses'))
         .limit(1);
     if (!appStatesRecords || appStatesRecords.length === 0) {
-        throw new Error('No appStatesRecords for addresses found');
+        return null;
     }
-    const addressRecord = appStatesRecords[0];
-    const addressArrayString = addressRecord.value;
-    if (!addressArrayString) {
+    const addressArrayString = appStatesRecords[0].value;
+    return parseAddressConfig(addressArrayString);
+}
+const getAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config || config.owned.length === 0) {
         throw new Error('No addresses found');
     }
-    return JSON.parse(addressArrayString);
+    return config.owned;
+};
+/**
+ * Like getAddressesFromDb but returns [] instead of throwing when no addresses are configured.
+ * Returns owned addresses. Use getAllAddressesFromDb for sync (owned + watched).
+ */
+const getAddressesFromDbOptional = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
 };
 /**
  * Write model to database and create model_schemas join entry
@@ -2685,7 +2851,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 +2918,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 +3045,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 +3119,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 +3134,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 +3184,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)
@@ -2970,10 +3206,18 @@ var db = /*#__PURE__*/Object.freeze({
     createOrUpdate: createOrUpdate,
     escapeSqliteString: escapeSqliteString,
     getAddressesFromDb: getAddressesFromDb,
+    getAddressesFromDbOptional: getAddressesFromDbOptional,
+    getAllAddressesFromDb: getAllAddressesFromDb,
     getModelId: getModelId,
     getModelIdByFileId: getModelIdByFileId,
     getModelNameByModelId: getModelNameByModelId,
+    getObjectForRow: getObjectForRow,
+    getOwnedAddressesFromDb: getOwnedAddressesFromDb,
     getPropertyModelNameAndDataType: getPropertyModelNameAndDataType,
+    getSchemaId: getSchemaId,
+    getSchemaIdByFileId: getSchemaIdByFileId,
+    getSqlResultObject: getSqlResultObject,
+    getWatchedAddressesFromDb: getWatchedAddressesFromDb,
     loadModelsFromDbForSchema: loadModelsFromDbForSchema,
     renameModelInDb: renameModelInDb,
     savePropertyToDb: savePropertyToDb,
@@ -3027,7 +3271,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-DpjD0o0E.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -3418,7 +3662,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-DpjD0o0E.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4264,7 +4508,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;
         }
@@ -4383,33 +4628,56 @@ var versionData = /*#__PURE__*/Object.freeze({
 
 const logger$p = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
- * Create ItemProperty instances for all metadata records to ensure they're cached
+ * Create ItemProperty instances for all metadata records to ensure they're cached.
+ * Passes propertyRecordSchema from Model when available (Fix 3: enables value persistence for runtime-created models).
  * @param metadataRows - Array of metadata records to create ItemProperty instances for
  * @param seedLocalId - Seed local ID
  * @param seedUid - Seed UID
+ * @param modelName - Model name for resolving propertyRecordSchema from Model
  * @returns Map of propertyName -> ItemProperty instance
  */
-const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) => {
+const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, modelName) => {
     const propertyInstances = new Map();
     if (metadataRows.length === 0) {
         return propertyInstances;
     }
     try {
-        const { ItemProperty } = await Promise.resolve().then(function () { return ItemProperty$1; });
-        // Create instances for all metadata records in parallel
+        const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
+        const { ItemProperty } = itemPropertyMod;
+        const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+        const { Model } = await Promise.resolve().then(function () { return Model$1; });
+        // Resolve Model and build property schemas for propertyRecordSchema (Fix 3)
+        let propertySchemas = {};
+        const model$1 = Model.getByName(modelName);
+        if (model$1?.properties?.length) {
+            propertySchemas = modelPropertiesToObject(model$1.properties);
+        }
+        // Create instances for all metadata records in parallel with propertyRecordSchema
         const createPromises = metadataRows.map(async (metaRow) => {
             try {
-                const property = await ItemProperty.find({
-                    propertyName: metaRow.propertyName,
+                const propertyName = metaRow.propertyName;
+                if (!propertyName) {
+                    logger$p(`Metadata row missing propertyName, skipping`);
+                    return;
+                }
+                const createProps = {
+                    propertyName,
                     seedLocalId,
                     seedUid,
-                });
+                    modelName,
+                    propertyValue: metaRow.propertyValue ?? undefined,
+                    versionLocalId: metaRow.versionLocalId ?? undefined,
+                    versionUid: metaRow.versionUid ?? undefined,
+                    schemaUid: metaRow.schemaUid ?? undefined,
+                    propertyRecordSchema: propertySchemas[propertyName] ?? undefined,
+                };
+                const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
-                    propertyInstances.set(metaRow.propertyName, property);
-                    logger$p(`Created/cached ItemProperty instance for propertyName "${metaRow.propertyName}"`);
+                    propertyInstances.set(propertyName, property);
+                    logger$p(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$p(`ItemProperty.find returned undefined for propertyName "${metaRow.propertyName}"`);
+                    logger$p(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
@@ -4429,7 +4697,6 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) =
 const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        console.log(`[loadOrCreateItem] Called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         logger$p(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
@@ -4541,16 +4808,11 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .from(metadata$1)
             .where(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedLocalId, resolvedSeedLocalId), drizzleOrm.eq(metadata$1.versionLocalId, latestVersionLocalId)));
         logger$p(`Found ${metadataRecords.length} metadata records for version ${latestVersionLocalId}`);
-        console.log(`[loadOrCreateItem] Found ${metadataRecords.length} metadata records for version ${latestVersionLocalId}`);
-        if (metadataRecords.length > 0) {
-            console.log(`[loadOrCreateItem] Metadata property names:`, metadataRecords.map((r) => r.propertyName));
-        }
         // Step 4: Create ItemProperty instances from metadata records
         // This ensures they're in the cache when Item.properties getter is called
         const propertyInstances = metadataRecords.length > 0
-            ? await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid)
+            ? await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid, modelName)
             : new Map();
-        console.log(`[loadOrCreateItem] Created ${propertyInstances.size} property instances:`, Array.from(propertyInstances.keys()));
         // Step 5: Return loaded item data with property instances
         sendBack({
             type: 'loadOrCreateItemSuccess',
@@ -4588,14 +4850,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-DDsT9zZ6.js'); });
+            const { getPublishUploads } = getPublishUploadsMod;
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CoLriAMV.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.
@@ -4767,14 +5032,18 @@ const itemMachineSingle = xstate.setup({
                     actions: xstate.assign(({ context, event }) => {
                         const item = event.item;
                         const existingPropertyInstances = context.propertyInstances || new Map();
-                        console.log(`[itemMachine] loadOrCreateItemSuccess for modelName: ${context.modelName}, propertyInstances from event:`, item.propertyInstances ? Array.from(item.propertyInstances.keys()) : 'none');
-                        // Merge property instances from loadOrCreateItem
+                        // Merge property instances from loadOrCreateItem (Fix 2: preserve existing when it has propertyRecordSchema and incoming doesn't)
                         if (item.propertyInstances) {
                             for (const [propertyName, propertyInstance] of item.propertyInstances) {
+                                const existing = existingPropertyInstances.get(propertyName);
+                                const existingHasSchema = existing?.propertyDef;
+                                const incomingHasSchema = propertyInstance?.propertyDef;
+                                if (existingHasSchema && !incomingHasSchema) {
+                                    continue; // Preserve existing instance with schema
+                                }
                                 existingPropertyInstances.set(propertyName, propertyInstance);
                             }
                         }
-                        console.log(`[itemMachine] After merge, total propertyInstances:`, Array.from(existingPropertyInstances.keys()));
                         return {
                             ...context,
                             seedLocalId: item.seedLocalId || context.seedLocalId,
@@ -5130,6 +5399,26 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     }
     const seedRow = seedRows[0];
     const resolvedSeedLocalId = seedRow.seedLocalId;
+    // Fix 5: Derive schemaName for multi-schema Model resolution (models -> model_schemas -> schemas)
+    let schemaName;
+    const normalizedModelName = modelName ? lodashEs.startCase(modelName) : (seedRow.type ? lodashEs.startCase(seedRow.type) : undefined);
+    if (appDb && normalizedModelName) {
+        try {
+            const schemaRows = await appDb
+                .select({ schemaName: schemas.name })
+                .from(models$1)
+                .innerJoin(modelSchemas, drizzleOrm.eq(models$1.id, modelSchemas.modelId))
+                .innerJoin(schemas, drizzleOrm.eq(modelSchemas.schemaId, schemas.id))
+                .where(drizzleOrm.eq(models$1.name, normalizedModelName))
+                .limit(1);
+            if (schemaRows.length > 0 && schemaRows[0].schemaName) {
+                schemaName = schemaRows[0].schemaName;
+            }
+        }
+        catch (error) {
+            logger$n('[getItemData] Error deriving schemaName:', error);
+        }
+    }
     // Now get version data if it exists - query versions table directly
     let versionRow = {
         versionsCount: 0,
@@ -5160,6 +5449,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     let itemData = {
         ...seedRow,
         ...versionRow,
+        schemaName,
     };
     const propertiesData = await getItemProperties({
         seedLocalId,
@@ -5183,12 +5473,28 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         return itemData;
 };
 
-const getItemsData = async ({ modelName, deleted, }) => {
+const getItemsData = async ({ modelName, deleted, includeEas = false, addressFilter, }) => {
     const appDb = BaseDb.getAppDb();
     const conditions = [];
+    if (!includeEas) {
+        conditions.push(drizzleOrm.or(drizzleOrm.isNull(seeds.uid), drizzleOrm.eq(seeds.uid, '')));
+    }
     if (modelName) {
         conditions.push(drizzleOrm.eq(seeds.type, casing.toSnakeCase(modelName)));
     }
+    if (addressFilter === 'owned') {
+        const ownedAddresses = await getOwnedAddressesFromDb();
+        if (ownedAddresses.length > 0) {
+            conditions.push(drizzleOrm.or(drizzleOrm.inArray(seeds.publisher, ownedAddresses), drizzleOrm.isNull(seeds.publisher)));
+        }
+    }
+    else if (addressFilter === 'watched') {
+        const watchedAddresses = await getWatchedAddressesFromDb();
+        if (watchedAddresses.length === 0) {
+            return [];
+        }
+        conditions.push(drizzleOrm.inArray(seeds.publisher, watchedAddresses));
+    }
     if (deleted) {
         conditions.push(drizzleOrm.or(drizzleOrm.isNotNull(seeds._markedForDeletion), drizzleOrm.eq(seeds._markedForDeletion, 1)));
     }
@@ -5325,7 +5631,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 +5961,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-CvcOtzbi.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
@@ -5992,7 +6300,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-CvcOtzbi.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
         // Re-check types with dynamically imported ModelPropertyDataTypes
@@ -6144,7 +6453,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,
@@ -6221,8 +6531,8 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
         const modelName = metadataRecord.modelType || context.modelName;
         if (modelName) {
             try {
-                // Normalize to PascalCase so "post" (from seeds.type/metadata) matches "Post" in models table
-                const normalizedModelName = lodashEs.startCase(modelName);
+                // Normalize snake_case to PascalCase: "test_post" -> "TestPost" (startCase gives "Test Post" which fails)
+                const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(modelName));
                 // Query properties table to get property schema
                 const modelRecords = await db
                     .select({ id: models$1.id })
@@ -6253,6 +6563,28 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 // Continue without propertyRecordSchema
             }
         }
+        if (!propertyRecordSchema && modelName) {
+            try {
+                const { Model } = await Promise.resolve().then(function () { return Model$1; });
+                const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+                const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(modelName));
+                // Try PascalCase first ("post" -> "Post"); then findByModelType for names with spaces ("new_model" -> "New model")
+                let model$1 = Model.getByName(normalizedModelName);
+                if (!model$1?.properties?.length) {
+                    model$1 = Model.findByModelType(casing.toSnakeCase(modelName));
+                }
+                if (model$1?.properties?.length) {
+                    const schemas = modelPropertiesToObject(model$1.properties);
+                    propertyRecordSchema = schemas[propertyName];
+                    if (propertyRecordSchema) {
+                        logger$k(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                    }
+                }
+            }
+            catch (error) {
+                logger$k(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+            }
+        }
         // Return loaded property data
         sendBack({
             type: 'loadOrCreatePropertySuccess',
@@ -6464,7 +6796,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-CvcOtzbi.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -6821,7 +7154,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-CvcOtzbi.js'); });
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
         }
@@ -7523,6 +7857,32 @@ Promise.resolve().then(function () { return Model$1; }).then(module => {
     // Return a default module structure to maintain type consistency
     return {};
 });
+/**
+ * Resolve propertyRecordSchema from in-memory Model (Fix 6: enables value persistence when useItemProperty path doesn't go through loadOrCreateItem).
+ * Tries getByName(pascalCase) first; if that fails (e.g. "New model" vs "NewModel"), falls back to findByModelType(modelType).
+ */
+const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, modelType) => {
+    if (!modelName && !modelType)
+        return undefined;
+    try {
+        const { Model } = await Promise.resolve().then(function () { return Model$1; });
+        const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+        let model$1 = modelName ? Model.getByName(modelName) : undefined;
+        if (!model$1?.properties?.length && modelType) {
+            model$1 = Model.findByModelType(modelType);
+        }
+        if (!model$1?.properties?.length)
+            return undefined;
+        const schemas = modelPropertiesToObject(model$1.properties);
+        const schema = schemas[propertyName];
+        return schema;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Convert modelType (snake_case from DB) to Model name (PascalCase). startCase adds spaces ("Test Post"); Model names are "TestPost". */
+const modelTypeToModelName = (modelType) => modelType ? lodashEs.upperFirst(lodashEs.camelCase(modelType)) : '';
 const logger$i = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
@@ -7619,7 +7979,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-CvcOtzbi.js'); });
+            const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
             if (context.seedLocalId && context.propertyName) {
@@ -7732,9 +8093,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');
@@ -8004,10 +8368,14 @@ class ItemProperty {
                 return undefined;
             }
             // Ensure modelName for constructor: metadata may have modelType only, or neither (e.g. when Item passes it)
+            // Use modelTypeToModelName: modelType is snake_case ("test_post"); Model names are PascalCase ("TestPost")
             const data = propertyData;
             const modelName = data.modelName ??
-                ((data.modelType ? lodashEs.startCase(data.modelType) : '') || modelNameOption || '');
-            foundProperty = ItemProperty.create({ ...propertyData, modelName }, { waitForReady: false });
+                ((data.modelType ? modelTypeToModelName(data.modelType) : '') || modelNameOption || '');
+            // Fix 6: resolve propertyRecordSchema from Model so value setter can persist (useItemProperty path)
+            // Pass modelType for fallback: "New model" -> "new_model" can't be reversed to exact name; findByModelType handles it
+            const propertyRecordSchema = await resolvePropertyRecordSchemaFromModel(modelName, propertyName, data.modelType);
+            foundProperty = ItemProperty.create({ ...propertyData, modelName, propertyRecordSchema }, { waitForReady: false });
         }
         if (!foundProperty) {
             return undefined;
@@ -8030,9 +8398,16 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         for (const data of propertiesData) {
+            const d = data;
+            const modelName = d.modelName ?? (d.modelType ? modelTypeToModelName(d.modelType) : '') ?? '';
+            // Fix 6: resolve propertyRecordSchema from Model so value setter can persist
+            const propertyRecordSchema = d.propertyName
+                ? await resolvePropertyRecordSchemaFromModel(modelName, d.propertyName, d.modelType)
+                : undefined;
             const createProps = {
                 ...data,
-                modelName: data.modelName ?? data.modelType ?? '',
+                modelName,
+                propertyRecordSchema,
             };
             const instance = this.create(createProps, { waitForReady: false });
             if (instance) {
@@ -8167,10 +8542,15 @@ class ItemProperty {
         });
     }
     async save() {
+        const ctx = this._getSnapshotContext();
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-Dm5ER1nI.js'); });
+        await assertItemOwned({
+            seedLocalId: ctx?.seedLocalId ?? undefined,
+            seedUid: ctx?.seedUid ?? undefined,
+        });
         await xstate.waitFor(this._service, (snapshot) => !snapshot.context.isSaving && snapshot.value === 'idle', {
             timeout: 10000,
         });
-        const ctx = this._getSnapshotContext();
         const canonicalId = ctx?.seedLocalId ?? ctx?.seedUid;
         if (canonicalId) {
             eventEmitter.emit('itemProperty.saved', { seedLocalId: ctx.seedLocalId, seedUid: ctx.seedUid });
@@ -8247,8 +8627,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 +8645,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,14 +8672,22 @@ 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)) {
-        let propertyRecordSchema;
-        if (propertySchemas && propertySchemas[propertyName]) {
-            propertyRecordSchema = propertySchemas[propertyName];
-        }
+    // Build set of all properties to create metadata for: union of model schema + propertyData
+    // This ensures we create metadata for ALL model properties even when creating with no initial values
+    // (fixes first-item persistence: loadOrCreateItem needs metadata rows to run createItemPropertyInstances)
+    const allPropertyNames = new Set(Object.keys(propertyData));
+    if (propertySchemas) {
+        for (const name of Object.keys(propertySchemas)) {
+            allPropertyNames.add(name);
+        }
+    }
+    for (const propertyName of allPropertyNames) {
+        const propertyValue = propertyData[propertyName];
+        const propertyRecordSchema = propertySchemas?.[propertyName];
         await createMetadata({
             seedLocalId: newSeedId,
             versionLocalId: newVersionId,
@@ -8463,6 +8854,8 @@ class Item {
             });
         };
         this.publish = async () => {
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-Dm5ER1nI.js'); });
+            await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
                 let wasPublishing = false;
@@ -8497,12 +8890,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-DDsT9zZ6.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-CoLriAMV.js'); });
+            const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions);
         };
         this.persistSeedUid = async () => {
@@ -8777,8 +9172,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)
@@ -9030,8 +9427,8 @@ class Item {
         }
     }
     static async all(modelName, deleted, options) {
-        const { waitForReady = false, readyTimeout = 5000 } = options ?? {};
-        const itemsData = await getItemsData({ modelName, deleted });
+        const { waitForReady = false, readyTimeout = 5000, includeEas = false, addressFilter, } = options ?? {};
+        const itemsData = await getItemsData({ modelName, deleted, includeEas, addressFilter });
         const itemInstances = [];
         for (const itemData of itemsData) {
             itemInstances.push(await Item.create({
@@ -9368,9 +9765,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 +9813,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 +9922,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 {
@@ -9642,6 +10044,8 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-Dm5ER1nI.js'); });
+        await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKey = context.seedUid || context.seedLocalId;
         const cacheKeys = cacheKey ? [cacheKey] : [];
@@ -9683,6 +10087,24 @@ class ConflictError extends Error {
     }
 }
 
+/**
+ * Normalizes AddressConfiguration to { owned, watched }.
+ * - string[] -> { owned: addresses, watched: [] }
+ * - { owned, watched? } -> { owned, watched: watched ?? [] }
+ */
+function normalizeAddressConfig(addresses) {
+    if (!addresses) {
+        return { owned: [], watched: [] };
+    }
+    if (Array.isArray(addresses)) {
+        return { owned: addresses, watched: [] };
+    }
+    return {
+        owned: addresses.owned ?? [],
+        watched: addresses.watched ?? [],
+    };
+}
+
 const isNode = () => {
     return (typeof process !== 'undefined' &&
         process.versions != null &&
@@ -9719,7 +10141,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();
@@ -9821,6 +10244,7 @@ const saveEasSeedsToDb = async ({ itemSeeds }) => {
             uid: seed.id,
             schemaUid: seed.schemaId,
             type: seed.schema.schemaNames[0].name,
+            publisher: seed.attester,
             createdAt: Date.now(),
             attestationCreatedAt: seed.timeCreated * 1000,
             attestationRaw,
@@ -9954,7 +10378,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();
@@ -10139,6 +10564,10 @@ const getRelatedSeedsAndVersions = async () => {
     });
 };
 const syncDbWithEasHandler = lodashEs.throttle(async (_) => {
+    const addresses = await getAllAddressesFromDb();
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
     const appDb = BaseDb.getAppDb();
     const { schemaStringToModelRecord } = await getModelSchemas();
     const modelSchemas = await getModelSchemasFromEas();
@@ -10176,7 +10605,6 @@ const syncDbWithEasHandler = lodashEs.throttle(async (_) => {
     if (schemaUids.length === 0) {
         return;
     }
-    const addresses = await getAddressesFromDb();
     const itemSeeds = await getSeedsFromSchemaUids({
         schemaUids,
         addresses,
@@ -10352,11 +10780,14 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
             }
             // If it's an absolute path that exists or is a valid filesystem path, use it as-is
         }
+        const normalizedAddresses = normalizeAddressConfig(addresses);
         sendBack({ type: 'updateContext', context: {
                 models: models || {},
                 endpoints,
                 arweaveDomain,
-                addresses: addresses || [],
+                addresses: normalizedAddresses.owned,
+                ownedAddresses: normalizedAddresses.owned,
+                watchedAddresses: normalizedAddresses.watched,
                 filesDir: normalizedFilesDir,
                 dbConfig,
             } });
@@ -10540,11 +10971,12 @@ const downloadAllFilesRequestHandler = async ({ endpoints, eventId, }) => {
 const downloadAllFilesBinaryRequestHandler = async () => {
     let addresses;
     if (BaseDb.isAppDbReady()) {
-        addresses = await getAddressesFromDb();
+        addresses = await getAllAddressesFromDb();
     }
     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) => {
@@ -10556,7 +10988,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
                 state === 'addModelsToDb' ||
                 state === 'idle';
         }, { timeout: 30000 });
-        addresses = await getAddressesFromDb();
+        addresses = await getAllAddressesFromDb();
     }
     if (!addresses || addresses.length === 0) {
         return;
@@ -10908,7 +11340,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
 const logger$a = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
     logger$a('saveConfig starting');
-    const { endpoints, addresses, arweaveDomain } = context;
+    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain } = context;
     // Validate endpoints - required for proper initialization
     // If endpoints are missing or invalid, initialization should fail
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
@@ -10928,7 +11360,9 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 throw new Error('App DB not found');
             }
             const endpointsValueString = JSON.stringify(endpoints);
-            const addressesValueString = JSON.stringify(addresses);
+            const owned = ownedAddresses ?? addresses ?? [];
+            const watched = watchedAddresses ?? [];
+            const addressesValueString = JSON.stringify({ owned, watched });
             // TODO: Figure out how to define on conflict with multiple rows added
             await appDb
                 .insert(appState)
@@ -10942,7 +11376,7 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
                     value: endpointsValueString,
                 },
             });
-            if (addresses) {
+            if (owned.length > 0 || watched.length > 0) {
                 await appDb
                     .insert(appState)
                     .values({
@@ -11374,8 +11808,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 +12127,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 +12222,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 +12244,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 +12420,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 +12457,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 +12672,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 +12695,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 +12762,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 +12799,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 +12841,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) {
@@ -12897,14 +13347,17 @@ const clientManagerMachine = xstate.setup({
                     actions: [
                         xstate.assign(({ event, spawn }) => {
                             const { addresses } = event;
+                            const normalized = normalizeAddressConfig(addresses);
                             spawn('saveAppState', {
                                 input: {
                                     key: 'addresses',
-                                    value: addresses,
+                                    value: { owned: normalized.owned, watched: normalized.watched },
                                 },
                             });
                             return {
-                                addresses,
+                                addresses: normalized.owned,
+                                ownedAddresses: normalized.owned,
+                                watchedAddresses: normalized.watched,
                                 isSaving: true,
                             };
                         })
@@ -12977,6 +13430,8 @@ const clientInstance = {
                     isSaving: false,
                     endpoints: undefined,
                     addresses: undefined,
+                    ownedAddresses: undefined,
+                    watchedAddresses: undefined,
                     models: undefined,
                     arweaveDomain: undefined,
                     filesDir: undefined,
@@ -13031,9 +13486,17 @@ const clientInstance = {
     },
     getAddresses: async () => {
         ensureInitialized();
-        const db = await BaseDb.getAppDb();
-        const results = await db.select().from(appState).where(drizzleOrm.eq(appState.key, 'addresses'));
-        return JSON.parse(results[0]?.value);
+        const owned = await getOwnedAddressesFromDb();
+        const watched = await getWatchedAddressesFromDb();
+        return { owned, watched };
+    },
+    getOwnedAddresses: async () => {
+        ensureInitialized();
+        return getOwnedAddressesFromDb();
+    },
+    getWatchedAddresses: async () => {
+        ensureInitialized();
+        return getWatchedAddressesFromDb();
     },
     addModel: async (modelDef) => {
         const db = await BaseDb.getAppDb();
@@ -13243,7 +13706,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-DpjD0o0E.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -13260,7 +13723,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-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -13776,7 +14239,11 @@ class Model {
         // Step 11: Register with schema if requested, OR trigger write if properties are provided
         // If properties are provided, we need to write the model to get modelId for property creation
         // If schema provided, trigger write process instead of registration
-        const shouldTriggerWrite = (registerWithSchema && schemaInstance) || (options?.properties && Object.keys(options.properties).length > 0);
+        // When schemaName is passed as string (e.g. useCreateModel), we must trigger write so runtime-created
+        // models get persisted to DB and show up in useModels (which queries the database).
+        const shouldTriggerWrite = (registerWithSchema && schemaInstance) ||
+            (options?.properties && Object.keys(options.properties).length > 0) ||
+            typeof schemaNameOrSchema === 'string';
         if (shouldTriggerWrite) {
             queueMicrotask(async () => {
                 try {
@@ -14059,6 +14526,22 @@ class Model {
         }
         return undefined;
     }
+    /**
+     * Find Model by modelType (snake_case from DB/metadata).
+     * Handles model names with spaces: "new_model" -> finds "New model" (toSnakeCase("New model") === "new_model").
+     */
+    static findByModelType(modelType) {
+        if (!modelType)
+            return undefined;
+        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
+            const parts = nameKey.split(':', 2);
+            const cachedModelName = parts[1];
+            if (cachedModelName && casing.toSnakeCase(cachedModelName) === modelType) {
+                return this.getById(id);
+            }
+        }
+        return undefined;
+    }
     /**
      * Get all Model instances for a schema from cache only (synchronous).
      * Includes models created at runtime via Model.create() that may not yet be in schema context.
@@ -14761,7 +15244,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 +15728,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`;
@@ -15293,105 +15778,6 @@ class Db extends BaseDb {
         // You can inspect what will happen before applying
         await apply();
         this.db = db;
-        // OLD CODE: Resolve better-sqlite3 from project's node_modules first, then fall back to SDK's node_modules
-        // This is important for tests and when the SDK is used as a dependency
-        // const projectDir = path.dirname(filesDir) // filesDir is .seed, so projectDir is the project root
-        // const projectBetterSqlite3Path = path.join(projectDir, 'node_modules', 'better-sqlite3')
-        // 
-        // let Database: any
-        // try {
-        //   const fs = await import('fs')
-        //   if (fs.existsSync(projectBetterSqlite3Path)) {
-        //     // Try to resolve from project's node_modules using the full path
-        //     // For Bun, we can try importing directly from the path
-        //     try {
-        //       // First try using createRequire (works in Node.js)
-        //       const { createRequire } = await import('module')
-        //       const projectRequire = createRequire(path.join(projectDir, 'package.json'))
-        //       const betterSqlite3Module = projectRequire('better-sqlite3')
-        //       Database = betterSqlite3Module.default || betterSqlite3Module
-        //       logger('[node/db/Db] Using better-sqlite3 from project node_modules via createRequire')
-        //     } catch (requireError: any) {
-        //       // If createRequire fails (e.g., in Bun), try direct path import
-        //       logger('[node/db/Db] createRequire failed, trying direct import:', requireError.message)
-        //       const betterSqlite3MainPath = path.join(projectBetterSqlite3Path, 'lib', 'database.js')
-        //       if (fs.existsSync(betterSqlite3MainPath)) {
-        //         // Use dynamic import with the full path
-        //         const betterSqlite3Module = await import(betterSqlite3MainPath)
-        //         Database = betterSqlite3Module.default || betterSqlite3Module.Database || betterSqlite3Module
-        //         logger('[node/db/Db] Using better-sqlite3 from project node_modules via direct import')
-        //       } else {
-        //         throw new Error(`better-sqlite3 main file not found at ${betterSqlite3MainPath}`)
-        //       }
-        //     }
-        //   } else {
-        //     // Fall back to regular import (from SDK's node_modules)
-        //     const betterSqlite3Module = await import('better-sqlite3')
-        //     Database = betterSqlite3Module.default || betterSqlite3Module
-        //     logger('[node/db/Db] Using better-sqlite3 from SDK node_modules')
-        //   }
-        // } catch (importError: any) {
-        //   logger('[node/db/Db] Error importing better-sqlite3:', importError.message)
-        //   logger('[node/db/Db] projectDir:', projectDir)
-        //   logger('[node/db/Db] projectBetterSqlite3Path:', projectBetterSqlite3Path)
-        //   throw new Error(`Failed to import better-sqlite3: ${importError.message}. Please install better-sqlite3 in your project.`)
-        // }
-        // OLD CODE: Create Database instance
-        // const sqlite = new Database(dbPath)
-        // 
-        // OLD CODE: Create drizzle instance with the Database
-        // const {drizzle} = await import('drizzle-orm/better-sqlite3')
-        // this.db = drizzle(sqlite, {
-        //   logger: true,
-        // })
-        // // NEW CODE: Use libsql instead of better-sqlite3
-        // // Resolve @libsql/client from project's node_modules first, then fall back to SDK's node_modules
-        // const projectDir = path.dirname(filesDir) // filesDir is .seed, so projectDir is the project root
-        // const projectLibsqlClientPath = path.join(projectDir, 'node_modules', '@libsql', 'client')
-        // let createClient: any
-        // try {
-        //   const fs = await import('fs')
-        //   if (fs.existsSync(projectLibsqlClientPath)) {
-        //     // Try to resolve from project's node_modules using the full path
-        //     try {
-        //       // First try using createRequire (works in Node.js)
-        //       const { createRequire } = await import('module')
-        //       const projectRequire = createRequire(path.join(projectDir, 'package.json'))
-        //       const libsqlClientModule = projectRequire('@libsql/client')
-        //       createClient = libsqlClientModule.createClient || libsqlClientModule.default?.createClient || libsqlClientModule.default
-        //       logger('[node/db/Db] Using @libsql/client from project node_modules via createRequire')
-        //     } catch (requireError: any) {
-        //       // If createRequire fails, try direct import
-        //       logger('[node/db/Db] createRequire failed, trying direct import:', requireError.message)
-        //       const libsqlClientModule = await import('@libsql/client')
-        //       createClient = libsqlClientModule.createClient
-        //       logger('[node/db/Db] Using @libsql/client from project node_modules via direct import')
-        //     }
-        //   } else {
-        //     // Fall back to regular import (from SDK's node_modules)
-        //     const libsqlClientModule = await import('@libsql/client')
-        //     createClient = libsqlClientModule.createClient
-        //     logger('[node/db/Db] Using @libsql/client from SDK node_modules')
-        //   }
-        // } catch (importError: any) {
-        //   logger('[node/db/Db] Error importing @libsql/client:', importError.message)
-        //   logger('[node/db/Db] projectDir:', projectDir)
-        //   logger('[node/db/Db] projectLibsqlClientPath:', projectLibsqlClientPath)
-        //   throw new Error(`Failed to import @libsql/client: ${importError.message}. Please install @libsql/client in your project.`)
-        // }
-        // // Convert file path to file: URL for libsql
-        // // If dbPath is already a file: URL, use it as is, otherwise convert it
-        // const dbUrl = dbPath.startsWith('file:') ? dbPath : `file:${path.resolve(dbPath)}`
-        // // Create libsql client instance
-        // const client = createClient({ url: dbUrl })
-        // // Create drizzle instance with the libsql client
-        // const {drizzle} = await import('drizzle-orm/libsql')
-        // this.db = drizzle(client, {
-        //   logger: true,
-        // })
-        // if (!this.db) {
-        //   throw new Error('Db not found')
-        // }
         return this.db;
     }
     static async connectToDb(pathToDir) {
@@ -15460,7 +15846,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 +16395,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-B95Ng80C.js', document.baseURI).href)));
 path.dirname(__filename$1);
 const commandExists = (command) => {
     try {
@@ -16525,6 +16912,7 @@ exports.getItemData = getItemData;
 exports.getLatestSchemaVersion = getLatestSchemaVersion;
 exports.getModelId = getModelId;
 exports.getModelIdByFileId = getModelIdByFileId;
+exports.getOwnedAddressesFromDb = getOwnedAddressesFromDb;
 exports.getSchemaForItemProperty = getSchemaForItemProperty;
 exports.getSchemaUidForModel = getSchemaUidForModel;
 exports.getSchemaUidForSchemaDefinition = getSchemaUidForSchemaDefinition;
@@ -16559,4 +16947,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-BeKPbbk0.js.map
+//# sourceMappingURL=index-B95Ng80C.js.map