@seedprotocol/sdk 0.4.6 → 0.4.7

package/dist/{index-Dk73a7JE.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';
@@ -607,7 +607,7 @@ const createPropertyInstances = async (propertyFileIds) => {
         return;
     }
     try {
-        const mod = await import('./ModelProperty-Cpd9xiIM.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');
@@ -796,7 +796,7 @@ 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 _mod_0 = await import('./Schema-BZKBy5Tx.js');
+            const _mod_0 = await import('./Schema-SbwqmoMM.js');
             const _ns_0 = _mod_0.b;
             const schemaMod = _ns_0;
             const { Schema } = schemaMod;
@@ -1042,7 +1042,7 @@ const loadOrCreateModel = fromCallback(({ sendBack, input: { context } }) => {
         }
         // Mark schema as draft when a new model is created so saveNewVersion() can persist it
         try {
-            const _mod_1 = await import('./Schema-BZKBy5Tx.js');
+            const _mod_1 = await import('./Schema-SbwqmoMM.js');
             const _ns_1 = _mod_1.b;
             const schemaMod = _ns_1;
             const { Schema } = schemaMod;
@@ -1088,10 +1088,10 @@ const validateModel = fromCallback(({ sendBack, input: { context } }) => {
     const _validateModel = async () => {
         try {
             // Use dynamic imports to break circular dependencies
-            const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+            const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
             const { SchemaValidationService } = validationServiceMod;
             const validationService = new SchemaValidationService();
-            const _mod_2 = await import('./Schema-BZKBy5Tx.js');
+            const _mod_2 = await import('./Schema-SbwqmoMM.js');
             const _ns_2 = _mod_2.b;
             const schemaMod = _ns_2;
             const { Schema } = schemaMod;
@@ -1205,7 +1205,7 @@ const createModelProperties = fromCallback(({ sendBack, input }) => {
             return;
         }
         logger$q(`Creating ${Object.keys(propertyDefinitions).length} properties for model "${modelName}" (id: ${_dbId})`);
-        const mod = await import('./ModelProperty-Cpd9xiIM.js');
+        const mod = await import('./ModelProperty-D4zaeIOT.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$q('ModelProperty not available from dynamic import');
@@ -1310,7 +1310,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                 logger$p(structureMsg);
                 console.log(structureMsg); // Always log to console
                 // Use existing Model validation
-                const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+                const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate model structure
@@ -1329,7 +1329,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     if (entityInput.entityData.schemaName) {
                         try {
                             logger$p(`[validateEntity] Validating model against schema "${entityInput.entityData.schemaName}"`);
-                            const _mod_3 = await import('./Schema-BZKBy5Tx.js');
+                            const _mod_3 = await import('./Schema-SbwqmoMM.js');
                             const _ns_3 = _mod_3.b;
                             const schemaMod = _ns_3;
                             const { Schema } = schemaMod;
@@ -1367,7 +1367,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'modelProperty') {
                 // Use existing ModelProperty validation
-                const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+                const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 // Validate property structure
@@ -1382,7 +1382,7 @@ const validateEntity = fromPromise(async ({ input }) => {
                     // If schema name and model name provided, validate against schema
                     if (entityInput.entityData._schemaName && entityInput.entityData.modelName) {
                         try {
-                            const _mod_4 = await import('./Schema-BZKBy5Tx.js');
+                            const _mod_4 = await import('./Schema-SbwqmoMM.js');
                             const _ns_4 = _mod_4.b;
                             const schemaMod = _ns_4;
                             const { Schema } = schemaMod;
@@ -1413,7 +1413,7 @@ const validateEntity = fromPromise(async ({ input }) => {
             }
             else if (entityInput.entityType === 'schema') {
                 // Schema validation - use existing validation
-                const validationServiceMod = await import('./SchemaValidationService-F8No7BHp.js');
+                const validationServiceMod = await import('./SchemaValidationService-DHGIw4Nx.js');
                 const { SchemaValidationService } = validationServiceMod;
                 const validationService = new SchemaValidationService();
                 const schemaResult = validationService.validateSchema(entityInput.entityData);
@@ -1450,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'),
@@ -1944,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-Cpd9xiIM.js');
+        const mod = await import('./ModelProperty-D4zaeIOT.js');
         const ModelProperty = mod?.ModelProperty ?? mod?.default;
         if (!ModelProperty) {
             logger$o('ModelProperty not available from dynamic import');
@@ -2624,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);
         });
     }
@@ -2640,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
@@ -3109,14 +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,
@@ -3170,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-Cpd9xiIM.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);
@@ -3561,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-Cpd9xiIM.js').then(({ ModelProperty }) => {
+                                    import('./ModelProperty-D4zaeIOT.js').then(({ ModelProperty }) => {
                                         const createPromises = newPropertyIds.map(async (propertyFileId) => {
                                             try {
                                                 const property = await ModelProperty.createById(propertyFileId);
@@ -4527,13 +4579,15 @@ 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;
@@ -4541,20 +4595,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$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) {
@@ -4574,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');
@@ -4686,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',
@@ -4740,9 +4808,9 @@ const runPublish = fromCallback(({ sendBack, input: { context } }) => {
                 sendBack({ type: 'publishError', error: new Error(`Item not found for seedLocalId: ${seedLocalId}`) });
                 return;
             }
-            const getPublishUploadsMod = await import('./getPublishUploads-DhvcKD_9.js');
+            const getPublishUploadsMod = await import('./getPublishUploads-B0WArDfp.js');
             const { getPublishUploads } = getPublishUploadsMod;
-            const getPublishPayloadMod = await import('./getPublishPayload-CWiLI1yd.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BRgULCf3.js');
             const { getPublishPayload } = getPublishPayloadMod;
             await getPublishUploads(item);
             // For first iteration: no Arweave sign/upload - pass empty uploadedTransactions.
@@ -4915,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,
@@ -5278,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,
@@ -5308,6 +5400,7 @@ const getItemData = async ({ modelName, seedLocalId, seedUid, }) => {
     let itemData = {
         ...seedRow,
         ...versionRow,
+        schemaName,
     };
     const propertiesData = await getItemProperties({
         seedLocalId,
@@ -5331,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)));
     }
@@ -5828,7 +5937,7 @@ 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 schemaMod = await import('./index-LfXKx_PE.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyValue || !isRelation || populatedFromDb) {
             return;
@@ -6167,7 +6276,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     // to use dynamically imported ModelPropertyDataTypes
     const _hydrateFromDb = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-LfXKx_PE.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
         const { ModelPropertyDataTypes } = schemaMod;
         const appDb = BaseDb.getAppDb();
         const whereClauses = [];
@@ -6398,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 })
@@ -6430,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',
@@ -6641,7 +6772,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _analyzeInput = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-LfXKx_PE.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
         const { ModelPropertyDataTypes } = schemaMod;
         let propertyName = propertyNameRaw;
         if (!propertyName) {
@@ -6999,7 +7130,7 @@ const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
     }
     const _saveRelation = async () => {
         // Use dynamic import to break circular dependency
-        const schemaMod = await import('./index-LfXKx_PE.js');
+        const schemaMod = await import('./index-BnF3MRZ8.js');
         const { ModelPropertyDataTypes } = schemaMod;
         if (!propertyNameRaw) {
             throw new Error('propertyName is required');
@@ -7702,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
@@ -7798,7 +7955,7 @@ class ItemProperty {
                 return;
             }
             // Use dynamic import to break circular dependency
-            const schemaMod = await import('./index-LfXKx_PE.js');
+            const schemaMod = await import('./index-BnF3MRZ8.js');
             const { ModelPropertyDataTypes } = schemaMod;
             const { context } = snapshot;
             const { propertyRecordSchema } = context;
@@ -7912,7 +8069,7 @@ class ItemProperty {
             setupState.subscriptionSetUp = true;
             logger(`[ItemProperty._setupLiveQuerySubscription] Setting up liveQuery for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
             try {
-                const _mod_5 = await import('./index-DBy53qbb.js');
+                const _mod_5 = await import('./index-BIPPEMVY.js');
                 const _ns_5 = _mod_5.s;
                 const seedSchemaMod = _ns_5;
                 const { metadata } = seedSchemaMod;
@@ -8189,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;
@@ -8215,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) {
@@ -8352,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 });
@@ -8432,7 +8605,7 @@ class ItemProperty {
                 if (!propertyName || (!seedLocalId && !seedUid))
                     return;
                 if (db) {
-                    const _mod_6 = await import('./index-DBy53qbb.js');
+                    const _mod_6 = await import('./index-BIPPEMVY.js');
                     const _ns_6 = _mod_6.s;
                     const seedSchemaMod = _ns_6;
                     const { metadata } = seedSchemaMod;
@@ -8483,11 +8656,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,
@@ -8654,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;
@@ -8688,13 +8870,13 @@ class Item {
         };
         this.getPublishUploads = async () => {
             // Use dynamic import to break circular dependency
-            const getPublishUploadsMod = await import('./getPublishUploads-DhvcKD_9.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 getPublishPayloadMod = await import('./getPublishPayload-CWiLI1yd.js');
+            const getPublishPayloadMod = await import('./getPublishPayload-BRgULCf3.js');
             const { getPublishPayload } = getPublishPayloadMod;
             return await getPublishPayload(this, uploadedTransactions);
         };
@@ -9225,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({
@@ -9563,7 +9745,7 @@ class Item {
             setupState.subscriptionSetUp = true;
             logger(`[Item._setupLiveQuerySubscription] Setting up liveQuery for seedLocalId: ${seedLocalId}`);
             try {
-                const _mod_7 = await import('./index-DBy53qbb.js');
+                const _mod_7 = await import('./index-BIPPEMVY.js');
                 const _ns_7 = _mod_7.s;
                 const seedSchemaMod = _ns_7;
                 const { seeds, versions, metadata } = seedSchemaMod;
@@ -9844,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] : [];
@@ -9885,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 &&
@@ -10024,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,
@@ -10343,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();
@@ -10380,7 +10587,6 @@ const syncDbWithEasHandler = throttle(async (_) => {
     if (schemaUids.length === 0) {
         return;
     }
-    const addresses = await getAddressesFromDb();
     const itemSeeds = await getSeedsFromSchemaUids({
         schemaUids,
         addresses,
@@ -10482,21 +10688,21 @@ const platformClassesInit = fromCallback(({ sendBack, input: { context, event }
         let PathResolver;
         let EasClient;
         if (isBrowser()) {
-            FileManager = (await import('./FileManager-BohtoKYo.js')).FileManager;
-            Db = (await import('./Db-C9fppVRl.js')).Db;
-            QueryClient = (await import('./QueryClient-BUoz2Vb0.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-Caio37h1.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-CLZUWoX2.js')).PathResolver;
-            EasClient = (await import('./EasClient-DQGAIj-b.js')).EasClient;
+            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-d64CkqXy.js')).FileManager;
-            Db = (await import('./Db-DJAG-5Di.js')).Db;
-            QueryClient = (await import('./QueryClient-COQ_Rs4-.js')).QueryClient;
-            ArweaveClient = (await import('./ArweaveClient-DLKAaS3K.js')).ArweaveClient;
-            PathResolver = (await import('./PathResolver-D6M0rzKV.js')).PathResolver;
-            EasClient = (await import('./EasClient-T7Nx9185.js')).EasClient;
+            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.`);
@@ -10556,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,
             } });
@@ -10744,7 +10953,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)
@@ -10761,7 +10970,7 @@ const downloadAllFilesBinaryRequestHandler = async () => {
                 state === 'addModelsToDb' ||
                 state === 'idle';
         }, { timeout: 30000 });
-        addresses = await getAddressesFromDb();
+        addresses = await getAllAddressesFromDb();
     }
     if (!addresses || addresses.length === 0) {
         return;
@@ -11113,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) {
@@ -11133,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)
@@ -11147,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({
@@ -13226,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,
                             };
                         })
@@ -13306,6 +13520,8 @@ const clientInstance = {
                     isSaving: false,
                     endpoints: undefined,
                     addresses: undefined,
+                    ownedAddresses: undefined,
+                    watchedAddresses: undefined,
                     models: undefined,
                     arweaveDomain: undefined,
                     filesDir: undefined,
@@ -13360,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();
@@ -13572,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-Cpd9xiIM.js')
+const modelPropertyImportPromise = import('./ModelProperty-D4zaeIOT.js')
     .then(module => {
     ModelPropertyClass = module.ModelProperty;
     return ModelPropertyClass;
@@ -13589,7 +13813,7 @@ function getModelProperty() {
 }
 // Lazy import cache for Schema to avoid circular dependency
 let SchemaClass = null;
-const schemaImportPromise = (async () => { const _mod_8 = await import('./Schema-BZKBy5Tx.js'); return _mod_8.b; })()
+const schemaImportPromise = (async () => { const _mod_8 = await import('./Schema-SbwqmoMM.js'); return _mod_8.b; })()
     .then(module => {
     SchemaClass = module.Schema;
     return SchemaClass;
@@ -14105,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 {
@@ -14388,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.
@@ -15422,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-Dk73a7JE.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