@seedprotocol/sdk 0.4.5 → 0.4.7

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

@@ -1,13 +1,13 @@
 import { waitFor, fromCallback, fromPromise, setup, assign, createActor } from 'xstate';
 import { sqliteTable, integer, text, unique, int, blob } from 'drizzle-orm/sqlite-core';
-import { relations, eq, and, isNull, isNotNull, not, or, max, count, getTableColumns, sql, gt, inArray, desc } from 'drizzle-orm';
+import { relations, eq, and, isNull, isNotNull, not, or, max, count, getTableColumns, sql, inArray, gt, desc } from 'drizzle-orm';
 import { customAlphabet } from 'nanoid';
 import * as nanoIdDictionary from 'nanoid-dictionary';
 import debug from 'debug';
 import pluralize from 'pluralize';
 import { ZeroAddress } from 'ethers';
 import { BehaviorSubject } from 'rxjs';
-import { startCase, orderBy, throttle, camelCase } from 'lodash-es';
+import { startCase, upperFirst, camelCase, orderBy, throttle } from 'lodash-es';
 import { toSnakeCase as toSnakeCase$1 } from 'drizzle-orm/casing';
 import EventEmitter from 'eventemitter3';
 import 'arweave';
@@ -424,6 +424,30 @@ const generateId = () => {
 const toSnakeCase = (str) => {
     return str.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
 };
+const identifyString = (str) => {
+    try {
+        JSON.parse(str);
+        return 'json';
+    }
+    catch (e) {
+        // Not JSON
+    }
+    if (!str) {
+        return;
+    }
+    if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
+        return 'html';
+    }
+    // Simple markdown checks (very naive)
+    if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
+        return 'markdown';
+    }
+    if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
+        return 'base64';
+    }
+    // Default to plain text if unsure
+    return 'text';
+};
 const getMimeType = (base64) => {
     if (!base64) {
         return null;
@@ -510,6 +534,12 @@ const convertTxIdToImage = async (txId) => {
 const getArweaveUrlForTransaction = (storageTransactionId) => {
     return BaseArweaveClient.getRawUrl(storageTransactionId);
 };
+const getExecutionTime = async (task, args) => {
+    const start = Date.now();
+    await task(...args);
+    return Date.now() - start;
+};
+const capitalizeFirstLetter = (string) => string.charAt(0).toUpperCase() + string.slice(1);
 const parseEasRelationPropertyName = (easPropertyName) => {
     // Split the input string on the first underscore
     const [singularProperty, modelName, idSegment] = easPropertyName.split('_');
@@ -525,6 +555,25 @@ const parseEasRelationPropertyName = (easPropertyName) => {
         isList, // True if the property is a list (e.g., 'ids' is present)
     };
 };
+const isBinary = (arrayBuffer) => {
+    const view = new Uint8Array(arrayBuffer);
+    let nonTextCount = 0;
+    const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
+    for (let i = 0; i < view.length; i++) {
+        const byte = view[i];
+        // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
+        if ((byte >= 32 && byte <= 126) || // Printable ASCII
+            byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
+        ) {
+            continue;
+        }
+        nonTextCount++;
+        if (nonTextCount / view.length > threshold) {
+            return true; // More than threshold are non-text bytes
+        }
+    }
+    return false; // Fewer than threshold are non-text bytes
+};
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -532,12 +581,16 @@ var index = /*#__PURE__*/Object.freeze({
     BaseEasClient: BaseEasClient,
     BaseFileManager: BaseFileManager,
     BaseQueryClient: BaseQueryClient,
+    capitalizeFirstLetter: capitalizeFirstLetter,
     convertTxIdToImage: convertTxIdToImage,
     generateId: generateId,
     getArweaveUrlForTransaction: getArweaveUrlForTransaction,
     getCorrectId: getCorrectId,
     getDataTypeFromString: getDataTypeFromString,
+    getExecutionTime: getExecutionTime,
     getMimeType: getMimeType,
+    identifyString: identifyString,
+    isBinary: isBinary,
     parseEasRelationPropertyName: parseEasRelationPropertyName,
     toSnakeCase: toSnakeCase,
     waitForEntityIdle: waitForEntityIdle
@@ -554,7 +607,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-CGdkocQ8.js');
+        const mod = await import('./ModelProperty-D4zaeIOT.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$s('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -637,7 +690,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                         // schemaFileId to match the database, both will point to the same cached instance.
                         if (dbSchemaFileId) {
                             try {
-                                const { Model } = await Promise.resolve().then(function () { return Model$1; });
+                                const modelMod = await Promise.resolve().then(function () { return Model$1; });
+                                const { Model } = modelMod;
                                 // Access instanceCacheById via type assertion since it's protected
                                 const cacheById = Model.instanceCacheById;
                                 if (cacheById.has(dbSchemaFileId)) {
@@ -742,7 +796,10 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+            const _mod_0 = await import('./Schema-SbwqmoMM.js');
+            const _ns_0 = _mod_0.b;
+            const schemaMod = _ns_0;
+            const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
             // Wait for schema to load if it's still loading
@@ -813,7 +870,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         let finalModelName = modelName;
         if (db) {
             // Check if this is an internal schema (Seed Protocol)
-            const { isInternalSchema } = await Promise.resolve().then(function () { return constants; });
+            const constantsMod = await Promise.resolve().then(function () { return constants; });
+            const { isInternalSchema } = constantsMod;
             const isInternal = isInternalSchema(schemaName);
             // Only skip duplicate check if:
             // 1. We found a model record to use (modelRecord is set), OR
@@ -828,7 +886,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                     const existingNumbers = new Set(existingNumbersFromSchemaContext ?? []);
                     // First, check Model cache for models (includes models from imported schemas that may not be in DB yet)
                     try {
-                        const { Model } = await Promise.resolve().then(function () { return Model$1; });
+                        const modelMod = await Promise.resolve().then(function () { return Model$1; });
+                        const { Model } = modelMod;
                         // Check name-based cache for this schema
                         // Skip the current model (context.id): Model.create() adds the new instance to the cache
                         // before this callback runs, so we must not count it as a duplicate.
@@ -887,8 +946,10 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
                     }
                     // Also check database for models (in case they're persisted but not in Schema context)
                     if (db) {
-                        const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                        const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                        const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                        const { modelSchemas } = modelSchemaSchemaMod;
+                        const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+                        const { schemas: schemasTable } = schemaSchemaMod;
                         // Query all models for this schema to check for duplicates (case-insensitive)
                         logger$s(`Checking database for duplicate model names in schema "${schemaName}"`);
                         const allModelsForSchema = await db
@@ -961,7 +1022,8 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Runtime creates use a placeholder cache key in Model.create; move it to the final name. Skip when schema model (_idFromSchema).
         if (!_idFromSchema) {
-            const { Model } = await Promise.resolve().then(function () { return Model$1; });
+            const modelMod = await Promise.resolve().then(function () { return Model$1; });
+            const { Model } = modelMod;
             Model.updateNameIndex('__pending__' + schemaFileId, finalModelName, schemaName, schemaFileId);
         }
         // If model name was changed, store it in a temporary internal field so loadOrCreateModelSuccess can apply it
@@ -980,7 +1042,10 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+            const _mod_1 = await import('./Schema-SbwqmoMM.js');
+            const _ns_1 = _mod_1.b;
+            const schemaMod = _ns_1;
+            const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
         }
@@ -1023,9 +1088,13 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+            const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
+            const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+            const _mod_2 = await import('./Schema-SbwqmoMM.js');
+            const _ns_2 = _mod_2.b;
+            const schemaMod = _ns_2;
+            const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
             if (!structureResult.isValid) {
@@ -1136,19 +1205,21 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$q(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-CGdkocQ8.js');
+        const mod = await import('./ModelProperty-D4zaeIOT.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$q('ModelProperty not available from dynamic import');
             sendBack({ type: 'createModelPropertiesError', error: new Error('ModelProperty not available') });
             return;
         }
-        const { eq } = await import('drizzle-orm');
+        const drizzleMod = await import('drizzle-orm');
+        const { eq } = drizzleMod;
         const db = BaseDb.getAppDb();
         for (const [propName, propData] of Object.entries(propertyDefinitions)) {
             // Use provided ID or generate a random one
             // IDs should be generated in the import process before creating properties
-            const { generateId } = await Promise.resolve().then(function () { return index; });
+            const helpersMod = await Promise.resolve().then(function () { return index; });
+            const { generateId } = helpersMod;
             const propertyFileId = propData.id || generateId();
             logger$q(`Creating property "${propName}" with fileId "${propertyFileId}"`);
             // Query database to get refModelId if the property has ref/refModelName
@@ -1239,7 +1310,8 @@ const validateEntity = fromPromise(async ({ input }) => {
                 logger$p(structureMsg);
                 console.log(structureMsg); // Always log to console
                 // Use existing Model validation
-                const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+                const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
                 const structureResult = validationService.validateModelStructure(entityInput.entityData);
@@ -1257,7 +1329,10 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$p(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+                            const _mod_3 = await import('./Schema-SbwqmoMM.js');
+                            const _ns_3 = _mod_3.b;
+                            const schemaMod = _ns_3;
+                            const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
                             });
@@ -1292,7 +1367,8 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+                const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
                 const structureResult = validationService.validatePropertyStructure(entityInput.entityData);
@@ -1306,7 +1382,10 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const { Schema } = await import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; });
+                            const _mod_4 = await import('./Schema-SbwqmoMM.js');
+                            const _ns_4 = _mod_4.b;
+                            const schemaMod = _ns_4;
+                            const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
                             });
@@ -1334,7 +1413,8 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const { SchemaValidationService } = await import('./SchemaValidationService-DyttFaV_.js');
+                const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
+                const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
                 if (!schemaResult.isValid) {
@@ -1370,6 +1450,7 @@ const seeds = sqliteTable('seeds', {
     uid: text('uid'),
     schemaUid: text('schema_uid'),
     type: text('type'),
+    publisher: text('publisher'),
     attestationRaw: text('attestation_raw'),
     attestationCreatedAt: int('attestation_created_at'),
     createdAt: int('created_at'),
@@ -1493,6 +1574,42 @@ const escapeSqliteString = (value) => {
     }
     return value.replace(/'/g, "''");
 };
+const getObjectForRow = (row) => {
+    const obj = {};
+    row.columnNames.forEach((colName, index) => {
+        const value = row.row[index];
+        if (typeof value !== 'string') {
+            obj[colName] = row.row[index];
+            return;
+        }
+        // Try to parse the value as JSON
+        try {
+            obj[colName] = JSON.parse(value);
+        }
+        catch (e) {
+            // If it fails, just set the value as a string
+            obj[colName] = value;
+        }
+    });
+    return obj;
+};
+const getSqlResultObject = (queryResult) => {
+    if (!queryResult || !queryResult.rows || queryResult.rows.length === 0) {
+        return;
+    }
+    let obj;
+    if (queryResult.rows.length === 1) {
+        obj = getObjectForRow(queryResult.rows[0]);
+    }
+    if (queryResult.rows.length > 1) {
+        obj = queryResult.rows.reduce((acc, row) => {
+            const rowObj = getObjectForRow(row);
+            acc.push(rowObj);
+            return acc;
+        }, []);
+    }
+    return obj;
+};
 const createOrUpdate = async (db, table, values) => {
     const valueFilters = [];
     const propertiesToExcludeFromDb = ['ref'];
@@ -1828,7 +1945,7 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
         const cacheKey = `${modelName}:${propertyName}`;
         // First, check the in-memory cache (for current session edits)
         // Robust dynamic import for consumer re-bundling (named or default export)
-        const mod = await import('./ModelProperty-CGdkocQ8.js');
+        const mod = await import('./ModelProperty-D4zaeIOT.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$o('ModelProperty not available from dynamic import');
@@ -2071,7 +2188,8 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 schema = pendingProperties;
             }
             else {
-                const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+                const modelHelpersMod = await Promise.resolve().then(function () { return model; });
+                const { modelPropertiesToObject } = modelHelpersMod;
                 const modelProperties = modelClass.properties || [];
                 schema = modelPropertiesToObject(modelProperties);
             }
@@ -2091,7 +2209,8 @@ const addModelsToDb$1 = async (models, schema, modelRenames, schemaFileData) =>
                 // If no propertyFileId from map, generate a random ID
                 // IDs should be generated in the import process before calling addModelsToDb
                 if (!propertyFileId) {
-                    const { generateId } = await Promise.resolve().then(function () { return index; });
+                    const helpersIndexMod = await Promise.resolve().then(function () { return index; });
+                    const { generateId } = helpersIndexMod;
                     propertyFileId = generateId();
                     logger$o(`Generated propertyFileId "${propertyFileId}" for property "${modelName}:${propertyName}" (not found in propertyFileIds map)`);
                 }
@@ -2506,13 +2625,49 @@ const savePropertyToDb = async (property) => {
         logger$o(`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);
         });
     }
@@ -2522,14 +2677,25 @@ const getAddressesFromDb = async () => {
         .where(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
@@ -2636,7 +2802,8 @@ async function writeModelToDb(modelFileId, data) {
                 throw new Error(`Model with id ${modelId} does not exist in database. Cannot create join record.`);
             }
             // Verify schemaId exists and get name/fileId for invalidation broadcast
-            const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+            const { schemas: schemasTable } = schemaSchemaMod;
             const schemaCheck = await db
                 .select({
                 id: schemasTable.id,
@@ -2702,7 +2869,8 @@ async function writeModelToDb(modelFileId, data) {
             else {
                 // Generate random propertyFileId
                 // IDs should be generated in the import process before calling writeModelToDb
-                const { generateId } = await Promise.resolve().then(function () { return index; });
+                const helpersIndexMod = await Promise.resolve().then(function () { return index; });
+                const { generateId } = helpersIndexMod;
                 propertyFileId = generateId();
                 logger$o(`Generated propertyFileId "${propertyFileId}" for property "${data.modelName}:${propName}"`);
             }
@@ -2828,6 +2996,68 @@ async function writePropertyToDb(propertyFileId, data, isEdited = false) {
         }
     }
 }
+/**
+ * Get schema database ID from schema name or schemaFileId
+ * @param schemaNameOrFileId - Schema name (string) or schemaFileId (string)
+ * @returns Schema database ID
+ * @throws Error if schema not found
+ */
+async function getSchemaId(schemaNameOrFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+    const { schemas: schemasTable } = schemaSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, desc } = drizzleMod;
+    // Try to find by schemaFileId first (more reliable)
+    let records = await db
+        .select()
+        .from(schemasTable)
+        .where(eq(schemasTable.schemaFileId, schemaNameOrFileId))
+        .orderBy(desc(schemasTable.version))
+        .limit(1);
+    // If not found by schemaFileId, try by name
+    if (records.length === 0) {
+        records = await db
+            .select()
+            .from(schemasTable)
+            .where(eq(schemasTable.name, schemaNameOrFileId))
+            .orderBy(desc(schemasTable.version))
+            .limit(1);
+    }
+    if (records.length === 0) {
+        throw new Error(`Schema "${schemaNameOrFileId}" not found in database`);
+    }
+    return records[0].id;
+}
+/**
+ * Get schema database ID from schemaFileId
+ * @param schemaFileId - The schema file ID
+ * @returns Schema database ID
+ * @throws Error if schema not found
+ */
+async function getSchemaIdByFileId(schemaFileId) {
+    const db = BaseDb.getAppDb();
+    if (!db) {
+        throw new Error('Database not available');
+    }
+    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+    const { schemas: schemasTable } = schemaSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, desc } = drizzleMod;
+    const records = await db
+        .select()
+        .from(schemasTable)
+        .where(eq(schemasTable.schemaFileId, schemaFileId))
+        .orderBy(desc(schemasTable.version))
+        .limit(1);
+    if (records.length === 0) {
+        throw new Error(`Schema with file ID "${schemaFileId}" not found in database`);
+    }
+    return records[0].id;
+}
 /**
  * Get model database ID from model name or modelFileId
  * @param modelNameOrFileId - Model name (string) or modelFileId (string)
@@ -2840,8 +3070,10 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
     if (!db) {
         throw new Error('Database not available');
     }
-    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-    const { eq, and, or } = await import('drizzle-orm');
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+    const { models: modelsTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq, and, or } = drizzleMod;
     // Try to find by modelFileId first (more reliable)
     let records = await db
         .select()
@@ -2853,8 +3085,10 @@ async function getModelId(modelNameOrFileId, schemaNameOrId) {
         [eq(modelsTable.name, modelNameOrFileId)];
         // If schema is provided, narrow the search
         if (schemaNameOrId !== undefined) {
-            const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-            const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+            const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+            const { modelSchemas } = modelSchemaSchemaMod;
+            const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+            const { schemas: schemasTable } = schemaSchemaMod;
             if (typeof schemaNameOrId === 'number') {
                 // schemaNameOrId is schemaId
                 records = await db
@@ -2901,8 +3135,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)
@@ -2921,10 +3157,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,
@@ -2978,7 +3222,7 @@ const writeToDatabase = fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await import('./ModelProperty-CGdkocQ8.js');
+                    const mod = await import('./ModelProperty-D4zaeIOT.js');
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -3369,7 +3613,7 @@ const modelMachine = setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    import('./ModelProperty-CGdkocQ8.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-D4zaeIOT.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4215,7 +4459,8 @@ const fetchDataFromEas = fromCallback(({ sendBack, input: { context } }) => {
         }
         else if (modelName) {
             // Dynamic import to break circular dependency
-            const { Model } = await Promise.resolve().then(function () { return Model$1; });
+            const modelMod = await Promise.resolve().then(function () { return Model$1; });
+            const { Model } = modelMod;
             const model = Model.getByName(modelName);
             modelSchema = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
         }
@@ -4334,33 +4579,56 @@ var versionData = /*#__PURE__*/Object.freeze({
 
 const logger$k = 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$k(`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$k(`Created/cached ItemProperty instance for propertyName "${metaRow.propertyName}"`);
+                    propertyInstances.set(propertyName, property);
+                    logger$k(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$k(`ItemProperty.find returned undefined for propertyName "${metaRow.propertyName}"`);
+                    logger$k(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
@@ -4380,7 +4648,6 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) =
 const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        console.log(`[loadOrCreateItem] Called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         logger$k(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
@@ -4492,16 +4759,11 @@ const loadOrCreateItem = fromCallback(({ sendBack, input: { context } }) => {
             .from(metadata$1)
             .where(and(eq(metadata$1.seedLocalId, resolvedSeedLocalId), eq(metadata$1.versionLocalId, latestVersionLocalId)));
         logger$k(`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',
@@ -4539,14 +4801,17 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
             return;
         }
         try {
-            const { Item } = await Promise.resolve().then(function () { return Item$1; });
+            const itemMod = await Promise.resolve().then(function () { return Item$1; });
+            const { Item } = itemMod;
             const item = await Item.find({ seedLocalId });
             if (!item) {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const { getPublishUploads } = await import('./getPublishUploads-Dc-HqhO8.js');
-            const { getPublishPayload } = await import('./getPublishPayload-uLm0AqN_.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-B0WArDfp.js');
+            const { getPublishUploads } = getPublishUploadsMod;
+            const getPublishPayloadMod = await import('./getPublishPayload-BRgULCf3.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.
@@ -4718,14 +4983,18 @@ const itemMachineSingle = setup({
                     actions: 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,
@@ -5081,6 +5350,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 ? startCase(modelName) : (seedRow.type ? startCase(seedRow.type) : undefined);
+    if (appDb && normalizedModelName) {
+        try {
+            const schemaRows = await appDb
+                .select({ schemaName: schemas.name })
+                .from(models$1)
+                .innerJoin(modelSchemas, eq(models$1.id, modelSchemas.modelId))
+                .innerJoin(schemas, eq(modelSchemas.schemaId, schemas.id))
+                .where(eq(models$1.name, normalizedModelName))
+                .limit(1);
+            if (schemaRows.length > 0 && schemaRows[0].schemaName) {
+                schemaName = schemaRows[0].schemaName;
+            }
+        }
+        catch (error) {
+            logger$i('[getItemData] Error deriving schemaName:', error);
+        }
+    }
     // Now get version data if it exists - query versions table directly
     let versionRow = {
         versionsCount: 0,
@@ -5111,6 +5400,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     let itemData = {
         ...seedRow,
         ...versionRow,
+        schemaName,
     };
     const propertiesData = await getItemProperties({
         seedLocalId,
@@ -5134,12 +5424,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(or(isNull(seeds.uid), eq(seeds.uid, '')));
+    }
     if (modelName) {
         conditions.push(eq(seeds.type, toSnakeCase$1(modelName)));
     }
+    if (addressFilter === 'owned') {
+        const ownedAddresses = await getOwnedAddressesFromDb();
+        if (ownedAddresses.length > 0) {
+            conditions.push(or(inArray(seeds.publisher, ownedAddresses), isNull(seeds.publisher)));
+        }
+    }
+    else if (addressFilter === 'watched') {
+        const watchedAddresses = await getWatchedAddressesFromDb();
+        if (watchedAddresses.length === 0) {
+            return [];
+        }
+        conditions.push(inArray(seeds.publisher, watchedAddresses));
+    }
     if (deleted) {
         conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
     }
@@ -5276,7 +5582,8 @@ const getModelSchemasFromEas = async () => {
     const queryClient = BaseQueryClient.getQueryClient();
     const easClient = BaseEasClient.getEasClient();
     // Dynamic import to break circular dependency
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     const allModels = await Model.all();
     const modelNames = allModels.map(m => m.modelName).filter((name) => !!name);
     // If there are no models, return empty array instead of querying
@@ -5630,7 +5937,8 @@ const resolveRelatedValue = fromCallback(({ sendBack, input: { context } }) => {
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
         }
@@ -5968,7 +6276,8 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
         // Re-check types with dynamically imported ModelPropertyDataTypes
@@ -6120,7 +6429,8 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = await Promise.resolve().then(function () { return Item$1; });
+            const itemMod = await Promise.resolve().then(function () { return Item$1; });
+            const { Item } = itemMod;
             const item = await Item.find({
                 seedLocalId: seedLocalId ?? undefined,
                 modelName,
@@ -6197,8 +6507,8 @@ const loadOrCreateProperty = 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 = startCase(modelName);
+                // Normalize snake_case to PascalCase: "test_post" -> "TestPost" (startCase gives "Test Post" which fails)
+                const normalizedModelName = upperFirst(camelCase(modelName));
                 // Query properties table to get property schema
                 const modelRecords = await db
                     .select({ id: models$1.id })
@@ -6229,6 +6539,28 @@ const loadOrCreateProperty = 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 = upperFirst(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(toSnakeCase$1(modelName));
+                }
+                if (model$1?.properties?.length) {
+                    const schemas = modelPropertiesToObject(model$1.properties);
+                    propertyRecordSchema = schemas[propertyName];
+                    if (propertyRecordSchema) {
+                        logger$f(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                    }
+                }
+            }
+            catch (error) {
+                logger$f(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+            }
+        }
         // Return loaded property data
         sendBack({
             type: 'loadOrCreatePropertySuccess',
@@ -6440,7 +6772,8 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         let propertyName = propertyNameRaw;
         if (!propertyName) {
             throw new Error('propertyName is required');
@@ -6797,7 +7130,8 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
+        const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
         }
@@ -7499,6 +7833,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 ? upperFirst(camelCase(modelType)) : '';
 const logger$d = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
@@ -7595,7 +7955,8 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const { ModelPropertyDataTypes } = await import('./index-LEY0Og1p.js');
+            const schemaMod = await import('./index-BnF3MRZ8.js');
+            const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
             if (context.seedLocalId && context.propertyName) {
@@ -7708,9 +8069,14 @@ class ItemProperty {
             setupState.subscriptionSetUp = true;
             logger(`[ItemProperty._setupLiveQuerySubscription] Setting up liveQuery for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             try {
-                const { metadata } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
-                const { eq, and, isNotNull } = await import('drizzle-orm');
-                const { getMetadataLatest } = await Promise.resolve().then(function () { return metadataLatest; });
+                const _mod_5 = await import('./index-BIPPEMVY.js');
+                const _ns_5 = _mod_5.s;
+                const seedSchemaMod = _ns_5;
+                const { metadata } = seedSchemaMod;
+                const drizzleMod = await import('drizzle-orm');
+                const { eq, and, isNotNull } = drizzleMod;
+                const metadataLatestMod = await Promise.resolve().then(function () { return metadataLatest; });
+                const { getMetadataLatest } = metadataLatestMod;
                 const db = BaseDb.getAppDb();
                 if (!db) {
                     logger('[ItemProperty._setupLiveQuerySubscription] Database not available');
@@ -7980,10 +8346,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 ? 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;
@@ -8006,9 +8376,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) {
@@ -8143,10 +8520,15 @@ class ItemProperty {
         });
     }
     async save() {
+        const ctx = this._getSnapshotContext();
+        const { assertItemOwned } = await import('./ownership-CSsweVap.js');
+        await assertItemOwned({
+            seedLocalId: ctx?.seedLocalId ?? undefined,
+            seedUid: ctx?.seedUid ?? undefined,
+        });
         await 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 });
@@ -8223,8 +8605,12 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const { metadata } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
-                    const { and, eq, or } = await import('drizzle-orm');
+                    const _mod_6 = await import('./index-BIPPEMVY.js');
+                    const _ns_6 = _mod_6.s;
+                    const seedSchemaMod = _ns_6;
+                    const { metadata } = seedSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { and, eq, or } = drizzleMod;
                     const conditions = [eq(metadata.propertyName, propertyName)];
                     if (seedLocalId && seedUid) {
                         conditions.push(or(eq(metadata.seedLocalId, seedLocalId), eq(metadata.seedUid, seedUid)));
@@ -8239,7 +8625,8 @@ class ItemProperty {
                         await db.delete(metadata).where(and(...conditions));
                     }
                 }
-                const { Item } = await Promise.resolve().then(function () { return Item$1; });
+                const itemMod = await Promise.resolve().then(function () { return Item$1; });
+                const { Item } = itemMod;
                 const item = Item.getById((seedLocalId || seedUid));
                 if (item) {
                     item.getService().send({ type: 'removePropertyInstance', propertyName });
@@ -8265,14 +8652,22 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
     const newSeedId = await createSeed({ type: seedType });
     const newVersionId = await createVersion({ seedLocalId: newSeedId, seedType: toSnakeCase$1(modelName) });
     // Dynamic import to break circular dependency
-    const { Model } = await Promise.resolve().then(function () { return Model$1; });
+    const modelMod = await Promise.resolve().then(function () { return Model$1; });
+    const { Model } = modelMod;
     const model = await Model.getByNameAsync(modelName);
     const propertySchemas = model?.properties ? modelPropertiesToObject(model.properties) : undefined;
-    for (const [propertyName, propertyValue] of Object.entries(propertyData)) {
-        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,
@@ -8439,6 +8834,8 @@ class Item {
             });
         };
         this.publish = async () => {
+            const { assertItemOwned } = await import('./ownership-CSsweVap.js');
+            await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
                 let wasPublishing = false;
@@ -8473,12 +8870,14 @@ class Item {
         };
         this.getPublishUploads = async () => {
             // Use dynamic import to break circular dependency
-            const { getPublishUploads } = await import('./getPublishUploads-Dc-HqhO8.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-B0WArDfp.js');
+            const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this);
         };
         this.getPublishPayload = async (uploadedTransactions) => {
             // Use dynamic import to break circular dependency
-            const { getPublishPayload } = await import('./getPublishPayload-uLm0AqN_.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BRgULCf3.js');
+            const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions);
         };
         this.persistSeedUid = async () => {
@@ -8753,8 +9152,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)
@@ -9006,8 +9407,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({
@@ -9344,9 +9745,14 @@ class Item {
             setupState.subscriptionSetUp = true;
             logger(`[Item._setupLiveQuerySubscription] Setting up liveQuery for seedLocalId: ${seedLocalId}`);
             try {
-                const { seeds, versions, metadata } = await import('./index-2FcQHgKp.js').then(function (n) { return n.s; });
-                const { eq, and } = await import('drizzle-orm');
-                const { getVersionData } = await Promise.resolve().then(function () { return versionData; });
+                const _mod_7 = await import('./index-BIPPEMVY.js');
+                const _ns_7 = _mod_7.s;
+                const seedSchemaMod = _ns_7;
+                const { seeds, versions, metadata } = seedSchemaMod;
+                const drizzleMod = await import('drizzle-orm');
+                const { eq, and } = drizzleMod;
+                const versionDataMod = await Promise.resolve().then(function () { return versionData; });
+                const { getVersionData } = versionDataMod;
                 const db = BaseDb.getAppDb();
                 if (!db) {
                     logger('[Item._setupLiveQuerySubscription] Database not available');
@@ -9389,7 +9795,8 @@ class Item {
                 // CRITICAL: Create ItemProperty instances BEFORE updating context
                 if (initialMetadataIds.length > 0) {
                     try {
-                        const { ItemProperty } = await Promise.resolve().then(function () { return ItemProperty$1; });
+                        const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
+                        const { ItemProperty } = itemPropertyMod;
                         const itemModelName = this._service.getSnapshot().context.modelName;
                         const createPromises = initialMetadata.map(async (metaRow) => {
                             try {
@@ -9497,7 +9904,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 {
@@ -9618,6 +10026,8 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
+        const { assertItemOwned } = await import('./ownership-CSsweVap.js');
+        await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKey = context.seedUid || context.seedLocalId;
         const cacheKeys = cacheKey ? [cacheKey] : [];
@@ -9659,6 +10069,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 &&
@@ -9695,7 +10123,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();
@@ -9797,6 +10226,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,
@@ -9930,7 +10360,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();
@@ -10115,6 +10546,10 @@ const getRelatedSeedsAndVersions = async () => {
     });
 };
 const syncDbWithEasHandler = throttle(async (_) => {
+    const addresses = await getAllAddressesFromDb();
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
     const appDb = BaseDb.getAppDb();
     const { schemaStringToModelRecord } = await getModelSchemas();
     const modelSchemas = await getModelSchemasFromEas();
@@ -10152,7 +10587,6 @@ const syncDbWithEasHandler = throttle(async (_) => {
     if (schemaUids.length === 0) {
         return;
     }
-    const addresses = await getAddressesFromDb();
     const itemSeeds = await getSeedsFromSchemaUids({
         schemaUids,
         addresses,
@@ -10254,21 +10688,21 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         let PathResolver;
         let EasClient;
         if (isBrowser()) {
-            FileManager = (await import('./FileManager-C9zr4AJe.js')).FileManager;
-            Db = (await import('./Db-DjFdIdR9.js')).Db;
-            QueryClient = (await import('./QueryClient-ByKPdRmE.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-CgWK-JgT.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-CX6GHoTS.js')).PathResolver;
-            EasClient = (await import('./EasClient-Aojewp6P.js')).EasClient;
+            FileManager = (await import('./FileManager-Cub9icdd.js')).FileManager;
+            Db = (await import('./Db-Cq4q88X_.js')).Db;
+            QueryClient = (await import('./QueryClient-Vs9KN5kS.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-nrTU_rhU.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-T1yEDECb.js')).PathResolver;
+            EasClient = (await import('./EasClient-ZCIE6UQq.js')).EasClient;
         }
         else if (isNode()) {
             console.log('isNode');
-            FileManager = (await import('./FileManager-CxGJLw5C.js')).FileManager;
-            Db = (await import('./Db-DjofXdeU.js')).Db;
-            QueryClient = (await import('./QueryClient-Cb1iJO-x.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-WcG8CZAE.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-z_WX47_o.js')).PathResolver;
-            EasClient = (await import('./EasClient-BVFXp2O6.js')).EasClient;
+            FileManager = (await import('./FileManager-HSFEess-.js')).FileManager;
+            Db = (await import('./Db-CWKaeNQH.js')).Db;
+            QueryClient = (await import('./QueryClient-DcKDQuwz.js')).QueryClient;
+            ArweaveClient = (await import('./ArweaveClient-BdQaTOZ4.js')).ArweaveClient;
+            PathResolver = (await import('./PathResolver-DVLBs_qi.js')).PathResolver;
+            EasClient = (await import('./EasClient-Du9_TULE.js')).EasClient;
         }
         else {
             throw new Error(`Unable to determine environment. isBrowser()=${isBrowser()}, isNode()=${isNode()}. Platform-specific implementations could not be loaded.`);
@@ -10328,11 +10762,14 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
             }
             // 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,
             } });
@@ -10516,11 +10953,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 waitFor(clientService, (snapshot) => {
@@ -10532,7 +10970,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
                 state === 'addModelsToDb' ||
                 state === 'idle';
         }, { timeout: 30000 });
-        addresses = await getAddressesFromDb();
+        addresses = await getAllAddressesFromDb();
     }
     if (!addresses || addresses.length === 0) {
         return;
@@ -10884,7 +11322,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
 const logger$5 = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     logger$5('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) {
@@ -10904,7 +11342,9 @@ const saveConfig = 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)
@@ -10918,7 +11358,7 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                     value: endpointsValueString,
                 },
             });
-            if (addresses) {
+            if (owned.length > 0 || watched.length > 0) {
                 await appDb
                     .insert(appState)
                     .values({
@@ -11458,8 +11898,10 @@ const logger$3 = debug('seedSdk:imports:json');
  * @returns Promise that resolves when properties are found, or rejects if not found after max retries
  */
 const verifyPropertiesPersisted = async (db, modelId, modelName, maxRetries = 10, retryDelay = 100) => {
-    const { properties: propertiesTable } = await Promise.resolve().then(function () { return ModelSchema; });
-    const { eq } = await import('drizzle-orm');
+    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+    const { properties: propertiesTable } = modelSchemaMod;
+    const drizzleMod = await import('drizzle-orm');
+    const { eq } = drizzleMod;
     console.log(`[verifyPropertiesPersisted] Starting verification for model "${modelName}" (modelId: ${modelId})`);
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         const props = await db
@@ -11775,7 +12217,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
         schemaFile = transformImportToSchemaFile(importData, version);
     }
     // Check if this is an internal SDK schema (should not create files in app directory)
-    const { isInternalSchema } = await Promise.resolve().then(function () { return constants; });
+    const constantsMod = await Promise.resolve().then(function () { return constants; });
+    const { isInternalSchema } = constantsMod;
     const isInternal = isInternalSchema(schemaFile.metadata.name, schemaFile.id);
     if (isInternal) {
         logger$3(`Skipping file creation for internal schema: ${schemaFile.metadata.name}`);
@@ -11869,7 +12312,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const { addSchemaToDb, addModelsToDb } = await Promise.resolve().then(function () { return db; });
+        const dbMod = await Promise.resolve().then(function () { return db; });
+        const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
             const db = BaseDb.getAppDb();
@@ -11890,9 +12334,12 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     // CRITICAL: Verify all expected models are linked via join table
                     // Retry querying until all models are visible (browser environments may have delays)
                     const expectedModelNames = Object.keys(schemaFile.models || {});
-                    const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-                    const { eq, and } = await import('drizzle-orm');
+                    const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                    const { modelSchemas } = modelSchemaSchemaMod;
+                    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { models: modelsTable } = modelSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { eq, and } = drizzleMod;
                     let allModelsLinked = false;
                     for (let attempt = 0; attempt < 10; attempt++) {
                         const modelLinks = await db
@@ -12063,10 +12510,11 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                             }
                         }
                     }
-                    // After properties are created, ensure schemaFile has the correct IDs from database
+                    // After properties are created (internal schema path), ensure schemaFile has the correct IDs from database
                     // Query the database to get the actual schemaFileId values that were used
                     // This ensures schemaData matches what's actually in the database
-                    const { properties: propertiesTable } = await Promise.resolve().then(function () { return ModelSchema; });
+                    const modelSchemaMod1 = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { properties: propertiesTable } = modelSchemaMod1;
                     let schemaFileUpdated = false;
                     for (const [modelName, modelFileId] of modelFileIds.entries()) {
                         // Get model record to find modelId
@@ -12099,7 +12547,8 @@ async function importJsonSchema(importFilePathOrContents, version = 1) {
                     // This is important even if nothing changed, to ensure consistency
                     const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                     // Update the schema record in the database with current schemaData
-                    const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const schemaSchemaMod1 = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const { schemas: schemasTable } = schemaSchemaMod1;
                     await db
                         .update(schemasTable)
                         .set({ schemaData: updatedSchemaData })
@@ -12313,7 +12762,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
             updatedAt: new Date(schemaFile.metadata.updatedAt).getTime(),
         };
         // Use dynamic import to break circular dependency
-        const { addSchemaToDb, addModelsToDb } = await Promise.resolve().then(function () { return db; });
+        const dbMod = await Promise.resolve().then(function () { return db; });
+        const { addSchemaToDb, addModelsToDb } = dbMod;
         // Try to add schema and models to database if database is available
         try {
             const db = BaseDb.getAppDb();
@@ -12335,9 +12785,12 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     await new Promise(resolve => setTimeout(resolve, 200));
                     console.log(`[importJsonSchema] Starting property verification for schema "${schemaName}" (schemaRecord.id: ${schemaRecord.id})`);
                     // Query the database to get model IDs that were just created
-                    const { modelSchemas } = await Promise.resolve().then(function () { return ModelSchemaSchema; });
-                    const { models: modelsTable } = await Promise.resolve().then(function () { return ModelSchema; });
-                    const { eq } = await import('drizzle-orm');
+                    const modelSchemaSchemaMod = await Promise.resolve().then(function () { return ModelSchemaSchema; });
+                    const { modelSchemas } = modelSchemaSchemaMod;
+                    const modelSchemaMod = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { models: modelsTable } = modelSchemaMod;
+                    const drizzleMod = await import('drizzle-orm');
+                    const { eq } = drizzleMod;
                     // Try to find models directly by schemaFileId first (more reliable than join table)
                     const seedModelId = modelFileIds.get('Seed');
                     let seedModel = [];
@@ -12399,10 +12852,11 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                             }
                         }
                     }
-                    // After properties are created, ensure schemaFile has the correct IDs from database
+                    // After properties are created (file path), ensure schemaFile has the correct IDs from database
                     // Query the database to get the actual schemaFileId values that were used
                     // This ensures schemaData matches what's actually in the database
-                    const { properties: propertiesTable } = await Promise.resolve().then(function () { return ModelSchema; });
+                    const modelSchemaMod2 = await Promise.resolve().then(function () { return ModelSchema; });
+                    const { properties: propertiesTable } = modelSchemaMod2;
                     let schemaFileUpdated = false;
                     for (const [modelName, modelFileId] of modelFileIds.entries()) {
                         // Get model record to find modelId
@@ -12435,7 +12889,8 @@ const loadSchemaFromFile = async (schemaFilePath) => {
                     // This is important even if nothing changed, to ensure consistency
                     const updatedSchemaData = JSON.stringify(schemaFile, null, 2);
                     // Update the schema record in the database with current schemaData
-                    const { schemas: schemasTable } = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const schemaSchemaMod = await Promise.resolve().then(function () { return SchemaSchema; });
+                    const { schemas: schemasTable } = schemaSchemaMod;
                     await db
                         .update(schemasTable)
                         .set({ schemaData: updatedSchemaData })
@@ -12476,7 +12931,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) {
@@ -12981,14 +13437,17 @@ const clientManagerMachine = setup({
                     actions: [
                         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,
                             };
                         })
@@ -13061,6 +13520,8 @@ const clientInstance = {
                     isSaving: false,
                     endpoints: undefined,
                     addresses: undefined,
+                    ownedAddresses: undefined,
+                    watchedAddresses: undefined,
                     models: undefined,
                     arweaveDomain: undefined,
                     filesDir: undefined,
@@ -13115,9 +13576,17 @@ const clientInstance = {
     },
     getAddresses: async () => {
         ensureInitialized();
-        const db = await BaseDb.getAppDb();
-        const results = await db.select().from(appState).where(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();
@@ -13327,7 +13796,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = import('./ModelProperty-CGdkocQ8.js')
+const modelPropertyImportPromise = import('./ModelProperty-D4zaeIOT.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -13344,7 +13813,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = import('./Schema-D1eqDHyt.js').then(function (n) { return n.b; })
+const schemaImportPromise = (async () => { const _mod_8 = await import('./Schema-SbwqmoMM.js'); return _mod_8.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -13860,7 +14329,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 {
@@ -14143,6 +14616,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 && toSnakeCase$1(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.
@@ -14845,7 +15334,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)
@@ -15176,5 +15666,5 @@ const Date$1 = () => PropertyConstructor(Property.Date());
 Type.Record(Type.String(), Type.Any());
 Type.Record(Type.String(), TProperty);
 
-export { getItemData as $, config as A, Boolean$1 as B, metadata$1 as C, Date$1 as D, EAS_ENDPOINT as E, modelRelations as F, modelSchemas as G, modelUids as H, Image as I, Json as J, modelsRelations as K, List as L, Model as M, Number$1 as N, propertiesRelations as O, Property as P, propertyUidRelations as Q, Relation as R, SEED_CONFIG_FILE as S, TPropertyDataType as T, propertyUids as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, schemas as W, seeds as X, versions as Y, ZERO_BYTES32 as Z, graphql as _, ModelPropertyDataTypes as a, Item as a0, saveAppState as a1, addModelsToDb$1 as a2, SCHEMA_NJK as a3, ItemProperty as a4, eventEmitter as a5, ClientManager as a6, INIT_SCRIPT_SUCCESS_MESSAGE as a7, SCHEMA_TS as a8, importJsonSchema as a9, SeedModels as aA, getArweaveUrlForTransaction as aB, createSchema as aC, readSchema as aD, listCompleteSchemaFiles as aE, getSchemaNameFromId as aF, getLatestSchemaVersion as aG, createModelsFromJson as aH, SEED_PROTOCOL_SCHEMA_NAME as aI, addSchemaToDb as aJ, loadModelsFromDbForSchema as aK, isInternalSchema as aL, createModelFromJson as aM, ConflictError as aN, unloadEntity as aO, clearDestroySubscriptions as aP, setupEntityLiveQuery as aQ, ModelSchema as aR, BaseFileManager$1 as aS, db as aT, schema as aU, SEEDPROTOCOL_Seed_Protocol_v1 as aV, Model$1 as aW, loadSchemaFromFile as aa, readJsonImportFile as ab, transformImportToSchemaFile as ac, writeProcessMachine as ad, generateId as ae, waitForEntityIdle as af, createReactiveProxy as ag, findEntity as ah, forceRemoveFromCaches as ai, runDestroyLifecycle as aj, getModelIdByFileId as ak, getModelId as al, getClient as am, ClientManagerState as an, getVersionData$1 as ao, createNewItem as ap, loadAllSchemasFromDb as aq, getSeedsBySchemaName as ar, GET_SEEDS as as, getItemVersionsFromEas as at, getItemPropertiesFromEas as au, setSchemaUidForSchemaDefinition as av, parseEasRelationPropertyName as aw, getModelSchemasFromEas as ax, getSchemaUidBySchemaName as ay, getSeedsFromSchemaUids as az, TStorageType as b, TProperty as c, TPropertyConstructor as d, PropertyMetadataKey as e, PropertyConstructor as f, Text as g, TValidationRules as h, getSchemaUidForModel as i, getCorrectId as j, defaultAttestationData as k, INTERNAL_DATA_TYPES as l, getSchemaUidForSchemaDefinition as m, getSchemaForItemProperty as n, modelPropertiesToObject as o, BaseDb as p, models$1 as q, properties as r, BaseQueryClient as s, toSnakeCase as t, BaseArweaveClient as u, BasePathResolver as v, BaseEasClient as w, BaseFileManager as x, appState as y, SEED_CONFIG_FALLBACKS as z };
-//# sourceMappingURL=index-DPll6EAp.js.map
+export { graphql as $, appState as A, Boolean$1 as B, SEED_CONFIG_FALLBACKS as C, Date$1 as D, EAS_ENDPOINT as E, config as F, metadata$1 as G, modelRelations as H, Image as I, Json as J, modelSchemas as K, List as L, Model as M, Number$1 as N, modelUids as O, Property as P, modelsRelations as Q, Relation as R, SEED_CONFIG_FILE as S, TPropertyDataType as T, propertiesRelations as U, VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA as V, propertyUidRelations as W, propertyUids as X, schemas as Y, ZERO_BYTES32 as Z, versions as _, ModelPropertyDataTypes as a, getItemData as a0, Item as a1, saveAppState as a2, addModelsToDb$1 as a3, SCHEMA_NJK as a4, ItemProperty as a5, eventEmitter as a6, ClientManager as a7, INIT_SCRIPT_SUCCESS_MESSAGE as a8, SCHEMA_TS as a9, getSeedsFromSchemaUids as aA, SeedModels as aB, getArweaveUrlForTransaction as aC, createSchema as aD, readSchema as aE, listCompleteSchemaFiles as aF, getSchemaNameFromId as aG, getLatestSchemaVersion as aH, createModelsFromJson as aI, SEED_PROTOCOL_SCHEMA_NAME as aJ, addSchemaToDb as aK, loadModelsFromDbForSchema as aL, isInternalSchema as aM, createModelFromJson as aN, ConflictError as aO, unloadEntity as aP, clearDestroySubscriptions as aQ, setupEntityLiveQuery as aR, ModelSchema as aS, BaseFileManager$1 as aT, db as aU, schema as aV, SEEDPROTOCOL_Seed_Protocol_v1 as aW, Model$1 as aX, importJsonSchema as aa, loadSchemaFromFile as ab, readJsonImportFile as ac, transformImportToSchemaFile as ad, writeProcessMachine as ae, generateId as af, waitForEntityIdle as ag, createReactiveProxy as ah, findEntity as ai, forceRemoveFromCaches as aj, runDestroyLifecycle as ak, getModelIdByFileId as al, getModelId as am, getClient as an, ClientManagerState as ao, getVersionData$1 as ap, createNewItem as aq, loadAllSchemasFromDb as ar, getSeedsBySchemaName as as, GET_SEEDS as at, getItemVersionsFromEas as au, getItemPropertiesFromEas as av, setSchemaUidForSchemaDefinition as aw, parseEasRelationPropertyName as ax, getModelSchemasFromEas as ay, getSchemaUidBySchemaName as az, TStorageType as b, TProperty as c, TPropertyConstructor as d, PropertyMetadataKey as e, PropertyConstructor as f, Text as g, TValidationRules as h, getOwnedAddressesFromDb as i, BaseDb as j, getSchemaUidForModel as k, getCorrectId as l, defaultAttestationData as m, INTERNAL_DATA_TYPES as n, getSchemaUidForSchemaDefinition as o, getSchemaForItemProperty as p, modelPropertiesToObject as q, models$1 as r, seeds as s, toSnakeCase as t, properties as u, BaseQueryClient as v, BaseArweaveClient as w, BasePathResolver as x, BaseEasClient as y, BaseFileManager as z };
+//# sourceMappingURL=index-zsq08F5p.js.map