@seedprotocol/sdk 0.4.7 → 0.4.8

package/dist/main.js

@@ -1,18 +1,21 @@
 import 'reflect-metadata';
-import { an as getClient, ao as ClientManagerState, j as BaseDb, a1 as Item, s as seeds, ap as getVersionData, aq as createNewItem, G as metadata, a5 as ItemProperty, Y as schemas, ar as loadAllSchemasFromDb, M as Model, r as models, K as modelSchemas, u as properties, a6 as eventEmitter, y as BaseEasClient, as as getSeedsBySchemaName, at as GET_SEEDS, au as getItemVersionsFromEas, av as getItemPropertiesFromEas, w as BaseArweaveClient, aw as setSchemaUidForSchemaDefinition, ax as parseEasRelationPropertyName } from './index-zsq08F5p.js';
-export { z as FileManager, a as ModelPropertyDataTypes, aB as SeedModels, a7 as client, aD as createSchema, aC as getArweaveUrlForTransaction, ay as getModelSchemasFromEas, aG as getSchemaNameFromId, az as getSchemaUidBySchemaName, aA as getSeedsFromSchemaUids, aa as importJsonSchema, aF as listSchemas, ac as readJsonImportFile, aE as readSchema, ad as transformImportToSchemaFile, ag as waitForEntityIdle } from './index-zsq08F5p.js';
-import { g as getPropertySchema } from './property-Cqh_o0zx.js';
-import { ModelProperty } from './ModelProperty-D4zaeIOT.js';
-import { S as Schema } from './Schema-SbwqmoMM.js';
-export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './Schema-SbwqmoMM.js';
+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-j8WN8W6V.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, ah as waitForEntityIdle } from './index-j8WN8W6V.js';
+import { g as getPropertySchema } from './property-C6qoOzLG.js';
+import { ModelProperty } from './ModelProperty-B9Z2DRxI.js';
+import { S as Schema } from './Schema-D1-HjT8z.js';
+export { a as deleteModelFromSchema, d as deletePropertyFromModel, r as renameModelProperty, u as updateModelProperties } from './Schema-D1-HjT8z.js';
 import React, { useState, useRef, useMemo, useEffect, useCallback } from 'react';
 import { flushSync } from 'react-dom';
-import { orderBy, startCase } from 'lodash-es';
+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-Di9vevKz.js';
+export { getFeedItemsBySchemaName } from '@seedprotocol/feed';
+export { resolvePublishPayloadValues } from './getPublishPayload-BBI_j9I2.js';
 import 'js-yaml';
 import 'fs';
 import 'xstate';
@@ -25,7 +28,7 @@ import 'drizzle-orm/casing';
 import 'eventemitter3';
 import 'arweave';
 import '@sinclair/typebox';
-import './SchemaValidationService-DHGIw4Nx.js';
+import './SchemaValidationService-CIXKzSpb.js';
 import '@sinclair/typebox/value';
 
 const useIsClientReady = () => {
@@ -619,8 +622,8 @@ async function fetchItemPropertiesList(seedLocalId, seedUid) {
     const modelProperties = [];
     if (modelName) {
         try {
-            const _mod_0 = await import('./index-zsq08F5p.js');
-            const _ns_0 = _mod_0.aX;
+            const _mod_0 = await import('./index-j8WN8W6V.js');
+            const _ns_0 = _mod_0.a$;
             const modelMod = _ns_0;
             const { Model } = modelMod;
             const model = await Model.getByNameAsync(modelName);
@@ -1047,6 +1050,20 @@ const useSchemas = () => {
         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;
@@ -1085,7 +1102,14 @@ const useSchemas = () => {
         }
         const setsAreEqual = currentSchemasSet.size === tableDataSchemasSet.size &&
             [...currentSchemasSet].every((id) => tableDataSchemasSet.has(id));
-        if (!setsAreEqual) {
+        // 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]);
@@ -1708,9 +1732,13 @@ const useModelProperties = (schemaIdOrModelId, modelName) => {
             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,
+        isLoading: effectiveIsLoading,
         error: queryError,
     };
 };
@@ -1875,6 +1903,7 @@ function useModelProperty(arg1, arg2, arg3) {
     // 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) {
@@ -1882,12 +1911,14 @@ function useModelProperty(arg1, arg2, arg3) {
         }
         // Clean up previous subscription
         subscriptionRef.current?.unsubscribe();
+        const debouncedUpdate = debounce(updateModelProperty, 100);
         // Subscribe to service changes
-        const subscription = modelProperty.getService().subscribe((snapshot) => {
-            updateModelProperty();
+        const subscription = modelProperty.getService().subscribe(() => {
+            debouncedUpdate();
         });
         subscriptionRef.current = subscription;
         return () => {
+            debouncedUpdate.cancel();
             subscriptionRef.current?.unsubscribe();
             subscriptionRef.current = undefined;
         };
@@ -1907,7 +1938,7 @@ const useCreateModelProperty = () => {
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const resetError = useCallback(() => setError(null), []);
-    const create = useCallback((_schemaId, modelName, property) => {
+    const create = useCallback((schemaId, modelName, property) => {
         setError(null);
         setIsLoading(true);
         subscriptionRef.current?.unsubscribe();
@@ -1918,7 +1949,9 @@ const useCreateModelProperty = () => {
             setIsLoading(false);
             throw err;
         }
-        const created = ModelProperty.create({ ...property, modelName }, { waitForReady: false });
+        // 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');
@@ -2032,6 +2065,51 @@ const useDeleteItem = () => {
     };
 };
 
+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',
@@ -2162,530 +2240,71 @@ function SeedProvider({ children, queryClient: queryClientProp, queryClientRef }
         children));
 }
 
-debug('seedSdk:feed');
-const relationValuesToExclude = [
-    '0x0000000000000000000000000000000000000000000000000000000000000020',
-];
-// Helper to convert snake_case to camelCase
-const toCamelCase = (str) => {
-    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-};
-// Helper to format timestamp as RFC 822 date string for RSS pubDate
-const formatRfc822Date = (timestamp) => {
-    const date = new Date(timestamp * 1000); // Convert from seconds to milliseconds
-    const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    const day = days[date.getUTCDay()];
-    const month = months[date.getUTCMonth()];
-    const year = date.getUTCFullYear();
-    const dayNum = date.getUTCDate().toString().padStart(2, '0');
-    const hours = date.getUTCHours().toString().padStart(2, '0');
-    const minutes = date.getUTCMinutes().toString().padStart(2, '0');
-    const seconds = date.getUTCSeconds().toString().padStart(2, '0');
-    return `${day}, ${dayNum} ${month} ${year} ${hours}:${minutes}:${seconds} GMT`;
-};
-// Helper to set default values for feed items
-const setFeedItemDefaults = (item, seedUid, schemaName) => {
-    // Set default title if not present (check both snake_case and camelCase)
-    if (!item.title && !item.Title) {
-        item.title = seedUid;
-        item.Title = seedUid; // Also set camelCase version
-    }
-    else if (item.title && !item.Title) {
-        item.Title = item.title;
-    }
-    else if (item.Title && !item.title) {
-        item.title = item.Title;
-    }
-    // Set default link/guid using seedUid or storage_transaction_id
-    // Handle empty strings, null, and undefined - check both formats
-    const storageTransactionIdSnake = item.storage_transaction_id &&
-        typeof item.storage_transaction_id === 'string' &&
-        item.storage_transaction_id.trim() !== '' &&
-        item.storage_transaction_id !== 'undefined' &&
-        item.storage_transaction_id !== seedUid // Don't use seedUid as transaction ID
-        ? item.storage_transaction_id.trim()
-        : null;
-    const storageTransactionIdCamel = item.storageTransactionId &&
-        typeof item.storageTransactionId === 'string' &&
-        item.storageTransactionId.trim() !== '' &&
-        item.storageTransactionId !== 'undefined' &&
-        item.storageTransactionId !== seedUid // Don't use seedUid as transaction ID
-        ? item.storageTransactionId.trim()
-        : null;
-    const storageTransactionId = storageTransactionIdSnake || storageTransactionIdCamel;
-    console.log('[feed] [setFeedItemDefaults] Setting defaults for item:', {
-        seedUid,
-        schemaName,
-        hasStorageTransactionIdSnake: !!storageTransactionIdSnake,
-        hasStorageTransactionIdCamel: !!storageTransactionIdCamel,
-        storageTransactionIdSnakeValue: item.storage_transaction_id,
-        storageTransactionIdCamelValue: item.storageTransactionId,
-        storageTransactionId,
-        itemKeys: Object.keys(item),
-    });
-    // If there's a valid storageTransactionId (not seedUid), use Arweave URL for the link
-    // Otherwise, build URL based on schema name (e.g., /images/ for image schema, /posts/ for post schema)
-    let defaultLink;
-    if (storageTransactionId && storageTransactionId !== seedUid && storageTransactionId.length > 0) {
-        try {
-            defaultLink = BaseArweaveClient.getRawUrl(storageTransactionId);
-            console.log('[feed] [setFeedItemDefaults] Using Arweave URL for storageTransactionId:', defaultLink);
-        }
-        catch (error) {
-            console.error('[feed] [setFeedItemDefaults] Error generating Arweave URL:', error);
-            // Fallback to default link format
-            const basePath = schemaName === 'image' ? 'images' : schemaName === 'post' ? 'posts' : schemaName.toLowerCase() + 's';
-            const baseUrl = 'https://seedprotocol.io';
-            defaultLink = `${baseUrl}/${basePath}/${seedUid || 'unknown'}`;
-        }
-    }
-    else {
-        const basePath = schemaName === 'image' ? 'images' : schemaName === 'post' ? 'posts' : schemaName.toLowerCase() + 's';
-        const baseUrl = 'https://seedprotocol.io';
-        // Ensure seedUid is valid, use 'unknown' as fallback to prevent 'undefined' in URLs
-        const validSeedUid = seedUid && typeof seedUid === 'string' && seedUid.trim() !== '' ? seedUid : 'unknown';
-        defaultLink = `${baseUrl}/${basePath}/${validSeedUid}`;
-        console.log('[feed] [setFeedItemDefaults] Using default link format:', defaultLink, { seedUid, validSeedUid });
-    }
-    // Always ensure link is set (override if undefined, null, empty, or the string "undefined")
-    const currentLink = item.link || item.Link;
-    if (!currentLink || currentLink === 'undefined' || (typeof currentLink === 'string' && currentLink.trim() === '')) {
-        item.link = defaultLink;
-        item.Link = defaultLink;
-        console.log('[feed] [setFeedItemDefaults] Set link to:', defaultLink);
-    }
-    else {
-        // Ensure both formats are set
-        if (!item.link || item.link === 'undefined') {
-            item.link = currentLink;
-        }
-        if (!item.Link || item.Link === 'undefined') {
-            item.Link = currentLink;
-        }
-    }
-    // Always ensure guid is set (use link if available, otherwise default)
-    const currentGuid = item.guid || item.Guid;
-    if (!currentGuid || currentGuid === 'undefined' || (typeof currentGuid === 'string' && currentGuid.trim() === '')) {
-        item.guid = item.link || defaultLink;
-        item.Guid = item.guid;
-        console.log('[feed] [setFeedItemDefaults] Set guid to:', item.guid);
-    }
-    else {
-        // Ensure both formats are set
-        if (!item.guid || item.guid === 'undefined') {
-            item.guid = currentGuid;
-        }
-        if (!item.Guid || item.Guid === 'undefined') {
-            item.Guid = currentGuid;
-        }
-    }
-    // Set pubDate from timeCreated if available
-    if (item.timeCreated && !item.pubDate && !item.PubDate) {
-        const pubDate = formatRfc822Date(item.timeCreated);
-        item.pubDate = pubDate;
-        item.PubDate = pubDate;
-    }
-    else if (item.pubDate && !item.PubDate) {
-        item.PubDate = item.pubDate;
-    }
-    else if (item.PubDate && !item.pubDate) {
-        item.pubDate = item.PubDate;
-    }
-    // Ensure seedUid is always present
-    if (!item.seedUid && !item.SeedUid) {
-        item.seedUid = seedUid;
-        item.SeedUid = seedUid;
-    }
-    else if (item.seedUid && !item.SeedUid) {
-        item.SeedUid = item.seedUid;
-    }
-    else if (item.SeedUid && !item.seedUid) {
-        item.seedUid = item.SeedUid;
-    }
-    // Note: We don't set storageTransactionId to seedUid as a fallback anymore
-    // because seedUid is not a valid Arweave transaction ID. If storageTransactionId
-    // doesn't exist, we'll use the default link format with seedUid instead.
-};
-const seedUidToModelType = new Map();
-const relatedSeedUids = new Set();
-const versionUidToSeedUid = new Map();
-const assembledFeedItems = new Map();
-const versionsBySeedUid = new Map();
-const latestVersionUidsBySeedUid = new Map();
-const processItemProperty = async (property, itemSeeds) => {
-    console.log('[feed] [processItemProperty] Starting to process property:', {
-        propertyId: property.id,
-        refUID: property.refUID,
-        schemaId: property.schemaId,
-    });
-    let metadata;
-    try {
-        metadata = JSON.parse(property.decodedDataJson)[0].value;
-    }
-    catch (error) {
-        console.error('[feed] [processItemProperty] Error parsing metadata:', error);
-        return;
+/**
+ * Collects all items that will be in the publish payload (main item + related items from
+ * relations and lists). Used by ensureEasSchemas to register schemas for nested items.
+ * Skips items that already have seedUid (already published).
+ */
+async function getRelatedItemsForPublish(item, visited = new Set()) {
+    const seedLocalId = item.seedLocalId;
+    if (!seedLocalId || visited.has(seedLocalId)) {
+        return [];
     }
-    let propertyNameSnake = metadata.name;
-    if (!propertyNameSnake) {
-        console.log('[feed] [processItemProperty] WARNING: no propertyName found for property:', {
-            propertyId: property.id,
-            property,
-        });
-        console.warn('[item/events] [syncDbWithEas] no propertyName found for property: ', property);
-        return;
+    visited.add(seedLocalId);
+    const result = [];
+    const { itemRelationProperties, itemImageProperties, itemListProperties } = getSegmentedItemProperties(item);
+    const getItemMod = await import('./getItem-f9rNUz7I.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;
+        if (!value)
+            return;
+        const { localId: seedLocalId, uid: seedUid } = getCorrectId(value);
+        const relatedItem = await getItem({ seedLocalId, seedUid });
+        if (!relatedItem || relatedItem.seedUid)
+            return;
+        const nested = await getRelatedItemsForPublish(relatedItem, visited);
+        result.push(...nested, relatedItem);
+    };
+    for (const prop of [...itemRelationProperties, ...itemImageProperties]) {
+        await processRelationOrImage(prop);
     }
-    console.log('[feed] [processItemProperty] Processing property:', {
-        propertyNameSnake,
-        propertyId: property.id,
-    });
-    let isRelation = false;
-    let refSeedType;
-    let refSchemaUid;
-    let isList = false;
-    const schemaUid = property.schemaId;
-    console.log('[feed] [processItemProperty] Setting schema UID for schema definition:', {
-        propertyNameSnake,
-        schemaUid,
-    });
-    setSchemaUidForSchemaDefinition({
-        text: propertyNameSnake,
-        schemaUid,
-    });
-    if ((propertyNameSnake.endsWith('_id') ||
-        propertyNameSnake.endsWith('_ids')) &&
-        propertyNameSnake !== 'storage_transaction_id' &&
-        propertyNameSnake !== 'storage_provider_transaction_id') {
-        isRelation = true;
-        console.log('[feed] [processItemProperty] Detected relation property:', {
-            propertyNameSnake,
-            metadataValue: metadata.value,
-        });
-        if (Array.isArray(metadata.value)) {
-            isList = true;
-            console.log('[feed] [processItemProperty] Detected list relation:', {
-                propertyNameSnake,
-                listLength: metadata.value.length,
-                values: metadata.value,
-            });
-            const result = parseEasRelationPropertyName(propertyNameSnake);
-            console.log('[feed] [processItemProperty] Parsed relation property name:', {
-                result,
-                originalPropertyName: propertyNameSnake,
-            });
-            if (result) {
-                propertyNameSnake = result.propertyName;
-                refSeedType = result.modelName;
-                console.log('[feed] [processItemProperty] Updated property name and seed type:', {
-                    newPropertyName: propertyNameSnake,
-                    refSeedType,
-                });
+    for (const listProperty of itemListProperties) {
+        if (!listProperty.propertyDef?.ref)
+            continue;
+        const snapshot = listProperty.getService().getSnapshot();
+        const context = snapshot.context ?? null;
+        if (!context)
+            continue;
+        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);
             }
-            metadata.value.forEach((value) => {
-                relatedSeedUids.add(value);
-                console.log('[feed] [processItemProperty] Added related seed UID to set:', {
-                    relatedSeedUid: value,
-                    totalRelatedSeeds: relatedSeedUids.size,
-                });
-            });
-        }
-        if (!isList) {
-            if (relationValuesToExclude.includes(metadata.value)) {
-                console.log('[feed] [processItemProperty] Excluding relation value:', {
-                    propertyNameSnake,
-                    excludedValue: metadata.value,
-                });
-                return;
+            catch {
+                value = value.split(',');
             }
-            relatedSeedUids.add(metadata.value);
-            console.log('[feed] [processItemProperty] Added single related seed UID:', {
-                relatedSeedUid: metadata.value,
-                totalRelatedSeeds: relatedSeedUids.size,
-            });
-        }
-    }
-    let propertyValue = metadata.value;
-    if (typeof propertyValue !== 'string') {
-        console.log('[feed] [processItemProperty] Converting property value to string:', {
-            propertyNameSnake,
-            originalType: typeof propertyValue,
-            originalValue: propertyValue,
-        });
-        propertyValue = JSON.stringify(propertyValue);
-    }
-    console.log('[feed] [processItemProperty] Final property value:', {
-        propertyNameSnake,
-        propertyValue,
-        isRelation,
-        isList,
-    });
-    if (isRelation && !isList) {
-        console.log('[feed] [processItemProperty] Processing single relation:', {
-            propertyNameSnake,
-            relationValue: metadata.value,
-            itemSeedsCount: itemSeeds.length,
-        });
-        const relatedSeed = itemSeeds.find((seed) => seed.id === metadata.value);
-        if (relatedSeed && relatedSeed.schema && relatedSeed.schema.schemaNames) {
-            refSeedType = relatedSeed.schema.schemaNames[0].name;
-            refSchemaUid = relatedSeed.schemaId;
-            console.log('[feed] [processItemProperty] Found related seed for single relation:', {
-                propertyNameSnake,
-                refSeedType,
-                refSchemaUid,
-                relatedSeedId: relatedSeed.id,
-            });
-        }
-        else {
-            console.log('[feed] [processItemProperty] No related seed found for single relation:', {
-                propertyNameSnake,
-                relationValue: metadata.value,
-            });
-        }
-    }
-    if (isRelation && isList) {
-        console.log('[feed] [processItemProperty] Processing list relation:', {
-            propertyNameSnake,
-            relationValues: metadata.value,
-            itemSeedsCount: itemSeeds.length,
-        });
-        const relatedSeeds = itemSeeds.filter((seed) => metadata.value.includes(seed.id));
-        console.log('[feed] [processItemProperty] Filtered related seeds for list:', {
-            propertyNameSnake,
-            foundSeedsCount: relatedSeeds.length,
-            foundSeedIds: relatedSeeds.map((s) => s.id),
-        });
-        if (relatedSeeds && relatedSeeds.length > 0) {
-            refSeedType = relatedSeeds[0].schema.schemaNames[0].name;
-            refSchemaUid = relatedSeeds[0].schemaId;
-            console.log('[feed] [processItemProperty] Set ref seed type and schema UID from list relation:', {
-                propertyNameSnake,
-                refSeedType,
-                refSchemaUid,
-            });
-        }
-        else {
-            console.log('[feed] [processItemProperty] No related seeds found for list relation:', {
-                propertyNameSnake,
-            });
-        }
-    }
-    console.log('[feed] [processItemProperty] Looking up seed UID for property:', {
-        propertyRefUID: property.refUID,
-        versionUidToSeedUidSize: versionUidToSeedUid.size,
-    });
-    const seedUidForProperty = versionUidToSeedUid.get(property.refUID);
-    if (!seedUidForProperty) {
-        console.log('[feed] [processItemProperty] WARNING: no seedUid found for property:', {
-            propertyRefUID: property.refUID,
-            propertyId: property.id,
-            property,
-        });
-        console.warn('no seedUid found for property: ', property);
-        return;
-    }
-    console.log('[feed] [processItemProperty] Found seed UID for property:', {
-        seedUidForProperty,
-        propertyNameSnake,
-    });
-    let existingFeedItem = assembledFeedItems.get(seedUidForProperty) || {};
-    const existingKeys = Object.keys(existingFeedItem);
-    // Store property in snake_case (original format)
-    existingFeedItem[propertyNameSnake] = propertyValue;
-    // Also store in camelCase for easier access by external consumers (e.g., RSS generators)
-    const propertyNameCamel = toCamelCase(propertyNameSnake);
-    if (propertyNameCamel !== propertyNameSnake) {
-        existingFeedItem[propertyNameCamel] = propertyValue;
-    }
-    assembledFeedItems.set(seedUidForProperty, existingFeedItem);
-    console.log('[feed] [processItemProperty] Updated assembled feed item:', {
-        seedUidForProperty,
-        propertyNameSnake,
-        propertyValue,
-        existingKeysCount: existingKeys.length,
-        newKeysCount: Object.keys(existingFeedItem).length,
-        totalAssembledItems: assembledFeedItems.size,
-    });
-};
-const processSeeds = async (seeds) => {
-    console.log('[feed] [processSeeds] Starting to process seeds:', {
-        seedsCount: seeds.length,
-        seedIds: seeds.map((s) => s.id),
-    });
-    const seedUids = seeds.map((seed) => seed.id);
-    for (let i = 0; i < seeds.length; i++) {
-        const seed = seeds[i];
-        seedUids.push(seed.id);
-        const modelType = seed.schema.schemaNames[0].name;
-        seedUidToModelType.set(seed.id, modelType);
-        // Initialize feed item with seed metadata
-        if (!assembledFeedItems.has(seed.id)) {
-            assembledFeedItems.set(seed.id, {
-                seedUid: seed.id,
-                timeCreated: seed.timeCreated,
-            });
-            console.log('[feed] [processSeeds] Initialized feed item for seed:', {
-                seedId: seed.id,
-                modelType,
-            });
         }
-        console.log('[feed] [processSeeds] Processing seed:', {
-            index: i,
-            seedId: seed.id,
-            modelType,
-            totalSeedsProcessed: i + 1,
-        });
-    }
-    console.log('[feed] [processSeeds] Completed seed mapping:', {
-        totalSeeds: seeds.length,
-        seedUidToModelTypeSize: seedUidToModelType.size,
-        seedUids,
-    });
-    console.log('[feed] [processSeeds] Fetching item versions from EAS:', {
-        seedUidsCount: seedUids.length,
-        seedUids,
-    });
-    const itemVersions = await getItemVersionsFromEas({ seedUids });
-    console.log('[feed] [processSeeds] Received item versions from EAS:', {
-        itemVersionsCount: itemVersions.length,
-        versionIds: itemVersions.map((v) => v.id),
-    });
-    for (let i = 0; i < itemVersions.length; i++) {
-        const itemVersion = itemVersions[i];
-        const seedUid = itemVersion.refUID;
-        versionUidToSeedUid.set(itemVersion.id, seedUid);
-        const existingVersions = versionsBySeedUid.get(seedUid) || [];
-        versionsBySeedUid.set(seedUid, [...existingVersions, itemVersion]);
-        console.log('[feed] [processSeeds] Processed item version:', {
-            index: i,
-            versionId: itemVersion.id,
-            seedUid,
-            timeCreated: itemVersion.timeCreated,
-            versionsForSeedCount: existingVersions.length + 1,
-        });
-    }
-    console.log('[feed] [processSeeds] Completed version mapping:', {
-        totalVersions: itemVersions.length,
-        versionUidToSeedUidSize: versionUidToSeedUid.size,
-        versionsBySeedUidSize: versionsBySeedUid.size,
-        uniqueSeedsWithVersions: Array.from(versionsBySeedUid.keys()),
-    });
-    // Get latest version for each seed and then use those to get the properties
-    console.log('[feed] [processSeeds] Determining latest versions for each seed');
-    const latestVersionUids = [];
-    for (const [seedUid, versions] of versionsBySeedUid.entries()) {
-        console.log('[feed] [processSeeds] Processing versions for seed:', {
-            seedUid,
-            versionsCount: versions.length,
-            versionIds: versions.map((v) => v.id),
-            timeCreateds: versions.map((v) => v.timeCreated),
-        });
-        // Sort versions by timeCreated in descending order (most recent first)
-        const sortedVersions = [...versions].sort((a, b) => b.timeCreated - a.timeCreated);
-        console.log('[feed] [processSeeds] Sorted versions:', {
-            seedUid,
-            sortedVersionIds: sortedVersions.map((v) => v.id),
-            sortedTimeCreateds: sortedVersions.map((v) => v.timeCreated),
-        });
-        // Get the most recent version for this seedUid
-        if (sortedVersions.length > 0) {
-            const latestVersion = sortedVersions[0];
-            latestVersionUids.push(latestVersion.id);
-            latestVersionUidsBySeedUid.set(seedUid, latestVersion.id);
-            console.log('[feed] [processSeeds] Set latest version for seed:', {
-                seedUid,
-                latestVersionId: latestVersion.id,
-                latestTimeCreated: latestVersion.timeCreated,
-            });
-        }
-        else {
-            console.log('[feed] [processSeeds] WARNING: No versions found for seed:', {
-                seedUid,
-            });
+        const arr = Array.isArray(value) ? value : [];
+        for (const seedId of arr) {
+            const { localId: seedLocalId, uid: seedUid } = getCorrectId(seedId);
+            const relatedItem = await getItem({ seedLocalId, seedUid });
+            if (!relatedItem || relatedItem.seedUid)
+                continue;
+            const nested = await getRelatedItemsForPublish(relatedItem, visited);
+            result.push(...nested, relatedItem);
         }
     }
-    console.log('[feed] [processSeeds] Completed latest version determination:', {
-        latestVersionUidsCount: latestVersionUids.length,
-        latestVersionUids,
-        latestVersionUidsBySeedUidSize: latestVersionUidsBySeedUid.size,
-    });
-    console.log('[feed] [processSeeds] Fetching item properties from EAS:', {
-        latestVersionUidsCount: latestVersionUids.length,
-        latestVersionUids,
-    });
-    const itemProperties = await getItemPropertiesFromEas({ versionUids: latestVersionUids });
-    console.log('[feed] [processSeeds] Received item properties from EAS:', {
-        itemPropertiesCount: itemProperties.length,
-        propertyIds: itemProperties.map((p) => p.id),
-    });
-    for (let i = 0; i < itemProperties.length; i++) {
-        console.log('[feed] [processSeeds] Processing item property:', {
-            index: i,
-            propertyId: itemProperties[i].id,
-            totalProperties: itemProperties.length,
-        });
-        await processItemProperty(itemProperties[i], seeds);
-    }
-    console.log('[feed] [processSeeds] Completed processing all seeds:', {
-        seedsCount: seeds.length,
-        itemVersionsCount: itemVersions.length,
-        itemPropertiesCount: itemProperties.length,
-        assembledFeedItemsSize: assembledFeedItems.size,
-    });
-};
-const getFeedItemsBySchemaName = async (schemaName) => {
-    console.log('[feed] [getFeedItemsBySchemaName] Starting feed retrieval:', {
-        schemaName,
-        currentAssembledItemsSize: assembledFeedItems.size,
-        currentRelatedSeedUidsSize: relatedSeedUids.size,
-    });
-    const easClient = BaseEasClient.getEasClient();
-    console.log('[feed] [getFeedItemsBySchemaName] Retrieved EAS client');
-    console.log('[feed] [getFeedItemsBySchemaName] Fetching seeds by schema name:', {
-        schemaName,
-    });
-    const seeds = await getSeedsBySchemaName(schemaName);
-    console.log('[feed] [getFeedItemsBySchemaName] Received seeds:', {
-        seedsCount: seeds.length,
-        seedIds: seeds.map((s) => s.id),
-    });
-    await processSeeds(seeds);
-    const relatedSeedUidsArray = Array.from(relatedSeedUids);
-    console.log('[feed] [getFeedItemsBySchemaName] Fetching related seeds:', {
-        relatedSeedUidsCount: relatedSeedUidsArray.length,
-        relatedSeedUids: relatedSeedUidsArray,
-    });
-    const { itemSeeds: relatedSeeds } = await easClient.request(GET_SEEDS, {
-        where: {
-            id: {
-                in: relatedSeedUidsArray,
-            },
-        },
-    });
-    console.log('[feed] [getFeedItemsBySchemaName] Received related seeds:', {
-        relatedSeedsCount: relatedSeeds.length,
-        relatedSeedIds: relatedSeeds.map((s) => s.id),
-    });
-    await processSeeds(relatedSeeds);
-    // Filter feed items to only include items matching the requested schema name
-    // and apply default values for required RSS fields
-    const feedItems = Array.from(assembledFeedItems.entries())
-        .filter(([seedUid]) => seedUidToModelType.get(seedUid) === schemaName)
-        .map(([seedUid, item]) => {
-        // Apply defaults for required RSS feed fields
-        setFeedItemDefaults(item, seedUid, schemaName);
-        return item;
-    });
-    console.log('[feed] [getFeedItemsBySchemaName] Completed feed retrieval:', {
-        schemaName,
-        feedItemsCount: feedItems.length,
-        assembledFeedItemsSize: assembledFeedItems.size,
-        filteredFeedItemsCount: feedItems.length,
-        feedItemKeys: feedItems.map((item) => Object.keys(item)),
-    });
-    return feedItems;
-};
+    return result;
+}
 
-export { BaseEasClient as EasClient, Item, ItemProperty, Model, ModelProperty, Schema, SeedProvider, createSeedQueryClient, getFeedItemsBySchemaName, getItemPropertiesFromEas, getItemVersionsFromEas, getPropertySchema, getSeedQueryDefaultOptions, getSeedsBySchemaName, invalidateItemPropertiesForItem, mergeSeedQueryDefaults, useAllSchemaVersions, useCreateItem, useCreateItemProperty, useCreateModel, useCreateModelProperty, useCreateSchema, useDeleteItem, useDestroyItemProperty, useDestroyModel, useDestroyModelProperty, useDestroySchema, useItem, useItemProperties, useItemProperty, useItems, useModel, useModelProperties, useModelProperty, useModels, usePublishItem, useSchema, useSchemas };
+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 };
 //# sourceMappingURL=main.js.map