@graphorin/memory 0.5.0

package/dist/tiers/semantic-memory.d.ts

@@ -0,0 +1,461 @@
+import { MemoryStoreAdapter } from "../internal/storage-adapter.js";
+import { ConflictDecision, ConflictPipeline } from "../conflict/types.js";
+import "../conflict/index.js";
+import { EntityResolver } from "../graph/entity-resolver.js";
+import { IterativeRetrievalResult, RetrievalGrader } from "../search/iterative.js";
+import { QueryTransformer } from "../search/query-transform.js";
+import { ReRanker } from "../search/types.js";
+import { EmbedderProvider, Fact, MemoryHit, MemoryProvenance, Sensitivity, SessionScope, Tracer } from "@graphorin/core";
+
+//#region src/tiers/semantic-memory.d.ts
+
+/**
+ * Author-time fact payload accepted by {@link SemanticMemory.remember}.
+ * The framework derives `id`, `kind: 'semantic'`, `userId`,
+ * `createdAt`, `updatedAt`, `validFrom`, the optional `embedder_id`,
+ * and the deduplication `hash` from this input.
+ *
+ * @stable
+ */
+interface FactInput {
+  readonly text: string;
+  readonly subject?: string;
+  readonly predicate?: string;
+  readonly object?: string;
+  readonly tags?: ReadonlyArray<string>;
+  readonly confidence?: number;
+  readonly sensitivity?: Sensitivity;
+  readonly validFrom?: string;
+  readonly validTo?: string;
+  readonly supersedes?: string;
+  /**
+   * Trust-provenance tag (P1-4). Writers that synthesize memory pass
+   * `'extraction'` / `'reflection'` so the fact lands quarantined;
+   * first-party writers pass `'user'` / `'tool'` (or omit it — absent ⇒
+   * treated as first-party `active`). The `status` is *derived* from
+   * this tag plus the injection heuristics; it is never author-set.
+   */
+  readonly provenance?: MemoryProvenance;
+  /**
+   * Importance hint in `[0, 1]` (X-1 / MCON-12). Feeds the multi-signal
+   * salience score that orders decay archiving and capacity eviction —
+   * higher importance ⇒ evicted later. Values are clamped to `[0, 1]`;
+   * non-finite values are dropped. The consolidator's extraction pass
+   * fills this from the model's per-fact 1–10 rating
+   * (`normalizeImportance`); absent ⇒ the neutral midpoint at scoring
+   * time.
+   */
+  readonly importance?: number;
+}
+/**
+ * Per-list weights for {@link FusionStrategy} `'weighted'` fusion (X-2),
+ * keyed by retriever *kind* rather than position so they survive the
+ * P2-3 multi-query fan-out (which appends extra FTS / vector candidate
+ * lists). Each defaults to the neutral `1` (≡ RRF). The HyDE list is a
+ * vector list and takes the `vector` weight.
+ *
+ * @stable
+ */
+interface FusionWeights {
+  /** Weight applied to every FTS5 (lexical) candidate list. Default `1`. */
+  readonly fts?: number;
+  /** Weight applied to every vector (incl. HyDE) candidate list. Default `1`. */
+  readonly vector?: number;
+}
+/**
+ * Score-fusion strategy for {@link SemanticMemory.search} (X-2).
+ *
+ * - `'rrf'` (the default when `fusion` is omitted) fuses the candidate
+ *   lists through the configured reranker — the zero-tuning
+ *   {@link RRFReranker} unless one was overridden.
+ * - `'weighted'` fuses through {@link WeightedRRFReranker}, scaling each
+ *   list's reciprocal-rank contribution by its {@link FusionWeights}, for
+ *   callers who have calibrated retriever reliability against labels (the
+ *   P0-1 eval harness). At equal weights it reproduces RRF.
+ *
+ * @stable
+ */
+type FusionStrategy = {
+  readonly strategy: 'rrf';
+} | {
+  readonly strategy: 'weighted';
+  readonly weights: FusionWeights;
+  /** Override the RRF constant for the weighted fuse. Default `60`. */
+  readonly k?: number;
+};
+/**
+ * Per-call options accepted by {@link SemanticMemory.search}.
+ *
+ * @stable
+ */
+interface FactSearchOptions {
+  readonly topK?: number;
+  readonly signal?: AbortSignal;
+  /** Override the per-list candidate count (default `60`). */
+  readonly candidateTopK?: number;
+  /**
+   * Any-of tags filter (MRET-4). A fact matches when it carries at
+   * least one of the requested tags; untagged facts never match.
+   * Applied in-store on the FTS leg and as a record-level filter on
+   * the fused result so every candidate leg (vector / HyDE / graph)
+   * obeys it.
+   */
+  readonly tags?: ReadonlyArray<string>;
+  /**
+   * Point-in-time ("as of") read. When set, only facts whose
+   * bi-temporal validity interval contains this instant are returned
+   * (`valid_from <= asOf < valid_to`, open-ended bounds allowed),
+   * applied at the store layer to both the FTS and vector candidate
+   * lists. ISO-8601. Absent ⇒ current behaviour is unchanged. P0-2.
+   *
+   * @stable
+   */
+  readonly asOf?: string;
+  /**
+   * Include quarantined facts in the result (P1-4). Defaults to
+   * `false` — action-driving recall (`fact_search`, auto-recall) never
+   * returns quarantined rows. Set `true` only for the validation /
+   * inspector path that surfaces quarantined facts to a human for
+   * promotion via {@link SemanticMemory.validate}.
+   *
+   * @stable
+   */
+  readonly includeQuarantined?: boolean;
+  /**
+   * Optional decay-aware ranking. When set, the reranker output is
+   * post-multiplied by the per-fact retention curve
+   * `score *= exp(-elapsedDays / tauDays)` so stale facts drop in
+   * the result list without ever being hard-deleted (principle 8).
+   * Requires the storage adapter to expose
+   * `semantic.listForDecay?(...)` so the search can read
+   * `strength` + `lastAccessedAt`; adapters without the surface
+   * skip the boost silently.
+   *
+   * @stable
+   */
+  readonly decay?: {
+    readonly tauDays: number;
+    /** Override the wall clock (test seam). */
+    readonly now?: () => number;
+  };
+  /**
+   * Multi-query / RAG-Fusion (P2-3). When set to `N > 1` *and* a query
+   * transformer is configured (`createMemory({ queryTransform })`), the
+   * query is fanned into up to `N - 1` reworded variants via one cheap
+   * LLM call; each variant is retrieved (FTS + vector) and **all** lists
+   * are fused through the existing RRF reranker — recovering memories
+   * whose stored wording differs from the user's phrasing. `N` bounds
+   * the *total* query strings, including the original. Offline (no
+   * transformer, or `N <= 1`) this is a **silent no-op**: search stays
+   * single-shot and makes no provider call. Opt-in + retrieval-heavy, so
+   * reserve it for deliberate recall rather than every search.
+   *
+   * @stable
+   */
+  readonly multiQuery?: number;
+  /**
+   * HyDE — Hypothetical Document Embeddings (arXiv:2212.10496), P2-3.
+   * When `true` *and* both a query transformer and an embedder are
+   * configured, generate a short hypothetical answer, embed it, and fuse
+   * its vector neighbours into the result. Helps short / ambiguous
+   * queries but adds a generate + embed round-trip and can drift — hence
+   * opt-in. With no transformer (or no embedder) this is a silent no-op
+   * and no provider call is made.
+   *
+   * @stable
+   */
+  readonly hyde?: boolean;
+  /**
+   * Score-fusion strategy (X-2). Omitted (the default) ⇒ RRF via the
+   * configured reranker — behaviour is unchanged. `{ strategy:
+   * 'weighted', weights }` fuses through {@link WeightedRRFReranker},
+   * up-/down-weighting the FTS vs vector candidate lists per
+   * {@link FusionWeights}; reserve it for callers who have calibrated the
+   * weights against labels (the P0-1 eval harness). At equal weights it
+   * reproduces RRF.
+   *
+   * @stable
+   */
+  readonly fusion?: FusionStrategy;
+  /**
+   * One-hop graph expansion (P2-1). With `1` *and* a graph-capable
+   * storage adapter (`store.graph`), the facts retrieved by the lexical /
+   * vector candidate pass are treated as seeds: facts sharing a canonical
+   * entity (subject / object) are fetched via a recursive CTE and fused
+   * in as an extra candidate list before rerank — surfacing connected
+   * facts the query never matched directly ("what did the person I met in
+   * Tbilisi recommend?"). `0` (the default) or a graph-less adapter ⇒ a
+   * silent no-op; recall is unchanged. Opt-in + retrieval-heavy.
+   *
+   * @stable
+   */
+  readonly expandHops?: 0 | 1;
+}
+/**
+ * Per-call options for {@link SemanticMemory.searchIterative} (P2-4) —
+ * the gated grade-then-reformulate loop. Extends {@link FactSearchOptions}
+ * (every base option applies to each retrieval pass); `topK` doubles as
+ * the cap on the accumulated result count.
+ *
+ * @stable
+ */
+interface IterativeSearchOptions extends FactSearchOptions {
+  /**
+   * Total-pass cap, clamped to `[1, 5]`. Omitted ⇒ the facade-configured
+   * default (`createMemory({ iterativeRetrieval: { maxIterations } })`)
+   * or `3`.
+   */
+  readonly maxIterations?: number;
+  /**
+   * Skip the heuristic difficulty gate and force the loop (still capped
+   * and still a no-op without a grader). For deliberate "deep recall"
+   * requests and tests.
+   */
+  readonly forceHard?: boolean;
+}
+/**
+ * Outcome of {@link SemanticMemory.searchIterative}. Beyond the ranked
+ * `hits`, `sufficient` / `abstained` tell the caller whether the memory
+ * actually answered the query — `abstained: true` means it should say so
+ * rather than confabulate.
+ *
+ * @stable
+ */
+type IterativeRecallResult = IterativeRetrievalResult<MemoryHit<Fact>>;
+/**
+ * Per-call options accepted by {@link SemanticMemory.remember}. The
+ * Phase 10b pipeline writes one row to `fact_conflicts` (and
+ * potentially one to `conflict_check_pending`) for every invocation;
+ * pass `pipeline: 'off'` to bypass the pipeline for a single call
+ * (useful for one-shot data imports).
+ *
+ * @stable
+ */
+interface FactRememberOptions {
+  readonly pipeline?: 'on' | 'off';
+  /** Cancellation signal forwarded to the embedder + storage layers. */
+  readonly signal?: AbortSignal;
+  /**
+   * Precomputed contextual-retrieval index text (P1-3, advanced). When
+   * supplied it overrides the instance's `'late-chunk'` computation: the
+   * embedding is computed from — and the FTS row indexed against — this
+   * text, while the canonical `text` is stored unchanged. The background
+   * consolidator passes this in its `'llm'` mode (the one place an LLM is
+   * allowed to write the situating context); first-party callers normally
+   * omit it and rely on the offline late-chunk default.
+   */
+  readonly indexText?: string;
+  /**
+   * Auto-promotion policy (MCON-2). When `true`, a *synthesized* write
+   * (consolidator extraction) that is **clean** by the injection heuristics is
+   * stored `active` instead of quarantined. Injection-flagged writes always
+   * stay quarantined — the security gate is preserved. Off by default; the
+   * consolidator passes it only when the operator opts in via
+   * `autoPromoteExtraction`. No effect on non-synthesized writes.
+   */
+  readonly autoPromoteSynthesized?: boolean;
+}
+/**
+ * Returned by {@link SemanticMemory.remember}. The `fact` is the
+ * stored row (which may be the *existing* fact when the pipeline
+ * dedups). The `decision` mirrors the pipeline outcome so callers can
+ * distinguish silent dedups from active inserts.
+ *
+ * @stable
+ */
+interface RememberOutcome {
+  readonly fact: Fact;
+  readonly decision: ConflictDecision;
+  /**
+   * Why this write landed quarantined, if it did (P1-4 / MRET-3).
+   * `'injection'` — the offline injection heuristics flagged the text
+   * (a memory-poisoning candidate). `'synthesized'` — a consolidator /
+   * reflection / induction write awaiting validation. Absent when the
+   * fact is `active` or when a dedup returned a pre-existing row.
+   */
+  readonly quarantineReason?: 'injection' | 'synthesized';
+}
+/**
+ * `SemanticMemory` — long-term factual store. Hybrid (vector + FTS5)
+ * search merges the two ranked lists through the configured
+ * {@link ReRanker} (default {@link RRFReranker} with `k = 60`).
+ *
+ * Phase 10a wrote facts straight through with MD5 deduplication;
+ * Phase 10b routes every `remember(...)` call through the multi-stage
+ * conflict resolution pipeline (DEC-117 / ADR-018 ext / RB-02). The
+ * pipeline can be disabled per-call (`pipeline: 'off'`) or per-`Memory`
+ * instance (`createMemory({ conflictPipeline: { mode: 'off' } })`).
+ *
+ * @stable
+ */
+declare class SemanticMemory {
+  #private;
+  constructor(args: {
+    store: MemoryStoreAdapter;
+    tracer: Tracer;
+    embedder: EmbedderProvider | null;
+    embedderIdProvider: () => string | null;
+    reranker: ReRanker;
+    conflictPipeline?: ConflictPipeline;
+    /**
+     * Query transformer for multi-query / HyDE retrieval (P2-3). When
+     * supplied, `search(..., { multiQuery })` / `{ hyde }` opt into one
+     * cheap LLM call to rewrite / hypothesize the query; omitted (the
+     * default) ⇒ those options are silent no-ops and search stays
+     * offline + single-shot.
+     */
+    queryTransformer?: QueryTransformer;
+    /**
+     * Contextual-retrieval mode for the write path (P1-3). `'late-chunk'`
+     * (default) prepends a deterministic situating context to the text
+     * that is embedded + FTS-indexed, leaving the canonical `text`
+     * untouched; `'off'` indexes the bare text. The hot write path never
+     * makes an LLM call — the `'llm'` enrichment is confined to the
+     * background consolidator, which supplies a precomputed `indexText`.
+     */
+    contextualRetrieval?: 'off' | 'late-chunk';
+    /**
+     * Entity resolver for the relation graph (P2-1). When supplied,
+     * `remember(...)` resolves a fact's subject / object to canonical
+     * entities and links them, enabling `search(..., { expandHops: 1 })`.
+     * Omitted (the default) ⇒ writes carry s/p/o but form no entity
+     * links, and the write path stays offline + unchanged.
+     */
+    entityResolver?: EntityResolver;
+    /**
+     * Retrieval grader for the gated iterative loop (P2-4). When
+     * supplied, `searchIterative(...)` can grade a retrieved set and
+     * reformulate on hard queries; omitted (the default) ⇒
+     * `searchIterative` runs a single, difficulty-gated pass and makes no
+     * provider call.
+     */
+    grader?: RetrievalGrader;
+    /** Default total-pass cap for `searchIterative`. Default 3. */
+    iterativeMaxIterations?: number;
+  });
+  /** Replace the active reranker. Returns the previous instance. */
+  setReranker(reranker: ReRanker): ReRanker;
+  /** Currently active reranker. */
+  reranker(): ReRanker;
+  /**
+   * Persist a fact. Returns the stored record. Phase 10b routes every
+   * call through the multi-stage conflict resolution pipeline; the
+   * legacy straight-through path is reachable per-call via
+   * `{ pipeline: 'off' }` (operators may disable the pipeline globally
+   * via `createMemory({ conflictPipeline: { mode: 'off' } })`).
+   */
+  remember(scope: SessionScope, input: FactInput, options?: FactRememberOptions): Promise<Fact>;
+  /**
+   * Like {@link remember} but returns the pipeline `decision` alongside
+   * the stored fact. Useful for callers that need to distinguish
+   * silent dedups (`decision.kind === 'dedup'`) from fresh inserts.
+   *
+   * @stable
+   */
+  rememberWithDecision(scope: SessionScope, input: FactInput, options?: FactRememberOptions): Promise<RememberOutcome>;
+  /** Hybrid (vector + FTS5) search merged through the configured reranker. */
+  search(scope: SessionScope, query: string, opts?: FactSearchOptions): Promise<ReadonlyArray<MemoryHit<Fact>>>;
+  /**
+   * Gated, iterative ("deep") recall for hard queries (P2-4). A cheap
+   * local heuristic ({@link assessQueryDifficulty}) decides whether the
+   * query is even a loop candidate; simple lookups take exactly one
+   * {@link search} pass and make no provider call. For a query judged
+   * hard *and* with a grader configured
+   * (`createMemory({ iterativeRetrieval })`), the retrieved set is graded
+   * for sufficiency and, when weak, the query is reformulated and
+   * retrieved again — **widening to one-hop graph expansion**
+   * (`expandHops: 1`) on each reformulation pass — up to `maxIterations`
+   * (hard-capped at 5). When still insufficient it returns
+   * `abstained: true` so the caller can decline to answer instead of
+   * confabulating.
+   *
+   * Without a grader (the offline default) this degrades to a single,
+   * difficulty-gated `search` and never calls a provider.
+   *
+   * @stable
+   */
+  searchIterative(scope: SessionScope, query: string, opts?: IterativeSearchOptions): Promise<IterativeRecallResult>;
+  /**
+   * Raw vector KNN neighbours for the consolidator's reconcile
+   * pre-filter (P0-3). Unlike {@link search} this skips FTS, reranking,
+   * and decay so the cosine scores survive intact (the conflict-pipeline
+   * zone thresholds are calibrated against them), and it **includes
+   * quarantined facts** so prior synthesized memories are visible to
+   * reconciliation. Returns `[]` when no embedder / vector adapter is
+   * configured — the consolidator then treats every candidate as a
+   * fresh `add`, degrading gracefully to the pre-reconcile behaviour.
+   *
+   * @stable
+   */
+  neighbors(scope: SessionScope, text: string, opts?: {
+    readonly topK?: number;
+  }): Promise<ReadonlyArray<MemoryHit<Fact>>>;
+  /** Lookup a single fact by id. Returns `null` for soft-deleted / missing. */
+  get(scope: SessionScope, factId: string): Promise<Fact | null>;
+  /**
+   * Return the full bi-temporal supersede chain that `factId` belongs
+   * to, oldest → newest, including superseded / soft-deleted rows so
+   * callers can answer "how did this fact change over time". Requires
+   * a storage adapter that implements
+   * `SemanticMemoryStoreExt.historyOf(...)` — the default
+   * `@graphorin/store-sqlite` adapter wires this through. P0-2.
+   *
+   * @stable
+   */
+  history(scope: SessionScope, factId: string): Promise<ReadonlyArray<Fact>>;
+  /**
+   * Promote a quarantined fact to `active` (P1-4). The validation path
+   * that admits a synthesized memory into action-driving recall once a
+   * human (or trusted non-agent caller) has reviewed it. Writes a
+   * `memory_history` audit row. Requires a storage adapter that
+   * implements `SemanticMemoryStoreExt.setStatus(...)` — the default
+   * `@graphorin/store-sqlite` adapter wires this through.
+   *
+   * MRET-3 / MST-1: promotion of a fact whose text still trips the
+   * offline injection heuristics is **refused** with
+   * {@link QuarantinePromotionRefusedError} — the model-facing
+   * `fact_validate` tool calls this with no `force`, so a poisoned
+   * memory can never be promoted by the agent itself (the one-turn
+   * `fact_remember(poison)` → `fact_validate(id)` chain is closed). An
+   * operator can override after review by passing `{ force: true }`
+   * from a trusted (non-agent) context. Synthesized-but-clean writes
+   * (consolidator / reflection) promote normally.
+   *
+   * @stable
+   */
+  validate(scope: SessionScope, factId: string, reason?: string, options?: {
+    readonly force?: boolean;
+  }): Promise<void>;
+  /** Mark `oldId` superseded by a new fact. Returns the new record. */
+  supersede(scope: SessionScope, oldId: string, newInput: FactInput, reason?: string): Promise<{
+    readonly old: string;
+    readonly new: Fact;
+  }>;
+  /** Soft-delete a fact (kept for replay; never hard-deleted). */
+  forget(scope: SessionScope, factId: string, reason?: string): Promise<void>;
+  /**
+   * Hard-delete a fact (GDPR path). Distinct from {@link forget}: the
+   * record is removed from storage entirely instead of soft-archived.
+   * Requires a storage adapter that implements
+   * `SemanticMemoryStoreExt.purge(...)` — the default
+   * `@graphorin/store-sqlite` adapter wires this through.
+   */
+  purge(scope: SessionScope, factId: string, reason?: string): Promise<void>;
+  /** Fuse multiple ranked lists outside of a `search()` call. */
+  fuse(query: string, lists: ReadonlyArray<ReadonlyArray<MemoryHit<Fact>>>, options?: {
+    topK?: number;
+    signal?: AbortSignal;
+  }): Promise<ReadonlyArray<MemoryHit<Fact>>>;
+  /** Pure-fusion helper — exposed for callers that already collected results. */
+  static fuseRrf<TRecord extends Fact>(lists: ReadonlyArray<ReadonlyArray<MemoryHit<TRecord>>>, k?: number): ReadonlyArray<MemoryHit<TRecord>>;
+  /**
+   * Pure weighted-fusion helper (X-2) — like {@link SemanticMemory.fuseRrf}
+   * but scales each list `i`'s reciprocal-rank contribution by
+   * `weights[i]`. A missing / invalid entry defaults to `1`, so equal or
+   * absent weights reproduce RRF.
+   */
+  static fuseWeighted<TRecord extends Fact>(lists: ReadonlyArray<ReadonlyArray<MemoryHit<TRecord>>>, weights: ReadonlyArray<number> | undefined, k?: number): ReadonlyArray<MemoryHit<TRecord>>;
+}
+//#endregion
+export { FactInput, FactRememberOptions, FactSearchOptions, FusionStrategy, FusionWeights, IterativeRecallResult, IterativeSearchOptions, RememberOutcome, SemanticMemory };
+//# sourceMappingURL=semantic-memory.d.ts.map

package/dist/tiers/semantic-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic-memory.d.ts","names":[],"sources":["../../src/tiers/semantic-memory.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AAsCA;;;;;AAwCiB,UAxCA,SAAA,CAwCa;EAoBlB,SAAA,IAAA,EAAA,MAAc;EAcT,SAAA,OAAA,CAAA,EAAA,MAAiB;EAEd,SAAA,SAAA,CAAA,EAAA,MAAA;EAUF,SAAA,MAAA,CAAA,EAAA,MAAA;EA4EE,SAAA,IAAA,CAAA,EA7JF,aA6JE,CAAA,MAAA,CAAA;EAAc,SAAA,UAAA,CAAA,EAAA,MAAA;EAwBjB,SAAA,WAAA,CAAA,EAnLQ,WAmLe;EAuB5B,SAAA,SAAA,CAAA,EAAA,MAAqB;EAAsC,SAAA,OAAA,CAAA,EAAA,MAAA;EAAV,SAAA,UAAA,CAAA,EAAA,MAAA;EAAzB;;AAWpC;AAiCA;AA0BA;;;EAgBc,SAAA,UAAA,CAAA,EArRU,gBAqRV;EAEA;;;;;;;;;EAwEH,SAAA,UAAA,CAAA,EAAA,MAAA;;;;;;;;;;;AAqO0B,UA9iBpB,aAAA,CA8iBoB;EAAV;EAAd,SAAA,GAAA,CAAA,EAAA,MAAA;EAAR;EAqLM,SAAA,MAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;AA0G2C,KAzzB1C,cAAA,GAyzB0C;EAyC3C,SAAA,QAAA,EAAA,KAAA;CAIN,GAAA;EAoCM,SAAA,QAAA,EAAA,UAAA;EAEG,SAAA,OAAA,EAx4BU,aAw4BV;EAEqC;EAA9C,SAAA,CAAA,CAAA,EAAA,MAAA;CAwBiB;;;;;;AAwCG,UAh8BR,iBAAA,CAg8BQ;EAAd,SAAA,IAAA,CAAA,EAAA,MAAA;EAC4B,SAAA,MAAA,CAAA,EA/7BnB,WA+7BmB;EACF;EAAV,SAAA,aAAA,CAAA,EAAA,MAAA;EAAd;;;;;;;EAQgB,SAAA,IAAA,CAAA,EA97BX,aA87BW,CAAA,MAAA,CAAA;EAAV;;;;;;;;;EAcA,SAAA,IAAA,CAAA,EAAA,MAAA;EAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAh4Be;;;;;;;;;;;;;;;;;;;;;;;UAwBH,sBAAA,SAA+B;;;;;;;;;;;;;;;;;;;;;;KAuBpC,qBAAA,GAAwB,yBAAyB,UAAU;;;;;;;;;;UAWtD,mBAAA;;;oBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BH,eAAA;iBACA;qBACI;;;;;;;;;;;;;;;;;;;;;;;cAwBR,cAAA;;;WAcF;YACC;cACE;;cAEA;uBACS;;;;;;;;uBAQA;;;;;;;;;;;;;;;;;qBAiBF;;;;;;;;aAQR;;;;;wBAkBW,WAAW;;cAOrB;;;;;;;;kBAYH,qBACA,qBACE,sBACR,QAAQ;;;;;;;;8BAaF,qBACA,qBACE,sBACR,QAAQ;;gBAgNF,oCAED,oBACL,QAAQ,cAAc,UAAU;;;;;;;;;;;;;;;;;;;;yBAqL1B,oCAED,yBACL,QAAQ;;;;;;;;;;;;;mBAiEF;;MAGN,QAAQ,cAAc,UAAU;;aAKlB,+BAA+B,QAAQ;;;;;;;;;;;iBA8BnC,+BAA+B,QAAQ,cAAc;;;;;;;;;;;;;;;;;;;;;kBAyCjE;;MAIN;;mBAoCM,uCAEG,6BAET;;kBAA8C;;;gBAwB7B,gDAAgD;;;;;;;;eAmBjD,gDAAgD;;6BAqB1D,cAAc,cAAc,UAAU;;aACV;MAClC,QAAQ,cAAc,UAAU;;iCAKJ,aACtB,cAAc,cAAc,UAAU,yBAE5C,cAAc,UAAU;;;;;;;sCAUS,aAC3B,cAAc,cAAc,UAAU,qBACpC,gDAER,cAAc,UAAU"}