kibi-cli 2.31.1 → 2.35.1

package/dist/public/proof-protocol.d.ts

@@ -1,14 +1,46 @@
 export declare const PROOF_RUN_VERSION: "kibi.proof-run.v1";
 export declare const PROOF_CONTRACT_VERSION: "kibi.proof-contract.v1";
-export declare const PROOF_RECEIPT_VERSION: "kibi.proof-receipt.v1";
+/**
+ * Receipts Kibi writes. v2 adds the contract's kind, the evidence level the
+ * receipt supports, and for certificate kinds the re-checked certificate.
+ */
+export declare const PROOF_RECEIPT_VERSION: "kibi.proof-receipt.v2";
+/** Receipts written before v2; still read, as e2e evidence at tested. */
+export declare const PROOF_RECEIPT_V1_VERSION: "kibi.proof-receipt.v1";
+export declare const PROOF_RECEIPT_VERSIONS: readonly ["kibi.proof-receipt.v1", "kibi.proof-receipt.v2"];
+/** The certificate a certificate-kind proof leaves for Kibi to re-check. */
+export declare const CODE_CERTIFICATE_VERSION: "kibi.code-certificate.v1";
 export declare const PROOF_INTEGRATION_VERSION: "kibi.proof-integration.v1";
 export declare const PROOF_RUN_OUTCOMES: readonly ["passed", "failed", "errored", "cancelled", "timed_out", "interrupted", "no_results"];
 export declare const PROOF_RESULT_OUTCOMES: readonly ["passed", "failed", "timed_out", "skipped", "interrupted", "errored"];
 export declare const PROOF_BINDING_KINDS: readonly ["native_case", "aggregate_run"];
 export declare const ATTEMPTS_STATUS: readonly ["complete", "unavailable"];
 export declare const RUN_FAILURE_PHASES: readonly ["setup", "collection", "execution", "teardown", "infrastructure"];
-export declare const SUCCESS_POLICIES: readonly ["all_required_first_attempt"];
+/**
+ * `all_required_first_attempt`: the whole run must pass and every obligation's
+ * own result must pass on its first attempt.
+ * `own_results_first_attempt`: a run whose only failures are other test cases
+ * (outcome `failed` in the execution phase) still proves an obligation whose
+ * own native-case result passed on its first attempt, so one unrelated
+ * failing case does not erase a suite's evidence. Aggregate-run obligations
+ * still need the whole run to pass.
+ */
+export declare const SUCCESS_POLICIES: readonly ["all_required_first_attempt", "own_results_first_attempt"];
+/**
+ * What a proof contract's checker establishes. Runner kinds (e2e, example,
+ * property) sample cases and support tested evidence; certificate kinds
+ * (exhaustive, typecheck, arithmetic, smt, rule, state_machine, regex,
+ * source) cover every case and support proved evidence once Kibi re-checks
+ * the certificate the run left. A source certificate is Kibi's own read of a
+ * project source (a JSON or YAML file, a glob, an OpenAPI document, the
+ * references the code makes, a data schema, a route table, a validator).
+ */
+export declare const PROOF_KINDS: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
+export declare const CERTIFICATE_PROOF_KINDS: readonly ["exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
+export type ProofKind = (typeof PROOF_KINDS)[number];
+export declare function isCertificateProofKind(kind: unknown): boolean;
 export type { AttemptsStatus, ProducerProvenance, ProofAttempt, ProofAttempts, ProofBinding, ProofBindingKind, ProofContract, ProofEnvironment, ProofObligation, ProofResult, ProofResultOutcome, ProofRun, ProofRunArtifact, ProofRunOutcome, RunFailurePhase, SuccessPolicy, } from "./proof-protocol-types.js";
+import type { ProofContract } from "./proof-protocol-types.js";
 export declare const PROOF_RESULT_SCHEMA: {
     readonly type: "object";
     readonly description: "One observed proof result. binding distinguishes native-case observations from aggregate-run bindings; attempts must report facts only.";
@@ -266,6 +298,15 @@ export declare const PROOF_RUN_ARTIFACT_SCHEMA: {
                 readonly minLength: 1;
             };
         };
+        readonly certificates: {
+            readonly type: "array";
+            readonly description: "kibi.code-certificate.v1 objects the run left for certificate-kind contracts, one per test. Kibi re-checks each before a receipt counts as proved.";
+            readonly maxItems: 1000;
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["version", "kind", "test_id"];
+            };
+        };
     };
     readonly additionalProperties: false;
 };
@@ -304,7 +345,217 @@ export declare const PROOF_CONTRACT_SCHEMA: {
         };
         readonly success_policy: {
             readonly type: "string";
-            readonly enum: readonly ["all_required_first_attempt"];
+            readonly enum: readonly ["all_required_first_attempt", "own_results_first_attempt"];
+        };
+        readonly kind: {
+            readonly type: "string";
+            readonly enum: readonly ["e2e", "example", "property", "exhaustive", "typecheck", "arithmetic", "smt", "rule", "state_machine", "regex", "source"];
+            readonly description: "What the checker establishes; absent means e2e. exhaustive, typecheck, arithmetic, smt, rule, state_machine and regex must leave a kibi.code-certificate.v1 that Kibi re-checks before the receipt counts as proved. source reads the contract's source itself: the run may leave {version, kind: source, test_id, source} or nothing, and Kibi stores its own read as the certificate.";
+        };
+        readonly source: {
+            readonly description: "source: the project source a source proof reads. A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+            readonly type: "object";
+            readonly required: readonly ["reader"];
+            readonly properties: {
+                readonly reader: {
+                    readonly type: "string";
+                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                };
+            };
+            readonly additionalProperties: true;
+        };
+        readonly domain_source: {
+            readonly type: "object";
+            readonly description: "exhaustive and typecheck: the symbol that defines the finite domain (typecheck: also the type whose fields a required_fields fact names). state_machine: the transition table or next-state function. The proof must import it from its source file; a hand-listed domain downgrades the receipt to example. Kibi reads the export named `export`, or the symbol's title when `export` is absent.";
+            readonly required: readonly ["symbol_id"];
+            readonly properties: {
+                readonly symbol_id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly export: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly description: "The name the domain is exported under in the symbol's source file, when the symbol's title is not that name.";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly witness: {
+            readonly type: "object";
+            readonly description: "typecheck: the repository-relative witness file Kibi compiles (an exhaustive switch ending in never, or a mapped type over the domain).";
+            readonly required: readonly ["path"];
+            readonly properties: {
+                readonly path: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly proves: {
+            readonly type: "array";
+            readonly description: "Certificate kinds: the requirement claim keys (CLAIM-...) this certificate proves. Each must be a modeled claim of a current requirement the test reaches through its scenarios. Kibi derives what the certificate must establish from the claim's grounding fact (a set fact for exhaustive or typecheck, a numeric fact for arithmetic or smt, a rule, predicate or set fact for rule and state_machine, a string fact for regex); a claim with no such derivation is only attested and never counts as proved.";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^CLAIM-";
+            };
+            readonly uniqueItems: true;
+        };
+        readonly value_source: {
+            readonly type: "array";
+            readonly description: "arithmetic and smt: code constants the assumptions read. Kibi evaluates each export at ingest and requires the certificate to assume the variable equals that value, so the proof is about the code and not only the knowledge base. With measure count the value is the size of a list, set, map or object export, so a count claim reads the collection itself. An entry {source, measure: count} counts the members Kibi reads from a project source (routes, tables, environment variables).";
+            readonly minItems: 1;
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly symbol_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly export: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly source: {
+                        readonly type: "object";
+                        readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                        readonly required: readonly ["reader"];
+                        readonly properties: {
+                            readonly reader: {
+                                readonly type: "string";
+                                readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                            };
+                        };
+                        readonly additionalProperties: true;
+                    };
+                    readonly measure: {
+                        readonly type: "string";
+                        readonly enum: readonly ["value", "count"];
+                        readonly description: "value (default for an export): the export is a number. count (the only measure of a source): the number of members of a list, set, map or object export, or of a source.";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly predicate_source: {
+            readonly type: "object";
+            readonly description: "rule: the code function behind each predicate a claim's rule, predicate or set fact names, keyed by predicate name. Each export takes the predicate's arguments in order and returns a boolean; Kibi calls it on every combination of its argument domains.";
+            readonly minProperties: 1;
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly required: readonly ["symbol_id"];
+                readonly properties: {
+                    readonly symbol_id: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly export: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly description: "The exported function's name in the symbol's source file. Without it Kibi reads the export named by the symbol's title.";
+                    };
+                    readonly harness_for: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly description: "The predicate is a test harness that decides the predicate by driving these code symbols (for example by calling the handler with each role). The symbols must be covered_by the test; a claim the harness proves is bound with scope harness.";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+        };
+        readonly domains: {
+            readonly type: "object";
+            readonly description: "rule: the finite domain of each argument type, keyed by type name (an array, Set, Map or object export, or a Python list, set, dict or Enum), or {source} for the members Kibi reads from a project source (every route, every table, every environment variable). state_machine with a next-state function: the `state` and `event` domains it is called on.";
+            readonly minProperties: 1;
+            readonly additionalProperties: {
+                readonly anyOf: readonly [{
+                    readonly type: "object";
+                    readonly required: readonly ["symbol_id"];
+                    readonly properties: {
+                        readonly symbol_id: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                        readonly export: {
+                            readonly type: "string";
+                            readonly minLength: 1;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly type: "object";
+                    readonly required: readonly ["source"];
+                    readonly properties: {
+                        readonly source: {
+                            readonly type: "object";
+                            readonly description: "A project source Kibi reads by itself. reader json or yaml: {file, path?, select?: keys|values|items}. glob: {pattern, capture?, ignore?} (capture true reads what each * matched). openapi: {file, select?: operations|unsecured_operations|security_schemes|responses}. references: {files, extract: env|imports|calls|string_args|thrown|property, callee?, key?, ignore?}. schema: {format: drizzle|prisma|sql, file (drizzle, prisma) or files (sql migrations), exports?, table?, select?: tables|columns|required_columns|nullable_columns|foreign_keys}. routes: {file, export, framework?: hono|express, path_prefix?, names_from?, select?: routes|middleware}. validator: {file, export, select?: fields|required_fields|optional_fields}. Paths are repository-relative. A member Kibi cannot read statically fails the read with its location.";
+                            readonly required: readonly ["reader"];
+                            readonly properties: {
+                                readonly reader: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["json", "yaml", "glob", "openapi", "references", "schema", "routes", "validator"];
+                                };
+                            };
+                            readonly additionalProperties: true;
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+        };
+        readonly initial_source: {
+            readonly description: "state_machine: the export holding the initial state (or states), needed for initial_states and reachable_states facts.";
+            readonly type: "object";
+            readonly required: readonly ["symbol_id"];
+            readonly properties: {
+                readonly symbol_id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly export: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly pattern_source: {
+            readonly description: "regex: the export holding the code's pattern (a RegExp, or a Python re.Pattern) or string constant that a string fact is about.";
+            readonly type: "object";
+            readonly required: readonly ["symbol_id"];
+            readonly properties: {
+                readonly symbol_id: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly export: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly constraint_source: {
+            readonly type: "object";
+            readonly description: "arithmetic and smt: the typed numeric property_value facts the certificate's assumptions come from. Kibi checks the assumptions (or the query's assertions) are exactly these facts' constraints, so the proof is about the knowledge base, not numbers the test chose.";
+            readonly required: readonly ["fact_ids"];
+            readonly properties: {
+                readonly fact_ids: {
+                    readonly type: "array";
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+            readonly additionalProperties: false;
         };
     };
     readonly additionalProperties: false;
@@ -350,5 +601,10 @@ export declare const PROOF_BINDINGS_SCHEMA: {
 export declare function proofResultErrors(value: unknown, label: string): string[];
 export declare function proofRunArtifactErrors(value: unknown): string[];
 export declare function proofContractErrors(value: unknown): string[];
+/**
+ * The optional contract fields beyond the v1 core, copied only when present
+ * so existing contracts keep their hash.
+ */
+export declare function optionalProofContractFields(contract: Record<string, unknown>): Pick<ProofContract, "kind" | "domain_source" | "witness" | "constraint_source" | "value_source" | "proves" | "predicate_source" | "domains" | "initial_source" | "pattern_source" | "source">;
 export declare function proofBindingsErrors(value: unknown): string[];
 //# sourceMappingURL=proof-protocol.d.ts.map

package/dist/public/proof-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proof-protocol.d.ts","sourceRoot":"","sources":["../../src/public/proof-protocol.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAE9D,eAAO,MAAM,sBAAsB,EAAG,wBAAiC,CAAC;AAExE,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAC;AAEtE,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,iGAQrB,CAAC;AAEX,eAAO,MAAM,qBAAqB,iFAOxB,CAAC;AAEX,eAAO,MAAM,mBAAmB,2CAA4C,CAAC;AAE7E,eAAO,MAAM,eAAe,sCAAuC,CAAC;AAEpE,eAAO,MAAM,kBAAkB,6EAMrB,CAAC;AAEX,eAAO,MAAM,gBAAgB,yCAA0C,CAAC;AAExE,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,2BAA2B,CAAC;AAWnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DtB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE5B,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AA0GX,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCzE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAkG/D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAwD5D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CA8C5D"}
+{"version":3,"file":"proof-protocol.d.ts","sourceRoot":"","sources":["../../src/public/proof-protocol.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,EAAG,mBAA4B,CAAC;AAE9D,eAAO,MAAM,sBAAsB,EAAG,wBAAiC,CAAC;AACxE;;;GAGG;AAEH,eAAO,MAAM,qBAAqB,EAAG,uBAAgC,CAAC;AACtE,yEAAyE;AAEzE,eAAO,MAAM,wBAAwB,EAAG,uBAAgC,CAAC;AAEzE,eAAO,MAAM,sBAAsB,6DAGzB,CAAC;AACX,4EAA4E;AAE5E,eAAO,MAAM,wBAAwB,EAAG,0BAAmC,CAAC;AAE5E,eAAO,MAAM,yBAAyB,EAAG,2BAAoC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,iGAQrB,CAAC;AAEX,eAAO,MAAM,qBAAqB,iFAOxB,CAAC;AAEX,eAAO,MAAM,mBAAmB,2CAA4C,CAAC;AAE7E,eAAO,MAAM,eAAe,sCAAuC,CAAC;AAEpE,eAAO,MAAM,kBAAkB,6EAMrB,CAAC;AAEX;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,sEAGnB,CAAC;AAEX;;;;;;;;GAQG;AAEH,eAAO,MAAM,WAAW,qIAYd,CAAC;AAGX,eAAO,MAAM,uBAAuB,uGAS1B,CAAC;AAGX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAGrD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,aAAa,GACd,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAIV,aAAa,EAGd,MAAM,2BAA2B,CAAC;AAQnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DtB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwE5B,CAAC;AAqDX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgIxB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AA0GX,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgCzE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAoH/D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAyD5D;AA0RD;;;GAGG;AAEH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,IAAI,CACL,aAAa,EACX,MAAM,GACN,eAAe,GACf,SAAS,GACT,mBAAmB,GACnB,cAAc,GACd,QAAQ,GACR,kBAAkB,GAClB,SAAS,GACT,gBAAgB,GAChB,gBAAgB,GAChB,QAAQ,CACX,CAgEA;AAsED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CA8C5D"}