@vibe-agent-toolkit/cli 0.2.0-rc.2 → 0.2.0-rc.3

package/dist/commands/cache/index.d.ts

@@ -1,68 +1,18 @@
 /**
- * Cache command group, plus the root-level `--no-cache` control surface.
- *
- * Both live here so the flag and the command that cleans up after it stay in one
- * place: `--no-cache` decides whether this run *writes* to the caches, `vat cache
- * clear` decides whether the caches *survive*.
+ * Cache command group.
+ *
+ * The paired `--no-cache` control surface lives in `./cache-control.js`:
+ * `--no-cache` decides whether this run *writes* to the caches, `vat cache
+ * clear` decides whether the caches *survive*. They are separate modules only
+ * because `bin.ts` registers the flag on every invocation and must not pay for
+ * this command's imports to do it.
+ *
+ * ⛔ Do NOT re-export `cache-control.js` from here for convenience. Importing it
+ * through this module pulls `./clear.js` and the whole resources package behind
+ * it — the exact ~1.2s that splitting the file removed — so a re-export leaves
+ * the expensive path one identical-looking import away, with nothing pinning
+ * the cheap one. Import from `./cache-control.js` directly.
  */
 import { Command } from 'commander';
-/**
- * Root options this module reads. Commander represents `--no-cache` as the
- * POSITIVE key `cache` — `true` by default, `false` only when the negated flag
- * is passed. It NEVER produces `noCache`; reading that key is the exact bug that
- * made three flags in this package silent no-ops (see
- * `test/commands/commander-option-keys.test.ts`).
- */
-export interface CacheControlOptions {
-    cache?: boolean;
-}
-/**
- * Register the root-level `--no-cache` flag and the hook that gives it effect.
- *
- * ## Why this sets an environment variable instead of plumbing a flag
- *
- * `vat validate`, `vat verify` and `vat build` enumerate nothing in their own
- * process: each `spawnSync`s the vat binary once per phase, and the child is
- * what parses the corpus. A flag parsed in the parent therefore never reaches
- * the process whose caching it is supposed to control, whereas `process.env` is
- * inherited by every child for free. `bin.ts` already leans on exactly that for
- * `VAT_CONTEXT` / `VAT_CONTEXT_PATH`.
- *
- * `VAT_CACHE=0` is read by `ParseCache` (packages/resources/src/parse-cache.ts)
- * per construction, never at module load, so setting it from a `preAction` hook
- * — after Commander has parsed, before any command body runs — is observed.
- *
- * ## The collision with `vat resources validate --no-cache`
- *
- * This root program does NOT use `enablePositionalOptions()`, so Commander scans
- * the WHOLE argv for root options, including everything after the subcommand
- * name. That is the same mechanism that let a root `-v` shadow the subcommands'
- * own `-v, --verbose` (see the incident recorded in `bin.ts`). Measured against
- * commander 12: `vat resources validate docs --no-cache` leaves the ROOT with
- * `cache: false` and the SUBCOMMAND with `cache: true` — the subcommand's
- * identically-named flag is swallowed before it ever sees it, which would have
- * silently re-enabled the external-URL cache the flag exists to bypass.
- *
- * Rather than break a shipped flag, the hook hands the value back down to
- * whichever action command declares a `cache` option of its own. `--no-cache` is
- * a superset — every cache off — so the handoff is a strengthening, never a
- * reversal.
- *
- * @param program - The root program to register the flag and hook on
- */
-export declare function registerCacheControl(program: Command): void;
-/**
- * Apply the root `--no-cache` decision: export it to child processes, and hand
- * it down to an action command that declares its own `cache` option.
- *
- * Exported so a test can drive it from real parsed options rather than from a
- * hand-built bag. Deliberately does nothing when the flag was not passed — a
- * toggle that writes `VAT_CACHE=1` by default would be indistinguishable from
- * one that is always on.
- *
- * @param rootOptions - Options bag from the ROOT program
- * @param actionCommand - The command whose action is about to run
- */
-export declare function applyCacheControl(rootOptions: CacheControlOptions, actionCommand: Command): void;
 export declare function createCacheCommand(): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/cache/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAM3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI,CAWhG;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CA6D5C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,kBAAkB,IAAI,OAAO,CA2E5C"}

package/dist/commands/cache/index.js

@@ -1,75 +1,20 @@
 /**
- * Cache command group, plus the root-level `--no-cache` control surface.
+ * Cache command group.
  *
- * Both live here so the flag and the command that cleans up after it stay in one
- * place: `--no-cache` decides whether this run *writes* to the caches, `vat cache
- * clear` decides whether the caches *survive*.
+ * The paired `--no-cache` control surface lives in `./cache-control.js`:
+ * `--no-cache` decides whether this run *writes* to the caches, `vat cache
+ * clear` decides whether the caches *survive*. They are separate modules only
+ * because `bin.ts` registers the flag on every invocation and must not pay for
+ * this command's imports to do it.
+ *
+ * ⛔ Do NOT re-export `cache-control.js` from here for convenience. Importing it
+ * through this module pulls `./clear.js` and the whole resources package behind
+ * it — the exact ~1.2s that splitting the file removed — so a re-export leaves
+ * the expensive path one identical-looking import away, with nothing pinning
+ * the cheap one. Import from `./cache-control.js` directly.
  */
 import { Command } from 'commander';
 import { cacheClearCommand } from './clear.js';
-/**
- * Register the root-level `--no-cache` flag and the hook that gives it effect.
- *
- * ## Why this sets an environment variable instead of plumbing a flag
- *
- * `vat validate`, `vat verify` and `vat build` enumerate nothing in their own
- * process: each `spawnSync`s the vat binary once per phase, and the child is
- * what parses the corpus. A flag parsed in the parent therefore never reaches
- * the process whose caching it is supposed to control, whereas `process.env` is
- * inherited by every child for free. `bin.ts` already leans on exactly that for
- * `VAT_CONTEXT` / `VAT_CONTEXT_PATH`.
- *
- * `VAT_CACHE=0` is read by `ParseCache` (packages/resources/src/parse-cache.ts)
- * per construction, never at module load, so setting it from a `preAction` hook
- * — after Commander has parsed, before any command body runs — is observed.
- *
- * ## The collision with `vat resources validate --no-cache`
- *
- * This root program does NOT use `enablePositionalOptions()`, so Commander scans
- * the WHOLE argv for root options, including everything after the subcommand
- * name. That is the same mechanism that let a root `-v` shadow the subcommands'
- * own `-v, --verbose` (see the incident recorded in `bin.ts`). Measured against
- * commander 12: `vat resources validate docs --no-cache` leaves the ROOT with
- * `cache: false` and the SUBCOMMAND with `cache: true` — the subcommand's
- * identically-named flag is swallowed before it ever sees it, which would have
- * silently re-enabled the external-URL cache the flag exists to bypass.
- *
- * Rather than break a shipped flag, the hook hands the value back down to
- * whichever action command declares a `cache` option of its own. `--no-cache` is
- * a superset — every cache off — so the handoff is a strengthening, never a
- * reversal.
- *
- * @param program - The root program to register the flag and hook on
- */
-export function registerCacheControl(program) {
-    program.option('--no-cache', "Disable VAT's disk caches for this run (also applies to spawned phases)");
-    program.hook('preAction', (_thisCommand, actionCommand) => {
-        applyCacheControl(program.opts(), actionCommand);
-    });
-}
-/**
- * Apply the root `--no-cache` decision: export it to child processes, and hand
- * it down to an action command that declares its own `cache` option.
- *
- * Exported so a test can drive it from real parsed options rather than from a
- * hand-built bag. Deliberately does nothing when the flag was not passed — a
- * toggle that writes `VAT_CACHE=1` by default would be indistinguishable from
- * one that is always on.
- *
- * @param rootOptions - Options bag from the ROOT program
- * @param actionCommand - The command whose action is about to run
- */
-export function applyCacheControl(rootOptions, actionCommand) {
-    if (rootOptions.cache !== false)
-        return;
-    process.env['VAT_CACHE'] = '0';
-    // `attributeName()`, not `name()`: for `--no-cache` the latter returns
-    // 'no-cache', so a check written against it never matches and the handoff
-    // above becomes a no-op that looks like it works.
-    if (actionCommand.options.some((option) => option.attributeName() === 'cache')) {
-        actionCommand.setOptionValue('cache', false);
-    }
-}
 export function createCacheCommand() {
     const cache = new Command('cache');
     cache
@@ -77,13 +22,20 @@ export function createCacheCommand() {
         .helpCommand(false)
         .addHelpText('after', `
 Description:
-  VAT keeps three disposable caches under <tmpdir>/.vat-cache: parse facts
-  keyed by file content, external-URL validation results, and per-OS-user
-  authenticated-link content. None of them is durable — recovery is always
-  "rescan", and the OS temp purge is the eviction policy.
+  VAT keeps four disposable caches under <tmpdir>/.vat-cache: parse facts
+  keyed by file content, external-URL validation results, per-OS-user
+  authenticated-link content, and the projection store — a SQLite database
+  holding one whole scanned tree per entry, and by far the largest of the
+  four. None of them is durable — recovery is always "rescan".
+
+  Only the projection store evicts anything on its own: it keeps the few most
+  recently written trees per root and drops the rest as it writes. The other
+  three rely on the OS temp purge, and every one of them is reclaimed in full
+  by vat cache clear.
 
   To run WITHOUT the caches rather than remove them, use --no-cache on any
-  command (or VAT_CACHE=0), which also applies to spawned phases.
+  command (or VAT_CACHE=0), which also applies to spawned phases and to the
+  projection store.
 
 Example:
   $ vat cache clear                    # Reclaim the temp-directory cache tree
@@ -97,9 +49,11 @@ Example:
         .addHelpText('after', `
 Description:
   Removes <tmpdir>/.vat-cache in its entirety — the parse cache, the
-  external-URL validation cache, and the per-OS-user authenticated-link cache.
-  Every one of them is disposable by design: the next run repopulates what it
-  needs, so the only cost of clearing is one cold pass.
+  external-URL validation cache, the per-OS-user authenticated-link cache, and
+  the projection store (<namespace>/projection-<shape>/projection.db), which is
+  usually most of the bytes this reclaims. Every one of them is disposable by
+  design: the next run repopulates what it needs, so the only cost of clearing
+  is one cold pass.
 
   Runs regardless of --no-cache / VAT_CACHE=0. Turning caching off must not
   disarm the one command that reclaims the space.
@@ -107,16 +61,21 @@ Description:
   A cache directory that does not exist is not an error — nothing to remove is
   a successful clear.
 
+  The tree is shared by every VAT on the machine, so another run writing into
+  it can make the delete stop part-way. That is reported as status: partial,
+  naming what went and what stayed, rather than failing with no account of it.
+
 Output:
   - cacheDir: absolute path that was targeted
   - existed: whether the directory was there at all
-  - removed: top-level entries that were deleted
-  - entriesRemoved / bytesRemoved: file count and total size, measured before
-    deletion
+  - removed: top-level entries that are now gone
+  - remaining / reason: what survived a partial clear, and why (partial only)
+  - entriesRemoved / bytesRemoved: file count and total size actually removed
 
 Exit Codes:
   0 - Cache cleared (or already absent)
-  2 - Could not remove the cache (permissions, busy file)
+  1 - Cleared only in part, because something else is using the tree
+  2 - Could not read or target the cache at all (permissions, unexpected layout)
 
 Example:
   $ vat cache clear                    # Reclaim the temp-directory cache tree

package/dist/commands/cache/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAA0B,MAAM,YAAY,CAAC;AAavE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAgB;IACnD,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,yEAAyE,CAAC,CAAC;IAExG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,EAAE;QACxD,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAuB,EAAE,aAAa,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAgC,EAAE,aAAsB;IACxF,IAAI,WAAW,CAAC,KAAK,KAAK,KAAK;QAAE,OAAO;IAExC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;IAE/B,uEAAuE;IACvE,0EAA0E;IAC1E,kDAAkD;IAClD,IAAI,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC;QAC/E,aAAa,CAAC,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC,KAAK;SACF,WAAW,CAAC,iEAAiE,CAAC;SAC9E,WAAW,CAAC,KAAK,CAAC;SAClB,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;CAYL,CACI,CAAC;IAEJ,KAAK;SACF,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gEAAgE,CAAC;SAC7E,MAAM,CAAC,KAAK;QACX,MAAM,iBAAiB,CAAC,IAAI,CAAC,eAAe,EAAuB,CAAC,CAAC;IACvE,CAAC,CAAC;SACD,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BL,CACI,CAAC;IAEJ,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAA0B,MAAM,YAAY,CAAC;AAGvE,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC,KAAK;SACF,WAAW,CAAC,iEAAiE,CAAC;SAC9E,WAAW,CAAC,KAAK,CAAC;SAClB,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;CAmBL,CACI,CAAC;IAEJ,KAAK;SACF,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gEAAgE,CAAC;SAC7E,MAAM,CAAC,KAAK;QACX,MAAM,iBAAiB,CAAC,IAAI,CAAC,eAAe,EAAuB,CAAC,CAAC;IACvE,CAAC,CAAC;SACD,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCL,CACI,CAAC;IAEJ,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/commands/claude/budget.d.ts

@@ -0,0 +1,157 @@
+/**
+ * `vat claude budget [paths...]` — is the always-loaded context at a working
+ * location over its budget?
+ *
+ * ## Why this is a command and not a check inside `vat resources validate`
+ *
+ * It used to be one: default-on, with a `--no-context-budget` opt-out. That is
+ * gone, in both directions — `vat resources validate` has no knowledge of the
+ * budget at all any more, not a flag, not a default. The ruling behind the move
+ * is short: *a validation run must not emit findings nobody asked for.* An
+ * `info` finding attached to a lane people run for link and anchor errors is a
+ * finding they scroll past, and a check people scroll past is a check they
+ * eventually silence.
+ *
+ * ## The sibling split: `context` QUERIES, `budget` CHECKS
+ *
+ * `vat claude context` answers a question and
+ * never gates — totals, admissions, the declared limits, no verdict, always
+ * exit 0. This command is the other half of that pair: it applies a THRESHOLD,
+ * produces findings with severities an adopter can configure, and lets an
+ * adopter who promotes the code to `error` fail their build with it. Two verbs
+ * because they are two acts, and folding a verdict into the query would make
+ * the query's number a number people learn to stop reading.
+ *
+ * ## Everything below is orchestration — deliberately
+ *
+ * Which directories exist, what each pays, and whether that is over budget are
+ * all decided in `@vibe-agent-toolkit/resources` (`buildClaudeContextPopulation`
+ * and `sweepAlwaysLoadedBudgets`); the wording and grouping of the findings in
+ * `utils/context-budget-issues.ts`; severity resolution in the two shared
+ * filters every other lane runs. This module populates one tree, calls them in
+ * order, and renders. It decides nothing about context loading of its own,
+ * which is the CLI-stays-dumb rule applied to the lane where the temptation is
+ * strongest.
+ *
+ * ⛔ The threshold is never re-spelled here. It is a MEASURED quantity that
+ * lives beside the detector (`DEFAULT_ALWAYS_LOADED_CONTEXT_TOKENS`), and a
+ * literal in this package would be a second source of truth that nothing
+ * compares.
+ *
+ * ## The stated bounds ride ONCE on the REPORT, in every format
+ *
+ * The sibling query publishes 23 stated limits; this command applies a threshold
+ * to the same measurement, so it publishes {@link ALWAYS_LOADED_BUDGET_LIMITS}
+ * and {@link CLAUDE_CONTEXT_BOUNDS_STATEMENT} beside its verdict — the half that
+ * GATES is the half whose bounds a reader most needs. Both are imported, never
+ * restated: the sentence is domain content owned beside the list it frames.
+ *
+ * ⛔ They belong to the REPORT, never to a finding. A per-finding copy is the
+ * defect this lane already shipped once on the query side, and it is invisible to
+ * any assertion that checks presence rather than counting occurrences.
+ */
+import { type BudgetSweep, type StatedLimit } from '@vibe-agent-toolkit/resources';
+import { type SeverityCounts, type ValidationIssue } from '@vibe-agent-toolkit/schema';
+import { Command } from 'commander';
+/** How the report is rendered. `text` is for a person; the other two are for a program. */
+export type BudgetOutputFormat = 'text' | 'yaml' | 'json';
+/** Flags `vat claude budget` accepts. */
+export interface ClaudeBudgetOptions {
+    format?: BudgetOutputFormat;
+    debug?: boolean;
+}
+/**
+ * The report one run emits.
+ *
+ * The three sweep counters ride beside the findings and describe the WHOLE
+ * tree, not the scope: a scope narrows what is reported, never what was
+ * measured. Publishing them is what keeps an empty `findings` legible — "9
+ * chains checked, none over budget" and "nothing was checked" are different
+ * answers and must not render identically.
+ */
+export interface BudgetReport {
+    readonly root: string;
+    /** The budget every chain was measured against, in tokens. */
+    readonly threshold: number;
+    /** The root-relative directories asked about. `''` is the whole tree. */
+    readonly scope: readonly string[];
+    /** Requested paths that named no working location — see `scopeSweepToPaths`. */
+    readonly unmatchedScope: readonly string[];
+    readonly status: 'success' | 'warning' | 'error';
+    readonly issueCounts: SeverityCounts;
+    /** Working locations the sweep evaluated, across the whole tree. */
+    readonly workingLocations: number;
+    /** Distinct instruction chains among them — the queries the sweep really issued. */
+    readonly distinctChains: number;
+    /** Locations whose representative the projection never realized. Counted, never zeroed. */
+    readonly skippedUnknownLocations: number;
+    readonly findings: readonly ValidationIssue[];
+    /**
+     * What this verdict does not settle, in either direction. Stated ONCE.
+     *
+     * ⛔ On the report beside `threshold`, never on a finding. These bound the
+     * MEASUREMENT METHOD, not any one chain — a finding carrying its own copy
+     * reads as though that chain had caveats of its own, and repeated across a
+     * sweep it is pure byte-identical duplication.
+     */
+    readonly boundsStatement: string;
+    /** The signed over/under-report bounds on the method. Stated ONCE. */
+    readonly limits: readonly StatedLimit[];
+}
+/**
+ * Create the `vat claude budget [paths...]` command.
+ *
+ * @returns The configured Commander command
+ */
+export declare function createBudgetCommand(): Command;
+/**
+ * Action handler for `vat claude budget [paths...]`.
+ *
+ * @param pathArgs - Directories to check; empty means the whole tree
+ * @param options - The command's flags
+ */
+export declare function claudeBudgetCommand(pathArgs: readonly string[], options: ClaudeBudgetOptions): Promise<void>;
+/** Everything {@link buildReport} needs, bundled past the lint gate's parameter ceiling. */
+export interface ReportInput {
+    readonly root: string;
+    readonly threshold: number;
+    readonly scope: readonly string[];
+    readonly sweep: BudgetSweep;
+    readonly scoped: {
+        readonly unmatchedScope: readonly string[];
+    };
+    readonly findings: readonly ValidationIssue[];
+}
+/**
+ * Assemble the report from the run's parts.
+ *
+ * ⛔ The counters come from the UNSCOPED sweep. They answer "what was measured",
+ * and a scope changes only what is reported — sourcing them from the narrowed
+ * view would let `vat claude budget docs` claim the tree has one chain.
+ *
+ * ⛔ This is the ONE place the stated bounds enter the machine-readable output,
+ * and keeping it a single assignment is what makes "stated once" structural
+ * rather than a habit: there is no per-finding site left where a copy could be
+ * reintroduced. They are attached unconditionally — a run that flagged nothing
+ * used the same method, and a reader acting on "within budget" needs them most.
+ *
+ * ⛔ Exported so it can be TESTED. What has to be pinned is a COUNT — that the
+ * block appears exactly once across a MULTI-finding report — and a presence
+ * check passes identically with a copy per finding.
+ *
+ * @param input - The run's parts
+ * @returns The report, ready to serialize
+ */
+export declare function buildReport(input: ReportInput): BudgetReport;
+/**
+ * Render the report for a person.
+ *
+ * ⛔ Exported so the "stated once" property can be pinned in TEXT as well as in
+ * json. The two renderings are separate code paths and this lane has already
+ * shipped a defect where they disagreed while each looked right alone.
+ *
+ * @param report - The report
+ * @returns The text rendering, newline-terminated
+ */
+export declare function renderReportText(report: BudgetReport): string;
+//# sourceMappingURL=budget.d.ts.map

package/dist/commands/claude/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../../src/commands/claude/budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EAML,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAmB5C,2FAA2F;AAC3F,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAE1D,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,gFAAgF;IAChF,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAC;IACrC,oEAAoE;IACpE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,oFAAoF;IACpF,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,2FAA2F;IAC3F,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;IAC9C;;;;;;;OAOG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC;CACzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAmE7C;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAkCf;AAED,4FAA4F;AAC5F,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;IAChE,QAAQ,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAgB5D;AAkFD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAa7D"}