@deepwatch/dsh-library 0.1.0

package/lib/client/read-plane.js

@@ -0,0 +1,193 @@
+/**
+ * The Library's end of the read plane: what the surface asks, and what it does
+ * with the answer.
+ *
+ * The Host end is `@deepwatch/dsh-tools`, which registers `WatchQueryService`
+ * and lets Typert generate a strict Remote from it. The Library does not import
+ * that generated artifact and does not mount it. Doing either would make the
+ * package that owns the Library capability depend on the package that reads it,
+ * which is the cycle `@deepwatch/dsh-client-remotes` exists to remove.
+ *
+ * So the namespace is described here from the contracts both ends already
+ * share. `@deepwatch/dsh-contracts/query/wire` is the single definition of
+ * every request and response on this wire — the generated declaration imports
+ * its types from exactly that module — and `RemoteResult` is upstream's own
+ * envelope. Nothing below restates a shape either side owns.
+ *
+ * That leaves one thing a shared contract cannot prove: that the namespace
+ * really is called `watchQuery` and really carries these two methods. Two
+ * things hold it. `@deepwatch/dsh-client-remotes` compares this interface
+ * against the generated one at compile time, so a changed signature stops the
+ * build; and `tests/remote-client-mount.test.mjs` mounts the real contribution
+ * through the real Gateway and calls it, so a changed *name* fails a test
+ * rather than a page.
+ *
+ * @module @deepwatch/dsh-library/client/read-plane
+ */
+import { WATCH_QUERY_WIRE_VERSION } from '@deepwatch/dsh-contracts/query/wire';
+/**
+ * Correlation ids, from a counter rather than from randomness.
+ *
+ * The host refuses a `requestId` that is not an identifier, and a counter
+ * produces one by construction. It is also what makes a failing request
+ * quotable: `library-7` names a call somebody can find twice.
+ */
+let sequence = 0;
+/** The next correlation id for a Library read. */
+export function nextRequestId() {
+    sequence += 1;
+    return `library-${String(sequence)}`;
+}
+/** An answer that produced no rows, and says why. */
+function nothing(note, health = 'stale') {
+    return { rows: [], total: 0, health, generation: 0, notes: [note], pageable: false };
+}
+/** The host's own vocabulary for index condition, in the surface's terms. */
+function healthOf(state) {
+    return state === 'rebuilding' ? 'indexing' : state;
+}
+/** One wire record as a row. */
+function rowOf(record) {
+    return {
+        key: `${record.recordId}@${record.revisionId}`,
+        recordId: record.recordId,
+        title: record.title,
+        kind: record.modality,
+        // The wire record carries provenance, not excerpts: the Host answers with
+        // what it persisted, and inventing a snippet from a title would put text on
+        // screen that no record contains.
+        snippets: [],
+        evidenceCount: record.evidenceIds.length,
+        current: record.current,
+    };
+}
+/**
+ * Ask the host, and turn whatever comes back into something renderable.
+ *
+ * Every outcome is an answer the surface shows rather than an exception it
+ * swallows. A refusal, an elapsed deadline and an expired cursor are different
+ * facts, and a person acts differently on each, so each keeps its own sentence.
+ */
+export async function readLibraryPage(reads, query, signal) {
+    const answer = await reads.librarySearch({
+        protocol: WATCH_QUERY_WIRE_VERSION,
+        requestId: nextRequestId(),
+        query: query.text,
+        modalities: query.modality === '' ? [] : [query.modality],
+        limit: query.limit,
+        cursor: null,
+        deadlineMs: query.deadlineMs,
+    }, signal);
+    // The transport envelope first. `ok: false` means the call never produced a
+    // domain answer at all — no Connection, a Gateway refusal, a codec that
+    // rejected the response — and reporting that as an empty library would be a
+    // lie about what the workspace contains.
+    if (!answer.ok) {
+        return nothing(`The Library host did not answer: ${answer.error.message}`, 'corrupt');
+    }
+    const value = answer.value;
+    switch (value.outcome) {
+        case 'page': {
+            const notes = value.records.length < value.total
+                ? [`Showing ${String(value.records.length)} of ${String(value.total)} matches; `
+                        + 'the host answered with one page and offered no cursor.']
+                : [];
+            return {
+                rows: value.records.map(rowOf),
+                total: value.total,
+                health: healthOf(value.indexState),
+                generation: value.generation,
+                notes,
+                // `nextCursor` is the host's own statement about whether more remains.
+                // Deriving it from `total` instead would offer a Next control the host
+                // has no way to answer.
+                pageable: value.nextCursor !== null,
+            };
+        }
+        case 'rejected':
+            return nothing(`The host refused the request (${value.reason}`
+                + `${value.field === null ? '' : ` at ${value.field}`}).`);
+        case 'deadline_exceeded':
+            return nothing(`The host did not answer within ${String(value.deadlineMs)}ms. Try a narrower query.`);
+        case 'cursor_expired':
+            return nothing('That page is no longer held by the host. Search again.');
+    }
+}
+/** A local index answer as the same view model, so the surface renders one shape. */
+export function fromIndex(result) {
+    return {
+        rows: result.results.map(entry => ({
+            key: entry.sourceId,
+            recordId: entry.sourceId,
+            title: entry.title,
+            kind: entry.kind,
+            snippets: entry.hits.map(hit => hit.text),
+            evidenceCount: entry.hits[0]?.evidenceIds.length ?? 0,
+            current: entry.current,
+        })),
+        total: result.total,
+        health: result.health,
+        // The local index is not a host generation and does not pretend to be one.
+        generation: 0,
+        notes: result.notes,
+        pageable: true,
+    };
+}
+/**
+ * Ask the host to read its roots again.
+ *
+ * Every outcome is rendered, and none of them is an exception. A refusal, an
+ * elapsed deadline, an abandoned rebuild and a failed one are four different
+ * facts; so is a rebuild that succeeded and found nothing new. Reporting any
+ * of them as "refreshed" would be a control that lies about what it did.
+ */
+export async function refreshLibrary(reads, deadlineMs, signal) {
+    const answer = await reads.libraryRefresh({
+        protocol: WATCH_QUERY_WIRE_VERSION,
+        requestId: nextRequestId(),
+        deadlineMs,
+    }, signal);
+    if (!answer.ok) {
+        return failedRefresh(`The Library host did not answer: ${answer.error.message}`);
+    }
+    const value = answer.value;
+    switch (value.outcome) {
+        case 'refreshed':
+            return {
+                refreshed: true,
+                generation: value.index.generation,
+                recordCount: value.index.recordCount,
+                note: value.skipped.length === 0
+                    ? ''
+                    : `${String(value.skipped.length)} file(s) were not readable: `
+                        + value.skipped.slice(0, 3).join('; '),
+                failed: false,
+            };
+        case 'refresh_cancelled':
+            return {
+                refreshed: false,
+                generation: value.index.generation,
+                recordCount: value.index.recordCount,
+                note: 'The refresh was abandoned. The Library is unchanged.',
+                failed: false,
+            };
+        case 'refresh_failed':
+            return {
+                refreshed: false,
+                generation: value.index.generation,
+                recordCount: value.index.recordCount,
+                note: `The refresh failed: ${value.reason}. The previous index is still searchable.`,
+                failed: true,
+            };
+        case 'rejected':
+            return failedRefresh(`The host refused the refresh (${value.reason}).`);
+        case 'deadline_exceeded':
+            return failedRefresh(`The refresh did not finish within ${String(value.deadlineMs)}ms. `
+                + 'It may still be running on the host.');
+    }
+}
+/** A refresh that produced no generation, and why. */
+function failedRefresh(note) {
+    return { refreshed: false, generation: 0, recordCount: 0, note, failed: true };
+}
+//# sourceMappingURL=read-plane.js.map

package/lib/client/search-view.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The Library, as a working search surface.
+ *
+ * It is backed by `LibraryIndex` — a local, derived, rebuildable inverted index
+ * — so search works offline, needs no service and needs no embedding model.
+ * Semantic retrieval stays a future optional plugin; this is what runs on any
+ * machine today.
+ *
+ * The records come from the evidence the workspace has actually seen. Where
+ * there are none the surface says so and offers a rebuild, rather than
+ * presenting an empty result set as though a search had run and found nothing —
+ * those are different facts and a person acts differently on each.
+ *
+ * Accessibility is not an afterthought here because a search box is where
+ * keyboard and screen-reader behaviour is most obviously felt: the field is
+ * labelled, results are a live region announcing their own count, every filter
+ * is a real control, and the index's condition is announced rather than only
+ * coloured.
+ *
+ * @module @deepwatch/dsh-library/client/search-view
+ */
+import type { ReactNode } from 'react';
+import { LibraryIndex, MAX_LIMIT } from '../index-store.js';
+import type { IndexableRecord } from '../index-store.js';
+import type { WatchQueryRemote } from './read-plane.js';
+export interface LibrarySearchProps {
+    /** The records to index. The store remains the source of truth. */
+    readonly records?: readonly IndexableRecord[];
+    /** Injected for tests; production builds its own. */
+    readonly index?: LibraryIndex;
+    /**
+     * The mounted `ctx.remote.watchQuery` namespace, when there is one.
+     *
+     * Present in a profile: the workspace's own host holds the library, and
+     * answering from a browser-side copy of it would be a second index with its
+     * own drift. Absent everywhere else — a test, a story, a build without the
+     * Host row — and the local index answers instead.
+     */
+    readonly reads?: WatchQueryRemote | undefined;
+}
+/** The Library search workflow: query, filter, sort, page, rebuild. */
+export declare function LibrarySearch({ records, index: injected, reads }: LibrarySearchProps): ReactNode;
+export { MAX_LIMIT };
+//# sourceMappingURL=search-view.d.ts.map

package/lib/client/search-view.js

@@ -0,0 +1,233 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
+import { LibraryIndex, MAX_LIMIT, tokenize } from '../index-store.js';
+import { fromIndex, readLibraryPage, refreshLibrary } from './read-plane.js';
+const PAGE = 10;
+/**
+ * How long the surface will wait for the host before it must show something.
+ *
+ * Shorter than the host's own ceiling on purpose: the host clamps to 30s, and a
+ * search box that can appear frozen for half a minute is a search box people
+ * stop trusting. The host is told this number, so an answer it cannot produce
+ * in time comes back as `deadline_exceeded` — a sentence on the screen — rather
+ * than as a request nobody ever cancelled.
+ */
+const DEADLINE_MS = 10_000;
+/**
+ * How long the surface will wait for a rebuild.
+ *
+ * Longer than a search, because it is one: reading a corpus is work a person
+ * has asked for and expects to take a moment. Still bounded, and still the
+ * number the host is told, so an overrun comes back as an answer rather than
+ * as a control that never settles.
+ */
+const REFRESH_DEADLINE_MS = 60_000;
+const S = {
+    root: {
+        display: 'flex', flexDirection: 'column', gap: '14px',
+        height: '100%', minHeight: 0,
+    },
+    bar: { display: 'flex', gap: '10px', flexWrap: 'wrap', alignItems: 'flex-end' },
+    field: { display: 'flex', flexDirection: 'column', gap: '4px', flex: '1 1 260px', minWidth: 0 },
+    label: {
+        fontSize: '11px', fontWeight: 600, letterSpacing: '.05em',
+        textTransform: 'uppercase', color: 'var(--dsw-alias-label-tertiary)',
+    },
+    input: {
+        background: 'var(--dsw-alias-bg-layer-2)',
+        border: '1px solid color-mix(in srgb, var(--watch-accent) 12%, var(--dsw-alias-border-l2))',
+        borderRadius: '10px', padding: '9px 11px', fontSize: '13px',
+        color: 'inherit', font: 'inherit', minWidth: 0, width: '100%',
+    },
+    select: {
+        background: 'var(--dsw-alias-bg-layer-2)',
+        border: '1px solid color-mix(in srgb, var(--watch-accent) 12%, var(--dsw-alias-border-l2))',
+        borderRadius: '10px', padding: '9px 11px', fontSize: '13px', color: 'inherit',
+    },
+    button: {
+        background: 'transparent', border: '1px solid var(--dsw-alias-border-l2)',
+        borderRadius: '10px', padding: '9px 13px', fontSize: '13px',
+        color: 'inherit', cursor: 'pointer',
+    },
+    status: { fontSize: '12px', color: 'var(--dsw-alias-label-tertiary)', margin: 0 },
+    list: { display: 'flex', flexDirection: 'column', gap: '8px', margin: 0, padding: 0, listStyle: 'none' },
+    hit: {
+        border: '1px solid color-mix(in srgb, var(--watch-accent) 9%, var(--dsw-alias-border-l2))', borderRadius: '14px',
+        padding: '14px 16px', background: 'linear-gradient(145deg, color-mix(in srgb, var(--watch-accent) 3%, var(--dsw-alias-bg-layer-2)), var(--dsw-alias-bg-base))',
+        boxShadow: '0 8px 24px color-mix(in srgb, black 7%, transparent)',
+    },
+    title: { fontSize: '13.5px', fontWeight: 600, margin: 0 },
+    snippet: {
+        fontSize: '12.5px', lineHeight: 1.6, margin: '6px 0 0',
+        color: 'var(--dsw-alias-label-secondary)', wordBreak: 'break-word',
+    },
+    meta: { fontSize: '11.5px', color: 'var(--dsw-alias-label-tertiary)', marginTop: '6px', display: 'flex', gap: '10px', flexWrap: 'wrap' },
+};
+/** What the index says about itself, in words a person can act on. */
+const HEALTH = {
+    empty: { says: 'Nothing indexed yet.', tone: 'var(--watch-tone-neutral)' },
+    ready: { says: 'Index ready.', tone: 'var(--watch-tone-active)' },
+    indexing: { says: 'Indexing — results are partial.', tone: 'var(--watch-tone-caution)' },
+    stale: { says: 'Index is behind the store.', tone: 'var(--watch-tone-caution)' },
+    corrupt: { says: 'Index unreadable. Rebuild required.', tone: 'var(--watch-tone-error)' },
+};
+const KINDS = ['video', 'audio', 'page', 'stream', 'document', 'screen_capture'];
+/**
+ * Highlight matches without building markup.
+ *
+ * The snippet is evidence, so it is never altered and never handed to a
+ * renderer as HTML. Splitting into plain segments and marking them with React
+ * elements keeps escaping the renderer's job, which is the only place it is
+ * reliably done.
+ */
+function Highlighted({ text, terms }) {
+    if (terms.length === 0 || text === '')
+        return _jsx(_Fragment, { children: text });
+    const pattern = terms
+        .map(term => term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .filter(term => term !== '')
+        .join('|');
+    if (pattern === '')
+        return _jsx(_Fragment, { children: text });
+    const parts = text.split(new RegExp(`(${pattern})`, 'giu'));
+    return (_jsx(_Fragment, { children: parts.map((part, index) => (terms.includes(part.toLowerCase())
+            ? _jsx("mark", { style: { background: 'var(--watch-wash-active)', color: 'inherit' }, children: part }, `${part}-${String(index)}`)
+            : _jsx("span", { children: part }, `${part}-${String(index)}`))) }));
+}
+/** The Library search workflow: query, filter, sort, page, rebuild. */
+export function LibrarySearch({ records = [], index: injected, reads }) {
+    const queryId = useId();
+    const kindId = useId();
+    const verdictId = useId();
+    const sortId = useId();
+    const [text, setText] = useState('');
+    const [kind, setKind] = useState('');
+    const [verdict, setVerdict] = useState('');
+    const [sort, setSort] = useState('relevance');
+    const [offset, setOffset] = useState(0);
+    const [generation, setGeneration] = useState(0);
+    const [state, setState] = useState(null);
+    // Bounded progress. `true` only while a rebuild the host accepted is
+    // outstanding, so the control cannot appear busy after the answer arrived.
+    const [refreshing, setRefreshing] = useState(false);
+    const [refreshed, setRefreshed] = useState(null);
+    const index = useMemo(() => {
+        if (injected !== undefined)
+            return injected;
+        const built = new LibraryIndex();
+        built.addAll(records);
+        return built;
+    }, [injected, records, generation]);
+    // Every query supersedes the one before it. Without this, a slow search over
+    // a large corpus can land after a newer one and overwrite it with stale
+    // results — the classic race that makes a search box feel haunted. It is what
+    // carries cancellation to the host too: the Remote takes the same signal, so
+    // an abandoned query is abandoned on both sides rather than only on this one.
+    const inFlight = useRef(null);
+    const run = useCallback((nextOffset) => {
+        inFlight.current?.abort();
+        const controller = new AbortController();
+        inFlight.current = controller;
+        setOffset(nextOffset);
+        if (reads === undefined) {
+            setState(fromIndex(index.search({
+                text,
+                ...(kind === '' ? {} : { kinds: [kind] }),
+                ...(verdict === '' ? {} : { verdicts: [verdict] }),
+                sort,
+                offset: nextOffset,
+                limit: PAGE,
+                signal: controller.signal,
+            })));
+            return;
+        }
+        void readLibraryPage(reads, { text, modality: kind, limit: PAGE, deadlineMs: DEADLINE_MS }, controller.signal).then(next => {
+            // A superseded answer is dropped rather than rendered: the newer query
+            // already owns the screen.
+            if (!controller.signal.aborted)
+                setState(next);
+        });
+    }, [reads, index, text, kind, verdict, sort]);
+    useEffect(() => { run(0); }, [run]);
+    useEffect(() => () => { inFlight.current?.abort(); }, []);
+    /**
+     * Ask the host to read its roots again, then search the result.
+     *
+     * Two steps rather than one, and deliberately in that order: the refresh
+     * reports what the host now holds, and the search that follows is what puts
+     * it on the screen. Collapsing them would leave the count and the rows
+     * describing two different generations.
+     */
+    const refresh = useCallback(() => {
+        if (reads === undefined) {
+            // No host to ask. The local index is derived, so discarding it and
+            // building it again is the whole refresh.
+            setGeneration(value => value + 1);
+            return;
+        }
+        if (refreshing)
+            return;
+        setRefreshing(true);
+        setRefreshed(null);
+        const controller = new AbortController();
+        void refreshLibrary(reads, REFRESH_DEADLINE_MS, controller.signal)
+            .then(next => {
+            setRefreshed(next);
+            setRefreshing(false);
+            // Re-read only where the host actually swapped something in. A failed
+            // refresh leaves the previous index searchable and the rows on screen
+            // are still correct for it.
+            if (next.refreshed)
+                setGeneration(value => value + 1);
+        });
+    }, [reads, refreshing]);
+    const terms = useMemo(() => tokenize(text), [text]);
+    // `noUncheckedIndexedAccess` is on, so an index lookup is optional even
+    // with a total record type. Falling back keeps the surface renderable
+    // for a health value a future build adds before this one knows it.
+    const health = HEALTH[state?.health ?? (reads === undefined ? index.health : 'empty')]
+        ?? { says: 'Index state unknown.', tone: 'var(--watch-tone-neutral)' };
+    const rows = state?.rows ?? [];
+    const total = state?.total ?? 0;
+    const shown = rows.length;
+    const page = Math.floor(offset / PAGE) + 1;
+    // The host answers one page and offers no cursor, so it never claims more
+    // pages than it can produce. Only the local index pages.
+    const pages = state?.pageable === true ? Math.max(1, Math.ceil(total / PAGE)) : 1;
+    return (_jsxs("div", { style: S.root, children: [_jsxs("form", { style: S.bar, role: "search", onSubmit: event => { event.preventDefault(); run(0); }, children: [_jsxs("div", { style: S.field, children: [_jsx("label", { htmlFor: queryId, style: S.label, children: "Search evidence" }), _jsx("input", { id: queryId, style: S.input, type: "search", value: text, placeholder: "Words in a transcript, a title, a run\u2026", onChange: event => { setText(event.target.value); } })] }), _jsxs("div", { style: S.field, children: [_jsx("label", { htmlFor: kindId, style: S.label, children: "Type" }), _jsxs("select", { id: kindId, style: S.select, value: kind, onChange: event => { setKind(event.target.value); }, children: [_jsx("option", { value: "", children: "Any type" }), KINDS.map(value => _jsx("option", { value: value, children: value.replace('_', ' ') }, value))] })] }), _jsxs("div", { style: S.field, children: [_jsx("label", { htmlFor: verdictId, style: S.label, children: "Verification" }), _jsxs("select", { id: verdictId, style: S.select, value: verdict, disabled: reads !== undefined, onChange: event => { setVerdict(event.target.value); }, children: [_jsx("option", { value: "", children: "Any state" }), ['VERIFIED', 'FAILED', 'UNVERIFIED', 'INCONCLUSIVE'].map(value => (_jsx("option", { value: value, children: value }, value)))] })] }), _jsxs("div", { style: S.field, children: [_jsx("label", { htmlFor: sortId, style: S.label, children: "Sort" }), _jsxs("select", { id: sortId, style: S.select, value: sort, disabled: reads !== undefined, onChange: event => { setSort(event.target.value); }, children: [_jsx("option", { value: "relevance", children: "Relevance" }), _jsx("option", { value: "newest", children: "Newest first" }), _jsx("option", { value: "oldest", children: "Oldest first" }), _jsx("option", { value: "title", children: "Title" })] })] }), _jsx("button", { type: "submit", style: S.button, children: "Search" }), _jsx("button", { type: "button", style: S.button, disabled: refreshing, 
+                        // Rebuilding is safe precisely because the index is derived: it can
+                        // be thrown away and reconstructed from the records at any time.
+                        //
+                        // It says what it does in each mode rather than one word for two
+                        // actions. Locally it discards the index and builds it again. Against
+                        // a host it asks the host to read its roots again — a real operation
+                        // with a real answer, which is why the label is the same verb and the
+                        // subject is the Library rather than a local structure.
+                        onClick: refresh, children: refreshing
+                            ? 'Refreshing…'
+                            : (reads === undefined ? 'Rebuild index' : 'Refresh library') })] }), _jsxs("p", { style: { ...S.status, color: health.tone }, children: [health.says, ' ', _jsx("span", { style: { color: 'var(--dsw-alias-label-tertiary)' }, children: reads === undefined
+                            ? `${String(index.size)} record(s) indexed on this machine.`
+                            : 'Answered by this workspace’s own host.' })] }), _jsx("p", { style: S.status, role: "status", "aria-live": "polite", children: total === 0
+                    ? (terms.length === 0 ? 'No records to list.' : `No matches for “${text}”.`)
+                    : `${String(total)} match${total === 1 ? '' : 'es'}, showing ${String(shown)} (page ${String(page)} of ${String(pages)}).` }), refreshing
+                ? (_jsx("p", { style: S.status, role: "status", "aria-live": "polite", children: "Reading the library again. The results below are the previous index until it finishes." }))
+                : null, refreshed === null || refreshing
+                ? null
+                : (_jsxs("p", { style: {
+                        ...S.status,
+                        color: refreshed.failed ? 'var(--watch-tone-error)' : 'var(--dsw-alias-label-tertiary)',
+                    }, role: "status", "aria-live": "polite", children: [refreshed.refreshed
+                            ? `Library refreshed: ${String(refreshed.recordCount)} record(s), `
+                                + `generation ${String(refreshed.generation)}.`
+                            : refreshed.note, refreshed.refreshed && refreshed.note !== '' ? ` ${refreshed.note}` : ''] })), (state?.notes ?? []).map(note => (_jsx("p", { style: S.status, children: note }, note))), total === 0
+                ? (_jsx("div", { style: { ...S.hit, borderStyle: 'dashed' }, children: _jsx("p", { style: { ...S.snippet, margin: 0 }, children: reads === undefined && index.size === 0
+                            ? 'Nothing has been indexed yet. Evidence appears here once the workspace has recorded some — then this searches it locally, with no service and no model.'
+                            : 'Nothing matched. Every word has to appear in a record; try fewer words, or clear the filters.' }) }))
+                : (_jsx("ul", { style: S.list, children: rows.map(entry => (_jsxs("li", { style: S.hit, children: [_jsx("h4", { style: S.title, children: _jsx(Highlighted, { text: entry.title, terms: terms }) }), entry.snippets.map((snippet, at) => (_jsx("p", { style: S.snippet, children: _jsx(Highlighted, { text: snippet, terms: terms }) }, `${entry.key}-${String(at)}`))), _jsxs("div", { style: S.meta, children: [_jsx("span", { children: entry.kind }), _jsx("span", { "data-watch-ltr": true, children: entry.recordId }), entry.evidenceCount > 0
+                                        ? (_jsx("span", { "data-watch-ltr": true, children: `${String(entry.evidenceCount)} evidence ref(s)` }))
+                                        : null] })] }, entry.key))) })), pages > 1
+                ? (_jsxs("nav", { style: { display: 'flex', gap: '8px' }, "aria-label": "Search results pages", children: [_jsx("button", { type: "button", style: S.button, disabled: offset === 0, onClick: () => { run(Math.max(0, offset - PAGE)); }, children: "Previous" }), _jsx("button", { type: "button", style: S.button, disabled: offset + PAGE >= total, onClick: () => { run(Math.min(offset + PAGE, Math.max(0, total - 1))); }, children: "Next" })] }))
+                : null] }));
+}
+export { MAX_LIMIT };
+//# sourceMappingURL=search-view.js.map