@xyo-network/xl1-protocol 5.2.0 → 5.2.1

package/dist/neutral/modules/network-model/staticRest/layout/admissionShadow.d.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+/** Schema id for a published admission shadow report. */
+export declare const AdmissionShadowReportSchema: "network.xyo.s3.admission.shadow" & {
+    readonly __schema: true;
+};
+/** Type literal for the admission shadow report schema. */
+export type AdmissionShadowReportSchema = typeof AdmissionShadowReportSchema;
+/** What both admission gates concluded about one candidate. */
+export declare const AdmissionShadowAssessmentZod: z.ZodObject<{
+    admittedByAllowList: z.ZodBoolean;
+    block: z.ZodInt;
+    dataHash: z.ZodString;
+    eStar: z.ZodOptional<z.ZodInt>;
+    eligible: z.ZodOptional<z.ZodBoolean>;
+    producer: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    resolvable: z.ZodBoolean;
+}, z.core.$strip>;
+/** What both admission gates concluded about one candidate. */
+export type AdmissionShadowAssessment = z.infer<typeof AdmissionShadowAssessmentZod>;
+/**
+ * Zod schema for one published round of shadow admission.
+ *
+ * Published rather than logged because the point of the posture is that anyone can see what
+ * enforcement would have done before it does it. An operator convinced by their own logs has
+ * convinced nobody.
+ *
+ * The back-link is what makes the series walkable without listing: a reader takes the head
+ * pointer and follows `previous` as far back as it cares to.
+ */
+export declare const AdmissionShadowReportZod: z.ZodObject<{
+    assessments: z.ZodArray<z.ZodObject<{
+        admittedByAllowList: z.ZodBoolean;
+        block: z.ZodInt;
+        dataHash: z.ZodString;
+        eStar: z.ZodOptional<z.ZodInt>;
+        eligible: z.ZodOptional<z.ZodBoolean>;
+        producer: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        resolvable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    divergent: z.ZodArray<z.ZodObject<{
+        admittedByAllowList: z.ZodBoolean;
+        block: z.ZodInt;
+        dataHash: z.ZodString;
+        eStar: z.ZodOptional<z.ZodInt>;
+        eligible: z.ZodOptional<z.ZodBoolean>;
+        producer: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        resolvable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    head: z.ZodInt;
+    previous: z.ZodOptional<z.ZodInt>;
+    schema: z.ZodLiteral<"network.xyo.s3.admission.shadow" & {
+        readonly __schema: true;
+    }>;
+}, z.core.$strip>;
+/** One published round of shadow admission. */
+export type AdmissionShadowReportDocument = z.infer<typeof AdmissionShadowReportZod>;
+/** Type guard that checks if a value is a valid AdmissionShadowReportDocument. */
+export declare const isAdmissionShadowReport: <T>(value: T) => value is T & {
+    assessments: {
+        admittedByAllowList: boolean;
+        block: number;
+        dataHash: string;
+        producer: string;
+        resolvable: boolean;
+        eStar?: number | undefined;
+        eligible?: boolean | undefined;
+        reason?: string | undefined;
+    }[];
+    divergent: {
+        admittedByAllowList: boolean;
+        block: number;
+        dataHash: string;
+        producer: string;
+        resolvable: boolean;
+        eStar?: number | undefined;
+        eligible?: boolean | undefined;
+        reason?: string | undefined;
+    }[];
+    head: number;
+    schema: "network.xyo.s3.admission.shadow" & {
+        readonly __schema: true;
+    };
+    previous?: number | undefined;
+};
+/** Converts a value to AdmissionShadowReportDocument, throwing if invalid. */
+export declare const asAdmissionShadowReport: {
+    <T>(value: T): (T & {
+        assessments: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        divergent: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        head: number;
+        schema: "network.xyo.s3.admission.shadow" & {
+            readonly __schema: true;
+        };
+        previous?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        assessments: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        divergent: {
+            admittedByAllowList: boolean;
+            block: number;
+            dataHash: string;
+            producer: string;
+            resolvable: boolean;
+            eStar?: number | undefined;
+            eligible?: boolean | undefined;
+            reason?: string | undefined;
+        }[];
+        head: number;
+        schema: "network.xyo.s3.admission.shadow" & {
+            readonly __schema: true;
+        };
+        previous?: number | undefined;
+    };
+};
+/** Builds a validated admission shadow report. */
+export declare function createAdmissionShadowReport(head: number, assessments: AdmissionShadowAssessment[], divergent: AdmissionShadowAssessment[], previous?: number): AdmissionShadowReportDocument;
+//# sourceMappingURL=admissionShadow.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/admissionShadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admissionShadow.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/admissionShadow.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,yDAAyD;AACzD,eAAO,MAAM,2BAA2B;;CAAoD,CAAA;AAC5F,2DAA2D;AAC3D,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAA;AAE5E,+DAA+D;AAC/D,eAAO,MAAM,4BAA4B;;;;;;;;;iBAiBvC,CAAA;AAEF,+DAA+D;AAC/D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEpF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUnC,CAAA;AAEF,+CAA+C;AAC/C,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,kFAAkF;AAClF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;CAAyC,CAAA;AAC7E,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoE,CAAA;AAExG,kDAAkD;AAClD,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,yBAAyB,EAAE,EACxC,SAAS,EAAE,yBAAyB,EAAE,EACtC,QAAQ,CAAC,EAAE,MAAM,GAChB,6BAA6B,CAI/B"}

package/dist/neutral/modules/network-model/staticRest/layout/index.d.ts

@@ -1,3 +1,4 @@
+export * from './admissionShadow.js';
 export * from './chainContractManifest.js';
 export * from './chainManifest.js';
 export * from './chainParams.js';
@@ -5,6 +6,7 @@ export * from './chainParamsRules.js';
 export * from './evmEventIndex.js';
 export * from './indexManifest.js';
 export * from './networkStakeRewardsIndex.js';
+export * from './slashIndex.js';
 export * from './transactionInclusionIndex.js';
 export * from './trustedPosture.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,oBAAoB,CAAA;AAClC,cAAc,kBAAkB,CAAA;AAChC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA;AAC9C,cAAc,qBAAqB,CAAA"}

package/dist/neutral/modules/network-model/staticRest/layout/slashIndex.d.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+/** Schema id for the slash index head pointer. */
+export declare const SlashIndexHeadSchema: "network.xyo.s3.slash.index.head" & {
+    readonly __schema: true;
+};
+/** Type literal for the slash index head schema. */
+export type SlashIndexHeadSchema = typeof SlashIndexHeadSchema;
+/** Bumped when the index layout changes, so readers can detect a mismatch. */
+export declare const SLASH_INDEX_VERSION = 1;
+/**
+ * Zod schema for the slash index head pointer.
+ *
+ * Written last in every pass. A reader that sees this pointer can rely on everything it names
+ * already being there, which is what makes a crashed pass safe to simply re-run: the pointer only
+ * ever advances over work that finished.
+ */
+export declare const SlashIndexHeadZod: z.ZodObject<{
+    height: z.ZodInt;
+    indexVersion: z.ZodInt;
+    schema: z.ZodLiteral<"network.xyo.s3.slash.index.head" & {
+        readonly __schema: true;
+    }>;
+    anchor: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/** The slash index head pointer. */
+export type SlashIndexHead = z.infer<typeof SlashIndexHeadZod>;
+/** Type guard that checks if a value is a valid SlashIndexHead. */
+export declare const isSlashIndexHead: <T>(value: T) => value is T & {
+    height: number;
+    indexVersion: number;
+    schema: "network.xyo.s3.slash.index.head" & {
+        readonly __schema: true;
+    };
+    anchor?: number | undefined;
+};
+/** Converts a value to SlashIndexHead, throwing if invalid. */
+export declare const asSlashIndexHead: {
+    <T>(value: T): (T & {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    };
+};
+/** Non-validating cast to SlashIndexHead. */
+export declare const toSlashIndexHead: {
+    (value: unknown): {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    } | undefined;
+    (value: unknown, assert: import("@ariestools/sdk").ZodFactoryConfig): {
+        height: number;
+        indexVersion: number;
+        schema: "network.xyo.s3.slash.index.head" & {
+            readonly __schema: true;
+        };
+        anchor?: number | undefined;
+    };
+};
+/** Schema id for the per-offense aggregate. */
+export declare const SlashIndexKeyRecordSchema: "network.xyo.s3.slash.index.key" & {
+    readonly __schema: true;
+};
+/** Type literal for the per-offense aggregate schema. */
+export type SlashIndexKeyRecordSchema = typeof SlashIndexKeyRecordSchema;
+/**
+ * Zod schema for everything recorded about one offense.
+ *
+ * The aggregates are the only discovery surface, because the published read path cannot list
+ * objects. That is why they are allowed to be rewritten while everything else is immutable — and
+ * why every rewrite only appends, so a pass that runs twice converges instead of losing history.
+ */
+export declare const SlashIndexKeyRecordZod: z.ZodObject<{
+    accused: z.ZodString;
+    adjudication: z.ZodOptional<z.ZodString>;
+    block: z.ZodInt;
+    challenges: z.ZodArray<z.ZodString>;
+    chain: z.ZodString;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        confirmed: "confirmed";
+        refuted: "refuted";
+        indeterminate: "indeterminate";
+        invalid: "invalid";
+    }>>;
+    offense: z.ZodEnum<{
+        equivocation: "equivocation";
+        "invalid-block": "invalid-block";
+        "reward-overmint": "reward-overmint";
+        "false-anchor": "false-anchor";
+        "ineligible-production": "ineligible-production";
+        "invalid-slash-request": "invalid-slash-request";
+        "false-attestation": "false-attestation";
+    }>;
+    requests: z.ZodArray<z.ZodString>;
+    schema: z.ZodLiteral<"network.xyo.s3.slash.index.key" & {
+        readonly __schema: true;
+    }>;
+}, z.core.$strip>;
+/** Everything recorded about one offense. */
+export type SlashIndexKeyRecord = z.infer<typeof SlashIndexKeyRecordZod>;
+/** Type guard that checks if a value is a valid SlashIndexKeyRecord. */
+export declare const isSlashIndexKeyRecord: <T>(value: T) => value is T & {
+    accused: string;
+    block: number;
+    challenges: string[];
+    chain: string;
+    offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+    requests: string[];
+    schema: "network.xyo.s3.slash.index.key" & {
+        readonly __schema: true;
+    };
+    adjudication?: string | undefined;
+    outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+};
+/** Converts a value to SlashIndexKeyRecord, throwing if invalid. */
+export declare const asSlashIndexKeyRecord: {
+    <T>(value: T): (T & {
+        accused: string;
+        block: number;
+        challenges: string[];
+        chain: string;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        requests: string[];
+        schema: "network.xyo.s3.slash.index.key" & {
+            readonly __schema: true;
+        };
+        adjudication?: string | undefined;
+        outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+    }) | undefined;
+    <T>(value: T, assert: import("@ariestools/sdk").ZodFactoryConfig): T & {
+        accused: string;
+        block: number;
+        challenges: string[];
+        chain: string;
+        offense: "equivocation" | "invalid-block" | "reward-overmint" | "false-anchor" | "ineligible-production" | "invalid-slash-request" | "false-attestation";
+        requests: string[];
+        schema: "network.xyo.s3.slash.index.key" & {
+            readonly __schema: true;
+        };
+        adjudication?: string | undefined;
+        outcome?: "confirmed" | "refuted" | "indeterminate" | "invalid" | undefined;
+    };
+};
+/** Builds a validated slash index head. */
+export declare function createSlashIndexHead(height: number, anchor?: number): SlashIndexHead;
+//# sourceMappingURL=slashIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/layout/slashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/layout/slashIndex.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,kDAAkD;AAClD,eAAO,MAAM,oBAAoB;;CAAoD,CAAA;AACrF,oDAAoD;AACpD,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAA;AAE9D,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAIpC;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;iBAQ5B,CAAA;AAEF,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE9D,mEAAmE;AACnE,eAAO,MAAM,gBAAgB;;;;;;;CAAkC,CAAA;AAC/D,+DAA+D;AAC/D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAAsD,CAAA;AACnF,6CAA6C;AAC7C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAAsD,CAAA;AAEnF,+CAA+C;AAC/C,eAAO,MAAM,yBAAyB;;CAAmD,CAAA;AACzF,yDAAyD;AACzD,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAA;AAExE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBjC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAExE,wEAAwE;AACxE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;CAAuC,CAAA;AACzE,oEAAoE;AACpE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAgE,CAAA;AAElG,2CAA2C;AAC3C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAIpF"}

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts

@@ -3,5 +3,6 @@ export * from './evmEventIndex.js';
 export * from './finalized.js';
 export * from './indexPaths.js';
 export * from './networkStakeRewardsIndex.js';
+export * from './slashIndex.js';
 export * from './transactionInclusionIndex.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,gCAAgC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,+BAA+B,CAAA;AAC7C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gCAAgC,CAAA"}

package/dist/neutral/modules/network-model/staticRest/paths/slashIndex.d.ts

@@ -0,0 +1,31 @@
+import type { Hash } from '@ariestools/sdk';
+import type { XyoAddress } from '@xyo-network/sdk';
+import type { OffenseCode } from '../../../protocol-model/index.js';
+/** Path of the mutable slash-index head. */
+export declare function slashIndexHeadPath(): string;
+/** Path of the static slash-index manifest. */
+export declare function slashIndexManifestPath(): string;
+/** Path of one immutable recorded slash request. */
+export declare function slashIndexRequestPath(hash: Hash): string;
+/** Path of one immutable recorded slash commitment. */
+export declare function slashIndexCommitPath(hash: Hash): string;
+/** Path of one immutable recorded slash challenge. */
+export declare function slashIndexChallengePath(hash: Hash): string;
+/** Path of one immutable recorded slash adjudication. */
+export declare function slashIndexAdjudicationPath(hash: Hash): string;
+/**
+ * Path of the aggregate for one offense.
+ *
+ * Keyed by the canonical offense identity rather than by any report, so several reports of the
+ * same misconduct converge on one object instead of accumulating as separate accusations.
+ */
+export declare function slashIndexKeyPath(accused: XyoAddress, offense: OffenseCode, block: number): string;
+/** Path of one producer's offense history. */
+export declare function slashIndexAccusedPath(address: XyoAddress): string;
+/** Path of one reporter's claim history. */
+export declare function slashIndexClaimantPath(address: XyoAddress): string;
+/** Path of one published admission shadow report. */
+export declare function admissionShadowPath(height: number): string;
+/** Path of the mutable pointer to the newest admission shadow report. */
+export declare function admissionShadowHeadPath(): string;
+//# sourceMappingURL=slashIndex.d.ts.map

package/dist/neutral/modules/network-model/staticRest/paths/slashIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slashIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/modules/network-model/staticRest/paths/slashIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAIlD,4CAA4C;AAC5C,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,+CAA+C;AAC/C,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,oDAAoD;AACpD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAExD;AAED,uDAAuD;AACvD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAEvD;AAED,sDAAsD;AACtD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE1D;AAED,yDAAyD;AACzD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElG;AAED,8CAA8C;AAC9C,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAEjE;AAED,4CAA4C;AAC5C,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAElE;AAED,qDAAqD;AACrD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}