@tutti-os/workspace-file-reference 0.0.13 → 0.0.15

package/dist/{chunk-LS7P3J6Z.js → chunk-KSK6PILG.js}

@@ -1,6 +1,10 @@
 import {
+  SOURCE_ROOT_NODE_ID,
+  appendReferencePage,
+  nodeRefKey,
+  sortReferenceNodes,
   uniqueWorkspaceFileReferences
-} from "./chunk-PAR2R2G5.js";
+} from "./chunk-HRC2MZ5H.js";
 
 // src/react/internal/reference/WorkspaceFileReferencePickerState.ts
 var workspaceFileReferenceDefaultExpandedDepth = 4;
@@ -158,7 +162,15 @@ var defaultDirectoryPath = "/";
 var defaultSearchDebounceMs = 180;
 function createWorkspaceFileReferencePickerController(input) {
   const searchDebounceMs = input.searchDebounceMs ?? defaultSearchDebounceMs;
-  let browseSequence = 0;
+  let nextBrowseSeq = 0;
+  const latestBrowseSeqByKey = /* @__PURE__ */ new Map();
+  const stampBrowse = (seqKey) => {
+    const sequence = ++nextBrowseSeq;
+    latestBrowseSeqByKey.set(seqKey, sequence);
+    return sequence;
+  };
+  const isBrowseStale = (seqKey, sequence) => !retained || latestBrowseSeqByKey.get(seqKey) !== sequence;
+  const REVEAL_SEQ_KEY = "\0reveal";
   let previewObjectUrl = null;
   let previewSequence = 0;
   let retained = false;
@@ -219,7 +231,7 @@ function createWorkspaceFileReferencePickerController(input) {
     searchAbortController = null;
   };
   const cancelCurrentBrowse = () => {
-    browseSequence += 1;
+    latestBrowseSeqByKey.clear();
   };
   const cancelCurrentPreview = () => {
     previewSequence += 1;
@@ -306,7 +318,8 @@ function createWorkspaceFileReferencePickerController(input) {
     if (normalizedRoot && snapshot.directoryStateByPath[normalizedRoot]?.loaded) {
       return;
     }
-    const sequence = ++browseSequence;
+    const seqKey = normalizedRoot ?? "";
+    const sequence = stampBrowse(seqKey);
     setSnapshot({
       browseError: null,
       isBrowseLoading: true
@@ -319,7 +332,7 @@ function createWorkspaceFileReferencePickerController(input) {
           prefetchDepth: 4,
           workspaceId: input.workspaceId
         });
-        if (!retained || sequence !== browseSequence) {
+        if (isBrowseStale(seqKey, sequence)) {
           return;
         }
         setSnapshot({
@@ -334,7 +347,7 @@ function createWorkspaceFileReferencePickerController(input) {
         return;
       }
       const listing = await loadDirectoryListing(activeBrowseRootPath);
-      if (!retained || sequence !== browseSequence || !listing) {
+      if (isBrowseStale(seqKey, sequence) || !listing) {
         return;
       }
       setSnapshot((current) => ({
@@ -352,7 +365,7 @@ function createWorkspaceFileReferencePickerController(input) {
         isBrowseLoading: false
       }));
     } catch (error) {
-      if (!retained || sequence !== browseSequence) {
+      if (isBrowseStale(seqKey, sequence)) {
         return;
       }
       setSnapshot({
@@ -369,7 +382,7 @@ function createWorkspaceFileReferencePickerController(input) {
     if (!retained || snapshot.directoryStateByPath[folderKey]?.loaded || snapshot.directoryStateByPath[folderKey]?.loading) {
       return;
     }
-    const sequence = ++browseSequence;
+    const sequence = stampBrowse(folderKey);
     setSnapshot((current) => ({
       ...current,
       directoryStateByPath: {
@@ -384,7 +397,7 @@ function createWorkspaceFileReferencePickerController(input) {
     }));
     try {
       const listing = await loadDirectoryListing(folderKey);
-      if (!retained || sequence !== browseSequence || !listing) {
+      if (isBrowseStale(folderKey, sequence) || !listing) {
         return;
       }
       setSnapshot((current) => ({
@@ -400,7 +413,7 @@ function createWorkspaceFileReferencePickerController(input) {
         }
       }));
     } catch {
-      if (!retained || sequence !== browseSequence) {
+      if (isBrowseStale(folderKey, sequence)) {
         return;
       }
       setSnapshot((current) => ({
@@ -538,7 +551,7 @@ function createWorkspaceFileReferencePickerController(input) {
         });
         return null;
       }
-      const sequence = ++browseSequence;
+      const sequence = stampBrowse(REVEAL_SEQ_KEY);
       const loadedDirectories = {};
       const expandedDirectories = {};
       const directoryState = (path) => loadedDirectories[path] ?? snapshot.directoryStateByPath[path];
@@ -569,7 +582,7 @@ function createWorkspaceFileReferencePickerController(input) {
           loading: false
         };
       }
-      if (!retained || sequence !== browseSequence) {
+      if (isBrowseStale(REVEAL_SEQ_KEY, sequence)) {
         return null;
       }
       setSnapshot((current) => ({
@@ -888,6 +901,638 @@ function useWorkspaceFileReferencePickerView({
   };
 }
 
+// src/react/internal/reference/referenceSourcePickerController.ts
+import { proxy as proxy2 } from "valtio/vanilla";
+var ROOT_CHILDREN_KEY = nodeRefKey({
+  sourceId: "",
+  nodeId: SOURCE_ROOT_NODE_ID
+});
+var defaultSearchDebounceMs2 = 180;
+var SEARCH_PAGE_SIZE = 30;
+var SEARCH_MAX_LIMIT = 200;
+function emptyTabState(sourceId) {
+  return {
+    sourceId,
+    expandedKeys: {},
+    childrenByKey: {},
+    mode: "browse",
+    searchQuery: "",
+    searchFilters: [],
+    searchScopeNodeId: null,
+    searchEntries: [],
+    searchNextCursor: null,
+    searchLimit: 0,
+    searchHasMore: false,
+    isSearchLoadingMore: false,
+    isSearchLoading: false,
+    searchError: null
+  };
+}
+function emptyChildrenState() {
+  return {
+    entries: [],
+    nextCursor: null,
+    loaded: false,
+    loading: false,
+    error: null
+  };
+}
+function createReferenceSourcePickerController(input) {
+  const { aggregator, scope } = input;
+  const searchDebounceMs = input.searchDebounceMs ?? defaultSearchDebounceMs2;
+  let retained = false;
+  let tabsReady = Promise.resolve();
+  let tabsSequence = 0;
+  let nextBrowseSeq = 0;
+  const latestBrowseSeqByKey = /* @__PURE__ */ new Map();
+  let searchSequence = 0;
+  let searchAbortController = null;
+  let searchTimer = null;
+  let snapshot = {
+    isLoadingTabs: false,
+    tabsError: null,
+    tabs: [],
+    activeSourceId: null,
+    bySource: {},
+    selection: []
+  };
+  const store = proxy2(snapshot);
+  const setSnapshot = (update) => {
+    const next = typeof update === "function" ? update(snapshot) : { ...snapshot, ...update };
+    if (next === snapshot) {
+      return;
+    }
+    snapshot = next;
+    Object.assign(store, next);
+  };
+  const updateTab = (sourceId, updater) => {
+    setSnapshot((current) => {
+      const existing = current.bySource[sourceId] ?? emptyTabState(sourceId);
+      const nextTab = updater(existing);
+      if (nextTab === existing) {
+        return current;
+      }
+      return {
+        ...current,
+        bySource: { ...current.bySource, [sourceId]: nextTab }
+      };
+    });
+  };
+  const childrenKeyForNode = (node) => node ? nodeRefKey(node.ref) : ROOT_CHILDREN_KEY;
+  const setChildrenState = (sourceId, key, patch) => {
+    updateTab(sourceId, (tab) => {
+      const current = tab.childrenByKey[key] ?? emptyChildrenState();
+      return {
+        ...tab,
+        childrenByKey: {
+          ...tab.childrenByKey,
+          [key]: { ...current, ...patch }
+        }
+      };
+    });
+  };
+  const loadChildren = async (sourceId, node, options) => {
+    if (!retained) {
+      return;
+    }
+    const key = childrenKeyForNode(node);
+    const tab = snapshot.bySource[sourceId];
+    const existing = tab?.childrenByKey[key];
+    const cursor = options.append ? existing?.nextCursor ?? null : null;
+    if (existing?.loading) {
+      return;
+    }
+    if (options.append && !cursor) {
+      return;
+    }
+    const seqKey = `${sourceId}\0${key}`;
+    const sequence = ++nextBrowseSeq;
+    latestBrowseSeqByKey.set(seqKey, sequence);
+    setChildrenState(sourceId, key, { loading: true, error: null });
+    try {
+      const result = await aggregator.listChildren(
+        scope,
+        node ? node.ref : { sourceId, nodeId: SOURCE_ROOT_NODE_ID },
+        { cursor }
+      );
+      if (!retained || latestBrowseSeqByKey.get(seqKey) !== sequence) {
+        return;
+      }
+      const prior = snapshot.bySource[sourceId]?.childrenByKey[key]?.entries ?? [];
+      const entries = options.append ? appendReferencePage(prior, result.entries) : result.ordered ? [...result.entries] : sortReferenceNodes(result.entries);
+      setChildrenState(sourceId, key, {
+        entries,
+        nextCursor: result.nextCursor ?? null,
+        loaded: true,
+        loading: false,
+        error: null
+      });
+    } catch (error) {
+      if (!retained || latestBrowseSeqByKey.get(seqKey) !== sequence) {
+        return;
+      }
+      setChildrenState(sourceId, key, {
+        loading: false,
+        error: normalizeError(error, "load children failed")
+      });
+    }
+  };
+  const ensureRootLoaded = (sourceId) => {
+    const root = snapshot.bySource[sourceId]?.childrenByKey[ROOT_CHILDREN_KEY];
+    if (root?.loaded || root?.loading) {
+      return;
+    }
+    void loadChildren(sourceId, null, { append: false });
+  };
+  const loadTabs = async () => {
+    if (!retained) {
+      return;
+    }
+    const sequence = ++tabsSequence;
+    setSnapshot({ isLoadingTabs: true, tabsError: null });
+    try {
+      const tabs = await aggregator.listSources(scope);
+      if (!retained || sequence !== tabsSequence) {
+        return;
+      }
+      const activeSourceId = snapshot.activeSourceId && tabs.some((tab) => tab.sourceId === snapshot.activeSourceId) ? snapshot.activeSourceId : tabs[0]?.sourceId ?? null;
+      setSnapshot((current) => ({
+        ...current,
+        isLoadingTabs: false,
+        tabs,
+        activeSourceId,
+        bySource: Object.fromEntries(
+          tabs.map((tab) => [
+            tab.sourceId,
+            current.bySource[tab.sourceId] ?? emptyTabState(tab.sourceId)
+          ])
+        )
+      }));
+      if (activeSourceId) {
+        ensureRootLoaded(activeSourceId);
+      }
+    } catch (error) {
+      if (!retained || sequence !== tabsSequence) {
+        return;
+      }
+      setSnapshot({
+        isLoadingTabs: false,
+        tabsError: normalizeError(error, "load reference sources failed")
+      });
+    }
+  };
+  const clearSearchTimer = () => {
+    if (searchTimer !== null) {
+      clearTimeout(searchTimer);
+      searchTimer = null;
+    }
+  };
+  const cancelSearch = () => {
+    clearSearchTimer();
+    searchSequence += 1;
+    searchAbortController?.abort();
+    searchAbortController = null;
+  };
+  const runSearch = async (sourceId, query, filters, scopeNodeId, limit, loadingMore) => {
+    if (!retained) {
+      return;
+    }
+    const sequence = ++searchSequence;
+    searchAbortController?.abort();
+    const abortController = new AbortController();
+    searchAbortController = abortController;
+    updateTab(sourceId, (tab) => ({
+      ...tab,
+      ...loadingMore ? { isSearchLoadingMore: true } : { isSearchLoading: true },
+      searchError: null
+    }));
+    try {
+      const result = await aggregator.search(scope, sourceId, {
+        query,
+        limit,
+        signal: abortController.signal,
+        ...filters.length > 0 ? { filters } : {},
+        ...scopeNodeId == null ? {} : { withinNodeId: scopeNodeId }
+      });
+      if (!retained || sequence !== searchSequence) {
+        return;
+      }
+      updateTab(sourceId, (tab) => ({
+        ...tab,
+        isSearchLoading: false,
+        isSearchLoadingMore: false,
+        searchEntries: sortReferenceNodes(result.entries),
+        searchNextCursor: result.nextCursor ?? null,
+        searchLimit: limit,
+        // 本页返回数达到请求上限、且未触全局上限 → 认为可能还有更多(增长式分页启发式)。
+        searchHasMore: result.entries.length >= limit && limit < SEARCH_MAX_LIMIT,
+        searchError: null
+      }));
+    } catch (error) {
+      if (isAbortError2(error) || !retained || sequence !== searchSequence) {
+        return;
+      }
+      updateTab(sourceId, (tab) => ({
+        ...tab,
+        isSearchLoading: false,
+        isSearchLoadingMore: false,
+        // 加载更多失败时保留已有结果,仅新查询失败才清空。
+        ...loadingMore ? {} : { searchEntries: [], searchHasMore: false },
+        searchError: normalizeError(error, "reference search failed")
+      }));
+    } finally {
+      if (sequence === searchSequence) {
+        searchAbortController = null;
+      }
+    }
+  };
+  const collectFolderFiles = async (folder) => {
+    const files = [];
+    const seen = /* @__PURE__ */ new Set();
+    const walk = async (node) => {
+      let cursor = null;
+      do {
+        const result = await aggregator.listChildren(scope, node.ref, {
+          cursor
+        });
+        for (const entry of result.entries) {
+          const key = nodeRefKey(entry.ref);
+          if (seen.has(key)) {
+            continue;
+          }
+          seen.add(key);
+          if (entry.kind === "folder") {
+            await walk(entry);
+          } else {
+            files.push(entry);
+          }
+        }
+        cursor = result.nextCursor ?? null;
+      } while (cursor);
+    };
+    await walk(folder);
+    return files;
+  };
+  const scheduleSearch = (sourceId, query, filters, scopeNodeId) => {
+    clearSearchTimer();
+    if (!retained || !query && filters.length === 0) {
+      return;
+    }
+    if (searchDebounceMs <= 0) {
+      void runSearch(
+        sourceId,
+        query,
+        filters,
+        scopeNodeId,
+        SEARCH_PAGE_SIZE,
+        false
+      );
+      return;
+    }
+    searchTimer = setTimeout(() => {
+      searchTimer = null;
+      void runSearch(
+        sourceId,
+        query,
+        filters,
+        scopeNodeId,
+        SEARCH_PAGE_SIZE,
+        false
+      );
+    }, searchDebounceMs);
+  };
+  return {
+    get store() {
+      return store;
+    },
+    getSnapshot() {
+      return snapshot;
+    },
+    open() {
+      if (retained) {
+        return;
+      }
+      retained = true;
+      tabsReady = loadTabs();
+    },
+    close() {
+      retained = false;
+      cancelSearch();
+      latestBrowseSeqByKey.clear();
+      tabsSequence += 1;
+    },
+    reset() {
+      cancelSearch();
+      latestBrowseSeqByKey.clear();
+      tabsSequence += 1;
+      setSnapshot({
+        isLoadingTabs: false,
+        tabsError: null,
+        tabs: [],
+        activeSourceId: null,
+        bySource: {},
+        selection: []
+      });
+    },
+    setActiveSource(sourceId) {
+      if (!snapshot.tabs.some((tab) => tab.sourceId === sourceId)) {
+        return;
+      }
+      const prevTab = snapshot.activeSourceId ? snapshot.bySource[snapshot.activeSourceId] : void 0;
+      const carriedQuery = prevTab?.searchQuery ?? "";
+      const carriedFilters = prevTab?.searchFilters ?? [];
+      const trimmed = carriedQuery.trim();
+      cancelSearch();
+      setSnapshot({ activeSourceId: sourceId });
+      if (trimmed === "" && carriedFilters.length === 0) {
+        updateTab(
+          sourceId,
+          (tab) => tab.mode === "browse" && tab.searchQuery === "" && tab.searchFilters.length === 0 ? tab : {
+            ...tab,
+            mode: "browse",
+            searchQuery: "",
+            searchFilters: [],
+            searchEntries: [],
+            searchHasMore: false,
+            isSearchLoading: false,
+            isSearchLoadingMore: false,
+            searchError: null
+          }
+        );
+        ensureRootLoaded(sourceId);
+        return;
+      }
+      const nextScopeNodeId = snapshot.bySource[sourceId]?.searchScopeNodeId ?? null;
+      updateTab(sourceId, (tab) => ({
+        ...tab,
+        searchQuery: carriedQuery,
+        searchFilters: carriedFilters,
+        searchScopeNodeId: nextScopeNodeId,
+        mode: "search",
+        // 沿用旧结果直到新结果就绪,避免切源瞬间闪空。
+        isSearchLoading: true,
+        searchError: null
+      }));
+      scheduleSearch(sourceId, trimmed, carriedFilters, nextScopeNodeId);
+    },
+    async locatePath(target) {
+      await tabsReady;
+      if (!retained) {
+        return [];
+      }
+      const refs = await aggregator.locateTarget(
+        scope,
+        target.sourceId,
+        target.params
+      );
+      if (!refs || refs.length === 0) {
+        return [];
+      }
+      const path = [];
+      let parent = {
+        sourceId: target.sourceId,
+        nodeId: SOURCE_ROOT_NODE_ID
+      };
+      for (const ref of refs) {
+        const { entries } = await aggregator.listChildren(scope, parent);
+        const targetKey = nodeRefKey(ref);
+        const node = entries.find(
+          (entry) => nodeRefKey(entry.ref) === targetKey
+        );
+        if (!node) {
+          break;
+        }
+        path.push(node);
+        parent = ref;
+      }
+      return path;
+    },
+    ensureChildren(node) {
+      const sourceId = node ? node.ref.sourceId : snapshot.activeSourceId;
+      if (!sourceId) {
+        return;
+      }
+      const key = childrenKeyForNode(node);
+      const childState = snapshot.bySource[sourceId]?.childrenByKey[key];
+      if (!childState?.loaded && !childState?.loading) {
+        void loadChildren(sourceId, node, { append: false });
+      }
+    },
+    ensureSourceRoot(sourceId) {
+      if (!sourceId || !snapshot.tabs.some((tab) => tab.sourceId === sourceId)) {
+        return;
+      }
+      ensureRootLoaded(sourceId);
+    },
+    toggleNode(node) {
+      if (node.kind !== "folder") {
+        return;
+      }
+      const sourceId = node.ref.sourceId;
+      const key = nodeRefKey(node.ref);
+      const wasExpanded = snapshot.bySource[sourceId]?.expandedKeys[key] ?? false;
+      const nextExpanded = !wasExpanded;
+      updateTab(sourceId, (tab) => ({
+        ...tab,
+        expandedKeys: { ...tab.expandedKeys, [key]: nextExpanded }
+      }));
+      const childState = snapshot.bySource[sourceId]?.childrenByKey[key];
+      if (nextExpanded && !childState?.loaded && !childState?.loading) {
+        void loadChildren(sourceId, node, { append: false });
+      }
+    },
+    loadMore(node) {
+      const sourceId = node ? node.ref.sourceId : snapshot.activeSourceId;
+      if (!sourceId) {
+        return;
+      }
+      void loadChildren(sourceId, node, { append: true });
+    },
+    loadMoreSourceRoot(sourceId) {
+      if (!sourceId) {
+        return;
+      }
+      void loadChildren(sourceId, null, { append: true });
+    },
+    setSearchQuery(query, scopeNodeId = null) {
+      const sourceId = snapshot.activeSourceId;
+      if (!sourceId) {
+        return;
+      }
+      const filters = snapshot.bySource[sourceId]?.searchFilters ?? [];
+      const trimmed = query.trim();
+      const nextMode = trimmed || filters.length > 0 ? "search" : "browse";
+      updateTab(sourceId, (tab) => ({
+        ...tab,
+        searchQuery: query,
+        searchScopeNodeId: scopeNodeId,
+        mode: nextMode,
+        // 进入搜索:立刻置 loading(搜索是 debounce 的,否则键入到取数之间会先渲染空态,
+        // 造成「空态 → spinner → 结果」闪烁)。保留上次 searchEntries,细化关键词时沿用旧结果而非闪空。
+        ...nextMode === "browse" ? { isSearchLoading: false, searchEntries: [], searchError: null } : { isSearchLoading: true, searchError: null }
+      }));
+      if (nextMode === "search") {
+        scheduleSearch(sourceId, trimmed, filters, scopeNodeId);
+      } else {
+        cancelSearch();
+        ensureRootLoaded(sourceId);
+      }
+    },
+    setSearchFilters(filters, scopeNodeId = null) {
+      const sourceId = snapshot.activeSourceId;
+      if (!sourceId) {
+        return;
+      }
+      const tab = snapshot.bySource[sourceId];
+      const trimmed = tab?.searchQuery.trim() ?? "";
+      const scopeId = scopeNodeId ?? tab?.searchScopeNodeId ?? null;
+      const nextMode = trimmed || filters.length > 0 ? "search" : "browse";
+      updateTab(sourceId, (current) => ({
+        ...current,
+        searchFilters: filters,
+        searchScopeNodeId: scopeId,
+        mode: nextMode,
+        ...nextMode === "browse" ? { isSearchLoading: false, searchEntries: [], searchError: null } : { isSearchLoading: true, searchError: null }
+      }));
+      if (nextMode === "search") {
+        scheduleSearch(sourceId, trimmed, filters, scopeId);
+      } else {
+        cancelSearch();
+        ensureRootLoaded(sourceId);
+      }
+    },
+    setSearchScope(scopeNodeId) {
+      const sourceId = snapshot.activeSourceId;
+      if (!sourceId) {
+        return;
+      }
+      const tab = snapshot.bySource[sourceId];
+      if (!tab || tab.searchScopeNodeId === scopeNodeId) {
+        return;
+      }
+      updateTab(sourceId, (current) => ({
+        ...current,
+        searchScopeNodeId: scopeNodeId
+      }));
+      const trimmed = tab.searchQuery.trim();
+      const filters = tab.searchFilters;
+      if (tab.mode === "search" && (trimmed || filters.length > 0)) {
+        scheduleSearch(sourceId, trimmed, filters, scopeNodeId);
+      }
+    },
+    loadMoreSearch() {
+      const sourceId = snapshot.activeSourceId;
+      if (!sourceId) {
+        return;
+      }
+      const tab = snapshot.bySource[sourceId];
+      if (!tab || tab.mode !== "search" || !tab.searchHasMore || tab.isSearchLoadingMore) {
+        return;
+      }
+      const trimmed = tab.searchQuery.trim();
+      if (!trimmed && tab.searchFilters.length === 0) {
+        return;
+      }
+      const nextLimit = Math.min(
+        (tab.searchLimit || SEARCH_PAGE_SIZE) + SEARCH_PAGE_SIZE,
+        SEARCH_MAX_LIMIT
+      );
+      if (nextLimit <= tab.searchLimit) {
+        return;
+      }
+      clearSearchTimer();
+      void runSearch(
+        sourceId,
+        trimmed,
+        tab.searchFilters,
+        tab.searchScopeNodeId,
+        nextLimit,
+        true
+      );
+    },
+    toggleSelection(node) {
+      const key = nodeRefKey(node.ref);
+      setSnapshot((current) => {
+        const exists = current.selection.some(
+          (item) => nodeRefKey(item.ref) === key
+        );
+        return {
+          ...current,
+          selection: exists ? current.selection.filter((item) => nodeRefKey(item.ref) !== key) : [...current.selection, node]
+        };
+      });
+    },
+    clearSelection() {
+      setSnapshot({ selection: [] });
+    },
+    async confirm() {
+      const resolved = [];
+      const seenPaths = /* @__PURE__ */ new Set();
+      const push = (ref) => {
+        if (seenPaths.has(ref.path)) {
+          return;
+        }
+        seenPaths.add(ref.path);
+        resolved.push(ref);
+      };
+      for (const node of snapshot.selection) {
+        if (node.kind !== "folder") {
+          push(aggregator.resolveSelection(node));
+          continue;
+        }
+        const navigable = aggregator.getLoadedSource(node.ref.sourceId)?.capabilities.navigable ?? false;
+        if (!navigable) {
+          push(aggregator.resolveSelection(node));
+          continue;
+        }
+        const files = await collectFolderFiles(node);
+        for (const fileNode of files) {
+          push(aggregator.resolveSelection(fileNode));
+        }
+      }
+      return resolved;
+    },
+    async confirmGrouped() {
+      const files = [];
+      const bundles = [];
+      const seenPaths = /* @__PURE__ */ new Set();
+      const pushFile = (ref) => {
+        if (seenPaths.has(ref.path)) {
+          return;
+        }
+        seenPaths.add(ref.path);
+        files.push(ref);
+      };
+      for (const node of snapshot.selection) {
+        const navigable = node.kind === "folder" && (aggregator.getLoadedSource(node.ref.sourceId)?.capabilities.navigable ?? false);
+        if (!navigable) {
+          pushFile(aggregator.resolveSelection(node));
+          continue;
+        }
+        const fileNodes = await collectFolderFiles(node);
+        const bundleSeen = /* @__PURE__ */ new Set();
+        const bundleFiles = [];
+        for (const fileNode of fileNodes) {
+          const ref = aggregator.resolveSelection(fileNode);
+          if (bundleSeen.has(ref.path)) {
+            continue;
+          }
+          bundleSeen.add(ref.path);
+          bundleFiles.push(ref);
+        }
+        bundles.push({ root: node, files: bundleFiles });
+      }
+      return { files, bundles };
+    }
+  };
+}
+function isAbortError2(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function normalizeError(error, fallback) {
+  return error instanceof Error ? error : new Error(fallback);
+}
+
 export {
   workspaceFileReferenceDefaultExpandedDepth,
   normalizeDirectoryPath,
@@ -896,6 +1541,8 @@ export {
   mergePrefetchedDirectoryState,
   createWorkspaceFileReferenceDirectoryStateFromSnapshot,
   prefetchReferenceTree,
-  useWorkspaceFileReferencePickerView
+  useWorkspaceFileReferencePickerView,
+  ROOT_CHILDREN_KEY,
+  createReferenceSourcePickerController
 };
-//# sourceMappingURL=chunk-LS7P3J6Z.js.map
+//# sourceMappingURL=chunk-KSK6PILG.js.map