@seedprotocol/sdk 0.4.1 → 0.4.3

package/dist/main.js

@@ -1,36 +1,2719 @@
 import 'reflect-metadata';
-import './Model/index.js';
-export { ModelPropertyDataTypes } from './helpers/property/index.js';
-export { getPropertySchema } from './helpers/property.js';
-import './Schema/validation.js';
-export { Item } from './Item/Item.js';
-export { ItemProperty } from './ItemProperty/ItemProperty.js';
-export { ModelProperty } from './ModelProperty/ModelProperty.js';
-export { Schema } from './Schema/Schema.js';
-export { Model } from './Model/Model.js';
-export { useCreateItem, useItem, useItems } from './browser/react/item.js';
-export { useItemProperties, useItemProperty } from './browser/react/itemProperty.js';
-import './browser/react/services.js';
-import './browser/react/db.js';
-export { useAllSchemaVersions, useCreateSchema, useSchema, useSchemas } from './browser/react/schema.js';
-export { useModelProperties, useModelProperty } from './browser/react/modelProperty.js';
-export { useDeleteItem } from './browser/react/trash.js';
-export { useModel, useModels } from './browser/react/model.js';
-import 'react';
-import './client/constants.js';
-export { ClientManager as client } from './client/ClientManager.js';
-import '@xstate/react';
-export { getArweaveUrlForTransaction } from './helpers/index.js';
-export { getItemPropertiesFromEas, getItemVersionsFromEas, getModelSchemasFromEas, getSchemaUidBySchemaName, getSeedsBySchemaName, getSeedsFromSchemaUids } from './eas.js';
-export { SeedModels } from './helpers/constants.js';
-export { getFeedItemsBySchemaName } from './feed.js';
-export { createSchema, getSchemaNameFromId, listCompleteSchemaFiles as listSchemas, readSchema } from './helpers/schema.js';
-export { deleteModelFromSchema, deletePropertyFromModel, renameModelProperty, updateModelProperties } from './helpers/updateSchema.js';
+import { ai as getClient, aj as ClientManagerState, p as BaseDb, X as seeds, ak as getVersionData, a0 as Item, al as createNewItem, C as metadata, a4 as ItemProperty, W as schemas, am as loadAllSchemasFromDb, q as models, G as modelSchemas, M as Model, r as properties, x as BaseEasClient, an as getSeedsBySchemaName, ao as GET_SEEDS, ap as getItemVersionsFromEas, aq as getItemPropertiesFromEas, z as BaseArweaveClient, ar as setSchemaUidForSchemaDefinition, as as parseEasRelationPropertyName } from './json-I3vJhXo8.js';
+export { s as FileManager, a as ModelPropertyDataTypes, aw as SeedModels, a6 as client, ay as createSchema, ax as getArweaveUrlForTransaction, at as getModelSchemasFromEas, aB as getSchemaNameFromId, au as getSchemaUidBySchemaName, av as getSeedsFromSchemaUids, a9 as importJsonSchema, aA as listSchemas, ab as readJsonImportFile, az as readSchema, ac as transformImportToSchemaFile } from './json-I3vJhXo8.js';
+import { g as getPropertySchema } from './property-Dy09KTxg.js';
+import { M as ModelProperty } from './ModelProperty-Cr3BmgkC.js';
+export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './ModelProperty-Cr3BmgkC.js';
+import { Schema } from './Schema-DeKabJ0T.js';
+import { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+import { orderBy, startCase } from 'lodash-es';
+import debug from 'debug';
+import { useSelector } from '@xstate/react';
+import { eq, or, isNotNull, isNull, and, gt, desc } from 'drizzle-orm';
+import 'pluralize';
 import 'js-yaml';
 import 'fs';
-import './helpers/db.js';
-export { importJsonSchema, readJsonImportFile, transformImportToSchemaFile } from './imports/json.js';
-export { seedVitePlugin } from './vite/index.js';
-export { BaseFileManager as FileManager } from './helpers/FileManager/BaseFileManager.js';
-export { BaseEasClient as EasClient } from './helpers/EasClient/BaseEasClient.js';
+import 'xstate';
+import 'rxjs';
+import 'drizzle-orm/casing';
+import '@sinclair/typebox';
+import 'arweave';
+import 'eventemitter3';
+import 'drizzle-orm/sqlite-core';
+import 'ethers';
+import 'nanoid';
+import 'nanoid-dictionary';
+import './SchemaValidationService-cTlURuDt.js';
+import '@sinclair/typebox/value';
+
+const useIsClientReady = () => {
+    const client = getClient();
+    const clientService = client.getService();
+    const isClientReady = useSelector(clientService, (snapshot) => {
+        return snapshot.value === ClientManagerState.IDLE;
+    });
+    // GlobalState removed - check ClientManager state directly
+    return isClientReady;
+};
+
+/**
+ * Hook to execute a reactive query that emits new results whenever the underlying data changes.
+ *
+ * Supports two usage patterns:
+ * 1. SQL tag function: useLiveQuery((sql) => sql`SELECT * FROM models`)
+ * 2. Drizzle query builder: useLiveQuery(db.select().from(models))
+ *
+ * @param query - SQL query function or Drizzle query builder, or null/undefined to disable the query
+ * @returns Array of query results, or undefined if not yet loaded
+ *
+ * @example
+ * ```typescript
+ * // Using SQL tag function
+ * const models = useLiveQuery<ModelRow>(
+ *   (sql) => sql`SELECT * FROM models WHERE schema_file_id = ${schemaId}`
+ * )
+ *
+ * // Using Drizzle query builder
+ * import { models } from '@/seedSchema'
+ * import { eq } from 'drizzle-orm'
+ *
+ * const appDb = BaseDb.getAppDb()
+ * const models = useLiveQuery<ModelRow>(
+ *   appDb.select().from(models).where(eq(models.schemaFileId, schemaId))
+ * )
+ * ```
+ */
+function useLiveQuery(query) {
+    const [data, setData] = useState(undefined);
+    const subscriptionRef = useRef(null);
+    const previousDataRef = useRef(undefined);
+    const isClientReady = useIsClientReady();
+    // Create Observable outside useEffect so it's stable and distinctUntilChanged can work
+    // Only recreate when query or isClientReady changes
+    const observable = useMemo(() => {
+        if (!isClientReady || !query) {
+            return null;
+        }
+        try {
+            return BaseDb.liveQuery(query);
+        }
+        catch (error) {
+            console.error('[useLiveQuery] Failed to create live query:', error);
+            return null;
+        }
+    }, [query, isClientReady]);
+    useEffect(() => {
+        // Cleanup previous subscription if it exists
+        if (subscriptionRef.current) {
+            subscriptionRef.current.unsubscribe();
+            subscriptionRef.current = null;
+        }
+        // Don't subscribe if observable is null
+        if (!observable) {
+            return;
+        }
+        const subscription = observable.subscribe({
+            next: (results) => {
+                const prev = previousDataRef.current;
+                const prevJson = prev ? JSON.stringify(prev) : 'undefined';
+                const currJson = results ? JSON.stringify(results) : 'undefined';
+                const isSameValue = prevJson === currJson;
+                // Defensive check: don't update state if values are the same
+                // This should be handled by distinctUntilChanged, but adding as safety
+                // (especially important for Drizzle query builders which may not work with distinctUntilChanged)
+                if (isSameValue && prev !== undefined) {
+                    return;
+                }
+                previousDataRef.current = results;
+                setData(results);
+            },
+            error: (err) => {
+                console.error('[useLiveQuery] Error:', err);
+                // Don't set data to undefined on error - keep last known good state
+                // This prevents UI flickering on transient errors
+            },
+        });
+        subscriptionRef.current = subscription;
+        // Cleanup on unmount or observable change
+        return () => {
+            if (subscriptionRef.current) {
+                subscriptionRef.current.unsubscribe();
+                subscriptionRef.current = null;
+            }
+        };
+    }, [observable]); // Only re-subscribe when observable changes
+    return data;
+}
+
+const logger$2 = debug('seedSdk:react:item');
+const useItem = ({ modelName, seedLocalId, seedUid }) => {
+    const [item, setItem] = useState();
+    const [isLoading, setIsLoading] = useState(!!(seedLocalId || seedUid));
+    const [error, setError] = useState(null);
+    const subscriptionRef = useRef(undefined);
+    const isClientReady = useIsClientReady();
+    const modelNameRef = useRef(modelName);
+    const seedLocalIdRef = useRef(seedLocalId);
+    const seedUidRef = useRef(seedUid);
+    // Determine if we should be loading based on parameters - use useMemo to stabilize
+    // Use refs to check current values to avoid dependency issues
+    const shouldLoad = useMemo(() => {
+        if (!isClientReady)
+            return false;
+        return !!(seedLocalIdRef.current || seedUidRef.current);
+    }, [isClientReady, seedLocalId, seedUid]);
+    const loadItem = useCallback(async () => {
+        // Check shouldLoad inside the function to avoid recreating the callback
+        const currentShouldLoad = !!(isClientReady && (seedLocalIdRef.current || seedUidRef.current));
+        if (!currentShouldLoad) {
+            setItem(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        try {
+            // Don't set isLoading here - let the subscription effect handle it
+            // This avoids race conditions where isLoading is set to true but then
+            // the subscription effect hasn't run yet to set it to false
+            setError(null);
+            const foundItem = await Item.find({
+                modelName: modelNameRef.current,
+                seedLocalId: seedLocalIdRef.current,
+                seedUid: seedUidRef.current,
+            });
+            if (!foundItem) {
+                logger$2('[useItem] [loadItem] no item found', modelNameRef.current, seedLocalIdRef.current);
+                setItem(undefined);
+                setIsLoading(false);
+                setError(null);
+                return;
+            }
+            // Item.find() now waits for idle by default, so the item should be ready
+            setItem(foundItem);
+            setIsLoading(false); // Item is ready since find() waited for idle
+            setError(null);
+        }
+        catch (error) {
+            logger$2('[useItem] Error loading item:', error);
+            setItem(undefined);
+            setIsLoading(false);
+            setError(error);
+        }
+    }, [isClientReady]);
+    useEffect(() => {
+        modelNameRef.current = modelName;
+        seedLocalIdRef.current = seedLocalId;
+        seedUidRef.current = seedUid;
+    }, [modelName, seedLocalId, seedUid]);
+    // Fetch/refetch when parameters change or client becomes ready
+    useEffect(() => {
+        // Only clear item if we don't have parameters to load
+        // Don't clear if shouldLoad is false but we have an item - it might just be a timing issue
+        if (!shouldLoad) {
+            // Only clear if we actually don't have parameters (not just client not ready)
+            if (!seedLocalId && !seedUid) {
+                setItem(undefined);
+                setIsLoading(false);
+                setError(null);
+            }
+            return;
+        }
+        loadItem();
+    }, [shouldLoad, loadItem, seedLocalId, seedUid]);
+    // Subscribe to service changes when item is available
+    useEffect(() => {
+        if (!item) {
+            // Clean up subscription if item is not available
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+            return;
+        }
+        // Clean up previous subscription
+        subscriptionRef.current?.unsubscribe();
+        // Subscribe to service changes
+        // Don't set isLoading here - it's already set correctly in loadItem
+        // Just subscribe to future state changes
+        const service = item.getService();
+        const subscription = service.subscribe((snapshot) => {
+            // Update loading state based on service state changes
+            if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
+                const isIdle = snapshot.value === 'idle';
+                setIsLoading(!isIdle);
+                // Clear error if service is in idle state
+                if (isIdle) {
+                    setError(null);
+                }
+                else if (snapshot.value === 'error') {
+                    // Set error if service is in error state
+                    setError(new Error('Item service error'));
+                }
+            }
+        });
+        subscriptionRef.current = subscription;
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [item]);
+    return {
+        item,
+        isLoading,
+        error,
+    };
+};
+const useItems = ({ modelName, deleted = false }) => {
+    const [items, setItems] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const isClientReady = useIsClientReady();
+    const subscriptionsRef = useRef(new Map());
+    const loadingItemsRef = useRef(new Set());
+    const previousSeedsTableDataRef = useRef(undefined);
+    const itemsRef = useRef([]); // Track items for comparison without triggering effects
+    // Watch the seeds table for changes
+    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
+    // IMPORTANT: This query must match the logic in getItemsData() to ensure seedsTableData
+    // only includes seeds that Item.all() will return (i.e., seeds with versionsCount > 0)
+    const db = isClientReady ? BaseDb.getAppDb() : null;
+    const seedsQuery = useMemo(() => {
+        if (!db)
+            return null;
+        const conditions = [];
+        if (modelName) {
+            conditions.push(eq(seeds.type, modelName.toLowerCase()));
+        }
+        if (deleted) {
+            conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
+        }
+        else {
+            conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
+        }
+        // Join with versionData and filter by versionsCount > 0 to match getItemsData() logic
+        // This ensures we only watch seeds that have at least one version
+        const versionData = getVersionData();
+        return db
+            .with(versionData)
+            .select({
+            localId: seeds.localId,
+            uid: seeds.uid,
+            type: seeds.type,
+            schemaUid: seeds.schemaUid,
+            createdAt: seeds.createdAt,
+            attestationCreatedAt: seeds.attestationCreatedAt,
+            _markedForDeletion: seeds._markedForDeletion,
+        })
+            .from(seeds)
+            .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+            .where(and(gt(versionData.versionsCount, 0), ...conditions))
+            .groupBy(seeds.localId);
+    }, [db, isClientReady, modelName, deleted]);
+    const seedsTableData = useLiveQuery(seedsQuery);
+    const fetchItems = useCallback(async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const allItems = await Item.all(modelName, deleted);
+            // Filter items into ready vs loading based on service state
+            const readyItems = [];
+            const loadingItemsList = [];
+            // Clear previous loading set
+            loadingItemsRef.current.clear();
+            for (const item of allItems) {
+                const snapshot = item.getService().getSnapshot();
+                const isIdle = snapshot.value === 'idle';
+                if (isIdle) {
+                    // Item is ready
+                    readyItems.push(item);
+                }
+                else {
+                    // Item is still loading - subscribe to state changes
+                    loadingItemsList.push(item);
+                    loadingItemsRef.current.add(item);
+                    // Clean up any existing subscription for this item
+                    const existingSub = subscriptionsRef.current.get(item);
+                    if (existingSub) {
+                        existingSub.unsubscribe();
+                    }
+                    // Subscribe to state changes
+                    const subscription = item.getService().subscribe((snapshot) => {
+                        if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
+                            const isIdle = snapshot.value === 'idle';
+                            if (isIdle) {
+                                // Item is now ready - update state
+                                setItems(prev => {
+                                    // Check if item is already in the list (by seedLocalId or seedUid)
+                                    const exists = prev.some(i => (i.seedLocalId && item.seedLocalId && i.seedLocalId === item.seedLocalId) ||
+                                        (i.seedUid && item.seedUid && i.seedUid === item.seedUid));
+                                    if (exists) {
+                                        return prev;
+                                    }
+                                    // Add the newly ready item
+                                    const updated = [...prev, item];
+                                    itemsRef.current = updated; // Update ref for comparison
+                                    return updated;
+                                });
+                                // Remove from loading set and clean up subscription
+                                loadingItemsRef.current.delete(item);
+                                subscription.unsubscribe();
+                                subscriptionsRef.current.delete(item);
+                                // Update loading state based on remaining loading items
+                                setIsLoading(loadingItemsRef.current.size > 0);
+                            }
+                            else if (snapshot.value === 'error') {
+                                // Item failed to load - clean up subscription
+                                loadingItemsRef.current.delete(item);
+                                subscription.unsubscribe();
+                                subscriptionsRef.current.delete(item);
+                                // Update loading state based on remaining loading items
+                                setIsLoading(loadingItemsRef.current.size > 0);
+                            }
+                        }
+                    });
+                    subscriptionsRef.current.set(item, subscription);
+                }
+            }
+            // Set initial ready items
+            setItems(readyItems);
+            itemsRef.current = readyItems; // Update ref for comparison
+            setError(null);
+            setIsLoading(loadingItemsList.length > 0); // Still loading if any items are loading
+        }
+        catch (error) {
+            setError(error);
+            setIsLoading(false);
+        }
+    }, [modelName, deleted]);
+    // Cleanup subscriptions for items that are no longer in the list
+    useEffect(() => {
+        const currentItemKeys = new Set();
+        for (const item of items) {
+            const key = item.seedLocalId || item.seedUid || '';
+            if (key) {
+                currentItemKeys.add(key);
+            }
+        }
+        // Clean up subscriptions for items that are no longer in the list
+        for (const [item, subscription] of subscriptionsRef.current.entries()) {
+            const key = item.seedLocalId || item.seedUid || '';
+            if (key && !currentItemKeys.has(key)) {
+                // Item is no longer in the list, clean up subscription
+                subscription.unsubscribe();
+                subscriptionsRef.current.delete(item);
+                loadingItemsRef.current.delete(item);
+            }
+        }
+        // Update loading state based on remaining loading items
+        if (loadingItemsRef.current.size === 0 && isLoading) {
+            setIsLoading(false);
+        }
+    }, [items, isLoading]);
+    // Fetch items on initial mount when client is ready
+    useEffect(() => {
+        if (!isClientReady) {
+            return;
+        }
+        // Initial fetch when client becomes ready
+        fetchItems();
+    }, [isClientReady, fetchItems]);
+    // Refetch items when table data actually changes (not just reference)
+    useEffect(() => {
+        if (!isClientReady || !seedsTableData) {
+            return;
+        }
+        // Check if seedsTableData actually changed by comparing with previous value
+        const prevData = previousSeedsTableDataRef.current;
+        const prevDataJson = prevData ? JSON.stringify(prevData.map(s => ({ localId: s.localId, uid: s.uid }))) : 'undefined';
+        const currDataJson = seedsTableData ? JSON.stringify(seedsTableData.map(s => ({ localId: s.localId, uid: s.uid }))) : 'undefined';
+        if (prevDataJson === currDataJson && prevData !== undefined) {
+            // Data hasn't actually changed, skip refetch
+            return;
+        }
+        // Update ref with current data
+        previousSeedsTableDataRef.current = seedsTableData;
+        // Extract identifying information from current items in state (using ref to avoid dependency)
+        const currentItemsSet = new Set();
+        for (const item of itemsRef.current) {
+            const key = item.seedLocalId || item.seedUid;
+            if (key) {
+                currentItemsSet.add(key);
+            }
+        }
+        // Extract identifying information from seedsTableData
+        const tableDataItemsSet = new Set();
+        for (const dbSeed of seedsTableData) {
+            const key = dbSeed.localId || dbSeed.uid;
+            if (key) {
+                tableDataItemsSet.add(key);
+            }
+        }
+        // Compare sets to detect changes
+        const setsAreEqual = currentItemsSet.size === tableDataItemsSet.size &&
+            [...currentItemsSet].every(id => tableDataItemsSet.has(id));
+        if (setsAreEqual) {
+            // Items in state match table data, skip refetch
+            return;
+        }
+        // Items have changed, fetch updated items
+        fetchItems();
+    }, [isClientReady, seedsTableData, fetchItems, modelName]);
+    // Cleanup all subscriptions on unmount
+    useEffect(() => {
+        return () => {
+            subscriptionsRef.current.forEach(sub => sub.unsubscribe());
+            subscriptionsRef.current.clear();
+            loadingItemsRef.current.clear();
+        };
+    }, []);
+    return {
+        items: orderBy(items, [
+            (item) => item.lastVersionPublishedAt ||
+                item.attestationCreatedAt ||
+                item.createdAt,
+        ], ['desc']),
+        isLoading,
+        error,
+    };
+};
+const useCreateItem = () => {
+    const [isCreatingItem, setIsCreatingItem] = useState(false);
+    const createItem = useCallback(async (modelName, itemData) => {
+        if (isCreatingItem) {
+            // TODO: should we setup a queue for this?
+            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
+            return;
+        }
+        setIsCreatingItem(true);
+        if (!itemData) {
+            itemData = {};
+        }
+        const { seedLocalId } = await createNewItem({ modelName, ...itemData });
+        await Item.find({ modelName, seedLocalId });
+        setIsCreatingItem(false);
+    }, [isCreatingItem]);
+    return {
+        createItem,
+        isCreatingItem,
+    };
+};
+
+const logger$1 = debug('seedSdk:react:property');
+const propertiesLogger = debug('seedSdk:react:itemProperties');
+function useItemProperty(arg1, arg2) {
+    const isClientReady = useIsClientReady();
+    const [property, setProperty] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const subscriptionRef = useRef(undefined);
+    const [, setVersion] = useState(0); // Version counter to force re-renders
+    // Determine which lookup mode we're in based on arguments
+    const lookupMode = useMemo(() => {
+        if (typeof arg1 === 'string' && arg2 !== undefined) {
+            // Two arguments: itemId, propertyName
+            return { type: 'itemId', itemId: arg1, propertyName: arg2 };
+        }
+        else if (typeof arg1 === 'object') {
+            // Object argument: { seedLocalId/seedUid, propertyName }
+            return {
+                type: 'identifiers',
+                seedLocalId: arg1.seedLocalId,
+                seedUid: arg1.seedUid,
+                propertyName: arg1.propertyName,
+            };
+        }
+        else {
+            return null;
+        }
+    }, [arg1, arg2]);
+    // Determine initial loading state
+    useMemo(() => {
+        if (!lookupMode)
+            return false;
+        if (lookupMode.type === 'itemId') {
+            return !!(lookupMode.itemId && lookupMode.propertyName);
+        }
+        else {
+            return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
+                lookupMode.propertyName);
+        }
+    }, [lookupMode]);
+    // Determine if we should be loading based on parameters
+    const shouldLoad = useMemo(() => {
+        if (!isClientReady)
+            return false;
+        if (!lookupMode)
+            return false;
+        if (lookupMode.type === 'itemId') {
+            return !!(lookupMode.itemId && lookupMode.propertyName);
+        }
+        else {
+            return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
+                lookupMode.propertyName);
+        }
+    }, [isClientReady, lookupMode]);
+    const updateItemProperty = useCallback(async () => {
+        if (!isClientReady || !lookupMode) {
+            setProperty(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        try {
+            setIsLoading(true);
+            setError(null);
+            let seedLocalId;
+            let seedUid;
+            if (lookupMode.type === 'itemId') {
+                // Resolve itemId to seedLocalId/seedUid
+                // For now, assume itemId is seedLocalId (could be enhanced to support seedUid)
+                seedLocalId = lookupMode.itemId;
+            }
+            else {
+                seedLocalId = lookupMode.seedLocalId;
+                seedUid = lookupMode.seedUid;
+            }
+            if (!seedLocalId && !seedUid) {
+                setProperty(undefined);
+                setIsLoading(false);
+                setError(null);
+                return;
+            }
+            const foundProperty = await ItemProperty.find({
+                propertyName: lookupMode.propertyName,
+                seedLocalId,
+                seedUid,
+            });
+            if (!foundProperty) {
+                logger$1(`[useItemProperty] [updateItemProperty] no property found for Item.${seedLocalId || seedUid}.${lookupMode.propertyName}`);
+                setProperty(undefined);
+                setIsLoading(false);
+                setError(null);
+                return;
+            }
+            // ItemProperty.find() now waits for idle by default, so the property should be ready
+            setProperty(foundProperty);
+            setIsLoading(false); // Property is ready since find() waited for idle
+            setError(null);
+        }
+        catch (error) {
+            logger$1('[useItemProperty] Error updating item property:', error);
+            setProperty(undefined);
+            setIsLoading(false);
+            setError(error);
+        }
+    }, [isClientReady, lookupMode]);
+    // Fetch/refetch when lookup parameters change or client becomes ready
+    useEffect(() => {
+        if (!shouldLoad) {
+            setProperty(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        updateItemProperty();
+    }, [shouldLoad, updateItemProperty]);
+    // Subscribe to service changes when property is available
+    useEffect(() => {
+        if (!property) {
+            // Clean up subscription if property is not available
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+            return;
+        }
+        // Clean up previous subscription
+        subscriptionRef.current?.unsubscribe();
+        // Subscribe to service changes
+        const subscription = property.getService().subscribe((snapshot) => {
+            // Update loading state based on service state
+            // Use type guard to check if snapshot has 'value' property
+            if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
+                const isIdle = snapshot.value === 'idle';
+                setIsLoading(!isIdle);
+                // Clear error if service is in idle state
+                if (isIdle) {
+                    setError(null);
+                }
+            }
+            // Force re-render by incrementing version counter
+            setVersion(prev => prev + 1);
+        });
+        subscriptionRef.current = subscription;
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [property]);
+    return {
+        property,
+        isLoading,
+        error,
+    };
+}
+function useItemProperties(arg1) {
+    const [properties, setProperties] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const isClientReady = useIsClientReady();
+    const subscriptionsRef = useRef(new Map());
+    const loadingPropertiesRef = useRef(new Set());
+    const previousTableDataRef = useRef(undefined);
+    // Determine which lookup mode we're in based on arguments
+    const lookupMode = useMemo(() => {
+        if (typeof arg1 === 'string') {
+            // String argument: itemId (assumed to be seedLocalId)
+            return { type: 'itemId', itemId: arg1 };
+        }
+        else if (typeof arg1 === 'object') {
+            // Object argument: { seedLocalId/seedUid }
+            return {
+                type: 'identifiers',
+                seedLocalId: arg1.seedLocalId,
+                seedUid: arg1.seedUid,
+            };
+        }
+        else {
+            return null;
+        }
+    }, [arg1]);
+    // Determine seedLocalId and seedUid for query
+    const seedLocalId = useMemo(() => {
+        if (!lookupMode)
+            return undefined;
+        if (lookupMode.type === 'itemId') {
+            return lookupMode.itemId;
+        }
+        else {
+            return lookupMode.seedLocalId;
+        }
+    }, [lookupMode]);
+    const seedUid = useMemo(() => {
+        if (!lookupMode || lookupMode.type === 'itemId')
+            return undefined;
+        return lookupMode.seedUid;
+    }, [lookupMode]);
+    // Watch the metadata table for changes
+    // Query metadata table directly and filter for latest records in JavaScript
+    // This is simpler and works better with useLiveQuery than CTEs
+    // Get db inside useMemo to avoid recreating query on each render
+    // Drizzle query builders are new objects each time, but useMemo will only recreate
+    // when dependencies change, which is what we want for reactive queries
+    const propertiesQuery = useMemo(() => {
+        if (!isClientReady || (!seedLocalId && !seedUid)) {
+            propertiesLogger('[useItemProperties] Query: returning null (not ready or no identifiers)');
+            return null;
+        }
+        const db = BaseDb.getAppDb();
+        if (!db) {
+            propertiesLogger('[useItemProperties] Query: returning null (no db)');
+            return null;
+        }
+        propertiesLogger(`[useItemProperties] Query: creating query for seedLocalId=${seedLocalId}, seedUid=${seedUid}`);
+        // Query metadata table directly - we'll filter for latest records in JavaScript
+        const query = seedUid
+            ? db
+                .select({
+                propertyName: metadata.propertyName,
+                propertyValue: metadata.propertyValue,
+                seedLocalId: metadata.seedLocalId,
+                seedUid: metadata.seedUid,
+                modelType: metadata.modelType,
+                schemaUid: metadata.schemaUid,
+                createdAt: metadata.createdAt,
+                attestationCreatedAt: metadata.attestationCreatedAt,
+            })
+                .from(metadata)
+                .where(and(eq(metadata.seedUid, seedUid), isNotNull(metadata.propertyName)))
+            : seedLocalId
+                ? db
+                    .select({
+                    propertyName: metadata.propertyName,
+                    propertyValue: metadata.propertyValue,
+                    seedLocalId: metadata.seedLocalId,
+                    seedUid: metadata.seedUid,
+                    modelType: metadata.modelType,
+                    schemaUid: metadata.schemaUid,
+                    createdAt: metadata.createdAt,
+                    attestationCreatedAt: metadata.attestationCreatedAt,
+                })
+                    .from(metadata)
+                    .where(and(eq(metadata.seedLocalId, seedLocalId), isNotNull(metadata.propertyName)))
+                : null;
+        propertiesLogger(`[useItemProperties] Query: created query object`, { queryType: seedUid ? 'seedUid' : 'seedLocalId' });
+        return query;
+    }, [isClientReady, seedLocalId, seedUid]);
+    const rawPropertiesTableData = useLiveQuery(propertiesQuery);
+    // Debug logging for rawPropertiesTableData
+    useEffect(() => {
+        if (rawPropertiesTableData !== undefined) {
+            propertiesLogger(`[useItemProperties] rawPropertiesTableData updated:`, {
+                length: rawPropertiesTableData?.length || 0,
+                isUndefined: rawPropertiesTableData === undefined,
+                isArray: Array.isArray(rawPropertiesTableData),
+                firstRecord: rawPropertiesTableData?.[0] || null,
+            });
+        }
+        else {
+            propertiesLogger('[useItemProperties] rawPropertiesTableData is undefined (query not executed yet)');
+        }
+    }, [rawPropertiesTableData]);
+    // Filter for latest records (one per propertyName) in JavaScript
+    const propertiesTableData = useMemo(() => {
+        if (!rawPropertiesTableData || rawPropertiesTableData.length === 0) {
+            return [];
+        }
+        // Group by propertyName and keep only the latest record for each
+        const latestByProperty = new Map();
+        for (const record of rawPropertiesTableData) {
+            if (!record.propertyName)
+                continue;
+            const existing = latestByProperty.get(record.propertyName);
+            if (!existing) {
+                latestByProperty.set(record.propertyName, record);
+            }
+            else {
+                // Compare timestamps to find the latest
+                const existingTime = existing.attestationCreatedAt || existing.createdAt || 0;
+                const currentTime = record.attestationCreatedAt || record.createdAt || 0;
+                if (currentTime > existingTime) {
+                    latestByProperty.set(record.propertyName, record);
+                }
+            }
+        }
+        return Array.from(latestByProperty.values());
+    }, [rawPropertiesTableData]);
+    const fetchItemProperties = useCallback(async () => {
+        if (!seedLocalId && !seedUid) {
+            propertiesLogger('[useItemProperties] fetchItemProperties: no identifiers, clearing properties');
+            setProperties([]);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        // Don't fetch if propertiesTableData is not available yet
+        if (propertiesTableData === undefined) {
+            propertiesLogger('[useItemProperties] fetchItemProperties: propertiesTableData is undefined, skipping');
+            return;
+        }
+        propertiesLogger(`[useItemProperties] fetchItemProperties: starting with ${propertiesTableData?.length || 0} records from table`);
+        try {
+            setIsLoading(true);
+            setError(null);
+            const db = BaseDb.getAppDb();
+            if (!db) {
+                propertiesLogger('[useItemProperties] fetchItemProperties: no db available');
+                setProperties([]);
+                setIsLoading(false);
+                return;
+            }
+            // Get modelName from metadata records or from seeds table
+            let modelName;
+            if (propertiesTableData && propertiesTableData.length > 0) {
+                const firstProperty = propertiesTableData[0];
+                if (firstProperty.modelType) {
+                    modelName = startCase(firstProperty.modelType);
+                }
+            }
+            // If we don't have modelName from metadata, try to get it from seeds table
+            if (!modelName) {
+                const seedRecords = await db
+                    .select({ type: seeds.type })
+                    .from(seeds)
+                    .where(seedUid ? eq(seeds.uid, seedUid) : eq(seeds.localId, seedLocalId))
+                    .limit(1);
+                if (seedRecords.length > 0 && seedRecords[0].type) {
+                    modelName = startCase(seedRecords[0].type);
+                }
+            }
+            // Get all ModelProperties for this Model
+            const modelProperties = [];
+            if (modelName) {
+                try {
+                    const { Model } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aS; });
+                    const model = await Model.getByNameAsync(modelName);
+                    if (model && model.properties) {
+                        for (const modelProperty of model.properties) {
+                            if (modelProperty.name) {
+                                modelProperties.push(modelProperty.name);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    propertiesLogger(`[useItemProperties] Error getting ModelProperties for ${modelName}:`, error);
+                    // Continue without ModelProperties - we'll still return properties from metadata
+                }
+            }
+            // Create a Set of property names that have metadata records
+            const propertiesWithMetadata = new Set();
+            if (propertiesTableData) {
+                for (const dbProperty of propertiesTableData) {
+                    if (dbProperty.propertyName) {
+                        propertiesWithMetadata.add(dbProperty.propertyName);
+                    }
+                }
+            }
+            const _itemProperties = [];
+            // First, create ItemProperty instances for properties that have metadata records
+            if (propertiesTableData && propertiesTableData.length > 0) {
+                for (const dbProperty of propertiesTableData) {
+                    if (!dbProperty.propertyName) {
+                        continue;
+                    }
+                    try {
+                        const itemProperty = await ItemProperty.find({
+                            propertyName: dbProperty.propertyName,
+                            seedLocalId: dbProperty.seedLocalId || undefined,
+                            seedUid: dbProperty.seedUid || undefined,
+                        });
+                        if (itemProperty) {
+                            _itemProperties.push(itemProperty);
+                        }
+                    }
+                    catch (error) {
+                        logger$1(`[useItemProperties] Error creating ItemProperty for ${dbProperty.propertyName}:`, error);
+                        // Continue with other properties even if one fails
+                    }
+                }
+            }
+            // Then, create ItemProperty instances for ModelProperties that don't have metadata records
+            if (modelName && modelProperties.length > 0) {
+                const resolvedSeedLocalId = propertiesTableData && propertiesTableData.length > 0
+                    ? propertiesTableData[0].seedLocalId || seedLocalId
+                    : seedLocalId;
+                const resolvedSeedUid = propertiesTableData && propertiesTableData.length > 0
+                    ? propertiesTableData[0].seedUid || seedUid
+                    : seedUid;
+                for (const propertyName of modelProperties) {
+                    // Skip if we already have a metadata record for this property
+                    if (propertiesWithMetadata.has(propertyName)) {
+                        continue;
+                    }
+                    try {
+                        // Create ItemProperty with empty value for properties without metadata records
+                        const itemProperty = ItemProperty.create({
+                            propertyName,
+                            modelName,
+                            seedLocalId: resolvedSeedLocalId || undefined,
+                            seedUid: resolvedSeedUid || undefined,
+                            propertyValue: null,
+                        });
+                        if (itemProperty) {
+                            _itemProperties.push(itemProperty);
+                        }
+                    }
+                    catch (error) {
+                        logger$1(`[useItemProperties] Error creating ItemProperty for missing property ${propertyName}:`, error);
+                        // Continue with other properties even if one fails
+                    }
+                }
+            }
+            // Also add system properties like 'createdAt' if they don't exist
+            // Get createdAt from seeds table
+            if (seedLocalId || seedUid) {
+                const seedRecords = await db
+                    .select({ createdAt: seeds.createdAt })
+                    .from(seeds)
+                    .where(seedUid ? eq(seeds.uid, seedUid) : eq(seeds.localId, seedLocalId))
+                    .limit(1);
+                if (seedRecords.length > 0 && seedRecords[0].createdAt) {
+                    const createdAtPropertyName = 'createdAt';
+                    const hasCreatedAtProperty = _itemProperties.some(p => p.propertyName === createdAtPropertyName);
+                    if (!hasCreatedAtProperty && modelName) {
+                        try {
+                            const resolvedSeedLocalId = propertiesTableData && propertiesTableData.length > 0
+                                ? propertiesTableData[0].seedLocalId || seedLocalId
+                                : seedLocalId;
+                            const resolvedSeedUid = propertiesTableData && propertiesTableData.length > 0
+                                ? propertiesTableData[0].seedUid || seedUid
+                                : seedUid;
+                            const createdAtProperty = ItemProperty.create({
+                                propertyName: createdAtPropertyName,
+                                modelName,
+                                seedLocalId: resolvedSeedLocalId || undefined,
+                                seedUid: resolvedSeedUid || undefined,
+                                propertyValue: seedRecords[0].createdAt.toString(),
+                            });
+                            if (createdAtProperty) {
+                                _itemProperties.push(createdAtProperty);
+                            }
+                        }
+                        catch (error) {
+                            logger$1(`[useItemProperties] Error creating createdAt ItemProperty:`, error);
+                        }
+                    }
+                }
+            }
+            // Filter out properties that are ready (idle state) vs still loading
+            const readyProperties = [];
+            const loadingPropertiesList = [];
+            // Clear previous loading set
+            loadingPropertiesRef.current.clear();
+            for (const property of _itemProperties) {
+                const snapshot = property.getService().getSnapshot();
+                // Use type guard to check if snapshot has 'value' property
+                const isIdle = snapshot && typeof snapshot === 'object' && 'value' in snapshot && snapshot.value === 'idle';
+                if (isIdle) {
+                    // Property is ready
+                    readyProperties.push(property);
+                }
+                else {
+                    // Property is still loading - subscribe to state changes
+                    loadingPropertiesList.push(property);
+                    loadingPropertiesRef.current.add(property);
+                    // Clean up any existing subscription for this property
+                    const existingSub = subscriptionsRef.current.get(property);
+                    if (existingSub) {
+                        existingSub.unsubscribe();
+                    }
+                    // Subscribe to state changes
+                    const subscription = property.getService().subscribe((snapshot) => {
+                        // Use type guard to check if snapshot has 'value' property
+                        if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
+                            const isIdle = snapshot.value === 'idle';
+                            if (isIdle) {
+                                // Property is now ready - update state
+                                setProperties(prev => {
+                                    // Check if property is already in the list (by propertyName and seedLocalId/seedUid)
+                                    const exists = prev.some(p => p.propertyName === property.propertyName &&
+                                        (p.seedLocalId === property.seedLocalId || p.seedUid === property.seedUid));
+                                    if (exists) {
+                                        return prev;
+                                    }
+                                    // Add the newly ready property
+                                    return [...prev, property];
+                                });
+                                // Remove from loading set and clean up subscription
+                                loadingPropertiesRef.current.delete(property);
+                                subscription.unsubscribe();
+                                subscriptionsRef.current.delete(property);
+                                // Update loading state based on remaining loading properties
+                                setIsLoading(loadingPropertiesRef.current.size > 0);
+                            }
+                            else if (snapshot.value === 'error') {
+                                // Property failed to load - clean up subscription
+                                loadingPropertiesRef.current.delete(property);
+                                subscription.unsubscribe();
+                                subscriptionsRef.current.delete(property);
+                                // Update loading state based on remaining loading properties
+                                setIsLoading(loadingPropertiesRef.current.size > 0);
+                            }
+                        }
+                    });
+                    subscriptionsRef.current.set(property, subscription);
+                }
+            }
+            // Set initial ready properties
+            setProperties(readyProperties);
+            setError(null);
+            setIsLoading(loadingPropertiesList.length > 0); // Still loading if any properties are loading
+        }
+        catch (error) {
+            setError(error);
+            setIsLoading(false);
+        }
+    }, [seedLocalId, seedUid, propertiesTableData]);
+    // Reset previous table data ref when identifiers change
+    useEffect(() => {
+        previousTableDataRef.current = undefined;
+    }, [seedLocalId, seedUid]);
+    // Fetch item properties when dbModelId becomes available
+    useEffect(() => {
+        if (!isClientReady) {
+            return;
+        }
+        if (!seedLocalId && !seedUid) {
+            setProperties([]);
+            setIsLoading(false);
+            setError(null);
+            previousTableDataRef.current = undefined;
+            return;
+        }
+        // Wait for propertiesTableData to be available before initial fetch
+        // (it may be undefined initially while the query is starting)
+        if (propertiesTableData === undefined) {
+            return;
+        }
+        // Initial fetch when client is ready and propertiesTableData is available
+        fetchItemProperties();
+    }, [isClientReady, seedLocalId, seedUid, fetchItemProperties, propertiesTableData]);
+    // Refetch item properties when table data actually changes (not just reference)
+    useEffect(() => {
+        if (!isClientReady || (!seedLocalId && !seedUid)) {
+            return;
+        }
+        // If propertiesTableData is undefined, the query hasn't started yet - wait for it
+        if (propertiesTableData === undefined) {
+            return;
+        }
+        // Create a stable string representation of the table data for comparison
+        const tableDataString = JSON.stringify(propertiesTableData.map(p => ({
+            propertyName: p.propertyName,
+            seedLocalId: p.seedLocalId,
+            seedUid: p.seedUid,
+        })).sort((a, b) => (a.propertyName || '').localeCompare(b.propertyName || '')));
+        // Skip if table data hasn't actually changed
+        if (previousTableDataRef.current === tableDataString) {
+            return;
+        }
+        previousTableDataRef.current = tableDataString;
+        // Extract identifying information from current properties in state
+        const currentPropertiesSet = new Set();
+        for (const prop of properties) {
+            const key = `${prop.propertyName}:${prop.seedLocalId || prop.seedUid}`;
+            currentPropertiesSet.add(key);
+        }
+        // Extract identifying information from propertiesTableData
+        const tableDataPropertiesSet = new Set();
+        for (const dbProperty of propertiesTableData) {
+            if (dbProperty.propertyName) {
+                const key = `${dbProperty.propertyName}:${dbProperty.seedLocalId || dbProperty.seedUid}`;
+                tableDataPropertiesSet.add(key);
+            }
+        }
+        // Compare sets to detect changes
+        // If tableDataPropertiesSet is empty but we have properties, or vice versa, that's a change
+        // If both are empty, skip (no data yet) - UNLESS this is the first time we're seeing empty data
+        // If both have data and match, skip
+        const setsAreEqual = currentPropertiesSet.size === tableDataPropertiesSet.size &&
+            currentPropertiesSet.size > 0 &&
+            [...currentPropertiesSet].every(id => tableDataPropertiesSet.has(id));
+        if (setsAreEqual) {
+            // Properties in state match table data, skip refetch
+            return;
+        }
+        // Always refetch if table data has properties (even if we don't have any yet)
+        // This handles the case where propertiesTableData changes from empty to having data
+        if (tableDataPropertiesSet.size > 0) {
+            // Properties have changed or data has arrived, fetch updated properties
+            fetchItemProperties();
+            return;
+        }
+        // If table data is empty but we have properties, that's also a change (properties were removed)
+        if (currentPropertiesSet.size > 0 && tableDataPropertiesSet.size === 0) {
+            fetchItemProperties();
+            return;
+        }
+        // If both are empty, we've already tried to fetch (in the first useEffect)
+        // and got empty results, so skip refetching until data arrives
+        // (the change detection above will handle when data arrives)
+    }, [isClientReady, propertiesTableData, properties, fetchItemProperties, seedLocalId, seedUid]);
+    // Cleanup subscriptions for properties that are no longer in the list
+    useEffect(() => {
+        const currentPropertyKeys = new Set();
+        for (const prop of properties) {
+            const key = `${prop.propertyName}:${prop.seedLocalId || prop.seedUid}`;
+            currentPropertyKeys.add(key);
+        }
+        // Clean up subscriptions for properties that are no longer in the list
+        for (const [property, subscription] of subscriptionsRef.current.entries()) {
+            const key = `${property.propertyName}:${property.seedLocalId || property.seedUid}`;
+            if (!currentPropertyKeys.has(key)) {
+                // Property is no longer in the list, clean up subscription
+                subscription.unsubscribe();
+                subscriptionsRef.current.delete(property);
+                loadingPropertiesRef.current.delete(property);
+            }
+        }
+        // Update loading state based on remaining loading properties
+        if (loadingPropertiesRef.current.size === 0 && isLoading) {
+            setIsLoading(false);
+        }
+    }, [properties, isLoading]);
+    // Cleanup all subscriptions on unmount
+    useEffect(() => {
+        return () => {
+            subscriptionsRef.current.forEach(sub => sub.unsubscribe());
+            subscriptionsRef.current.clear();
+            loadingPropertiesRef.current.clear();
+        };
+    }, []);
+    return {
+        properties,
+        isLoading,
+        error,
+    };
+}
+
+debug('seedSdk:react:services');
+
+debug('seedSdk:react:db');
+
+const logger = debug('seedSdk:react:schema');
+/**
+ * Hook to get a Schema class instance (with setters) that is reactive
+ * This allows you to edit schema properties directly like: schema.name = 'New name'
+ * The schema instance uses a Proxy to ensure React re-renders when properties change
+ * @param schemaIdentifier - The name of the schema or the schema file ID
+ *   - If a name is provided, retrieves the latest version with that name
+ *   - If an ID is provided, retrieves the specific schema by ID
+ * @returns Object with schema instance
+ */
+const useSchema = (schemaIdentifier) => {
+    const [schema, setSchema] = useState(null);
+    const [isLoading, setIsLoading] = useState(schemaIdentifier ? true : false);
+    const [error, setError] = useState(null);
+    const subscriptionRef = useRef(null);
+    const isClientReady = useIsClientReady();
+    const loadSchema = useCallback((identifier) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const schemaInstance = Schema.create(identifier);
+            setSchema(schemaInstance);
+            const service = schemaInstance.getService();
+            const initialSnapshot = service.getSnapshot();
+            // Set initial loading state based on whether status is 'idle'
+            const isIdle = initialSnapshot.value === 'idle';
+            setIsLoading(!isIdle);
+            if (isIdle) {
+                setError(null);
+            }
+            // Subscribe to all status changes and update isLoading based on whether status is 'idle'
+            subscriptionRef.current = service.subscribe((snapshot) => {
+                const isIdle = snapshot.value === 'idle';
+                setIsLoading(!isIdle);
+                if (isIdle) {
+                    setError(null);
+                }
+            });
+        }
+        catch (error) {
+            logger('[useSchema] Error creating schema:', error);
+            setError(error);
+            setSchema(null);
+            setIsLoading(false);
+            return null;
+        }
+    }, []);
+    useEffect(() => {
+        // Clean up previous subscription before starting a new load
+        if (subscriptionRef.current) {
+            subscriptionRef.current.unsubscribe();
+            subscriptionRef.current = null;
+        }
+        if (!isClientReady) {
+            setSchema(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!schemaIdentifier) {
+            setSchema(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        loadSchema(schemaIdentifier);
+        // Cleanup function to unsubscribe when effect re-runs or component unmounts
+        return () => {
+            if (subscriptionRef.current) {
+                subscriptionRef.current.unsubscribe();
+                subscriptionRef.current = null;
+            }
+        };
+    }, [schemaIdentifier, isClientReady, loadSchema]);
+    return {
+        schema,
+        isLoading,
+        error,
+    };
+};
+const useSchemas = () => {
+    const [schemas$1, setSchemas] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const isClientReady = useIsClientReady();
+    const subscriptionsRef = useRef(new Map());
+    const loadingSchemasRef = useRef(new Set());
+    const previousSchemasTableDataRef = useRef(undefined);
+    const schemasRef = useRef([]); // Track schemas for comparison without triggering effects
+    // Watch the schemas table for changes
+    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
+    const db = isClientReady ? BaseDb.getAppDb() : null;
+    const schemasQuery = useMemo(() => {
+        if (!db)
+            return null;
+        return db.select().from(schemas).orderBy(schemas.name, desc(schemas.version));
+    }, [db, isClientReady]);
+    const schemasTableData = useLiveQuery(schemasQuery);
+    const fetchSchemas = useCallback(async () => {
+        try {
+            setIsLoading(true);
+            const timestamp = Date.now();
+            // Also check what's in the database directly before calling Schema.all()
+            const db = BaseDb.getAppDb();
+            if (db) {
+                const directCheck = await db.select().from(schemas).orderBy(schemas.name, desc(schemas.version));
+            }
+            const allSchemas = await Schema.all();
+            // Filter out schemas without an id and subscribe to state changes
+            const readySchemas = [];
+            const loadingSchemasList = [];
+            // Clear previous loading set
+            loadingSchemasRef.current.clear();
+            for (const schema of allSchemas) {
+                const snapshot = schema.getService().getSnapshot();
+                const hasId = !!schema.id;
+                const isIdle = snapshot.value === 'idle';
+                if (hasId && isIdle) {
+                    // Schema is ready
+                    readySchemas.push(schema);
+                }
+                else {
+                    // Schema is still loading - subscribe to state changes
+                    loadingSchemasList.push(schema);
+                    loadingSchemasRef.current.add(schema);
+                    // Clean up any existing subscription for this schema
+                    const existingSub = subscriptionsRef.current.get(schema);
+                    if (existingSub) {
+                        existingSub.unsubscribe();
+                    }
+                    // Subscribe to state changes
+                    const subscription = schema.getService().subscribe((snapshot) => {
+                        const hasId = !!schema.id;
+                        const isIdle = snapshot.value === 'idle';
+                        if (hasId && isIdle) {
+                            // Schema is now ready - update state
+                            setSchemas(prev => {
+                                // Check if schema is already in the list (by id)
+                                if (schema.id && prev.some(s => s.id === schema.id)) {
+                                    return prev;
+                                }
+                                // Add the newly ready schema
+                                const updated = [...prev, schema].sort((a, b) => {
+                                    // Sort by name for consistency
+                                    const nameA = a.metadata?.name || '';
+                                    const nameB = b.metadata?.name || '';
+                                    return nameA.localeCompare(nameB);
+                                });
+                                schemasRef.current = updated; // Update ref for comparison
+                                return updated;
+                            });
+                            // Remove from loading set and clean up subscription
+                            loadingSchemasRef.current.delete(schema);
+                            subscription.unsubscribe();
+                            subscriptionsRef.current.delete(schema);
+                            // Update loading state based on remaining loading schemas
+                            setIsLoading(loadingSchemasRef.current.size > 0);
+                        }
+                        else if (snapshot.value === 'error') {
+                            // Schema failed to load - clean up subscription
+                            loadingSchemasRef.current.delete(schema);
+                            subscription.unsubscribe();
+                            subscriptionsRef.current.delete(schema);
+                            // Update loading state based on remaining loading schemas
+                            setIsLoading(loadingSchemasRef.current.size > 0);
+                        }
+                    });
+                    subscriptionsRef.current.set(schema, subscription);
+                }
+            }
+            // Set initial ready schemas
+            setSchemas(readySchemas);
+            schemasRef.current = readySchemas; // Update ref for comparison
+            setError(null);
+            setIsLoading(loadingSchemasList.length > 0); // Still loading if any schemas are loading
+        }
+        catch (error) {
+            setError(error);
+            setIsLoading(false);
+        }
+    }, []); // Remove schemasTableData dependency - we'll call fetchSchemas explicitly when table data changes
+    // Cleanup subscriptions for schemas that are no longer in the list
+    useEffect(() => {
+        const currentSchemaIds = new Set(schemas$1.map(s => s.id).filter(Boolean));
+        // Clean up subscriptions for schemas that are no longer in the list
+        for (const [schema, subscription] of subscriptionsRef.current.entries()) {
+            if (schema.id && !currentSchemaIds.has(schema.id)) {
+                // Schema is no longer in the list, clean up subscription
+                subscription.unsubscribe();
+                subscriptionsRef.current.delete(schema);
+                loadingSchemasRef.current.delete(schema);
+            }
+        }
+        // Update loading state based on remaining loading schemas
+        if (loadingSchemasRef.current.size === 0 && isLoading) {
+            setIsLoading(false);
+        }
+    }, [schemas$1, isLoading]);
+    // Fetch schemas on initial mount when client is ready
+    useEffect(() => {
+        if (!isClientReady) {
+            return;
+        }
+        // Initial fetch when client becomes ready
+        fetchSchemas();
+    }, [isClientReady, fetchSchemas]);
+    // Refetch schemas when table data actually changes (not just reference)
+    useEffect(() => {
+        if (!isClientReady || !schemasTableData) {
+            return;
+        }
+        // Check if schemasTableData actually changed by comparing with previous value
+        const prevData = previousSchemasTableDataRef.current;
+        const prevDataJson = prevData ? JSON.stringify(prevData) : 'undefined';
+        const currDataJson = schemasTableData ? JSON.stringify(schemasTableData) : 'undefined';
+        if (prevDataJson === currDataJson && prevData !== undefined) {
+            // Data hasn't actually changed, skip refetch
+            return;
+        }
+        // Update ref with current data
+        previousSchemasTableDataRef.current = schemasTableData;
+        // Extract identifying information from current schemas in state (using ref to avoid dependency)
+        // Use schemaFileId if available, otherwise fall back to name+version
+        const currentSchemasSet = new Set();
+        for (const schema of schemasRef.current) {
+            const schemaFileId = schema.id || schema.schemaFileId;
+            if (schemaFileId) {
+                currentSchemasSet.add(schemaFileId);
+            }
+            else {
+                // Fallback to name+version if schemaFileId not available
+                const name = schema.metadata?.name;
+                const version = schema.version;
+                if (name && version !== undefined) {
+                    currentSchemasSet.add(`${name}:${version}`);
+                }
+            }
+        }
+        // Extract identifying information from schemasTableData
+        const tableDataSchemasSet = new Set();
+        for (const dbSchema of schemasTableData) {
+            // Skip internal Seed Protocol schema for comparison (it's filtered out by Schema.all())
+            if (dbSchema.name === 'Seed Protocol') {
+                continue;
+            }
+            if (dbSchema.schemaFileId) {
+                tableDataSchemasSet.add(dbSchema.schemaFileId);
+            }
+            else {
+                // Fallback to name+version if schemaFileId not available
+                if (dbSchema.name && dbSchema.version !== undefined) {
+                    tableDataSchemasSet.add(`${dbSchema.name}:${dbSchema.version}`);
+                }
+            }
+        }
+        // Compare sets to detect changes
+        const setsAreEqual = currentSchemasSet.size === tableDataSchemasSet.size &&
+            [...currentSchemasSet].every(id => tableDataSchemasSet.has(id));
+        if (setsAreEqual) {
+            // Schemas in state match table data, skip refetch
+            return;
+        }
+        // Schemas have changed, fetch updated schemas
+        fetchSchemas();
+    }, [isClientReady, schemasTableData, fetchSchemas]); // Removed 'schemas' from dependencies to break the loop
+    // Cleanup all subscriptions on unmount
+    useEffect(() => {
+        return () => {
+            subscriptionsRef.current.forEach(sub => sub.unsubscribe());
+            subscriptionsRef.current.clear();
+            loadingSchemasRef.current.clear();
+        };
+    }, []);
+    return {
+        schemas: schemas$1,
+        isLoading,
+        error,
+    };
+};
+const useCreateSchema = () => {
+    const errorRef = useRef(null);
+    const subscriptionRef = useRef(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const createSchema = useCallback((schemaName) => {
+        setIsLoading(true);
+        const schema = Schema.create(schemaName);
+        const subscription = schema.getService().subscribe((snapshot) => {
+            if (snapshot.value === 'error') {
+                errorRef.current = new Error('Failed to create schema');
+            }
+            if (snapshot.value === 'idle') {
+                setIsLoading(false);
+            }
+        });
+        subscriptionRef.current = subscription;
+        return schema;
+    }, [setIsLoading]);
+    useEffect(() => {
+        setError(errorRef.current);
+    }, [errorRef.current]);
+    return {
+        createSchema,
+        isLoading,
+        error,
+    };
+};
+const useAllSchemaVersions = () => {
+    const [schemaInstances, setSchemaInstances] = useState();
+    const schemaInstancesRef = useRef(new Map());
+    const isClientReady = useIsClientReady();
+    const fetchSchemas = useCallback(async () => {
+        if (!isClientReady) {
+            return;
+        }
+        try {
+            // Use DB-first approach: load all schemas from database
+            // This will also import any missing schemas from files
+            const allSchemasData = await loadAllSchemasFromDb();
+            // Extract unique schema names
+            const schemaNames = new Set();
+            for (const schemaData of allSchemasData) {
+                const schemaName = schemaData.schema.metadata?.name;
+                if (schemaName) {
+                    schemaNames.add(schemaName);
+                }
+            }
+            // Create/update Schema instances
+            const currentInstances = new Map();
+            for (const schemaName of schemaNames) {
+                // Reuse existing instance if it exists
+                if (schemaInstancesRef.current.has(schemaName)) {
+                    const existingInstance = schemaInstancesRef.current.get(schemaName);
+                    currentInstances.set(schemaName, existingInstance);
+                }
+                else {
+                    // Create new instance
+                    const schema = Schema.create(schemaName);
+                    currentInstances.set(schemaName, schema);
+                }
+            }
+            // Cleanup instances that are no longer needed
+            for (const [name, instance] of schemaInstancesRef.current.entries()) {
+                if (!schemaNames.has(name)) {
+                    instance.unload();
+                }
+            }
+            // Update ref and state
+            schemaInstancesRef.current = currentInstances;
+            setSchemaInstances(Array.from(currentInstances.values()));
+        }
+        catch (error) {
+            logger('Error fetching all schema versions from database:', error);
+            setSchemaInstances(null);
+        }
+    }, [isClientReady]);
+    useEffect(() => {
+        if (!isClientReady) {
+            return;
+        }
+        fetchSchemas();
+    }, [isClientReady, fetchSchemas]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            schemaInstancesRef.current.forEach((instance) => {
+                instance.unload();
+            });
+            schemaInstancesRef.current.clear();
+        };
+    }, []);
+    return schemaInstances;
+};
+
+/**
+ * Hook to get all Model instances for a specific schema
+ * Uses useLiveQuery to watch for changes in the models table and automatically
+ * updates the returned Model instances when changes occur.
+ * @param schemaId - The schema ID (schema file ID) or schema name to get models from
+ * @returns Array of Model instances belonging to the schema
+ */
+const useModels = (schemaId) => {
+    const [models$1, setModels] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const isClientReady = useIsClientReady();
+    // Watch the models table for changes via model_schemas join table
+    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
+    const db = isClientReady ? BaseDb.getAppDb() : null;
+    const modelsQuery = useMemo(() => {
+        if (!db || !schemaId)
+            return null;
+        return db
+            .select({
+            modelFileId: models.schemaFileId,
+            modelName: models.name,
+        })
+            .from(schemas)
+            .innerJoin(modelSchemas, eq(schemas.id, modelSchemas.schemaId))
+            .innerJoin(models, eq(modelSchemas.modelId, models.id))
+            .where(or(eq(schemas.schemaFileId, schemaId), eq(schemas.name, schemaId)));
+    }, [db, isClientReady, schemaId]);
+    const modelsTableData = useLiveQuery(modelsQuery);
+    const fetchModels = useCallback(async () => {
+        if (!schemaId) {
+            setModels([]);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        try {
+            setIsLoading(true);
+            const timestamp = Date.now();
+            console.log(`[useModels.fetchModels] [${timestamp}] Starting fetch, modelsTableData count:`, modelsTableData?.length, 'models:', modelsTableData?.map(m => m.modelName));
+            // Use Model.createBySchemaId to get Model instances (handles caching)
+            const modelInstances = await Model.createBySchemaId(schemaId);
+            console.log(`[useModels.fetchModels] [${timestamp}] Model.createBySchemaId() returned:`, modelInstances.length, 'models:', modelInstances.map((m) => m.modelName));
+            setModels(prev => {
+                // Check if anything actually changed
+                if (prev.length !== modelInstances.length) {
+                    console.log('[useModels] Length changed:', prev.length, '->', modelInstances.length);
+                    return modelInstances;
+                }
+                // Compare by modelFileId (schemaFileId) or name
+                const hasChanged = modelInstances.some((model, i) => !prev[i] ||
+                    model.id !== prev[i].id ||
+                    model.modelName !== prev[i].modelName);
+                if (hasChanged) {
+                    console.log('[useModels] Models changed (by ID or name)');
+                }
+                else {
+                    console.log('[useModels] No changes detected');
+                }
+                return hasChanged ? modelInstances : prev;
+            });
+            setError(null);
+            setIsLoading(false);
+        }
+        catch (error) {
+            setError(error);
+            setIsLoading(false);
+        }
+    }, [schemaId]);
+    // Fetch models on initial mount when client is ready
+    useEffect(() => {
+        if (!isClientReady) {
+            return;
+        }
+        // Initial fetch when client becomes ready
+        fetchModels();
+    }, [isClientReady, fetchModels]);
+    // Refetch models when table data actually changes (not just reference)
+    useEffect(() => {
+        if (!isClientReady || !modelsTableData || !schemaId) {
+            return;
+        }
+        // Extract identifying information from current models in state
+        // Use modelFileId (schemaFileId) if available, otherwise fall back to name
+        const currentModelsSet = new Set();
+        for (const model of models$1) {
+            const modelFileId = model.id || model.modelFileId;
+            if (modelFileId) {
+                currentModelsSet.add(modelFileId);
+            }
+            else {
+                // Fallback to name if modelFileId not available
+                const name = model.modelName;
+                if (name) {
+                    currentModelsSet.add(name);
+                }
+            }
+        }
+        // Extract identifying information from modelsTableData
+        const tableDataModelsSet = new Set();
+        for (const dbModel of modelsTableData) {
+            if (dbModel.modelFileId) {
+                tableDataModelsSet.add(dbModel.modelFileId);
+            }
+            else {
+                // Fallback to name if modelFileId not available
+                if (dbModel.modelName) {
+                    tableDataModelsSet.add(dbModel.modelName);
+                }
+            }
+        }
+        // Compare sets to detect changes
+        const setsAreEqual = currentModelsSet.size === tableDataModelsSet.size &&
+            [...currentModelsSet].every(id => tableDataModelsSet.has(id));
+        if (setsAreEqual) {
+            // Models in state match table data, skip refetch
+            return;
+        }
+        // Models have changed - log for debugging
+        console.log('[useModels] modelsTableData changed:', {
+            currentCount: currentModelsSet.size,
+            tableDataCount: tableDataModelsSet.size,
+            currentIds: Array.from(currentModelsSet),
+            tableDataIds: Array.from(tableDataModelsSet),
+            tableDataNames: modelsTableData.map(m => m.modelName),
+            tableDataFull: modelsTableData.map(m => ({ name: m.modelName, modelFileId: m.modelFileId })),
+        });
+        // Models have changed, fetch updated models
+        fetchModels();
+    }, [isClientReady, modelsTableData, models$1, fetchModels, schemaId]);
+    return {
+        models: models$1,
+        isLoading,
+        error,
+    };
+};
+/**
+ * Hook to get a specific Model instance
+ * Can be called in two ways:
+ * 1. With schemaId and modelName: useModel(schemaId, modelName)
+ * 2. With modelId: useModel(modelId)
+ *
+ * @param schemaIdOrModelId - The schema ID (schema file ID) OR the model ID (modelFileId)
+ * @param modelName - The name of the model to retrieve (required if first param is schemaId)
+ * @returns Object with model, isLoading, and error
+ */
+const useModel = (schemaIdOrModelId, modelName) => {
+    const isClientReady = useIsClientReady();
+    const [model, setModel] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const subscriptionRef = useRef(undefined);
+    const [, setVersion] = useState(0); // Version counter to force re-renders
+    // If modelName is provided, treat first param as schemaId
+    // Otherwise, treat first param as modelId
+    const isModelIdLookup = modelName === undefined || modelName === null;
+    // Determine initial loading state
+    useMemo(() => {
+        if (!isClientReady)
+            return false;
+        if (isModelIdLookup) {
+            return !!schemaIdOrModelId;
+        }
+        else {
+            return !!(schemaIdOrModelId && modelName);
+        }
+    }, [isClientReady, isModelIdLookup, schemaIdOrModelId, modelName]);
+    // Lookup model by ID if needed
+    useEffect(() => {
+        if (!isClientReady || !isModelIdLookup || !schemaIdOrModelId) {
+            setModel(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        const lookupModelById = async () => {
+            try {
+                setIsLoading(true);
+                setError(null);
+                // Use Model.createById which handles cache + DB lookup
+                const foundModel = await Model.createById(schemaIdOrModelId);
+                setModel(foundModel || undefined);
+                setIsLoading(false);
+                setError(null);
+            }
+            catch (error) {
+                console.error('[useModel] Error looking up model by ID:', error);
+                setModel(undefined);
+                setIsLoading(false);
+                setError(error);
+            }
+        };
+        lookupModelById();
+    }, [isClientReady, isModelIdLookup, schemaIdOrModelId]);
+    // Subscribe to service changes when model is available (for modelId lookup)
+    useEffect(() => {
+        if (!isModelIdLookup || !model) {
+            // Clean up subscription if model is not available
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+            return;
+        }
+        // Clean up previous subscription
+        subscriptionRef.current?.unsubscribe();
+        // Subscribe to service changes
+        const subscription = model.getService().subscribe((snapshot) => {
+            // Force re-render by incrementing version counter
+            setVersion(prev => prev + 1);
+        });
+        subscriptionRef.current = subscription;
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [isModelIdLookup, model]);
+    // If doing modelId lookup, return the model directly
+    if (isModelIdLookup) {
+        return {
+            model,
+            isLoading,
+            error,
+        };
+    }
+    // Otherwise, use schemaId + modelName lookup via useModels
+    const { models: modelsList, isLoading: modelsLoading, error: modelsError } = useModels(schemaIdOrModelId);
+    const foundModel = useMemo(() => {
+        if (!modelName) {
+            return undefined;
+        }
+        // Try both modelName property and name getter for compatibility
+        return modelsList.find((m) => {
+            const mName = m.modelName ?? m.name;
+            return mName === modelName;
+        });
+    }, [modelsList, modelName]);
+    // Subscribe to service changes when model is available (for schemaId + modelName lookup)
+    useEffect(() => {
+        if (isModelIdLookup || !foundModel) {
+            // Clean up subscription if model is not available
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+            return;
+        }
+        // Clean up previous subscription
+        subscriptionRef.current?.unsubscribe();
+        // Subscribe to service changes
+        const subscription = foundModel.getService().subscribe((snapshot) => {
+            // Force re-render by incrementing version counter
+            setVersion(prev => prev + 1);
+        });
+        subscriptionRef.current = subscription;
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [isModelIdLookup, foundModel]);
+    // For schemaId + modelName lookup, derive loading/error from useModels
+    return {
+        model: foundModel,
+        isLoading: modelsLoading,
+        error: modelsError,
+    };
+};
+
+debug('seedSdk:browser:react:modelProperty');
+/**
+ * Hook to get all ModelProperty instances for a specific model
+ * Can be called in two ways:
+ * 1. With schemaId and modelName: useModelProperties(schemaId, modelName)
+ * 2. With modelId: useModelProperties(modelId)
+ *
+ * Uses useLiveQuery to watch for changes in the properties table and automatically
+ * updates the returned ModelProperty instances when changes occur.
+ *
+ * @param schemaIdOrModelId - The schema ID (schema file ID) OR the model ID (modelFileId)
+ * @param modelName - The name of the model to get properties from (required if first param is schemaId)
+ * @returns Object with modelProperties array, isLoading, and error
+ */
+const useModelProperties = (schemaIdOrModelId, modelName) => {
+    // Use useModel to handle both lookup patterns (by ID or by schemaId + modelName)
+    const { model } = useModel(schemaIdOrModelId, modelName);
+    // Determine the modelName for use in getPropertySchema
+    const modelNameForProperty = useMemo(() => {
+        if (!model)
+            return undefined;
+        try {
+            return model.modelName ?? model.name;
+        }
+        catch {
+            return undefined;
+        }
+    }, [model]);
+    const [modelProperties, setModelProperties] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const isClientReady = useIsClientReady();
+    // Get _dbId (database ID) from model context
+    const dbModelId = useMemo(() => {
+        if (!model)
+            return null;
+        try {
+            const context = model._getSnapshotContext();
+            return context._dbId; // _dbId is the database integer ID
+        }
+        catch {
+            return null;
+        }
+    }, [model]);
+    // Watch the properties table for changes
+    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
+    const db = isClientReady ? BaseDb.getAppDb() : null;
+    const propertiesQuery = useMemo(() => {
+        if (!db || !dbModelId)
+            return null;
+        return db
+            .select({
+            id: properties.id,
+            name: properties.name,
+            dataType: properties.dataType,
+            schemaFileId: properties.schemaFileId,
+        })
+            .from(properties)
+            .where(eq(properties.modelId, dbModelId));
+    }, [db, isClientReady, dbModelId]);
+    const propertiesTableData = useLiveQuery(propertiesQuery);
+    const fetchModelProperties = useCallback(async () => {
+        if (!modelNameForProperty || !model || !schemaIdOrModelId) {
+            setModelProperties([]);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        try {
+            setIsLoading(true);
+            const timestamp = Date.now();
+            console.log(`[useModelProperties.fetchModelProperties] [${timestamp}] Starting fetch, propertiesTableData count:`, propertiesTableData?.length, 'properties:', propertiesTableData?.map(p => p.name));
+            // Use propertiesTableData (database state) as the source of truth instead of model.properties (schema file)
+            // This ensures we get the current names even after property renames
+            if (!propertiesTableData || propertiesTableData.length === 0) {
+                setModelProperties([]);
+                setError(null);
+                setIsLoading(false);
+                return;
+            }
+            const _modelProperties = [];
+            // Iterate over propertiesTableData and create ModelProperty instances by schemaFileId
+            // This works even when property names have changed, since schemaFileId is stable
+            for (const dbProperty of propertiesTableData) {
+                if (!dbProperty.schemaFileId) {
+                    // If no schemaFileId, fall back to name-based lookup (for backwards compatibility)
+                    const modelPropertyData = await getPropertySchema(modelNameForProperty, dbProperty.name);
+                    if (modelPropertyData) {
+                        const modelProperty = ModelProperty.create({
+                            ...modelPropertyData,
+                        });
+                        _modelProperties.push(modelProperty);
+                    }
+                }
+                else {
+                    // Use createById to get/create the instance by schemaFileId (stable across renames)
+                    const modelProperty = await ModelProperty.createById(dbProperty.schemaFileId);
+                    if (modelProperty) {
+                        _modelProperties.push(modelProperty);
+                    }
+                }
+            }
+            console.log(`[useModelProperties.fetchModelProperties] [${timestamp}] Created ${_modelProperties.length} ModelProperty instances`);
+            setModelProperties(prev => {
+                // Check if anything actually changed
+                if (prev.length !== _modelProperties.length) {
+                    console.log('[useModelProperties] Length changed:', prev.length, '->', _modelProperties.length);
+                    return _modelProperties;
+                }
+                // Compare by property name or schemaFileId
+                const hasChanged = _modelProperties.some((prop, i) => {
+                    if (!prev[i])
+                        return true;
+                    const prevContext = prev[i]._getSnapshotContext();
+                    const currContext = prop._getSnapshotContext();
+                    const prevId = prevContext?.id;
+                    const currId = currContext?.id;
+                    const prevName = prev[i].name;
+                    const currName = prop.name;
+                    return prevId !== currId || prevName !== currName;
+                });
+                if (hasChanged) {
+                    console.log('[useModelProperties] Properties changed (by ID or name)');
+                }
+                else {
+                    console.log('[useModelProperties] No changes detected');
+                }
+                return hasChanged ? _modelProperties : prev;
+            });
+            setError(null);
+            setIsLoading(false);
+        }
+        catch (error) {
+            setError(error);
+            setIsLoading(false);
+        }
+    }, [modelNameForProperty, model, propertiesTableData, schemaIdOrModelId]);
+    // Fetch model properties when dbModelId becomes available (model has finished loading)
+    // This ensures we wait for the model to be fully loaded before trying to fetch properties
+    useEffect(() => {
+        if (!isClientReady || !dbModelId || !modelNameForProperty || !model || !schemaIdOrModelId) {
+            return;
+        }
+        // Wait for propertiesTableData to be available before initial fetch
+        // (it may be undefined initially while the query is starting)
+        if (propertiesTableData === undefined) {
+            return;
+        }
+        // Initial fetch when model is ready and dbModelId is available
+        fetchModelProperties();
+    }, [isClientReady, dbModelId, fetchModelProperties, modelNameForProperty, model, schemaIdOrModelId, propertiesTableData]);
+    // Refetch model properties when table data actually changes (not just reference)
+    useEffect(() => {
+        if (!isClientReady || !modelNameForProperty || !model || !schemaIdOrModelId || !dbModelId) {
+            return;
+        }
+        // If propertiesTableData is undefined, the query hasn't started yet - wait for it
+        if (propertiesTableData === undefined) {
+            return;
+        }
+        // Extract identifying information from current properties in state
+        const currentPropertiesSet = new Set();
+        for (const prop of modelProperties) {
+            const context = prop._getSnapshotContext();
+            const propertyFileId = context?.id;
+            if (propertyFileId) {
+                currentPropertiesSet.add(propertyFileId);
+            }
+            else {
+                // Fallback to name if propertyFileId not available
+                const name = prop.name;
+                if (name) {
+                    currentPropertiesSet.add(name);
+                }
+            }
+        }
+        // Extract identifying information from propertiesTableData
+        const tableDataPropertiesSet = new Set();
+        for (const dbProperty of propertiesTableData) {
+            if (dbProperty.schemaFileId) {
+                tableDataPropertiesSet.add(dbProperty.schemaFileId);
+            }
+            else {
+                // Fallback to name if schemaFileId not available
+                if (dbProperty.name) {
+                    tableDataPropertiesSet.add(dbProperty.name);
+                }
+            }
+        }
+        // Compare sets to detect changes
+        // If currentPropertiesSet is empty but tableDataPropertiesSet has data, that's a change
+        const setsAreEqual = currentPropertiesSet.size === tableDataPropertiesSet.size &&
+            currentPropertiesSet.size > 0 &&
+            [...currentPropertiesSet].every(id => tableDataPropertiesSet.has(id));
+        if (setsAreEqual) {
+            // Properties in state match table data, skip refetch
+            return;
+        }
+        // Properties have changed - log for debugging
+        console.log('[useModelProperties] propertiesTableData changed:', {
+            currentCount: currentPropertiesSet.size,
+            tableDataCount: tableDataPropertiesSet.size,
+            currentIds: Array.from(currentPropertiesSet),
+            tableDataIds: Array.from(tableDataPropertiesSet),
+            tableDataNames: propertiesTableData.map(p => p.name),
+            tableDataFull: propertiesTableData.map(p => ({ name: p.name, schemaFileId: p.schemaFileId })),
+        });
+        // Properties have changed, fetch updated properties
+        fetchModelProperties();
+    }, [isClientReady, propertiesTableData, modelProperties, fetchModelProperties, modelNameForProperty, model, schemaIdOrModelId]);
+    return {
+        modelProperties,
+        isLoading,
+        error,
+    };
+};
+/**
+ * Helper function to get property schema by modelFileId and propertyName
+ */
+const getPropertySchemaByModelFileId = async (modelFileId, propertyName) => {
+    // Get model by modelFileId
+    const model = await Model.createById(modelFileId);
+    if (!model) {
+        return undefined;
+    }
+    // Get modelName from model
+    const modelName = model.modelName ?? model.name;
+    if (!modelName) {
+        return undefined;
+    }
+    // Use existing getPropertySchema function
+    return getPropertySchema(modelName, propertyName);
+};
+function useModelProperty(arg1, arg2, arg3) {
+    // Determine initial loading state - start loading if we have valid parameters
+    const initialLoadingState = useMemo(() => {
+        if (arg3 !== undefined && arg3 !== null) {
+            // Three arguments: schemaId, modelName, propertyName
+            return !!(arg1 && arg2 && arg3);
+        }
+        else if (arg2 !== undefined && arg2 !== null) {
+            // Two arguments: modelFileId, propertyName
+            return !!(arg1 && arg2);
+        }
+        else {
+            // One argument: propertyFileId
+            return !!arg1;
+        }
+    }, [arg1, arg2, arg3]);
+    const [modelProperty, setModelProperty] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(initialLoadingState);
+    const [error, setError] = useState(null);
+    const subscriptionRef = useRef(undefined);
+    const isClientReady = useIsClientReady();
+    // Determine which lookup mode we're in based on arguments
+    const lookupMode = useMemo(() => {
+        if (arg3 !== undefined && arg3 !== null) {
+            // Three arguments: schemaId, modelName, propertyName
+            return { type: 'schemaId', schemaId: arg1, modelName: arg2, propertyName: arg3 };
+        }
+        else if (arg2 !== undefined && arg2 !== null) {
+            // Two arguments: modelFileId, propertyName
+            return { type: 'modelFileId', modelFileId: arg1, propertyName: arg2 };
+        }
+        else {
+            // One argument: propertyFileId
+            return { type: 'propertyFileId', propertyFileId: arg1 };
+        }
+    }, [arg1, arg2, arg3]);
+    // Determine if we should be loading based on parameters
+    const shouldLoad = useMemo(() => {
+        if (!isClientReady)
+            return false;
+        if (lookupMode.type === 'propertyFileId') {
+            return !!lookupMode.propertyFileId;
+        }
+        else if (lookupMode.type === 'modelFileId') {
+            return !!(lookupMode.modelFileId && lookupMode.propertyName);
+        }
+        else {
+            return !!(lookupMode.schemaId && lookupMode.modelName && lookupMode.propertyName);
+        }
+    }, [isClientReady, lookupMode]);
+    const updateModelProperty = useCallback(async () => {
+        if (!isClientReady) {
+            setModelProperty(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        let propertyData;
+        let resolvedModelName;
+        try {
+            setIsLoading(true);
+            setError(null);
+            if (lookupMode.type === 'propertyFileId') {
+                if (!lookupMode.propertyFileId) {
+                    setModelProperty(undefined);
+                    setIsLoading(false);
+                    setError(null);
+                    return;
+                }
+                // Use ModelProperty.createById for propertyFileId lookup
+                const foundProperty = await ModelProperty.createById(lookupMode.propertyFileId);
+                if (foundProperty) {
+                    setModelProperty(foundProperty);
+                    setIsLoading(false);
+                    setError(null);
+                }
+                else {
+                    setModelProperty(undefined);
+                    setIsLoading(false);
+                    setError(null);
+                }
+                return;
+            }
+            else if (lookupMode.type === 'modelFileId') {
+                if (!lookupMode.modelFileId || !lookupMode.propertyName) {
+                    setModelProperty(undefined);
+                    setIsLoading(false);
+                    setError(null);
+                    return;
+                }
+                // Get property schema by modelFileId and propertyName
+                // This function already gets the model and resolves modelName
+                propertyData = await getPropertySchemaByModelFileId(lookupMode.modelFileId, lookupMode.propertyName);
+                // Get modelName from model (needed for ModelProperty.create)
+                const model = await Model.createById(lookupMode.modelFileId);
+                resolvedModelName = model?.modelName ?? model?.name;
+            }
+            else {
+                // lookupMode.type === 'schemaId'
+                if (!lookupMode.schemaId || !lookupMode.modelName || !lookupMode.propertyName) {
+                    setModelProperty(undefined);
+                    setIsLoading(false);
+                    setError(null);
+                    return;
+                }
+                // Use existing getPropertySchema for schemaId + modelName + propertyName
+                propertyData = await getPropertySchema(lookupMode.modelName, lookupMode.propertyName);
+                resolvedModelName = lookupMode.modelName;
+            }
+            if (propertyData && resolvedModelName) {
+                const createdProperty = ModelProperty.create({
+                    ...propertyData,
+                    modelName: resolvedModelName,
+                });
+                setModelProperty(createdProperty);
+                setIsLoading(false);
+                setError(null);
+            }
+            else {
+                setModelProperty(undefined);
+                setIsLoading(false);
+                setError(null);
+            }
+        }
+        catch (error) {
+            console.error('[useModelProperty] Error updating model property:', error);
+            setModelProperty(undefined);
+            setIsLoading(false);
+            setError(error);
+        }
+    }, [isClientReady, lookupMode.type, lookupMode.propertyFileId, lookupMode.modelFileId, lookupMode.propertyName, lookupMode.schemaId, lookupMode.modelName]);
+    // Fetch/refetch when lookup parameters change or client becomes ready
+    useEffect(() => {
+        if (!shouldLoad) {
+            setModelProperty(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        updateModelProperty();
+    }, [shouldLoad, updateModelProperty]);
+    // Subscribe to service changes when modelProperty is available
+    useEffect(() => {
+        if (!modelProperty) {
+            return;
+        }
+        // Clean up previous subscription
+        subscriptionRef.current?.unsubscribe();
+        // Subscribe to service changes
+        const subscription = modelProperty.getService().subscribe((snapshot) => {
+            updateModelProperty();
+        });
+        subscriptionRef.current = subscription;
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [modelProperty, updateModelProperty]);
+    return {
+        modelProperty,
+        isLoading,
+        error,
+    };
+}
+
+const deleteItem = async ({ seedLocalId, seedUid }) => {
+    const appDb = BaseDb.getAppDb();
+    const conditions = [];
+    if (seedLocalId) {
+        conditions.push(eq(seeds.localId, seedLocalId));
+    }
+    if (seedUid) {
+        conditions.push(eq(seeds.uid, seedUid));
+    }
+    if (conditions.length === 0) {
+        return;
+    }
+    await appDb
+        .update(seeds)
+        .set({
+        _markedForDeletion: 1,
+    })
+        .where(or(...conditions));
+};
+
+const useDeleteItem = () => {
+    const [isDeletingItem, setIsDeletingItem] = useState(false);
+    const destroy = useCallback(async (item) => {
+        if (!item) {
+            return;
+        }
+        setIsDeletingItem(true);
+        await deleteItem({ seedLocalId: item.seedLocalId });
+        setIsDeletingItem(false);
+    }, [isDeletingItem]);
+    useEffect(() => { }, []);
+    return {
+        deleteItem: destroy,
+        isDeletingItem,
+    };
+};
+
+debug('seedSdk:feed');
+const relationValuesToExclude = [
+    '0x0000000000000000000000000000000000000000000000000000000000000020',
+];
+// Helper to convert snake_case to camelCase
+const toCamelCase = (str) => {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+};
+// Helper to format timestamp as RFC 822 date string for RSS pubDate
+const formatRfc822Date = (timestamp) => {
+    const date = new Date(timestamp * 1000); // Convert from seconds to milliseconds
+    const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const day = days[date.getUTCDay()];
+    const month = months[date.getUTCMonth()];
+    const year = date.getUTCFullYear();
+    const dayNum = date.getUTCDate().toString().padStart(2, '0');
+    const hours = date.getUTCHours().toString().padStart(2, '0');
+    const minutes = date.getUTCMinutes().toString().padStart(2, '0');
+    const seconds = date.getUTCSeconds().toString().padStart(2, '0');
+    return `${day}, ${dayNum} ${month} ${year} ${hours}:${minutes}:${seconds} GMT`;
+};
+// Helper to set default values for feed items
+const setFeedItemDefaults = (item, seedUid, schemaName) => {
+    // Set default title if not present (check both snake_case and camelCase)
+    if (!item.title && !item.Title) {
+        item.title = seedUid;
+        item.Title = seedUid; // Also set camelCase version
+    }
+    else if (item.title && !item.Title) {
+        item.Title = item.title;
+    }
+    else if (item.Title && !item.title) {
+        item.title = item.Title;
+    }
+    // Set default link/guid using seedUid or storage_transaction_id
+    // Handle empty strings, null, and undefined - check both formats
+    const storageTransactionIdSnake = item.storage_transaction_id &&
+        typeof item.storage_transaction_id === 'string' &&
+        item.storage_transaction_id.trim() !== '' &&
+        item.storage_transaction_id !== 'undefined' &&
+        item.storage_transaction_id !== seedUid // Don't use seedUid as transaction ID
+        ? item.storage_transaction_id.trim()
+        : null;
+    const storageTransactionIdCamel = item.storageTransactionId &&
+        typeof item.storageTransactionId === 'string' &&
+        item.storageTransactionId.trim() !== '' &&
+        item.storageTransactionId !== 'undefined' &&
+        item.storageTransactionId !== seedUid // Don't use seedUid as transaction ID
+        ? item.storageTransactionId.trim()
+        : null;
+    const storageTransactionId = storageTransactionIdSnake || storageTransactionIdCamel;
+    console.log('[feed] [setFeedItemDefaults] Setting defaults for item:', {
+        seedUid,
+        schemaName,
+        hasStorageTransactionIdSnake: !!storageTransactionIdSnake,
+        hasStorageTransactionIdCamel: !!storageTransactionIdCamel,
+        storageTransactionIdSnakeValue: item.storage_transaction_id,
+        storageTransactionIdCamelValue: item.storageTransactionId,
+        storageTransactionId,
+        itemKeys: Object.keys(item),
+    });
+    // If there's a valid storageTransactionId (not seedUid), use Arweave URL for the link
+    // Otherwise, build URL based on schema name (e.g., /images/ for image schema, /posts/ for post schema)
+    let defaultLink;
+    if (storageTransactionId && storageTransactionId !== seedUid && storageTransactionId.length > 0) {
+        try {
+            defaultLink = BaseArweaveClient.getRawUrl(storageTransactionId);
+            console.log('[feed] [setFeedItemDefaults] Using Arweave URL for storageTransactionId:', defaultLink);
+        }
+        catch (error) {
+            console.error('[feed] [setFeedItemDefaults] Error generating Arweave URL:', error);
+            // Fallback to default link format
+            const basePath = schemaName === 'image' ? 'images' : schemaName === 'post' ? 'posts' : schemaName.toLowerCase() + 's';
+            const baseUrl = 'https://seedprotocol.io';
+            defaultLink = `${baseUrl}/${basePath}/${seedUid || 'unknown'}`;
+        }
+    }
+    else {
+        const basePath = schemaName === 'image' ? 'images' : schemaName === 'post' ? 'posts' : schemaName.toLowerCase() + 's';
+        const baseUrl = 'https://seedprotocol.io';
+        // Ensure seedUid is valid, use 'unknown' as fallback to prevent 'undefined' in URLs
+        const validSeedUid = seedUid && typeof seedUid === 'string' && seedUid.trim() !== '' ? seedUid : 'unknown';
+        defaultLink = `${baseUrl}/${basePath}/${validSeedUid}`;
+        console.log('[feed] [setFeedItemDefaults] Using default link format:', defaultLink, { seedUid, validSeedUid });
+    }
+    // Always ensure link is set (override if undefined, null, empty, or the string "undefined")
+    const currentLink = item.link || item.Link;
+    if (!currentLink || currentLink === 'undefined' || (typeof currentLink === 'string' && currentLink.trim() === '')) {
+        item.link = defaultLink;
+        item.Link = defaultLink;
+        console.log('[feed] [setFeedItemDefaults] Set link to:', defaultLink);
+    }
+    else {
+        // Ensure both formats are set
+        if (!item.link || item.link === 'undefined') {
+            item.link = currentLink;
+        }
+        if (!item.Link || item.Link === 'undefined') {
+            item.Link = currentLink;
+        }
+    }
+    // Always ensure guid is set (use link if available, otherwise default)
+    const currentGuid = item.guid || item.Guid;
+    if (!currentGuid || currentGuid === 'undefined' || (typeof currentGuid === 'string' && currentGuid.trim() === '')) {
+        item.guid = item.link || defaultLink;
+        item.Guid = item.guid;
+        console.log('[feed] [setFeedItemDefaults] Set guid to:', item.guid);
+    }
+    else {
+        // Ensure both formats are set
+        if (!item.guid || item.guid === 'undefined') {
+            item.guid = currentGuid;
+        }
+        if (!item.Guid || item.Guid === 'undefined') {
+            item.Guid = currentGuid;
+        }
+    }
+    // Set pubDate from timeCreated if available
+    if (item.timeCreated && !item.pubDate && !item.PubDate) {
+        const pubDate = formatRfc822Date(item.timeCreated);
+        item.pubDate = pubDate;
+        item.PubDate = pubDate;
+    }
+    else if (item.pubDate && !item.PubDate) {
+        item.PubDate = item.pubDate;
+    }
+    else if (item.PubDate && !item.pubDate) {
+        item.pubDate = item.PubDate;
+    }
+    // Ensure seedUid is always present
+    if (!item.seedUid && !item.SeedUid) {
+        item.seedUid = seedUid;
+        item.SeedUid = seedUid;
+    }
+    else if (item.seedUid && !item.SeedUid) {
+        item.SeedUid = item.seedUid;
+    }
+    else if (item.SeedUid && !item.seedUid) {
+        item.seedUid = item.SeedUid;
+    }
+    // Note: We don't set storageTransactionId to seedUid as a fallback anymore
+    // because seedUid is not a valid Arweave transaction ID. If storageTransactionId
+    // doesn't exist, we'll use the default link format with seedUid instead.
+};
+const seedUidToModelType = new Map();
+const relatedSeedUids = new Set();
+const versionUidToSeedUid = new Map();
+const assembledFeedItems = new Map();
+const versionsBySeedUid = new Map();
+const latestVersionUidsBySeedUid = new Map();
+const processItemProperty = async (property, itemSeeds) => {
+    console.log('[feed] [processItemProperty] Starting to process property:', {
+        propertyId: property.id,
+        refUID: property.refUID,
+        schemaId: property.schemaId,
+    });
+    let metadata;
+    try {
+        metadata = JSON.parse(property.decodedDataJson)[0].value;
+    }
+    catch (error) {
+        console.error('[feed] [processItemProperty] Error parsing metadata:', error);
+        return;
+    }
+    let propertyNameSnake = metadata.name;
+    if (!propertyNameSnake) {
+        console.log('[feed] [processItemProperty] WARNING: no propertyName found for property:', {
+            propertyId: property.id,
+            property,
+        });
+        console.warn('[item/events] [syncDbWithEas] no propertyName found for property: ', property);
+        return;
+    }
+    console.log('[feed] [processItemProperty] Processing property:', {
+        propertyNameSnake,
+        propertyId: property.id,
+    });
+    let isRelation = false;
+    let refSeedType;
+    let refSchemaUid;
+    let isList = false;
+    const schemaUid = property.schemaId;
+    console.log('[feed] [processItemProperty] Setting schema UID for schema definition:', {
+        propertyNameSnake,
+        schemaUid,
+    });
+    setSchemaUidForSchemaDefinition({
+        text: propertyNameSnake,
+        schemaUid,
+    });
+    if ((propertyNameSnake.endsWith('_id') ||
+        propertyNameSnake.endsWith('_ids')) &&
+        propertyNameSnake !== 'storage_transaction_id' &&
+        propertyNameSnake !== 'storage_provider_transaction_id') {
+        isRelation = true;
+        console.log('[feed] [processItemProperty] Detected relation property:', {
+            propertyNameSnake,
+            metadataValue: metadata.value,
+        });
+        if (Array.isArray(metadata.value)) {
+            isList = true;
+            console.log('[feed] [processItemProperty] Detected list relation:', {
+                propertyNameSnake,
+                listLength: metadata.value.length,
+                values: metadata.value,
+            });
+            const result = parseEasRelationPropertyName(propertyNameSnake);
+            console.log('[feed] [processItemProperty] Parsed relation property name:', {
+                result,
+                originalPropertyName: propertyNameSnake,
+            });
+            if (result) {
+                propertyNameSnake = result.propertyName;
+                refSeedType = result.modelName;
+                console.log('[feed] [processItemProperty] Updated property name and seed type:', {
+                    newPropertyName: propertyNameSnake,
+                    refSeedType,
+                });
+            }
+            metadata.value.forEach((value) => {
+                relatedSeedUids.add(value);
+                console.log('[feed] [processItemProperty] Added related seed UID to set:', {
+                    relatedSeedUid: value,
+                    totalRelatedSeeds: relatedSeedUids.size,
+                });
+            });
+        }
+        if (!isList) {
+            if (relationValuesToExclude.includes(metadata.value)) {
+                console.log('[feed] [processItemProperty] Excluding relation value:', {
+                    propertyNameSnake,
+                    excludedValue: metadata.value,
+                });
+                return;
+            }
+            relatedSeedUids.add(metadata.value);
+            console.log('[feed] [processItemProperty] Added single related seed UID:', {
+                relatedSeedUid: metadata.value,
+                totalRelatedSeeds: relatedSeedUids.size,
+            });
+        }
+    }
+    let propertyValue = metadata.value;
+    if (typeof propertyValue !== 'string') {
+        console.log('[feed] [processItemProperty] Converting property value to string:', {
+            propertyNameSnake,
+            originalType: typeof propertyValue,
+            originalValue: propertyValue,
+        });
+        propertyValue = JSON.stringify(propertyValue);
+    }
+    console.log('[feed] [processItemProperty] Final property value:', {
+        propertyNameSnake,
+        propertyValue,
+        isRelation,
+        isList,
+    });
+    if (isRelation && !isList) {
+        console.log('[feed] [processItemProperty] Processing single relation:', {
+            propertyNameSnake,
+            relationValue: metadata.value,
+            itemSeedsCount: itemSeeds.length,
+        });
+        const relatedSeed = itemSeeds.find((seed) => seed.id === metadata.value);
+        if (relatedSeed && relatedSeed.schema && relatedSeed.schema.schemaNames) {
+            refSeedType = relatedSeed.schema.schemaNames[0].name;
+            refSchemaUid = relatedSeed.schemaId;
+            console.log('[feed] [processItemProperty] Found related seed for single relation:', {
+                propertyNameSnake,
+                refSeedType,
+                refSchemaUid,
+                relatedSeedId: relatedSeed.id,
+            });
+        }
+        else {
+            console.log('[feed] [processItemProperty] No related seed found for single relation:', {
+                propertyNameSnake,
+                relationValue: metadata.value,
+            });
+        }
+    }
+    if (isRelation && isList) {
+        console.log('[feed] [processItemProperty] Processing list relation:', {
+            propertyNameSnake,
+            relationValues: metadata.value,
+            itemSeedsCount: itemSeeds.length,
+        });
+        const relatedSeeds = itemSeeds.filter((seed) => metadata.value.includes(seed.id));
+        console.log('[feed] [processItemProperty] Filtered related seeds for list:', {
+            propertyNameSnake,
+            foundSeedsCount: relatedSeeds.length,
+            foundSeedIds: relatedSeeds.map((s) => s.id),
+        });
+        if (relatedSeeds && relatedSeeds.length > 0) {
+            refSeedType = relatedSeeds[0].schema.schemaNames[0].name;
+            refSchemaUid = relatedSeeds[0].schemaId;
+            console.log('[feed] [processItemProperty] Set ref seed type and schema UID from list relation:', {
+                propertyNameSnake,
+                refSeedType,
+                refSchemaUid,
+            });
+        }
+        else {
+            console.log('[feed] [processItemProperty] No related seeds found for list relation:', {
+                propertyNameSnake,
+            });
+        }
+    }
+    console.log('[feed] [processItemProperty] Looking up seed UID for property:', {
+        propertyRefUID: property.refUID,
+        versionUidToSeedUidSize: versionUidToSeedUid.size,
+    });
+    const seedUidForProperty = versionUidToSeedUid.get(property.refUID);
+    if (!seedUidForProperty) {
+        console.log('[feed] [processItemProperty] WARNING: no seedUid found for property:', {
+            propertyRefUID: property.refUID,
+            propertyId: property.id,
+            property,
+        });
+        console.warn('no seedUid found for property: ', property);
+        return;
+    }
+    console.log('[feed] [processItemProperty] Found seed UID for property:', {
+        seedUidForProperty,
+        propertyNameSnake,
+    });
+    let existingFeedItem = assembledFeedItems.get(seedUidForProperty) || {};
+    const existingKeys = Object.keys(existingFeedItem);
+    // Store property in snake_case (original format)
+    existingFeedItem[propertyNameSnake] = propertyValue;
+    // Also store in camelCase for easier access by external consumers (e.g., RSS generators)
+    const propertyNameCamel = toCamelCase(propertyNameSnake);
+    if (propertyNameCamel !== propertyNameSnake) {
+        existingFeedItem[propertyNameCamel] = propertyValue;
+    }
+    assembledFeedItems.set(seedUidForProperty, existingFeedItem);
+    console.log('[feed] [processItemProperty] Updated assembled feed item:', {
+        seedUidForProperty,
+        propertyNameSnake,
+        propertyValue,
+        existingKeysCount: existingKeys.length,
+        newKeysCount: Object.keys(existingFeedItem).length,
+        totalAssembledItems: assembledFeedItems.size,
+    });
+};
+const processSeeds = async (seeds) => {
+    console.log('[feed] [processSeeds] Starting to process seeds:', {
+        seedsCount: seeds.length,
+        seedIds: seeds.map((s) => s.id),
+    });
+    const seedUids = seeds.map((seed) => seed.id);
+    for (let i = 0; i < seeds.length; i++) {
+        const seed = seeds[i];
+        seedUids.push(seed.id);
+        const modelType = seed.schema.schemaNames[0].name;
+        seedUidToModelType.set(seed.id, modelType);
+        // Initialize feed item with seed metadata
+        if (!assembledFeedItems.has(seed.id)) {
+            assembledFeedItems.set(seed.id, {
+                seedUid: seed.id,
+                timeCreated: seed.timeCreated,
+            });
+            console.log('[feed] [processSeeds] Initialized feed item for seed:', {
+                seedId: seed.id,
+                modelType,
+            });
+        }
+        console.log('[feed] [processSeeds] Processing seed:', {
+            index: i,
+            seedId: seed.id,
+            modelType,
+            totalSeedsProcessed: i + 1,
+        });
+    }
+    console.log('[feed] [processSeeds] Completed seed mapping:', {
+        totalSeeds: seeds.length,
+        seedUidToModelTypeSize: seedUidToModelType.size,
+        seedUids,
+    });
+    console.log('[feed] [processSeeds] Fetching item versions from EAS:', {
+        seedUidsCount: seedUids.length,
+        seedUids,
+    });
+    const itemVersions = await getItemVersionsFromEas({ seedUids });
+    console.log('[feed] [processSeeds] Received item versions from EAS:', {
+        itemVersionsCount: itemVersions.length,
+        versionIds: itemVersions.map((v) => v.id),
+    });
+    for (let i = 0; i < itemVersions.length; i++) {
+        const itemVersion = itemVersions[i];
+        const seedUid = itemVersion.refUID;
+        versionUidToSeedUid.set(itemVersion.id, seedUid);
+        const existingVersions = versionsBySeedUid.get(seedUid) || [];
+        versionsBySeedUid.set(seedUid, [...existingVersions, itemVersion]);
+        console.log('[feed] [processSeeds] Processed item version:', {
+            index: i,
+            versionId: itemVersion.id,
+            seedUid,
+            timeCreated: itemVersion.timeCreated,
+            versionsForSeedCount: existingVersions.length + 1,
+        });
+    }
+    console.log('[feed] [processSeeds] Completed version mapping:', {
+        totalVersions: itemVersions.length,
+        versionUidToSeedUidSize: versionUidToSeedUid.size,
+        versionsBySeedUidSize: versionsBySeedUid.size,
+        uniqueSeedsWithVersions: Array.from(versionsBySeedUid.keys()),
+    });
+    // Get latest version for each seed and then use those to get the properties
+    console.log('[feed] [processSeeds] Determining latest versions for each seed');
+    const latestVersionUids = [];
+    for (const [seedUid, versions] of versionsBySeedUid.entries()) {
+        console.log('[feed] [processSeeds] Processing versions for seed:', {
+            seedUid,
+            versionsCount: versions.length,
+            versionIds: versions.map((v) => v.id),
+            timeCreateds: versions.map((v) => v.timeCreated),
+        });
+        // Sort versions by timeCreated in descending order (most recent first)
+        const sortedVersions = [...versions].sort((a, b) => b.timeCreated - a.timeCreated);
+        console.log('[feed] [processSeeds] Sorted versions:', {
+            seedUid,
+            sortedVersionIds: sortedVersions.map((v) => v.id),
+            sortedTimeCreateds: sortedVersions.map((v) => v.timeCreated),
+        });
+        // Get the most recent version for this seedUid
+        if (sortedVersions.length > 0) {
+            const latestVersion = sortedVersions[0];
+            latestVersionUids.push(latestVersion.id);
+            latestVersionUidsBySeedUid.set(seedUid, latestVersion.id);
+            console.log('[feed] [processSeeds] Set latest version for seed:', {
+                seedUid,
+                latestVersionId: latestVersion.id,
+                latestTimeCreated: latestVersion.timeCreated,
+            });
+        }
+        else {
+            console.log('[feed] [processSeeds] WARNING: No versions found for seed:', {
+                seedUid,
+            });
+        }
+    }
+    console.log('[feed] [processSeeds] Completed latest version determination:', {
+        latestVersionUidsCount: latestVersionUids.length,
+        latestVersionUids,
+        latestVersionUidsBySeedUidSize: latestVersionUidsBySeedUid.size,
+    });
+    console.log('[feed] [processSeeds] Fetching item properties from EAS:', {
+        latestVersionUidsCount: latestVersionUids.length,
+        latestVersionUids,
+    });
+    const itemProperties = await getItemPropertiesFromEas({ versionUids: latestVersionUids });
+    console.log('[feed] [processSeeds] Received item properties from EAS:', {
+        itemPropertiesCount: itemProperties.length,
+        propertyIds: itemProperties.map((p) => p.id),
+    });
+    for (let i = 0; i < itemProperties.length; i++) {
+        console.log('[feed] [processSeeds] Processing item property:', {
+            index: i,
+            propertyId: itemProperties[i].id,
+            totalProperties: itemProperties.length,
+        });
+        await processItemProperty(itemProperties[i], seeds);
+    }
+    console.log('[feed] [processSeeds] Completed processing all seeds:', {
+        seedsCount: seeds.length,
+        itemVersionsCount: itemVersions.length,
+        itemPropertiesCount: itemProperties.length,
+        assembledFeedItemsSize: assembledFeedItems.size,
+    });
+};
+const getFeedItemsBySchemaName = async (schemaName) => {
+    console.log('[feed] [getFeedItemsBySchemaName] Starting feed retrieval:', {
+        schemaName,
+        currentAssembledItemsSize: assembledFeedItems.size,
+        currentRelatedSeedUidsSize: relatedSeedUids.size,
+    });
+    const easClient = BaseEasClient.getEasClient();
+    console.log('[feed] [getFeedItemsBySchemaName] Retrieved EAS client');
+    console.log('[feed] [getFeedItemsBySchemaName] Fetching seeds by schema name:', {
+        schemaName,
+    });
+    const seeds = await getSeedsBySchemaName(schemaName);
+    console.log('[feed] [getFeedItemsBySchemaName] Received seeds:', {
+        seedsCount: seeds.length,
+        seedIds: seeds.map((s) => s.id),
+    });
+    await processSeeds(seeds);
+    const relatedSeedUidsArray = Array.from(relatedSeedUids);
+    console.log('[feed] [getFeedItemsBySchemaName] Fetching related seeds:', {
+        relatedSeedUidsCount: relatedSeedUidsArray.length,
+        relatedSeedUids: relatedSeedUidsArray,
+    });
+    const { itemSeeds: relatedSeeds } = await easClient.request(GET_SEEDS, {
+        where: {
+            id: {
+                in: relatedSeedUidsArray,
+            },
+        },
+    });
+    console.log('[feed] [getFeedItemsBySchemaName] Received related seeds:', {
+        relatedSeedsCount: relatedSeeds.length,
+        relatedSeedIds: relatedSeeds.map((s) => s.id),
+    });
+    await processSeeds(relatedSeeds);
+    // Filter feed items to only include items matching the requested schema name
+    // and apply default values for required RSS fields
+    const feedItems = Array.from(assembledFeedItems.entries())
+        .filter(([seedUid]) => seedUidToModelType.get(seedUid) === schemaName)
+        .map(([seedUid, item]) => {
+        // Apply defaults for required RSS feed fields
+        setFeedItemDefaults(item, seedUid, schemaName);
+        return item;
+    });
+    console.log('[feed] [getFeedItemsBySchemaName] Completed feed retrieval:', {
+        schemaName,
+        feedItemsCount: feedItems.length,
+        assembledFeedItemsSize: assembledFeedItems.size,
+        filteredFeedItemsCount: feedItems.length,
+        feedItemKeys: feedItems.map((item) => Object.keys(item)),
+    });
+    return feedItems;
+};
+
+export { BaseEasClient as EasClient, Item, ItemProperty, Model, ModelProperty, Schema, getFeedItemsBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getPropertySchema, getSeedsBySchemaName, useAllSchemaVersions, useCreateItem, useCreateSchema, useDeleteItem, useItem, useItemProperties, useItemProperty, useItems, useModel, useModelProperties, useModelProperty, useModels, useSchema, useSchemas };
 //# sourceMappingURL=main.js.map