@behavproof/cli 0.0.0-stage → 0.1.0

package/dist/registration.d.ts

@@ -0,0 +1,595 @@
+import { z } from 'zod';
+import { type Approval } from '@behavproof/core';
+export declare const RegistrationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    repository: z.ZodObject<{
+        id: z.ZodString;
+        fullName: z.ZodString;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        commitSha: z.ZodString;
+        prNumber: z.ZodNumber;
+        projectPath: z.ZodUnion<readonly [z.ZodLiteral<".">, z.ZodString]>;
+        policyRef: z.ZodString;
+        configRef: z.ZodOptional<z.ZodString>;
+        fileHashes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>;
+    policyId: z.ZodString;
+    policy: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        profileVersion: z.ZodLiteral<"1">;
+        rules: z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                off: "off";
+                warn: "warn";
+            }>;
+            min: z.ZodOptional<z.ZodNumber>;
+            minMutants: z.ZodOptional<z.ZodNumber>;
+            allowNotApplicable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    config: z.ZodPipe<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        formal: z.ZodOptional<z.ZodObject<{
+            models: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contractId: z.ZodString;
+                model: z.ZodString;
+                modelSources: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                quint: z.ZodObject<{
+                    entry: z.ZodString;
+                    version: z.ZodString;
+                    apalacheVersion: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>;
+                properties: z.ZodArray<z.ZodString>;
+                checks: z.ZodArray<z.ZodEnum<{
+                    parse: "parse";
+                    typecheck: "typecheck";
+                    test: "test";
+                    run: "run";
+                    verify: "verify";
+                }>>;
+                maxSteps: z.ZodNumber;
+                maxSamples: z.ZodDefault<z.ZodNumber>;
+                seed: z.ZodString;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                report: z.ZodString;
+                driver: z.ZodOptional<z.ZodString>;
+                driverSources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                implementation: z.ZodOptional<z.ZodString>;
+                implementationSources: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                conformanceReport: z.ZodOptional<z.ZodString>;
+                traceReceipt: z.ZodOptional<z.ZodString>;
+                traceDirectory: z.ZodOptional<z.ZodString>;
+                requiredActions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                minTraces: z.ZodDefault<z.ZodNumber>;
+                minComparisons: z.ZodDefault<z.ZodNumber>;
+                requireCanary: z.ZodDefault<z.ZodBoolean>;
+                canary: z.ZodOptional<z.ZodObject<{
+                    faultId: z.ZodString;
+                    implementation: z.ZodString;
+                    targetRef: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            audit: "audit";
+            gate: "gate";
+        }>>;
+        profile: z.ZodDefault<z.ZodEnum<{
+            basic: "basic";
+            standard: "standard";
+            critical: "critical";
+        }>>;
+        profileVersion: z.ZodDefault<z.ZodLiteral<"1">>;
+        riskOverrides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"path">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"module">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"contract-kind">;
+                value: z.ZodEnum<{
+                    external: "external";
+                    examples: "examples";
+                    invariant: "invariant";
+                    state_machine: "state_machine";
+                    api_contract: "api_contract";
+                }>;
+            }, z.core.$strict>], "kind">;
+            profile: z.ZodEnum<{
+                basic: "basic";
+                standard: "standard";
+                critical: "critical";
+            }>;
+        }, z.core.$strict>>>;
+        git: z.ZodDefault<z.ZodObject<{
+            base: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>>;
+        reports: z.ZodDefault<z.ZodObject<{
+            vitest: z.ZodOptional<z.ZodString>;
+            coverage: z.ZodOptional<z.ZodString>;
+            mutation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        executionManifests: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        rules: z.ZodDefault<z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                off: "off";
+                warn: "warn";
+            }>;
+            min: z.ZodOptional<z.ZodNumber>;
+            minMutants: z.ZodOptional<z.ZodNumber>;
+            allowNotApplicable: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>>;
+        contracts: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    external: "external";
+                    "vitest-inline": "vitest-inline";
+                    manifest: "manifest";
+                    gherkin: "gherkin";
+                    openapi: "openapi";
+                }>;
+                include: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+            requireExecutionEvidence: z.ZodDefault<z.ZodBoolean>;
+            approval: z.ZodDefault<z.ZodObject<{
+                provider: z.ZodLiteral<"github-protected-review">;
+                requiredForRisk: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    basic: "basic";
+                    standard: "standard";
+                    critical: "critical";
+                }>>>;
+                onUnverifiable: z.ZodDefault<z.ZodLiteral<"unknown">>;
+            }, z.core.$strict>>;
+            documents: z.ZodDefault<z.ZodObject<{
+                output: z.ZodDefault<z.ZodString>;
+                commit: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        rules: Record<string, {
+            severity: "error" | "off" | "warn";
+            min?: number | undefined;
+            minMutants?: number | undefined;
+            allowNotApplicable?: string[] | undefined;
+        }>;
+        schemaVersion: 1;
+        mode: "audit" | "gate";
+        profile: "basic" | "standard" | "critical";
+        profileVersion: "1";
+        riskOverrides: {
+            selector: {
+                kind: "path";
+                value: string;
+            } | {
+                kind: "module";
+                value: string;
+            } | {
+                kind: "contract-kind";
+                value: "external" | "examples" | "invariant" | "state_machine" | "api_contract";
+            };
+            profile: "basic" | "standard" | "critical";
+        }[];
+        git: {
+            base: string;
+        };
+        reports: {
+            vitest?: string | undefined;
+            coverage?: string | undefined;
+            mutation?: string | undefined;
+        };
+        executionManifests: string[];
+        contracts: {
+            enabled: boolean;
+            sources: {
+                type: "external" | "vitest-inline" | "manifest" | "gherkin" | "openapi";
+                include: string[];
+            }[];
+            requireExecutionEvidence: boolean;
+            approval: {
+                provider: "github-protected-review";
+                requiredForRisk: ("basic" | "standard" | "critical")[];
+                onUnverifiable: "unknown";
+            };
+            documents: {
+                output: string;
+                commit: boolean;
+            };
+        };
+        formal?: {
+            models: {
+                id: string;
+                contractId: string;
+                model: string;
+                modelSources: string[];
+                quint: {
+                    entry: string;
+                    version: string;
+                    apalacheVersion?: string | undefined;
+                };
+                properties: string[];
+                checks: ("parse" | "typecheck" | "test" | "run" | "verify")[];
+                maxSteps: number;
+                maxSamples: number;
+                seed: string;
+                timeoutMs: number;
+                report: string;
+                implementationSources: string[];
+                requiredActions: string[];
+                minTraces: number;
+                minComparisons: number;
+                requireCanary: boolean;
+                driver?: string | undefined;
+                driverSources?: string[] | undefined;
+                implementation?: string | undefined;
+                conformanceReport?: string | undefined;
+                traceReceipt?: string | undefined;
+                traceDirectory?: string | undefined;
+                canary?: {
+                    faultId: string;
+                    implementation: string;
+                    targetRef: string;
+                } | undefined;
+            }[];
+        } | undefined;
+    }, {
+        schemaVersion: 1;
+        mode: "audit" | "gate";
+        profile: "basic" | "standard" | "critical";
+        profileVersion: "1";
+        riskOverrides: {
+            selector: {
+                kind: "path";
+                value: string;
+            } | {
+                kind: "module";
+                value: string;
+            } | {
+                kind: "contract-kind";
+                value: "external" | "examples" | "invariant" | "state_machine" | "api_contract";
+            };
+            profile: "basic" | "standard" | "critical";
+        }[];
+        git: {
+            base: string;
+        };
+        reports: {
+            vitest?: string | undefined;
+            coverage?: string | undefined;
+            mutation?: string | undefined;
+        };
+        executionManifests: string[];
+        rules: Record<string, {
+            severity: "error" | "off" | "warn";
+            min?: number | undefined;
+            minMutants?: number | undefined;
+            allowNotApplicable?: string[] | undefined;
+        }>;
+        contracts: {
+            enabled: boolean;
+            sources: {
+                type: "external" | "vitest-inline" | "manifest" | "gherkin" | "openapi";
+                include: string[];
+            }[];
+            requireExecutionEvidence: boolean;
+            approval: {
+                provider: "github-protected-review";
+                requiredForRisk: ("basic" | "standard" | "critical")[];
+                onUnverifiable: "unknown";
+            };
+            documents: {
+                output: string;
+                commit: boolean;
+            };
+        };
+        formal?: {
+            models: {
+                id: string;
+                contractId: string;
+                model: string;
+                modelSources: string[];
+                quint: {
+                    entry: string;
+                    version: string;
+                    apalacheVersion?: string | undefined;
+                };
+                properties: string[];
+                checks: ("parse" | "typecheck" | "test" | "run" | "verify")[];
+                maxSteps: number;
+                maxSamples: number;
+                seed: string;
+                timeoutMs: number;
+                report: string;
+                implementationSources: string[];
+                requiredActions: string[];
+                minTraces: number;
+                minComparisons: number;
+                requireCanary: boolean;
+                driver?: string | undefined;
+                driverSources?: string[] | undefined;
+                implementation?: string | undefined;
+                conformanceReport?: string | undefined;
+                traceReceipt?: string | undefined;
+                traceDirectory?: string | undefined;
+                canary?: {
+                    faultId: string;
+                    implementation: string;
+                    targetRef: string;
+                } | undefined;
+            }[];
+        } | undefined;
+    }>>;
+    baseline: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        commitSha: z.ZodString;
+        contracts: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            formal: z.ZodOptional<z.ZodObject<{
+                modelId: z.ZodString;
+                modelHash: z.ZodString;
+                driverHash: z.ZodOptional<z.ZodString>;
+                propertyIds: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            kind: z.ZodEnum<{
+                external: "external";
+                examples: "examples";
+                invariant: "invariant";
+                state_machine: "state_machine";
+                api_contract: "api_contract";
+            }>;
+            intentIds: z.ZodArray<z.ZodString>;
+            revisionHash: z.ZodString;
+            sourceRef: z.ZodString;
+            caseIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            risk: z.ZodOptional<z.ZodEnum<{
+                basic: "basic";
+                standard: "standard";
+                critical: "critical";
+            }>>;
+            cases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                input: z.ZodJSONSchema;
+                expected: z.ZodJSONSchema;
+                negative: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        intents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            risk: z.ZodEnum<{
+                basic: "basic";
+                standard: "standard";
+                critical: "critical";
+            }>;
+            contentHash: z.ZodString;
+            origin: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    external: "external";
+                    manifest: "manifest";
+                    inline: "inline";
+                }>;
+                ref: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        policyHash: z.ZodOptional<z.ZodString>;
+        extractorVersion: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        discoveryDiagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            sourceRef: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    inputs: z.ZodArray<z.ZodString>;
+    configPaths: z.ZodArray<z.ZodString>;
+    claimScopes: z.ZodArray<z.ZodObject<{
+        contractId: z.ZodString;
+        caseIds: z.ZodArray<z.ZodString>;
+        targetRef: z.ZodString;
+        method: z.ZodString;
+    }, z.core.$strict>>;
+    approvals: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                intent: "intent";
+                contract: "contract";
+                policy: "policy";
+                registry: "registry";
+            }>;
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            pass: "pass";
+            fail: "fail";
+            not_applicable: "not_applicable";
+        }>;
+        source: z.ZodObject<{
+            provider: z.ZodString;
+            ref: z.ZodString;
+        }, z.core.$strict>;
+        approvedBy: z.ZodArray<z.ZodString>;
+        subjectCommitSha: z.ZodOptional<z.ZodString>;
+        reasons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Registration = z.infer<typeof RegistrationSchema>;
+export type RegistrationAuthority = {
+    verifySource: (registration: Registration) => boolean;
+    verifyApproval: (approval: Approval) => boolean;
+};
+export type VerifiedRegistration = {
+    readonly registration: Registration;
+    readonly digest: string;
+};
+export declare function createRegistration(value: unknown, authority: RegistrationAuthority): VerifiedRegistration;
+export declare function persistRegistration(projectRoot: string, directory: string, handle: VerifiedRegistration): Promise<{
+    path: string;
+    digest: string;
+}>;
+/** expectedDigest belongs to the protected host invocation, never to candidate JSON. */
+export declare function loadRegistration(projectRoot: string, path: string, expectedDigest: string): Promise<Registration>;
+/** Path projection only; obtain authority separately with loadRegistration and a protected digest. */
+export declare function registrationProjectData(value: Registration): {
+    baseline: {
+        scope?: string[] | undefined;
+        contracts: {
+            sourceRef: string;
+            id: string;
+            kind: "external" | "examples" | "invariant" | "state_machine" | "api_contract";
+            intentIds: string[];
+            revisionHash: string;
+            formal?: {
+                modelId: string;
+                modelHash: string;
+                propertyIds: string[];
+                driverHash?: string | undefined;
+            } | undefined;
+            caseIds?: string[] | undefined;
+            risk?: "basic" | "standard" | "critical" | undefined;
+            cases?: {
+                id: string;
+                input: z.core.util.JSONType;
+                expected: z.core.util.JSONType;
+                negative?: boolean | undefined;
+            }[] | undefined;
+        }[];
+        intents: {
+            origin: {
+                ref: string;
+                kind: "external" | "manifest" | "inline";
+            };
+            id: string;
+            statement: string;
+            risk: "basic" | "standard" | "critical";
+            contentHash: string;
+        }[];
+        schemaVersion: 1;
+        commitSha: string;
+        repositoryId?: string | undefined;
+        policyHash?: string | undefined;
+        extractorVersion?: string | undefined;
+        discoveryDiagnostics?: {
+            code: string;
+            sourceRef: string;
+            message: string;
+        }[] | undefined;
+    };
+    inputs: string[];
+    configPaths: string[];
+    claimScopes: {
+        targetRef: string;
+        contractId: string;
+        caseIds: string[];
+        method: string;
+    }[];
+    configRef?: string;
+    policy: {
+        schemaVersion: 1;
+        profileVersion: "1";
+        rules: Record<string, {
+            severity: "error" | "off" | "warn";
+            min?: number | undefined;
+            minMutants?: number | undefined;
+            allowNotApplicable?: string[] | undefined;
+        }>;
+    };
+    config: {
+        rules: Record<string, {
+            severity: "error" | "off" | "warn";
+            min?: number | undefined;
+            minMutants?: number | undefined;
+            allowNotApplicable?: string[] | undefined;
+        }>;
+        schemaVersion: 1;
+        mode: "audit" | "gate";
+        profile: "basic" | "standard" | "critical";
+        profileVersion: "1";
+        riskOverrides: {
+            selector: {
+                kind: "path";
+                value: string;
+            } | {
+                kind: "module";
+                value: string;
+            } | {
+                kind: "contract-kind";
+                value: "external" | "examples" | "invariant" | "state_machine" | "api_contract";
+            };
+            profile: "basic" | "standard" | "critical";
+        }[];
+        git: {
+            base: string;
+        };
+        reports: {
+            vitest?: string | undefined;
+            coverage?: string | undefined;
+            mutation?: string | undefined;
+        };
+        executionManifests: string[];
+        contracts: {
+            enabled: boolean;
+            sources: {
+                type: "external" | "vitest-inline" | "manifest" | "gherkin" | "openapi";
+                include: string[];
+            }[];
+            requireExecutionEvidence: boolean;
+            approval: {
+                provider: "github-protected-review";
+                requiredForRisk: ("basic" | "standard" | "critical")[];
+                onUnverifiable: "unknown";
+            };
+            documents: {
+                output: string;
+                commit: boolean;
+            };
+        };
+        formal?: {
+            models: {
+                id: string;
+                contractId: string;
+                model: string;
+                modelSources: string[];
+                quint: {
+                    entry: string;
+                    version: string;
+                    apalacheVersion?: string | undefined;
+                };
+                properties: string[];
+                checks: ("parse" | "typecheck" | "test" | "run" | "verify")[];
+                maxSteps: number;
+                maxSamples: number;
+                seed: string;
+                timeoutMs: number;
+                report: string;
+                implementationSources: string[];
+                requiredActions: string[];
+                minTraces: number;
+                minComparisons: number;
+                requireCanary: boolean;
+                driver?: string | undefined;
+                driverSources?: string[] | undefined;
+                implementation?: string | undefined;
+                conformanceReport?: string | undefined;
+                traceReceipt?: string | undefined;
+                traceDirectory?: string | undefined;
+                canary?: {
+                    faultId: string;
+                    implementation: string;
+                    targetRef: string;
+                } | undefined;
+            }[];
+        } | undefined;
+    };
+};
+//# sourceMappingURL=registration.d.ts.map

package/dist/registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration.d.ts","sourceRoot":"","sources":["../src/registration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAA2H,KAAK,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAIzK,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoD4B,CAAC;sBAAwC,CAAC;8BACpE,CAAC;;;;;;;;;;;;;;;;;;;;;;;kBAQiD,CAAC;oBACnF,CAAC;oBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAGqG,CAAC;;;;;;;;;;;;;;sBAAkf,CAAC;6BAA+C,CAAC;8BAAkD,CAAC;iCAAmD,CAAC;4BAA8C,CAAC;8BAAgD,CAAC;sBAAwC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAyuB,CAAC;oBAAsC,CAAC;oBAAsC,CAAC;;;;;eAAkJ,CAAC;sBAAwC,CAAC;8BAAgD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAizB,CAAC;;;;;;;;;;;;;;sBAAkf,CAAC;6BAA+C,CAAC;8BAAkD,CAAC;iCAAmD,CAAC;4BAA8C,CAAC;8BAAgD,CAAC;sBAAwC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA3D1gH,CAAC;AACH,MAAM,MAAM,YAAY,GAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC5D,MAAM,MAAM,qBAAqB,GAAC;IAAC,YAAY,EAAC,CAAC,YAAY,EAAC,YAAY,KAAG,OAAO,CAAC;IAAA,cAAc,EAAC,CAAC,QAAQ,EAAC,QAAQ,KAAG,OAAO,CAAA;CAAC,CAAC;AAClI,MAAM,MAAM,oBAAoB,GAAC;IAAC,QAAQ,CAAC,YAAY,EAAC,YAAY,CAAC;IAAA,QAAQ,CAAC,MAAM,EAAC,MAAM,CAAA;CAAC,CAAC;AAG7F,wBAAgB,kBAAkB,CAAC,KAAK,EAAC,OAAO,EAAC,SAAS,EAAC,qBAAqB,GAAE,oBAAoB,CAwBrG;AAQD,wBAAsB,mBAAmB,CAAC,WAAW,EAAC,MAAM,EAAC,SAAS,EAAC,MAAM,EAAC,MAAM,EAAC,oBAAoB;;;GAKxG;AAED,wFAAwF;AACxF,wBAAsB,gBAAgB,CAAC,WAAW,EAAC,MAAM,EAAC,IAAI,EAAC,MAAM,EAAC,cAAc,EAAC,MAAM,GAAE,OAAO,CAAC,YAAY,CAAC,CAKjH;AAED,sGAAsG;AACtG,wBAAgB,uBAAuB,CAAC,KAAK,EAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eARC,CAAC;sBAAwC,CAAC;8BACpE,CAAC;;;;;;;;;;;;;;;;;;;;;;;kBAQiD,CAAC;oBACnF,CAAC;oBAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAGqG,CAAC;;;;;;;;;;;;;;sBAAkf,CAAC;6BAA+C,CAAC;8BAAkD,CAAC;iCAAmD,CAAC;4BAA8C,CAAC;8BAAgD,CAAC;sBAAwC,CAAC;;;;;;;;EADj6B"}