openpond-sdk 0.12.13 → 0.12.15

package/dist/types/packages/sdk/src/neuron-calibration-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neuron-calibration-records.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-calibration-records.ts"],"names":[],"mappings":"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"}

package/dist/types/packages/sdk/src/neuron-residual-calibration.d.ts

@@ -0,0 +1,189 @@
+import { z } from "zod";
+/** One unsteered forward over an explicit tokenized source. No result scales
+ * or profile publication evidence are accepted as a calibration source. */
+export declare const NeuronResidualCalibrationRequestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationRequest.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    prompt: z.ZodObject<{
+        id: z.ZodString;
+        tokenIds: z.ZodArray<z.ZodNumber>;
+        attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    }, z.core.$strict>;
+    layers: z.ZodArray<z.ZodNumber>;
+    maximumForwardTokenWork: z.ZodNumber;
+    maximumDurationSeconds: z.ZodNumber;
+}, z.core.$strict>;
+export type NeuronResidualCalibrationRequest = z.infer<typeof NeuronResidualCalibrationRequestSchema>;
+export declare const NeuronResidualCalibrationExportContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.v1">;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    prompt: z.ZodObject<{
+        id: z.ZodString;
+        tokenIds: z.ZodArray<z.ZodNumber>;
+        attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    }, z.core.$strict>;
+    calibration: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        modelHash: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        statistic: z.ZodLiteral<"midpoint_median_fp32">;
+        sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+        layers: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            median: z.ZodNumber;
+            sampleCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+        implementationHash: z.ZodString;
+        torchVersion: z.ZodString;
+        device: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NeuronResidualCalibrationExportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibrationExport.v1">;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    prompt: z.ZodObject<{
+        id: z.ZodString;
+        tokenIds: z.ZodArray<z.ZodNumber>;
+        attentionMask: z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    }, z.core.$strict>;
+    calibration: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        modelHash: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        statistic: z.ZodLiteral<"midpoint_median_fp32">;
+        sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+        layers: z.ZodArray<z.ZodObject<{
+            layer: z.ZodNumber;
+            median: z.ZodNumber;
+            sampleCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    runtime: z.ZodObject<{
+        implementation: z.ZodLiteral<"torch_dense_serial_calibration_v1">;
+        implementationHash: z.ZodString;
+        torchVersion: z.ZodString;
+        device: z.ZodString;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronResidualCalibrationExport = z.infer<typeof NeuronResidualCalibrationExportSchema>;
+export declare function parseAndVerifyNeuronResidualCalibrationExport(raw: unknown, expected?: NeuronResidualCalibrationRequest): Promise<{
+    schemaVersion: "openpond.neuronResidualCalibrationExport.v1";
+    model: {
+        schemaVersion: "openpond.neuronSteeringModel.v1";
+        modelId: string;
+        revision: string;
+        configHash: string;
+        weightsHash: string;
+        tokenizerHash: string;
+        weightIdentity: "torch_state_dict_sha256_v1";
+        architecture: "dense_decoder";
+        dtype: "bfloat16" | "float16" | "float32";
+        quantization: "none";
+        adapter: null;
+        hiddenSize: number;
+        intermediateSizes: number[];
+    };
+    prompt: {
+        id: string;
+        tokenIds: number[];
+        attentionMask: (0 | 1)[];
+    };
+    calibration: {
+        schemaVersion: "openpond.neuronResidualCalibration.v1";
+        id: string;
+        revision: number;
+        modelHash: string;
+        source: {
+            id: string;
+            contentHash: string;
+        };
+        statistic: "midpoint_median_fp32";
+        sample: "non_padding_prompt_after_position_zero";
+        layers: {
+            layer: number;
+            median: number;
+            sampleCount: number;
+        }[];
+        contentHash: string;
+    };
+    runtime: {
+        implementation: "torch_dense_serial_calibration_v1";
+        implementationHash: string;
+        torchVersion: string;
+        device: string;
+    };
+    contentHash: string;
+}>;
+//# sourceMappingURL=neuron-residual-calibration.d.ts.map

package/dist/types/packages/sdk/src/neuron-residual-calibration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neuron-residual-calibration.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-residual-calibration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB;2EAC2E;AAC3E,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAcjD,CAAC;AACH,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC;AAEtG,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM9C,CAAC;AACZ,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsF,CAAC;AACzI,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAEpG,wBAAsB,6CAA6C,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAe5H"}

package/dist/types/packages/sdk/src/neuron-steering.d.ts

@@ -0,0 +1,260 @@
+import { z } from "zod";
+export declare const NeuronSteeringReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+/** Reference identity is verified against tensor state, configuration and
+ * tokenizer descriptors. It is not a registry publication or worker release. */
+export declare const NeuronSteeringModelSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+    modelId: z.ZodString;
+    revision: z.ZodString;
+    configHash: z.ZodString;
+    weightsHash: z.ZodString;
+    tokenizerHash: z.ZodString;
+    weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+    architecture: z.ZodLiteral<"dense_decoder">;
+    dtype: z.ZodEnum<{
+        bfloat16: "bfloat16";
+        float16: "float16";
+        float32: "float32";
+    }>;
+    quantization: z.ZodLiteral<"none">;
+    adapter: z.ZodNull;
+    hiddenSize: z.ZodNumber;
+    intermediateSizes: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+export type NeuronSteeringModel = z.infer<typeof NeuronSteeringModelSchema>;
+export declare const NeuronSteeringEntrySchema: z.ZodObject<{
+    layer: z.ZodNumber;
+    neuron: z.ZodNumber;
+    dose: z.ZodNumber;
+}, z.core.$strict>;
+export declare const NeuronSteeringTokenScopeSchema: z.ZodObject<{
+    phase: z.ZodEnum<{
+        decode_only: "decode_only";
+        prompt_and_decode: "prompt_and_decode";
+        prompt_only: "prompt_only";
+    }>;
+    positions: z.ZodEnum<{
+        after_position_zero: "after_position_zero";
+        all_non_padding: "all_non_padding";
+    }>;
+}, z.core.$strict>;
+export declare const NeuronSteeringNormalizationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"fixed_residual_reference">;
+    calibration: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "mode">;
+export declare const NeuronSteeringProfileContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.v1">;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    hook: z.ZodLiteral<"mlp.down_proj.input">;
+    operation: z.ZodLiteral<"add">;
+    normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+        statistic: z.ZodLiteral<"midpoint_median_fp32">;
+        sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"fixed_residual_reference">;
+        calibration: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "mode">;
+    tokenScope: z.ZodObject<{
+        phase: z.ZodEnum<{
+            decode_only: "decode_only";
+            prompt_and_decode: "prompt_and_decode";
+            prompt_only: "prompt_only";
+        }>;
+        positions: z.ZodEnum<{
+            after_position_zero: "after_position_zero";
+            all_non_padding: "all_non_padding";
+        }>;
+    }, z.core.$strict>;
+    entries: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        neuron: z.ZodNumber;
+        dose: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const NeuronSteeringProfileSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronSteeringProfile.v1">;
+    model: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.neuronSteeringModel.v1">;
+        modelId: z.ZodString;
+        revision: z.ZodString;
+        configHash: z.ZodString;
+        weightsHash: z.ZodString;
+        tokenizerHash: z.ZodString;
+        weightIdentity: z.ZodLiteral<"torch_state_dict_sha256_v1">;
+        architecture: z.ZodLiteral<"dense_decoder">;
+        dtype: z.ZodEnum<{
+            bfloat16: "bfloat16";
+            float16: "float16";
+            float32: "float32";
+        }>;
+        quantization: z.ZodLiteral<"none">;
+        adapter: z.ZodNull;
+        hiddenSize: z.ZodNumber;
+        intermediateSizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    hook: z.ZodLiteral<"mlp.down_proj.input">;
+    operation: z.ZodLiteral<"add">;
+    normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"baseline_prompt_residual_median">;
+        statistic: z.ZodLiteral<"midpoint_median_fp32">;
+        sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"fixed_residual_reference">;
+        calibration: z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "mode">;
+    tokenScope: z.ZodObject<{
+        phase: z.ZodEnum<{
+            decode_only: "decode_only";
+            prompt_and_decode: "prompt_and_decode";
+            prompt_only: "prompt_only";
+        }>;
+        positions: z.ZodEnum<{
+            after_position_zero: "after_position_zero";
+            all_non_padding: "all_non_padding";
+        }>;
+    }, z.core.$strict>;
+    entries: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        neuron: z.ZodNumber;
+        dose: z.ZodNumber;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronSteeringProfile = z.infer<typeof NeuronSteeringProfileSchema>;
+export declare function createNeuronSteeringProfile(raw: z.input<typeof NeuronSteeringProfileContentSchema>): Promise<NeuronSteeringProfile>;
+export declare function parseAndVerifyNeuronSteeringProfile(raw: unknown, model?: NeuronSteeringModel): Promise<{
+    schemaVersion: "openpond.neuronSteeringProfile.v1";
+    model: {
+        schemaVersion: "openpond.neuronSteeringModel.v1";
+        modelId: string;
+        revision: string;
+        configHash: string;
+        weightsHash: string;
+        tokenizerHash: string;
+        weightIdentity: "torch_state_dict_sha256_v1";
+        architecture: "dense_decoder";
+        dtype: "bfloat16" | "float16" | "float32";
+        quantization: "none";
+        adapter: null;
+        hiddenSize: number;
+        intermediateSizes: number[];
+    };
+    hook: "mlp.down_proj.input";
+    operation: "add";
+    normalization: {
+        mode: "baseline_prompt_residual_median";
+        statistic: "midpoint_median_fp32";
+        sample: "non_padding_prompt_after_position_zero";
+    } | {
+        mode: "fixed_residual_reference";
+        calibration: {
+            id: string;
+            revision: number;
+            contentHash: string;
+        };
+    };
+    tokenScope: {
+        phase: "decode_only" | "prompt_and_decode" | "prompt_only";
+        positions: "after_position_zero" | "all_non_padding";
+    };
+    entries: {
+        layer: number;
+        neuron: number;
+        dose: number;
+    }[];
+    contentHash: string;
+}>;
+export declare const NeuronResidualCalibrationContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    modelHash: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+    layers: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        median: z.ZodNumber;
+        sampleCount: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const NeuronResidualCalibrationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.neuronResidualCalibration.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    modelHash: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    statistic: z.ZodLiteral<"midpoint_median_fp32">;
+    sample: z.ZodLiteral<"non_padding_prompt_after_position_zero">;
+    layers: z.ZodArray<z.ZodObject<{
+        layer: z.ZodNumber;
+        median: z.ZodNumber;
+        sampleCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type NeuronResidualCalibration = z.infer<typeof NeuronResidualCalibrationSchema>;
+export declare function parseAndVerifyNeuronResidualCalibration(raw: unknown, model: NeuronSteeringModel, reference?: z.infer<typeof NeuronSteeringReferenceSchema>): Promise<{
+    schemaVersion: "openpond.neuronResidualCalibration.v1";
+    id: string;
+    revision: number;
+    modelHash: string;
+    source: {
+        id: string;
+        contentHash: string;
+    };
+    statistic: "midpoint_median_fp32";
+    sample: "non_padding_prompt_after_position_zero";
+    layers: {
+        layer: number;
+        median: number;
+        sampleCount: number;
+    }[];
+    contentHash: string;
+}>;
+//# sourceMappingURL=neuron-steering.d.ts.map

package/dist/types/packages/sdk/src/neuron-steering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neuron-steering.d.ts","sourceRoot":"","sources":["../../../../../src/neuron-steering.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,6BAA6B;;;;kBAA0F,CAAC;AAErI;gFACgF;AAChF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;kBAO3B,CAAC;AACZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,eAAO,MAAM,yBAAyB;;;;kBAE3B,CAAC;AACZ,eAAO,MAAM,8BAA8B;;;;;;;;;;kBAGhC,CAAC;AACZ,eAAO,MAAM,iCAAiC;;;;;;;;;;;4BAI5C,CAAC;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAa7C,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAuE,CAAC;AAChH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAGzI;AACD,wBAAsB,mCAAmC,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKlG;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;kBASjD,CAAC;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;kBAA2E,CAAC;AACxH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,wBAAsB,uCAAuC,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,mBAAmB,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC;;;;;;;;;;;;;;;;;GAOhK"}