@quereus/quereus 3.3.0 → 4.0.0

package/dist/src/planner/analysis/coverage-prover.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Coverage prover — recognizes when an explicit materialized view *covers* a
+ * UNIQUE constraint, i.e. its materialized row set is observation-equivalent to
+ * the set of rows the constraint governs, keyed so a point lookup answers the
+ * uniqueness question. Pure analysis: it records a constraint↔structure link
+ * (see `runtime/emit/materialized-view.ts`); **nothing enforces through the MV's
+ * backing table in this ticket** (that needs row-time write-through maintenance
+ * — see `docs/materialized-views.md` § Covering structures, the soundness note).
+ *
+ * Shape — the body, after optimization, walks down to a single constrained base
+ * table `T` through a chain of:
+ *
+ *     TableReference(T) → optional Filter(P) → Project(...) → optional Sort
+ *
+ * (physical access nodes such as IndexScan / SeqScan are transparent links in
+ * the chain). A binary **join** is admitted when `T` provably contributes
+ * *exactly one* MV row per governed `T` row — see the 1:1 decomposition below.
+ * Aggregation, DISTINCT, set operations, `FanOutLookupJoin`, and `AsofScan` are
+ * always `NotCovers('shape')`.
+ *
+ * Soundness is paramount: a false `Covers` would (once the lens layer routes
+ * enforcement through the structure) silently miss conflicts. Every check is
+ * conservative — a false `NotCovers` only forgoes an optimization.
+ *
+ * ---
+ *
+ * **The 1:1 join decomposition.** "Exactly one MV row per governed `T` row"
+ * splits into two independent obligations, each proven by a distinct surface:
+ *
+ *  - **No row loss (≥1).** Proven one of two ways during the plan walk:
+ *
+ *      1. *Row preservation* — `T` sits on the row-*preserving* side of the join:
+ *         a `left` join with `T` in the left subtree, or a `right` join with `T`
+ *         in the right subtree.
+ *      2. *Referential integrity* — an `inner`/`cross` join whose equi-pairs are
+ *         an inclusion dependency from the `T`-side relation to the lookup table's
+ *         **primary key**, over a lookup side that exposes the parent's *full* row
+ *         set (`innerJoinRetainsConstrainedTable`). Enforced RI then makes every
+ *         `T` row match exactly one lookup row, so the inner join loses nothing.
+ *         This obligation is now **IND-derived** (Wave 2): it first consults the
+ *         propagated `PhysicalProperties.inds` surface on the `T`-side subtree
+ *         (`indDerivedNoRowLoss`) and falls back to the original structural
+ *         NOT-NULL-FK-on-`T` check (`lookupCoveringFK`, `!match.nullable`) when no
+ *         IND discharges it. Both gate on the same preconditions, so they agree on
+ *         every single-FK shape; the IND path additionally proves no-row-loss
+ *         across multi-hop FK chains (`T → M → P`) whose threaded IND a single
+ *         `lookupCoveringFK` call cannot see. Both lean on the engine treating
+ *         declared FKs as inclusion dependencies — see the RI soundness note below.
+ *
+ *    Every other join type/position (`inner`/`cross` *without* a covering FK/IND;
+ *    `semi`/`anti` filter; `full` injects lookup-only rows; `T` on the dropping
+ *    side) is rejected as `shape`. FDs encode uniqueness, not existence, so
+ *    obligation (1) cannot be FD-derived; obligation (2) is discharged from the
+ *    propagated IND surface (the Wave-1 over-claim-free guarantee licenses trusting
+ *    it) with the structural FK-schema read as fallback.
+ *
+ *  - **No fan-out (≤1).** `T`'s primary key must be a unique key of the
+ *    **topmost join's output relation**, read through `isUnique`. The optimizer
+ *    propagates join key-preservation into the join's `physical.fds`
+ *    (`analyzeJoinKeyCoverage` → `propagateJoinFds`): for `T LEFT JOIN L on
+ *    T.fk = L.ukey` it emits `T.pk → all_join_cols` *iff* the equi-pairs cover a
+ *    unique key of `L`, i.e. iff each `T` row matches ≤1 `L` row. The moment the
+ *    lookup side can multiply a `T` row, no preserved-key FD is emitted and
+ *    `T.pk` is not a superkey of the join output ⇒ `NotCovers('fanout')`.
+ *
+ *    **Why the join frame, not the projected `root`.** The check is deliberately
+ *    against the topmost join node, where the lookup columns are still present.
+ *    A fanning `left` join still carries `T`'s own PK FD `T.pk → T-cols` (from
+ *    the left input's `physical.fds`); once the lookup columns are *projected
+ *    away* in `root`, that FD would make `T.pk` a derived key of the narrowed
+ *    relation and silently mask the fan-out (the duplicate `T` rows survive
+ *    projection without `DISTINCT`). At the join frame the retained lookup
+ *    columns witness the fan-out, so `isUnique` is faithful regardless of what
+ *    the projection keeps.
+ *
+ * Both obligations are required and neither implies the other: a `left` join to
+ * a *non-unique* lookup key is row-preserving but fans out (caught by the fan-out
+ * gate); an `inner` join to a unique *non-FK* (or nullable-FK) lookup key does
+ * not fan out but can lose `T` rows (caught by the no-row-loss gate). A NOT-NULL
+ * FK→PK inner join satisfies both at once: the FK target is the PK, so it is
+ * unique (no fan-out) *and* every `T` row matches (no row loss).
+ *
+ * **Referential-integrity soundness (load-bearing).** Obligation (2) is sound
+ * only because Quereus *enforces* referential integrity: `pragma foreign_keys`
+ * defaults on, and the optimizer treats every declared FK as a hard inclusion
+ * dependency (`child.fk ⊆ parent.pk` — see `util/ind-utils.ts`). The INNER
+ * branch of `rule-join-elimination` already relies on exactly this invariant to
+ * drop an FK→PK join, so admitting the same shape here introduces no *new*
+ * assumption. If FKs were advisory — or RI is disabled and orphan child rows are
+ * inserted — both this admit path *and* inner join elimination would be unsound
+ * together; that is a global optimizer assumption, not one this prover owns.
+ *
+ * **NOT the `extractBindings` `'row'` classification.** A tempting-but-wrong
+ * signal is the binding extractor's `'row'` class (`binding-extractor.ts`,
+ * `analyzeRowSpecific`). That is *equality-pinned* — it fires only when equality
+ * constraints cover `T`'s key at the reference, and reports a bare join scan as
+ * `'global'`. The sound realization of "exactly one MV row per source row" is
+ * `T`'s primary key being preserved as a key of the join output — the FD-surface
+ * fact `isUnique` already consumes — so `binding-extractor.ts` needs no change.
+ *
+ * The v1 projection / ordering / predicate checks are frame-correct for a join
+ * body: the covering columns all belong to `T` (UC + PK), the lookup-side
+ * attributes simply are not in `baseAttrToCol` and are ignored, and the join `ON`
+ * lives in the AST `from` clause (not `WHERE`). The AST `ORDER BY` / `WHERE`
+ * column resolution is **qualifier-aware** (`makeBodyColumnResolver`): `alias.col`
+ * resolves to a `T` column only when `alias` denotes `T`'s reference, and a bare
+ * `col` only when unambiguous across the join's sources. A term on a lookup-side
+ * column therefore fails on its own terms (`ordering-mismatch` for an `ORDER BY`,
+ * `predicate-entailment` for a `WHERE`) rather than mis-mapping onto a same-named
+ * `T` column — so a 1:1 join whose lookup key shares a UC column name (e.g.
+ * `line_items ⋈ products on l.sku = p.sku`) now covers, instead of being rejected
+ * by the former bare-name collision guard.
+ *
+ * **Cross-schema qualifier resolution is (schema, table)-aware.** Qualifier
+ * matching keys on the reference's `(schema, table)` pair, not its table name
+ * alone: a `schema.table.col` ORDER BY / WHERE term whose *table* name equals
+ * `T`'s but whose *schema* denotes a different schema (e.g. a lookup `s2.t` joined
+ * against base `main.t`, both named `t`) resolves to `undefined` instead of
+ * collapsing onto base `T`'s same-named column and yielding a false `Covers`. This
+ * is **defense-in-depth**: the binder rejects *every* 3-part `schema.table.column`
+ * reference in expression context before the prover runs (see
+ * `AliasedScope.resolveSymbol` / `resolveColumn`), so a real materialized view can
+ * never carry such a term — the guard is reachable only by feeding `proveCoverage`
+ * a hand-built `selectAst` (which is what the dedicated unit test does). The two
+ * SQL-reachable orderings (`order by uc` bare, `order by t.uc` 2-part) both
+ * resolve to base `T`'s column, a genuine cover, and are unchanged.
+ *
+ * **Join elimination, not handled here.** When the optimizer eliminates a
+ * key-preserving lookup join (lookup columns unprojected + FK→PK alignment, see
+ * `rule-join-elimination.ts`) the body collapses to a single-source chain and the
+ * v1 path covers it with no join-specific code. This module handles the residual
+ * cases where the join survives the optimizer but is still provably 1:1.
+ *
+ * Inner/cross covering via enforced referential integrity is handled (obligation
+ * (2) above). Full-outer covering remains deferred (it injects lookup-only rows
+ * that have no governed `T` row).
+ *
+ * ---
+ *
+ * Two different "coverage" questions live in this module; keep them apart:
+ *
+ *  1. **Base-table covering** (`proveCoverage`, above) — does an explicit MV's
+ *     materialized row set cover a `unique` constraint on a *base table* `T`,
+ *     keyed so a point lookup answers the uniqueness question and the base PK is
+ *     reconstructible so a conflicting row can be identified? Requires literal
+ *     projection of every UC column + the source PK, an `order by` permutation of
+ *     the UC columns, and predicate/NULL-skip alignment.
+ *
+ *  2. **Output-relation effective key** (`proveEffectiveKeyUnique`, below) — is
+ *     the body's *own output relation* provably unique on the declared key
+ *     columns, via its effective key (declared keys, FD-closure-derived keys, or
+ *     the all-columns/set fallback, all read through the unified `isUnique`
+ *     surface)? This is the obligation primitive the lens prover consumes for its
+ *     `obligation: proved` class — e.g. a `group by x, y` body whose output is
+ *     intrinsically one row per `(x, y)` vacuously satisfies a logical
+ *     `unique(x, y)`, so no runtime enforcement structure is needed.
+ *
+ * **Why (2) is NOT folded into (1).** An FD-derived output key cannot prove a
+ * *base-table* constraint, and folding it in would be unsound. A `group by x`
+ * body's output is *always* unique on `x` — whether or not `T` satisfies
+ * `unique(x)` — because grouping collapses base-row duplicates: two base rows
+ * with `x = 5` (a base-constraint violation) still yield exactly one output row
+ * for `x = 5`. Output-key uniqueness is therefore silent about base duplicates;
+ * that masking is the whole problem. Aggregating bodies also drop the base PK, so
+ * the "identify the conflicting base row" half of the v1 covering contract (for
+ * REPLACE / IGNORE conflict resolution) is unrecoverable. (2) is thus a proof
+ * about the *derived (output) relation's own* constraint, deliberately kept out
+ * of `proveCoverage` to preserve the v1 soundness boundary and leave the
+ * eager-link path (`linkCoveredUniqueConstraints`) untouched. Whether a covering
+ * *enforcement* structure can ever be FD-derived (detection-only, ABORT) is a
+ * separate concern of the row-time-enforcement / lens tickets, not this one.
+ */
+import type { RelationalPlanNode } from '../nodes/plan-node.js';
+import { TableReferenceNode } from '../nodes/reference.js';
+import type { EquiJoinPair } from '../nodes/join-utils.js';
+import type { MaintainedTableSchema } from '../../schema/derivation.js';
+import type { TableSchema, UniqueConstraintSchema } from '../../schema/table.js';
+export type CoverageFailureReason = 'shape' | 'fanout' | 'missing-uc-column' | 'missing-pk-column' | 'collation-mismatch' | 'ordering-mismatch' | 'predicate-entailment' | 'missing-null-skip';
+export type CoverageResult = {
+    covers: true;
+} | {
+    covers: false;
+    reason: CoverageFailureReason;
+};
+/**
+ * Options for {@link proveCoverage}. Production callers leave this empty.
+ *
+ * `structuralOnly` is a verification seam: it disables the Wave-2 IND-derived
+ * no-row-loss path so the inner/cross obligation uses only the structural
+ * NOT-NULL-FK check. The equivalence test runs each existing FK→PK body twice
+ * (IND on vs `structuralOnly`) and asserts identical verdicts — the structural
+ * guarantee that the two derivations cannot disagree on the single-FK corpus.
+ */
+export interface ProveCoverageOptions {
+    readonly structuralOnly?: boolean;
+}
+/**
+ * Outcome of `proveEffectiveKeyUnique`. `not-a-key` means the body's effective
+ * key does not subsume `keyColumns`; `out-of-frame` means an index fell outside
+ * the body's output columns.
+ */
+export type EffectiveKeyResult = {
+    proved: true;
+} | {
+    proved: false;
+    reason: 'not-a-key' | 'out-of-frame';
+};
+/**
+ * Decides whether `mv` covers `uc` on `baseTable`. `root` is the optimized body
+ * relation (`db.getPlan(body).getRelations()[0]`); the body's declared `order by`
+ * comes from `mv.selectAst`. See the module doc for the recognition rules.
+ */
+export declare function proveCoverage(root: RelationalPlanNode, mv: MaintainedTableSchema, uc: UniqueConstraintSchema, baseTable: TableSchema, opts?: ProveCoverageOptions): CoverageResult;
+/**
+ * Outcome of {@link walkToConstrainedBase} / {@link proveOneToOneJoin}: the leaf
+ * `TableReferenceNode` over `baseTable` plus the topmost join descended through
+ * (`undefined` for a single-source chain), or a structural failure reason.
+ */
+export type WalkResult = {
+    ok: true;
+    tableRef: TableReferenceNode;
+    topJoin: RelationalPlanNode | undefined;
+} | {
+    ok: false;
+    reason: CoverageFailureReason;
+};
+/**
+ * Walk `root` down to the constrained base table `T`, proving **no row loss**
+ * at every join descended through. Single-source pass-throughs (Filter + the
+ * physical access nodes in {@link PASS_THROUGH}) are transparent links; a binary
+ * join is descended into `T`'s side iff `T` provably keeps every governed row:
+ *
+ *  - **row-preservation** — `T` on the preserving side of an outer join
+ *    (`left`→left subtree, `right`→right subtree); or
+ *  - **referential integrity** — an `inner`/`cross` join whose equi-pairs are a
+ *    NOT-NULL FK / non-null IND from `T` to the lookup table's PK, so enforced RI
+ *    makes every `T` row match exactly one lookup row
+ *    (`innerJoinRetainsConstrainedTable`).
+ *
+ * Every other join type/position (a fanning lookup, `semi`/`anti`, `full`, `T`
+ * on the dropping side, a self-join, aggregation/DISTINCT/set-op) returns
+ * `{ ok: false, reason: 'shape' }`. The **no-fan-out** (≤1) obligation is NOT
+ * checked here — callers run {@link proveJoinNoFanout} on the returned `topJoin`
+ * (see {@link proveOneToOneJoin}); `proveCoverage` keeps its own fan-out gate so
+ * its diagnostic ordering is unchanged. Shared by `proveCoverage` and the
+ * materialized-view 1:1-join gate so the join soundness logic lives in one place.
+ */
+export declare function walkToConstrainedBase(root: RelationalPlanNode, baseTable: TableSchema, opts?: ProveCoverageOptions): WalkResult;
+/**
+ * Prove that `root`'s body is **provably 1:1 on `baseTable`** — exactly one
+ * output row per governed `T` row. Composes the two independent obligations the
+ * coverage prover splits a 1:1 join into: no-row-loss (≥1, via
+ * {@link walkToConstrainedBase}'s descent) and no-fan-out (≤1, via
+ * {@link proveJoinNoFanout} on the captured `topJoin`). For a single-source body
+ * (no join) the fan-out gate is vacuous and this succeeds iff the chain walks to
+ * `T`. The materialized-view 1:1-join gate calls this on the analyzed body to
+ * admit a join shape; `proveCoverage` reuses the same primitives directly so the
+ * join soundness logic is not duplicated.
+ */
+export declare function proveOneToOneJoin(root: RelationalPlanNode, baseTable: TableSchema, opts?: ProveCoverageOptions): WalkResult;
+/**
+ * "Body proves it": true iff the body's output relation is provably unique on
+ * `keyColumns` (output-column indices) via its effective key — declared keys,
+ * FD-closure-derived keys, or the set/all-columns fallback, all read through the
+ * unified `isUnique` surface. This is the obligation primitive the lens prover
+ * consumes for its `obligation: proved` class (e.g. a `group by x, y` body
+ * proving a logical `unique(x, y)`).
+ *
+ * `root` MUST be the optimized body relation (the same node `proveCoverage`
+ * receives: `db.getPlan(body).getRelations()[0]`), so `physical.fds` is
+ * populated — the group-key FD (`propagateAggregateFds`) and projected
+ * source-key FDs live there.
+ *
+ * Soundness notes (why the v1 base-table covering checks do NOT apply here):
+ *  - Ordering: irrelevant — a proof of intrinsic uniqueness needs no ordered
+ *    point-lookup path, so the canonical `group by` body (no ORDER BY) qualifies.
+ *  - PK reconstructibility / observation-equivalence: irrelevant — there is no
+ *    enforcement and no base row to identify; the constraint is on the output.
+ *  - NULL-skip: composes trivially by subsumption. `isUnique` proves *strict*
+ *    key-uniqueness (NULL treated as a value); SQL `unique` is NULL-permissive
+ *    (weaker), so strict-unique ⟹ `unique` holds. No extra NULL handling.
+ *  - Superkey semantics are correct: if the body's real key is a subset of
+ *    `keyColumns`, the (stronger) constraint on the smaller set still implies the
+ *    declared one — `isUnique` already returns true for any superset of a key.
+ *
+ * `keyColumns` are **body-output** column indices; the lens prover owns the
+ * logical-column → output-column mapping (this primitive does no base-table
+ * attribute-id translation — that was a v1 mechanism for the base frame and does
+ * not apply to the output frame). Delegates uniqueness entirely to `isUnique`
+ * (DRY); the value this adds is the named obligation seam, the diagnostic result
+ * shape, and the load-bearing soundness documentation above.
+ */
+export declare function proveEffectiveKeyUnique(root: RelationalPlanNode, keyColumns: readonly number[]): EffectiveKeyResult;
+/**
+ * Equi-pairs of a binary join in attribute-id form, or `undefined` when the join
+ * carries anything beyond an equi-only condition (which could drop `T` rows and
+ * so breaks the no-row-loss proof). Physical joins (`BloomJoin`/`MergeJoin`)
+ * pre-extract their equi-pairs and stash any remainder in `residualCondition`; a
+ * logical `JoinNode` carries a single `condition` that must be a pure
+ * AND-of-column-equalities *every one of which crosses the two join sides*. A
+ * same-side column equality (e.g. `c.x = c.y`) passes the pure-equi shape but is
+ * a single-relation filter `extractEquiPairsFromCondition` drops — so we reject
+ * unless the extracted cross-side pair count matches the conjunct count, rather
+ * than leaning on predicate pushdown to have hoisted it below the join. A bare
+ * cross join (no condition / no equi-pairs) yields an empty list, which the
+ * caller treats as "no FK to align".
+ */
+export declare function pureJoinEquiAttrPairs(join: RelationalPlanNode): readonly EquiJoinPair[] | undefined;
+/**
+ * No-fan-out (≤1) gate for a join body: `T`'s primary key must be a unique key of
+ * `topJoin`'s output relation (`isUnique`), mapped into the join output frame via
+ * stable attribute ids. Checked at the join frame rather than the projected
+ * `root` — see the module doc ("Why the join frame, not the projected root").
+ *
+ * The complementary no-row-loss (≥1) obligation is the structural side/type gate
+ * in the shape walk; name-resolution safety is now the qualifier-aware resolver
+ * (`makeBodyColumnResolver`), which made the former bare-name collision guard
+ * unnecessary.
+ */
+export declare function proveJoinNoFanout(topJoin: RelationalPlanNode, tableRef: TableReferenceNode, baseTable: TableSchema): CoverageResult;
+//# sourceMappingURL=coverage-prover.d.ts.map

package/dist/src/planner/analysis/coverage-prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-prover.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/coverage-prover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2KG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAoD,MAAM,uBAAuB,CAAC;AAElH,OAAO,EAAE,kBAAkB,EAAuB,MAAM,uBAAuB,CAAC;AAUhF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAQjF,MAAM,MAAM,qBAAqB,GAC9B,OAAO,GACP,QAAQ,GACR,mBAAmB,GACnB,mBAAmB,GACnB,oBAAoB,GACpB,mBAAmB,GACnB,sBAAsB,GACtB,mBAAmB,CAAC;AAEvB,MAAM,MAAM,cAAc,GACvB;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,GAChB;IAAE,MAAM,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,CAAC;AAEpD;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;CAClC;AAUD;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAC3B;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,GAChB;IAAE,MAAM,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,WAAW,GAAG,cAAc,CAAA;CAAE,CAAC;AA2C3D;;;;GAIG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,kBAAkB,EACxB,EAAE,EAAE,qBAAqB,EACzB,EAAE,EAAE,sBAAsB,EAC1B,SAAS,EAAE,WAAW,EACtB,IAAI,GAAE,oBAAyB,GAC7B,cAAc,CAoGhB;AAED;;;;GAIG;AACH,MAAM,MAAM,UAAU,GACnB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,kBAAkB,CAAC;IAAC,OAAO,EAAE,kBAAkB,GAAG,SAAS,CAAA;CAAE,GACnF;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,kBAAkB,EACxB,SAAS,EAAE,WAAW,EACtB,IAAI,GAAE,oBAAyB,GAC7B,UAAU,CA2CZ;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,kBAAkB,EACxB,SAAS,EAAE,WAAW,EACtB,IAAI,GAAE,oBAAyB,GAC7B,UAAU,CAQZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,kBAAkB,EACxB,UAAU,EAAE,SAAS,MAAM,EAAE,GAC3B,kBAAkB,CAMpB;AA0KD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,YAAY,EAAE,GAAG,SAAS,CAkBnG;AAqND;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,kBAAkB,EAC5B,SAAS,EAAE,WAAW,GACpB,cAAc,CAchB"}