@aceshooting/lyra-ui 3.9.0 → 4.1.0

package/dist/components/result-card/result-card.styles.js

@@ -6,18 +6,18 @@ export const styles = css `
   [part='base'] {
     display: flex;
     flex-direction: column;
-    border: var(--lyra-border-width-thin) solid var(--lyra-color-border);
-    border-radius: var(--lyra-radius);
-    background: var(--lyra-color-surface);
+    border: var(--lr-border-width-thin) solid var(--lr-color-border);
+    border-radius: var(--lr-radius);
+    background: var(--lr-color-surface);
     overflow: hidden;
-    font-size: var(--lyra-font-size-sm);
+    font-size: var(--lr-font-size-sm);
   }
   [part='header'] {
     display: flex;
     align-items: center;
-    gap: var(--lyra-space-s);
-    padding: var(--lyra-space-xs) var(--lyra-space-s);
-    border-block-end: var(--lyra-border-width-thin) solid var(--lyra-color-border);
+    gap: var(--lr-space-s);
+    padding: var(--lr-space-xs) var(--lr-space-s);
+    border-block-end: var(--lr-border-width-thin) solid var(--lr-color-border);
   }
   [part='header'][hidden] {
     display: none;
@@ -25,8 +25,8 @@ export const styles = css `
   [part='title'] {
     flex: 1 1 auto;
     min-inline-size: 0;
-    color: var(--lyra-color-text);
-    font-weight: var(--lyra-font-weight-semibold);
+    color: var(--lr-color-text);
+    font-weight: var(--lr-font-weight-semibold);
     overflow: hidden;
     text-overflow: ellipsis;
     white-space: nowrap;
@@ -34,7 +34,7 @@ export const styles = css `
   [part='actions'] {
     display: flex;
     align-items: center;
-    gap: var(--lyra-space-xs);
+    gap: var(--lr-space-xs);
     flex: 0 0 auto;
   }
   [part='actions'][hidden] {
@@ -43,8 +43,8 @@ export const styles = css `
   [part='body'] {
     display: flex;
     flex-direction: column;
-    gap: var(--lyra-space-xs);
-    padding: var(--lyra-space-s);
+    gap: var(--lr-space-xs);
+    padding: var(--lr-space-s);
   }
 `;
 //# sourceMappingURL=result-card.styles.js.map

package/dist/components/result-card/result-field.class.d.ts

@@ -1,14 +1,14 @@
 import { type TemplateResult } from 'lit';
 import { LyraElement } from '../../internal/lyra-element.js';
 /**
- * `<lyra-result-field>` — a single label/value row, meant for use inside a
- * `<lyra-result-card>` body (though it works standalone too). Renders as a
+ * `<lr-result-field>` — a single label/value row, meant for use inside a
+ * `<lr-result-card>` body (though it works standalone too). Renders as a
  * dense "label: value" line by default — e.g. "Status: 200 OK" or
  * "Duration: 340ms" — matching the compact, small-card presentation this
  * pair exists for.
  *
- * @customElement lyra-result-field
- * @slot - Rich value content (e.g. a `<lyra-chip>` status badge, or a plain
+ * @customElement lr-result-field
+ * @slot - Rich value content (e.g. a `<lr-chip>` status badge, or a plain
  * text override), taking precedence over the `value` prop whenever it has
  * any assigned content.
  * @csspart base - The row container.
@@ -31,7 +31,7 @@ export declare class LyraResultField extends LyraElement {
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'lyra-result-field': LyraResultField;
+        'lr-result-field': LyraResultField;
     }
 }
 //# sourceMappingURL=result-field.class.d.ts.map

package/dist/components/result-card/result-field.class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result-field.class.d.ts","sourceRoot":"","sources":["../../../src/components/result-card/result-field.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAI7D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,MAAM,CAAC,MAAM,iCAAgC;IAE7C,kFAAkF;IACtE,KAAK,SAAM;IAEvB;8CAC0C;IAC9B,KAAK,SAAM;IAEd,OAAO,CAAC,YAAY,CAAS;IAEtC,SAAS,CAAC,UAAU,IAAI,IAAI,CAI3B;IAED,YAAY,IAAI,IAAI,CAOnB;IAED,OAAO,CAAC,YAAY,CAElB;IAEF,MAAM,IAAI,cAAc,CAUvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,mBAAmB,EAAE,eAAe,CAAC;KACtC;CACF"}
+{"version":3,"file":"result-field.class.d.ts","sourceRoot":"","sources":["../../../src/components/result-card/result-field.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAI7D;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,MAAM,CAAC,MAAM,iCAAgC;IAE7C,kFAAkF;IACtE,KAAK,SAAM;IAEvB;8CAC0C;IAC9B,KAAK,SAAM;IAEd,OAAO,CAAC,YAAY,CAAS;IAEtC,SAAS,CAAC,UAAU,IAAI,IAAI,CAI3B;IAED,YAAY,IAAI,IAAI,CAOnB;IAED,OAAO,CAAC,YAAY,CAElB;IAEF,MAAM,IAAI,cAAc,CAUvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,iBAAiB,EAAE,eAAe,CAAC;KACpC;CACF"}

package/dist/components/result-card/result-field.class.js

@@ -10,14 +10,14 @@ import { LyraElement } from '../../internal/lyra-element.js';
 import { hasRealContent } from '../../internal/a11y.js';
 import { styles } from './result-field.styles.js';
 /**
- * `<lyra-result-field>` — a single label/value row, meant for use inside a
- * `<lyra-result-card>` body (though it works standalone too). Renders as a
+ * `<lr-result-field>` — a single label/value row, meant for use inside a
+ * `<lr-result-card>` body (though it works standalone too). Renders as a
  * dense "label: value" line by default — e.g. "Status: 200 OK" or
  * "Duration: 340ms" — matching the compact, small-card presentation this
  * pair exists for.
  *
- * @customElement lyra-result-field
- * @slot - Rich value content (e.g. a `<lyra-chip>` status badge, or a plain
+ * @customElement lr-result-field
+ * @slot - Rich value content (e.g. a `<lr-chip>` status badge, or a plain
  * text override), taking precedence over the `value` prop whenever it has
  * any assigned content.
  * @csspart base - The row container.
@@ -46,8 +46,8 @@ export class LyraResultField extends LyraElement {
     }
     firstUpdated() {
         // Fallback reconciliation against the fully-resolved slot assignment,
-        // the same belt-and-suspenders pass lyra-source-card's hasFullSlot and
-        // lyra-empty's hasIcon/hasActions take -- a no-op in the common case
+        // the same belt-and-suspenders pass lr-source-card's hasFullSlot and
+        // lr-empty's hasIcon/hasActions take -- a no-op in the common case
         // since willUpdate already seeded the correct value above.
         const slot = this.shadowRoot.querySelector('slot');
         this.hasValueSlot = hasRealContent(slot.assignedNodes({ flatten: true }));

package/dist/components/result-card/result-field.class.js.map

@@ -1 +1 @@
-{"version":3,"file":"result-field.class.js","sourceRoot":"","sources":["../../../src/components/result-card/result-field.class.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAuB,MAAM,KAAK,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAAhD;;QAGE,kFAAkF;QACtE,UAAK,GAAG,EAAE,CAAC;QAEvB;kDAC0C;QAC9B,UAAK,GAAG,EAAE,CAAC;QAEN,iBAAY,GAAG,KAAK,CAAC;QAiB9B,iBAAY,GAAG,CAAC,CAAQ,EAAQ,EAAE;YACxC,IAAI,CAAC,YAAY,GAAG,cAAc,CAAE,CAAC,CAAC,MAA0B,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACrG,CAAC,CAAC;IAaJ,CAAC;aAzCQ,WAAM,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,AAA/B,CAAgC;IAWnC,UAAU;QAClB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED,YAAY;QACV,sEAAsE;QACtE,uEAAuE;QACvE,qEAAqE;QACrE,2DAA2D;QAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,UAAW,CAAC,aAAa,CAAC,MAAM,CAAoB,CAAC;QACvE,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAMD,MAAM;QACJ,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACvC,OAAO,IAAI,CAAA;;UAEL,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAA,sBAAsB,IAAI,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO;;aAEhE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,qBAAqB,IAAI,CAAC,YAAY;;;KAGtF,CAAC;IACJ,CAAC;CACF;AAtCa;IAAX,QAAQ,EAAE;8CAAY;AAIX;IAAX,QAAQ,EAAE;8CAAY;AAEN;IAAhB,KAAK,EAAE;qDAA8B"}
+{"version":3,"file":"result-field.class.js","sourceRoot":"","sources":["../../../src/components/result-card/result-field.class.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAuB,MAAM,KAAK,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAAhD;;QAGE,kFAAkF;QACtE,UAAK,GAAG,EAAE,CAAC;QAEvB;kDAC0C;QAC9B,UAAK,GAAG,EAAE,CAAC;QAEN,iBAAY,GAAG,KAAK,CAAC;QAiB9B,iBAAY,GAAG,CAAC,CAAQ,EAAQ,EAAE;YACxC,IAAI,CAAC,YAAY,GAAG,cAAc,CAAE,CAAC,CAAC,MAA0B,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACrG,CAAC,CAAC;IAaJ,CAAC;aAzCQ,WAAM,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,AAA/B,CAAgC;IAWnC,UAAU;QAClB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED,YAAY;QACV,sEAAsE;QACtE,qEAAqE;QACrE,mEAAmE;QACnE,2DAA2D;QAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,UAAW,CAAC,aAAa,CAAC,MAAM,CAAoB,CAAC;QACvE,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC5E,CAAC;IAMD,MAAM;QACJ,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;QACvC,OAAO,IAAI,CAAA;;UAEL,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAA,sBAAsB,IAAI,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO;;aAEhE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,qBAAqB,IAAI,CAAC,YAAY;;;KAGtF,CAAC;IACJ,CAAC;CACF;AAtCa;IAAX,QAAQ,EAAE;8CAAY;AAIX;IAAX,QAAQ,EAAE;8CAAY;AAEN;IAAhB,KAAK,EAAE;qDAA8B"}

package/dist/components/result-card/result-field.styles.js

@@ -12,18 +12,18 @@ export const styles = css `
     display: flex;
     align-items: baseline;
     flex-wrap: wrap;
-    column-gap: var(--lyra-space-xs);
-    font-size: var(--lyra-font-size-sm);
-    line-height: var(--lyra-line-height-1-4);
+    column-gap: var(--lr-space-xs);
+    font-size: var(--lr-font-size-sm);
+    line-height: var(--lr-line-height-1-4);
   }
   [part='label'] {
     flex: 0 0 auto;
-    color: var(--lyra-color-text-quiet);
+    color: var(--lr-color-text-quiet);
   }
   [part='value'] {
     flex: 1 1 auto;
     min-inline-size: 0;
-    color: var(--lyra-color-text);
+    color: var(--lr-color-text);
     overflow-wrap: anywhere;
   }
   [part='value'] ::slotted(*) {

package/dist/components/retrieval-results/retrieval-results.class.d.ts

@@ -0,0 +1,151 @@
+import { type TemplateResult } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import type { RetrievalChunk } from '../../ai/types.js';
+import '../virtual-list/virtual-list.js';
+import '../chunk-inspector/chunk-inspector.js';
+import '../checkbox/checkbox.js';
+import '../spinner/spinner.js';
+import '../empty/empty.js';
+/** `lr-select`'s detail: the complete updated selection, both as bare ids and as the (deduplicated)
+ *  `RetrievalChunk` records they refer to -- a host wanting "what got selected" rarely wants to
+ *  re-look up `ids` against its own copy of `chunks` on every toggle. */
+export interface RetrievalResultsSelectDetail {
+    ids: string[];
+    chunks: RetrievalChunk[];
+}
+export interface LyraRetrievalResultsEventMap {
+    'lr-select': CustomEvent<RetrievalResultsSelectDetail>;
+    'lr-load-more': CustomEvent<undefined>;
+    'lr-chunk-open': CustomEvent<{
+        id: string;
+        sourceId: string;
+    }>;
+}
+/**
+ * `<lr-retrieval-results>` — the orchestration-level ranked-chunk-list surface: takes raw
+ * `RetrievalChunk[]` (the shared retrieval-and-grounding type from `src/ai/types.ts`) and adds
+ * everything a single retrieval call's result set needs beyond what one chunk's own rendering
+ * provides -- deduplication, optional grouping by source, multi-selection, pagination/infinite
+ * loading, and a compact/expanded presentation switch -- while composing existing primitives for
+ * every part that already has one, never re-implementing chunk/score/source rendering itself.
+ *
+ * **Composition, not reinvention.** Each rendered row wraps exactly one chunk in an internal
+ * `<lr-chunk-inspector>` (fed a single-element `chunks` array), reusing its score bar/tier
+ * coloring, title+page rendering, expandable text, and `compact` mode verbatim -- this component
+ * never hand-rolls chunk-card markup. `metadata` (arbitrary `Record<string, unknown>`, which no
+ * existing primitive renders) is the one genuinely new bit of presentation here, shown as a plain
+ * key/value list in `expanded` presentation only. Large result sets are windowed through an
+ * internal `<lr-virtual-list>`, exactly like `<lr-thread-list>`'s own data-mode rendering -- each
+ * row's rendered content therefore lives inside `<lr-virtual-list>`'s own shadow root, not this
+ * component's, whenever virtualization is active (see that component's own doc for why).
+ *
+ * **Controlled component.** `chunks`/`selectedIds`/`loading`/`error`/`hasMore` are all host-owned;
+ * this component never fetches, retries, or mutates its own copy of `chunks`. Selecting a row
+ * updates `selectedIds` locally *then* emits `lr-select` (the same "update own copy, then emit;
+ * reassign to control" convention `<lr-source-picker>` already uses) so a host can either accept
+ * the update as-is or override it before the next render.
+ *
+ * **Deduplication** keeps, per duplicate `id`, whichever chunk has the higher `score` -- set
+ * `dedupe="false"` to see every raw entry `chunks` contains, duplicates included. **Grouping**
+ * (`grouping="source"`) buckets the deduplicated, score-sorted list by `source.id`, each bucket
+ * ordered by its own best-scoring chunk first, and always renders through the internal
+ * `<lr-virtual-list>` (regardless of `virtualize-at`) so group headers have a single rendering path
+ * — `<lr-thread-list>`'s own date-bucket grouping takes the identical approach.
+ *
+ * **Pagination.** While virtualized, `has-more`/`loading` are forwarded straight to the internal
+ * `<lr-virtual-list>`, which fires `lr-load-more` itself on scroll-near-bottom (re-emitted here
+ * unchanged). Below the virtualization threshold (a short, non-grouped list), scrolling near the
+ * bottom isn't a meaningful gesture, so a `[part="load-more"]` button takes its place instead,
+ * showing a spinner in place of the button while `loading` is true.
+ *
+ * @customElement lr-retrieval-results
+ * @event lr-select - The selected-chunk set changed. `detail: { ids, chunks }` — `ids` is the
+ * complete updated selection (not just the toggled id), `chunks` the matching deduplicated
+ * `RetrievalChunk` records.
+ * @event lr-load-more - More results were requested — via the internal `<lr-virtual-list>`'s own
+ * scroll-near-bottom detection while virtualized, or the built-in `[part="load-more"]` button
+ * otherwise. Only ever fires while `has-more` is true and `loading` is false.
+ * @event lr-chunk-open - A row's title/open button was activated, forwarded verbatim from the
+ * per-row `<lr-chunk-inspector>`'s own `lr-chunk-open`. `detail: { id, sourceId }` — the event a
+ * host routes into `<lr-document-viewer>`.
+ * @csspart base - The outer container.
+ * @csspart error - The error message region (`role="alert"`), shown while `error` is non-empty.
+ * @csspart spinner - The initial-load `<lr-spinner>`, shown while `loading` is true and `chunks`
+ * is still empty.
+ * @csspart empty - The `<lr-empty>` wrapper, shown when `chunks` is empty and neither `error` nor
+ * `loading` is set.
+ * @csspart row - One result row's wrapper. Below the virtualization threshold this is a plain,
+ * directly-styleable element in this component's own shadow root; while virtualized it is exported
+ * from the internal `<lr-virtual-list>`'s own `row` part instead (`::part(row)` still reaches it
+ * either way).
+ * @csspart group-header - Exported from the internal `<lr-virtual-list>`'s `group` part —
+ * grouped/virtualized mode only.
+ * @csspart select - The per-row `<lr-checkbox>`, omitted entirely when `selectable` is false.
+ * @csspart row-body - The wrapper around a row's `<lr-chunk-inspector>` plus its optional
+ * metadata list; carries `data-selected` while that row is selected.
+ * @csspart metadata - The `<dl>` of a chunk's `metadata` entries — omitted entirely when a chunk
+ * has no `metadata`, or while `presentation="compact"`.
+ * @csspart metadata-entry - One metadata key/value pair's wrapper.
+ * @csspart load-more-row - The wrapper around the non-virtualized-mode pagination footer.
+ * @csspart load-more - The "Load more" button itself (non-virtualized mode, `loading` false).
+ */
+export declare class LyraRetrievalResults extends LyraElement<LyraRetrievalResultsEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    /** The raw (not deduplicated/sorted/grouped) result set. Host-owned. */
+    chunks: RetrievalChunk[];
+    /** Controlled selection, by chunk `id`. The component updates its own copy on toggle *then*
+     *  emits `lr-select`; reassign to control. An id with no matching chunk is harmless -- it simply
+     *  never renders a checked row. */
+    selectedIds: string[];
+    /** Shows a per-row `<lr-checkbox>`. */
+    selectable: boolean;
+    /** Drops duplicate `id`s before rendering, keeping whichever duplicate has the higher `score`. */
+    dedupe: boolean;
+    /** `'score'` (default) sorts the deduplicated list descending by `score`; `'none'` preserves
+     *  `chunks`' own given order. */
+    sort: 'score' | 'none';
+    /** `'source'` buckets rows under a header per `source.id` (always rendered through the internal
+     *  `<lr-virtual-list>`, regardless of `virtualize-at`); `'none'` (default) is a flat ranked list. */
+    grouping: 'source' | 'none';
+    /** `'expanded'` (default) shows each chunk's full `<lr-chunk-inspector>` row (score bar, text
+     *  preview with its own expand toggle) plus any `metadata`; `'compact'` shows title + score bar
+     *  only, on both. */
+    presentation: 'compact' | 'expanded';
+    /** Forwarded verbatim to every per-row `<lr-chunk-inspector>`'s own `thresholds`. */
+    thresholds: {
+        high: number;
+        medium: number;
+    };
+    /** Above this many rows (after dedup, before grouping), rendering switches from a plain list to
+     *  the internal `<lr-virtual-list>`. Grouped mode always virtualizes regardless of this value. */
+    virtualizeAt: number;
+    /** Marks the chunk currently open in a viewer -- forwarded to each per-row `<lr-chunk-inspector>`
+     *  and to the internal `<lr-virtual-list>` (which scrolls the matching row into view). */
+    activeId: string;
+    loading: boolean;
+    /** While virtualized, forwarded to the internal `<lr-virtual-list>` so scrolling near the bottom
+     *  fires `lr-load-more`; otherwise shows the built-in `[part="load-more"]` footer. */
+    hasMore: boolean;
+    /** Non-empty replaces the entire result view with a `role="alert"` error message -- caller-
+     *  supplied text, not routed through `localize()` (the same stance `<lr-document-preview>`'s own
+     *  `error-message` takes for the same reason: this is app/network data, not library copy). */
+    error: string;
+    /** Accessible name for the results region. Defaults to the localized `chunkInspectorLabel`
+     *  ("Retrieved chunks") -- reused rather than a new key, since it already says exactly what this
+     *  region is. */
+    label: string;
+    private get effectiveVirtualizeAt();
+    private get dedupedChunks();
+    private get processedChunks();
+    private toggleSelect;
+    private renderMetadata;
+    private renderRow;
+    private renderLoadMoreFooter;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lr-retrieval-results': LyraRetrievalResults;
+    }
+}
+//# sourceMappingURL=retrieval-results.class.d.ts.map

package/dist/components/retrieval-results/retrieval-results.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieval-results.class.d.ts","sourceRoot":"","sources":["../../../src/components/retrieval-results/retrieval-results.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,iCAAiC,CAAC;AACzC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,yBAAyB,CAAC;AACjC,OAAO,uBAAuB,CAAC;AAC/B,OAAO,mBAAmB,CAAC;AAG3B;;yEAEyE;AACzE,MAAM,WAAW,4BAA4B;IAC3C,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,WAAW,CAAC,4BAA4B,CAAC,CAAC;IACvD,cAAc,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC;IACvC,eAAe,EAAE,WAAW,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChE;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,qBAAa,oBAAqB,SAAQ,WAAW,CAAC,4BAA4B,CAAC;IACjF,MAAM,CAAC,MAAM,iCAAgC;IAE7C,wEAAwE;IACxC,MAAM,EAAE,cAAc,EAAE,CAAM;IAE9D;;uCAEmC;IACH,WAAW,EAAE,MAAM,EAAE,CAAM;IAE3D,uCAAuC;IACK,UAAU,UAAQ;IAE9D,kGAAkG;IACtD,MAAM,UAAQ;IAE1D;qCACiC;IACrB,IAAI,EAAE,OAAO,GAAG,MAAM,CAAW;IAE7C;yGACqG;IACzF,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAU;IAEjD;;yBAEqB;IACT,YAAY,EAAE,SAAS,GAAG,UAAU,CAAc;IAE9D,qFAAqF;IACrD,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAA+B;IAE3G;sGACkG;IAC1C,YAAY,SAAM;IAE1E;8FAC0F;IACpD,QAAQ,SAAM;IAER,OAAO,UAAS;IAE5D;0FACsF;IACnB,OAAO,UAAS;IAEnF;;kGAE8F;IAClF,KAAK,SAAM;IAEvB;;qBAEiB;IACL,KAAK,SAAM;IAEvB,OAAO,KAAK,qBAAqB,GAEhC;IAED,OAAO,KAAK,aAAa,GAQxB;IAED,OAAO,KAAK,eAAe,GAuB1B;IAED,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,cAAc;IAkBtB,OAAO,CAAC,SAAS,CAyBf;IAEF,OAAO,CAAC,oBAAoB;IAa5B,MAAM,IAAI,cAAc,CAwCvB;CACF;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,sBAAsB,EAAE,oBAAoB,CAAC;KAC9C;CACF"}

package/dist/components/retrieval-results/retrieval-results.class.js

@@ -0,0 +1,340 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html, nothing } from 'lit';
+import { property } from 'lit/decorators.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { finiteCount } from '../../internal/numbers.js';
+import '../virtual-list/virtual-list.js';
+import '../chunk-inspector/chunk-inspector.js';
+import '../checkbox/checkbox.js';
+import '../spinner/spinner.js';
+import '../empty/empty.js';
+import { styles } from './retrieval-results.styles.js';
+/** `RetrievalChunk` -> `lr-chunk-inspector`'s own `LyraChunk` display-row shape, per the mapping
+ *  `RetrievalChunk`'s own doc comment (`src/ai/types.ts`) already specifies: `source.id -> sourceId`,
+ *  `source.name -> title`. No `page`/`anchor` -- `RetrievalChunk`/`DocumentRef` carry neither, so
+ *  those fields are simply left unset rather than guessed at from `metadata`. */
+function toLyraChunk(chunk) {
+    return {
+        id: chunk.id,
+        text: chunk.text,
+        score: chunk.score,
+        sourceId: chunk.source.id,
+        title: chunk.source.name,
+    };
+}
+function formatMetadataValue(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+/**
+ * `<lr-retrieval-results>` — the orchestration-level ranked-chunk-list surface: takes raw
+ * `RetrievalChunk[]` (the shared retrieval-and-grounding type from `src/ai/types.ts`) and adds
+ * everything a single retrieval call's result set needs beyond what one chunk's own rendering
+ * provides -- deduplication, optional grouping by source, multi-selection, pagination/infinite
+ * loading, and a compact/expanded presentation switch -- while composing existing primitives for
+ * every part that already has one, never re-implementing chunk/score/source rendering itself.
+ *
+ * **Composition, not reinvention.** Each rendered row wraps exactly one chunk in an internal
+ * `<lr-chunk-inspector>` (fed a single-element `chunks` array), reusing its score bar/tier
+ * coloring, title+page rendering, expandable text, and `compact` mode verbatim -- this component
+ * never hand-rolls chunk-card markup. `metadata` (arbitrary `Record<string, unknown>`, which no
+ * existing primitive renders) is the one genuinely new bit of presentation here, shown as a plain
+ * key/value list in `expanded` presentation only. Large result sets are windowed through an
+ * internal `<lr-virtual-list>`, exactly like `<lr-thread-list>`'s own data-mode rendering -- each
+ * row's rendered content therefore lives inside `<lr-virtual-list>`'s own shadow root, not this
+ * component's, whenever virtualization is active (see that component's own doc for why).
+ *
+ * **Controlled component.** `chunks`/`selectedIds`/`loading`/`error`/`hasMore` are all host-owned;
+ * this component never fetches, retries, or mutates its own copy of `chunks`. Selecting a row
+ * updates `selectedIds` locally *then* emits `lr-select` (the same "update own copy, then emit;
+ * reassign to control" convention `<lr-source-picker>` already uses) so a host can either accept
+ * the update as-is or override it before the next render.
+ *
+ * **Deduplication** keeps, per duplicate `id`, whichever chunk has the higher `score` -- set
+ * `dedupe="false"` to see every raw entry `chunks` contains, duplicates included. **Grouping**
+ * (`grouping="source"`) buckets the deduplicated, score-sorted list by `source.id`, each bucket
+ * ordered by its own best-scoring chunk first, and always renders through the internal
+ * `<lr-virtual-list>` (regardless of `virtualize-at`) so group headers have a single rendering path
+ * — `<lr-thread-list>`'s own date-bucket grouping takes the identical approach.
+ *
+ * **Pagination.** While virtualized, `has-more`/`loading` are forwarded straight to the internal
+ * `<lr-virtual-list>`, which fires `lr-load-more` itself on scroll-near-bottom (re-emitted here
+ * unchanged). Below the virtualization threshold (a short, non-grouped list), scrolling near the
+ * bottom isn't a meaningful gesture, so a `[part="load-more"]` button takes its place instead,
+ * showing a spinner in place of the button while `loading` is true.
+ *
+ * @customElement lr-retrieval-results
+ * @event lr-select - The selected-chunk set changed. `detail: { ids, chunks }` — `ids` is the
+ * complete updated selection (not just the toggled id), `chunks` the matching deduplicated
+ * `RetrievalChunk` records.
+ * @event lr-load-more - More results were requested — via the internal `<lr-virtual-list>`'s own
+ * scroll-near-bottom detection while virtualized, or the built-in `[part="load-more"]` button
+ * otherwise. Only ever fires while `has-more` is true and `loading` is false.
+ * @event lr-chunk-open - A row's title/open button was activated, forwarded verbatim from the
+ * per-row `<lr-chunk-inspector>`'s own `lr-chunk-open`. `detail: { id, sourceId }` — the event a
+ * host routes into `<lr-document-viewer>`.
+ * @csspart base - The outer container.
+ * @csspart error - The error message region (`role="alert"`), shown while `error` is non-empty.
+ * @csspart spinner - The initial-load `<lr-spinner>`, shown while `loading` is true and `chunks`
+ * is still empty.
+ * @csspart empty - The `<lr-empty>` wrapper, shown when `chunks` is empty and neither `error` nor
+ * `loading` is set.
+ * @csspart row - One result row's wrapper. Below the virtualization threshold this is a plain,
+ * directly-styleable element in this component's own shadow root; while virtualized it is exported
+ * from the internal `<lr-virtual-list>`'s own `row` part instead (`::part(row)` still reaches it
+ * either way).
+ * @csspart group-header - Exported from the internal `<lr-virtual-list>`'s `group` part —
+ * grouped/virtualized mode only.
+ * @csspart select - The per-row `<lr-checkbox>`, omitted entirely when `selectable` is false.
+ * @csspart row-body - The wrapper around a row's `<lr-chunk-inspector>` plus its optional
+ * metadata list; carries `data-selected` while that row is selected.
+ * @csspart metadata - The `<dl>` of a chunk's `metadata` entries — omitted entirely when a chunk
+ * has no `metadata`, or while `presentation="compact"`.
+ * @csspart metadata-entry - One metadata key/value pair's wrapper.
+ * @csspart load-more-row - The wrapper around the non-virtualized-mode pagination footer.
+ * @csspart load-more - The "Load more" button itself (non-virtualized mode, `loading` false).
+ */
+export class LyraRetrievalResults extends LyraElement {
+    constructor() {
+        super(...arguments);
+        /** The raw (not deduplicated/sorted/grouped) result set. Host-owned. */
+        this.chunks = [];
+        /** Controlled selection, by chunk `id`. The component updates its own copy on toggle *then*
+         *  emits `lr-select`; reassign to control. An id with no matching chunk is harmless -- it simply
+         *  never renders a checked row. */
+        this.selectedIds = [];
+        /** Shows a per-row `<lr-checkbox>`. */
+        this.selectable = true;
+        /** Drops duplicate `id`s before rendering, keeping whichever duplicate has the higher `score`. */
+        this.dedupe = true;
+        /** `'score'` (default) sorts the deduplicated list descending by `score`; `'none'` preserves
+         *  `chunks`' own given order. */
+        this.sort = 'score';
+        /** `'source'` buckets rows under a header per `source.id` (always rendered through the internal
+         *  `<lr-virtual-list>`, regardless of `virtualize-at`); `'none'` (default) is a flat ranked list. */
+        this.grouping = 'none';
+        /** `'expanded'` (default) shows each chunk's full `<lr-chunk-inspector>` row (score bar, text
+         *  preview with its own expand toggle) plus any `metadata`; `'compact'` shows title + score bar
+         *  only, on both. */
+        this.presentation = 'expanded';
+        /** Forwarded verbatim to every per-row `<lr-chunk-inspector>`'s own `thresholds`. */
+        this.thresholds = { high: 0.75, medium: 0.5 };
+        /** Above this many rows (after dedup, before grouping), rendering switches from a plain list to
+         *  the internal `<lr-virtual-list>`. Grouped mode always virtualizes regardless of this value. */
+        this.virtualizeAt = 50;
+        /** Marks the chunk currently open in a viewer -- forwarded to each per-row `<lr-chunk-inspector>`
+         *  and to the internal `<lr-virtual-list>` (which scrolls the matching row into view). */
+        this.activeId = '';
+        this.loading = false;
+        /** While virtualized, forwarded to the internal `<lr-virtual-list>` so scrolling near the bottom
+         *  fires `lr-load-more`; otherwise shows the built-in `[part="load-more"]` footer. */
+        this.hasMore = false;
+        /** Non-empty replaces the entire result view with a `role="alert"` error message -- caller-
+         *  supplied text, not routed through `localize()` (the same stance `<lr-document-preview>`'s own
+         *  `error-message` takes for the same reason: this is app/network data, not library copy). */
+        this.error = '';
+        /** Accessible name for the results region. Defaults to the localized `chunkInspectorLabel`
+         *  ("Retrieved chunks") -- reused rather than a new key, since it already says exactly what this
+         *  region is. */
+        this.label = '';
+        // Shared by both rendering paths (flat list and `<lr-virtual-list>`'s `renderItem`), exactly like
+        // `<lr-chunk-inspector>`'s own `renderChunk` and `<lr-thread-list>`'s own `renderRow`. Returns
+        // only the row's *content* (checkbox + body) -- the surrounding `role="listitem"`/`part="row"`
+        // wrapper is supplied by whichever caller renders it, since `<lr-virtual-list>` already supplies
+        // its own per-row wrapper when virtualized and a second, nested one would double up `part="row"`
+        // within the same shadow tree and duplicate `role="listitem"` semantics.
+        this.renderRow = (item) => {
+            const chunk = item;
+            const selected = this.selectedIds.includes(chunk.id);
+            const rowLabel = chunk.source.name || this.localize('untitledSource');
+            return html `
+      ${this.selectable
+                ? html `<lr-checkbox
+            part="select"
+            .checked=${selected}
+            aria-label="${this.localize('select')} ${rowLabel}"
+            @lr-change=${() => this.toggleSelect(chunk)}
+          ></lr-checkbox>`
+                : nothing}
+      <div part="row-body" ?data-selected=${selected}>
+        <lr-chunk-inspector
+          .chunks=${[toLyraChunk(chunk)]}
+          .thresholds=${this.thresholds}
+          ?compact=${this.presentation === 'compact'}
+          active-id=${this.activeId}
+          label=${rowLabel}
+          @lr-chunk-open=${(e) => this.emit('lr-chunk-open', e.detail)}
+        ></lr-chunk-inspector>
+        ${this.presentation === 'expanded' ? this.renderMetadata(chunk.metadata) : nothing}
+      </div>
+    `;
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    get effectiveVirtualizeAt() {
+        return finiteCount(this.virtualizeAt, 50);
+    }
+    get dedupedChunks() {
+        if (!this.dedupe)
+            return this.chunks;
+        const byId = new Map();
+        for (const chunk of this.chunks) {
+            const existing = byId.get(chunk.id);
+            if (!existing || chunk.score > existing.score)
+                byId.set(chunk.id, chunk);
+        }
+        return [...byId.values()];
+    }
+    get processedChunks() {
+        const deduped = this.dedupedChunks;
+        const sorted = this.sort === 'score' ? [...deduped].sort((a, b) => b.score - a.score) : deduped;
+        if (this.grouping !== 'source')
+            return { chunks: sorted, groups: [] };
+        const bySource = new Map();
+        const order = [];
+        for (const chunk of sorted) {
+            const key = chunk.source.id;
+            if (!bySource.has(key)) {
+                bySource.set(key, []);
+                order.push(key);
+            }
+            bySource.get(key).push(chunk);
+        }
+        const rows = [];
+        const groups = [];
+        for (const key of order) {
+            const groupChunks = bySource.get(key);
+            groups.push({ key, label: groupChunks[0].source.name || this.localize('untitledSource'), startIndex: rows.length });
+            rows.push(...groupChunks);
+        }
+        return { chunks: rows, groups };
+    }
+    toggleSelect(chunk) {
+        const next = new Set(this.selectedIds);
+        if (next.has(chunk.id))
+            next.delete(chunk.id);
+        else
+            next.add(chunk.id);
+        const ids = [...next];
+        this.selectedIds = ids;
+        const selectedChunks = this.dedupedChunks.filter((c) => next.has(c.id));
+        this.emit('lr-select', { ids, chunks: selectedChunks });
+    }
+    renderMetadata(metadata) {
+        const entries = metadata ? Object.entries(metadata) : [];
+        if (entries.length === 0)
+            return nothing;
+        return html `
+      <dl part="metadata">
+        ${entries.map(([key, value]) => html `<div part="metadata-entry"><dt>${key}</dt><dd>${formatMetadataValue(value)}</dd></div>`)}
+      </dl>
+    `;
+    }
+    renderLoadMoreFooter() {
+        if (!this.hasMore)
+            return nothing;
+        return html `
+      <div part="load-more-row">
+        ${this.loading
+            ? html `<lr-spinner part="spinner"></lr-spinner>`
+            : html `<button type="button" part="load-more" @click=${() => this.emit('lr-load-more')}>
+              ${this.localize('loadMore')}
+            </button>`}
+      </div>
+    `;
+    }
+    render() {
+        const label = this.label || this.localize('chunkInspectorLabel');
+        if (this.error) {
+            return html `<div part="base"><div part="error" role="alert">${this.error}</div></div>`;
+        }
+        const processed = this.processedChunks;
+        if (processed.chunks.length === 0) {
+            if (this.loading) {
+                return html `<div part="base"><lr-spinner part="spinner"></lr-spinner></div>`;
+            }
+            // `heading` is passed as slotted light-DOM content (rather than the `heading` attribute) so
+            // `[part="empty"]`'s `.textContent` -- a plain DOM accessor, which never pierces
+            // `<lr-empty>`'s own shadow root -- actually includes the message; the same reason
+            // `<lr-chunk-inspector>`'s own empty state takes this shape.
+            return html `<div part="base"><lr-empty part="empty"><span slot="heading">${this.localize('chunkInspectorEmpty')}</span></lr-empty></div>`;
+        }
+        const useVirtualList = this.grouping === 'source' || processed.chunks.length > this.effectiveVirtualizeAt;
+        return html `
+      <div part="base" role="group" aria-label=${label}>
+        ${useVirtualList
+            ? html `<lr-virtual-list
+              exportparts="row:row, group:group-header"
+              .items=${processed.chunks}
+              .renderItem=${this.renderRow}
+              .keyFunction=${(item) => item.id}
+              .groups=${processed.groups}
+              .activeId=${this.activeId || ''}
+              ?loading=${this.loading}
+              ?has-more=${this.hasMore}
+              @lr-load-more=${() => this.emit('lr-load-more')}
+            ></lr-virtual-list>`
+            : html `<div role="list">
+                ${processed.chunks.map((c) => html `<div part="row" role="listitem">${this.renderRow(c)}</div>`)}
+              </div>
+              ${this.renderLoadMoreFooter()}`}
+      </div>
+    `;
+    }
+}
+__decorate([
+    property({ attribute: false })
+], LyraRetrievalResults.prototype, "chunks", void 0);
+__decorate([
+    property({ attribute: false })
+], LyraRetrievalResults.prototype, "selectedIds", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraRetrievalResults.prototype, "selectable", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraRetrievalResults.prototype, "dedupe", void 0);
+__decorate([
+    property()
+], LyraRetrievalResults.prototype, "sort", void 0);
+__decorate([
+    property()
+], LyraRetrievalResults.prototype, "grouping", void 0);
+__decorate([
+    property()
+], LyraRetrievalResults.prototype, "presentation", void 0);
+__decorate([
+    property({ attribute: false })
+], LyraRetrievalResults.prototype, "thresholds", void 0);
+__decorate([
+    property({ type: Number, attribute: 'virtualize-at' })
+], LyraRetrievalResults.prototype, "virtualizeAt", void 0);
+__decorate([
+    property({ attribute: 'active-id' })
+], LyraRetrievalResults.prototype, "activeId", void 0);
+__decorate([
+    property({ type: Boolean, reflect: true })
+], LyraRetrievalResults.prototype, "loading", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'has-more', reflect: true })
+], LyraRetrievalResults.prototype, "hasMore", void 0);
+__decorate([
+    property()
+], LyraRetrievalResults.prototype, "error", void 0);
+__decorate([
+    property()
+], LyraRetrievalResults.prototype, "label", void 0);
+//# sourceMappingURL=retrieval-results.class.js.map