@seedprotocol/sdk 0.4.2 → 0.4.4

package/dist/main.js

@@ -1,36 +1,2685 @@
 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 { am as getClient, an as ClientManagerState, p as BaseDb, a0 as Item, X as seeds, ao as getVersionData, ap as createNewItem, C as metadata, a4 as ItemProperty, W as schemas, aq as loadAllSchemasFromDb, M as Model, q as models, G as modelSchemas, r as properties, a5 as eventEmitter, x as BaseEasClient, ar as getSeedsBySchemaName, as as GET_SEEDS, at as getItemVersionsFromEas, au as getItemPropertiesFromEas, z as BaseArweaveClient, av as setSchemaUidForSchemaDefinition, aw as parseEasRelationPropertyName } from './ClientManager-DoHUt8tU.js';
+export { s as FileManager, a as ModelPropertyDataTypes, aA as SeedModels, a6 as client, aC as createSchema, aB as getArweaveUrlForTransaction, ax as getModelSchemasFromEas, aF as getSchemaNameFromId, ay as getSchemaUidBySchemaName, az as getSeedsFromSchemaUids, a9 as importJsonSchema, aE as listSchemas, ab as readJsonImportFile, aD as readSchema, ac as transformImportToSchemaFile, ah as waitForEntityIdle } from './ClientManager-DoHUt8tU.js';
+import { g as getPropertySchema } from './property-fK7tSUDX.js';
+import { M as ModelProperty } from './ModelProperty-gjcA83Mq.js';
+export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './ModelProperty-gjcA83Mq.js';
+import { Schema } from './Schema-ClTcpgbt.js';
+import React, { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+import { flushSync } from 'react-dom';
+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 { useQueryClient, useQuery, QueryClient as QueryClient$1, QueryClientProvider } from '@tanstack/react-query';
+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 'nanoid';
+import 'nanoid-dictionary';
+import 'ethers';
+import './SchemaValidationService-BfoEiHNr.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 hasSeenIdleRef = useRef(false);
+    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);
+                // Don't clear item if we already have one for the same request (e.g. duplicate loadItem from effect re-run)
+                setItem((prev) => {
+                    if (!prev)
+                        return undefined;
+                    const match = (prev.seedLocalId && prev.seedLocalId === seedLocalIdRef.current) ||
+                        (prev.seedUid && prev.seedUid === seedUidRef.current);
+                    return match ? prev : 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;
+            hasSeenIdleRef.current = false;
+            return;
+        }
+        // Clean up previous subscription
+        subscriptionRef.current?.unsubscribe();
+        hasSeenIdleRef.current = false;
+        // Subscribe to service changes. Only set isLoading to true after we've seen idle at least
+        // once, so we don't overwrite the ready state that loadItem() just set (find() waits for idle).
+        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';
+                if (isIdle) {
+                    hasSeenIdleRef.current = true;
+                    setIsLoading(false);
+                    setError(null);
+                }
+                else if (snapshot.value === 'error') {
+                    setError(new Error('Item service error'));
+                    setIsLoading(false);
+                }
+                else {
+                    // Only show loading if we've already seen idle (real transition to loading)
+                    if (hasSeenIdleRef.current) {
+                        setIsLoading(true);
+                    }
+                }
+            }
+        });
+        subscriptionRef.current = subscription;
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [item]);
+    return {
+        item,
+        isLoading,
+        error,
+    };
+};
+const getItemsQueryKey = (modelName, deleted) => ['seed', 'items', modelName ?? null, deleted ?? false];
+const useItems = ({ modelName, deleted = false }) => {
+    const isClientReady = useIsClientReady();
+    const queryClient = useQueryClient();
+    const previousSeedsTableDataRef = useRef(undefined);
+    const itemsRef = useRef([]);
+    const lastFetchedIdsRef = useRef(new Set());
+    const queryKey = useMemo(() => getItemsQueryKey(modelName, deleted), [modelName, deleted]);
+    const { data: items = [], isLoading, error: queryError, } = useQuery({
+        queryKey,
+        queryFn: () => Item.all(modelName, deleted, { waitForReady: true }),
+        enabled: isClientReady,
+    });
+    itemsRef.current = items;
+    // Watch the seeds table for changes
+    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)));
+        }
+        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);
+    // Invalidate when table data actually changes so useQuery refetches
+    useEffect(() => {
+        if (!isClientReady || !seedsTableData)
+            return;
+        const tableDataItemsSet = new Set();
+        for (const dbSeed of seedsTableData) {
+            const key = dbSeed.localId || dbSeed.uid;
+            if (key)
+                tableDataItemsSet.add(key);
+        }
+        const currentItemsSet = new Set();
+        for (const item of itemsRef.current) {
+            const key = item.seedLocalId || item.seedUid;
+            if (key)
+                currentItemsSet.add(key);
+        }
+        if (tableDataItemsSet.size === 0 && currentItemsSet.size > 0)
+            return;
+        const lastFetched = lastFetchedIdsRef.current;
+        if (lastFetched.size === tableDataItemsSet.size &&
+            [...lastFetched].every((id) => tableDataItemsSet.has(id))) {
+            return;
+        }
+        previousSeedsTableDataRef.current = seedsTableData;
+        const setsAreEqual = currentItemsSet.size === tableDataItemsSet.size &&
+            [...currentItemsSet].every((id) => tableDataItemsSet.has(id));
+        if (setsAreEqual) {
+            lastFetchedIdsRef.current = new Set(tableDataItemsSet);
+            return;
+        }
+        lastFetchedIdsRef.current = new Set(tableDataItemsSet);
+        queryClient.invalidateQueries({ queryKey });
+    }, [isClientReady, seedsTableData, queryClient, queryKey]);
+    return {
+        items: orderBy(items, [
+            (item) => item.lastVersionPublishedAt ||
+                item.attestationCreatedAt ||
+                item.createdAt,
+        ], ['desc']),
+        isLoading,
+        error: queryError,
+    };
+};
+const useCreateItem = () => {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const resetError = useCallback(() => setError(null), []);
+    const createItem = useCallback(async (modelName, itemData) => {
+        if (isLoading) {
+            logger$2('[useCreateItem] [createItem] already creating item, skipping');
+            return undefined;
+        }
+        setError(null);
+        // Flush loading=true synchronously so the UI (and tests) can observe it before async work runs.
+        flushSync(() => setIsLoading(true));
+        try {
+            const data = itemData ?? {};
+            const { seedLocalId } = await createNewItem({ modelName, ...data });
+            const newItem = await Item.find({ modelName, seedLocalId });
+            return (newItem ?? undefined);
+        }
+        catch (err) {
+            logger$2('[useCreateItem] Error creating item:', err);
+            setError(err instanceof Error ? err : new Error(String(err)));
+            return undefined;
+        }
+        finally {
+            // Defer clearing loading so React can commit the loading=true render first.
+            // Otherwise the test (or UI) may never observe isLoading true (same continuation batching).
+            queueMicrotask(() => setIsLoading(false));
+        }
+    }, [isLoading]);
+    return {
+        createItem,
+        isLoading,
+        error,
+        resetError,
+    };
+};
+const usePublishItem = () => {
+    const [publishingItem, setPublishingItem] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const subscriptionRef = useRef(undefined);
+    const resetError = useCallback(() => setError(null), []);
+    const publishItem = useCallback((item) => {
+        if (!item)
+            return;
+        setPublishingItem(item);
+        setError(null);
+        item.publish().catch(() => {
+            // Error is surfaced via service state subscription; avoid unhandled rejection
+        });
+    }, []);
+    useEffect(() => {
+        if (!publishingItem) {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+            setIsLoading(false);
+            return;
+        }
+        subscriptionRef.current?.unsubscribe();
+        const service = publishingItem.getService();
+        const subscription = service.subscribe((snapshot) => {
+            const value = snapshot?.value;
+            const ctx = snapshot?.context;
+            setIsLoading(value === 'publishing');
+            const publishError = ctx?._publishError;
+            setError(publishError ? new Error(publishError.message) : null);
+        });
+        subscriptionRef.current = subscription;
+        const snap = service.getSnapshot();
+        setIsLoading(snap?.value === 'publishing');
+        const ctx = snap?.context;
+        const publishError = ctx?._publishError;
+        setError(publishError ? new Error(publishError.message) : null);
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, [publishingItem]);
+    return {
+        publishItem,
+        isLoading,
+        error,
+        resetError,
+    };
+};
+
+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
+    // Extract primitives so useMemo/useCallback deps are stable when caller passes inline objects
+    // Support object form with itemId: useItemProperty({ itemId, propertyName })
+    const arg1IsObject = typeof arg1 === 'object' && arg1 != null;
+    const obj = arg1IsObject ? arg1 : null;
+    const itemIdFromObj = obj != null ? obj.itemId : undefined;
+    const seedLocalId = obj != null ? obj.seedLocalId : undefined;
+    const seedUid = obj != null ? obj.seedUid : undefined;
+    const propertyNameFromObj = obj != null ? obj.propertyName : undefined;
+    const itemId = typeof arg1 === 'string' ? arg1 : (itemIdFromObj !== undefined && itemIdFromObj !== '' ? itemIdFromObj : undefined);
+    const propertyNameFromArgs = typeof arg1 === 'string' ? arg2 : undefined;
+    const propertyName = propertyNameFromObj ?? propertyNameFromArgs;
+    // Determine which lookup mode we're in based on arguments (deps are primitives to avoid infinite loop)
+    // Unify itemId and identifiers: when itemId is provided (string or object form), use it as seedLocalId so we hit the same code path
+    const lookupMode = useMemo(() => {
+        const resolvedSeedLocalId = (itemId !== undefined && itemId !== '') ? itemId : seedLocalId;
+        const resolvedSeedUid = (itemId !== undefined && itemId !== '') ? undefined : seedUid;
+        if ((resolvedSeedLocalId != null || resolvedSeedUid != null) && propertyName != null && propertyName !== '') {
+            return {
+                type: 'identifiers',
+                seedLocalId: resolvedSeedLocalId ?? undefined,
+                seedUid: resolvedSeedUid,
+                propertyName,
+            };
+        }
+        return null;
+    }, [itemId, propertyName, seedLocalId, seedUid]);
+    // Determine initial loading state
+    useMemo(() => {
+        if (!lookupMode)
+            return false;
+        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;
+        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);
+            const seedLocalId = lookupMode.seedLocalId;
+            const 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.
+    // Skip refetch when we already have the property for this lookup (avoids setting loading true
+    // again when effect re-runs e.g. from Strict Mode or updateItemProperty identity change).
+    // Match by the active identifier only: when looking up by seedLocalId both must match;
+    // when looking up by seedUid both must match. Do not use (seedUid === undefined) as a match
+    // when seedLocalIds differ, which would incorrectly skip refetch after seedLocalId change.
+    useEffect(() => {
+        if (!shouldLoad) {
+            setProperty(undefined);
+            setIsLoading(false);
+            setError(null);
+            return;
+        }
+        const alreadyHavePropertyGuard = property &&
+            lookupMode &&
+            property.propertyName === lookupMode.propertyName &&
+            ((lookupMode.seedLocalId != null && property.seedLocalId === lookupMode.seedLocalId) ||
+                (lookupMode.seedUid != null && property.seedUid === lookupMode.seedUid));
+        if (alreadyHavePropertyGuard)
+            return;
+        updateItemProperty();
+    }, [shouldLoad, updateItemProperty, property, lookupMode]);
+    // 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. Only set isLoading to false when idle; never set to true
+        // here so we never overwrite the loaded state when the machine emits any non-idle state
+        // (e.g. loading, initializing, resolvingRelatedValue) after the initial fetch.
+        const subscription = property.getService().subscribe((snapshot) => {
+            if (snapshot && typeof snapshot === 'object' && 'value' in snapshot && snapshot.value === 'idle') {
+                setIsLoading(false);
+                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,
+    };
+}
+/** Fetches item properties list for useQuery (shared with useItemProperties). */
+async function fetchItemPropertiesList(seedLocalId, seedUid) {
+    if (!seedLocalId && !seedUid)
+        return [];
+    const db = BaseDb.getAppDb();
+    if (!db)
+        return [];
+    const baseList = await ItemProperty.all({ seedLocalId: seedLocalId ?? undefined, seedUid: seedUid ?? undefined }, { waitForReady: true });
+    const _itemProperties = [...baseList];
+    const propertiesWithMetadata = new Set();
+    for (const p of baseList) {
+        if (p.propertyName)
+            propertiesWithMetadata.add(p.propertyName);
+    }
+    let modelName;
+    if (baseList.length > 0) {
+        const first = baseList[0];
+        modelName = first.modelName ?? first.modelType;
+        if (modelName && typeof modelName === 'string')
+            modelName = startCase(modelName);
+    }
+    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);
+        }
+    }
+    const modelProperties = [];
+    if (modelName) {
+        try {
+            const { Model } = await import('./ClientManager-DoHUt8tU.js').then(function (n) { return n.aX; });
+            const model = await Model.getByNameAsync(modelName);
+            if (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);
+        }
+    }
+    if (modelName && modelProperties.length > 0) {
+        const resolvedSeedLocalId = baseList.length > 0 ? (baseList[0].seedLocalId ?? seedLocalId) : seedLocalId;
+        const resolvedSeedUid = baseList.length > 0 ? (baseList[0].seedUid ?? seedUid) : seedUid;
+        for (const propertyName of modelProperties) {
+            if (propertiesWithMetadata.has(propertyName))
+                continue;
+            try {
+                const itemProperty = ItemProperty.create({
+                    propertyName,
+                    modelName,
+                    seedLocalId: resolvedSeedLocalId || undefined,
+                    seedUid: resolvedSeedUid || undefined,
+                    propertyValue: null,
+                }, { waitForReady: false });
+                if (itemProperty)
+                    _itemProperties.push(itemProperty);
+            }
+            catch (error) {
+                logger$1(`[useItemProperties] Error creating ItemProperty for missing property ${propertyName}:`, error);
+            }
+        }
+    }
+    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 = baseList.length > 0 ? (baseList[0].seedLocalId ?? seedLocalId) : seedLocalId;
+                    const resolvedSeedUid = baseList.length > 0 ? (baseList[0].seedUid ?? seedUid) : seedUid;
+                    const createdAtProperty = ItemProperty.create({
+                        propertyName: createdAtPropertyName,
+                        modelName,
+                        seedLocalId: resolvedSeedLocalId || undefined,
+                        seedUid: resolvedSeedUid || undefined,
+                        propertyValue: seedRecords[0].createdAt.toString(),
+                    }, { waitForReady: false });
+                    if (createdAtProperty)
+                        _itemProperties.push(createdAtProperty);
+                }
+                catch (error) {
+                    logger$1(`[useItemProperties] Error creating createdAt ItemProperty:`, error);
+                }
+            }
+        }
+    }
+    return _itemProperties;
+}
+function useItemProperties(arg1) {
+    const isClientReady = useIsClientReady();
+    const queryClient = useQueryClient();
+    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]);
+    const canonicalItemKey = seedLocalId ?? seedUid ?? '';
+    const itemPropertiesQueryKey = useMemo(() => ['seed', 'itemProperties', canonicalItemKey], [canonicalItemKey]);
+    const { data: properties = [], isLoading, error: queryError, } = useQuery({
+        queryKey: itemPropertiesQueryKey,
+        queryFn: () => fetchItemPropertiesList(seedLocalId, seedUid),
+        enabled: isClientReady && !!canonicalItemKey,
+    });
+    // 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);
+    // 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]);
+    // Invalidate when metadata table data actually changes so useQuery refetches
+    useEffect(() => {
+        if (!isClientReady || (!seedLocalId && !seedUid) || propertiesTableData === undefined)
+            return;
+        // Include propertyValue so value-only changes produce a different string and trigger invalidation
+        const tableDataString = JSON.stringify(propertiesTableData
+            .map((p) => ({
+            propertyName: p.propertyName,
+            propertyValue: p.propertyValue,
+            seedLocalId: p.seedLocalId,
+            seedUid: p.seedUid,
+        }))
+            .sort((a, b) => (a.propertyName || '').localeCompare(b.propertyName || '')));
+        if (previousTableDataRef.current === tableDataString)
+            return;
+        previousTableDataRef.current = tableDataString;
+        // Invalidate when metadata table data changed (new/updated/removed props or value changes)
+        // so useQuery refetches and UI shows latest values.
+        if (propertiesTableData.length > 0) {
+            queryClient.invalidateQueries({ queryKey: itemPropertiesQueryKey });
+        }
+    }, [isClientReady, propertiesTableData, properties, seedLocalId, seedUid, queryClient, itemPropertiesQueryKey]);
+    useEffect(() => {
+        previousTableDataRef.current = undefined;
+    }, [seedLocalId, seedUid]);
+    return {
+        properties,
+        isLoading,
+        error: queryError,
+    };
+}
+/**
+ * Hook to create an ItemProperty with loading and error state.
+ * create(props) creates a new property instance for an item; provide seedLocalId or seedUid, propertyName, and modelName.
+ */
+const useCreateItemProperty = () => {
+    const subscriptionRef = useRef(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const resetError = useCallback(() => setError(null), []);
+    const create = useCallback((props) => {
+        if (!props.propertyName || (!props.seedLocalId && !props.seedUid) || !props.modelName) {
+            const err = new Error('seedLocalId or seedUid, propertyName, and modelName are required');
+            setError(err);
+            return undefined;
+        }
+        setError(null);
+        setIsLoading(true);
+        subscriptionRef.current?.unsubscribe();
+        subscriptionRef.current = undefined;
+        const instance = ItemProperty.create(props, { waitForReady: false });
+        if (!instance) {
+            setError(new Error('Failed to create item property'));
+            setIsLoading(false);
+            return undefined;
+        }
+        const subscription = instance.getService().subscribe((snapshot) => {
+            if (snapshot?.value === 'error') {
+                const err = snapshot.context?._loadingError?.error ?? new Error('Failed to create item property');
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setIsLoading(false);
+            }
+            if (snapshot?.value === 'idle') {
+                setError(null);
+                setIsLoading(false);
+            }
+        });
+        subscriptionRef.current = subscription;
+        return instance;
+    }, []);
+    useEffect(() => {
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, []);
+    return {
+        create,
+        isLoading,
+        error,
+        resetError,
+    };
+};
+const useDestroyItemProperty = () => {
+    const [currentInstance, setCurrentInstance] = useState(null);
+    const [destroyState, setDestroyState] = useState({
+        isLoading: false,
+        error: null,
+    });
+    useEffect(() => {
+        if (!currentInstance) {
+            setDestroyState({ isLoading: false, error: null });
+            return;
+        }
+        const service = currentInstance.getService();
+        const update = () => {
+            const snap = service.getSnapshot();
+            const ctx = snap.context;
+            setDestroyState({
+                isLoading: !!ctx._destroyInProgress,
+                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
+            });
+        };
+        update();
+        const sub = service.subscribe(update);
+        return () => sub.unsubscribe();
+    }, [currentInstance]);
+    const destroy = useCallback(async (itemProperty) => {
+        if (!itemProperty)
+            return;
+        setCurrentInstance(itemProperty);
+        await itemProperty.destroy();
+    }, []);
+    const resetError = useCallback(() => {
+        if (currentInstance) {
+            currentInstance.getService().send({ type: 'clearDestroyError' });
+        }
+    }, [currentInstance]);
+    return {
+        destroy,
+        isLoading: destroyState.isLoading,
+        error: destroyState.error,
+        resetError,
+    };
+};
+
+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, {
+                waitForReady: false,
+            });
+            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';
+            if (isIdle) {
+                flushSync(() => setIsLoading(false));
+                setError(null);
+            }
+            else {
+                setIsLoading(true);
+            }
+            // Subscribe to all status changes and update isLoading based on whether status is 'idle'
+            subscriptionRef.current = service.subscribe((snapshot) => {
+                const isIdle = snapshot.value === 'idle';
+                if (isIdle) {
+                    flushSync(() => setIsLoading(false));
+                    setError(null);
+                }
+                else {
+                    setIsLoading(true);
+                }
+            });
+        }
+        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 SEED_SCHEMAS_QUERY_KEY = ['seed', 'schemas'];
+const useSchemas = () => {
+    const isClientReady = useIsClientReady();
+    const queryClient = useQueryClient();
+    const previousSchemasTableDataRef = useRef(undefined);
+    const schemasRef = useRef([]);
+    const { data: schemas$1 = [], isLoading, error: queryError, } = useQuery({
+        queryKey: SEED_SCHEMAS_QUERY_KEY,
+        queryFn: () => Schema.all({ waitForReady: true }),
+        enabled: isClientReady,
+    });
+    schemasRef.current = schemas$1;
+    // Watch the schemas table for changes and invalidate so useQuery refetches
+    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);
+    useEffect(() => {
+        if (!isClientReady || !schemasTableData) {
+            return;
+        }
+        const prevData = previousSchemasTableDataRef.current;
+        const prevDataJson = prevData ? JSON.stringify(prevData) : 'undefined';
+        const currDataJson = schemasTableData ? JSON.stringify(schemasTableData) : 'undefined';
+        if (prevDataJson === currDataJson && prevData !== undefined) {
+            return;
+        }
+        previousSchemasTableDataRef.current = schemasTableData;
+        const currentSchemasSet = new Set();
+        for (const schema of schemasRef.current) {
+            const schemaFileId = schema.id || schema.schemaFileId;
+            if (schemaFileId) {
+                currentSchemasSet.add(schemaFileId);
+            }
+            else {
+                const name = schema.metadata?.name;
+                const version = schema.version;
+                if (name && version !== undefined) {
+                    currentSchemasSet.add(`${name}:${version}`);
+                }
+            }
+        }
+        const tableDataSchemasSet = new Set();
+        for (const dbSchema of schemasTableData) {
+            if (dbSchema.name === 'Seed Protocol')
+                continue;
+            if (dbSchema.schemaFileId) {
+                tableDataSchemasSet.add(dbSchema.schemaFileId);
+            }
+            else if (dbSchema.name != null && dbSchema.version !== undefined) {
+                tableDataSchemasSet.add(`${dbSchema.name}:${dbSchema.version}`);
+            }
+        }
+        const setsAreEqual = currentSchemasSet.size === tableDataSchemasSet.size &&
+            [...currentSchemasSet].every((id) => tableDataSchemasSet.has(id));
+        if (!setsAreEqual) {
+            queryClient.invalidateQueries({ queryKey: SEED_SCHEMAS_QUERY_KEY });
+        }
+    }, [isClientReady, schemasTableData, queryClient]);
+    return {
+        schemas: schemas$1,
+        isLoading,
+        error: queryError,
+    };
+};
+const useCreateSchema = () => {
+    const subscriptionRef = useRef(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const resetError = useCallback(() => setError(null), []);
+    const createSchema = useCallback((schemaName) => {
+        setError(null);
+        setIsLoading(true);
+        subscriptionRef.current?.unsubscribe();
+        subscriptionRef.current = null;
+        const schema = Schema.create(schemaName, {
+            waitForReady: false,
+        });
+        const subscription = schema.getService().subscribe((snapshot) => {
+            if (snapshot.value === 'error') {
+                const err = snapshot.context._loadingError?.error;
+                setError(err instanceof Error ? err : new Error('Failed to create schema'));
+                setIsLoading(false);
+            }
+            if (snapshot.value === 'idle') {
+                setError(null);
+                setIsLoading(false);
+            }
+        });
+        subscriptionRef.current = subscription;
+        return schema;
+    }, []);
+    useEffect(() => {
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = null;
+        };
+    }, []);
+    return {
+        createSchema,
+        isLoading,
+        error,
+        resetError,
+    };
+};
+const useDestroySchema = () => {
+    const [currentInstance, setCurrentInstance] = useState(null);
+    const [destroyState, setDestroyState] = useState({
+        isLoading: false,
+        error: null,
+    });
+    useEffect(() => {
+        if (!currentInstance) {
+            setDestroyState({ isLoading: false, error: null });
+            return;
+        }
+        const service = currentInstance.getService();
+        const update = () => {
+            const snap = service.getSnapshot();
+            const ctx = snap.context;
+            setDestroyState({
+                isLoading: !!ctx._destroyInProgress,
+                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
+            });
+        };
+        update();
+        const sub = service.subscribe(update);
+        return () => sub.unsubscribe();
+    }, [currentInstance]);
+    const destroy = useCallback(async (schema) => {
+        if (!schema)
+            return;
+        setCurrentInstance(schema);
+        await schema.destroy();
+    }, []);
+    const resetError = useCallback(() => {
+        if (currentInstance) {
+            currentInstance.getService().send({ type: 'clearDestroyError' });
+        }
+    }, [currentInstance]);
+    return {
+        destroy,
+        isLoading: destroyState.isLoading,
+        error: destroyState.error,
+        resetError,
+    };
+};
+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, {
+                        waitForReady: false,
+                    });
+                    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 getModelsQueryKey = (schemaId) => ['seed', 'models', schemaId];
+// Last-known-good models per schemaId so we never flash [] after remount or refetch race (survives component unmount).
+const lastModelsBySchemaId = new Map();
+const useModels = (schemaId) => {
+    const isClientReady = useIsClientReady();
+    const queryClient = useQueryClient();
+    const modelsRef = useRef([]);
+    const queryKey = useMemo(() => getModelsQueryKey(schemaId), [schemaId]);
+    const { data: models$1 = [], isLoading, error: queryError, } = useQuery({
+        queryKey,
+        queryFn: async () => {
+            // Capture previous data before any async work so we don't overwrite good cache with [].
+            const prev = queryClient.getQueryData(queryKey);
+            // Use waitForReady: false so we return models as soon as they exist; waitForReady: true
+            // filters to only idle models and can return [] while a model is in creatingProperties.
+            const next = await Model.all(schemaId, { waitForReady: false });
+            // getModelsData can intermittently return [] after returning data; keep prev to avoid overwrite.
+            if (Array.isArray(prev) && prev.length > 0 && Array.isArray(next) && next.length === 0) {
+                return [...prev];
+            }
+            // If this refetch returned [], avoid overwriting non-empty cache (e.g. race where another refetch already wrote data).
+            if (Array.isArray(next) && next.length === 0) {
+                const current = queryClient.getQueryData(queryKey);
+                if (Array.isArray(current) && current.length > 0) {
+                    return [...current];
+                }
+            }
+            return next;
+        },
+        enabled: isClientReady && !!schemaId,
+    });
+    // Never expose [] when we previously had models (avoids flash from refetch races, remounts, or intermittent getModelsData returning []).
+    // When schemaId is null/undefined, always show [] — do not use fallback from a previous schema.
+    const schemaIdKey = schemaId && typeof schemaId === 'string' ? schemaId : '';
+    if (models$1.length > 0) {
+        lastModelsBySchemaId.set(schemaIdKey, models$1);
+    }
+    const fallback = modelsRef.current.length > 0 ? modelsRef.current : lastModelsBySchemaId.get(schemaIdKey);
+    const displayModels = !schemaId
+        ? models$1
+        : models$1.length > 0
+            ? models$1
+            : fallback?.length
+                ? fallback
+                : models$1;
+    modelsRef.current = displayModels;
+    // When a model is created, writeModelToDb posts to this channel; live query over join often doesn't re-run
+    useEffect(() => {
+        if (!schemaId || typeof BroadcastChannel === 'undefined')
+            return;
+        const ch = new BroadcastChannel('seed-models-invalidate');
+        const onMessage = (event) => {
+            const { schemaName, schemaFileId } = event.data || {};
+            if (schemaId === schemaName || schemaId === schemaFileId) {
+                queryClient.invalidateQueries({ queryKey });
+                queryClient.refetchQueries({ queryKey });
+            }
+        };
+        ch.addEventListener('message', onMessage);
+        return () => {
+            ch.removeEventListener('message', onMessage);
+            ch.close();
+        };
+    }, [schemaId, queryClient, queryKey]);
+    // Stabilize query reference: only recreate when (schemaId, isClientReady) change, not when db reference changes.
+    // This keeps the same liveQuery observable/subscription alive so effects can deliver updates when a new model is added.
+    const stableModelsQueryKeyRef = useRef(null);
+    const stableModelsQueryRef = useRef(null);
+    function buildModelsQuery() {
+        const currentDb = BaseDb.getAppDb();
+        if (!currentDb || !schemaId)
+            return null;
+        return currentDb
+            .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)));
+    }
+    const modelsQuery = useMemo(() => {
+        if (!schemaId || !isClientReady)
+            return null;
+        const key = { schemaId, ready: isClientReady };
+        const prevKey = stableModelsQueryKeyRef.current;
+        if (prevKey &&
+            prevKey.schemaId === key.schemaId &&
+            prevKey.ready === key.ready &&
+            stableModelsQueryRef.current !== null) {
+            return stableModelsQueryRef.current;
+        }
+        const q = buildModelsQuery();
+        if (!q)
+            return null;
+        stableModelsQueryKeyRef.current = key;
+        stableModelsQueryRef.current = q;
+        return q;
+    }, [schemaId, isClientReady]);
+    const modelsTableData = useLiveQuery(modelsQuery);
+    useEffect(() => {
+        if (!isClientReady || !modelsTableData || !schemaId)
+            return;
+        const currentModelsSet = new Set();
+        for (const model of modelsRef.current) {
+            const modelFileId = model.id || model.modelFileId;
+            if (modelFileId)
+                currentModelsSet.add(modelFileId);
+            else if (model.modelName)
+                currentModelsSet.add(model.modelName);
+        }
+        const tableDataModelsSet = new Set();
+        for (const dbModel of modelsTableData) {
+            if (dbModel.modelFileId)
+                tableDataModelsSet.add(dbModel.modelFileId);
+            else if (dbModel.modelName)
+                tableDataModelsSet.add(dbModel.modelName);
+        }
+        const setsAreEqual = currentModelsSet.size === tableDataModelsSet.size &&
+            [...currentModelsSet].every((id) => tableDataModelsSet.has(id));
+        // Only invalidate when the table has rows we might be missing (live query saw new data).
+        // Do NOT invalidate when we have more than the table: the live query may not have updated
+        // yet (e.g. join over model_schemas), and refetching would overwrite cache with [].
+        const tableHasNewRows = tableDataModelsSet.size > 0 &&
+            [...tableDataModelsSet].some((id) => !currentModelsSet.has(id));
+        if (!setsAreEqual && tableHasNewRows) {
+            queryClient.invalidateQueries({ queryKey });
+        }
+    }, [isClientReady, modelsTableData, schemaId, queryClient, queryKey]);
+    return {
+        models: displayModels,
+        isLoading,
+        error: queryError,
+    };
+};
+/**
+ * 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,
+    };
+};
+const useCreateModel = () => {
+    const subscriptionRef = useRef(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const resetError = useCallback(() => setError(null), []);
+    const create = useCallback((schemaName, modelName, options) => {
+        setError(null);
+        setIsLoading(true);
+        subscriptionRef.current?.unsubscribe();
+        subscriptionRef.current = undefined;
+        const model = Model.create(modelName, schemaName, {
+            ...options,
+            waitForReady: false,
+        });
+        const subscription = model.getService().subscribe((snapshot) => {
+            if (snapshot.value === 'error') {
+                setError(snapshot.context._loadingError?.error ??
+                    new Error('Failed to create model'));
+                setIsLoading(false);
+            }
+            if (snapshot.value === 'idle') {
+                setError(null);
+                setIsLoading(false);
+            }
+        });
+        subscriptionRef.current = subscription;
+        return model;
+    }, []);
+    useEffect(() => {
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, []);
+    return {
+        create,
+        isLoading,
+        error,
+        resetError,
+    };
+};
+const useDestroyModel = () => {
+    const [currentInstance, setCurrentInstance] = useState(null);
+    const [destroyState, setDestroyState] = useState({
+        isLoading: false,
+        error: null,
+    });
+    useEffect(() => {
+        if (!currentInstance) {
+            setDestroyState({ isLoading: false, error: null });
+            return;
+        }
+        const service = currentInstance.getService();
+        const update = () => {
+            const snap = service.getSnapshot();
+            const ctx = snap.context;
+            setDestroyState({
+                isLoading: !!ctx._destroyInProgress,
+                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
+            });
+        };
+        update();
+        const sub = service.subscribe(update);
+        return () => sub.unsubscribe();
+    }, [currentInstance]);
+    const destroy = useCallback(async (model) => {
+        if (!model)
+            return;
+        setCurrentInstance(model);
+        await model.destroy();
+    }, []);
+    const resetError = useCallback(() => {
+        if (currentInstance) {
+            currentInstance.getService().send({ type: 'clearDestroyError' });
+        }
+    }, [currentInstance]);
+    return {
+        destroy,
+        isLoading: destroyState.isLoading,
+        error: destroyState.error,
+        resetError,
+    };
+};
+
+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
+    useMemo(() => {
+        if (!model)
+            return undefined;
+        try {
+            return model.modelName ?? model.name;
+        }
+        catch {
+            return undefined;
+        }
+    }, [model]);
+    const isClientReady = useIsClientReady();
+    const queryClient = useQueryClient();
+    // Get _dbId (database ID) from model context
+    const dbModelId = useMemo(() => {
+        if (!model)
+            return null;
+        try {
+            const context = model._getSnapshotContext();
+            return context._dbId;
+        }
+        catch {
+            return null;
+        }
+    }, [model]);
+    const modelId = model?.id;
+    const modelPropertiesQueryKey = useMemo(() => ['seed', 'modelProperties', modelId ?? ''], [modelId]);
+    const { data: modelProperties = [], isLoading, error: queryError, } = useQuery({
+        queryKey: modelPropertiesQueryKey,
+        queryFn: () => ModelProperty.all(modelId, { waitForReady: true }),
+        enabled: isClientReady && !!modelId,
+    });
+    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 modelPropertiesRef = useRef([]);
+    modelPropertiesRef.current = modelProperties;
+    // Fallback: when we have modelId but query returned [] (e.g. properties not in DB yet or
+    // propertiesTableData is undefined because model._dbId isn't set yet), schedule refetches
+    // so we pick up properties after they're written.
+    useEffect(() => {
+        if (!modelId || modelProperties.length > 0 || !queryClient || !modelPropertiesQueryKey)
+            return;
+        const delays = [400, 1200, 2500];
+        const timers = delays.map((ms) => setTimeout(() => {
+            queryClient.invalidateQueries({ queryKey: modelPropertiesQueryKey });
+        }, ms));
+        return () => timers.forEach((t) => clearTimeout(t));
+    }, [modelId, modelProperties.length, queryClient, modelPropertiesQueryKey]);
+    useEffect(() => {
+        if (!isClientReady || !model?.id || !propertiesTableData || !modelPropertiesQueryKey)
+            return;
+        const currentPropertiesSet = new Set();
+        for (const prop of modelPropertiesRef.current) {
+            const context = prop._getSnapshotContext();
+            const propertyFileId = context?.id;
+            if (propertyFileId)
+                currentPropertiesSet.add(propertyFileId);
+            else if (prop.name)
+                currentPropertiesSet.add(prop.name);
+        }
+        const tableDataPropertiesSet = new Set();
+        for (const dbProperty of propertiesTableData) {
+            if (dbProperty.schemaFileId)
+                tableDataPropertiesSet.add(dbProperty.schemaFileId);
+            else if (dbProperty.name)
+                tableDataPropertiesSet.add(dbProperty.name);
+        }
+        const setsAreEqual = currentPropertiesSet.size === tableDataPropertiesSet.size &&
+            (currentPropertiesSet.size === 0 ||
+                [...currentPropertiesSet].every((id) => tableDataPropertiesSet.has(id)));
+        // Invalidate when cached list is out of sync with the table: either we have stale cached data
+        // (currentPropertiesSet.size > 0) or the table has new rows we don't have yet (tableDataPropertiesSet.size > 0).
+        // The latter handles the case where the initial query returned [] before properties were written.
+        const shouldInvalidate = !setsAreEqual && (currentPropertiesSet.size > 0 || tableDataPropertiesSet.size > 0);
+        if (shouldInvalidate) {
+            queryClient.invalidateQueries({ queryKey: modelPropertiesQueryKey });
+        }
+    }, [isClientReady, propertiesTableData, model?.id, queryClient, modelPropertiesQueryKey]);
+    return {
+        modelProperties,
+        isLoading,
+        error: queryError,
+    };
+};
+/**
+ * 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 }, { waitForReady: false });
+                const resolvedProperty = createdProperty instanceof Promise ? await createdProperty : createdProperty;
+                flushSync(() => {
+                    setModelProperty(resolvedProperty);
+                    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.
+    // Skip subscription for schemaId/modelFileId lookups where we created the instance locally—
+    // refetching on every snapshot would set loading and can race with the initial render.
+    const shouldSubscribe = lookupMode.type === 'propertyFileId';
+    useEffect(() => {
+        if (!modelProperty || !shouldSubscribe) {
+            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, shouldSubscribe]);
+    return {
+        modelProperty,
+        isLoading,
+        error,
+    };
+}
+/**
+ * Hook to create a ModelProperty with loading and error state.
+ * create(schemaId, modelName, property) creates a new property on the model.
+ */
+const useCreateModelProperty = () => {
+    const subscriptionRef = useRef(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const resetError = useCallback(() => setError(null), []);
+    const create = useCallback((_schemaId, modelName, property) => {
+        setError(null);
+        setIsLoading(true);
+        subscriptionRef.current?.unsubscribe();
+        subscriptionRef.current = undefined;
+        if (!modelName || !property.name || !property.dataType) {
+            const err = new Error('modelName, property name and dataType are required');
+            setError(err);
+            setIsLoading(false);
+            throw err;
+        }
+        const created = ModelProperty.create({ ...property, modelName }, { waitForReady: false });
+        const subscription = created.getService().subscribe((snapshot) => {
+            if (snapshot.value === 'error') {
+                const err = snapshot.context._loadingError?.error ?? new Error('Failed to create model property');
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setIsLoading(false);
+            }
+            if (snapshot.value === 'idle') {
+                setError(null);
+                setIsLoading(false);
+            }
+        });
+        subscriptionRef.current = subscription;
+        return created;
+    }, []);
+    useEffect(() => {
+        return () => {
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
+        };
+    }, []);
+    return {
+        create,
+        isLoading,
+        error,
+        resetError,
+    };
+};
+const useDestroyModelProperty = () => {
+    const [currentInstance, setCurrentInstance] = useState(null);
+    const [destroyState, setDestroyState] = useState({
+        isLoading: false,
+        error: null,
+    });
+    useEffect(() => {
+        if (!currentInstance) {
+            setDestroyState({ isLoading: false, error: null });
+            return;
+        }
+        const service = currentInstance.getService();
+        const update = () => {
+            const snap = service.getSnapshot();
+            const ctx = snap.context;
+            setDestroyState({
+                isLoading: !!ctx._destroyInProgress,
+                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
+            });
+        };
+        update();
+        const sub = service.subscribe(update);
+        return () => sub.unsubscribe();
+    }, [currentInstance]);
+    const destroy = useCallback(async (modelProperty) => {
+        if (!modelProperty)
+            return;
+        setCurrentInstance(modelProperty);
+        await modelProperty.destroy();
+    }, []);
+    const resetError = useCallback(() => {
+        if (currentInstance) {
+            currentInstance.getService().send({ type: 'clearDestroyError' });
+        }
+    }, [currentInstance]);
+    return {
+        destroy,
+        isLoading: destroyState.isLoading,
+        error: destroyState.error,
+        resetError,
+    };
+};
+
+const useDeleteItem = () => {
+    const [currentInstance, setCurrentInstance] = useState(null);
+    const [destroyState, setDestroyState] = useState({
+        isLoading: false,
+        error: null,
+    });
+    useEffect(() => {
+        if (!currentInstance) {
+            setDestroyState({ isLoading: false, error: null });
+            return;
+        }
+        const service = currentInstance.getService();
+        const update = () => {
+            const snap = service.getSnapshot();
+            const ctx = snap.context;
+            setDestroyState({
+                isLoading: !!ctx._destroyInProgress,
+                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
+            });
+        };
+        update();
+        const sub = service.subscribe(update);
+        return () => sub.unsubscribe();
+    }, [currentInstance]);
+    const destroy = useCallback(async (item) => {
+        if (!item)
+            return;
+        setCurrentInstance(item);
+        await item.destroy();
+    }, []);
+    const resetError = useCallback(() => {
+        if (currentInstance) {
+            currentInstance.getService().send({ type: 'clearDestroyError' });
+        }
+    }, [currentInstance]);
+    return {
+        deleteItem: destroy,
+        isLoading: destroyState.isLoading,
+        error: destroyState.error,
+        resetError,
+    };
+};
+
+const SEED_QUERY_DEFAULT_OPTIONS = {
+    queries: {
+        networkMode: 'offlineFirst',
+        gcTime: 1000 * 60 * 60 * 24, // 24 hours
+        staleTime: 1000 * 60, // 1 minute - list data can be slightly stale
+    },
+};
+/**
+ * Returns the default options used by Seed for list-query caching.
+ * Use this when building your own QueryClient so Seed hooks get consistent behavior.
+ */
+function getSeedQueryDefaultOptions() {
+    return { ...SEED_QUERY_DEFAULT_OPTIONS };
+}
+/**
+ * Merges Seed's default query options with your existing default options.
+ * Your options take precedence over Seed's. Use when constructing your own QueryClient:
+ *
+ * @example
+ * ```ts
+ * const client = new QueryClient({
+ *   defaultOptions: mergeSeedQueryDefaults({
+ *     queries: { gcTime: 1000 * 60 * 60 },
+ *   }),
+ * })
+ * ```
+ */
+function mergeSeedQueryDefaults(userOptions) {
+    const seed = getSeedQueryDefaultOptions();
+    if (!userOptions)
+        return seed;
+    return {
+        queries: {
+            ...seed.queries,
+            ...(userOptions.queries ?? {}),
+        },
+        mutations: {
+            ...(seed.mutations ?? {}),
+            ...(userOptions.mutations ?? {}),
+        },
+    };
+}
+/**
+ * Creates a QueryClient configured with Seed's default options.
+ * Use this when you want to provide your own QueryClientProvider but still use Seed's defaults.
+ *
+ * @param overrides - Optional config to merge with Seed defaults (e.g. defaultOptions, logger).
+ */
+function createSeedQueryClient(overrides) {
+    const defaults = getSeedQueryDefaultOptions();
+    const { defaultOptions: userDefaultOptions, ...restOverrides } = overrides ?? {};
+    return new QueryClient$1({
+        ...restOverrides,
+        defaultOptions: userDefaultOptions
+            ? mergeSeedQueryDefaults(userDefaultOptions)
+            : defaults,
+    });
+}
+
+/** Module-level ref so invalidateItemPropertiesForItem works when test and app share the same bundle but not the same window (e.g. iframe). */
+let invalidateItemPropertiesRef = null;
+/**
+ * Invalidates and refetches the item-properties query for an item.
+ * Call this after updating an ItemProperty (e.g. after save()) so useItemProperties
+ * refetches and the UI updates. Returns a Promise that resolves when the refetch has completed (if available).
+ */
+function invalidateItemPropertiesForItem(canonicalId) {
+    const p1 = invalidateItemPropertiesRef?.(canonicalId);
+    if (typeof window !== 'undefined' && window.__SEED_INVALIDATE_ITEM_PROPERTIES__) {
+        window.__SEED_INVALIDATE_ITEM_PROPERTIES__(canonicalId);
+    }
+    return Promise.resolve(p1).then(() => { });
+}
+function SeedProviderEventSubscriber({ queryClient }) {
+    useEffect(() => {
+        const invalidate = (canonicalId) => {
+            const key = ['seed', 'itemProperties', canonicalId];
+            queryClient.invalidateQueries({ queryKey: key });
+            return queryClient.refetchQueries({ queryKey: key });
+        };
+        invalidateItemPropertiesRef = invalidate;
+        if (typeof window !== 'undefined') {
+            window.__SEED_INVALIDATE_ITEM_PROPERTIES__ = invalidate;
+        }
+        const handler = (payload) => {
+            const canonicalId = payload?.seedLocalId ?? payload?.seedUid;
+            if (canonicalId) {
+                invalidate(canonicalId);
+            }
+        };
+        eventEmitter.on('itemProperty.saved', handler);
+        return () => {
+            eventEmitter.off('itemProperty.saved', handler);
+            invalidateItemPropertiesRef = null;
+            if (typeof window !== 'undefined') {
+                window.__SEED_INVALIDATE_ITEM_PROPERTIES__ = null;
+            }
+        };
+    }, [queryClient]);
+    return null;
+}
+/**
+ * Provider that supplies a React Query client to Seed list hooks (useSchemas, useItems, useModels, etc.)
+ * so results are cached and shared across components. Wrap your app (or the subtree that uses Seed hooks)
+ * after calling client.init().
+ *
+ * - No props: uses an internal QueryClient with Seed defaults.
+ * - queryClient prop: use your own client (e.g. merge getSeedQueryDefaultOptions when creating it).
+ */
+function SeedProvider({ children, queryClient: queryClientProp, queryClientRef }) {
+    const queryClient = useMemo(() => queryClientProp ?? createSeedQueryClient(), [queryClientProp]);
+    if (queryClientRef) {
+        queryClientRef.current = queryClient;
+        if (typeof window !== 'undefined') {
+            const w = window;
+            w.__TEST_SEED_QUERY_CLIENT__ = queryClient;
+            try {
+                if (window.parent && window.parent !== window)
+                    window.parent.__TEST_SEED_QUERY_CLIENT__ = queryClient;
+            }
+            catch {
+                // cross-origin frame, ignore
+            }
+        }
+    }
+    return (React.createElement(QueryClientProvider, { client: queryClient },
+        React.createElement(SeedProviderEventSubscriber, { queryClient: queryClient }),
+        children));
+}
+
+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, SeedProvider, createSeedQueryClient, getFeedItemsBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getPropertySchema, getSeedQueryDefaultOptions, getSeedsBySchemaName, invalidateItemPropertiesForItem, mergeSeedQueryDefaults, useAllSchemaVersions, useCreateItem, useCreateItemProperty, useCreateModel, useCreateModelProperty, useCreateSchema, useDeleteItem, useDestroyItemProperty, useDestroyModel, useDestroyModelProperty, useDestroySchema, useItem, useItemProperties, useItemProperty, useItems, useModel, useModelProperties, useModelProperty, useModels, usePublishItem, useSchema, useSchemas };
 //# sourceMappingURL=main.js.map