@seedprotocol/sdk 0.4.6 → 0.4.7

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

@@ -647,7 +647,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DpjD0o0E.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$x('createPropertyInstances: ModelProperty not available from dynamic import');
@@ -836,7 +836,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         // Step 2: Fallback to Schema context (only if database doesn't have the model)
         // This handles the case where model exists in schema file but not yet in database
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             const schemaSnapshot = schema.getService().getSnapshot();
@@ -1080,7 +1080,7 @@ const loadOrCreateModel = xstate.fromCallback(({ sendBack, input: { context } })
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; });
             const { Schema } = schemaMod;
             const schema = Schema.create(schemaName, { waitForReady: false });
             schema.getService().send({ type: 'markAsDraft', propertyKey: 'schema:models' });
@@ -1124,10 +1124,10 @@ const validateModel = xstate.fromCallback(({ sendBack, input: { context } }) =>
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+            const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-O3FCMROl.js'); });
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; });
             const { Schema } = schemaMod;
             // Validate model structure
             const structureResult = validationService.validateModelStructure(context);
@@ -1239,7 +1239,7 @@ const createModelProperties = xstate.fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$v(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DpjD0o0E.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$v('ModelProperty not available from dynamic import');
@@ -1344,7 +1344,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                 logger$u(structureMsg);
                 console.log(structureMsg); // Always log to console
                 // Use existing Model validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-O3FCMROl.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -1363,7 +1363,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$u(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData.schemaName, {
                                 waitForReady: false,
@@ -1399,7 +1399,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-O3FCMROl.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1414,7 +1414,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; });
+                            const schemaMod = await Promise.resolve().then(function () { return require('./Schema-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; });
                             const { Schema } = schemaMod;
                             const schema = Schema.create(entityInput.entityData._schemaName, {
                                 waitForReady: false,
@@ -1443,7 +1443,7 @@ const validateEntity = xstate.fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-p5BbJV9T.js'); });
+                const validationServiceMod = await Promise.resolve().then(function () { return require('./SchemaValidationService-O3FCMROl.js'); });
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1480,6 +1480,7 @@ const seeds = sqliteCore.sqliteTable('seeds', {
     uid: sqliteCore.text('uid'),
     schemaUid: sqliteCore.text('schema_uid'),
     type: sqliteCore.text('type'),
+    publisher: sqliteCore.text('publisher'),
     attestationRaw: sqliteCore.text('attestation_raw'),
     attestationCreatedAt: sqliteCore.int('attestation_created_at'),
     createdAt: sqliteCore.int('created_at'),
@@ -1993,7 +1994,7 @@ async function checkIfPropertyIsEdited(modelName, propertyName, schemaFileValue)
         const cacheKey = `${modelName}:${propertyName}`;
         // First, check the in-memory cache (for current session edits)
         // Robust dynamic import for consumer re-bundling (named or default export)
-        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
+        const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DpjD0o0E.js'); });
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$t('ModelProperty not available from dynamic import');
@@ -2673,13 +2674,49 @@ const savePropertyToDb = async (property) => {
         logger$t(`Created property ${property.modelName}:${property.name} in database`);
     }
 };
-const getAddressesFromDb = async () => {
+function parseAddressConfig(value) {
+    if (!value)
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+            return { owned: parsed, watched: [] };
+        }
+        if (parsed && typeof parsed === 'object' && Array.isArray(parsed.owned)) {
+            return {
+                owned: parsed.owned,
+                watched: Array.isArray(parsed.watched) ? parsed.watched : [],
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+const getOwnedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
+};
+const getWatchedAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.watched ?? [];
+};
+/**
+ * Returns owned + watched addresses. Use for EAS sync and file download.
+ */
+const getAllAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config)
+        return [];
+    return [...config.owned, ...config.watched];
+};
+async function getAddressConfigFromDb() {
     const appDb = BaseDb.getAppDb();
     if (!appDb) {
         return new Promise((resolve) => {
             setTimeout(async () => {
-                const addresses = await getAddressesFromDb();
-                resolve(addresses);
+                resolve(await getAddressConfigFromDb());
             }, 500);
         });
     }
@@ -2689,14 +2726,25 @@ const getAddressesFromDb = async () => {
         .where(drizzleOrm.eq(appState.key, 'addresses'))
         .limit(1);
     if (!appStatesRecords || appStatesRecords.length === 0) {
-        throw new Error('No appStatesRecords for addresses found');
+        return null;
     }
-    const addressRecord = appStatesRecords[0];
-    const addressArrayString = addressRecord.value;
-    if (!addressArrayString) {
+    const addressArrayString = appStatesRecords[0].value;
+    return parseAddressConfig(addressArrayString);
+}
+const getAddressesFromDb = async () => {
+    const config = await getAddressConfigFromDb();
+    if (!config || config.owned.length === 0) {
         throw new Error('No addresses found');
     }
-    return JSON.parse(addressArrayString);
+    return config.owned;
+};
+/**
+ * Like getAddressesFromDb but returns [] instead of throwing when no addresses are configured.
+ * Returns owned addresses. Use getAllAddressesFromDb for sync (owned + watched).
+ */
+const getAddressesFromDbOptional = async () => {
+    const config = await getAddressConfigFromDb();
+    return config?.owned ?? [];
 };
 /**
  * Write model to database and create model_schemas join entry
@@ -3158,14 +3206,18 @@ var db = /*#__PURE__*/Object.freeze({
     createOrUpdate: createOrUpdate,
     escapeSqliteString: escapeSqliteString,
     getAddressesFromDb: getAddressesFromDb,
+    getAddressesFromDbOptional: getAddressesFromDbOptional,
+    getAllAddressesFromDb: getAllAddressesFromDb,
     getModelId: getModelId,
     getModelIdByFileId: getModelIdByFileId,
     getModelNameByModelId: getModelNameByModelId,
     getObjectForRow: getObjectForRow,
+    getOwnedAddressesFromDb: getOwnedAddressesFromDb,
     getPropertyModelNameAndDataType: getPropertyModelNameAndDataType,
     getSchemaId: getSchemaId,
     getSchemaIdByFileId: getSchemaIdByFileId,
     getSqlResultObject: getSqlResultObject,
+    getWatchedAddressesFromDb: getWatchedAddressesFromDb,
     loadModelsFromDbForSchema: loadModelsFromDbForSchema,
     renameModelInDb: renameModelInDb,
     savePropertyToDb: savePropertyToDb,
@@ -3219,7 +3271,7 @@ const writeToDatabase = xstate.fromCallback(({ sendBack, input }) => {
                 // initial write completes is not overwritten by the stale requestWrite payload.
                 let dataToWrite = input.entityData;
                 try {
-                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); });
+                    const mod = await Promise.resolve().then(function () { return require('./ModelProperty-DpjD0o0E.js'); });
                     const ModelProperty = mod?.ModelProperty ?? mod?.default;
                     if (ModelProperty && typeof ModelProperty.getById === 'function') {
                         const instance = ModelProperty.getById(input.entityId);
@@ -3610,7 +3662,7 @@ const modelMachine = xstate.setup({
                                 // Create ModelProperty instances for any new property IDs
                                 if (Array.isArray(newPropertyIds) && newPropertyIds.length > 0) {
                                     // Import and create instances asynchronously (fire-and-forget)
-                                    Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); }).then(({ ModelProperty }) => {
+                                    Promise.resolve().then(function () { return require('./ModelProperty-DpjD0o0E.js'); }).then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4576,13 +4628,15 @@ var versionData = /*#__PURE__*/Object.freeze({
 
 const logger$p = debug('seedSdk:item:actors:loadOrCreateItem');
 /**
- * Create ItemProperty instances for all metadata records to ensure they're cached
+ * Create ItemProperty instances for all metadata records to ensure they're cached.
+ * Passes propertyRecordSchema from Model when available (Fix 3: enables value persistence for runtime-created models).
  * @param metadataRows - Array of metadata records to create ItemProperty instances for
  * @param seedLocalId - Seed local ID
  * @param seedUid - Seed UID
+ * @param modelName - Model name for resolving propertyRecordSchema from Model
  * @returns Map of propertyName -> ItemProperty instance
  */
-const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) => {
+const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid, modelName) => {
     const propertyInstances = new Map();
     if (metadataRows.length === 0) {
         return propertyInstances;
@@ -4590,20 +4644,40 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) =
     try {
         const itemPropertyMod = await Promise.resolve().then(function () { return ItemProperty$1; });
         const { ItemProperty } = itemPropertyMod;
-        // Create instances for all metadata records in parallel
+        const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+        const { Model } = await Promise.resolve().then(function () { return Model$1; });
+        // Resolve Model and build property schemas for propertyRecordSchema (Fix 3)
+        let propertySchemas = {};
+        const model$1 = Model.getByName(modelName);
+        if (model$1?.properties?.length) {
+            propertySchemas = modelPropertiesToObject(model$1.properties);
+        }
+        // Create instances for all metadata records in parallel with propertyRecordSchema
         const createPromises = metadataRows.map(async (metaRow) => {
             try {
-                const property = await ItemProperty.find({
-                    propertyName: metaRow.propertyName,
+                const propertyName = metaRow.propertyName;
+                if (!propertyName) {
+                    logger$p(`Metadata row missing propertyName, skipping`);
+                    return;
+                }
+                const createProps = {
+                    propertyName,
                     seedLocalId,
                     seedUid,
-                });
+                    modelName,
+                    propertyValue: metaRow.propertyValue ?? undefined,
+                    versionLocalId: metaRow.versionLocalId ?? undefined,
+                    versionUid: metaRow.versionUid ?? undefined,
+                    schemaUid: metaRow.schemaUid ?? undefined,
+                    propertyRecordSchema: propertySchemas[propertyName] ?? undefined,
+                };
+                const property = ItemProperty.create(createProps, { waitForReady: false });
                 if (property) {
-                    propertyInstances.set(metaRow.propertyName, property);
-                    logger$p(`Created/cached ItemProperty instance for propertyName "${metaRow.propertyName}"`);
+                    propertyInstances.set(propertyName, property);
+                    logger$p(`Created/cached ItemProperty instance for propertyName "${propertyName}" with propertyRecordSchema: ${!!createProps.propertyRecordSchema}`);
                 }
                 else {
-                    logger$p(`ItemProperty.find returned undefined for propertyName "${metaRow.propertyName}"`);
+                    logger$p(`ItemProperty.create returned undefined for propertyName "${propertyName}"`);
                 }
             }
             catch (error) {
@@ -4623,7 +4697,6 @@ const createItemPropertyInstances = async (metadataRows, seedLocalId, seedUid) =
 const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } }) => {
     const _loadOrCreateItem = async () => {
         const { seedLocalId, seedUid, modelName } = context;
-        console.log(`[loadOrCreateItem] Called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         logger$p(`loadOrCreateItem called for modelName: ${modelName}, seedLocalId: ${seedLocalId}, seedUid: ${seedUid}`);
         if (!seedLocalId && !seedUid) {
             throw new Error('seedLocalId or seedUid is required');
@@ -4735,16 +4808,11 @@ const loadOrCreateItem = xstate.fromCallback(({ sendBack, input: { context } })
             .from(metadata$1)
             .where(drizzleOrm.and(drizzleOrm.eq(metadata$1.seedLocalId, resolvedSeedLocalId), drizzleOrm.eq(metadata$1.versionLocalId, latestVersionLocalId)));
         logger$p(`Found ${metadataRecords.length} metadata records for version ${latestVersionLocalId}`);
-        console.log(`[loadOrCreateItem] Found ${metadataRecords.length} metadata records for version ${latestVersionLocalId}`);
-        if (metadataRecords.length > 0) {
-            console.log(`[loadOrCreateItem] Metadata property names:`, metadataRecords.map((r) => r.propertyName));
-        }
         // Step 4: Create ItemProperty instances from metadata records
         // This ensures they're in the cache when Item.properties getter is called
         const propertyInstances = metadataRecords.length > 0
-            ? await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid)
+            ? await createItemPropertyInstances(metadataRecords, resolvedSeedLocalId, resolvedSeedUid, modelName)
             : new Map();
-        console.log(`[loadOrCreateItem] Created ${propertyInstances.size} property instances:`, Array.from(propertyInstances.keys()));
         // Step 5: Return loaded item data with property instances
         sendBack({
             type: 'loadOrCreateItemSuccess',
@@ -4789,9 +4857,9 @@ const runPublish = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-5_oXzwol.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DDsT9zZ6.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BcjCN_bD.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CoLriAMV.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             await getPublishUploads(item);
             // For first iteration: no Arweave sign/upload - pass empty uploadedTransactions.
@@ -4964,14 +5032,18 @@ const itemMachineSingle = xstate.setup({
                     actions: xstate.assign(({ context, event }) => {
                         const item = event.item;
                         const existingPropertyInstances = context.propertyInstances || new Map();
-                        console.log(`[itemMachine] loadOrCreateItemSuccess for modelName: ${context.modelName}, propertyInstances from event:`, item.propertyInstances ? Array.from(item.propertyInstances.keys()) : 'none');
-                        // Merge property instances from loadOrCreateItem
+                        // Merge property instances from loadOrCreateItem (Fix 2: preserve existing when it has propertyRecordSchema and incoming doesn't)
                         if (item.propertyInstances) {
                             for (const [propertyName, propertyInstance] of item.propertyInstances) {
+                                const existing = existingPropertyInstances.get(propertyName);
+                                const existingHasSchema = existing?.propertyDef;
+                                const incomingHasSchema = propertyInstance?.propertyDef;
+                                if (existingHasSchema && !incomingHasSchema) {
+                                    continue; // Preserve existing instance with schema
+                                }
                                 existingPropertyInstances.set(propertyName, propertyInstance);
                             }
                         }
-                        console.log(`[itemMachine] After merge, total propertyInstances:`, Array.from(existingPropertyInstances.keys()));
                         return {
                             ...context,
                             seedLocalId: item.seedLocalId || context.seedLocalId,
@@ -5327,6 +5399,26 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     }
     const seedRow = seedRows[0];
     const resolvedSeedLocalId = seedRow.seedLocalId;
+    // Fix 5: Derive schemaName for multi-schema Model resolution (models -> model_schemas -> schemas)
+    let schemaName;
+    const normalizedModelName = modelName ? lodashEs.startCase(modelName) : (seedRow.type ? lodashEs.startCase(seedRow.type) : undefined);
+    if (appDb && normalizedModelName) {
+        try {
+            const schemaRows = await appDb
+                .select({ schemaName: schemas.name })
+                .from(models$1)
+                .innerJoin(modelSchemas, drizzleOrm.eq(models$1.id, modelSchemas.modelId))
+                .innerJoin(schemas, drizzleOrm.eq(modelSchemas.schemaId, schemas.id))
+                .where(drizzleOrm.eq(models$1.name, normalizedModelName))
+                .limit(1);
+            if (schemaRows.length > 0 && schemaRows[0].schemaName) {
+                schemaName = schemaRows[0].schemaName;
+            }
+        }
+        catch (error) {
+            logger$n('[getItemData] Error deriving schemaName:', error);
+        }
+    }
     // Now get version data if it exists - query versions table directly
     let versionRow = {
         versionsCount: 0,
@@ -5357,6 +5449,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     let itemData = {
         ...seedRow,
         ...versionRow,
+        schemaName,
     };
     const propertiesData = await getItemProperties({
         seedLocalId,
@@ -5380,12 +5473,28 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
         return itemData;
 };
 
-const getItemsData = async ({ modelName, deleted, }) => {
+const getItemsData = async ({ modelName, deleted, includeEas = false, addressFilter, }) => {
     const appDb = BaseDb.getAppDb();
     const conditions = [];
+    if (!includeEas) {
+        conditions.push(drizzleOrm.or(drizzleOrm.isNull(seeds.uid), drizzleOrm.eq(seeds.uid, '')));
+    }
     if (modelName) {
         conditions.push(drizzleOrm.eq(seeds.type, casing.toSnakeCase(modelName)));
     }
+    if (addressFilter === 'owned') {
+        const ownedAddresses = await getOwnedAddressesFromDb();
+        if (ownedAddresses.length > 0) {
+            conditions.push(drizzleOrm.or(drizzleOrm.inArray(seeds.publisher, ownedAddresses), drizzleOrm.isNull(seeds.publisher)));
+        }
+    }
+    else if (addressFilter === 'watched') {
+        const watchedAddresses = await getWatchedAddressesFromDb();
+        if (watchedAddresses.length === 0) {
+            return [];
+        }
+        conditions.push(drizzleOrm.inArray(seeds.publisher, watchedAddresses));
+    }
     if (deleted) {
         conditions.push(drizzleOrm.or(drizzleOrm.isNotNull(seeds._markedForDeletion), drizzleOrm.eq(seeds._markedForDeletion, 1)));
     }
@@ -5852,7 +5961,7 @@ const resolveRelatedValue = xstate.fromCallback(({ sendBack, input: { context }
     const { isRelation, propertyValue, propertyName, seedUid, propertyRecordSchema, populatedFromDb, schemaUid, } = context;
     const _resolveRelatedValue = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-CvcOtzbi.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -6191,7 +6300,7 @@ const hydrateFromDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-CvcOtzbi.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -6422,8 +6531,8 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
         const modelName = metadataRecord.modelType || context.modelName;
         if (modelName) {
             try {
-                // Normalize to PascalCase so "post" (from seeds.type/metadata) matches "Post" in models table
-                const normalizedModelName = lodashEs.startCase(modelName);
+                // Normalize snake_case to PascalCase: "test_post" -> "TestPost" (startCase gives "Test Post" which fails)
+                const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(modelName));
                 // Query properties table to get property schema
                 const modelRecords = await db
                     .select({ id: models$1.id })
@@ -6454,6 +6563,28 @@ const loadOrCreateProperty = xstate.fromCallback(({ sendBack, input: { context }
                 // Continue without propertyRecordSchema
             }
         }
+        if (!propertyRecordSchema && modelName) {
+            try {
+                const { Model } = await Promise.resolve().then(function () { return Model$1; });
+                const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+                const normalizedModelName = lodashEs.upperFirst(lodashEs.camelCase(modelName));
+                // Try PascalCase first ("post" -> "Post"); then findByModelType for names with spaces ("new_model" -> "New model")
+                let model$1 = Model.getByName(normalizedModelName);
+                if (!model$1?.properties?.length) {
+                    model$1 = Model.findByModelType(casing.toSnakeCase(modelName));
+                }
+                if (model$1?.properties?.length) {
+                    const schemas = modelPropertiesToObject(model$1.properties);
+                    propertyRecordSchema = schemas[propertyName];
+                    if (propertyRecordSchema) {
+                        logger$k(`Fallback: loaded propertyRecordSchema from Model for propertyName "${propertyName}"`);
+                    }
+                }
+            }
+            catch (error) {
+                logger$k(`Fallback Model lookup failed for propertyName "${propertyName}": ${error}`);
+            }
+        }
         // Return loaded property data
         sendBack({
             type: 'loadOrCreatePropertySuccess',
@@ -6665,7 +6796,7 @@ const analyzeInput = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-CvcOtzbi.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         let propertyName = propertyNameRaw;
         if (!propertyName) {
@@ -7023,7 +7154,7 @@ const saveRelation = xstate.fromCallback(({ sendBack, input: { context, event }
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+        const schemaMod = await Promise.resolve().then(function () { return require('./index-CvcOtzbi.js'); });
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -7726,6 +7857,32 @@ Promise.resolve().then(function () { return Model$1; }).then(module => {
     // Return a default module structure to maintain type consistency
     return {};
 });
+/**
+ * Resolve propertyRecordSchema from in-memory Model (Fix 6: enables value persistence when useItemProperty path doesn't go through loadOrCreateItem).
+ * Tries getByName(pascalCase) first; if that fails (e.g. "New model" vs "NewModel"), falls back to findByModelType(modelType).
+ */
+const resolvePropertyRecordSchemaFromModel = async (modelName, propertyName, modelType) => {
+    if (!modelName && !modelType)
+        return undefined;
+    try {
+        const { Model } = await Promise.resolve().then(function () { return Model$1; });
+        const { modelPropertiesToObject } = await Promise.resolve().then(function () { return model; });
+        let model$1 = modelName ? Model.getByName(modelName) : undefined;
+        if (!model$1?.properties?.length && modelType) {
+            model$1 = Model.findByModelType(modelType);
+        }
+        if (!model$1?.properties?.length)
+            return undefined;
+        const schemas = modelPropertiesToObject(model$1.properties);
+        const schema = schemas[propertyName];
+        return schema;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Convert modelType (snake_case from DB) to Model name (PascalCase). startCase adds spaces ("Test Post"); Model names are "TestPost". */
+const modelTypeToModelName = (modelType) => modelType ? lodashEs.upperFirst(lodashEs.camelCase(modelType)) : '';
 const logger$i = debug('seedSdk:property:class');
 // Define tracked properties for the Proxy
 // These properties will be read from/written to the actor context
@@ -7822,7 +7979,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await Promise.resolve().then(function () { return require('./index-BrmvhXsG.js'); });
+            const schemaMod = await Promise.resolve().then(function () { return require('./index-CvcOtzbi.js'); });
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -8211,10 +8368,14 @@ class ItemProperty {
                 return undefined;
             }
             // Ensure modelName for constructor: metadata may have modelType only, or neither (e.g. when Item passes it)
+            // Use modelTypeToModelName: modelType is snake_case ("test_post"); Model names are PascalCase ("TestPost")
             const data = propertyData;
             const modelName = data.modelName ??
-                ((data.modelType ? lodashEs.startCase(data.modelType) : '') || modelNameOption || '');
-            foundProperty = ItemProperty.create({ ...propertyData, modelName }, { waitForReady: false });
+                ((data.modelType ? modelTypeToModelName(data.modelType) : '') || modelNameOption || '');
+            // Fix 6: resolve propertyRecordSchema from Model so value setter can persist (useItemProperty path)
+            // Pass modelType for fallback: "New model" -> "new_model" can't be reversed to exact name; findByModelType handles it
+            const propertyRecordSchema = await resolvePropertyRecordSchemaFromModel(modelName, propertyName, data.modelType);
+            foundProperty = ItemProperty.create({ ...propertyData, modelName, propertyRecordSchema }, { waitForReady: false });
         }
         if (!foundProperty) {
             return undefined;
@@ -8237,9 +8398,16 @@ class ItemProperty {
         const propertiesData = await getItemProperties({ seedLocalId, seedUid });
         const instances = [];
         for (const data of propertiesData) {
+            const d = data;
+            const modelName = d.modelName ?? (d.modelType ? modelTypeToModelName(d.modelType) : '') ?? '';
+            // Fix 6: resolve propertyRecordSchema from Model so value setter can persist
+            const propertyRecordSchema = d.propertyName
+                ? await resolvePropertyRecordSchemaFromModel(modelName, d.propertyName, d.modelType)
+                : undefined;
             const createProps = {
                 ...data,
-                modelName: data.modelName ?? data.modelType ?? '',
+                modelName,
+                propertyRecordSchema,
             };
             const instance = this.create(createProps, { waitForReady: false });
             if (instance) {
@@ -8374,10 +8542,15 @@ class ItemProperty {
         });
     }
     async save() {
+        const ctx = this._getSnapshotContext();
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-Dm5ER1nI.js'); });
+        await assertItemOwned({
+            seedLocalId: ctx?.seedLocalId ?? undefined,
+            seedUid: ctx?.seedUid ?? undefined,
+        });
         await xstate.waitFor(this._service, (snapshot) => !snapshot.context.isSaving && snapshot.value === 'idle', {
             timeout: 10000,
         });
-        const ctx = this._getSnapshotContext();
         const canonicalId = ctx?.seedLocalId ?? ctx?.seedUid;
         if (canonicalId) {
             eventEmitter.emit('itemProperty.saved', { seedLocalId: ctx.seedLocalId, seedUid: ctx.seedUid });
@@ -8503,11 +8676,18 @@ const createNewItem = async ({ modelName, ...propertyData }) => {
     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,
@@ -8674,6 +8854,8 @@ class Item {
             });
         };
         this.publish = async () => {
+            const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-Dm5ER1nI.js'); });
+            await assertItemOwned(this);
             this._service.send({ type: 'startPublish' });
             return new Promise((resolve, reject) => {
                 let wasPublishing = false;
@@ -8708,13 +8890,13 @@ class Item {
         };
         this.getPublishUploads = async () => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-5_oXzwol.js'); });
+            const getPublishUploadsMod = await Promise.resolve().then(function () { return require('./getPublishUploads-DDsT9zZ6.js'); });
             const { getPublishUploads } = getPublishUploadsMod;
             return await getPublishUploads(this);
         };
         this.getPublishPayload = async (uploadedTransactions) => {
             // Use dynamic import to break circular dependency
-            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-BcjCN_bD.js'); });
+            const getPublishPayloadMod = await Promise.resolve().then(function () { return require('./getPublishPayload-CoLriAMV.js'); });
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions);
         };
@@ -9245,8 +9427,8 @@ class Item {
         }
     }
     static async all(modelName, deleted, options) {
-        const { waitForReady = false, readyTimeout = 5000 } = options ?? {};
-        const itemsData = await getItemsData({ modelName, deleted });
+        const { waitForReady = false, readyTimeout = 5000, includeEas = false, addressFilter, } = options ?? {};
+        const itemsData = await getItemsData({ modelName, deleted, includeEas, addressFilter });
         const itemInstances = [];
         for (const itemData of itemsData) {
             itemInstances.push(await Item.create({
@@ -9862,6 +10044,8 @@ class Item {
      * Destroy the item: soft delete in DB, remove from caches, clean up subscriptions, stop service.
      */
     async destroy() {
+        const { assertItemOwned } = await Promise.resolve().then(function () { return require('./ownership-Dm5ER1nI.js'); });
+        await assertItemOwned(this);
         const context = this._getSnapshotContext();
         const cacheKey = context.seedUid || context.seedLocalId;
         const cacheKeys = cacheKey ? [cacheKey] : [];
@@ -9903,6 +10087,24 @@ class ConflictError extends Error {
     }
 }
 
+/**
+ * Normalizes AddressConfiguration to { owned, watched }.
+ * - string[] -> { owned: addresses, watched: [] }
+ * - { owned, watched? } -> { owned, watched: watched ?? [] }
+ */
+function normalizeAddressConfig(addresses) {
+    if (!addresses) {
+        return { owned: [], watched: [] };
+    }
+    if (Array.isArray(addresses)) {
+        return { owned: addresses, watched: [] };
+    }
+    return {
+        owned: addresses.owned ?? [],
+        watched: addresses.watched ?? [],
+    };
+}
+
 const isNode = () => {
     return (typeof process !== 'undefined' &&
         process.versions != null &&
@@ -10042,6 +10244,7 @@ const saveEasSeedsToDb = async ({ itemSeeds }) => {
             uid: seed.id,
             schemaUid: seed.schemaId,
             type: seed.schema.schemaNames[0].name,
+            publisher: seed.attester,
             createdAt: Date.now(),
             attestationCreatedAt: seed.timeCreated * 1000,
             attestationRaw,
@@ -10361,6 +10564,10 @@ const getRelatedSeedsAndVersions = async () => {
     });
 };
 const syncDbWithEasHandler = lodashEs.throttle(async (_) => {
+    const addresses = await getAllAddressesFromDb();
+    if (!addresses || addresses.length === 0) {
+        return;
+    }
     const appDb = BaseDb.getAppDb();
     const { schemaStringToModelRecord } = await getModelSchemas();
     const modelSchemas = await getModelSchemasFromEas();
@@ -10398,7 +10605,6 @@ const syncDbWithEasHandler = lodashEs.throttle(async (_) => {
     if (schemaUids.length === 0) {
         return;
     }
-    const addresses = await getAddressesFromDb();
     const itemSeeds = await getSeedsFromSchemaUids({
         schemaUids,
         addresses,
@@ -10574,11 +10780,14 @@ const platformClassesInit = xstate.fromCallback(({ sendBack, input: { context, e
             }
             // If it's an absolute path that exists or is a valid filesystem path, use it as-is
         }
+        const normalizedAddresses = normalizeAddressConfig(addresses);
         sendBack({ type: 'updateContext', context: {
                 models: models || {},
                 endpoints,
                 arweaveDomain,
-                addresses: addresses || [],
+                addresses: normalizedAddresses.owned,
+                ownedAddresses: normalizedAddresses.owned,
+                watchedAddresses: normalizedAddresses.watched,
                 filesDir: normalizedFilesDir,
                 dbConfig,
             } });
@@ -10762,7 +10971,7 @@ 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)
@@ -10779,7 +10988,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
                 state === 'addModelsToDb' ||
                 state === 'idle';
         }, { timeout: 30000 });
-        addresses = await getAddressesFromDb();
+        addresses = await getAllAddressesFromDb();
     }
     if (!addresses || addresses.length === 0) {
         return;
@@ -11131,7 +11340,7 @@ const addModelsToDb = xstate.fromCallback(({ sendBack, input: { context } }) =>
 const logger$a = debug('seedSdk:client:actors:saveConfig');
 const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
     logger$a('saveConfig starting');
-    const { endpoints, addresses, arweaveDomain } = context;
+    const { endpoints, addresses, ownedAddresses, watchedAddresses, arweaveDomain } = context;
     // Validate endpoints - required for proper initialization
     // If endpoints are missing or invalid, initialization should fail
     if (!endpoints || !endpoints.filePaths || !endpoints.files) {
@@ -11151,7 +11360,9 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
                 throw new Error('App DB not found');
             }
             const endpointsValueString = JSON.stringify(endpoints);
-            const addressesValueString = JSON.stringify(addresses);
+            const owned = ownedAddresses ?? addresses ?? [];
+            const watched = watchedAddresses ?? [];
+            const addressesValueString = JSON.stringify({ owned, watched });
             // TODO: Figure out how to define on conflict with multiple rows added
             await appDb
                 .insert(appState)
@@ -11165,7 +11376,7 @@ const saveConfig = xstate.fromCallback(({ sendBack, input: { context } }) => {
                     value: endpointsValueString,
                 },
             });
-            if (addresses) {
+            if (owned.length > 0 || watched.length > 0) {
                 await appDb
                     .insert(appState)
                     .values({
@@ -13136,14 +13347,17 @@ const clientManagerMachine = xstate.setup({
                     actions: [
                         xstate.assign(({ event, spawn }) => {
                             const { addresses } = event;
+                            const normalized = normalizeAddressConfig(addresses);
                             spawn('saveAppState', {
                                 input: {
                                     key: 'addresses',
-                                    value: addresses,
+                                    value: { owned: normalized.owned, watched: normalized.watched },
                                 },
                             });
                             return {
-                                addresses,
+                                addresses: normalized.owned,
+                                ownedAddresses: normalized.owned,
+                                watchedAddresses: normalized.watched,
                                 isSaving: true,
                             };
                         })
@@ -13216,6 +13430,8 @@ const clientInstance = {
                     isSaving: false,
                     endpoints: undefined,
                     addresses: undefined,
+                    ownedAddresses: undefined,
+                    watchedAddresses: undefined,
                     models: undefined,
                     arweaveDomain: undefined,
                     filesDir: undefined,
@@ -13270,9 +13486,17 @@ const clientInstance = {
     },
     getAddresses: async () => {
         ensureInitialized();
-        const db = await BaseDb.getAppDb();
-        const results = await db.select().from(appState).where(drizzleOrm.eq(appState.key, 'addresses'));
-        return JSON.parse(results[0]?.value);
+        const owned = await getOwnedAddressesFromDb();
+        const watched = await getWatchedAddressesFromDb();
+        return { owned, watched };
+    },
+    getOwnedAddresses: async () => {
+        ensureInitialized();
+        return getOwnedAddressesFromDb();
+    },
+    getWatchedAddresses: async () => {
+        ensureInitialized();
+        return getWatchedAddressesFromDb();
     },
     addModel: async (modelDef) => {
         const db = await BaseDb.getAppDb();
@@ -13482,7 +13706,7 @@ const saveDraftLogger = debug('seedSdk:model:saveDraftToDb');
 // Lazy import cache for ModelProperty to avoid circular dependency
 // Eagerly start loading to minimize delay on first access
 let ModelPropertyClass = null;
-const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-B4pV91tc.js'); })
+const modelPropertyImportPromise = Promise.resolve().then(function () { return require('./ModelProperty-DpjD0o0E.js'); })
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -13499,7 +13723,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-TErl3J36.js'); }).then(function (n) { return n.Schema$1; })
+const schemaImportPromise = Promise.resolve().then(function () { return require('./Schema-DkSBMBwz.js'); }).then(function (n) { return n.Schema$1; })
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -14015,7 +14239,11 @@ class Model {
         // Step 11: Register with schema if requested, OR trigger write if properties are provided
         // If properties are provided, we need to write the model to get modelId for property creation
         // If schema provided, trigger write process instead of registration
-        const shouldTriggerWrite = (registerWithSchema && schemaInstance) || (options?.properties && Object.keys(options.properties).length > 0);
+        // When schemaName is passed as string (e.g. useCreateModel), we must trigger write so runtime-created
+        // models get persisted to DB and show up in useModels (which queries the database).
+        const shouldTriggerWrite = (registerWithSchema && schemaInstance) ||
+            (options?.properties && Object.keys(options.properties).length > 0) ||
+            typeof schemaNameOrSchema === 'string';
         if (shouldTriggerWrite) {
             queueMicrotask(async () => {
                 try {
@@ -14298,6 +14526,22 @@ class Model {
         }
         return undefined;
     }
+    /**
+     * Find Model by modelType (snake_case from DB/metadata).
+     * Handles model names with spaces: "new_model" -> finds "New model" (toSnakeCase("New model") === "new_model").
+     */
+    static findByModelType(modelType) {
+        if (!modelType)
+            return undefined;
+        for (const [nameKey, id] of this.instanceCacheByName.entries()) {
+            const parts = nameKey.split(':', 2);
+            const cachedModelName = parts[1];
+            if (cachedModelName && casing.toSnakeCase(cachedModelName) === modelType) {
+                return this.getById(id);
+            }
+        }
+        return undefined;
+    }
     /**
      * Get all Model instances for a schema from cache only (synchronous).
      * Includes models created at runtime via Model.create() that may not yet be in schema context.
@@ -15534,105 +15778,6 @@ class Db extends BaseDb {
         // You can inspect what will happen before applying
         await apply();
         this.db = db;
-        // OLD CODE: Resolve better-sqlite3 from project's node_modules first, then fall back to SDK's node_modules
-        // This is important for tests and when the SDK is used as a dependency
-        // const projectDir = path.dirname(filesDir) // filesDir is .seed, so projectDir is the project root
-        // const projectBetterSqlite3Path = path.join(projectDir, 'node_modules', 'better-sqlite3')
-        // 
-        // let Database: any
-        // try {
-        //   const fs = await import('fs')
-        //   if (fs.existsSync(projectBetterSqlite3Path)) {
-        //     // Try to resolve from project's node_modules using the full path
-        //     // For Bun, we can try importing directly from the path
-        //     try {
-        //       // First try using createRequire (works in Node.js)
-        //       const { createRequire } = await import('module')
-        //       const projectRequire = createRequire(path.join(projectDir, 'package.json'))
-        //       const betterSqlite3Module = projectRequire('better-sqlite3')
-        //       Database = betterSqlite3Module.default || betterSqlite3Module
-        //       logger('[node/db/Db] Using better-sqlite3 from project node_modules via createRequire')
-        //     } catch (requireError: any) {
-        //       // If createRequire fails (e.g., in Bun), try direct path import
-        //       logger('[node/db/Db] createRequire failed, trying direct import:', requireError.message)
-        //       const betterSqlite3MainPath = path.join(projectBetterSqlite3Path, 'lib', 'database.js')
-        //       if (fs.existsSync(betterSqlite3MainPath)) {
-        //         // Use dynamic import with the full path
-        //         const betterSqlite3Module = await import(betterSqlite3MainPath)
-        //         Database = betterSqlite3Module.default || betterSqlite3Module.Database || betterSqlite3Module
-        //         logger('[node/db/Db] Using better-sqlite3 from project node_modules via direct import')
-        //       } else {
-        //         throw new Error(`better-sqlite3 main file not found at ${betterSqlite3MainPath}`)
-        //       }
-        //     }
-        //   } else {
-        //     // Fall back to regular import (from SDK's node_modules)
-        //     const betterSqlite3Module = await import('better-sqlite3')
-        //     Database = betterSqlite3Module.default || betterSqlite3Module
-        //     logger('[node/db/Db] Using better-sqlite3 from SDK node_modules')
-        //   }
-        // } catch (importError: any) {
-        //   logger('[node/db/Db] Error importing better-sqlite3:', importError.message)
-        //   logger('[node/db/Db] projectDir:', projectDir)
-        //   logger('[node/db/Db] projectBetterSqlite3Path:', projectBetterSqlite3Path)
-        //   throw new Error(`Failed to import better-sqlite3: ${importError.message}. Please install better-sqlite3 in your project.`)
-        // }
-        // OLD CODE: Create Database instance
-        // const sqlite = new Database(dbPath)
-        // 
-        // OLD CODE: Create drizzle instance with the Database
-        // const {drizzle} = await import('drizzle-orm/better-sqlite3')
-        // this.db = drizzle(sqlite, {
-        //   logger: true,
-        // })
-        // // NEW CODE: Use libsql instead of better-sqlite3
-        // // Resolve @libsql/client from project's node_modules first, then fall back to SDK's node_modules
-        // const projectDir = path.dirname(filesDir) // filesDir is .seed, so projectDir is the project root
-        // const projectLibsqlClientPath = path.join(projectDir, 'node_modules', '@libsql', 'client')
-        // let createClient: any
-        // try {
-        //   const fs = await import('fs')
-        //   if (fs.existsSync(projectLibsqlClientPath)) {
-        //     // Try to resolve from project's node_modules using the full path
-        //     try {
-        //       // First try using createRequire (works in Node.js)
-        //       const { createRequire } = await import('module')
-        //       const projectRequire = createRequire(path.join(projectDir, 'package.json'))
-        //       const libsqlClientModule = projectRequire('@libsql/client')
-        //       createClient = libsqlClientModule.createClient || libsqlClientModule.default?.createClient || libsqlClientModule.default
-        //       logger('[node/db/Db] Using @libsql/client from project node_modules via createRequire')
-        //     } catch (requireError: any) {
-        //       // If createRequire fails, try direct import
-        //       logger('[node/db/Db] createRequire failed, trying direct import:', requireError.message)
-        //       const libsqlClientModule = await import('@libsql/client')
-        //       createClient = libsqlClientModule.createClient
-        //       logger('[node/db/Db] Using @libsql/client from project node_modules via direct import')
-        //     }
-        //   } else {
-        //     // Fall back to regular import (from SDK's node_modules)
-        //     const libsqlClientModule = await import('@libsql/client')
-        //     createClient = libsqlClientModule.createClient
-        //     logger('[node/db/Db] Using @libsql/client from SDK node_modules')
-        //   }
-        // } catch (importError: any) {
-        //   logger('[node/db/Db] Error importing @libsql/client:', importError.message)
-        //   logger('[node/db/Db] projectDir:', projectDir)
-        //   logger('[node/db/Db] projectLibsqlClientPath:', projectLibsqlClientPath)
-        //   throw new Error(`Failed to import @libsql/client: ${importError.message}. Please install @libsql/client in your project.`)
-        // }
-        // // Convert file path to file: URL for libsql
-        // // If dbPath is already a file: URL, use it as is, otherwise convert it
-        // const dbUrl = dbPath.startsWith('file:') ? dbPath : `file:${path.resolve(dbPath)}`
-        // // Create libsql client instance
-        // const client = createClient({ url: dbUrl })
-        // // Create drizzle instance with the libsql client
-        // const {drizzle} = await import('drizzle-orm/libsql')
-        // this.db = drizzle(client, {
-        //   logger: true,
-        // })
-        // if (!this.db) {
-        //   throw new Error('Db not found')
-        // }
         return this.db;
     }
     static async connectToDb(pathToDir) {
@@ -16250,7 +16395,7 @@ const getTsImport = async (filePath) => {
 
 // Get the directory of this file to resolve relative paths
 // @ts-ignore - rollup plugin-typescript doesn't recognize import.meta with module: "preserve"
-const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-CXI4VF1H.js', document.baseURI).href)));
+const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cjs/index-B95Ng80C.js', document.baseURI).href)));
 path.dirname(__filename$1);
 const commandExists = (command) => {
     try {
@@ -16767,6 +16912,7 @@ exports.getItemData = getItemData;
 exports.getLatestSchemaVersion = getLatestSchemaVersion;
 exports.getModelId = getModelId;
 exports.getModelIdByFileId = getModelIdByFileId;
+exports.getOwnedAddressesFromDb = getOwnedAddressesFromDb;
 exports.getSchemaForItemProperty = getSchemaForItemProperty;
 exports.getSchemaUidForModel = getSchemaUidForModel;
 exports.getSchemaUidForSchemaDefinition = getSchemaUidForSchemaDefinition;
@@ -16801,4 +16947,4 @@ exports.versions = versions;
 exports.waitForEntityIdle = waitForEntityIdle;
 exports.withSeed = withSeed;
 exports.writeProcessMachine = writeProcessMachine;
-//# sourceMappingURL=index-CXI4VF1H.js.map
+//# sourceMappingURL=index-B95Ng80C.js.map