@seedprotocol/sdk 0.4.14 → 0.4.16

package/dist/main.js

@@ -1,2242 +1,143 @@
 import 'reflect-metadata';
-import { ao as getClient, ap as ClientManagerState, j as BaseDb, x as Item, s as seeds, aq as getVersionData, ar as createNewItem, O as metadata, a6 as ItemProperty, a0 as schemas, as as loadAllSchemasFromDb, M as Model, u as models, U as modelSchemas, v as properties, at as getSchemaNameFromId, C as BaseFileManager, a7 as eventEmitter, l as getCorrectId } from './index-Dh_gxItx.js';
-export { z as BaseArweaveClient, aE as DEFAULT_ARWEAVE_GATEWAYS, aD as DEFAULT_ARWEAVE_HOST, G as EasClient, o as INTERNAL_DATA_TYPES, a as ModelPropertyDataTypes, aC as SeedModels, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, a8 as client, aI as createSchema, aF as getArweaveUrlForTransaction, q as getEasSchemaForItemProperty, az as getEasSchemaUidBySchemaName, ay as getItemPropertiesFromEas, ax as getItemVersionsFromEas, aw as getModelSchemasFromEas, aB as getSeedsBySchemaName, aA as getSeedsFromSchemaUids, aH as getUploadExecutor, ab as importJsonSchema, aK as listSchemas, ad as readJsonImportFile, aJ as readSchema, av as setSchemaUidForModel, au as setSchemaUidForSchemaDefinition, aG as setUploadExecutor, ae as transformImportToSchemaFile, ai as waitForEntityIdle } from './index-Dh_gxItx.js';
-import { g as getPropertySchema } from './property-CppuVi-i.js';
-import { ModelProperty } from './ModelProperty-D8d25NtC.js';
-import { S as Schema } from './Schema-CLlE7onI.js';
-export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './Schema-CLlE7onI.js';
-import React, { useState, useRef, useMemo, useEffect, useCallback } from 'react';
-import { flushSync } from 'react-dom';
-import { orderBy, startCase, debounce } from 'lodash-es';
-import debug from 'debug';
-import { useSelector } from '@xstate/react';
-import { or, isNull, eq, isNotNull, and, gt, desc } from 'drizzle-orm';
-import { useQueryClient, useQuery, QueryClient as QueryClient$1, QueryClientProvider } from '@tanstack/react-query';
-import 'pluralize';
-import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-DfQNbOpb.js';
-export { resolvePublishPayloadValues } from './getPublishPayload-BekDN5Ti.js';
+import { o as BaseDb, z as versions, a3 as metadata, s as seeds, C as parseListPropertyValueFromStorage, q as getCorrectId } from './index-uPXtq2cf.js';
+export { v as BaseArweaveClient, t as BaseFileManager, ai as ClientManagerState, aE as DEFAULT_ARWEAVE_GATEWAYS, aD as DEFAULT_ARWEAVE_HOST, $ as EasClient, t as FileManager, H as INTERNAL_DATA_TYPES, aq as ImageSize, r as Item, ar as ItemProperty, aj as MachineIds, M as Model, b as ModelPropertyDataTypes, ap as SEED_PROTOCOL_SCHEMA_NAME, aC as SeedModels, V as VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA, W as appState, a$ as client, ak as createNewItem, aT as createSchema, ag as eventEmitter, aA as generateId, aG as getAddressesForItemsFilter, aH as getArweaveUrlForTransaction, ah as getClient, Q as getEasSchemaForItemProperty, ax as getEasSchemaUidBySchemaName, p as getGetAdditionalSyncAddresses, aP as getGetPublisherForNewSeeds, aw as getItemPropertiesFromEas, av as getItemVersionsFromEas, am as getMetadataLatest, au as getModelSchemasFromEas, aR as getRevokeExecutor, aW as getSchemaNameFromId, az as getSeedsBySchemaName, ay as getSeedsFromSchemaUids, aJ as getUploadApiArweaveDataUrl, aN as getUploadExecutor, aK as getUploadPipelineTransactionStatus, al as getVersionData, aX as importJsonSchema, aV as listSchemas, an as loadAllSchemasFromDb, a5 as modelSchemas, a6 as modelUids, x as models, aI as normalizeUploadApiBaseUrl, y as properties, ao as propertyMachine, aa as propertyUids, ab as publishProcesses, aY as readJsonImportFile, aU as readSchema, ac as schemas, aS as setAdditionalSyncAddresses, aO as setGetPublisherForNewSeeds, aQ as setRevokeExecutor, at as setSchemaUidForModel, as as setSchemaUidForSchemaDefinition, aM as setUploadExecutor, aZ as syncSchemaFromSource, a_ as transformImportToSchemaFile, aF as updateSeedRevokedAt, ad as uploadProcesses, aL as waitForEntityIdle, aB as withExcludeRevokedFilter } from './index-uPXtq2cf.js';
+export { getPropertySchema } from './property-Dt0U3UXJ.js';
+import { eq, desc, and, isNotNull, ne, or } from 'drizzle-orm';
+export { S as Schema, a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, s as schemaMachine, u as updateModelProperties } from './Schema-Bnim4hAF.js';
+export { ModelProperty } from './ModelProperty-CkQaEsBu.js';
+export { isItemOwned } from './ownership-QK5haR3-.js';
+import { g as getSegmentedItemProperties } from './getSegmentedItemProperties-CJWdYH9W.js';
+export { PublishValidationFailedError, resolvePublishPayloadValues, validateItemForPublish } from './getPublishPayload-CdfPTl8l.js';
+export { itemHasPublishUploadCandidates } from './getPublishUploads-CGBky9q9.js';
 import 'js-yaml';
 import 'fs';
 import 'xstate';
 import 'drizzle-orm/sqlite-core';
 import 'nanoid';
 import 'nanoid-dictionary';
+import 'debug';
 import 'ethers';
-import 'rxjs';
+import 'pluralize';
+import '@sinclair/typebox';
 import 'drizzle-orm/casing';
+import 'lodash-es';
+import 'rxjs';
 import 'eventemitter3';
 import 'arweave';
-import '@sinclair/typebox';
-import './SchemaValidationService-CwKY3QlY.js';
+import 'js-sha3';
+import './SchemaValidationService-DXxRk-9Q.js';
 import '@sinclair/typebox/value';
 
-const useIsClientReady = () => {
-    const client = getClient();
-    const clientService = client.getService();
-    const isClientReady = useSelector(clientService, (snapshot) => {
-        return snapshot.value === ClientManagerState.IDLE;
-    });
-    // GlobalState removed - check ClientManager state directly
-    return isClientReady;
-};
-
+const isEmptyUid = (uid) => uid == null || uid === '' || uid === 'NULL';
 /**
- * Hook to execute a reactive query that emits new results whenever the underlying data changes.
- *
- * Supports two usage patterns:
- * 1. SQL tag function: useLiveQuery((sql) => sql`SELECT * FROM models`)
- * 2. Drizzle query builder: useLiveQuery(db.select().from(models))
- *
- * @param query - SQL query function or Drizzle query builder, or null/undefined to disable the query
- * @returns Array of query results, or undefined if not yet loaded
- *
- * @example
- * ```typescript
- * // Using SQL tag function
- * const models = useLiveQuery<ModelRow>(
- *   (sql) => sql`SELECT * FROM models WHERE schema_file_id = ${schemaId}`
- * )
- *
- * // Using Drizzle query builder
- * import { models } from '@/seedSchema'
- * import { eq } from 'drizzle-orm'
- *
- * const appDb = BaseDb.getAppDb()
- * const models = useLiveQuery<ModelRow>(
- *   appDb.select().from(models).where(eq(models.schemaFileId, schemaId))
- * )
- * ```
+ * Updates the version record with the attestation UID after a Version attestation is created.
+ * Targets the version without a uid yet (the one being published).
+ * Publisher is immutable once set: we never overwrite an existing publisher.
  */
-function useLiveQuery(query) {
-    const [data, setData] = useState(undefined);
-    const subscriptionRef = useRef(null);
-    const previousDataRef = useRef(undefined);
-    const isClientReady = useIsClientReady();
-    // Create Observable outside useEffect so it's stable and distinctUntilChanged can work
-    // Only recreate when query or isClientReady changes
-    const observable = useMemo(() => {
-        if (!isClientReady || !query) {
-            return null;
-        }
-        try {
-            return BaseDb.liveQuery(query);
-        }
-        catch (error) {
-            console.error('[useLiveQuery] Failed to create live query:', error);
-            return null;
-        }
-    }, [query, isClientReady]);
-    useEffect(() => {
-        // Cleanup previous subscription if it exists
-        if (subscriptionRef.current) {
-            subscriptionRef.current.unsubscribe();
-            subscriptionRef.current = null;
-        }
-        // Don't subscribe if observable is null
-        if (!observable) {
-            return;
-        }
-        const subscription = observable.subscribe({
-            next: (results) => {
-                const prev = previousDataRef.current;
-                const prevJson = prev ? JSON.stringify(prev) : 'undefined';
-                const currJson = results ? JSON.stringify(results) : 'undefined';
-                const isSameValue = prevJson === currJson;
-                // Defensive check: don't update state if values are the same
-                // This should be handled by distinctUntilChanged, but adding as safety
-                // (especially important for Drizzle query builders which may not work with distinctUntilChanged)
-                if (isSameValue && prev !== undefined) {
-                    return;
-                }
-                previousDataRef.current = results;
-                setData(results);
-            },
-            error: (err) => {
-                console.error('[useLiveQuery] Error:', err);
-                // Don't set data to undefined on error - keep last known good state
-                // This prevents UI flickering on transient errors
-            },
-        });
-        subscriptionRef.current = subscription;
-        // Cleanup on unmount or observable change
-        return () => {
-            if (subscriptionRef.current) {
-                subscriptionRef.current.unsubscribe();
-                subscriptionRef.current = null;
-            }
-        };
-    }, [observable]); // Only re-subscribe when observable changes
-    return data;
-}
-
-const logger$2 = debug('seedSdk:react:item');
-const useItem = ({ modelName, seedLocalId, seedUid }) => {
-    const [item, setItem] = useState();
-    const [isLoading, setIsLoading] = useState(!!(seedLocalId || seedUid));
-    const [error, setError] = useState(null);
-    const subscriptionRef = useRef(undefined);
-    const hasSeenIdleRef = useRef(false);
-    const isClientReady = useIsClientReady();
-    const modelNameRef = useRef(modelName);
-    const seedLocalIdRef = useRef(seedLocalId);
-    const seedUidRef = useRef(seedUid);
-    // Determine if we should be loading based on parameters - use useMemo to stabilize
-    // Use refs to check current values to avoid dependency issues
-    const shouldLoad = useMemo(() => {
-        if (!isClientReady)
-            return false;
-        return !!(seedLocalIdRef.current || seedUidRef.current);
-    }, [isClientReady, seedLocalId, seedUid]);
-    const loadItem = useCallback(async () => {
-        // Check shouldLoad inside the function to avoid recreating the callback
-        const currentShouldLoad = !!(isClientReady && (seedLocalIdRef.current || seedUidRef.current));
-        if (!currentShouldLoad) {
-            setItem(undefined);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        try {
-            // Don't set isLoading here - let the subscription effect handle it
-            // This avoids race conditions where isLoading is set to true but then
-            // the subscription effect hasn't run yet to set it to false
-            setError(null);
-            const foundItem = await Item.find({
-                modelName: modelNameRef.current,
-                seedLocalId: seedLocalIdRef.current,
-                seedUid: seedUidRef.current,
-            });
-            if (!foundItem) {
-                logger$2('[useItem] [loadItem] no item found', modelNameRef.current, seedLocalIdRef.current);
-                // Don't clear item if we already have one for the same request (e.g. duplicate loadItem from effect re-run)
-                setItem((prev) => {
-                    if (!prev)
-                        return undefined;
-                    const match = (prev.seedLocalId && prev.seedLocalId === seedLocalIdRef.current) ||
-                        (prev.seedUid && prev.seedUid === seedUidRef.current);
-                    return match ? prev : undefined;
-                });
-                setIsLoading(false);
-                setError(null);
-                return;
-            }
-            // Item.find() now waits for idle by default, so the item should be ready
-            setItem(foundItem);
-            setIsLoading(false); // Item is ready since find() waited for idle
-            setError(null);
-        }
-        catch (error) {
-            logger$2('[useItem] Error loading item:', error);
-            setItem(undefined);
-            setIsLoading(false);
-            setError(error);
-        }
-    }, [isClientReady]);
-    useEffect(() => {
-        modelNameRef.current = modelName;
-        seedLocalIdRef.current = seedLocalId;
-        seedUidRef.current = seedUid;
-    }, [modelName, seedLocalId, seedUid]);
-    // Fetch/refetch when parameters change or client becomes ready
-    useEffect(() => {
-        // Only clear item if we don't have parameters to load
-        // Don't clear if shouldLoad is false but we have an item - it might just be a timing issue
-        if (!shouldLoad) {
-            // Only clear if we actually don't have parameters (not just client not ready)
-            if (!seedLocalId && !seedUid) {
-                setItem(undefined);
-                setIsLoading(false);
-                setError(null);
-            }
-            return;
-        }
-        loadItem();
-    }, [shouldLoad, loadItem, seedLocalId, seedUid]);
-    // Subscribe to service changes when item is available
-    useEffect(() => {
-        if (!item) {
-            // Clean up subscription if item is not available
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-            hasSeenIdleRef.current = false;
-            return;
-        }
-        // Clean up previous subscription
-        subscriptionRef.current?.unsubscribe();
-        hasSeenIdleRef.current = false;
-        // Subscribe to service changes. Only set isLoading to true after we've seen idle at least
-        // once, so we don't overwrite the ready state that loadItem() just set (find() waits for idle).
-        const service = item.getService();
-        const subscription = service.subscribe((snapshot) => {
-            // Update loading state based on service state changes
-            if (snapshot && typeof snapshot === 'object' && 'value' in snapshot) {
-                const isIdle = snapshot.value === 'idle';
-                if (isIdle) {
-                    hasSeenIdleRef.current = true;
-                    setIsLoading(false);
-                    setError(null);
-                }
-                else if (snapshot.value === 'error') {
-                    setError(new Error('Item service error'));
-                    setIsLoading(false);
-                }
-                else {
-                    // Only show loading if we've already seen idle (real transition to loading)
-                    if (hasSeenIdleRef.current) {
-                        setIsLoading(true);
-                    }
-                }
-            }
-        });
-        subscriptionRef.current = subscription;
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, [item]);
-    return {
-        item,
-        isLoading,
-        error,
-    };
-};
-const getItemsQueryKey = (modelName, deleted, includeEas, addressFilter) => ['seed', 'items', modelName ?? null, deleted ?? false, includeEas ?? false, addressFilter ?? null];
-const useItems = ({ modelName, deleted = false, includeEas = false, addressFilter, }) => {
-    const isClientReady = useIsClientReady();
-    const queryClient = useQueryClient();
-    const previousSeedsTableDataRef = useRef(undefined);
-    const itemsRef = useRef([]);
-    const lastFetchedIdsRef = useRef(new Set());
-    const queryKey = useMemo(() => getItemsQueryKey(modelName, deleted, includeEas, addressFilter), [modelName, deleted, includeEas, addressFilter]);
-    const { data: items = [], isLoading, error: queryError, } = useQuery({
-        queryKey,
-        queryFn: () => Item.all(modelName, deleted, { waitForReady: true, includeEas, addressFilter }),
-        enabled: isClientReady,
-    });
-    itemsRef.current = items;
-    // Watch the seeds table for changes
-    const db = isClientReady ? BaseDb.getAppDb() : null;
-    const seedsQuery = useMemo(() => {
-        if (!db)
-            return null;
-        const conditions = [];
-        if (!includeEas) {
-            conditions.push(or(isNull(seeds.uid), eq(seeds.uid, '')));
-        }
-        if (modelName) {
-            conditions.push(eq(seeds.type, modelName.toLowerCase()));
-        }
-        if (deleted) {
-            conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
-        }
-        else {
-            conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
-        }
-        const versionData = getVersionData();
-        return db
-            .with(versionData)
-            .select({
-            localId: seeds.localId,
-            uid: seeds.uid,
-            type: seeds.type,
-            schemaUid: seeds.schemaUid,
-            createdAt: seeds.createdAt,
-            attestationCreatedAt: seeds.attestationCreatedAt,
-            _markedForDeletion: seeds._markedForDeletion,
-        })
-            .from(seeds)
-            .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
-            .where(and(gt(versionData.versionsCount, 0), ...conditions))
-            .groupBy(seeds.localId);
-    }, [db, isClientReady, modelName, deleted, includeEas]);
-    const seedsTableData = useLiveQuery(seedsQuery);
-    // Invalidate when table data actually changes so useQuery refetches
-    useEffect(() => {
-        if (!isClientReady || !seedsTableData)
-            return;
-        const tableDataItemsSet = new Set();
-        for (const dbSeed of seedsTableData) {
-            const key = dbSeed.localId || dbSeed.uid;
-            if (key)
-                tableDataItemsSet.add(key);
-        }
-        const currentItemsSet = new Set();
-        for (const item of itemsRef.current) {
-            const key = item.seedLocalId || item.seedUid;
-            if (key)
-                currentItemsSet.add(key);
-        }
-        if (tableDataItemsSet.size === 0 && currentItemsSet.size > 0)
-            return;
-        const lastFetched = lastFetchedIdsRef.current;
-        if (lastFetched.size === tableDataItemsSet.size &&
-            [...lastFetched].every((id) => tableDataItemsSet.has(id))) {
-            return;
-        }
-        previousSeedsTableDataRef.current = seedsTableData;
-        const setsAreEqual = currentItemsSet.size === tableDataItemsSet.size &&
-            [...currentItemsSet].every((id) => tableDataItemsSet.has(id));
-        if (setsAreEqual) {
-            lastFetchedIdsRef.current = new Set(tableDataItemsSet);
-            return;
-        }
-        lastFetchedIdsRef.current = new Set(tableDataItemsSet);
-        queryClient.invalidateQueries({ queryKey });
-    }, [isClientReady, seedsTableData, queryClient, queryKey]);
-    return {
-        items: orderBy(items, [
-            (item) => item.lastVersionPublishedAt ||
-                item.attestationCreatedAt ||
-                item.createdAt,
-        ], ['desc']),
-        isLoading,
-        error: queryError,
-    };
-};
-const useCreateItem = () => {
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const resetError = useCallback(() => setError(null), []);
-    const createItem = useCallback(async (modelName, itemData) => {
-        if (isLoading) {
-            logger$2('[useCreateItem] [createItem] already creating item, skipping');
-            return undefined;
-        }
-        setError(null);
-        // Flush loading=true synchronously so the UI (and tests) can observe it before async work runs.
-        flushSync(() => setIsLoading(true));
-        try {
-            const data = itemData ?? {};
-            const { seedLocalId } = await createNewItem({ modelName, ...data });
-            const newItem = await Item.find({ modelName, seedLocalId });
-            return (newItem ?? undefined);
-        }
-        catch (err) {
-            logger$2('[useCreateItem] Error creating item:', err);
-            setError(err instanceof Error ? err : new Error(String(err)));
-            return undefined;
-        }
-        finally {
-            // Defer clearing loading so React can commit the loading=true render first.
-            // Otherwise the test (or UI) may never observe isLoading true (same continuation batching).
-            queueMicrotask(() => setIsLoading(false));
-        }
-    }, [isLoading]);
-    return {
-        createItem,
-        isLoading,
-        error,
-        resetError,
-    };
-};
-const usePublishItem = () => {
-    const [publishingItem, setPublishingItem] = useState(null);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const subscriptionRef = useRef(undefined);
-    const resetError = useCallback(() => setError(null), []);
-    const publishItem = useCallback((item) => {
-        if (!item)
-            return;
-        setPublishingItem(item);
-        setError(null);
-        item.publish().catch(() => {
-            // Error is surfaced via service state subscription; avoid unhandled rejection
-        });
-    }, []);
-    useEffect(() => {
-        if (!publishingItem) {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-            setIsLoading(false);
-            return;
-        }
-        subscriptionRef.current?.unsubscribe();
-        const service = publishingItem.getService();
-        const subscription = service.subscribe((snapshot) => {
-            const value = snapshot?.value;
-            const ctx = snapshot?.context;
-            setIsLoading(value === 'publishing');
-            const publishError = ctx?._publishError;
-            setError(publishError ? new Error(publishError.message) : null);
-        });
-        subscriptionRef.current = subscription;
-        const snap = service.getSnapshot();
-        setIsLoading(snap?.value === 'publishing');
-        const ctx = snap?.context;
-        const publishError = ctx?._publishError;
-        setError(publishError ? new Error(publishError.message) : null);
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, [publishingItem]);
-    return {
-        publishItem,
-        isLoading,
-        error,
-        resetError,
-    };
+const updateVersionUid = async ({ seedLocalId, versionUid, publisher, }) => {
+    if (!seedLocalId || !versionUid) {
+        return;
+    }
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return;
+    const rows = await appDb
+        .select({ localId: versions.localId, uid: versions.uid, publisher: versions.publisher })
+        .from(versions)
+        .where(eq(versions.seedLocalId, seedLocalId))
+        .orderBy(desc(versions.createdAt));
+    const toUpdate = rows.find((r) => r.localId && isEmptyUid(r.uid));
+    if (!toUpdate?.localId)
+        return;
+    let shouldSetPublisher = publisher != null && publisher !== '';
+    if (shouldSetPublisher && toUpdate.publisher != null && toUpdate.publisher !== '') {
+        shouldSetPublisher = false;
+    }
+    await appDb
+        .update(versions)
+        .set({
+        uid: versionUid,
+        ...(shouldSetPublisher && { publisher }),
+        updatedAt: Date.now(),
+    })
+        .where(eq(versions.localId, toUpdate.localId));
 };
 
-const logger$1 = debug('seedSdk:react:property');
-const propertiesLogger = debug('seedSdk:react:itemProperties');
-function useItemProperty(arg1, arg2) {
-    const isClientReady = useIsClientReady();
-    const [property, setProperty] = useState(undefined);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const subscriptionRef = useRef(undefined);
-    const [, setVersion] = useState(0); // Version counter to force re-renders
-    // Extract primitives so useMemo/useCallback deps are stable when caller passes inline objects
-    // Support object form with itemId: useItemProperty({ itemId, propertyName })
-    const arg1IsObject = typeof arg1 === 'object' && arg1 != null;
-    const obj = arg1IsObject ? arg1 : null;
-    const itemIdFromObj = obj != null ? obj.itemId : undefined;
-    const seedLocalId = obj != null ? obj.seedLocalId : undefined;
-    const seedUid = obj != null ? obj.seedUid : undefined;
-    const propertyNameFromObj = obj != null ? obj.propertyName : undefined;
-    const itemId = typeof arg1 === 'string' ? arg1 : (itemIdFromObj !== undefined && itemIdFromObj !== '' ? itemIdFromObj : undefined);
-    const propertyNameFromArgs = typeof arg1 === 'string' ? arg2 : undefined;
-    const propertyName = propertyNameFromObj ?? propertyNameFromArgs;
-    // Determine which lookup mode we're in based on arguments (deps are primitives to avoid infinite loop)
-    // Unify itemId and identifiers: when itemId is provided (string or object form), use it as seedLocalId so we hit the same code path
-    const lookupMode = useMemo(() => {
-        const resolvedSeedLocalId = (itemId !== undefined && itemId !== '') ? itemId : seedLocalId;
-        const resolvedSeedUid = (itemId !== undefined && itemId !== '') ? undefined : seedUid;
-        if ((resolvedSeedLocalId != null || resolvedSeedUid != null) && propertyName != null && propertyName !== '') {
-            return {
-                type: 'identifiers',
-                seedLocalId: resolvedSeedLocalId ?? undefined,
-                seedUid: resolvedSeedUid,
-                propertyName,
-            };
-        }
-        return null;
-    }, [itemId, propertyName, seedLocalId, seedUid]);
-    // Determine initial loading state
-    useMemo(() => {
-        if (!lookupMode)
-            return false;
-        return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
-            lookupMode.propertyName);
-    }, [lookupMode]);
-    // Determine if we should be loading based on parameters
-    const shouldLoad = useMemo(() => {
-        if (!isClientReady)
-            return false;
-        if (!lookupMode)
-            return false;
-        return !!((lookupMode.seedLocalId || lookupMode.seedUid) &&
-            lookupMode.propertyName);
-    }, [isClientReady, lookupMode]);
-    const updateItemProperty = useCallback(async () => {
-        if (!isClientReady || !lookupMode) {
-            setProperty(undefined);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        try {
-            setIsLoading(true);
-            setError(null);
-            const seedLocalId = lookupMode.seedLocalId;
-            const seedUid = lookupMode.seedUid;
-            if (!seedLocalId && !seedUid) {
-                setProperty(undefined);
-                setIsLoading(false);
-                setError(null);
-                return;
-            }
-            const foundProperty = await ItemProperty.find({
-                propertyName: lookupMode.propertyName,
-                seedLocalId,
-                seedUid,
-            });
-            if (!foundProperty) {
-                logger$1(`[useItemProperty] [updateItemProperty] no property found for Item.${seedLocalId || seedUid}.${lookupMode.propertyName}`);
-                setProperty(undefined);
-                setIsLoading(false);
-                setError(null);
-                return;
-            }
-            // ItemProperty.find() now waits for idle by default, so the property should be ready
-            setProperty(foundProperty);
-            setIsLoading(false); // Property is ready since find() waited for idle
-            setError(null);
-        }
-        catch (error) {
-            logger$1('[useItemProperty] Error updating item property:', error);
-            setProperty(undefined);
-            setIsLoading(false);
-            setError(error);
-        }
-    }, [isClientReady, lookupMode]);
-    // Fetch/refetch when lookup parameters change or client becomes ready.
-    // Skip refetch when we already have the property for this lookup (avoids setting loading true
-    // again when effect re-runs e.g. from Strict Mode or updateItemProperty identity change).
-    // Match by the active identifier only: when looking up by seedLocalId both must match;
-    // when looking up by seedUid both must match. Do not use (seedUid === undefined) as a match
-    // when seedLocalIds differ, which would incorrectly skip refetch after seedLocalId change.
-    useEffect(() => {
-        if (!shouldLoad) {
-            setProperty(undefined);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        const alreadyHavePropertyGuard = property &&
-            lookupMode &&
-            property.propertyName === lookupMode.propertyName &&
-            ((lookupMode.seedLocalId != null && property.seedLocalId === lookupMode.seedLocalId) ||
-                (lookupMode.seedUid != null && property.seedUid === lookupMode.seedUid));
-        if (alreadyHavePropertyGuard)
-            return;
-        updateItemProperty();
-    }, [shouldLoad, updateItemProperty, property, lookupMode]);
-    // Subscribe to service changes when property is available
-    useEffect(() => {
-        if (!property) {
-            // Clean up subscription if property is not available
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-            return;
-        }
-        // Clean up previous subscription
-        subscriptionRef.current?.unsubscribe();
-        // Subscribe to service changes. Only set isLoading to false when idle; never set to true
-        // here so we never overwrite the loaded state when the machine emits any non-idle state
-        // (e.g. loading, initializing, resolvingRelatedValue) after the initial fetch.
-        const subscription = property.getService().subscribe((snapshot) => {
-            if (snapshot && typeof snapshot === 'object' && 'value' in snapshot && snapshot.value === 'idle') {
-                setIsLoading(false);
-                setError(null);
-            }
-            // Force re-render by incrementing version counter
-            setVersion(prev => prev + 1);
-        });
-        subscriptionRef.current = subscription;
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, [property]);
-    return {
-        property,
-        isLoading,
-        error,
-    };
-}
-/** Fetches item properties list for useQuery (shared with useItemProperties). */
-async function fetchItemPropertiesList(seedLocalId, seedUid) {
-    if (!seedLocalId && !seedUid)
-        return [];
-    const db = BaseDb.getAppDb();
-    if (!db)
+const getVersionsForSeedUid = async (seedUid) => {
+    if (!seedUid)
         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 _mod_0 = await import('./index-Dh_gxItx.js');
-            const _ns_0 = _mod_0.a$;
-            const modelMod = _ns_0;
-            const { Model } = modelMod;
-            const model = await Model.getByNameAsync(modelName);
-            if (model?.properties) {
-                for (const modelProperty of model.properties) {
-                    if (modelProperty.name)
-                        modelProperties.push(modelProperty.name);
-                }
-            }
-        }
-        catch (error) {
-            propertiesLogger(`[useItemProperties] Error getting ModelProperties for ${modelName}:`, error);
-        }
-    }
-    if (modelName && modelProperties.length > 0) {
-        const resolvedSeedLocalId = baseList.length > 0 ? (baseList[0].seedLocalId ?? seedLocalId) : seedLocalId;
-        const resolvedSeedUid = baseList.length > 0 ? (baseList[0].seedUid ?? seedUid) : seedUid;
-        for (const propertyName of modelProperties) {
-            if (propertiesWithMetadata.has(propertyName))
-                continue;
-            try {
-                const itemProperty = ItemProperty.create({
-                    propertyName,
-                    modelName,
-                    seedLocalId: resolvedSeedLocalId || undefined,
-                    seedUid: resolvedSeedUid || undefined,
-                    propertyValue: null,
-                }, { waitForReady: false });
-                if (itemProperty)
-                    _itemProperties.push(itemProperty);
-            }
-            catch (error) {
-                logger$1(`[useItemProperties] Error creating ItemProperty for missing property ${propertyName}:`, error);
-            }
-        }
-    }
-    if (seedLocalId || seedUid) {
-        const seedRecords = await db
-            .select({ createdAt: seeds.createdAt })
-            .from(seeds)
-            .where(seedUid ? eq(seeds.uid, seedUid) : eq(seeds.localId, seedLocalId))
-            .limit(1);
-        if (seedRecords.length > 0 && seedRecords[0].createdAt) {
-            const createdAtPropertyName = 'createdAt';
-            const hasCreatedAtProperty = _itemProperties.some((p) => p.propertyName === createdAtPropertyName);
-            if (!hasCreatedAtProperty && modelName) {
-                try {
-                    const resolvedSeedLocalId = baseList.length > 0 ? (baseList[0].seedLocalId ?? seedLocalId) : seedLocalId;
-                    const resolvedSeedUid = baseList.length > 0 ? (baseList[0].seedUid ?? seedUid) : seedUid;
-                    const createdAtProperty = ItemProperty.create({
-                        propertyName: createdAtPropertyName,
-                        modelName,
-                        seedLocalId: resolvedSeedLocalId || undefined,
-                        seedUid: resolvedSeedUid || undefined,
-                        propertyValue: seedRecords[0].createdAt.toString(),
-                    }, { waitForReady: false });
-                    if (createdAtProperty)
-                        _itemProperties.push(createdAtProperty);
-                }
-                catch (error) {
-                    logger$1(`[useItemProperties] Error creating createdAt ItemProperty:`, error);
-                }
-            }
-        }
-    }
-    return _itemProperties;
-}
-function useItemProperties(arg1) {
-    const isClientReady = useIsClientReady();
-    const queryClient = useQueryClient();
-    const previousTableDataRef = useRef(undefined);
-    // Determine which lookup mode we're in based on arguments
-    const lookupMode = useMemo(() => {
-        if (typeof arg1 === 'string') {
-            // String argument: itemId (assumed to be seedLocalId)
-            return { type: 'itemId', itemId: arg1 };
-        }
-        else if (typeof arg1 === 'object') {
-            // Object argument: { seedLocalId/seedUid }
-            return {
-                type: 'identifiers',
-                seedLocalId: arg1.seedLocalId,
-                seedUid: arg1.seedUid,
-            };
-        }
-        else {
-            return null;
-        }
-    }, [arg1]);
-    // Determine seedLocalId and seedUid for query
-    const seedLocalId = useMemo(() => {
-        if (!lookupMode)
-            return undefined;
-        if (lookupMode.type === 'itemId') {
-            return lookupMode.itemId;
-        }
-        else {
-            return lookupMode.seedLocalId;
-        }
-    }, [lookupMode]);
-    const seedUid = useMemo(() => {
-        if (!lookupMode || lookupMode.type === 'itemId')
-            return undefined;
-        return lookupMode.seedUid;
-    }, [lookupMode]);
-    const canonicalItemKey = seedLocalId ?? seedUid ?? '';
-    const itemPropertiesQueryKey = useMemo(() => ['seed', 'itemProperties', canonicalItemKey], [canonicalItemKey]);
-    const { data: properties = [], isLoading, error: queryError, } = useQuery({
-        queryKey: itemPropertiesQueryKey,
-        queryFn: () => fetchItemPropertiesList(seedLocalId, seedUid),
-        enabled: isClientReady && !!canonicalItemKey,
-    });
-    // Watch the metadata table for changes
-    // Query metadata table directly and filter for latest records in JavaScript
-    // This is simpler and works better with useLiveQuery than CTEs
-    // Get db inside useMemo to avoid recreating query on each render
-    // Drizzle query builders are new objects each time, but useMemo will only recreate
-    // when dependencies change, which is what we want for reactive queries
-    const propertiesQuery = useMemo(() => {
-        if (!isClientReady || (!seedLocalId && !seedUid)) {
-            propertiesLogger('[useItemProperties] Query: returning null (not ready or no identifiers)');
-            return null;
-        }
-        const db = BaseDb.getAppDb();
-        if (!db) {
-            propertiesLogger('[useItemProperties] Query: returning null (no db)');
-            return null;
-        }
-        propertiesLogger(`[useItemProperties] Query: creating query for seedLocalId=${seedLocalId}, seedUid=${seedUid}`);
-        // Query metadata table directly - we'll filter for latest records in JavaScript
-        const query = seedUid
-            ? db
-                .select({
-                propertyName: metadata.propertyName,
-                propertyValue: metadata.propertyValue,
-                seedLocalId: metadata.seedLocalId,
-                seedUid: metadata.seedUid,
-                modelType: metadata.modelType,
-                schemaUid: metadata.schemaUid,
-                createdAt: metadata.createdAt,
-                attestationCreatedAt: metadata.attestationCreatedAt,
-            })
-                .from(metadata)
-                .where(and(eq(metadata.seedUid, seedUid), isNotNull(metadata.propertyName)))
-            : seedLocalId
-                ? db
-                    .select({
-                    propertyName: metadata.propertyName,
-                    propertyValue: metadata.propertyValue,
-                    seedLocalId: metadata.seedLocalId,
-                    seedUid: metadata.seedUid,
-                    modelType: metadata.modelType,
-                    schemaUid: metadata.schemaUid,
-                    createdAt: metadata.createdAt,
-                    attestationCreatedAt: metadata.attestationCreatedAt,
-                })
-                    .from(metadata)
-                    .where(and(eq(metadata.seedLocalId, seedLocalId), isNotNull(metadata.propertyName)))
-                : null;
-        propertiesLogger(`[useItemProperties] Query: created query object`, { queryType: seedUid ? 'seedUid' : 'seedLocalId' });
-        return query;
-    }, [isClientReady, seedLocalId, seedUid]);
-    const rawPropertiesTableData = useLiveQuery(propertiesQuery);
-    // Filter for latest records (one per propertyName) in JavaScript
-    const propertiesTableData = useMemo(() => {
-        if (!rawPropertiesTableData || rawPropertiesTableData.length === 0) {
-            return [];
-        }
-        // Group by propertyName and keep only the latest record for each
-        const latestByProperty = new Map();
-        for (const record of rawPropertiesTableData) {
-            if (!record.propertyName)
-                continue;
-            const existing = latestByProperty.get(record.propertyName);
-            if (!existing) {
-                latestByProperty.set(record.propertyName, record);
-            }
-            else {
-                // Compare timestamps to find the latest
-                const existingTime = existing.attestationCreatedAt || existing.createdAt || 0;
-                const currentTime = record.attestationCreatedAt || record.createdAt || 0;
-                if (currentTime > existingTime) {
-                    latestByProperty.set(record.propertyName, record);
-                }
-            }
-        }
-        return Array.from(latestByProperty.values());
-    }, [rawPropertiesTableData]);
-    // Invalidate when metadata table data actually changes so useQuery refetches
-    useEffect(() => {
-        if (!isClientReady || (!seedLocalId && !seedUid) || propertiesTableData === undefined)
-            return;
-        // Include propertyValue so value-only changes produce a different string and trigger invalidation
-        const tableDataString = JSON.stringify(propertiesTableData
-            .map((p) => ({
-            propertyName: p.propertyName,
-            propertyValue: p.propertyValue,
-            seedLocalId: p.seedLocalId,
-            seedUid: p.seedUid,
-        }))
-            .sort((a, b) => (a.propertyName || '').localeCompare(b.propertyName || '')));
-        if (previousTableDataRef.current === tableDataString)
-            return;
-        previousTableDataRef.current = tableDataString;
-        // Invalidate when metadata table data changed (new/updated/removed props or value changes)
-        // so useQuery refetches and UI shows latest values.
-        if (propertiesTableData.length > 0) {
-            queryClient.invalidateQueries({ queryKey: itemPropertiesQueryKey });
-        }
-    }, [isClientReady, propertiesTableData, properties, seedLocalId, seedUid, queryClient, itemPropertiesQueryKey]);
-    useEffect(() => {
-        previousTableDataRef.current = undefined;
-    }, [seedLocalId, seedUid]);
-    return {
-        properties,
-        isLoading,
-        error: queryError,
-    };
-}
-/**
- * Hook to create an ItemProperty with loading and error state.
- * create(props) creates a new property instance for an item; provide seedLocalId or seedUid, propertyName, and modelName.
- */
-const useCreateItemProperty = () => {
-    const subscriptionRef = useRef(undefined);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const resetError = useCallback(() => setError(null), []);
-    const create = useCallback((props) => {
-        if (!props.propertyName || (!props.seedLocalId && !props.seedUid) || !props.modelName) {
-            const err = new Error('seedLocalId or seedUid, propertyName, and modelName are required');
-            setError(err);
-            return undefined;
-        }
-        setError(null);
-        setIsLoading(true);
-        subscriptionRef.current?.unsubscribe();
-        subscriptionRef.current = undefined;
-        const instance = ItemProperty.create(props, { waitForReady: false });
-        if (!instance) {
-            setError(new Error('Failed to create item property'));
-            setIsLoading(false);
-            return undefined;
-        }
-        const subscription = instance.getService().subscribe((snapshot) => {
-            if (snapshot?.value === 'error') {
-                const err = snapshot.context?._loadingError?.error ?? new Error('Failed to create item property');
-                setError(err instanceof Error ? err : new Error(String(err)));
-                setIsLoading(false);
-            }
-            if (snapshot?.value === 'idle') {
-                setError(null);
-                setIsLoading(false);
-            }
-        });
-        subscriptionRef.current = subscription;
-        return instance;
-    }, []);
-    useEffect(() => {
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, []);
-    return {
-        create,
-        isLoading,
-        error,
-        resetError,
-    };
-};
-const useDestroyItemProperty = () => {
-    const [currentInstance, setCurrentInstance] = useState(null);
-    const [destroyState, setDestroyState] = useState({
-        isLoading: false,
-        error: null,
-    });
-    useEffect(() => {
-        if (!currentInstance) {
-            setDestroyState({ isLoading: false, error: null });
-            return;
-        }
-        const service = currentInstance.getService();
-        const update = () => {
-            const snap = service.getSnapshot();
-            const ctx = snap.context;
-            setDestroyState({
-                isLoading: !!ctx._destroyInProgress,
-                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
-            });
-        };
-        update();
-        const sub = service.subscribe(update);
-        return () => sub.unsubscribe();
-    }, [currentInstance]);
-    const destroy = useCallback(async (itemProperty) => {
-        if (!itemProperty)
-            return;
-        setCurrentInstance(itemProperty);
-        await itemProperty.destroy();
-    }, []);
-    const resetError = useCallback(() => {
-        if (currentInstance) {
-            currentInstance.getService().send({ type: 'clearDestroyError' });
-        }
-    }, [currentInstance]);
-    return {
-        destroy,
-        isLoading: destroyState.isLoading,
-        error: destroyState.error,
-        resetError,
-    };
-};
-
-debug('seedSdk:react:services');
-
-debug('seedSdk:react:db');
-
-const logger = debug('seedSdk:react:schema');
-/**
- * Hook to get a Schema class instance (with setters) that is reactive
- * This allows you to edit schema properties directly like: schema.name = 'New name'
- * The schema instance uses a Proxy to ensure React re-renders when properties change
- * @param schemaIdentifier - The name of the schema or the schema file ID
- *   - If a name is provided, retrieves the latest version with that name
- *   - If an ID is provided, retrieves the specific schema by ID
- * @returns Object with schema instance
- */
-const useSchema = (schemaIdentifier) => {
-    const [schema, setSchema] = useState(null);
-    const [isLoading, setIsLoading] = useState(schemaIdentifier ? true : false);
-    const [error, setError] = useState(null);
-    const subscriptionRef = useRef(null);
-    const isClientReady = useIsClientReady();
-    const loadSchema = useCallback((identifier) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const schemaInstance = Schema.create(identifier, {
-                waitForReady: false,
-            });
-            setSchema(schemaInstance);
-            const service = schemaInstance.getService();
-            const initialSnapshot = service.getSnapshot();
-            // Set initial loading state based on whether status is 'idle'
-            const isIdle = initialSnapshot.value === 'idle';
-            if (isIdle) {
-                flushSync(() => setIsLoading(false));
-                setError(null);
-            }
-            else {
-                setIsLoading(true);
-            }
-            // Subscribe to all status changes and update isLoading based on whether status is 'idle'
-            subscriptionRef.current = service.subscribe((snapshot) => {
-                const isIdle = snapshot.value === 'idle';
-                if (isIdle) {
-                    flushSync(() => setIsLoading(false));
-                    setError(null);
-                }
-                else {
-                    setIsLoading(true);
-                }
-            });
-        }
-        catch (error) {
-            logger('[useSchema] Error creating schema:', error);
-            setError(error);
-            setSchema(null);
-            setIsLoading(false);
-            return null;
-        }
-    }, []);
-    useEffect(() => {
-        // Clean up previous subscription before starting a new load
-        if (subscriptionRef.current) {
-            subscriptionRef.current.unsubscribe();
-            subscriptionRef.current = null;
-        }
-        if (!isClientReady) {
-            setSchema(null);
-            setError(null);
-            setIsLoading(false);
-            return;
-        }
-        if (!schemaIdentifier) {
-            setSchema(null);
-            setError(null);
-            setIsLoading(false);
-            return;
-        }
-        loadSchema(schemaIdentifier);
-        // Cleanup function to unsubscribe when effect re-runs or component unmounts
-        return () => {
-            if (subscriptionRef.current) {
-                subscriptionRef.current.unsubscribe();
-                subscriptionRef.current = null;
-            }
-        };
-    }, [schemaIdentifier, isClientReady, loadSchema]);
-    return {
-        schema,
-        isLoading,
-        error,
-    };
-};
-const SEED_SCHEMAS_QUERY_KEY = ['seed', 'schemas'];
-const useSchemas = () => {
-    const isClientReady = useIsClientReady();
-    const queryClient = useQueryClient();
-    const previousSchemasTableDataRef = useRef(undefined);
-    const schemasRef = useRef([]);
-    const { data: schemas$1 = [], isLoading, error: queryError, } = useQuery({
-        queryKey: SEED_SCHEMAS_QUERY_KEY,
-        queryFn: () => Schema.all({ waitForReady: true }),
-        enabled: isClientReady,
-    });
-    schemasRef.current = schemas$1;
-    // Watch the schemas table for changes and invalidate so useQuery refetches
-    const db = isClientReady ? BaseDb.getAppDb() : null;
-    const schemasQuery = useMemo(() => {
-        if (!db)
-            return null;
-        return db.select().from(schemas).orderBy(schemas.name, desc(schemas.version));
-    }, [db, isClientReady]);
-    const schemasTableData = useLiveQuery(schemasQuery);
-    // When a schema is created, addSchemaToDb posts to this channel; live query often doesn't re-run when schemas table is inserted.
-    useEffect(() => {
-        if (typeof BroadcastChannel === 'undefined')
-            return;
-        const ch = new BroadcastChannel('seed-schemas-invalidate');
-        const onMessage = () => {
-            queryClient.invalidateQueries({ queryKey: SEED_SCHEMAS_QUERY_KEY });
-        };
-        ch.addEventListener('message', onMessage);
-        return () => {
-            ch.removeEventListener('message', onMessage);
-            ch.close();
-        };
-    }, [queryClient]);
-    useEffect(() => {
-        if (!isClientReady || !schemasTableData) {
-            return;
-        }
-        const prevData = previousSchemasTableDataRef.current;
-        const prevDataJson = prevData ? JSON.stringify(prevData) : 'undefined';
-        const currDataJson = schemasTableData ? JSON.stringify(schemasTableData) : 'undefined';
-        if (prevDataJson === currDataJson && prevData !== undefined) {
-            return;
-        }
-        previousSchemasTableDataRef.current = schemasTableData;
-        const currentSchemasSet = new Set();
-        for (const schema of schemasRef.current) {
-            const schemaFileId = schema.id || schema.schemaFileId;
-            if (schemaFileId) {
-                currentSchemasSet.add(schemaFileId);
-            }
-            else {
-                const name = schema.metadata?.name;
-                const version = schema.version;
-                if (name && version !== undefined) {
-                    currentSchemasSet.add(`${name}:${version}`);
-                }
-            }
-        }
-        const tableDataSchemasSet = new Set();
-        for (const dbSchema of schemasTableData) {
-            if (dbSchema.name === 'Seed Protocol')
-                continue;
-            if (dbSchema.schemaFileId) {
-                tableDataSchemasSet.add(dbSchema.schemaFileId);
-            }
-            else if (dbSchema.name != null && dbSchema.version !== undefined) {
-                tableDataSchemasSet.add(`${dbSchema.name}:${dbSchema.version}`);
-            }
-        }
-        const setsAreEqual = currentSchemasSet.size === tableDataSchemasSet.size &&
-            [...currentSchemasSet].every((id) => tableDataSchemasSet.has(id));
-        // Only invalidate when we have data and the table has rows we might be missing (live query saw new data).
-        // Skip during initial load (currentSchemasSet empty) to avoid disrupting loading state.
-        // Do NOT invalidate when we have more than the table: the live query may not have updated
-        // yet, and refetching could overwrite cache with stale/empty data.
-        const tableHasNewRows = currentSchemasSet.size > 0 &&
-            tableDataSchemasSet.size > 0 &&
-            [...tableDataSchemasSet].some((id) => !currentSchemasSet.has(id));
-        if (!setsAreEqual && tableHasNewRows) {
-            queryClient.invalidateQueries({ queryKey: SEED_SCHEMAS_QUERY_KEY });
-        }
-    }, [isClientReady, schemasTableData, queryClient]);
-    return {
-        schemas: schemas$1,
-        isLoading,
-        error: queryError,
-    };
-};
-const useCreateSchema = () => {
-    const subscriptionRef = useRef(null);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const resetError = useCallback(() => setError(null), []);
-    const createSchema = useCallback((schemaName) => {
-        setError(null);
-        setIsLoading(true);
-        subscriptionRef.current?.unsubscribe();
-        subscriptionRef.current = null;
-        const schema = Schema.create(schemaName, {
-            waitForReady: false,
-        });
-        const subscription = schema.getService().subscribe((snapshot) => {
-            if (snapshot.value === 'error') {
-                const err = snapshot.context._loadingError?.error;
-                setError(err instanceof Error ? err : new Error('Failed to create schema'));
-                setIsLoading(false);
-            }
-            if (snapshot.value === 'idle') {
-                setError(null);
-                setIsLoading(false);
-            }
-        });
-        subscriptionRef.current = subscription;
-        return schema;
-    }, []);
-    useEffect(() => {
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = null;
-        };
-    }, []);
-    return {
-        createSchema,
-        isLoading,
-        error,
-        resetError,
-    };
-};
-const useDestroySchema = () => {
-    const [currentInstance, setCurrentInstance] = useState(null);
-    const [destroyState, setDestroyState] = useState({
-        isLoading: false,
-        error: null,
-    });
-    useEffect(() => {
-        if (!currentInstance) {
-            setDestroyState({ isLoading: false, error: null });
-            return;
-        }
-        const service = currentInstance.getService();
-        const update = () => {
-            const snap = service.getSnapshot();
-            const ctx = snap.context;
-            setDestroyState({
-                isLoading: !!ctx._destroyInProgress,
-                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
-            });
-        };
-        update();
-        const sub = service.subscribe(update);
-        return () => sub.unsubscribe();
-    }, [currentInstance]);
-    const destroy = useCallback(async (schema) => {
-        if (!schema)
-            return;
-        setCurrentInstance(schema);
-        await schema.destroy();
-    }, []);
-    const resetError = useCallback(() => {
-        if (currentInstance) {
-            currentInstance.getService().send({ type: 'clearDestroyError' });
-        }
-    }, [currentInstance]);
-    return {
-        destroy,
-        isLoading: destroyState.isLoading,
-        error: destroyState.error,
-        resetError,
-    };
-};
-const useAllSchemaVersions = () => {
-    const [schemaInstances, setSchemaInstances] = useState();
-    const schemaInstancesRef = useRef(new Map());
-    const isClientReady = useIsClientReady();
-    const fetchSchemas = useCallback(async () => {
-        if (!isClientReady) {
-            return;
-        }
-        try {
-            // Use DB-first approach: load all schemas from database
-            // This will also import any missing schemas from files
-            const allSchemasData = await loadAllSchemasFromDb();
-            // Extract unique schema names
-            const schemaNames = new Set();
-            for (const schemaData of allSchemasData) {
-                const schemaName = schemaData.schema.metadata?.name;
-                if (schemaName) {
-                    schemaNames.add(schemaName);
-                }
-            }
-            // Create/update Schema instances
-            const currentInstances = new Map();
-            for (const schemaName of schemaNames) {
-                // Reuse existing instance if it exists
-                if (schemaInstancesRef.current.has(schemaName)) {
-                    const existingInstance = schemaInstancesRef.current.get(schemaName);
-                    currentInstances.set(schemaName, existingInstance);
-                }
-                else {
-                    // Create new instance
-                    const schema = Schema.create(schemaName, {
-                        waitForReady: false,
-                    });
-                    currentInstances.set(schemaName, schema);
-                }
-            }
-            // Cleanup instances that are no longer needed
-            for (const [name, instance] of schemaInstancesRef.current.entries()) {
-                if (!schemaNames.has(name)) {
-                    instance.unload();
-                }
-            }
-            // Update ref and state
-            schemaInstancesRef.current = currentInstances;
-            setSchemaInstances(Array.from(currentInstances.values()));
-        }
-        catch (error) {
-            logger('Error fetching all schema versions from database:', error);
-            setSchemaInstances(null);
-        }
-    }, [isClientReady]);
-    useEffect(() => {
-        if (!isClientReady) {
-            return;
-        }
-        fetchSchemas();
-    }, [isClientReady, fetchSchemas]);
-    // Cleanup on unmount
-    useEffect(() => {
-        return () => {
-            schemaInstancesRef.current.forEach((instance) => {
-                instance.unload();
-            });
-            schemaInstancesRef.current.clear();
-        };
-    }, []);
-    return schemaInstances;
+    const appDb = BaseDb.getAppDb();
+    const rows = (await appDb
+        .select({ uid: versions.uid, seedUid: versions.seedUid })
+        .from(versions)
+        .where(eq(versions.seedUid, seedUid)));
+    return rows
+        .filter((r) => r.uid && r.uid !== '0x' + '0'.repeat(64))
+        .map((r) => ({ uid: r.uid }));
 };
 
 /**
- * Hook to get all Model instances for a specific schema
- * Uses useLiveQuery to watch for changes in the models table and automatically
- * updates the returned Model instances when changes occur.
- * @param schemaId - The schema ID (schema file ID) or schema name to get models from
- * @returns Array of Model instances belonging to the schema
+ * Returns attestation UIDs (metadata.uid) for all metadata records belonging to a seed.
+ * Used when revoking attestations - metadata attestations must be revoked.
  */
-const getModelsQueryKey = (schemaId) => ['seed', 'models', schemaId];
-// Last-known-good models per schemaId so we never flash [] after remount or refetch race (survives component unmount).
-const lastModelsBySchemaId = new Map();
-const useModels = (schemaId) => {
-    const isClientReady = useIsClientReady();
-    const queryClient = useQueryClient();
-    const modelsRef = useRef([]);
-    const queryKey = useMemo(() => getModelsQueryKey(schemaId), [schemaId]);
-    const { data: models$1 = [], isLoading, error: queryError, } = useQuery({
-        queryKey,
-        queryFn: async () => {
-            // Capture previous data before any async work so we don't overwrite good cache with [].
-            const prev = queryClient.getQueryData(queryKey);
-            // Use waitForReady: false so we return models as soon as they exist; waitForReady: true
-            // filters to only idle models and can return [] while a model is in creatingProperties.
-            const next = await Model.all(schemaId, { waitForReady: false });
-            // getModelsData can intermittently return [] after returning data; keep prev to avoid overwrite.
-            if (Array.isArray(prev) && prev.length > 0 && Array.isArray(next) && next.length === 0) {
-                return [...prev];
-            }
-            // If this refetch returned [], avoid overwriting non-empty cache (e.g. race where another refetch already wrote data).
-            if (Array.isArray(next) && next.length === 0) {
-                const current = queryClient.getQueryData(queryKey);
-                if (Array.isArray(current) && current.length > 0) {
-                    return [...current];
-                }
-            }
-            return next;
-        },
-        enabled: isClientReady && !!schemaId,
-    });
-    // Never expose [] when we previously had models (avoids flash from refetch races, remounts, or intermittent getModelsData returning []).
-    // When schemaId is null/undefined, always show [] — do not use fallback from a previous schema.
-    const schemaIdKey = schemaId && typeof schemaId === 'string' ? schemaId : '';
-    if (models$1.length > 0) {
-        lastModelsBySchemaId.set(schemaIdKey, models$1);
-    }
-    const fallback = modelsRef.current.length > 0 ? modelsRef.current : lastModelsBySchemaId.get(schemaIdKey);
-    const displayModels = !schemaId
-        ? models$1
-        : models$1.length > 0
-            ? models$1
-            : fallback?.length
-                ? fallback
-                : models$1;
-    modelsRef.current = displayModels;
-    // When a model is created, writeModelToDb posts to this channel; live query over join often doesn't re-run
-    useEffect(() => {
-        if (!schemaId || typeof BroadcastChannel === 'undefined')
-            return;
-        const ch = new BroadcastChannel('seed-models-invalidate');
-        const onMessage = (event) => {
-            const { schemaName, schemaFileId } = event.data || {};
-            if (schemaId === schemaName || schemaId === schemaFileId) {
-                queryClient.invalidateQueries({ queryKey });
-                queryClient.refetchQueries({ queryKey });
-            }
-        };
-        ch.addEventListener('message', onMessage);
-        return () => {
-            ch.removeEventListener('message', onMessage);
-            ch.close();
-        };
-    }, [schemaId, queryClient, queryKey]);
-    // Stabilize query reference: only recreate when (schemaId, isClientReady) change, not when db reference changes.
-    // This keeps the same liveQuery observable/subscription alive so effects can deliver updates when a new model is added.
-    const stableModelsQueryKeyRef = useRef(null);
-    const stableModelsQueryRef = useRef(null);
-    function buildModelsQuery() {
-        const currentDb = BaseDb.getAppDb();
-        if (!currentDb || !schemaId)
-            return null;
-        return currentDb
-            .select({
-            modelFileId: models.schemaFileId,
-            modelName: models.name,
-        })
-            .from(schemas)
-            .innerJoin(modelSchemas, eq(schemas.id, modelSchemas.schemaId))
-            .innerJoin(models, eq(modelSchemas.modelId, models.id))
-            .where(or(eq(schemas.schemaFileId, schemaId), eq(schemas.name, schemaId)));
-    }
-    const modelsQuery = useMemo(() => {
-        if (!schemaId || !isClientReady)
-            return null;
-        const key = { schemaId, ready: isClientReady };
-        const prevKey = stableModelsQueryKeyRef.current;
-        if (prevKey &&
-            prevKey.schemaId === key.schemaId &&
-            prevKey.ready === key.ready &&
-            stableModelsQueryRef.current !== null) {
-            return stableModelsQueryRef.current;
-        }
-        const q = buildModelsQuery();
-        if (!q)
-            return null;
-        stableModelsQueryKeyRef.current = key;
-        stableModelsQueryRef.current = q;
-        return q;
-    }, [schemaId, isClientReady]);
-    const modelsTableData = useLiveQuery(modelsQuery);
-    useEffect(() => {
-        if (!isClientReady || !modelsTableData || !schemaId)
-            return;
-        const currentModelsSet = new Set();
-        for (const model of modelsRef.current) {
-            const modelFileId = model.id || model.modelFileId;
-            if (modelFileId)
-                currentModelsSet.add(modelFileId);
-            else if (model.modelName)
-                currentModelsSet.add(model.modelName);
-        }
-        const tableDataModelsSet = new Set();
-        for (const dbModel of modelsTableData) {
-            if (dbModel.modelFileId)
-                tableDataModelsSet.add(dbModel.modelFileId);
-            else if (dbModel.modelName)
-                tableDataModelsSet.add(dbModel.modelName);
-        }
-        const setsAreEqual = currentModelsSet.size === tableDataModelsSet.size &&
-            [...currentModelsSet].every((id) => tableDataModelsSet.has(id));
-        // Only invalidate when the table has rows we might be missing (live query saw new data).
-        // Do NOT invalidate when we have more than the table: the live query may not have updated
-        // yet (e.g. join over model_schemas), and refetching would overwrite cache with [].
-        const tableHasNewRows = tableDataModelsSet.size > 0 &&
-            [...tableDataModelsSet].some((id) => !currentModelsSet.has(id));
-        if (!setsAreEqual && tableHasNewRows) {
-            queryClient.invalidateQueries({ queryKey });
-        }
-    }, [isClientReady, modelsTableData, schemaId, queryClient, queryKey]);
-    return {
-        models: displayModels,
-        isLoading,
-        error: queryError,
-    };
-};
-/**
- * Hook to get a specific Model instance
- * Can be called in two ways:
- * 1. With schemaId and modelName: useModel(schemaId, modelName)
- * 2. With modelId: useModel(modelId)
- *
- * @param schemaIdOrModelId - The schema ID (schema file ID) OR the model ID (modelFileId)
- * @param modelName - The name of the model to retrieve (required if first param is schemaId)
- * @returns Object with model, isLoading, and error
- */
-const useModel = (schemaIdOrModelId, modelName) => {
-    const isClientReady = useIsClientReady();
-    const [model, setModel] = useState(undefined);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const subscriptionRef = useRef(undefined);
-    const [, setVersion] = useState(0); // Version counter to force re-renders
-    // If modelName is provided, treat first param as schemaId
-    // Otherwise, treat first param as modelId
-    const isModelIdLookup = modelName === undefined || modelName === null;
-    // Determine initial loading state
-    useMemo(() => {
-        if (!isClientReady)
-            return false;
-        if (isModelIdLookup) {
-            return !!schemaIdOrModelId;
-        }
-        else {
-            return !!(schemaIdOrModelId && modelName);
-        }
-    }, [isClientReady, isModelIdLookup, schemaIdOrModelId, modelName]);
-    // Lookup model by ID if needed
-    useEffect(() => {
-        if (!isClientReady || !isModelIdLookup || !schemaIdOrModelId) {
-            setModel(undefined);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        const lookupModelById = async () => {
-            try {
-                setIsLoading(true);
-                setError(null);
-                // Use Model.createById which handles cache + DB lookup
-                const foundModel = await Model.createById(schemaIdOrModelId);
-                setModel(foundModel || undefined);
-                setIsLoading(false);
-                setError(null);
-            }
-            catch (error) {
-                console.error('[useModel] Error looking up model by ID:', error);
-                setModel(undefined);
-                setIsLoading(false);
-                setError(error);
-            }
-        };
-        lookupModelById();
-    }, [isClientReady, isModelIdLookup, schemaIdOrModelId]);
-    // Subscribe to service changes when model is available (for modelId lookup)
-    useEffect(() => {
-        if (!isModelIdLookup || !model) {
-            // Clean up subscription if model is not available
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-            return;
-        }
-        // Clean up previous subscription
-        subscriptionRef.current?.unsubscribe();
-        // Subscribe to service changes
-        const subscription = model.getService().subscribe((snapshot) => {
-            // Force re-render by incrementing version counter
-            setVersion(prev => prev + 1);
-        });
-        subscriptionRef.current = subscription;
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, [isModelIdLookup, model]);
-    // If doing modelId lookup, return the model directly
-    if (isModelIdLookup) {
-        return {
-            model,
-            isLoading,
-            error,
-        };
-    }
-    // Otherwise, use schemaId + modelName lookup via useModels
-    const { models: modelsList, isLoading: modelsLoading, error: modelsError } = useModels(schemaIdOrModelId);
-    const foundModel = useMemo(() => {
-        if (!modelName) {
-            return undefined;
-        }
-        // Try both modelName property and name getter for compatibility
-        return modelsList.find((m) => {
-            const mName = m.modelName ?? m.name;
-            return mName === modelName;
-        });
-    }, [modelsList, modelName]);
-    // Subscribe to service changes when model is available (for schemaId + modelName lookup)
-    useEffect(() => {
-        if (isModelIdLookup || !foundModel) {
-            // Clean up subscription if model is not available
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-            return;
-        }
-        // Clean up previous subscription
-        subscriptionRef.current?.unsubscribe();
-        // Subscribe to service changes
-        const subscription = foundModel.getService().subscribe((snapshot) => {
-            // Force re-render by incrementing version counter
-            setVersion(prev => prev + 1);
-        });
-        subscriptionRef.current = subscription;
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, [isModelIdLookup, foundModel]);
-    // For schemaId + modelName lookup, derive loading/error from useModels
-    return {
-        model: foundModel,
-        isLoading: modelsLoading,
-        error: modelsError,
-    };
-};
-const useCreateModel = () => {
-    const subscriptionRef = useRef(undefined);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const resetError = useCallback(() => setError(null), []);
-    const create = useCallback((schemaName, modelName, options) => {
-        setError(null);
-        setIsLoading(true);
-        subscriptionRef.current?.unsubscribe();
-        subscriptionRef.current = undefined;
-        const model = Model.create(modelName, schemaName, {
-            ...options,
-            waitForReady: false,
-        });
-        const subscription = model.getService().subscribe((snapshot) => {
-            if (snapshot.value === 'error') {
-                setError(snapshot.context._loadingError?.error ??
-                    new Error('Failed to create model'));
-                setIsLoading(false);
-            }
-            if (snapshot.value === 'idle') {
-                setError(null);
-                setIsLoading(false);
-            }
-        });
-        subscriptionRef.current = subscription;
-        return model;
-    }, []);
-    useEffect(() => {
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, []);
-    return {
-        create,
-        isLoading,
-        error,
-        resetError,
-    };
-};
-const useDestroyModel = () => {
-    const [currentInstance, setCurrentInstance] = useState(null);
-    const [destroyState, setDestroyState] = useState({
-        isLoading: false,
-        error: null,
-    });
-    useEffect(() => {
-        if (!currentInstance) {
-            setDestroyState({ isLoading: false, error: null });
-            return;
-        }
-        const service = currentInstance.getService();
-        const update = () => {
-            const snap = service.getSnapshot();
-            const ctx = snap.context;
-            setDestroyState({
-                isLoading: !!ctx._destroyInProgress,
-                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
-            });
-        };
-        update();
-        const sub = service.subscribe(update);
-        return () => sub.unsubscribe();
-    }, [currentInstance]);
-    const destroy = useCallback(async (model) => {
-        if (!model)
-            return;
-        setCurrentInstance(model);
-        await model.destroy();
-    }, []);
-    const resetError = useCallback(() => {
-        if (currentInstance) {
-            currentInstance.getService().send({ type: 'clearDestroyError' });
-        }
-    }, [currentInstance]);
-    return {
-        destroy,
-        isLoading: destroyState.isLoading,
-        error: destroyState.error,
-        resetError,
-    };
+const getMetadataAttestationUidsForSeedUid = async (seedUid) => {
+    if (!seedUid)
+        return [];
+    const appDb = BaseDb.getAppDb();
+    const rows = await appDb
+        .select({ uid: metadata.uid, schemaUid: metadata.schemaUid })
+        .from(metadata)
+        .where(and(eq(metadata.seedUid, seedUid), isNotNull(metadata.uid), ne(metadata.uid, ''), ne(metadata.uid, '0x' + '0'.repeat(64))));
+    return rows
+        .filter((r) => r.uid != null && r.schemaUid != null)
+        .map((r) => ({ uid: r.uid, schemaUid: r.schemaUid }));
 };
 
-debug('seedSdk:browser:react:modelProperty');
-/**
- * Hook to get all ModelProperty instances for a specific model
- * Can be called in two ways:
- * 1. With schemaId and modelName: useModelProperties(schemaId, modelName)
- * 2. With modelId: useModelProperties(modelId)
- *
- * Uses useLiveQuery to watch for changes in the properties table and automatically
- * updates the returned ModelProperty instances when changes occur.
- *
- * @param schemaIdOrModelId - The schema ID (schema file ID) OR the model ID (modelFileId)
- * @param modelName - The name of the model to get properties from (required if first param is schemaId)
- * @returns Object with modelProperties array, isLoading, and error
- */
-const useModelProperties = (schemaIdOrModelId, modelName) => {
-    // Use useModel to handle both lookup patterns (by ID or by schemaId + modelName)
-    const { model } = useModel(schemaIdOrModelId, modelName);
-    // Determine the modelName for use in getPropertySchema
-    useMemo(() => {
-        if (!model)
-            return undefined;
-        try {
-            return model.modelName ?? model.name;
-        }
-        catch {
-            return undefined;
-        }
-    }, [model]);
-    const isClientReady = useIsClientReady();
-    const queryClient = useQueryClient();
-    // Get _dbId (database ID) from model context
-    const dbModelId = useMemo(() => {
-        if (!model)
-            return null;
+function getAttesterFromRow(row) {
+    if (row.publisher)
+        return row.publisher;
+    if (row.attestationRaw) {
         try {
-            const context = model._getSnapshotContext();
-            return context._dbId;
+            const parsed = JSON.parse(row.attestationRaw);
+            return parsed.attester ?? null;
         }
         catch {
             return null;
         }
-    }, [model]);
-    const modelId = model?.id;
-    const modelPropertiesQueryKey = useMemo(() => ['seed', 'modelProperties', modelId ?? ''], [modelId]);
-    const { data: modelProperties = [], isLoading, error: queryError, } = useQuery({
-        queryKey: modelPropertiesQueryKey,
-        queryFn: () => ModelProperty.all(modelId, { waitForReady: true }),
-        enabled: isClientReady && !!modelId,
-    });
-    const db = isClientReady ? BaseDb.getAppDb() : null;
-    const propertiesQuery = useMemo(() => {
-        if (!db || !dbModelId)
-            return null;
-        return db
-            .select({
-            id: properties.id,
-            name: properties.name,
-            dataType: properties.dataType,
-            schemaFileId: properties.schemaFileId,
-        })
-            .from(properties)
-            .where(eq(properties.modelId, dbModelId));
-    }, [db, isClientReady, dbModelId]);
-    const propertiesTableData = useLiveQuery(propertiesQuery);
-    const modelPropertiesRef = useRef([]);
-    modelPropertiesRef.current = modelProperties;
-    // Fallback: when we have modelId but query returned [] (e.g. properties not in DB yet or
-    // propertiesTableData is undefined because model._dbId isn't set yet), schedule refetches
-    // so we pick up properties after they're written.
-    useEffect(() => {
-        if (!modelId || modelProperties.length > 0 || !queryClient || !modelPropertiesQueryKey)
-            return;
-        const delays = [400, 1200, 2500];
-        const timers = delays.map((ms) => setTimeout(() => {
-            queryClient.invalidateQueries({ queryKey: modelPropertiesQueryKey });
-        }, ms));
-        return () => timers.forEach((t) => clearTimeout(t));
-    }, [modelId, modelProperties.length, queryClient, modelPropertiesQueryKey]);
-    useEffect(() => {
-        if (!isClientReady || !model?.id || !propertiesTableData || !modelPropertiesQueryKey)
-            return;
-        const currentPropertiesSet = new Set();
-        for (const prop of modelPropertiesRef.current) {
-            const context = prop._getSnapshotContext();
-            const propertyFileId = context?.id;
-            if (propertyFileId)
-                currentPropertiesSet.add(propertyFileId);
-            else if (prop.name)
-                currentPropertiesSet.add(prop.name);
-        }
-        const tableDataPropertiesSet = new Set();
-        for (const dbProperty of propertiesTableData) {
-            if (dbProperty.schemaFileId)
-                tableDataPropertiesSet.add(dbProperty.schemaFileId);
-            else if (dbProperty.name)
-                tableDataPropertiesSet.add(dbProperty.name);
-        }
-        const setsAreEqual = currentPropertiesSet.size === tableDataPropertiesSet.size &&
-            (currentPropertiesSet.size === 0 ||
-                [...currentPropertiesSet].every((id) => tableDataPropertiesSet.has(id)));
-        // Invalidate when cached list is out of sync with the table: either we have stale cached data
-        // (currentPropertiesSet.size > 0) or the table has new rows we don't have yet (tableDataPropertiesSet.size > 0).
-        // The latter handles the case where the initial query returned [] before properties were written.
-        const shouldInvalidate = !setsAreEqual && (currentPropertiesSet.size > 0 || tableDataPropertiesSet.size > 0);
-        if (shouldInvalidate) {
-            queryClient.invalidateQueries({ queryKey: modelPropertiesQueryKey });
-        }
-    }, [isClientReady, propertiesTableData, model?.id, queryClient, modelPropertiesQueryKey]);
-    // When we have cached modelProperties, do not report isLoading: true even if the query
-    // is refetching (e.g. after useModels refetch causes modelId to change briefly). UX expects
-    // isLoading false once we have shown data.
-    const effectiveIsLoading = isLoading && modelProperties.length === 0;
-    return {
-        modelProperties,
-        isLoading: effectiveIsLoading,
-        error: queryError,
-    };
-};
-/**
- * Helper function to get property schema by modelFileId and propertyName
- */
-const getPropertySchemaByModelFileId = async (modelFileId, propertyName) => {
-    // Get model by modelFileId
-    const model = await Model.createById(modelFileId);
-    if (!model) {
-        return undefined;
-    }
-    // Get modelName from model
-    const modelName = model.modelName ?? model.name;
-    if (!modelName) {
-        return undefined;
-    }
-    // Use existing getPropertySchema function
-    return getPropertySchema(modelName, propertyName);
-};
-function useModelProperty(arg1, arg2, arg3) {
-    // Determine initial loading state - start loading if we have valid parameters
-    const initialLoadingState = useMemo(() => {
-        if (arg3 !== undefined && arg3 !== null) {
-            // Three arguments: schemaId, modelName, propertyName
-            return !!(arg1 && arg2 && arg3);
-        }
-        else if (arg2 !== undefined && arg2 !== null) {
-            // Two arguments: modelFileId, propertyName
-            return !!(arg1 && arg2);
-        }
-        else {
-            // One argument: propertyFileId
-            return !!arg1;
-        }
-    }, [arg1, arg2, arg3]);
-    const [modelProperty, setModelProperty] = useState(undefined);
-    const [isLoading, setIsLoading] = useState(initialLoadingState);
-    const [error, setError] = useState(null);
-    const subscriptionRef = useRef(undefined);
-    const isClientReady = useIsClientReady();
-    // Determine which lookup mode we're in based on arguments
-    const lookupMode = useMemo(() => {
-        if (arg3 !== undefined && arg3 !== null) {
-            // Three arguments: schemaId, modelName, propertyName
-            return { type: 'schemaId', schemaId: arg1, modelName: arg2, propertyName: arg3 };
-        }
-        else if (arg2 !== undefined && arg2 !== null) {
-            // Two arguments: modelFileId, propertyName
-            return { type: 'modelFileId', modelFileId: arg1, propertyName: arg2 };
-        }
-        else {
-            // One argument: propertyFileId
-            return { type: 'propertyFileId', propertyFileId: arg1 };
-        }
-    }, [arg1, arg2, arg3]);
-    // Determine if we should be loading based on parameters
-    const shouldLoad = useMemo(() => {
-        if (!isClientReady)
-            return false;
-        if (lookupMode.type === 'propertyFileId') {
-            return !!lookupMode.propertyFileId;
-        }
-        else if (lookupMode.type === 'modelFileId') {
-            return !!(lookupMode.modelFileId && lookupMode.propertyName);
-        }
-        else {
-            return !!(lookupMode.schemaId && lookupMode.modelName && lookupMode.propertyName);
-        }
-    }, [isClientReady, lookupMode]);
-    const updateModelProperty = useCallback(async () => {
-        if (!isClientReady) {
-            setModelProperty(undefined);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        let propertyData;
-        let resolvedModelName;
-        try {
-            setIsLoading(true);
-            setError(null);
-            if (lookupMode.type === 'propertyFileId') {
-                if (!lookupMode.propertyFileId) {
-                    setModelProperty(undefined);
-                    setIsLoading(false);
-                    setError(null);
-                    return;
-                }
-                // Use ModelProperty.createById for propertyFileId lookup
-                const foundProperty = await ModelProperty.createById(lookupMode.propertyFileId);
-                if (foundProperty) {
-                    setModelProperty(foundProperty);
-                    setIsLoading(false);
-                    setError(null);
-                }
-                else {
-                    setModelProperty(undefined);
-                    setIsLoading(false);
-                    setError(null);
-                }
-                return;
-            }
-            else if (lookupMode.type === 'modelFileId') {
-                if (!lookupMode.modelFileId || !lookupMode.propertyName) {
-                    setModelProperty(undefined);
-                    setIsLoading(false);
-                    setError(null);
-                    return;
-                }
-                // Get property schema by modelFileId and propertyName
-                // This function already gets the model and resolves modelName
-                propertyData = await getPropertySchemaByModelFileId(lookupMode.modelFileId, lookupMode.propertyName);
-                // Get modelName from model (needed for ModelProperty.create)
-                const model = await Model.createById(lookupMode.modelFileId);
-                resolvedModelName = model?.modelName ?? model?.name;
-            }
-            else {
-                // lookupMode.type === 'schemaId'
-                if (!lookupMode.schemaId || !lookupMode.modelName || !lookupMode.propertyName) {
-                    setModelProperty(undefined);
-                    setIsLoading(false);
-                    setError(null);
-                    return;
-                }
-                // Use existing getPropertySchema for schemaId + modelName + propertyName
-                propertyData = await getPropertySchema(lookupMode.modelName, lookupMode.propertyName);
-                resolvedModelName = lookupMode.modelName;
-            }
-            if (propertyData && resolvedModelName) {
-                const createdProperty = ModelProperty.create({ ...propertyData, modelName: resolvedModelName }, { waitForReady: false });
-                const resolvedProperty = createdProperty instanceof Promise ? await createdProperty : createdProperty;
-                flushSync(() => {
-                    setModelProperty(resolvedProperty);
-                    setIsLoading(false);
-                    setError(null);
-                });
-            }
-            else {
-                setModelProperty(undefined);
-                setIsLoading(false);
-                setError(null);
-            }
-        }
-        catch (error) {
-            console.error('[useModelProperty] Error updating model property:', error);
-            setModelProperty(undefined);
-            setIsLoading(false);
-            setError(error);
-        }
-    }, [isClientReady, lookupMode.type, lookupMode.propertyFileId, lookupMode.modelFileId, lookupMode.propertyName, lookupMode.schemaId, lookupMode.modelName]);
-    // Fetch/refetch when lookup parameters change or client becomes ready
-    useEffect(() => {
-        if (!shouldLoad) {
-            setModelProperty(undefined);
-            setIsLoading(false);
-            setError(null);
-            return;
-        }
-        updateModelProperty();
-    }, [shouldLoad, updateModelProperty]);
-    // Subscribe to service changes when modelProperty is available.
-    // Skip subscription for schemaId/modelFileId lookups where we created the instance locally—
-    // refetching on every snapshot would set loading and can race with the initial render.
-    // Debounce to reduce refetch frequency and avoid updateContext/refetch loops.
-    const shouldSubscribe = lookupMode.type === 'propertyFileId';
-    useEffect(() => {
-        if (!modelProperty || !shouldSubscribe) {
-            return;
-        }
-        // Clean up previous subscription
-        subscriptionRef.current?.unsubscribe();
-        const debouncedUpdate = debounce(updateModelProperty, 100);
-        // Subscribe to service changes
-        const subscription = modelProperty.getService().subscribe(() => {
-            debouncedUpdate();
-        });
-        subscriptionRef.current = subscription;
-        return () => {
-            debouncedUpdate.cancel();
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, [modelProperty, updateModelProperty, shouldSubscribe]);
-    return {
-        modelProperty,
-        isLoading,
-        error,
-    };
-}
-/**
- * Hook to create a ModelProperty with loading and error state.
- * create(schemaId, modelName, property) creates a new property on the model.
- */
-const useCreateModelProperty = () => {
-    const subscriptionRef = useRef(undefined);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const resetError = useCallback(() => setError(null), []);
-    const create = useCallback((schemaId, modelName, property) => {
-        setError(null);
-        setIsLoading(true);
-        subscriptionRef.current?.unsubscribe();
-        subscriptionRef.current = undefined;
-        if (!modelName || !property.name || !property.dataType) {
-            const err = new Error('modelName, property name and dataType are required');
-            setError(err);
-            setIsLoading(false);
-            throw err;
-        }
-        // Resolve schema name: schemaId may be "Blog-1" (schemaName-version) or just "Blog"
-        const schemaName = getSchemaNameFromId(schemaId) ?? schemaId;
-        const created = ModelProperty.create({ ...property, modelName }, { waitForReady: false, schemaName });
-        const subscription = created.getService().subscribe((snapshot) => {
-            if (snapshot.value === 'error') {
-                const err = snapshot.context._loadingError?.error ?? new Error('Failed to create model property');
-                setError(err instanceof Error ? err : new Error(String(err)));
-                setIsLoading(false);
-            }
-            if (snapshot.value === 'idle') {
-                setError(null);
-                setIsLoading(false);
-            }
-        });
-        subscriptionRef.current = subscription;
-        return created;
-    }, []);
-    useEffect(() => {
-        return () => {
-            subscriptionRef.current?.unsubscribe();
-            subscriptionRef.current = undefined;
-        };
-    }, []);
-    return {
-        create,
-        isLoading,
-        error,
-        resetError,
-    };
-};
-const useDestroyModelProperty = () => {
-    const [currentInstance, setCurrentInstance] = useState(null);
-    const [destroyState, setDestroyState] = useState({
-        isLoading: false,
-        error: null,
-    });
-    useEffect(() => {
-        if (!currentInstance) {
-            setDestroyState({ isLoading: false, error: null });
-            return;
-        }
-        const service = currentInstance.getService();
-        const update = () => {
-            const snap = service.getSnapshot();
-            const ctx = snap.context;
-            setDestroyState({
-                isLoading: !!ctx._destroyInProgress,
-                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
-            });
-        };
-        update();
-        const sub = service.subscribe(update);
-        return () => sub.unsubscribe();
-    }, [currentInstance]);
-    const destroy = useCallback(async (modelProperty) => {
-        if (!modelProperty)
-            return;
-        setCurrentInstance(modelProperty);
-        await modelProperty.destroy();
-    }, []);
-    const resetError = useCallback(() => {
-        if (currentInstance) {
-            currentInstance.getService().send({ type: 'clearDestroyError' });
-        }
-    }, [currentInstance]);
-    return {
-        destroy,
-        isLoading: destroyState.isLoading,
-        error: destroyState.error,
-        resetError,
-    };
-};
-
-const useDeleteItem = () => {
-    const [currentInstance, setCurrentInstance] = useState(null);
-    const [destroyState, setDestroyState] = useState({
-        isLoading: false,
-        error: null,
-    });
-    useEffect(() => {
-        if (!currentInstance) {
-            setDestroyState({ isLoading: false, error: null });
-            return;
-        }
-        const service = currentInstance.getService();
-        const update = () => {
-            const snap = service.getSnapshot();
-            const ctx = snap.context;
-            setDestroyState({
-                isLoading: !!ctx._destroyInProgress,
-                error: ctx._destroyError ? new Error(ctx._destroyError.message) : null,
-            });
-        };
-        update();
-        const sub = service.subscribe(update);
-        return () => sub.unsubscribe();
-    }, [currentInstance]);
-    const destroy = useCallback(async (item) => {
-        if (!item)
-            return;
-        setCurrentInstance(item);
-        await item.destroy();
-    }, []);
-    const resetError = useCallback(() => {
-        if (currentInstance) {
-            currentInstance.getService().send({ type: 'clearDestroyError' });
-        }
-    }, [currentInstance]);
-    return {
-        deleteItem: destroy,
-        isLoading: destroyState.isLoading,
-        error: destroyState.error,
-        resetError,
-    };
-};
-
-const IMAGE_FILES_QUERY_KEY = ['seed', 'imageFiles'];
-/**
- * Returns an up-to-date list of image filenames stored in the file system (OPFS in browser).
- * Automatically refetches when images are saved (file-saved) or after bulk downloads (fs.downloadAll.success).
- *
- * Must be used within SeedProvider and after client.init().
- *
- * @example
- * ```tsx
- * const { imageFiles, isLoading, error, refetch } = useImageFiles()
- * // imageFiles: ['photo.jpg', 'cover.png']
- * ```
- */
-function useImageFiles() {
-    const isClientReady = useIsClientReady();
-    const queryClient = useQueryClient();
-    const { data: imageFiles = [], isLoading, error, refetch, } = useQuery({
-        queryKey: IMAGE_FILES_QUERY_KEY,
-        queryFn: () => BaseFileManager.listImageFiles(),
-        enabled: isClientReady,
-    });
-    useEffect(() => {
-        const fileSavedHandler = (filePath) => {
-            if (filePath.includes('/images/')) {
-                queryClient.invalidateQueries({ queryKey: IMAGE_FILES_QUERY_KEY });
-            }
-        };
-        const downloadSuccessHandler = () => {
-            queryClient.invalidateQueries({ queryKey: IMAGE_FILES_QUERY_KEY });
-        };
-        eventEmitter.on('file-saved', fileSavedHandler);
-        eventEmitter.on('fs.downloadAll.success', downloadSuccessHandler);
-        return () => {
-            eventEmitter.off('file-saved', fileSavedHandler);
-            eventEmitter.off('fs.downloadAll.success', downloadSuccessHandler);
-        };
-    }, [queryClient]);
-    return {
-        imageFiles,
-        isLoading,
-        error: error instanceof Error ? error : null,
-        refetch,
-    };
-}
-
-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().
+ * Returns the attester address for a seed (from seeds.publisher or attestationRaw.attester).
+ * Used when revoking attestations to determine which account must perform the revoke.
  *
- * - No props: uses an internal QueryClient with Seed defaults.
- * - queryClient prop: use your own client (e.g. merge getSeedQueryDefaultOptions when creating it).
+ * @param seedLocalId - Optional seed local ID
+ * @param seedUid - Optional seed UID (attestation ID)
+ * @returns The attester address, or null if not found or no attester
  */
-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));
+async function getAttesterForSeed(params) {
+    const { seedLocalId, seedUid } = params;
+    const appDb = BaseDb.getAppDb();
+    if (!appDb)
+        return null;
+    const conditions = [];
+    if (seedLocalId)
+        conditions.push(eq(seeds.localId, seedLocalId));
+    if (seedUid)
+        conditions.push(eq(seeds.uid, seedUid));
+    if (conditions.length === 0)
+        return null;
+    const seedRows = await appDb
+        .select({
+        publisher: seeds.publisher,
+        attestationRaw: seeds.attestationRaw,
+    })
+        .from(seeds)
+        .where(conditions.length === 1 ? conditions[0] : or(...conditions))
+        .limit(1);
+    if (!seedRows || seedRows.length === 0)
+        return null;
+    return getAttesterFromRow(seedRows[0]);
 }
 
 /**
@@ -2251,15 +152,39 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
     }
     visited.add(seedLocalId);
     const result = [];
-    const { itemRelationProperties, itemImageProperties, itemListProperties } = getSegmentedItemProperties(item);
-    const getItemMod = await import('./getItem-B_IP-uNX.js');
+    const { itemRelationProperties, itemImageProperties, itemListProperties } = await getSegmentedItemProperties(item);
+    const getItemMod = await import('./getItem-ClK0UZqi.js');
     const { getItem } = getItemMod;
     const processRelationOrImage = async (prop) => {
         const snapshot = prop.getService().getSnapshot();
         const context = snapshot.context ?? null;
         if (!context)
             return;
-        const value = context.propertyValue;
+        let value = context.propertyValue;
+        // File/Image/Html/Json: fallback to metadata when propertyValue is empty (e.g. schema-loaded before metadata)
+        const isStorageSeed = prop.propertyDef?.dataType === 'File' ||
+            prop.propertyDef?.dataType === 'Image' ||
+            prop.propertyDef?.dataType === 'Html' ||
+            prop.propertyDef?.dataType === 'Json' ||
+            (prop.propertyDef?.dataType === 'Relation' &&
+                (prop.propertyDef?.refValueType === 'File' ||
+                    prop.propertyDef?.refValueType === 'Image' ||
+                    prop.propertyDef?.refValueType === 'Html' ||
+                    prop.propertyDef?.refValueType === 'Json'));
+        if (!value && prop.propertyName && isStorageSeed) {
+            const ctx = context;
+            if (ctx.seedLocalId || ctx.seedUid) {
+                const _mod_0 = await import('./index-uPXtq2cf.js');
+                const _ns_0 = _mod_0.bs;
+                const { getPropertyData } = _ns_0;
+                const meta = await getPropertyData({
+                    propertyName: prop.propertyName,
+                    seedLocalId: ctx.seedLocalId,
+                    seedUid: ctx.seedUid,
+                });
+                value = meta?.propertyValue;
+            }
+        }
         if (!value)
             return;
         const { localId: seedLocalId, uid: seedUid } = getCorrectId(value);
@@ -2273,7 +198,9 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
         await processRelationOrImage(prop);
     }
     for (const listProperty of itemListProperties) {
-        if (!listProperty.propertyDef?.ref)
+        const listRef = listProperty.propertyDef?.ref ||
+            listProperty.propertyDef?.refModelName;
+        if (!listRef)
             continue;
         const snapshot = listProperty.getService().getSnapshot();
         const context = snapshot.context ?? null;
@@ -2282,15 +209,8 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
         let value = context.propertyValue;
         if (!value || listProperty.uid)
             continue;
-        if (typeof value === 'string' && value.length === 66)
-            value = [value];
-        if (typeof value === 'string' && value.length > 66) {
-            try {
-                value = JSON.parse(value);
-            }
-            catch {
-                value = value.split(',');
-            }
+        if (typeof value === 'string') {
+            value = parseListPropertyValueFromStorage(value);
         }
         const arr = Array.isArray(value) ? value : [];
         for (const seedId of arr) {
@@ -2305,5 +225,5 @@ async function getRelatedItemsForPublish(item, visited = new Set()) {
     return result;
 }
 
-export { BaseFileManager as FileManager, Item, ItemProperty, Model, ModelProperty, Schema, SeedProvider, createSeedQueryClient, getCorrectId, getPropertySchema, getRelatedItemsForPublish, getSchemaNameFromId, getSeedQueryDefaultOptions, getSegmentedItemProperties, invalidateItemPropertiesForItem, mergeSeedQueryDefaults, useAllSchemaVersions, useCreateItem, useCreateItemProperty, useCreateModel, useCreateModelProperty, useCreateSchema, useDeleteItem, useDestroyItemProperty, useDestroyModel, useDestroyModelProperty, useDestroySchema, useImageFiles, useItem, useItemProperties, useItemProperty, useItems, useModel, useModelProperties, useModelProperty, useModels, usePublishItem, useSchema, useSchemas };
+export { BaseDb, getAttesterForSeed, getCorrectId, getMetadataAttestationUidsForSeedUid, getRelatedItemsForPublish, getSegmentedItemProperties, getVersionsForSeedUid, metadata, seeds, updateVersionUid, versions };
 //# sourceMappingURL=main.js.map