@stigmer/react 3.1.0 → 3.1.2

package/workspace/useWorkspaceContentSearch.js

@@ -0,0 +1,154 @@
+"use client";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { toError } from "../internal/toError.js";
+/** Default debounce for content-search query changes — matches `useResourceSearch`. */
+const DEFAULT_DEBOUNCE_MS = 300;
+/**
+ * Minimum query length before a disk search fires. Content search hits the
+ * filesystem on every query (unlike the cached filename search), so a
+ * single-character query would scan the whole tree for a near-useless result.
+ * Two characters is a gentle, documented floor — not an arbitrary limit.
+ */
+const DEFAULT_MIN_LENGTH = 2;
+const EMPTY_GROUPS = [];
+/**
+ * Behavior hook powering workspace-wide content (text) search.
+ *
+ * The text-grep sibling of
+ * {@link useWorkspaceFileSearch}: it keeps
+ * that hook's per-entry aggregation, error isolation, and generation guard, and
+ * adds the platform's canonical debounce idiom from `useResourceSearch`
+ * (`query`/`debouncedQuery` + `setTimeout`). The key difference is that the
+ * debounced query is part of the *fetch* — each keystroke hits disk via the
+ * injected {@link WorkspaceContentSearcher}, uncached — so a `minLength` guard
+ * and a debounce protect the filesystem.
+ *
+ * Prior results stay visible while a new debounced query loads (`isRefetching`
+ * true, results unchanged); only the very first search with nothing to show
+ * flips `isLoading`. This avoids a per-keystroke blank flash the cached filename
+ * search never had.
+ *
+ * @example
+ * ```tsx
+ * const { groups, totalMatches, isRefetching } = useWorkspaceContentSearch({
+ *   entries: workspace.entries,
+ *   searcher: workspaceContentSearcher,
+ *   query,
+ * });
+ * ```
+ */
+export function useWorkspaceContentSearch({ entries, searcher, query, debounceMs = DEFAULT_DEBOUNCE_MS, minLength = DEFAULT_MIN_LENGTH, }) {
+    // Settled results per entry, keyed by entry id. Retained across query changes
+    // and only swapped wholesale when a new generation fully resolves — so a
+    // reload never blanks what the user is already reading.
+    const [results, setResults] = useState({});
+    const [pending, setPending] = useState(false);
+    // Debounce the query into the fetch key (the `useResourceSearch` idiom).
+    const [debouncedQuery, setDebouncedQuery] = useState(query);
+    useEffect(() => {
+        const timer = setTimeout(() => setDebouncedQuery(query), debounceMs);
+        return () => clearTimeout(timer);
+    }, [query, debounceMs]);
+    // Latest entries read inside the effect without widening its dependency to the
+    // (possibly per-render) array identity — the effect keys on the id set instead.
+    const entriesRef = useRef(entries);
+    entriesRef.current = entries;
+    const entriesKey = entries.map((entry) => entry.id).join("\u0000");
+    // Ignore resolutions from a superseded run (id set, searcher, or query changed).
+    const generationRef = useRef(0);
+    const effectiveQuery = debouncedQuery.trim();
+    const belowMinLength = effectiveQuery.length < minLength;
+    useEffect(() => {
+        // No searcher or a too-short query: clear results, nothing in flight. (An
+        // in-flight generation is abandoned via the bumped ref.)
+        if (!searcher || belowMinLength) {
+            generationRef.current += 1;
+            setResults({});
+            setPending(false);
+            return;
+        }
+        const currentEntries = entriesRef.current;
+        const generation = ++generationRef.current;
+        setPending(true);
+        Promise.all(currentEntries.map(async (entry) => {
+            try {
+                const result = await searcher(entry, effectiveQuery);
+                if (result === null)
+                    return [entry.id, { status: "unsupported" }];
+                return [
+                    entry.id,
+                    { status: "ready", matches: result.matches, truncated: result.truncated },
+                ];
+            }
+            catch (err) {
+                return [entry.id, { status: "error", error: toError(err) }];
+            }
+        })).then((settled) => {
+            // A newer generation started while this batch was in flight — drop it so
+            // stale results never overwrite fresher ones (or clobber a cleared state).
+            if (generationRef.current !== generation)
+                return;
+            const next = {};
+            for (const [id, res] of settled)
+                next[id] = res;
+            setResults(next);
+            setPending(false);
+        });
+    }, [entriesKey, searcher, effectiveQuery, belowMinLength]);
+    return useMemo(() => {
+        if (!searcher) {
+            return {
+                groups: EMPTY_GROUPS,
+                totalMatches: 0,
+                isLoading: false,
+                isRefetching: false,
+                isUnsupported: true,
+                error: null,
+            };
+        }
+        const groups = [];
+        let totalMatches = 0;
+        let firstError = null;
+        let unsupportedCount = 0;
+        let settledCount = 0;
+        for (const entry of entries) {
+            const state = results[entry.id];
+            if (!state)
+                continue;
+            settledCount += 1;
+            if (state.status === "unsupported") {
+                unsupportedCount += 1;
+                continue;
+            }
+            if (state.status === "error") {
+                if (!firstError)
+                    firstError = state.error;
+                groups.push({ entry, matches: [], truncated: false, error: state.error });
+                continue;
+            }
+            totalMatches += state.matches.length;
+            // Worth showing only when it carries matches or a truncation notice.
+            if (state.matches.length > 0 || state.truncated) {
+                groups.push({
+                    entry,
+                    matches: state.matches,
+                    truncated: state.truncated,
+                    error: null,
+                });
+            }
+        }
+        const hasPriorResults = settledCount > 0;
+        const isUnsupported = entries.length > 0 && unsupportedCount === entries.length;
+        return {
+            groups,
+            totalMatches,
+            // First search (nothing settled yet) blanks; a reload over existing
+            // results keeps them visible and signals `isRefetching` instead.
+            isLoading: pending && !hasPriorResults,
+            isRefetching: pending && hasPriorResults,
+            isUnsupported,
+            error: firstError,
+        };
+    }, [entries, results, pending, searcher]);
+}
+//# sourceMappingURL=useWorkspaceContentSearch.js.map

package/workspace/useWorkspaceContentSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceContentSearch.js","sourceRoot":"","sources":["../../src/workspace/useWorkspaceContentSearch.ts"],"names":[],"mappings":"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"}

package/workspace/useWorkspaceFileContent.d.ts

@@ -0,0 +1,73 @@
+import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
+import type { WorkspaceFileContent, WorkspaceFileReader } from "./WorkspaceFileReader.js";
+/** Options for {@link useWorkspaceFileContent}. */
+export interface UseWorkspaceFileContentOptions {
+    /** The workspace entry that owns the file, or `null` when nothing is open. */
+    readonly entry: WorkspaceEntry | null;
+    /** Repo-relative (git) or root-relative (local) path, or `null` when nothing is open. */
+    readonly path: string | null;
+    /**
+     * Platform-injected content reader. `undefined` when the host app injects
+     * no reader at all (e.g. web with no GitHub token) — surfaced as
+     * {@link UseWorkspaceFileContentReturn.isUnsupported}, not an error.
+     */
+    readonly reader: WorkspaceFileReader | undefined;
+}
+/** Return value of {@link useWorkspaceFileContent}. */
+export interface UseWorkspaceFileContentReturn {
+    /**
+     * The decoded file content (+ metadata), or `null` while the request is
+     * in-flight, skipped, failed, or the substrate is unsupported. A present
+     * object with `text === null` is a real file that is binary, too large, or
+     * undecodable — distinct from `isUnsupported`.
+     */
+    readonly content: WorkspaceFileContent | null;
+    /** `true` only on the first load, before any content has arrived. */
+    readonly isLoading: boolean;
+    /** `true` while a background refetch is in flight and stale content is shown. */
+    readonly isRefetching: boolean;
+    /** Error from the last failed read (a reader throw), or `null` when healthy. */
+    readonly error: Error | null;
+    /**
+     * `true` when no reader can serve this file — either no reader was injected
+     * or the reader reported the entry's substrate as unsupported (git-on-desktop,
+     * local-on-web, missing token). This is the honest "not available here" state,
+     * never an error.
+     */
+    readonly isUnsupported: boolean;
+    /** Imperatively re-read the current file. Stale content stays visible. */
+    readonly refetch: () => void;
+}
+/**
+ * Behavior hook that reads a single workspace file's content on demand.
+ *
+ * The byte-reading peer of {@link useWorkspaceFiles}
+ * (which lists the tree), built on the same {@link useFetch} engine as the
+ * content-fetch family ({@link useArtifactContent},
+ * `useToolOutputContent`, `useFileChangeContent`) so it inherits their
+ * stale-while-revalidate, cancellation, and `refetch` semantics for free.
+ *
+ * Deliberately passes **no** `cacheKey`: file bodies (up to
+ * {@link MAX_WORKSPACE_FILE_READ_BYTES})
+ * do not belong in the cross-mount metadata cache, which is sized for small,
+ * hot resources. Re-opening a file re-reads it — the correct trade for a
+ * read-only viewer.
+ *
+ * Maps the reader's two failure axes onto distinct states:
+ * - reader resolves `null` (unsupported substrate) -> {@link UseWorkspaceFileContentReturn.isUnsupported}
+ * - reader **throws** (404, network, unreadable) -> {@link UseWorkspaceFileContentReturn.error}
+ *
+ * Pass `null` for `entry`/`path` (or an `undefined` reader) to stay idle —
+ * the established `useFetch` convention.
+ *
+ * @example
+ * ```tsx
+ * const { content, isLoading, error, isUnsupported } = useWorkspaceFileContent({
+ *   entry,
+ *   path: "src/index.ts",
+ *   reader: workspaceFileReader,
+ * });
+ * ```
+ */
+export declare function useWorkspaceFileContent({ entry, path, reader, }: UseWorkspaceFileContentOptions): UseWorkspaceFileContentReturn;
+//# sourceMappingURL=useWorkspaceFileContent.d.ts.map

package/workspace/useWorkspaceFileContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceFileContent.d.ts","sourceRoot":"","sources":["../../src/workspace/useWorkspaceFileContent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,0BAA0B,CAAC;AAElC,mDAAmD;AACnD,MAAM,WAAW,8BAA8B;IAC7C,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAClD;AAED,uDAAuD;AACvD,MAAM,WAAW,6BAA6B;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAAC;IAC9C,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,IAAI,EACJ,MAAM,GACP,EAAE,8BAA8B,GAAG,6BAA6B,CA+BhE"}

package/workspace/useWorkspaceFileContent.js

@@ -0,0 +1,57 @@
+"use client";
+import { useMemo } from "react";
+import { useFetch } from "../internal/useFetch.js";
+const EMPTY_CONTENT = { content: null };
+/**
+ * Behavior hook that reads a single workspace file's content on demand.
+ *
+ * The byte-reading peer of {@link useWorkspaceFiles}
+ * (which lists the tree), built on the same {@link useFetch} engine as the
+ * content-fetch family ({@link useArtifactContent},
+ * `useToolOutputContent`, `useFileChangeContent`) so it inherits their
+ * stale-while-revalidate, cancellation, and `refetch` semantics for free.
+ *
+ * Deliberately passes **no** `cacheKey`: file bodies (up to
+ * {@link MAX_WORKSPACE_FILE_READ_BYTES})
+ * do not belong in the cross-mount metadata cache, which is sized for small,
+ * hot resources. Re-opening a file re-reads it — the correct trade for a
+ * read-only viewer.
+ *
+ * Maps the reader's two failure axes onto distinct states:
+ * - reader resolves `null` (unsupported substrate) -> {@link UseWorkspaceFileContentReturn.isUnsupported}
+ * - reader **throws** (404, network, unreadable) -> {@link UseWorkspaceFileContentReturn.error}
+ *
+ * Pass `null` for `entry`/`path` (or an `undefined` reader) to stay idle —
+ * the established `useFetch` convention.
+ *
+ * @example
+ * ```tsx
+ * const { content, isLoading, error, isUnsupported } = useWorkspaceFileContent({
+ *   entry,
+ *   path: "src/index.ts",
+ *   reader: workspaceFileReader,
+ * });
+ * ```
+ */
+export function useWorkspaceFileContent({ entry, path, reader, }) {
+    // The fetch runs only when a reader, an entry, and a path are all present.
+    const enabled = !!(reader && entry && path);
+    const { data, isLoading, isRefetching, error, refetch } = useFetch(enabled
+        ? () => reader(entry, path).then((c) => ({ content: c }))
+        : null, 
+    // Identity deps: a change to any of these is a different file to read.
+    [entry?.id ?? null, path ?? null, reader], EMPTY_CONTENT);
+    // Unsupported = no reader at all, or a completed fetch that resolved to null
+    // (the reader's "this substrate isn't mine" signal). In-flight and error
+    // states are excluded so the viewer shows loading/error, not "unavailable".
+    const isUnsupported = !reader || (enabled && !isLoading && !error && data.content === null);
+    return useMemo(() => ({
+        content: data.content,
+        isLoading,
+        isRefetching,
+        error,
+        isUnsupported,
+        refetch,
+    }), [data.content, isLoading, isRefetching, error, isUnsupported, refetch]);
+}
+//# sourceMappingURL=useWorkspaceFileContent.js.map

package/workspace/useWorkspaceFileContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceFileContent.js","sourceRoot":"","sources":["../../src/workspace/useWorkspaceFileContent.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAyDnD,MAAM,aAAa,GAAoB,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,uBAAuB,CAAC,EACtC,KAAK,EACL,IAAI,EACJ,MAAM,GACyB;IAC/B,2EAA2E;IAC3E,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC,MAAM,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC;IAE5C,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,GACrD,QAAQ,CACN,OAAO;QACL,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;QACzD,CAAC,CAAC,IAAI;IACR,uEAAuE;IACvE,CAAC,KAAK,EAAE,EAAE,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,MAAM,CAAC,EACzC,aAAa,CACd,CAAC;IAEJ,6EAA6E;IAC7E,yEAAyE;IACzE,4EAA4E;IAC5E,MAAM,aAAa,GACjB,CAAC,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC;IAExE,OAAO,OAAO,CACZ,GAAG,EAAE,CAAC,CAAC;QACL,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,SAAS;QACT,YAAY;QACZ,KAAK;QACL,aAAa;QACb,OAAO;KACR,CAAC,EACF,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,CACvE,CAAC;AACJ,CAAC"}

package/workspace/useWorkspaceFileSearch.d.ts

@@ -0,0 +1,61 @@
+import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
+import type { WorkspaceFileLister } from "./WorkspaceFileLister.js";
+import { type WorkspaceFileMatch } from "./matchWorkspaceFiles.js";
+/** Options for {@link useWorkspaceFileSearch}. */
+export interface UseWorkspaceFileSearchOptions {
+    /** All workspace entries to search across. */
+    readonly entries: readonly WorkspaceEntry[];
+    /** Platform-injected file lister. `undefined` → nothing is searchable. */
+    readonly lister: WorkspaceFileLister | undefined;
+    /** Current search query. Empty/whitespace yields no matches (search shows a hint). */
+    readonly query: string;
+}
+/** Matches (and per-entry status) for one workspace entry. */
+export interface WorkspaceFileSearchGroup {
+    /** The workspace entry these matches belong to. */
+    readonly entry: WorkspaceEntry;
+    /** Ranked matches within this entry, best-first. */
+    readonly matches: readonly WorkspaceFileMatch[];
+    /** `true` when this entry's listing was truncated (repository too large). */
+    readonly truncated: boolean;
+    /** Listing error for this entry, if any (isolated — other entries still resolve). */
+    readonly error: Error | null;
+}
+/** Return value of {@link useWorkspaceFileSearch}. */
+export interface UseWorkspaceFileSearchReturn {
+    /** Entries with something to show (matches, an error, or a truncation notice). */
+    readonly groups: readonly WorkspaceFileSearchGroup[];
+    /** Total matches across all groups (for a "showing N of M" affordance). */
+    readonly totalMatches: number;
+    /** `true` while any entry's listing is still loading. */
+    readonly isLoading: boolean;
+    /** `true` when no substrate can be searched (no lister, or every entry unsupported). */
+    readonly isUnsupported: boolean;
+    /** First per-entry error, for a top-level fallback message. `null` when none. */
+    readonly error: Error | null;
+}
+/**
+ * Behavior hook powering workspace-wide filename/path search.
+ *
+ * Loads each entry's listing through the shared
+ * {@link loadEntryFiles} cache (warm from
+ * Files browsing → usually free), then ranks matches per entry with the pure
+ * {@link matchWorkspaceFiles}. Fetching is keyed by the set of entry ids, so a
+ * query change re-ranks the already-loaded listings without re-fetching. Errors
+ * are isolated per entry (one failing repo never blanks the rest), and a stale
+ * generation's late resolutions are ignored.
+ *
+ * Meant to be consumed by a component mounted only while Search is active
+ * (`WorkspaceFileSearch`), so the Files view incurs no search fetching.
+ *
+ * @example
+ * ```tsx
+ * const { groups, totalMatches, isLoading } = useWorkspaceFileSearch({
+ *   entries: workspace.entries,
+ *   lister: workspaceFileLister,
+ *   query,
+ * });
+ * ```
+ */
+export declare function useWorkspaceFileSearch({ entries, lister, query, }: UseWorkspaceFileSearchOptions): UseWorkspaceFileSearchReturn;
+//# sourceMappingURL=useWorkspaceFileSearch.d.ts.map

package/workspace/useWorkspaceFileSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceFileSearch.d.ts","sourceRoot":"","sources":["../../src/workspace/useWorkspaceFileSearch.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAExF,kDAAkD;AAClD,MAAM,WAAW,6BAA6B;IAC5C,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACjD,sFAAsF;IACtF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,8DAA8D;AAC9D,MAAM,WAAW,wBAAwB;IACvC,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAChD,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,qFAAqF;IACrF,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED,sDAAsD;AACtD,MAAM,WAAW,4BAA4B;IAC3C,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACrD,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,wFAAwF;IACxF,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,iFAAiF;IACjF,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAWD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,MAAM,EACN,KAAK,GACN,EAAE,6BAA6B,GAAG,4BAA4B,CAsG9D"}

package/workspace/useWorkspaceFileSearch.js

@@ -0,0 +1,119 @@
+"use client";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { toError } from "../internal/toError.js";
+import { loadEntryFiles } from "./workspaceListingCache.js";
+import { matchWorkspaceFiles } from "./matchWorkspaceFiles.js";
+const EMPTY_GROUPS = [];
+/**
+ * Behavior hook powering workspace-wide filename/path search.
+ *
+ * Loads each entry's listing through the shared
+ * {@link loadEntryFiles} cache (warm from
+ * Files browsing → usually free), then ranks matches per entry with the pure
+ * {@link matchWorkspaceFiles}. Fetching is keyed by the set of entry ids, so a
+ * query change re-ranks the already-loaded listings without re-fetching. Errors
+ * are isolated per entry (one failing repo never blanks the rest), and a stale
+ * generation's late resolutions are ignored.
+ *
+ * Meant to be consumed by a component mounted only while Search is active
+ * (`WorkspaceFileSearch`), so the Files view incurs no search fetching.
+ *
+ * @example
+ * ```tsx
+ * const { groups, totalMatches, isLoading } = useWorkspaceFileSearch({
+ *   entries: workspace.entries,
+ *   lister: workspaceFileLister,
+ *   query,
+ * });
+ * ```
+ */
+export function useWorkspaceFileSearch({ entries, lister, query, }) {
+    const [states, setStates] = useState({});
+    // Latest entries read inside the effect without widening its dependency to the
+    // (possibly per-render) array identity — the effect keys on the id set instead.
+    const entriesRef = useRef(entries);
+    entriesRef.current = entries;
+    const entriesKey = entries.map((entry) => entry.id).join("\u0000");
+    // Ignore resolutions from a superseded entry set (id set or lister changed).
+    const generationRef = useRef(0);
+    useEffect(() => {
+        if (!lister) {
+            setStates({});
+            return;
+        }
+        const currentEntries = entriesRef.current;
+        const generation = ++generationRef.current;
+        // Seed loading for not-yet-known entries; drop states for removed ones.
+        setStates((prev) => {
+            const next = {};
+            for (const entry of currentEntries) {
+                next[entry.id] = prev[entry.id] ?? { status: "loading" };
+            }
+            return next;
+        });
+        for (const entry of currentEntries) {
+            loadEntryFiles(entry, lister)
+                .then((listing) => {
+                if (generationRef.current !== generation)
+                    return;
+                setStates((prev) => ({
+                    ...prev,
+                    [entry.id]: listing === null
+                        ? { status: "unsupported" }
+                        : { status: "ready", listing },
+                }));
+            })
+                .catch((err) => {
+                if (generationRef.current !== generation)
+                    return;
+                setStates((prev) => ({
+                    ...prev,
+                    [entry.id]: { status: "error", error: toError(err) },
+                }));
+            });
+        }
+    }, [entriesKey, lister]);
+    return useMemo(() => {
+        if (!lister) {
+            return {
+                groups: EMPTY_GROUPS,
+                totalMatches: 0,
+                isLoading: false,
+                isUnsupported: true,
+                error: null,
+            };
+        }
+        const groups = [];
+        let totalMatches = 0;
+        let isLoading = false;
+        let firstError = null;
+        let unsupportedCount = 0;
+        for (const entry of entries) {
+            const state = states[entry.id];
+            if (!state || state.status === "loading") {
+                isLoading = true;
+                continue;
+            }
+            if (state.status === "unsupported") {
+                unsupportedCount += 1;
+                continue;
+            }
+            const error = state.status === "error" ? state.error ?? null : null;
+            if (error && !firstError)
+                firstError = error;
+            const truncated = state.listing?.truncated ?? false;
+            const matches = state.listing
+                ? matchWorkspaceFiles(state.listing.files, query)
+                : [];
+            totalMatches += matches.length;
+            // A group is worth showing only when it carries matches, an error, or a
+            // truncation notice — otherwise it is silent.
+            if (matches.length > 0 || error || truncated) {
+                groups.push({ entry, matches, truncated, error });
+            }
+        }
+        const isUnsupported = entries.length > 0 && unsupportedCount === entries.length;
+        return { groups, totalMatches, isLoading, isUnsupported, error: firstError };
+    }, [entries, states, query, lister]);
+}
+//# sourceMappingURL=useWorkspaceFileSearch.js.map

package/workspace/useWorkspaceFileSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceFileSearch.js","sourceRoot":"","sources":["../../src/workspace/useWorkspaceFileSearch.ts"],"names":[],"mappings":"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"}

package/workspace/useWorkspaceFiles.d.ts

@@ -1,6 +1,6 @@
-import { type TreeNode } from "../internal/file-tree";
-import type { WorkspaceEntry } from "./useWorkspaceEntries";
-import type { WorkspaceFileLister } from "./WorkspaceFileLister";
+import type { TreeNode } from "../internal/file-tree/index.js";
+import type { WorkspaceEntry } from "./useWorkspaceEntries.js";
+import type { WorkspaceFileLister } from "./WorkspaceFileLister.js";
 /** Options for {@link useWorkspaceFiles}. */
 export interface UseWorkspaceFilesOptions {
     /** The workspace entry to list files for (`null` when nothing is selected). */
@@ -16,6 +16,12 @@ export interface UseWorkspaceFilesReturn {
     readonly isLoading: boolean;
     /** Error from the lister, if any. */
     readonly error: Error | null;
+    /**
+     * `true` when the listing was truncated by the backend (repository too large).
+     * The advisory entry is excluded from `tree`; callers render an incomplete-results
+     * banner from this flag instead (DD-11).
+     */
+    readonly truncated: boolean;
     /** Re-fetch the file listing for the current entry (cache-bust). */
     readonly refresh: () => void;
 }
@@ -23,16 +29,18 @@ export interface UseWorkspaceFilesReturn {
  * Behavior hook that fetches and caches a file listing for a single
  * workspace entry, converting it into a {@link TreeNode} hierarchy.
  *
- * - Calls the platform-injected `lister` when the entry changes.
- * - Caches results per `entry.id` so tab switches and re-expands
- *   are instant without re-fetching.
+ * - Calls the platform-injected `lister` (via the shared
+ *   {@link loadEntryFiles} cache) when the
+ *   entry changes.
+ * - Reads the shared listing cache so tab switches, re-expands, and the search
+ *   surface are instant without re-fetching (one cache, keyed by `entry.id`).
  * - Returns an empty tree and skips the call when `lister` is
  *   `undefined` (graceful degradation — DD-011 opt-in).
  * - Memoizes the return value for referential stability (DD-010).
  *
  * @example
  * ```tsx
- * const { tree, isLoading, error, refresh } = useWorkspaceFiles({
+ * const { tree, isLoading, error, truncated, refresh } = useWorkspaceFiles({
  *   entry: selectedEntry,
  *   lister: workspaceFileLister,
  * });

package/workspace/useWorkspaceFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWorkspaceFiles.d.ts","sourceRoot":"","sources":["../../src/workspace/useWorkspaceFiles.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAsB,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAErF,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,sGAAsG;IACtG,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAClD;AAED,iDAAiD;AACjD,MAAM,WAAW,uBAAuB;IACtC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IACnC,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAiBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,MAAM,GACP,EAAE,wBAAwB,GAAG,uBAAuB,CAsEpD"}
+{"version":3,"file":"useWorkspaceFiles.d.ts","sourceRoot":"","sources":["../../src/workspace/useWorkspaceFiles.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAGpE,6CAA6C;AAC7C,MAAM,WAAW,wBAAwB;IACvC,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,sGAAsG;IACtG,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAClD;AAED,iDAAiD;AACjD,MAAM,WAAW,uBAAuB;IACtC,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IACnC,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B;AAID;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,MAAM,GACP,EAAE,wBAAwB,GAAG,uBAAuB,CA0EpD"}

package/workspace/useWorkspaceFiles.js

@@ -1,29 +1,24 @@
 "use client";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { buildFileTree } from "../internal/file-tree";
-import { toError } from "../internal/toError";
+import { toError } from "../internal/toError.js";
+import { loadEntryFiles, peekEntryListing } from "./workspaceListingCache.js";
 const EMPTY_TREE = [];
-/**
- * Module-level cache shared across all component instances. This ensures
- * that switching between tabs (e.g., Workspace tab unmount/remount) doesn't
- * re-fetch file listings that were already loaded. Entries are keyed by
- * the workspace entry's stable ID.
- */
-const sharedCache = new Map();
 /**
  * Behavior hook that fetches and caches a file listing for a single
  * workspace entry, converting it into a {@link TreeNode} hierarchy.
  *
- * - Calls the platform-injected `lister` when the entry changes.
- * - Caches results per `entry.id` so tab switches and re-expands
- *   are instant without re-fetching.
+ * - Calls the platform-injected `lister` (via the shared
+ *   {@link loadEntryFiles} cache) when the
+ *   entry changes.
+ * - Reads the shared listing cache so tab switches, re-expands, and the search
+ *   surface are instant without re-fetching (one cache, keyed by `entry.id`).
  * - Returns an empty tree and skips the call when `lister` is
  *   `undefined` (graceful degradation — DD-011 opt-in).
  * - Memoizes the return value for referential stability (DD-010).
  *
  * @example
  * ```tsx
- * const { tree, isLoading, error, refresh } = useWorkspaceFiles({
+ * const { tree, isLoading, error, truncated, refresh } = useWorkspaceFiles({
  *   entry: selectedEntry,
  *   lister: workspaceFileLister,
  * });
@@ -33,14 +28,16 @@ export function useWorkspaceFiles({ entry, lister, }) {
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [tree, setTree] = useState(EMPTY_TREE);
+    const [truncated, setTruncated] = useState(false);
     const fetchIdRef = useRef(0);
     const fetchFiles = useCallback(async (target, bustCache) => {
         if (!lister)
             return;
         if (!bustCache) {
-            const cached = sharedCache.get(target.id);
+            const cached = peekEntryListing(target.id);
             if (cached) {
                 setTree(cached.tree);
+                setTruncated(cached.truncated);
                 setError(null);
                 setIsLoading(false);
                 return;
@@ -50,17 +47,17 @@ export function useWorkspaceFiles({ entry, lister, }) {
         setIsLoading(true);
         setError(null);
         try {
-            const files = await lister(target);
+            const listing = await loadEntryFiles(target, lister, { bustCache });
             if (fetchIdRef.current !== id)
                 return;
-            if (files === null) {
+            if (listing === null) {
                 setTree(EMPTY_TREE);
+                setTruncated(false);
                 setIsLoading(false);
                 return;
             }
-            const built = buildFileTree(files.filter((f) => !f.isDirectory));
-            sharedCache.set(target.id, { files, tree: built });
-            setTree(built);
+            setTree(listing.tree);
+            setTruncated(listing.truncated);
             setIsLoading(false);
         }
         catch (err) {
@@ -68,12 +65,14 @@ export function useWorkspaceFiles({ entry, lister, }) {
                 return;
             setError(toError(err));
             setTree(EMPTY_TREE);
+            setTruncated(false);
             setIsLoading(false);
         }
     }, [lister]);
     useEffect(() => {
         if (!entry || !lister) {
             setTree(EMPTY_TREE);
+            setTruncated(false);
             setIsLoading(false);
             setError(null);
             return;
@@ -85,6 +84,6 @@ export function useWorkspaceFiles({ entry, lister, }) {
             fetchFiles(entry, true);
         }
     }, [entry, lister, fetchFiles]);
-    return useMemo(() => ({ tree, isLoading, error, refresh }), [tree, isLoading, error, refresh]);
+    return useMemo(() => ({ tree, isLoading, error, truncated, refresh }), [tree, isLoading, error, truncated, refresh]);
 }
 //# sourceMappingURL=useWorkspaceFiles.js.map