onadit 0.0.1 → 1.0.0

package/dist/src/retrieval/compact.d.ts

@@ -0,0 +1,306 @@
+import type { TableName } from "../storage/tables.js";
+import type { RankedResult } from "./reranker.js";
+export declare const SNIPPET_MAX = 400;
+export declare const SUMMARY_MAX = 800;
+export declare const TITLE_MAX = 120;
+/**
+ * Token threshold above which `renderCompactMarkdown` annotates a hit with a
+ * compact `~Nk tokens` warning. The point is to make the agent see the size
+ * before it commits to a `detail=full` expansion that would blow context.
+ */
+export declare const LARGE_HIT_TOKEN_THRESHOLD = 10000;
+/**
+ * Middle-detail excerpt caps (characters, matching SNIPPET_MAX / SUMMARY_MAX).
+ * Targets ~2k–4k tokens total for an evidence-focused view that sits between
+ * `summary` (≤800 chars) and `full` (entire row content):
+ *
+ * - rows at or below MIDDLE_INLINE_THRESHOLD_CHARS get the full content inline
+ *   (the excerpt would be the same content with no truncation, so skip the
+ *   elision overhead);
+ * - larger rows get the first MIDDLE_HEAD_CHARS + last MIDDLE_TAIL_CHARS with
+ *   a single elision marker between, preserving the bookends most useful for
+ *   fact-checking (initial question, final answer/decision) while bounding
+ *   cost.
+ *
+ * Char-based bounds are an intentional approximation: for typical mixed text,
+ * 1 token ≈ 4 chars, so 8000 head + 4000 tail ≈ 3000 tokens.
+ */
+export declare const MIDDLE_HEAD_CHARS = 8000;
+export declare const MIDDLE_TAIL_CHARS = 4000;
+export declare const MIDDLE_INLINE_THRESHOLD_CHARS = 12000;
+/**
+ * Neighbor chunks to include on each side of the matched chunk for a
+ * `detail="middle"` expand of a chunked source. The window is `[i-K, i+K]`
+ * clamped to the set, so K=1 yields up to 3 contiguous chunks (~5k chars /
+ * ~1.4k tokens at the default 1800-char target) — enough surrounding context to
+ * read the matched section in place without re-dumping the whole conversation.
+ */
+export declare const MIDDLE_CHUNK_NEIGHBORS = 1;
+export type Tier = "hot" | "cold" | "digest" | "document" | "structured_doc";
+export interface CompactExpand {
+    route: string;
+    params: Record<string, unknown>;
+}
+export interface CompactHit {
+    id: string;
+    source: string;
+    title: string;
+    score: number;
+    retrieval_method: string;
+    timestamp: string;
+    tier: Tier;
+    snippet: string;
+    /** UTF-16 positions in the returned stored body, end exclusive. */
+    passage_start?: number;
+    passage_end?: number;
+    /** Authoritative terms used for passage matching, native-reader opt-in only. */
+    match_terms?: string[];
+    summary: string;
+    /**
+     * Exact UTF-8 byte length of the row's full content. Always populated, so
+     * callers can sort or filter by size before requesting `detail="full"`.
+     */
+    content_bytes: number;
+    /**
+     * Rough token count for the row's full content (~bytes/4). Heuristic, not a
+     * model-accurate count — meant for "will this fit in my context" decisions.
+     */
+    content_tokens_estimate: number;
+    expand: CompactExpand;
+    /**
+     * Row content, present when the caller asked for detail="full" or
+     * detail="middle". For middle, this is a bounded excerpt (head + elision
+     * marker + tail) when the row is larger than MIDDLE_INLINE_THRESHOLD_CHARS,
+     * or the full content inline when the row fits under that threshold.
+     * `content_bytes` always reflects the *original* row size, so the agent
+     * can tell whether middle content was truncated.
+     */
+    content?: string;
+    /**
+     * True when `content` is a bounded excerpt rather than the full row body
+     * (i.e., middle-detail hit large enough to require head+tail truncation).
+     * Absent otherwise — agents that care about completeness check this flag
+     * before treating `content` as authoritative.
+     */
+    content_truncated?: boolean;
+    /**
+     * When this hit represents a chunked source (long doc/conversation), the
+     * total number of chunk rows that matched and were collapsed into this one
+     * representative. Present (> 1) only for grouped chunk hits; absent for
+     * ordinary single-row hits. Lets the UI say "+N more sections".
+     */
+    matched_sections?: number;
+    /**
+     * Number of near-duplicate CONVERSATION captures collapsed into this one
+     * representative (same task captured across sessions lands as distinct rows;
+     * see `collapseConversationDuplicates`). Present (> 1) only when conversation
+     * dedup (RIFT_CONV_DEDUP) folded copies into this hit; absent otherwise.
+     * Distinct from `matched_sections`, which counts chunk siblings of ONE source.
+     * Lets the UI say "+N duplicate captures".
+     */
+    duplicate_count?: number;
+    /**
+     * Total chunks in the parent set, when this hit's `content` was reassembled
+     * from a chunked source via the expand path. Present only for stitched chunk
+     * expansions; absent for single-row hits.
+     */
+    chunk_count?: number;
+    /**
+     * Number of chunk siblings stitched together into `content` on this expand.
+     * For `detail="full"` this is the whole parent set (== `chunk_count` when all
+     * siblings were present); for `detail="middle"` it is the matched chunk plus
+     * its bounded neighbor window. Lets a reader tell a stitched body from a
+     * single-chunk one. For a stitched hit, the TOP-LEVEL `content_bytes` /
+     * `content_tokens_estimate` describe the body actually returned (the bounded
+     * `middle` window or the full parent), while the SAME fields inside
+     * `expand.params` advertise the full parent body that re-issuing the
+     * `detail="full"` pointer would return — so a `middle` hit never under-states
+     * the cost of escalating to `full`. `stitched_chunks < chunk_count` signals
+     * that more sections are available via `detail="full"`.
+     */
+    stitched_chunks?: number;
+}
+/**
+ * Pre-call size advert for an expansion: every compact hit carries this on
+ * both the top-level fields and inside `expand.params`, so an agent that
+ * copy-pastes the expand pointer verbatim still sees the size warning at the
+ * exact moment it chooses whether to spend context on `detail="full"`.
+ */
+export declare function computeContentSize(content: string): {
+    content_bytes: number;
+    content_tokens_estimate: number;
+};
+/**
+ * Build the middle-detail content excerpt for a row body.
+ *
+ * - For content at or below MIDDLE_INLINE_THRESHOLD_CHARS, returns the content
+ *   as-is (no truncation, `truncated: false`) — at that size the head+tail
+ *   excerpt would equal the input anyway, and skipping the elision marker
+ *   keeps the response identical to detail="full" for small rows.
+ * - For larger content, returns `head + elision marker + tail` where head is
+ *   the first MIDDLE_HEAD_CHARS and tail is the last MIDDLE_TAIL_CHARS. The
+ *   marker reports how many characters were elided so a reader knows the gap
+ *   size without having to subtract.
+ */
+export declare function buildMiddleExcerpt(content: string, query?: string): {
+    text: string;
+    truncated: boolean;
+};
+type RawRow = Record<string, unknown>;
+/**
+ * Batch-fetch the raw source rows for reranked results.
+ * Groups ids by source table and issues one `id IN (...)` query per table.
+ *
+ * Keyed by {@link rankedKey} — `(source_table, id)`, NOT bare id — so a row id
+ * shared across two tables (cloud vs local docs, hot vs cold) can never have one
+ * table's row overwrite the other's and produce a dishonest snippet/title/source
+ * for the surviving hit. Callers must look up via `get(rankedKey(r))`.
+ */
+export declare function fetchRawRowsForRanked(ranked: RankedResult[]): Promise<Map<string, RawRow>>;
+/**
+ * Compute the parent grouping key for every reranked result using a
+ * projection-only query (no `content`, no embedding vector) per source table.
+ *
+ * Returns `rankedKey(r) → parentKey | null`, keyed by `(source_table, id)` so a
+ * row id shared across two tables (cloud vs local docs, hot vs cold) can never
+ * collide into one entry. `null` for any row with no explicit chunk marker (the
+ * flag-off / legacy case — never grouped) and for any id with no backing row.
+ * Digests never chunk, so their ids map to `null` without a query. Pair with
+ * {@link groupByParent} (which looks up via {@link rankedKey}), then call
+ * {@link fetchRawRowsForRanked} on the post-group top-k representatives only.
+ */
+export declare function fetchParentKeysForRanked(ranked: RankedResult[]): Promise<Map<string, string | null>>;
+/** Derive the compact `tier` label from source_table (+ source_scope for docs). */
+export declare function deriveTier(sourceTable: TableName, row?: RawRow): Tier;
+/**
+ * Candidate source tables that can hold a row with the given compact tier.
+ * The `document` and `structured_doc` tiers map to either the cloud or local
+ * structured-docs table — callers should try them in order and keep the first hit.
+ */
+export declare function tablesForTier(tier: Tier): TableName[];
+/**
+ * Fetch a single row by id for the id-based expansion path on /search.
+ *
+ * When `sourceTableHint` is provided, only that table is consulted — this is
+ * the authoritative path for compact hits, which carry their backing table
+ * identity in `expand.params.source_table` precisely to disambiguate rows
+ * that may share an id across the cloud / local structured-doc tables.
+ *
+ * When `sourceTableHint` is omitted, falls back to iterating the candidate
+ * tables for the tier (first-match wins). This fallback is only used for
+ * hand-crafted expansion requests that don't carry `source_table`.
+ */
+export declare function fetchRowByIdForTier(id: string, tier: Tier, sourceTableHint?: TableName): Promise<{
+    row: RawRow;
+    sourceTable: TableName;
+} | null>;
+/**
+ * Fetch every row matching `id` across all supported tables.
+ *
+ * Used by the no-tier exact-ID path on /search: callers that pass only `id`
+ * deserve a deterministic answer — exactly one row, an explicit not-found,
+ * or an explicit ambiguous-ID error. Never silently fall back to ranked
+ * search.
+ *
+ * Returns an array of {row, sourceTable} hits — empty if nothing matches.
+ */
+export declare function fetchRowsByIdAcrossTables(id: string): Promise<Array<{
+    row: RawRow;
+    sourceTable: TableName;
+}>>;
+/**
+ * Fetch every row matching `id` across the given tables. Used by the
+ * tier-without-source_table path: when a tier maps to multiple backing
+ * tables (document / structured_doc → cloud + local), callers deserve the
+ * same ambiguity guarantee as the bare-id path rather than silent
+ * first-match-wins.
+ */
+export declare function fetchRowsByIdInTables(id: string, tables: readonly TableName[]): Promise<Array<{
+    row: RawRow;
+    sourceTable: TableName;
+}>>;
+/**
+ * Build a CompactHit directly from a raw row (bypassing retrieval/ranking).
+ * Used by the id-based expansion path: score is fixed at 1.0 and
+ * retrieval_method is labelled "direct" to signal a non-search fetch.
+ */
+export declare function buildCompactHitFromRow(row: RawRow, sourceTable: TableName, opts: {
+    query?: string;
+    includePassage?: boolean;
+    expandRoute?: string;
+    /**
+     * Detail level for the returned hit. Defaults to "full" — the exact-ID
+     * path is overwhelmingly used to fetch the row body verbatim. "middle"
+     * yields a bounded head+tail excerpt; "summary" omits content entirely.
+     */
+    detail?: DetailLevel;
+}): CompactHit;
+/**
+ * Build a CompactHit for the exact-ID expand path, reassembling chunk siblings
+ * when the matched row belongs to a chunk set.
+ *
+ * - Unchunked rows, and any `detail="summary"` request, are returned verbatim by
+ *   {@link buildCompactHitFromRow} — so with `RIFT_CHUNKING` off (no marked rows)
+ *   this is provably the pre-stitching behavior.
+ * - For a chunked row, `detail="full"` reassembles the whole parent in
+ *   `chunk_index` order; `detail="middle"` reassembles the matched chunk plus a
+ *   bounded neighbor window (`MIDDLE_CHUNK_NEIGHBORS` each side). Both ranges are
+ *   contiguous, and seams are de-overlapped so duplicated text appears once.
+ *
+ * The representative identity (id, title, source, timestamp, snippet, score)
+ * comes from the matched row. `content` and the TOP-LEVEL size fields are
+ * replaced with the stitched body actually returned, while the `expand.params`
+ * size fields advertise the FULL parent (what the `detail="full"` escalation
+ * pointer would return), plus `chunk_count` / `stitched_chunks` for observability.
+ */
+export declare function buildExpandedHit(row: RawRow, sourceTable: TableName, opts: {
+    query?: string;
+    includePassage?: boolean;
+    expandRoute?: string;
+    detail?: DetailLevel;
+}): Promise<CompactHit>;
+/** Derive a stable `source` string (what produced this row). */
+export declare function deriveSource(sourceTable: TableName, row?: RawRow): string;
+/** Derive a compact title. Prefers stored metadata, then first non-empty line. */
+export declare function deriveTitle(sourceTable: TableName, row: RawRow | undefined, content: string, summary: string): string;
+/**
+ * Derive a bounded snippet.
+ * - lexical/hybrid: up to 400 chars centered on the best query-term hit.
+ * - vector-only: first 400 chars of the first user turn (or content).
+ */
+export declare function deriveSnippet(content: string, query: string, retrievalMethod: string): string;
+/** Derive a bounded summary. Prefers stored summary, then content fallback. */
+export declare function deriveSummary(row: RawRow | undefined, content: string): string;
+export type DetailLevel = "summary" | "middle" | "full";
+export interface BuildCompactHitOptions {
+    query: string;
+    includePassage?: boolean;
+    detail: DetailLevel;
+    /** Route to advertise in `expand.route`. Defaults to "/search". */
+    expandRoute?: string;
+    /**
+     * Total chunk rows collapsed into this representative (from group-by-parent).
+     * Recorded as `matched_sections` when > 1.
+     */
+    siblingCount?: number | undefined;
+    /**
+     * Near-duplicate conversation captures folded into this representative (from
+     * `collapseConversationDuplicates`). Recorded as `duplicate_count` when > 1.
+     */
+    duplicateCount?: number | undefined;
+}
+export declare function buildCompactHit(ranked: RankedResult, row: RawRow | undefined, opts: BuildCompactHitOptions): CompactHit;
+/** Compact markdown rendering of a set of hits — no raw JSON. */
+export declare function renderCompactMarkdown(hits: CompactHit[], opts?: {
+    degraded?: boolean;
+    degradedReason?: string;
+    lexical?: boolean;
+}): string;
+/**
+ * Compact size warning for large hits, e.g. `~82k tokens`. Returns the empty
+ * string for hits below `LARGE_HIT_TOKEN_THRESHOLD` so the markdown stays
+ * concise when expansion would be cheap.
+ */
+export declare function formatSizeWarning(tokensEstimate: number | undefined): string;
+export {};
+//# sourceMappingURL=compact.d.ts.map

package/dist/src/retrieval/compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/retrieval/compact.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAalD,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,OAAQ,CAAC;AACvC,eAAO,MAAM,iBAAiB,OAAQ,CAAC;AACvC,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAE7E,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG;IACnD,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAIA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAcA;AAsCD,KAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAwBtC;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,YAAY,EAAE,GACrB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAqB9B;AAoBD;;;;;;;;;;;GAWG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,YAAY,EAAE,GACrB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAmCrC;AAED,mFAAmF;AACnF,wBAAgB,UAAU,CAAC,WAAW,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAcrE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,CAYrD;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,IAAI,EACV,eAAe,CAAC,EAAE,SAAS,GAC1B,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,SAAS,CAAA;CAAE,GAAG,IAAI,CAAC,CAiBzD;AAED;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC,CAEzD;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,SAAS,SAAS,EAAE,GAC3B,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC,CAczD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,SAAS,EACtB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GACA,UAAU,CAmDZ;AA+DD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,SAAS,EACtB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,GACA,OAAO,CAAC,UAAU,CAAC,CAwErB;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAAC,WAAW,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAMzE;AAED,kFAAkF;AAClF,wBAAgB,WAAW,CACzB,WAAW,EAAE,SAAS,EACtB,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,MAAM,CAwBR;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,eAAe,EAAE,MAAM,GACtB,MAAM,CAUR;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,OAAO,EAAE,MAAM,GACd,MAAM,CASR;AAED,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,WAAW,CAAC;IACpB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,IAAI,EAAE,sBAAsB,GAC3B,UAAU,CAyEZ;AAID,iEAAiE;AACjE,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAAE,EAClB,IAAI,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAC5E,MAAM,CA+CR;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAQ5E"}