@seedprotocol/sdk 0.4.3 → 0.4.5

package/dist/main.js

@@ -1,29 +1,31 @@
 import 'reflect-metadata';
-import { ai as getClient, aj as ClientManagerState, p as BaseDb, X as seeds, ak as getVersionData, a0 as Item, al as createNewItem, C as metadata, a4 as ItemProperty, W as schemas, am as loadAllSchemasFromDb, q as models, G as modelSchemas, M as Model, r as properties, x as BaseEasClient, an as getSeedsBySchemaName, ao as GET_SEEDS, ap as getItemVersionsFromEas, aq as getItemPropertiesFromEas, z as BaseArweaveClient, ar as setSchemaUidForSchemaDefinition, as as parseEasRelationPropertyName } from './json-I3vJhXo8.js';
-export { s as FileManager, a as ModelPropertyDataTypes, aw as SeedModels, a6 as client, ay as createSchema, ax as getArweaveUrlForTransaction, at as getModelSchemasFromEas, aB as getSchemaNameFromId, au as getSchemaUidBySchemaName, av as getSeedsFromSchemaUids, a9 as importJsonSchema, aA as listSchemas, ab as readJsonImportFile, az as readSchema, ac as transformImportToSchemaFile } from './json-I3vJhXo8.js';
-import { g as getPropertySchema } from './property-Dy09KTxg.js';
-import { M as ModelProperty } from './ModelProperty-Cr3BmgkC.js';
-export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './ModelProperty-Cr3BmgkC.js';
-import { Schema } from './Schema-DeKabJ0T.js';
-import { useState, useRef, useMemo, useEffect, useCallback } from 'react';
+import { 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, w as BaseEasClient, ar as getSeedsBySchemaName, as as GET_SEEDS, at as getItemVersionsFromEas, au as getItemPropertiesFromEas, u as BaseArweaveClient, av as setSchemaUidForSchemaDefinition, aw as parseEasRelationPropertyName } from './index-DPll6EAp.js';
+export { x 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, af as waitForEntityIdle } from './index-DPll6EAp.js';
+import { g as getPropertySchema } from './property-B15X7jLX.js';
+import { ModelProperty } from './ModelProperty-CGdkocQ8.js';
+import { S as Schema } from './Schema-D1eqDHyt.js';
+export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './Schema-D1eqDHyt.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 'xstate';
-import 'rxjs';
-import 'drizzle-orm/casing';
-import '@sinclair/typebox';
-import 'arweave';
-import 'eventemitter3';
 import 'drizzle-orm/sqlite-core';
-import 'ethers';
 import 'nanoid';
 import 'nanoid-dictionary';
-import './SchemaValidationService-cTlURuDt.js';
+import 'ethers';
+import 'rxjs';
+import 'drizzle-orm/casing';
+import 'eventemitter3';
+import 'arweave';
+import '@sinclair/typebox';
+import './SchemaValidationService-DyttFaV_.js';
 import '@sinclair/typebox/value';
 
 const useIsClientReady = () => {
@@ -131,6 +133,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
     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);
@@ -163,7 +166,14 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             });
             if (!foundItem) {
                 logger$2('[useItem] [loadItem] no item found', modelNameRef.current, seedLocalIdRef.current);
-                setItem(undefined);
+                // 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;
@@ -206,26 +216,33 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             // 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();
-        // Subscribe to service changes
-        // Don't set isLoading here - it's already set correctly in loadItem
-        // Just subscribe to future state changes
+        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';
-                setIsLoading(!isIdle);
-                // Clear error if service is in idle state
                 if (isIdle) {
+                    hasSeenIdleRef.current = true;
+                    setIsLoading(false);
                     setError(null);
                 }
                 else if (snapshot.value === 'error') {
-                    // Set error if service is in error state
                     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);
+                    }
                 }
             }
         });
@@ -241,19 +258,21 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
         error,
     };
 };
+const getItemsQueryKey = (modelName, deleted) => ['seed', 'items', modelName ?? null, deleted ?? false];
 const useItems = ({ modelName, deleted = false }) => {
-    const [items, setItems] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
     const isClientReady = useIsClientReady();
-    const subscriptionsRef = useRef(new Map());
-    const loadingItemsRef = useRef(new Set());
+    const queryClient = useQueryClient();
     const previousSeedsTableDataRef = useRef(undefined);
-    const itemsRef = useRef([]); // Track items for comparison without triggering effects
+    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
-    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
-    // IMPORTANT: This query must match the logic in getItemsData() to ensure seedsTableData
-    // only includes seeds that Item.all() will return (i.e., seeds with versionsCount > 0)
     const db = isClientReady ? BaseDb.getAppDb() : null;
     const seedsQuery = useMemo(() => {
         if (!db)
@@ -268,8 +287,6 @@ const useItems = ({ modelName, deleted = false }) => {
         else {
             conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
         }
-        // Join with versionData and filter by versionsCount > 0 to match getItemsData() logic
-        // This ensures we only watch seeds that have at least one version
         const versionData = getVersionData();
         return db
             .with(versionData)
@@ -288,162 +305,39 @@ const useItems = ({ modelName, deleted = false }) => {
             .groupBy(seeds.localId);
     }, [db, isClientReady, modelName, deleted]);
     const seedsTableData = useLiveQuery(seedsQuery);
-    const fetchItems = useCallback(async () => {
-        try {
-            setIsLoading(true);
-            setError(null);
-            const allItems = await Item.all(modelName, deleted);
-            // Filter items into ready vs loading based on service state
-            const readyItems = [];
-            const loadingItemsList = [];
-            // Clear previous loading set
-            loadingItemsRef.current.clear();
-            for (const item of allItems) {
-                const snapshot = item.getService().getSnapshot();
-                const isIdle = snapshot.value === 'idle';
-                if (isIdle) {
-                    // Item is ready
-                    readyItems.push(item);
-                }
-                else {
-                    // Item is still loading - subscribe to state changes
-                    loadingItemsList.push(item);
-                    loadingItemsRef.current.add(item);
-                    // Clean up any existing subscription for this item
-                    const existingSub = subscriptionsRef.current.get(item);
-                    if (existingSub) {
-                        existingSub.unsubscribe();
-                    }
-                    // Subscribe to state changes
-                    const subscription = item.getService().subscribe((snapshot) => {
-                        if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
-                            const isIdle = snapshot.value === 'idle';
-                            if (isIdle) {
-                                // Item is now ready - update state
-                                setItems(prev => {
-                                    // Check if item is already in the list (by seedLocalId or seedUid)
-                                    const exists = prev.some(i => (i.seedLocalId && item.seedLocalId && i.seedLocalId === item.seedLocalId) ||
-                                        (i.seedUid && item.seedUid && i.seedUid === item.seedUid));
-                                    if (exists) {
-                                        return prev;
-                                    }
-                                    // Add the newly ready item
-                                    const updated = [...prev, item];
-                                    itemsRef.current = updated; // Update ref for comparison
-                                    return updated;
-                                });
-                                // Remove from loading set and clean up subscription
-                                loadingItemsRef.current.delete(item);
-                                subscription.unsubscribe();
-                                subscriptionsRef.current.delete(item);
-                                // Update loading state based on remaining loading items
-                                setIsLoading(loadingItemsRef.current.size > 0);
-                            }
-                            else if (snapshot.value === 'error') {
-                                // Item failed to load - clean up subscription
-                                loadingItemsRef.current.delete(item);
-                                subscription.unsubscribe();
-                                subscriptionsRef.current.delete(item);
-                                // Update loading state based on remaining loading items
-                                setIsLoading(loadingItemsRef.current.size > 0);
-                            }
-                        }
-                    });
-                    subscriptionsRef.current.set(item, subscription);
-                }
-            }
-            // Set initial ready items
-            setItems(readyItems);
-            itemsRef.current = readyItems; // Update ref for comparison
-            setError(null);
-            setIsLoading(loadingItemsList.length > 0); // Still loading if any items are loading
-        }
-        catch (error) {
-            setError(error);
-            setIsLoading(false);
-        }
-    }, [modelName, deleted]);
-    // Cleanup subscriptions for items that are no longer in the list
-    useEffect(() => {
-        const currentItemKeys = new Set();
-        for (const item of items) {
-            const key = item.seedLocalId || item.seedUid || '';
-            if (key) {
-                currentItemKeys.add(key);
-            }
-        }
-        // Clean up subscriptions for items that are no longer in the list
-        for (const [item, subscription] of subscriptionsRef.current.entries()) {
-            const key = item.seedLocalId || item.seedUid || '';
-            if (key && !currentItemKeys.has(key)) {
-                // Item is no longer in the list, clean up subscription
-                subscription.unsubscribe();
-                subscriptionsRef.current.delete(item);
-                loadingItemsRef.current.delete(item);
-            }
-        }
-        // Update loading state based on remaining loading items
-        if (loadingItemsRef.current.size === 0 && isLoading) {
-            setIsLoading(false);
-        }
-    }, [items, isLoading]);
-    // Fetch items on initial mount when client is ready
-    useEffect(() => {
-        if (!isClientReady) {
-            return;
-        }
-        // Initial fetch when client becomes ready
-        fetchItems();
-    }, [isClientReady, fetchItems]);
-    // Refetch items when table data actually changes (not just reference)
+    // Invalidate when table data actually changes so useQuery refetches
     useEffect(() => {
-        if (!isClientReady || !seedsTableData) {
-            return;
-        }
-        // Check if seedsTableData actually changed by comparing with previous value
-        const prevData = previousSeedsTableDataRef.current;
-        const prevDataJson = prevData ? JSON.stringify(prevData.map(s => ({ localId: s.localId, uid: s.uid }))) : 'undefined';
-        const currDataJson = seedsTableData ? JSON.stringify(seedsTableData.map(s => ({ localId: s.localId, uid: s.uid }))) : 'undefined';
-        if (prevDataJson === currDataJson && prevData !== undefined) {
-            // Data hasn't actually changed, skip refetch
+        if (!isClientReady || !seedsTableData)
             return;
+        const tableDataItemsSet = new Set();
+        for (const dbSeed of seedsTableData) {
+            const key = dbSeed.localId || dbSeed.uid;
+            if (key)
+                tableDataItemsSet.add(key);
         }
-        // Update ref with current data
-        previousSeedsTableDataRef.current = seedsTableData;
-        // Extract identifying information from current items in state (using ref to avoid dependency)
         const currentItemsSet = new Set();
         for (const item of itemsRef.current) {
             const key = item.seedLocalId || item.seedUid;
-            if (key) {
+            if (key)
                 currentItemsSet.add(key);
-            }
         }
-        // Extract identifying information from seedsTableData
-        const tableDataItemsSet = new Set();
-        for (const dbSeed of seedsTableData) {
-            const key = dbSeed.localId || dbSeed.uid;
-            if (key) {
-                tableDataItemsSet.add(key);
-            }
+        if (tableDataItemsSet.size === 0 && currentItemsSet.size > 0)
+            return;
+        const lastFetched = lastFetchedIdsRef.current;
+        if (lastFetched.size === tableDataItemsSet.size &&
+            [...lastFetched].every((id) => tableDataItemsSet.has(id))) {
+            return;
         }
-        // Compare sets to detect changes
+        previousSeedsTableDataRef.current = seedsTableData;
         const setsAreEqual = currentItemsSet.size === tableDataItemsSet.size &&
-            [...currentItemsSet].every(id => tableDataItemsSet.has(id));
+            [...currentItemsSet].every((id) => tableDataItemsSet.has(id));
         if (setsAreEqual) {
-            // Items in state match table data, skip refetch
+            lastFetchedIdsRef.current = new Set(tableDataItemsSet);
             return;
         }
-        // Items have changed, fetch updated items
-        fetchItems();
-    }, [isClientReady, seedsTableData, fetchItems, modelName]);
-    // Cleanup all subscriptions on unmount
-    useEffect(() => {
-        return () => {
-            subscriptionsRef.current.forEach(sub => sub.unsubscribe());
-            subscriptionsRef.current.clear();
-            loadingItemsRef.current.clear();
-        };
-    }, []);
+        lastFetchedIdsRef.current = new Set(tableDataItemsSet);
+        queryClient.invalidateQueries({ queryKey });
+    }, [isClientReady, seedsTableData, queryClient, queryKey]);
     return {
         items: orderBy(items, [
             (item) => item.lastVersionPublishedAt ||
@@ -451,28 +345,92 @@ const useItems = ({ modelName, deleted = false }) => {
                 item.createdAt,
         ], ['desc']),
         isLoading,
-        error,
+        error: queryError,
     };
 };
 const useCreateItem = () => {
-    const [isCreatingItem, setIsCreatingItem] = useState(false);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const resetError = useCallback(() => setError(null), []);
     const createItem = useCallback(async (modelName, itemData) => {
-        if (isCreatingItem) {
-            // TODO: should we setup a queue for this?
-            console.error(`[useCreateItem] [createItem] already creating item`, itemData);
-            return;
+        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;
         }
-        setIsCreatingItem(true);
-        if (!itemData) {
-            itemData = {};
+        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));
         }
-        const { seedLocalId } = await createNewItem({ modelName, ...itemData });
-        await Item.find({ modelName, seedLocalId });
-        setIsCreatingItem(false);
-    }, [isCreatingItem]);
+    }, [isLoading]);
     return {
         createItem,
-        isCreatingItem,
+        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,
     };
 };
 
@@ -485,36 +443,38 @@ function useItemProperty(arg1, arg2) {
     const [error, setError] = useState(null);
     const subscriptionRef = useRef(undefined);
     const [, setVersion] = useState(0); // Version counter to force re-renders
-    // Determine which lookup mode we're in based on arguments
+    // 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(() => {
-        if (typeof arg1 === 'string' && arg2 !== undefined) {
-            // Two arguments: itemId, propertyName
-            return { type: 'itemId', itemId: arg1, propertyName: arg2 };
-        }
-        else if (typeof arg1 === 'object') {
-            // Object argument: { seedLocalId/seedUid, propertyName }
+        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: arg1.seedLocalId,
-                seedUid: arg1.seedUid,
-                propertyName: arg1.propertyName,
+                seedLocalId: resolvedSeedLocalId ?? undefined,
+                seedUid: resolvedSeedUid,
+                propertyName,
             };
         }
-        else {
-            return null;
-        }
-    }, [arg1, arg2]);
+        return null;
+    }, [itemId, propertyName, seedLocalId, seedUid]);
     // Determine initial loading state
     useMemo(() => {
         if (!lookupMode)
             return false;
-        if (lookupMode.type === 'itemId') {
-            return !!(lookupMode.itemId && lookupMode.propertyName);
-        }
-        else {
-            return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
-                lookupMode.propertyName);
-        }
+        return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
+            lookupMode.propertyName);
     }, [lookupMode]);
     // Determine if we should be loading based on parameters
     const shouldLoad = useMemo(() => {
@@ -522,13 +482,8 @@ function useItemProperty(arg1, arg2) {
             return false;
         if (!lookupMode)
             return false;
-        if (lookupMode.type === 'itemId') {
-            return !!(lookupMode.itemId && lookupMode.propertyName);
-        }
-        else {
-            return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
-                lookupMode.propertyName);
-        }
+        return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
+            lookupMode.propertyName);
     }, [isClientReady, lookupMode]);
     const updateItemProperty = useCallback(async () => {
         if (!isClientReady || !lookupMode) {
@@ -540,17 +495,8 @@ function useItemProperty(arg1, arg2) {
         try {
             setIsLoading(true);
             setError(null);
-            let seedLocalId;
-            let seedUid;
-            if (lookupMode.type === 'itemId') {
-                // Resolve itemId to seedLocalId/seedUid
-                // For now, assume itemId is seedLocalId (could be enhanced to support seedUid)
-                seedLocalId = lookupMode.itemId;
-            }
-            else {
-                seedLocalId = lookupMode.seedLocalId;
-                seedUid = lookupMode.seedUid;
-            }
+            const seedLocalId = lookupMode.seedLocalId;
+            const seedUid = lookupMode.seedUid;
             if (!seedLocalId && !seedUid) {
                 setProperty(undefined);
                 setIsLoading(false);
@@ -581,7 +527,12 @@ function useItemProperty(arg1, arg2) {
             setError(error);
         }
     }, [isClientReady, lookupMode]);
-    // Fetch/refetch when lookup parameters change or client becomes ready
+    // 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);
@@ -589,8 +540,15 @@ function useItemProperty(arg1, arg2) {
             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]);
+    }, [shouldLoad, updateItemProperty, property, lookupMode]);
     // Subscribe to service changes when property is available
     useEffect(() => {
         if (!property) {
@@ -601,17 +559,13 @@ function useItemProperty(arg1, arg2) {
         }
         // Clean up previous subscription
         subscriptionRef.current?.unsubscribe();
-        // Subscribe to service changes
+        // 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) => {
-            // Update loading state based on service state
-            // Use type guard to check if snapshot has 'value' property
-            if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
-                const isIdle = snapshot.value === 'idle';
-                setIsLoading(!isIdle);
-                // Clear error if service is in idle state
-                if (isIdle) {
-                    setError(null);
-                }
+            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);
@@ -628,13 +582,109 @@ function useItemProperty(arg1, arg2) {
         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('./index-DPll6EAp.js').then(function (n) { return n.aW; });
+            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 [properties, setProperties] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
     const isClientReady = useIsClientReady();
-    const subscriptionsRef = useRef(new Map());
-    const loadingPropertiesRef = useRef(new Set());
+    const queryClient = useQueryClient();
     const previousTableDataRef = useRef(undefined);
     // Determine which lookup mode we're in based on arguments
     const lookupMode = useMemo(() => {
@@ -670,6 +720,13 @@ function useItemProperties(arg1) {
             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
@@ -721,20 +778,6 @@ function useItemProperties(arg1) {
         return query;
     }, [isClientReady, seedLocalId, seedUid]);
     const rawPropertiesTableData = useLiveQuery(propertiesQuery);
-    // Debug logging for rawPropertiesTableData
-    useEffect(() => {
-        if (rawPropertiesTableData !== undefined) {
-            propertiesLogger(`[useItemProperties] rawPropertiesTableData updated:`, {
-                length: rawPropertiesTableData?.length || 0,
-                isUndefined: rawPropertiesTableData === undefined,
-                isArray: Array.isArray(rawPropertiesTableData),
-                firstRecord: rawPropertiesTableData?.[0] || null,
-            });
-        }
-        else {
-            propertiesLogger('[useItemProperties] rawPropertiesTableData is undefined (query not executed yet)');
-        }
-    }, [rawPropertiesTableData]);
     // Filter for latest records (one per propertyName) in JavaScript
     const propertiesTableData = useMemo(() => {
         if (!rawPropertiesTableData || rawPropertiesTableData.length === 0) {
@@ -760,358 +803,131 @@ function useItemProperties(arg1) {
         }
         return Array.from(latestByProperty.values());
     }, [rawPropertiesTableData]);
-    const fetchItemProperties = useCallback(async () => {
-        if (!seedLocalId && !seedUid) {
-            propertiesLogger('[useItemProperties] fetchItemProperties: no identifiers, clearing properties');
-            setProperties([]);
-            setIsLoading(false);
-            setError(null);
+    // Invalidate when metadata table data actually changes so useQuery refetches
+    useEffect(() => {
+        if (!isClientReady || (!seedLocalId && !seedUid) || propertiesTableData === undefined)
             return;
-        }
-        // Don't fetch if propertiesTableData is not available yet
-        if (propertiesTableData === undefined) {
-            propertiesLogger('[useItemProperties] fetchItemProperties: propertiesTableData is undefined, skipping');
+        // 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 });
         }
-        propertiesLogger(`[useItemProperties] fetchItemProperties: starting with ${propertiesTableData?.length || 0} records from table`);
-        try {
-            setIsLoading(true);
-            setError(null);
-            const db = BaseDb.getAppDb();
-            if (!db) {
-                propertiesLogger('[useItemProperties] fetchItemProperties: no db available');
-                setProperties([]);
-                setIsLoading(false);
-                return;
-            }
-            // Get modelName from metadata records or from seeds table
-            let modelName;
-            if (propertiesTableData && propertiesTableData.length > 0) {
-                const firstProperty = propertiesTableData[0];
-                if (firstProperty.modelType) {
-                    modelName = startCase(firstProperty.modelType);
-                }
-            }
-            // If we don't have modelName from metadata, try to get it from seeds table
-            if (!modelName) {
-                const seedRecords = await db
-                    .select({ type: seeds.type })
-                    .from(seeds)
-                    .where(seedUid ? eq(seeds.uid, seedUid) : eq(seeds.localId, seedLocalId))
-                    .limit(1);
-                if (seedRecords.length > 0 && seedRecords[0].type) {
-                    modelName = startCase(seedRecords[0].type);
-                }
-            }
-            // Get all ModelProperties for this Model
-            const modelProperties = [];
-            if (modelName) {
-                try {
-                    const { Model } = await import('./json-I3vJhXo8.js').then(function (n) { return n.aS; });
-                    const model = await Model.getByNameAsync(modelName);
-                    if (model && model.properties) {
-                        for (const modelProperty of model.properties) {
-                            if (modelProperty.name) {
-                                modelProperties.push(modelProperty.name);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    propertiesLogger(`[useItemProperties] Error getting ModelProperties for ${modelName}:`, error);
-                    // Continue without ModelProperties - we'll still return properties from metadata
-                }
-            }
-            // Create a Set of property names that have metadata records
-            const propertiesWithMetadata = new Set();
-            if (propertiesTableData) {
-                for (const dbProperty of propertiesTableData) {
-                    if (dbProperty.propertyName) {
-                        propertiesWithMetadata.add(dbProperty.propertyName);
-                    }
-                }
-            }
-            const _itemProperties = [];
-            // First, create ItemProperty instances for properties that have metadata records
-            if (propertiesTableData && propertiesTableData.length > 0) {
-                for (const dbProperty of propertiesTableData) {
-                    if (!dbProperty.propertyName) {
-                        continue;
-                    }
-                    try {
-                        const itemProperty = await ItemProperty.find({
-                            propertyName: dbProperty.propertyName,
-                            seedLocalId: dbProperty.seedLocalId || undefined,
-                            seedUid: dbProperty.seedUid || undefined,
-                        });
-                        if (itemProperty) {
-                            _itemProperties.push(itemProperty);
-                        }
-                    }
-                    catch (error) {
-                        logger$1(`[useItemProperties] Error creating ItemProperty for ${dbProperty.propertyName}:`, error);
-                        // Continue with other properties even if one fails
-                    }
-                }
-            }
-            // Then, create ItemProperty instances for ModelProperties that don't have metadata records
-            if (modelName && modelProperties.length > 0) {
-                const resolvedSeedLocalId = propertiesTableData && propertiesTableData.length > 0
-                    ? propertiesTableData[0].seedLocalId || seedLocalId
-                    : seedLocalId;
-                const resolvedSeedUid = propertiesTableData && propertiesTableData.length > 0
-                    ? propertiesTableData[0].seedUid || seedUid
-                    : seedUid;
-                for (const propertyName of modelProperties) {
-                    // Skip if we already have a metadata record for this property
-                    if (propertiesWithMetadata.has(propertyName)) {
-                        continue;
-                    }
-                    try {
-                        // Create ItemProperty with empty value for properties without metadata records
-                        const itemProperty = ItemProperty.create({
-                            propertyName,
-                            modelName,
-                            seedLocalId: resolvedSeedLocalId || undefined,
-                            seedUid: resolvedSeedUid || undefined,
-                            propertyValue: null,
-                        });
-                        if (itemProperty) {
-                            _itemProperties.push(itemProperty);
-                        }
-                    }
-                    catch (error) {
-                        logger$1(`[useItemProperties] Error creating ItemProperty for missing property ${propertyName}:`, error);
-                        // Continue with other properties even if one fails
-                    }
-                }
-            }
-            // Also add system properties like 'createdAt' if they don't exist
-            // Get createdAt from seeds table
-            if (seedLocalId || seedUid) {
-                const seedRecords = await db
-                    .select({ createdAt: seeds.createdAt })
-                    .from(seeds)
-                    .where(seedUid ? eq(seeds.uid, seedUid) : eq(seeds.localId, seedLocalId))
-                    .limit(1);
-                if (seedRecords.length > 0 && seedRecords[0].createdAt) {
-                    const createdAtPropertyName = 'createdAt';
-                    const hasCreatedAtProperty = _itemProperties.some(p => p.propertyName === createdAtPropertyName);
-                    if (!hasCreatedAtProperty && modelName) {
-                        try {
-                            const resolvedSeedLocalId = propertiesTableData && propertiesTableData.length > 0
-                                ? propertiesTableData[0].seedLocalId || seedLocalId
-                                : seedLocalId;
-                            const resolvedSeedUid = propertiesTableData && propertiesTableData.length > 0
-                                ? propertiesTableData[0].seedUid || seedUid
-                                : seedUid;
-                            const createdAtProperty = ItemProperty.create({
-                                propertyName: createdAtPropertyName,
-                                modelName,
-                                seedLocalId: resolvedSeedLocalId || undefined,
-                                seedUid: resolvedSeedUid || undefined,
-                                propertyValue: seedRecords[0].createdAt.toString(),
-                            });
-                            if (createdAtProperty) {
-                                _itemProperties.push(createdAtProperty);
-                            }
-                        }
-                        catch (error) {
-                            logger$1(`[useItemProperties] Error creating createdAt ItemProperty:`, error);
-                        }
-                    }
-                }
-            }
-            // Filter out properties that are ready (idle state) vs still loading
-            const readyProperties = [];
-            const loadingPropertiesList = [];
-            // Clear previous loading set
-            loadingPropertiesRef.current.clear();
-            for (const property of _itemProperties) {
-                const snapshot = property.getService().getSnapshot();
-                // Use type guard to check if snapshot has 'value' property
-                const isIdle = snapshot && typeof snapshot === 'object' && 'value' in snapshot && snapshot.value === 'idle';
-                if (isIdle) {
-                    // Property is ready
-                    readyProperties.push(property);
-                }
-                else {
-                    // Property is still loading - subscribe to state changes
-                    loadingPropertiesList.push(property);
-                    loadingPropertiesRef.current.add(property);
-                    // Clean up any existing subscription for this property
-                    const existingSub = subscriptionsRef.current.get(property);
-                    if (existingSub) {
-                        existingSub.unsubscribe();
-                    }
-                    // Subscribe to state changes
-                    const subscription = property.getService().subscribe((snapshot) => {
-                        // Use type guard to check if snapshot has 'value' property
-                        if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
-                            const isIdle = snapshot.value === 'idle';
-                            if (isIdle) {
-                                // Property is now ready - update state
-                                setProperties(prev => {
-                                    // Check if property is already in the list (by propertyName and seedLocalId/seedUid)
-                                    const exists = prev.some(p => p.propertyName === property.propertyName &&
-                                        (p.seedLocalId === property.seedLocalId || p.seedUid === property.seedUid));
-                                    if (exists) {
-                                        return prev;
-                                    }
-                                    // Add the newly ready property
-                                    return [...prev, property];
-                                });
-                                // Remove from loading set and clean up subscription
-                                loadingPropertiesRef.current.delete(property);
-                                subscription.unsubscribe();
-                                subscriptionsRef.current.delete(property);
-                                // Update loading state based on remaining loading properties
-                                setIsLoading(loadingPropertiesRef.current.size > 0);
-                            }
-                            else if (snapshot.value === 'error') {
-                                // Property failed to load - clean up subscription
-                                loadingPropertiesRef.current.delete(property);
-                                subscription.unsubscribe();
-                                subscriptionsRef.current.delete(property);
-                                // Update loading state based on remaining loading properties
-                                setIsLoading(loadingPropertiesRef.current.size > 0);
-                            }
-                        }
-                    });
-                    subscriptionsRef.current.set(property, subscription);
-                }
-            }
-            // Set initial ready properties
-            setProperties(readyProperties);
-            setError(null);
-            setIsLoading(loadingPropertiesList.length > 0); // Still loading if any properties are loading
-        }
-        catch (error) {
-            setError(error);
-            setIsLoading(false);
-        }
-    }, [seedLocalId, seedUid, propertiesTableData]);
-    // Reset previous table data ref when identifiers change
+    }, [isClientReady, propertiesTableData, properties, seedLocalId, seedUid, queryClient, itemPropertiesQueryKey]);
     useEffect(() => {
         previousTableDataRef.current = undefined;
     }, [seedLocalId, seedUid]);
-    // Fetch item properties when dbModelId becomes available
-    useEffect(() => {
-        if (!isClientReady) {
-            return;
+    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;
         }
-        if (!seedLocalId && !seedUid) {
-            setProperties([]);
+        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);
-            setError(null);
-            previousTableDataRef.current = undefined;
-            return;
-        }
-        // Wait for propertiesTableData to be available before initial fetch
-        // (it may be undefined initially while the query is starting)
-        if (propertiesTableData === undefined) {
-            return;
-        }
-        // Initial fetch when client is ready and propertiesTableData is available
-        fetchItemProperties();
-    }, [isClientReady, seedLocalId, seedUid, fetchItemProperties, propertiesTableData]);
-    // Refetch item properties when table data actually changes (not just reference)
-    useEffect(() => {
-        if (!isClientReady || (!seedLocalId && !seedUid)) {
-            return;
+            return undefined;
         }
-        // If propertiesTableData is undefined, the query hasn't started yet - wait for it
-        if (propertiesTableData === undefined) {
-            return;
-        }
-        // Create a stable string representation of the table data for comparison
-        const tableDataString = JSON.stringify(propertiesTableData.map(p => ({
-            propertyName: p.propertyName,
-            seedLocalId: p.seedLocalId,
-            seedUid: p.seedUid,
-        })).sort((a, b) => (a.propertyName || '').localeCompare(b.propertyName || '')));
-        // Skip if table data hasn't actually changed
-        if (previousTableDataRef.current === tableDataString) {
-            return;
-        }
-        previousTableDataRef.current = tableDataString;
-        // Extract identifying information from current properties in state
-        const currentPropertiesSet = new Set();
-        for (const prop of properties) {
-            const key = `${prop.propertyName}:${prop.seedLocalId || prop.seedUid}`;
-            currentPropertiesSet.add(key);
-        }
-        // Extract identifying information from propertiesTableData
-        const tableDataPropertiesSet = new Set();
-        for (const dbProperty of propertiesTableData) {
-            if (dbProperty.propertyName) {
-                const key = `${dbProperty.propertyName}:${dbProperty.seedLocalId || dbProperty.seedUid}`;
-                tableDataPropertiesSet.add(key);
+        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);
             }
-        }
-        // Compare sets to detect changes
-        // If tableDataPropertiesSet is empty but we have properties, or vice versa, that's a change
-        // If both are empty, skip (no data yet) - UNLESS this is the first time we're seeing empty data
-        // If both have data and match, skip
-        const setsAreEqual = currentPropertiesSet.size === tableDataPropertiesSet.size &&
-            currentPropertiesSet.size > 0 &&
-            [...currentPropertiesSet].every(id => tableDataPropertiesSet.has(id));
-        if (setsAreEqual) {
-            // Properties in state match table data, skip refetch
-            return;
-        }
-        // Always refetch if table data has properties (even if we don't have any yet)
-        // This handles the case where propertiesTableData changes from empty to having data
-        if (tableDataPropertiesSet.size > 0) {
-            // Properties have changed or data has arrived, fetch updated properties
-            fetchItemProperties();
-            return;
-        }
-        // If table data is empty but we have properties, that's also a change (properties were removed)
-        if (currentPropertiesSet.size > 0 && tableDataPropertiesSet.size === 0) {
-            fetchItemProperties();
-            return;
-        }
-        // If both are empty, we've already tried to fetch (in the first useEffect)
-        // and got empty results, so skip refetching until data arrives
-        // (the change detection above will handle when data arrives)
-    }, [isClientReady, propertiesTableData, properties, fetchItemProperties, seedLocalId, seedUid]);
-    // Cleanup subscriptions for properties that are no longer in the list
-    useEffect(() => {
-        const currentPropertyKeys = new Set();
-        for (const prop of properties) {
-            const key = `${prop.propertyName}:${prop.seedLocalId || prop.seedUid}`;
-            currentPropertyKeys.add(key);
-        }
-        // Clean up subscriptions for properties that are no longer in the list
-        for (const [property, subscription] of subscriptionsRef.current.entries()) {
-            const key = `${property.propertyName}:${property.seedLocalId || property.seedUid}`;
-            if (!currentPropertyKeys.has(key)) {
-                // Property is no longer in the list, clean up subscription
-                subscription.unsubscribe();
-                subscriptionsRef.current.delete(property);
-                loadingPropertiesRef.current.delete(property);
+            if (snapshot?.value === 'idle') {
+                setError(null);
+                setIsLoading(false);
             }
-        }
-        // Update loading state based on remaining loading properties
-        if (loadingPropertiesRef.current.size === 0 && isLoading) {
-            setIsLoading(false);
-        }
-    }, [properties, isLoading]);
-    // Cleanup all subscriptions on unmount
+        });
+        subscriptionRef.current = subscription;
+        return instance;
+    }, []);
     useEffect(() => {
         return () => {
-            subscriptionsRef.current.forEach(sub => sub.unsubscribe());
-            subscriptionsRef.current.clear();
-            loadingPropertiesRef.current.clear();
+            subscriptionRef.current?.unsubscribe();
+            subscriptionRef.current = undefined;
         };
     }, []);
     return {
-        properties,
+        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');
 
@@ -1137,23 +953,31 @@ const useSchema = (schemaIdentifier) => {
         setIsLoading(true);
         setError(null);
         try {
-            const schemaInstance = Schema.create(identifier);
+            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';
-            setIsLoading(!isIdle);
             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';
-                setIsLoading(!isIdle);
                 if (isIdle) {
+                    flushSync(() => setIsLoading(false));
                     setError(null);
                 }
+                else {
+                    setIsLoading(true);
+                }
             });
         }
         catch (error) {
@@ -1197,17 +1021,19 @@ const useSchema = (schemaIdentifier) => {
         error,
     };
 };
+const SEED_SCHEMAS_QUERY_KEY = ['seed', 'schemas'];
 const useSchemas = () => {
-    const [schemas$1, setSchemas] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
     const isClientReady = useIsClientReady();
-    const subscriptionsRef = useRef(new Map());
-    const loadingSchemasRef = useRef(new Set());
+    const queryClient = useQueryClient();
     const previousSchemasTableDataRef = useRef(undefined);
-    const schemasRef = useRef([]); // Track schemas for comparison without triggering effects
-    // Watch the schemas table for changes
-    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
+    const 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)
@@ -1215,131 +1041,17 @@ const useSchemas = () => {
         return db.select().from(schemas).orderBy(schemas.name, desc(schemas.version));
     }, [db, isClientReady]);
     const schemasTableData = useLiveQuery(schemasQuery);
-    const fetchSchemas = useCallback(async () => {
-        try {
-            setIsLoading(true);
-            const timestamp = Date.now();
-            // Also check what's in the database directly before calling Schema.all()
-            const db = BaseDb.getAppDb();
-            if (db) {
-                const directCheck = await db.select().from(schemas).orderBy(schemas.name, desc(schemas.version));
-            }
-            const allSchemas = await Schema.all();
-            // Filter out schemas without an id and subscribe to state changes
-            const readySchemas = [];
-            const loadingSchemasList = [];
-            // Clear previous loading set
-            loadingSchemasRef.current.clear();
-            for (const schema of allSchemas) {
-                const snapshot = schema.getService().getSnapshot();
-                const hasId = !!schema.id;
-                const isIdle = snapshot.value === 'idle';
-                if (hasId && isIdle) {
-                    // Schema is ready
-                    readySchemas.push(schema);
-                }
-                else {
-                    // Schema is still loading - subscribe to state changes
-                    loadingSchemasList.push(schema);
-                    loadingSchemasRef.current.add(schema);
-                    // Clean up any existing subscription for this schema
-                    const existingSub = subscriptionsRef.current.get(schema);
-                    if (existingSub) {
-                        existingSub.unsubscribe();
-                    }
-                    // Subscribe to state changes
-                    const subscription = schema.getService().subscribe((snapshot) => {
-                        const hasId = !!schema.id;
-                        const isIdle = snapshot.value === 'idle';
-                        if (hasId && isIdle) {
-                            // Schema is now ready - update state
-                            setSchemas(prev => {
-                                // Check if schema is already in the list (by id)
-                                if (schema.id && prev.some(s => s.id === schema.id)) {
-                                    return prev;
-                                }
-                                // Add the newly ready schema
-                                const updated = [...prev, schema].sort((a, b) => {
-                                    // Sort by name for consistency
-                                    const nameA = a.metadata?.name || '';
-                                    const nameB = b.metadata?.name || '';
-                                    return nameA.localeCompare(nameB);
-                                });
-                                schemasRef.current = updated; // Update ref for comparison
-                                return updated;
-                            });
-                            // Remove from loading set and clean up subscription
-                            loadingSchemasRef.current.delete(schema);
-                            subscription.unsubscribe();
-                            subscriptionsRef.current.delete(schema);
-                            // Update loading state based on remaining loading schemas
-                            setIsLoading(loadingSchemasRef.current.size > 0);
-                        }
-                        else if (snapshot.value === 'error') {
-                            // Schema failed to load - clean up subscription
-                            loadingSchemasRef.current.delete(schema);
-                            subscription.unsubscribe();
-                            subscriptionsRef.current.delete(schema);
-                            // Update loading state based on remaining loading schemas
-                            setIsLoading(loadingSchemasRef.current.size > 0);
-                        }
-                    });
-                    subscriptionsRef.current.set(schema, subscription);
-                }
-            }
-            // Set initial ready schemas
-            setSchemas(readySchemas);
-            schemasRef.current = readySchemas; // Update ref for comparison
-            setError(null);
-            setIsLoading(loadingSchemasList.length > 0); // Still loading if any schemas are loading
-        }
-        catch (error) {
-            setError(error);
-            setIsLoading(false);
-        }
-    }, []); // Remove schemasTableData dependency - we'll call fetchSchemas explicitly when table data changes
-    // Cleanup subscriptions for schemas that are no longer in the list
-    useEffect(() => {
-        const currentSchemaIds = new Set(schemas$1.map(s => s.id).filter(Boolean));
-        // Clean up subscriptions for schemas that are no longer in the list
-        for (const [schema, subscription] of subscriptionsRef.current.entries()) {
-            if (schema.id && !currentSchemaIds.has(schema.id)) {
-                // Schema is no longer in the list, clean up subscription
-                subscription.unsubscribe();
-                subscriptionsRef.current.delete(schema);
-                loadingSchemasRef.current.delete(schema);
-            }
-        }
-        // Update loading state based on remaining loading schemas
-        if (loadingSchemasRef.current.size === 0 && isLoading) {
-            setIsLoading(false);
-        }
-    }, [schemas$1, isLoading]);
-    // Fetch schemas on initial mount when client is ready
-    useEffect(() => {
-        if (!isClientReady) {
-            return;
-        }
-        // Initial fetch when client becomes ready
-        fetchSchemas();
-    }, [isClientReady, fetchSchemas]);
-    // Refetch schemas when table data actually changes (not just reference)
     useEffect(() => {
         if (!isClientReady || !schemasTableData) {
             return;
         }
-        // Check if schemasTableData actually changed by comparing with previous value
         const prevData = previousSchemasTableDataRef.current;
         const prevDataJson = prevData ? JSON.stringify(prevData) : 'undefined';
         const currDataJson = schemasTableData ? JSON.stringify(schemasTableData) : 'undefined';
         if (prevDataJson === currDataJson && prevData !== undefined) {
-            // Data hasn't actually changed, skip refetch
             return;
         }
-        // Update ref with current data
         previousSchemasTableDataRef.current = schemasTableData;
-        // Extract identifying information from current schemas in state (using ref to avoid dependency)
-        // Use schemaFileId if available, otherwise fall back to name+version
         const currentSchemasSet = new Set();
         for (const schema of schemasRef.current) {
             const schemaFileId = schema.id || schema.schemaFileId;
@@ -1347,7 +1059,6 @@ const useSchemas = () => {
                 currentSchemasSet.add(schemaFileId);
             }
             else {
-                // Fallback to name+version if schemaFileId not available
                 const name = schema.metadata?.name;
                 const version = schema.version;
                 if (name && version !== undefined) {
@@ -1355,73 +1066,109 @@ const useSchemas = () => {
                 }
             }
         }
-        // Extract identifying information from schemasTableData
         const tableDataSchemasSet = new Set();
         for (const dbSchema of schemasTableData) {
-            // Skip internal Seed Protocol schema for comparison (it's filtered out by Schema.all())
-            if (dbSchema.name === 'Seed Protocol') {
+            if (dbSchema.name === 'Seed Protocol')
                 continue;
-            }
             if (dbSchema.schemaFileId) {
                 tableDataSchemasSet.add(dbSchema.schemaFileId);
             }
-            else {
-                // Fallback to name+version if schemaFileId not available
-                if (dbSchema.name && dbSchema.version !== undefined) {
-                    tableDataSchemasSet.add(`${dbSchema.name}:${dbSchema.version}`);
-                }
+            else if (dbSchema.name != null && dbSchema.version !== undefined) {
+                tableDataSchemasSet.add(`${dbSchema.name}:${dbSchema.version}`);
             }
         }
-        // Compare sets to detect changes
         const setsAreEqual = currentSchemasSet.size === tableDataSchemasSet.size &&
-            [...currentSchemasSet].every(id => tableDataSchemasSet.has(id));
-        if (setsAreEqual) {
-            // Schemas in state match table data, skip refetch
-            return;
+            [...currentSchemasSet].every((id) => tableDataSchemasSet.has(id));
+        if (!setsAreEqual) {
+            queryClient.invalidateQueries({ queryKey: SEED_SCHEMAS_QUERY_KEY });
         }
-        // Schemas have changed, fetch updated schemas
-        fetchSchemas();
-    }, [isClientReady, schemasTableData, fetchSchemas]); // Removed 'schemas' from dependencies to break the loop
-    // Cleanup all subscriptions on unmount
-    useEffect(() => {
-        return () => {
-            subscriptionsRef.current.forEach(sub => sub.unsubscribe());
-            subscriptionsRef.current.clear();
-            loadingSchemasRef.current.clear();
-        };
-    }, []);
+    }, [isClientReady, schemasTableData, queryClient]);
     return {
         schemas: schemas$1,
         isLoading,
-        error,
+        error: queryError,
     };
 };
 const useCreateSchema = () => {
-    const errorRef = useRef(null);
     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);
-        const schema = Schema.create(schemaName);
+        subscriptionRef.current?.unsubscribe();
+        subscriptionRef.current = null;
+        const schema = Schema.create(schemaName, {
+            waitForReady: false,
+        });
         const subscription = schema.getService().subscribe((snapshot) => {
             if (snapshot.value === 'error') {
-                errorRef.current = new Error('Failed to create schema');
+                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;
-    }, [setIsLoading]);
+    }, []);
     useEffect(() => {
-        setError(errorRef.current);
-    }, [errorRef.current]);
+        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 = () => {
@@ -1454,7 +1201,9 @@ const useAllSchemaVersions = () => {
                 }
                 else {
                     // Create new instance
-                    const schema = Schema.create(schemaName);
+                    const schema = Schema.create(schemaName, {
+                        waitForReady: false,
+                    });
                     currentInstances.set(schemaName, schema);
                 }
             }
@@ -1498,18 +1247,79 @@ const useAllSchemaVersions = () => {
  * @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 [models$1, setModels] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
     const isClientReady = useIsClientReady();
-    // Watch the models table for changes via model_schemas join table
-    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
-    const db = isClientReady ? BaseDb.getAppDb() : null;
-    const modelsQuery = useMemo(() => {
-        if (!db || !schemaId)
+    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 db
+        return currentDb
             .select({
             modelFileId: models.schemaFileId,
             modelName: models.name,
@@ -1518,113 +1328,59 @@ const useModels = (schemaId) => {
             .innerJoin(modelSchemas, eq(schemas.id, modelSchemas.schemaId))
             .innerJoin(models, eq(modelSchemas.modelId, models.id))
             .where(or(eq(schemas.schemaFileId, schemaId), eq(schemas.name, schemaId)));
-    }, [db, isClientReady, schemaId]);
+    }
+    const 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);
-    const fetchModels = useCallback(async () => {
-        if (!schemaId) {
-            setModels([]);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        try {
-            setIsLoading(true);
-            const timestamp = Date.now();
-            console.log(`[useModels.fetchModels] [${timestamp}] Starting fetch, modelsTableData count:`, modelsTableData?.length, 'models:', modelsTableData?.map(m => m.modelName));
-            // Use Model.createBySchemaId to get Model instances (handles caching)
-            const modelInstances = await Model.createBySchemaId(schemaId);
-            console.log(`[useModels.fetchModels] [${timestamp}] Model.createBySchemaId() returned:`, modelInstances.length, 'models:', modelInstances.map((m) => m.modelName));
-            setModels(prev => {
-                // Check if anything actually changed
-                if (prev.length !== modelInstances.length) {
-                    console.log('[useModels] Length changed:', prev.length, '->', modelInstances.length);
-                    return modelInstances;
-                }
-                // Compare by modelFileId (schemaFileId) or name
-                const hasChanged = modelInstances.some((model, i) => !prev[i] ||
-                    model.id !== prev[i].id ||
-                    model.modelName !== prev[i].modelName);
-                if (hasChanged) {
-                    console.log('[useModels] Models changed (by ID or name)');
-                }
-                else {
-                    console.log('[useModels] No changes detected');
-                }
-                return hasChanged ? modelInstances : prev;
-            });
-            setError(null);
-            setIsLoading(false);
-        }
-        catch (error) {
-            setError(error);
-            setIsLoading(false);
-        }
-    }, [schemaId]);
-    // Fetch models on initial mount when client is ready
     useEffect(() => {
-        if (!isClientReady) {
+        if (!isClientReady || !modelsTableData || !schemaId)
             return;
-        }
-        // Initial fetch when client becomes ready
-        fetchModels();
-    }, [isClientReady, fetchModels]);
-    // Refetch models when table data actually changes (not just reference)
-    useEffect(() => {
-        if (!isClientReady || !modelsTableData || !schemaId) {
-            return;
-        }
-        // Extract identifying information from current models in state
-        // Use modelFileId (schemaFileId) if available, otherwise fall back to name
         const currentModelsSet = new Set();
-        for (const model of models$1) {
+        for (const model of modelsRef.current) {
             const modelFileId = model.id || model.modelFileId;
-            if (modelFileId) {
+            if (modelFileId)
                 currentModelsSet.add(modelFileId);
-            }
-            else {
-                // Fallback to name if modelFileId not available
-                const name = model.modelName;
-                if (name) {
-                    currentModelsSet.add(name);
-                }
-            }
+            else if (model.modelName)
+                currentModelsSet.add(model.modelName);
         }
-        // Extract identifying information from modelsTableData
         const tableDataModelsSet = new Set();
         for (const dbModel of modelsTableData) {
-            if (dbModel.modelFileId) {
+            if (dbModel.modelFileId)
                 tableDataModelsSet.add(dbModel.modelFileId);
-            }
-            else {
-                // Fallback to name if modelFileId not available
-                if (dbModel.modelName) {
-                    tableDataModelsSet.add(dbModel.modelName);
-                }
-            }
+            else if (dbModel.modelName)
+                tableDataModelsSet.add(dbModel.modelName);
         }
-        // Compare sets to detect changes
         const setsAreEqual = currentModelsSet.size === tableDataModelsSet.size &&
-            [...currentModelsSet].every(id => tableDataModelsSet.has(id));
-        if (setsAreEqual) {
-            // Models in state match table data, skip refetch
-            return;
-        }
-        // Models have changed - log for debugging
-        console.log('[useModels] modelsTableData changed:', {
-            currentCount: currentModelsSet.size,
-            tableDataCount: tableDataModelsSet.size,
-            currentIds: Array.from(currentModelsSet),
-            tableDataIds: Array.from(tableDataModelsSet),
-            tableDataNames: modelsTableData.map(m => m.modelName),
-            tableDataFull: modelsTableData.map(m => ({ name: m.modelName, modelFileId: m.modelFileId })),
-        });
-        // Models have changed, fetch updated models
-        fetchModels();
-    }, [isClientReady, modelsTableData, models$1, fetchModels, schemaId]);
+            [...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: models$1,
+        models: displayModels,
         isLoading,
-        error,
+        error: queryError,
     };
 };
 /**
@@ -1754,6 +1510,89 @@ const useModel = (schemaIdOrModelId, modelName) => {
         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');
 /**
@@ -1773,7 +1612,7 @@ const useModelProperties = (schemaIdOrModelId, modelName) => {
     // Use useModel to handle both lookup patterns (by ID or by schemaId + modelName)
     const { model } = useModel(schemaIdOrModelId, modelName);
     // Determine the modelName for use in getPropertySchema
-    const modelNameForProperty = useMemo(() => {
+    useMemo(() => {
         if (!model)
             return undefined;
         try {
@@ -1783,24 +1622,27 @@ const useModelProperties = (schemaIdOrModelId, modelName) => {
             return undefined;
         }
     }, [model]);
-    const [modelProperties, setModelProperties] = useState([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
     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; // _dbId is the database integer ID
+            return context._dbId;
         }
         catch {
             return null;
         }
     }, [model]);
-    // Watch the properties table for changes
-    // Memoize the query so it's stable across renders - this is critical for distinctUntilChanged to work
+    const 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)
@@ -1816,159 +1658,54 @@ const useModelProperties = (schemaIdOrModelId, modelName) => {
             .where(eq(properties.modelId, dbModelId));
     }, [db, isClientReady, dbModelId]);
     const propertiesTableData = useLiveQuery(propertiesQuery);
-    const fetchModelProperties = useCallback(async () => {
-        if (!modelNameForProperty || !model || !schemaIdOrModelId) {
-            setModelProperties([]);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        try {
-            setIsLoading(true);
-            const timestamp = Date.now();
-            console.log(`[useModelProperties.fetchModelProperties] [${timestamp}] Starting fetch, propertiesTableData count:`, propertiesTableData?.length, 'properties:', propertiesTableData?.map(p => p.name));
-            // Use propertiesTableData (database state) as the source of truth instead of model.properties (schema file)
-            // This ensures we get the current names even after property renames
-            if (!propertiesTableData || propertiesTableData.length === 0) {
-                setModelProperties([]);
-                setError(null);
-                setIsLoading(false);
-                return;
-            }
-            const _modelProperties = [];
-            // Iterate over propertiesTableData and create ModelProperty instances by schemaFileId
-            // This works even when property names have changed, since schemaFileId is stable
-            for (const dbProperty of propertiesTableData) {
-                if (!dbProperty.schemaFileId) {
-                    // If no schemaFileId, fall back to name-based lookup (for backwards compatibility)
-                    const modelPropertyData = await getPropertySchema(modelNameForProperty, dbProperty.name);
-                    if (modelPropertyData) {
-                        const modelProperty = ModelProperty.create({
-                            ...modelPropertyData,
-                        });
-                        _modelProperties.push(modelProperty);
-                    }
-                }
-                else {
-                    // Use createById to get/create the instance by schemaFileId (stable across renames)
-                    const modelProperty = await ModelProperty.createById(dbProperty.schemaFileId);
-                    if (modelProperty) {
-                        _modelProperties.push(modelProperty);
-                    }
-                }
-            }
-            console.log(`[useModelProperties.fetchModelProperties] [${timestamp}] Created ${_modelProperties.length} ModelProperty instances`);
-            setModelProperties(prev => {
-                // Check if anything actually changed
-                if (prev.length !== _modelProperties.length) {
-                    console.log('[useModelProperties] Length changed:', prev.length, '->', _modelProperties.length);
-                    return _modelProperties;
-                }
-                // Compare by property name or schemaFileId
-                const hasChanged = _modelProperties.some((prop, i) => {
-                    if (!prev[i])
-                        return true;
-                    const prevContext = prev[i]._getSnapshotContext();
-                    const currContext = prop._getSnapshotContext();
-                    const prevId = prevContext?.id;
-                    const currId = currContext?.id;
-                    const prevName = prev[i].name;
-                    const currName = prop.name;
-                    return prevId !== currId || prevName !== currName;
-                });
-                if (hasChanged) {
-                    console.log('[useModelProperties] Properties changed (by ID or name)');
-                }
-                else {
-                    console.log('[useModelProperties] No changes detected');
-                }
-                return hasChanged ? _modelProperties : prev;
-            });
-            setError(null);
-            setIsLoading(false);
-        }
-        catch (error) {
-            setError(error);
-            setIsLoading(false);
-        }
-    }, [modelNameForProperty, model, propertiesTableData, schemaIdOrModelId]);
-    // Fetch model properties when dbModelId becomes available (model has finished loading)
-    // This ensures we wait for the model to be fully loaded before trying to fetch properties
+    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 (!isClientReady || !dbModelId || !modelNameForProperty || !model || !schemaIdOrModelId) {
+        if (!modelId || modelProperties.length > 0 || !queryClient || !modelPropertiesQueryKey)
             return;
-        }
-        // Wait for propertiesTableData to be available before initial fetch
-        // (it may be undefined initially while the query is starting)
-        if (propertiesTableData === undefined) {
-            return;
-        }
-        // Initial fetch when model is ready and dbModelId is available
-        fetchModelProperties();
-    }, [isClientReady, dbModelId, fetchModelProperties, modelNameForProperty, model, schemaIdOrModelId, propertiesTableData]);
-    // Refetch model properties when table data actually changes (not just reference)
+        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 || !modelNameForProperty || !model || !schemaIdOrModelId || !dbModelId) {
-            return;
-        }
-        // If propertiesTableData is undefined, the query hasn't started yet - wait for it
-        if (propertiesTableData === undefined) {
+        if (!isClientReady || !model?.id || !propertiesTableData || !modelPropertiesQueryKey)
             return;
-        }
-        // Extract identifying information from current properties in state
         const currentPropertiesSet = new Set();
-        for (const prop of modelProperties) {
+        for (const prop of modelPropertiesRef.current) {
             const context = prop._getSnapshotContext();
             const propertyFileId = context?.id;
-            if (propertyFileId) {
+            if (propertyFileId)
                 currentPropertiesSet.add(propertyFileId);
-            }
-            else {
-                // Fallback to name if propertyFileId not available
-                const name = prop.name;
-                if (name) {
-                    currentPropertiesSet.add(name);
-                }
-            }
+            else if (prop.name)
+                currentPropertiesSet.add(prop.name);
         }
-        // Extract identifying information from propertiesTableData
         const tableDataPropertiesSet = new Set();
         for (const dbProperty of propertiesTableData) {
-            if (dbProperty.schemaFileId) {
+            if (dbProperty.schemaFileId)
                 tableDataPropertiesSet.add(dbProperty.schemaFileId);
-            }
-            else {
-                // Fallback to name if schemaFileId not available
-                if (dbProperty.name) {
-                    tableDataPropertiesSet.add(dbProperty.name);
-                }
-            }
+            else if (dbProperty.name)
+                tableDataPropertiesSet.add(dbProperty.name);
         }
-        // Compare sets to detect changes
-        // If currentPropertiesSet is empty but tableDataPropertiesSet has data, that's a change
         const setsAreEqual = currentPropertiesSet.size === tableDataPropertiesSet.size &&
-            currentPropertiesSet.size > 0 &&
-            [...currentPropertiesSet].every(id => tableDataPropertiesSet.has(id));
-        if (setsAreEqual) {
-            // Properties in state match table data, skip refetch
-            return;
-        }
-        // Properties have changed - log for debugging
-        console.log('[useModelProperties] propertiesTableData changed:', {
-            currentCount: currentPropertiesSet.size,
-            tableDataCount: tableDataPropertiesSet.size,
-            currentIds: Array.from(currentPropertiesSet),
-            tableDataIds: Array.from(tableDataPropertiesSet),
-            tableDataNames: propertiesTableData.map(p => p.name),
-            tableDataFull: propertiesTableData.map(p => ({ name: p.name, schemaFileId: p.schemaFileId })),
-        });
-        // Properties have changed, fetch updated properties
-        fetchModelProperties();
-    }, [isClientReady, propertiesTableData, modelProperties, fetchModelProperties, modelNameForProperty, model, schemaIdOrModelId]);
+            (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,
+        error: queryError,
     };
 };
 /**
@@ -2098,13 +1835,13 @@ function useModelProperty(arg1, arg2, arg3) {
                 resolvedModelName = lookupMode.modelName;
             }
             if (propertyData && resolvedModelName) {
-                const createdProperty = ModelProperty.create({
-                    ...propertyData,
-                    modelName: 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);
                 });
-                setModelProperty(createdProperty);
-                setIsLoading(false);
-                setError(null);
             }
             else {
                 setModelProperty(undefined);
@@ -2129,9 +1866,12 @@ function useModelProperty(arg1, arg2, arg3) {
         }
         updateModelProperty();
     }, [shouldLoad, updateModelProperty]);
-    // Subscribe to service changes when modelProperty is available
+    // 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) {
+        if (!modelProperty || !shouldSubscribe) {
             return;
         }
         // Clean up previous subscription
@@ -2145,51 +1885,277 @@ function useModelProperty(arg1, arg2, arg3) {
             subscriptionRef.current?.unsubscribe();
             subscriptionRef.current = undefined;
         };
-    }, [modelProperty, updateModelProperty]);
+    }, [modelProperty, updateModelProperty, shouldSubscribe]);
     return {
         modelProperty,
         isLoading,
         error,
     };
 }
-
-const deleteItem = async ({ seedLocalId, seedUid }) => {
-    const appDb = BaseDb.getAppDb();
-    const conditions = [];
-    if (seedLocalId) {
-        conditions.push(eq(seeds.localId, seedLocalId));
-    }
-    if (seedUid) {
-        conditions.push(eq(seeds.uid, seedUid));
-    }
-    if (conditions.length === 0) {
-        return;
-    }
-    await appDb
-        .update(seeds)
-        .set({
-        _markedForDeletion: 1,
-    })
-        .where(or(...conditions));
+/**
+ * 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 [isDeletingItem, setIsDeletingItem] = useState(false);
+    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) {
+        if (!item)
             return;
+        setCurrentInstance(item);
+        await item.destroy();
+    }, []);
+    const resetError = useCallback(() => {
+        if (currentInstance) {
+            currentInstance.getService().send({ type: 'clearDestroyError' });
         }
-        setIsDeletingItem(true);
-        await deleteItem({ seedLocalId: item.seedLocalId });
-        setIsDeletingItem(false);
-    }, [isDeletingItem]);
-    useEffect(() => { }, []);
+    }, [currentInstance]);
     return {
         deleteItem: destroy,
-        isDeletingItem,
+        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',
@@ -2715,5 +2681,5 @@ const getFeedItemsBySchemaName = async (schemaName) => {
     return feedItems;
 };
 
-export { BaseEasClient as EasClient, Item, ItemProperty, Model, ModelProperty, Schema, getFeedItemsBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getPropertySchema, getSeedsBySchemaName, useAllSchemaVersions, useCreateItem, useCreateSchema, useDeleteItem, useItem, useItemProperties, useItemProperty, useItems, useModel, useModelProperties, useModelProperty, useModels, useSchema, useSchemas };
+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