@descryy/core 0.1.0

package/dist/store/schema.js

@@ -0,0 +1,322 @@
+/**
+ * The graph schema.
+ *
+ * Held as a TypeScript constant rather than a `.sql` file on disk. Reading a
+ * sibling `.sql` at runtime resolves to `src/` under Node's type stripping and
+ * `dist/` after `tsc`, so it needs an asset-copy build step and then behaves
+ * differently in tests than in production — the same class of trap the build
+ * plan flags for the traversal worker entrypoint. A constant has neither
+ * problem and costs nothing but syntax highlighting.
+ *
+ * ## Five corrections to the written schema
+ *
+ * Architecture §24.1 and blueprint §0.8 both describe this schema, and both need
+ * amending. Each is recorded here because the docs are the shared reference and
+ * a silent divergence is worse than either version.
+ *
+ * 1. **No `properties` table.** §11.8 names `nodes`/`edges`/`properties`, but
+ *    §24.1 and blueprint §0.8 both use a JSON column instead. An entity-
+ *    attribute-value table turns every node read into a join and defeats the
+ *    adjacency performance target that §11.8's own traversal decision rests on.
+ *    Language-specific detail lives in the `attrs` JSON column, which nothing
+ *    above the IR reads.
+ *
+ * 2. **No `edges.weight`.** Blueprint §0.8 lists it. But `EdgeWeight` in §12.4
+ *    is tuning config keyed by edge *type*, not a per-row value — storing it per
+ *    row would let 30,000 copies of one tunable drift apart. The single genuine
+ *    per-edge quantity, `CHANGES_WITH`'s co-change count, lives in `attrs`.
+ *
+ * 3. **No `edges.language`.** Both §24.1 and blueprint §0.8 declare it, and
+ *    `IREdge` has no such field — nothing in the IR could ever populate it. A
+ *    column no producer can fill is a column every reader must special-case.
+ *
+ * 4. **`nodes.language` is nullable.** §24.1 declares it `NOT NULL`. DEC-014
+ *    establishes that `API_ENDPOINT` — the cross-language join node — belongs to
+ *    no language, and XL-2 asserts it carries none. `NOT NULL` makes the join
+ *    node unstorable.
+ *
+ * 5. **Composite adjacency indices.** Blueprint §0.8 indexes `edges(source)` and
+ *    `edges(target)`. Every traversal hop filters by edge type as well, and the
+ *    prior-art measurement on this machine found a max in-degree of 1,036 — so
+ *    a single-column index means scanning a thousand rows to keep four.
+ *    `edges(source, type)` and `edges(target, type)` are the real access paths.
+ *
+ * ## Derived vs earned — DEC-017
+ *
+ * The partition is expressed in `DERIVED_TABLES` / `EARNED_TABLES` below rather
+ * than left as prose, because the only thing that makes DEC-017 real is that
+ * `dropDerived()` can be tested to leave the earned side untouched.
+ */
+import { NODE_ID_PREFIX } from "@descryy/ir";
+/**
+ * Bumped when the IR itself changes shape, not when an adapter changes.
+ *
+ * DEC-017: on mismatch, refuse to read, drop derived, rebuild, migrate earned.
+ * A stored graph is derived data and is never the source of truth.
+ */
+export const IR_SCHEMA_VERSION = 4; // 3 -> 4: edge ids move e1: -> e2:, DEC-323
+/**
+ * The tag on every node id, derived from the constant rather than restated.
+ *
+ * A graph tagged otherwise is not ours, and the whole point of the tag is to say
+ * so out loud instead of silently failing to match. Restating it here as a
+ * literal would let the store keep validating the previous scheme after an id
+ * change — the exact failure the tag exists to prevent.
+ */
+export const NODE_ID_SCHEME = NODE_ID_PREFIX.replace(":", "");
+/**
+ * Regenerable from source. Dropping these loses time, never information.
+ */
+export const DERIVED_TABLES = [
+    "nodes",
+    "edges",
+    "unresolved_refs",
+    "file_hashes",
+    "embeddings",
+    "adapter_runs",
+];
+/**
+ * Cannot be regenerated: a run that witnessed an edge fire is gone once the
+ * process exits, and a human's correction of a wrong edge is not in the source
+ * at all. These survive every rebuild.
+ */
+export const EARNED_TABLES = [
+    "observed_edges",
+    "edge_corrections",
+    "incident_links",
+    "pr_scopes",
+];
+/**
+ * Children before parents. Stated explicitly rather than derived by reversing
+ * `DERIVED_TABLES`: `PRAGMA foreign_keys` cannot be changed inside a
+ * transaction, so a drop in the wrong order either fails or leans on cascade
+ * behaviour to rescue it. Neither should be left to the order someone happened
+ * to list the tables in.
+ */
+export const DERIVED_DROP_ORDER = [
+    "embeddings",
+    "unresolved_refs",
+    "edges",
+    "nodes",
+    "file_hashes",
+    "adapter_runs",
+];
+export const SCHEMA_SQL = `
+-- ---------------------------------------------------------------------------
+-- graph_meta — identity of the store itself. Read before anything else.
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS graph_meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+) STRICT;
+
+-- ---------------------------------------------------------------------------
+-- adapter_runs — one row per accepted IRBatch. §24.1's adapter registry state
+-- and DEC-015's invalidation key are the same thing, so they are one table.
+--
+-- id is derived (hash of producer + repo + commit + source files), never an
+-- autoincrement rowid: re-ingesting an identical batch must reuse the same row,
+-- or idempotence is impossible to state.
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS adapter_runs (
+  id                 TEXT PRIMARY KEY,
+  repo               TEXT    NOT NULL,
+  -- The identity scope workspace-scoped ids in this batch were computed under
+  -- (DEC-054). NULL means "this repository alone". Recorded because the scope is
+  -- configuration: once it changes, no node id in this run can be re-derived from
+  -- the row itself, and a workspace typo is otherwise invisible after the fact.
+  workspace          TEXT,
+  commit_sha         TEXT    NOT NULL,
+  adapter_id         TEXT    NOT NULL,   -- the part before '@'
+  adapter_version    TEXT    NOT NULL,   -- the part after '@'
+  produced_by        TEXT    NOT NULL,   -- adapter_id@adapter_version, as written on every row
+  reached_resolution INTEGER NOT NULL,
+  source_files       TEXT    NOT NULL,   -- JSON array; the invalidation key (DEC-015)
+  file_count         INTEGER NOT NULL,
+  written_at         INTEGER NOT NULL
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS idx_runs_adapter ON adapter_runs(adapter_id);
+CREATE INDEX IF NOT EXISTS idx_runs_producer ON adapter_runs(produced_by);
+
+-- ---------------------------------------------------------------------------
+-- nodes
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS nodes (
+  id          TEXT PRIMARY KEY,
+  type        TEXT    NOT NULL,
+  name        TEXT    NOT NULL,
+  file_path   TEXT,                      -- null for fileless types (DEC-014)
+  start_line  INTEGER,
+  end_line    INTEGER,
+  language    TEXT,                      -- correction 4: nullable
+  produced_by TEXT    NOT NULL,
+  resolution  INTEGER NOT NULL,
+  attrs       TEXT    NOT NULL,          -- JSON; correction 1
+  run_id      TEXT    NOT NULL REFERENCES adapter_runs(id) ON DELETE CASCADE
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type);
+CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
+CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file_path);
+CREATE INDEX IF NOT EXISTS idx_nodes_resolution ON nodes(resolution);
+CREATE INDEX IF NOT EXISTS idx_nodes_run ON nodes(run_id);
+
+-- ---------------------------------------------------------------------------
+-- edges. Primary key is hash(from, to, type) per DEC-012, so two adapters
+-- finding the same relationship collide by construction — which is what makes
+-- a merge policy statable at all. 30% of prior-art edges were exact
+-- duplicates, so this is load-bearing rather than tidy.
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS edges (
+  id              TEXT PRIMARY KEY,
+  source          TEXT    NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  target          TEXT    NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  type            TEXT    NOT NULL,
+  resolution      INTEGER NOT NULL,
+  confidence      REAL    NOT NULL,
+  produced_by     TEXT    NOT NULL,
+  observed_by_run TEXT,                  -- present exactly when resolution = 4
+  attrs           TEXT,                  -- JSON or null; corrections 1 and 2
+  run_id          TEXT    NOT NULL REFERENCES adapter_runs(id) ON DELETE CASCADE,
+  CHECK (resolution BETWEEN 0 AND 4),
+  CHECK (confidence BETWEEN 0.0 AND 1.0),
+  CHECK ((resolution = 4) = (observed_by_run IS NOT NULL))
+) STRICT;
+
+-- Correction 5: the real access paths. Every hop filters by type.
+CREATE INDEX IF NOT EXISTS idx_edges_source_type ON edges(source, type);
+CREATE INDEX IF NOT EXISTS idx_edges_target_type ON edges(target, type);
+CREATE INDEX IF NOT EXISTS idx_edges_resolution ON edges(resolution);
+CREATE INDEX IF NOT EXISTS idx_edges_run ON edges(run_id);
+
+-- ---------------------------------------------------------------------------
+-- unresolved_refs — DEC-016. What an adapter saw but could not resolve.
+--
+-- Not edges, because a name-matched guess is a false claim under §11B.1. Not
+-- discarded either, because then §11B.6 recall has no denominator and §20.2's
+-- "not analysable" category has nothing to count. On the prior-art graphs this
+-- is 52-60% of everything emitted.
+-- ---------------------------------------------------------------------------
+-- id is a content hash, never an autoincrement rowid: an insertion-order key
+-- would make the permuted-ingest determinism proof impossible to state, and two
+-- byte-identical references are the same reference.
+CREATE TABLE IF NOT EXISTS unresolved_refs (
+  id           TEXT PRIMARY KEY,
+  from_node_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  edge_type    TEXT NOT NULL,
+  raw_target   TEXT NOT NULL,
+  file_path    TEXT,
+  line         INTEGER,
+  produced_by  TEXT NOT NULL,
+  reason       TEXT NOT NULL,
+  -- DEC-242's attrs.blockedBy/attrs.refusalClass live here, JSON or null --
+  -- same optional-attrs treatment as edges (correction 2), and deliberately
+  -- excluded from id's content hash below: this is classification of a
+  -- refusal, not part of what makes two refusals the same refusal. Added in
+  -- schema version 3 -- DEC-017 governs what that bump costs an existing
+  -- store (drop derived, rebuild; earned tables untouched).
+  attrs        TEXT,
+  run_id       TEXT NOT NULL REFERENCES adapter_runs(id) ON DELETE CASCADE
+) STRICT;
+
+CREATE INDEX IF NOT EXISTS idx_unresolved_from ON unresolved_refs(from_node_id);
+CREATE INDEX IF NOT EXISTS idx_unresolved_target ON unresolved_refs(raw_target);
+CREATE INDEX IF NOT EXISTS idx_unresolved_run ON unresolved_refs(run_id);
+
+-- ---------------------------------------------------------------------------
+-- file_hashes — §11.14 rebuild acceleration. Layer 1 change detection is
+-- defined against this table and v2.1 never declared it.
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS file_hashes (
+  file_path      TEXT PRIMARY KEY,
+  hash           TEXT    NOT NULL,
+  last_parsed_at INTEGER NOT NULL
+) STRICT;
+
+-- ---------------------------------------------------------------------------
+-- embeddings — pointer table only. No vector extension is loaded in this build;
+-- §8.2 keeps vectors in pgvector hosted or a local extension, and a column of
+-- serialised floats with no index would be a scan, not a search.
+-- ---------------------------------------------------------------------------
+CREATE TABLE IF NOT EXISTS embeddings (
+  node_id          TEXT PRIMARY KEY REFERENCES nodes(id) ON DELETE CASCADE,
+  vector_reference TEXT NOT NULL,
+  model_version    TEXT NOT NULL
+) STRICT;
+
+-- ===========================================================================
+-- EARNED — DEC-017. Never dropped. No REFERENCES into the derived tables:
+-- a foreign key would cascade these away with the graph they describe, which
+-- is precisely the outcome the partition exists to prevent.
+-- ===========================================================================
+
+-- R4 evidence. An edge witnessed firing during a live run (§11B.3). This is the
+-- product's core moat and cannot be recomputed from source at any price.
+CREATE TABLE IF NOT EXISTS observed_edges (
+  edge_id     TEXT NOT NULL,
+  run_id      TEXT NOT NULL,
+  from_node_id TEXT NOT NULL,
+  to_node_id  TEXT NOT NULL,
+  edge_type   TEXT NOT NULL,
+  commit_sha  TEXT NOT NULL,
+  observed_at INTEGER NOT NULL,
+  PRIMARY KEY (edge_id, run_id)
+) STRICT;
+
+-- §11B.5. A human said an edge was wrong, or runtime contradicted it. Feeding
+-- this back is how precision improves; losing it repeats the same false claim.
+CREATE TABLE IF NOT EXISTS edge_corrections (
+  edge_id      TEXT PRIMARY KEY,
+  verdict      TEXT    NOT NULL,         -- 'wrong' | 'right'
+  reason       TEXT    NOT NULL,
+  corrected_at INTEGER NOT NULL
+) STRICT;
+
+-- §14.2. One pull request's computed scope, and it is EARNED rather than derived
+-- for a reason that is easy to get backwards.
+--
+-- Everything else on the derived side can be regenerated from source because the
+-- source is what produced it. A PR scope cannot: it was computed against a graph
+-- at one commit, and that graph moves. Recomputing it later answers a DIFFERENT
+-- question and returns a plausible answer to it — so dropping this table does
+-- not lose time, it loses the COMPARISON BASIS. Overlap scoring between two PRs
+-- is only meaningful when both scopes were computed against the same graph, and
+-- nothing in a recomputed row would say that it was not.
+--
+-- graph_commit_sha is therefore not decoration: it is the field that makes two
+-- rows comparable or not, and a reader that ignores it will happily overlap a
+-- scope from last week with one from today and report a number.
+--
+-- scope_json holds the node id set. Kept opaque here on purpose: the shape of a
+-- scope is the scoping layer's business, and a column per dimension would need
+-- a migration every time that layer learns something. What the store guarantees
+-- is that the bytes come back unchanged with the commit they were computed at.
+CREATE TABLE IF NOT EXISTS pr_scopes (
+  pr_id            TEXT    NOT NULL,
+  repo             TEXT    NOT NULL,
+  -- The head commit of the PR itself.
+  head_sha         TEXT    NOT NULL,
+  -- The commit the GRAPH was at when this scope was computed. Two scopes are
+  -- comparable only when these agree.
+  graph_commit_sha TEXT    NOT NULL,
+  scope_json       TEXT    NOT NULL,
+  node_count       INTEGER NOT NULL,
+  computed_at      INTEGER NOT NULL,
+  PRIMARY KEY (repo, pr_id, graph_commit_sha)
+) STRICT;
+
+-- The access path for overlap scoring: every scope computed against one graph.
+-- Without it, comparing N PRs scans the whole table N times.
+CREATE INDEX IF NOT EXISTS idx_pr_scopes_graph ON pr_scopes(repo, graph_commit_sha);
+
+-- Incident and fix-pattern links. Accumulated from real failures over time.
+CREATE TABLE IF NOT EXISTS incident_links (
+  incident_node_id TEXT NOT NULL,
+  target_node_id   TEXT NOT NULL,
+  kind             TEXT NOT NULL,
+  created_at       INTEGER NOT NULL,
+  PRIMARY KEY (incident_node_id, target_node_id, kind)
+) STRICT;
+`;
+//# sourceMappingURL=schema.js.map

package/dist/store/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/store/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,CAAC,4CAA4C;AAEhF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AAE9D;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO;IACP,OAAO;IACP,iBAAiB;IACjB,aAAa;IACb,YAAY;IACZ,cAAc;CACN,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,gBAAgB;IAChB,kBAAkB;IAClB,gBAAgB;IAChB,WAAW;CACH,CAAC;AAKX;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,YAAY;IACZ,iBAAiB;IACjB,OAAO;IACP,OAAO;IACP,aAAa;IACb,cAAc;CAC4B,CAAC;AAE7C,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyNzB,CAAC"}

package/dist/store/writer.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The batch writer — DEC-015.
+ *
+ * "The writer deletes everything previously written by `producedBy` for
+ * `sourceFiles`, then inserts, in one transaction." That sentence hides three
+ * decisions the decision entry does not make, and getting any of them wrong
+ * loses data silently. They are made here and each is tested.
+ *
+ * ## 1. Invalidation matches on adapter *id* and *repo*, not `producedBy` alone
+ *
+ * `producedBy` is `id@version`. Matching the full string would mean an adapter
+ * upgrade never invalidates anything the old version wrote — the two producers
+ * would simply coexist, and the graph would hold both readings of every file
+ * forever. §24.1 is explicit: "an adapter version bump invalidates every node
+ * and edge that adapter produced". So overlap is computed on the id, and the
+ * version is what makes the *stale* rows recognisable.
+ *
+ * `repo` is a second, equally load-bearing part of the same match, added after
+ * a real defect: a store holding more than one repository (`descry-runtime`'s
+ * graph correlator merges a frontend and a backend into one store to trace
+ * across them, per DEC-228) can have two repos using the same adapter with an
+ * overlapping relative file path — `src/index.ts`, `package.json`, anything
+ * common. Without `repo` in this match, writing the second repo's batch reads
+ * as "adapter X re-ran over a file it already owned" and evicts the first
+ * repo's run outright — silent cross-repository data loss, not a wrong
+ * answer. `invalidateAdapter` below is intentionally *not* repo-scoped — its
+ * own contract is "every repo," a different, explicitly global operation.
+ *
+ * ## 2. Prior runs are matched by file-set *overlap*, not equality
+ *
+ * A batch is the unit of invalidation, but the batch that previously owned a
+ * file may have covered a different set of files. Deleting only exact-matching
+ * runs leaves two rows for the same symbol; deleting only the intersection is
+ * impossible, because an edge has no file. So every prior run of the same
+ * adapter that touches *any* of these files is replaced whole — and the files
+ * it covered that this batch does not re-supply are reported as `evictedFiles`.
+ * Reporting them is the honest-degradation rule (principle 7): the caller is
+ * told what fell out, rather than discovering it as a missing edge next week.
+ *
+ * ## 3. A run also cleans up after its own previous write
+ *
+ * The run id is content-derived from producer, repo, commit and file set — not
+ * from the nodes. So an adapter re-run at the same commit over the same files
+ * lands on the *same* run id, and "delete the prior runs" excludes it by
+ * definition. Without a self-clean pass, rows that run no longer produces stay
+ * forever: the upsert refreshes what is still there and nothing removes what is
+ * not. Every write therefore ends by deleting its own run's rows that this batch
+ * did not supply.
+ *
+ * ## 4. Re-supplied nodes are updated, not deleted and recreated
+ *
+ * A node id is stable across file moves by construction (DEC-004), so re-parsing
+ * a file normally yields the ids that were already there. Deleting a prior run's
+ * nodes wholesale would cascade away every edge *other* runs had pointing into
+ * them, and those runs will not be re-run. Instead: upsert the ids this batch
+ * supplies, then delete the prior run — whose remaining nodes are exactly those
+ * it no longer produces. Edges into a node that genuinely disappeared do cascade
+ * away, and are reported as `orphanedEdges`, because keeping an edge to a node
+ * that no longer exists is the wrong-edge failure the precision rule forbids.
+ */
+import { type IRBatch } from "@descryy/ir";
+import type { SqlDriver } from "./driver/driver.ts";
+export interface WriteResult {
+    readonly runId: string;
+    readonly nodesWritten: number;
+    readonly edgesWritten: number;
+    readonly unresolvedWritten: number;
+    /** Prior runs of the same adapter that this batch replaced. */
+    readonly runsReplaced: number;
+    /**
+     * Files a replaced run covered that this batch did not re-supply. Their rows
+     * are gone and will not come back until the adapter is re-run over them.
+     * Non-empty is not an error, but it is never silent.
+     */
+    readonly evictedFiles: readonly string[];
+    /**
+     * Edges removed because an endpoint node ceased to exist. Always reported:
+     * this is the one place the store deletes something nobody asked it to.
+     */
+    readonly orphanedEdges: number;
+}
+export interface WriteOptions {
+    /** Injectable so the determinism proof is not at the mercy of the wall clock. */
+    readonly now?: () => number;
+}
+/**
+ * A run id derived from the batch's content, never a counter.
+ *
+ * Re-ingesting an identical batch must land on the same row, or "idempotent"
+ * cannot even be stated as a property. `sourceFiles` is sorted first so that an
+ * adapter listing the same files in a different order does not create a second
+ * run for identical work.
+ */
+export declare function runIdFor(batch: IRBatch): string;
+/**
+ * Write one normalised batch. **Input must already have passed the Normaliser** —
+ * this function does no validation, on purpose. Two validators drift; one
+ * validator at the boundary is a boundary.
+ */
+export declare function writeBatch(driver: SqlDriver, batch: IRBatch, options?: WriteOptions): WriteResult;
+/**
+ * Remove everything an adapter ever produced, at every version, for every repo.
+ *
+ * §24.1's invalidation rule, as its own operation rather than a side effect of
+ * writing. It is deliberately separate from `writeBatch`: an upgraded adapter
+ * usually re-runs over a subset of files first, and folding this into the write
+ * path would make a partial re-run delete data it was never going to replace.
+ */
+export declare function invalidateAdapter(driver: SqlDriver, adapterId: string): {
+    runsRemoved: number;
+};
+/** §11.14 rebuild acceleration. Layer 1 change detection reads this. */
+export declare function putFileHash(driver: SqlDriver, filePath: string, hash: string, parsedAt: number): void;
+/** Nodes touching these files, unchanged. */
+export declare function getFileHash(driver: SqlDriver, filePath: string): string | undefined;
+//# sourceMappingURL=writer.d.ts.map

package/dist/store/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/store/writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AAGH,OAAO,EAAyB,KAAK,OAAO,EAAmC,MAAM,aAAa,CAAC;AAGnG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CAC7B;AAYD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAI/C;AAmCD;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,YAAiB,GACzB,WAAW,CA0Nb;AAYD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAK/F;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,IAAI,CAON;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAInF"}