@gate-forge/witness 0.0.0-stage → 0.8.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 UKD
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,115 @@
-# Temporary Holding Version
+# @gate-forge/witness
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The runner-neutral Gateforge witness: the loopback HTTP witness that turns a
+test run's traffic into machine-verifiable evidence, plus the contract every
+test runner implements to feed it.
+
+## Why this package exists
+
+Gateforge used to only work for Playwright users. The reason was never the
+evidence model — it was where the code sat: the witness service and the
+per-test session client lived inside a package named after one runner.
+
+The witness is an HTTP proxy plus a DB/queue reader, and a proxy does not care
+who sends the traffic. Everything runner-specific collapses into four jobs,
+declared by the `RunnerAdapter` contract:
+
+| Job | Method | What a runner must provide |
+| --- | --- | --- |
+| List | `enumerate()` | The tests, BEFORE the run. The expected set is fixed first. |
+| Tag | `childEnv()` | The per-test identity: a session proxy origin or a signed session header. |
+| Run | `execute()` | The suite, under trusted supervision with a finite timeout. |
+| Read | `parseResults()` | The outcome in a STRUCTURED format (native JSON or JUnit XML) — never terminal colors. |
+
+## The conformance suite
+
+`runRunnerAdapterContract(adapter, host)` is the one suite every adapter must
+pass. The suite owns the assertions; a `RunnerContractHost` owns only the
+runner mechanics (which files to materialize, how to spawn the runner, where
+its report lands). Grading always runs through `superviseExecution` from
+`@gate-forge/core` — the same neutral completeness rules a Playwright run is
+graded by.
+
+It checks that the adapter:
+
+- enumerates the expected set, and reports a project with **no** tests as
+  `unavailable` rather than as an empty successful run;
+- tags every session with its own value, and never leaks parent-side wiring
+  (the verifier key, the obligations, spool or CI paths) to the runner child;
+- reads an unreadable report as incomplete instead of inventing outcomes;
+- attributes **nothing** to a test whose runner identity never arrived;
+- runs a suite itself (`execute`), not just reports;
+- and blocks, with a typed cause, on a failing, skipping, retried, unplanned or
+  zero-test run.
+
+## Trust rules (unchanged)
+
+- A runner's own "passed" is never authority. `parseResults` produces reporter
+  INPUT; the verdict comes from supervision plus the witness-issued session
+  trace.
+- A request without a valid session tag is never attributed to a test.
+- Additions only: existing JSON keys, cause codes, exit codes, config keys and
+  receipts are frozen, and every new setting defaults to today's behavior.
+
+## Adapters
+
+The runner-neutral parts live here: the `RunnerAdapter` contract, the
+session tagging types, and the conformance suite. Each adapter
+implementation lives beside the runner machinery it drives (the shared
+collection/report/spool code the supervised run already uses), which is
+why the Playwright adapter has always lived in `@gate-forge/pack-playwright`:
+
+| Runner | Where | Tag channel |
+| --- | --- | --- |
+| Playwright | `@gate-forge/pack-playwright` (`discovery/playwright-runner-adapter.ts`) | session proxy |
+| Cypress | `@gate-forge/pack-playwright` (`discovery/cypress-runner-adapter.ts`) | session proxy |
+| pytest + httpx | `@gate-forge/pack-playwright` (`discovery/pytest-runner-adapter.ts` + `python/gateforge_pytest_plugin.py`) | session proxy |
+| Jest/Vitest + supertest | `@gate-forge/pack-playwright` (`discovery/vitest-runner-adapter.ts`) | session proxy |
+
+An in-process test client (supertest, FastAPI `TestClient`) calls the app
+without going through the proxy. The adapters REFUSE that mode with a typed
+message instead of passing it silently — the request never reaches the witness,
+so it can never be evidence.
+
+## Per-session adapter identity
+
+A per-tenant singleton row (a table whose UNIQUE constraint includes the
+tenant scope column) cannot be read from the fixed witness-environment
+seat: that seat's tenant already has the row. A test that creates the
+tenant first registers that tenant's login for ITS OWN session through
+the session-authenticated `POST /sessions/identity` (`seat` plus the
+credential `values`, keyed by the same witness env var names the adapter
+seat declares). Kit adapters resolve the seat by `ctx.sessionId` first and
+the process-global environment seat otherwise.
+
+The whole of its authority is *who the engine reads as, for one session*.
+The engine still performs every read; a wrong tenant makes the row unfound
+(the app answers 403/404 and the entity grades absent); the identity is
+keyed by that session id, cannot be registered for a foreign or ended
+session, and is dropped when the session closes or is released; and the
+credential never reaches a record, the run state, a log or a report. The
+full argument is in `packages/cli/guides/TEST-ENVIRONMENT.md`. Without a
+registration the read is byte-identical to today's behavior.
+
+## The operator's fixture/actor provider
+
+A declared behavior case names a `fixture` recipe and an `actor`. The witness
+materializes both before it drives the case, through the module named by
+`GATEFORGE_FIXTURE_PROVIDER` (loaded by `witness/bin.ts` at startup; a
+witness started without one simply has no cases to prepare).
+
+The module's default export is `{ prepare(input), release(leaseId),
+resolveCredential(credentialRef) }`. `prepare` returns `{ leaseId, namespace,
+subjects, actors }` with SERVER-ISSUED subject identities; `release` drops what
+that lease provisioned; `resolveCredential` turns a lease `credentialRef` into
+request material and runs in this process, so a secret never leaves it.
+
+The provider is engine-side code and the only caller of its own provisioning
+HTTP calls. The suite never imports it, and nothing it returns can mint
+evidence — it only supplies the subjects a case drives, so a case's proof still
+comes from the request the witness issued and the state it read itself. A
+repository should therefore exclude the provider from its product scan scope
+(`.gateforge.yml` `project.paths.exclude`, matching
+`classification-policy.yml` `scanRoots`), or the engine's own provisioning
+traffic is reported as unresolved application call sites. See
+`example/behavior/fixtures/fixture-provider.mjs` for a working provider.

package/dist/adapter/contract-suite.d.ts

@@ -0,0 +1,167 @@
+/**
+ * The runner-adapter contract suite (plan 2026-09-25 phase 0).
+ *
+ * One shared conformance suite every runner adapter must pass. The suite
+ * owns the ASSERTIONS; a {@link RunnerContractHost} owns only the
+ * runner mechanics (which files to materialize, how to spawn the runner,
+ * where its structured report lands). Nothing here parses a runner's
+ * output — the adapter does that, and the suite checks the adapter did
+ * it honestly.
+ *
+ * The suite is deliberately framework-free (no test runner import): each
+ * adapter's package runs {@link runRunnerAdapterContract} and asserts
+ * the returned violation list is empty. That keeps one implementation
+ * of "what a runner adapter must do" instead of N look-alike copies.
+ *
+ * Grading always runs through `superviseExecution`
+ * (`@gate-forge/core`) — the neutral completeness rules. The suite never
+ * invents a verdict of its own, so a contract pass means the adapter
+ * feeds the same enforcement point a Playwright run feeds.
+ */
+import { type RunnerExecutionEnvelope } from '@gate-forge/core';
+import type { RunnerAdapter, RunnerExecuteRequest, RunnerRawResults } from './contract.js';
+/**
+ * The behaviours a conforming adapter must distinguish. Each one is a
+ * way a run can silently look green when it is not.
+ */
+export type ContractScenarioKind = 
+/** Every planned test passes on its first attempt. */
+'pass'
+/** A planned test fails. */
+ | 'fail'
+/** A planned test is skipped — nothing was proven by it. */
+ | 'skip'
+/** A planned test needed a second attempt (required retries are zero). */
+ | 'retry'
+/** The runner ran a test that was not in the expected set. */
+ | 'unplanned'
+/** The runner ran nothing at all. */
+ | 'zero'
+/** The runner ran the suite but never tagged its traffic. */
+ | 'untagged';
+/** One contract scenario: the expected set plus the behaviour to produce. */
+export interface ContractScenario {
+    kind: ContractScenarioKind;
+    /** Exact logical keys the run is expected to cover (fixed pre-run). */
+    expectedLogicalKeys: readonly string[];
+    /** Repo-relative posix file the planned tests live in. */
+    file: string;
+    /** Full title path of the planned tests. */
+    titlePath: readonly string[];
+    /** Runner project, or null. */
+    project: string | null;
+}
+/**
+ * One observed execution of a scenario: the runner's REAL structured
+ * report plus the envelope the adapter read out of it.
+ *
+ * The envelope is always `adapter.parseResults(raw)` — never the
+ * runner's own verdict and never a hand-written one. Grading the
+ * adapter's reading of real runner output is the whole point: a runner
+ * that prints "0 failed" proves nothing until an adapter has turned it
+ * into outcomes supervision can compare against the expected set.
+ */
+export interface ContractObservation {
+    /** `adapter.parseResults(raw)` — the adapter's structured envelope. */
+    envelope: RunnerExecutionEnvelope;
+    /** The runner's structured report, exactly as the runner emitted it. */
+    raw: RunnerRawResults;
+    /**
+     * Why the host produced this report outside `adapter.execute` (e.g.
+     * the scenario cannot occur under the supervised policy, which forces
+     * zero retries). Empty when `adapter.execute` produced it.
+     */
+    note?: string;
+}
+/**
+ * The runner-specific mechanics a contract run needs. An adapter
+ * supplies none of these: the suite drives the adapter and asserts.
+ */
+export interface RunnerContractHost {
+    /** Runner name under test (must equal the adapter's). */
+    readonly runner: string;
+    /**
+     * The runner project the expected set is bound to, or null when the
+     * runner reports none. It is part of the identity join key, so the
+     * suite cannot guess it: the host owns the runner's own naming.
+     */
+    readonly project: string | null;
+    /**
+     * The scenario FILE + TITLE PATH identity the runner natively
+     * collects, when the runner's own naming cannot be the suite default
+     * (`e2e/contract.spec.ts` › `contract` — a pytest module, for
+     * example, cannot live at a `.ts` path). The host owns the runner's
+     * own naming for exactly the same reason {@link project} is
+     * host-owned; every assertion is unchanged.
+     */
+    readonly scenario?: Partial<Pick<ContractScenario, 'file' | 'titlePath'>>;
+    /**
+     * Materializes a project whose suite produces `scenario`.
+     *
+     * Args:
+     *   scenario: the behaviour the produced suite must exhibit.
+     *
+     * Returns:
+     *   Promise<string>: the absolute project root.
+     */
+    materialize(scenario: ContractScenario): Promise<string>;
+    /**
+     * Spawns the REAL runner over the materialized project and returns its
+     * structured report, graded by `adapter.parseResults`.
+     *
+     * The host spawns; the adapter reads. A scenario the supervised
+     * policy forbids (a retry — the supervised run forces `--retries=0`)
+     * is produced with the runner's OWN setting and the host says so in
+     * {@link ContractObservation.note}: the point of that case is that
+     * the adapter DETECTS a retry when one happens, not that the engine
+     * permits one.
+     *
+     * Args:
+     *   adapter: the adapter under test (for `parseResults` only).
+     *   projectRoot: the root `materialize` returned.
+     *   scenario: the behaviour to produce.
+     *
+     * Returns:
+     *   Promise<ContractObservation>: the real report and its envelope.
+     */
+    run(adapter: RunnerAdapter, projectRoot: string, scenario: ContractScenario): Promise<ContractObservation>;
+    /**
+     * The request a `pass` scenario executes with (timeout, run state).
+     * The suite calls `adapter.execute` with it for the execute check.
+     */
+    executeRequest(projectRoot: string, scenario: ContractScenario): RunnerExecuteRequest;
+    /**
+     * A report in this runner's NATIVE format whose every row carries no
+     * framework identity — the shape a runner emits when its per-test tag
+     * never reached it. The suite feeds it to `parseResults` to prove the
+     * adapter attributes nothing from it.
+     */
+    untaggedReport(): string;
+}
+/** One contract violation (a non-empty list is a contract failure). */
+export interface ContractViolation {
+    /** The contract case the violation belongs to. */
+    case: string;
+    /** Single-cause explanation. */
+    detail: string;
+}
+/** The scenarios every adapter is graded on, in a stable order. */
+export declare const CONTRACT_SCENARIOS: readonly ContractScenarioKind[];
+/** Builds the canonical scenario for one kind (single planned test). */
+export declare function contractScenario(kind: ContractScenarioKind, overrides?: Partial<ContractScenario>): ContractScenario;
+/**
+ * Runs the full contract against one adapter.
+ *
+ * Every check is fail-closed: an adapter that throws, reports a missing
+ * field, or grades a dishonest run green produces a violation. The
+ * returned list is the whole result — an empty list is a pass.
+ *
+ * Args:
+ *   adapter: the adapter under test.
+ *   host: the runner mechanics for `adapter.runner`.
+ *
+ * Returns:
+ *   Promise<ContractViolation[]>: every contract case that failed.
+ */
+export declare function runRunnerAdapterContract(adapter: RunnerAdapter, host: RunnerContractHost): Promise<ContractViolation[]>;
+//# sourceMappingURL=contract-suite.d.ts.map

package/dist/adapter/contract-suite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-suite.d.ts","sourceRoot":"","sources":["../../src/adapter/contract-suite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAiD,KAAK,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAC/G,OAAO,KAAK,EACV,aAAa,EAEb,oBAAoB,EACpB,gBAAgB,EAIjB,MAAM,eAAe,CAAC;AAEvB;;;GAGG;AACH,MAAM,MAAM,oBAAoB;AAC9B,sDAAsD;AACpD,MAAM;AACR,4BAA4B;GAC1B,MAAM;AACR,4DAA4D;GAC1D,MAAM;AACR,0EAA0E;GACxE,OAAO;AACT,8DAA8D;GAC5D,WAAW;AACb,qCAAqC;GACnC,MAAM;AACR,6DAA6D;GAC3D,UAAU,CAAC;AAEf,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,uEAAuE;IACvE,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,+BAA+B;IAC/B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,QAAQ,EAAE,uBAAuB,CAAC;IAClC,wEAAwE;IACxE,GAAG,EAAE,gBAAgB,CAAC;IACtB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAC1E;;;;;;;;OAQG;IACH,WAAW,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzD;;;;;;;;;;;;;;;;;;OAkBG;IACH,GAAG,CACD,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAChC;;;OAGG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,oBAAoB,CAAC;IACtF;;;;;OAKG;IACH,cAAc,IAAI,MAAM,CAAC;CAC1B;AAED,uEAAuE;AACvE,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;CAChB;AAwED,mEAAmE;AACnE,eAAO,MAAM,kBAAkB,EAAE,SAAS,oBAAoB,EAO7D,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,oBAAoB,EAC1B,SAAS,GAAE,OAAO,CAAC,gBAAgB,CAAM,GACxC,gBAAgB,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAmC9B"}