@openpond/evals 0.1.0

package/dist/runs.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { FailureClassSchema, ImmutableArtifactRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "./common.js";
+export const ModelRefSchema = z.object({
+    provider: ReleaseIdSchema,
+    model: ReleaseIdSchema,
+    revision: z.string().trim().min(1).max(500).nullable().default(null),
+    artifactHash: ReleaseHashSchema.nullable().default(null),
+    tokenizerRevision: z.string().trim().min(1).max(500).nullable().default(null),
+    chatTemplateHash: ReleaseHashSchema.nullable().default(null),
+}).strict();
+export const RuntimeTargetBindingSchema = z.object({
+    adapterId: ReleaseIdSchema,
+    placement: z.enum(["local", "remote", "colocated", "provider_native"]),
+    runtimeVersion: z.string().trim().min(1).max(200),
+    capabilityReceipt: ReleaseHashSchema,
+}).strict();
+export const RunLimitsSchema = z.object({
+    maxTurns: z.number().int().positive().max(100_000),
+    timeoutMs: z.number().int().positive().max(86_400_000),
+    maxOutputBytes: z.number().int().positive().max(250_000_000),
+    maximumSpendUsd: z.number().nonnegative().nullable(),
+}).strict();
+export const RunManifestContentSchema = z.object({
+    schemaVersion: z.literal("openpond.runManifest.v1"),
+    id: ReleaseIdSchema,
+    harnessRelease: ImmutableReleaseRefSchema,
+    tasksetRelease: ImmutableReleaseRefSchema,
+    model: ModelRefSchema,
+    runtimeTarget: RuntimeTargetBindingSchema,
+    limits: RunLimitsSchema,
+    approval: z.object({ id: ReleaseIdSchema, contentHash: ReleaseHashSchema }).strict().nullable(),
+    createdAt: ReleaseTimestampSchema,
+    metadata: MetadataSchema,
+}).strict();
+export const RunManifestSchema = RunManifestContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export const AttemptReceiptContentSchema = z.object({
+    schemaVersion: z.literal("openpond.attemptReceipt.v1"),
+    id: ReleaseIdSchema,
+    runManifest: ImmutableReleaseRefSchema,
+    taskId: ReleaseIdSchema,
+    seed: z.string().trim().min(1).max(500),
+    terminal: z.boolean(),
+    failureClass: FailureClassSchema.nullable(),
+    outputHash: ReleaseHashSchema.nullable(),
+    traceHash: ReleaseHashSchema,
+    artifactRefs: z.array(ImmutableArtifactRefSchema).max(100_000),
+    graderEvidenceRefs: z.array(ImmutableArtifactRefSchema).max(10_000),
+    startedAt: ReleaseTimestampSchema,
+    completedAt: ReleaseTimestampSchema,
+    latencyMs: z.number().int().nonnegative(),
+    costUsd: z.number().nonnegative().nullable(),
+    legacyAttemptRef: ReleaseIdSchema.nullable().default(null),
+    metadata: MetadataSchema,
+}).strict();
+export const AttemptReceiptSchema = AttemptReceiptContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export const EvaluationResultContentSchema = z.object({
+    schemaVersion: z.literal("openpond.evaluationResult.v1"),
+    id: ReleaseIdSchema,
+    runManifest: ImmutableReleaseRefSchema,
+    harnessRelease: ImmutableReleaseRefSchema,
+    tasksetRelease: ImmutableReleaseRefSchema,
+    model: ModelRefSchema,
+    receiptRefs: z.array(ImmutableReleaseRefSchema).min(1).max(1_000_000),
+    attemptCount: z.number().int().positive(),
+    rewardEligibleCount: z.number().int().nonnegative(),
+    terminalCount: z.number().int().nonnegative(),
+    meanScore: z.number().min(0).max(1).nullable(),
+    failureCounts: z.record(FailureClassSchema, z.number().int().nonnegative()),
+    metadata: MetadataSchema,
+}).strict();
+export const EvaluationResultSchema = EvaluationResultContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export function createRunManifest(input) {
+    const content = RunManifestContentSchema.parse(input);
+    return RunManifestSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+export function createAttemptReceipt(input) {
+    const content = AttemptReceiptContentSchema.parse(input);
+    return AttemptReceiptSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+export function verifyAttemptReceipt(receipt) {
+    const parsed = AttemptReceiptSchema.safeParse(receipt);
+    if (!parsed.success)
+        return false;
+    const { contentHash: actual, ...content } = parsed.data;
+    return contentHash(AttemptReceiptContentSchema.parse(content)) === actual;
+}
+export function aggregateEvaluationReceipts(input) {
+    if (!input.receipts.length)
+        throw new Error("An evaluation requires at least one attempt receipt.");
+    for (const receipt of input.receipts) {
+        if (receipt.runManifest.id !== input.manifest.id || receipt.runManifest.contentHash !== input.manifest.contentHash) {
+            throw new Error(`Attempt receipt ${receipt.id} belongs to a different Run Manifest.`);
+        }
+        if (!verifyAttemptReceipt(receipt))
+            throw new Error(`Attempt receipt ${receipt.id} has an invalid content hash.`);
+    }
+    const scores = input.receipts.flatMap((receipt) => typeof receipt.metadata.score === "number" && Number.isFinite(receipt.metadata.score)
+        ? [receipt.metadata.score]
+        : []);
+    const failureCounts = Object.fromEntries(FailureClassSchema.options.map((failure) => [failure, input.receipts.filter((receipt) => receipt.failureClass === failure).length]));
+    const content = EvaluationResultContentSchema.parse({
+        schemaVersion: "openpond.evaluationResult.v1",
+        id: input.id,
+        runManifest: { id: input.manifest.id, contentHash: input.manifest.contentHash },
+        harnessRelease: input.manifest.harnessRelease,
+        tasksetRelease: input.manifest.tasksetRelease,
+        model: input.manifest.model,
+        receiptRefs: input.receipts.map((receipt) => ({ id: receipt.id, contentHash: receipt.contentHash })),
+        attemptCount: input.receipts.length,
+        rewardEligibleCount: input.receipts.filter((receipt) => receipt.metadata.rewardEligible === true && receipt.failureClass !== "infrastructure_failure").length,
+        terminalCount: input.receipts.filter((receipt) => receipt.terminal).length,
+        meanScore: scores.length ? scores.reduce((total, score) => total + score, 0) / scores.length : null,
+        failureCounts,
+        metadata: input.metadata ?? {},
+    });
+    return EvaluationResultSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+export function assertComparableRunManifests(base, candidate) {
+    if (base.harnessRelease.contentHash !== candidate.harnessRelease.contentHash) {
+        throw new Error("Evaluation runs use different Harness Releases.");
+    }
+    if (base.tasksetRelease.contentHash !== candidate.tasksetRelease.contentHash) {
+        throw new Error("Evaluation runs use different Taskset Releases.");
+    }
+}
+export function rewardEligibleReceipts(receipts) {
+    return receipts.filter((receipt) => receipt.terminal
+        && receipt.failureClass !== "infrastructure_failure"
+        && receipt.failureClass !== "timeout"
+        && receipt.failureClass !== "cancelled"
+        && receipt.metadata.rewardEligible === true
+        && typeof receipt.metadata.score === "number");
+}

package/dist/sha256.js

@@ -0,0 +1,91 @@
+// FIPS 180-4 SHA-256 implemented over platform-neutral typed arrays so the
+// portable contracts keep the same synchronous content-hash API in any host.
+const INITIAL_STATE = new Uint32Array([
+    0x6a09e667,
+    0xbb67ae85,
+    0x3c6ef372,
+    0xa54ff53a,
+    0x510e527f,
+    0x9b05688c,
+    0x1f83d9ab,
+    0x5be0cd19,
+]);
+const ROUND_CONSTANTS = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+export function sha256Hex(value) {
+    const bytes = typeof value === "string" ? new TextEncoder().encode(value) : value;
+    const paddedLength = Math.ceil((bytes.byteLength + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.byteLength] = 0x80;
+    const bitLength = bytes.byteLength * 8;
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x1_0000_0000), false);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    const state = new Uint32Array(INITIAL_STATE);
+    const words = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            words[index] = view.getUint32(offset + index * 4, false);
+        }
+        for (let index = 16; index < 64; index += 1) {
+            const previous = words[index - 15];
+            const recent = words[index - 2];
+            const sigma0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ (previous >>> 3);
+            const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ (recent >>> 10);
+            words[index] = (words[index - 16] + sigma0 + words[index - 7] + sigma1) >>> 0;
+        }
+        let a = state[0];
+        let b = state[1];
+        let c = state[2];
+        let d = state[3];
+        let e = state[4];
+        let f = state[5];
+        let g = state[6];
+        let h = state[7];
+        for (let index = 0; index < 64; index += 1) {
+            const choice = (e & f) ^ (~e & g);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const first = (h + sum1 + choice + ROUND_CONSTANTS[index] + words[index]) >>> 0;
+            const second = (sum0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + first) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (first + second) >>> 0;
+        }
+        state[0] = (state[0] + a) >>> 0;
+        state[1] = (state[1] + b) >>> 0;
+        state[2] = (state[2] + c) >>> 0;
+        state[3] = (state[3] + d) >>> 0;
+        state[4] = (state[4] + e) >>> 0;
+        state[5] = (state[5] + f) >>> 0;
+        state[6] = (state[6] + g) >>> 0;
+        state[7] = (state[7] + h) >>> 0;
+    }
+    return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}

package/dist/tasksets.js

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, MetadataSchema, ReleaseHashSchema, ReleaseIdSchema, assertContentHash, contentHash, } from "./common.js";
+export const TaskSplitSchema = z.enum(["train", "validation", "test", "frozen_eval"]);
+export const PolicyBoundarySchema = z.object({
+    policyVisibleFields: z.array(ReleaseIdSchema).max(1_000).default([]),
+    privilegedFields: z.array(ReleaseIdSchema).max(1_000).default([]),
+    hiddenGraderRefs: z.array(ReleaseIdSchema).max(1_000).default([]),
+    connectedAppScopes: z.array(ReleaseIdSchema).max(100).default([]),
+}).strict();
+export const ToolDeclarationSchema = z.object({
+    name: z.string().trim().min(1).max(64).regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    description: z.string().trim().min(1).max(2_000),
+    inputSchema: z.record(z.string(), z.unknown()),
+    inputSchemaHash: ReleaseHashSchema,
+    sideEffect: z.enum(["read", "write"]),
+    timeoutMs: z.number().int().positive().max(3_600_000),
+}).strict();
+export const CapabilityRequirementSchema = z.object({
+    id: ReleaseIdSchema,
+    required: z.boolean(),
+    scopes: z.array(z.string().trim().min(1).max(500)).max(100).default([]),
+    portability: z.enum(["portable", "host_adapter", "local_only", "hosted_only"]),
+}).strict();
+export const EnvironmentContractSchema = z.object({
+    protocolVersion: z.literal("openpond.environment.v1"),
+    kind: z.enum(["text", "agent", "work", "custom_program"]),
+    entrypoint: z.string().trim().min(1).max(1_000),
+    stateful: z.boolean(),
+    deterministicSeeds: z.boolean(),
+    lifecycle: z.array(z.enum(["create", "reset", "step", "collect", "destroy"])).min(5).max(5),
+    networkPolicy: z.enum(["none", "declared_read_only", "declared_scoped"]),
+    defaultTimeoutMs: z.number().int().positive().max(3_600_000),
+}).strict();
+const GraderBaseSchema = z.object({
+    id: ReleaseIdSchema,
+    version: z.string().trim().min(1).max(100),
+    weight: z.number().nonnegative().max(1_000).default(1),
+    hardGate: z.boolean().default(false),
+    rewardEligible: z.boolean().default(false),
+    privileged: z.boolean().default(false),
+});
+export const DeterministicGraderSpecSchema = GraderBaseSchema.extend({
+    kind: z.enum(["content", "schema", "artifact", "runtime_event", "state"]),
+    config: z.record(z.string(), z.unknown()),
+}).strict();
+export const ModelJudgeGraderSpecSchema = GraderBaseSchema.extend({
+    kind: z.literal("model_judge"),
+    rubricRef: ImmutableAssetRefSchema,
+    calibrationStatus: z.enum(["pending", "passed", "failed"]),
+}).strict();
+export const CustomVerifierGraderSpecSchema = GraderBaseSchema.extend({
+    kind: z.literal("custom_verifier"),
+    verifierRef: ImmutableAssetRefSchema,
+    timeoutMs: z.number().int().positive().max(300_000),
+    networkPolicy: z.literal("none"),
+}).strict();
+export const HumanGraderSpecSchema = GraderBaseSchema.extend({
+    kind: z.literal("human"),
+    rubricRef: ImmutableAssetRefSchema,
+    reviewerRole: z.string().trim().min(1).max(500),
+}).strict();
+export const GraderSpecSchema = z.union([
+    DeterministicGraderSpecSchema,
+    ModelJudgeGraderSpecSchema,
+    CustomVerifierGraderSpecSchema,
+    HumanGraderSpecSchema,
+]);
+export const TaskRecordSchema = z.object({
+    id: ReleaseIdSchema,
+    clusterKey: ReleaseIdSchema,
+    split: TaskSplitSchema,
+    input: z.record(z.string(), z.unknown()),
+    expectedOutput: z.record(z.string(), z.unknown()).nullable(),
+    policyVisibleContext: z.record(z.string(), z.unknown()).default({}),
+    privilegedContextRef: ReleaseIdSchema.nullable(),
+    artifactRefs: z.array(ImmutableAssetRefSchema).max(1_000).default([]),
+    tags: z.array(ReleaseIdSchema).max(100).default([]),
+}).strict();
+export const TasksetReleaseContentSchema = z.object({
+    schemaVersion: z.literal("openpond.tasksetRelease.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    harnessRelease: ImmutableReleaseRefSchema,
+    policy: PolicyBoundarySchema,
+    environment: EnvironmentContractSchema,
+    tools: z.array(ToolDeclarationSchema).max(200),
+    capabilities: z.array(CapabilityRequirementSchema).max(200),
+    tasks: z.array(TaskRecordSchema).min(1).max(1_000_000),
+    graders: z.array(GraderSpecSchema).min(1).max(1_000),
+    metadata: MetadataSchema,
+}).strict();
+export const TasksetReleaseSchema = TasksetReleaseContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export function validateTasksetRelease(input) {
+    const parsed = TasksetReleaseSchema.safeParse(input);
+    if (!parsed.success) {
+        return {
+            valid: false,
+            taskset: null,
+            computedHash: null,
+            issues: parsed.error.issues.map((issue) => ({
+                code: "schema_invalid",
+                severity: "error",
+                message: issue.message,
+                path: issue.path.join("."),
+            })),
+        };
+    }
+    const taskset = parsed.data;
+    const issues = [];
+    const clusterSplits = new Map();
+    for (const task of taskset.tasks) {
+        const splits = clusterSplits.get(task.clusterKey) ?? new Set();
+        splits.add(task.split);
+        clusterSplits.set(task.clusterKey, splits);
+    }
+    for (const [cluster, splits] of clusterSplits) {
+        if (splits.size > 1)
+            issues.push({
+                code: "split_cluster_contamination",
+                severity: "error",
+                message: `Source cluster ${cluster} appears in multiple splits.`,
+                path: "tasks",
+            });
+    }
+    if (!taskset.tasks.some((task) => task.split === "frozen_eval"))
+        issues.push({
+            code: "frozen_eval_missing",
+            severity: "warning",
+            message: "The release has no frozen-evaluation task.",
+            path: "tasks",
+        });
+    const { contentHash: _contentHash, ...tasksetContent } = taskset;
+    const computedHash = contentHash(TasksetReleaseContentSchema.parse(tasksetContent));
+    if (computedHash !== taskset.contentHash)
+        issues.push({
+            code: "content_hash_mismatch",
+            severity: "error",
+            message: `Taskset contentHash is ${taskset.contentHash}; expected ${computedHash}.`,
+            path: "contentHash",
+        });
+    return { valid: !issues.some((issue) => issue.severity === "error"), taskset, computedHash, issues };
+}
+export function assertTasksetRelease(taskset) {
+    assertContentHash(taskset, "Taskset release");
+    const report = validateTasksetRelease(taskset);
+    const error = report.issues.find((issue) => issue.severity === "error");
+    if (error)
+        throw new Error(error.message);
+}
+export function policyTaskView(task) {
+    return {
+        id: task.id,
+        input: structuredClone(task.input),
+        policyVisibleContext: structuredClone(task.policyVisibleContext),
+        artifactRefs: task.artifactRefs.filter((artifact) => artifact.visibility === "policy"),
+        tags: [...task.tags],
+    };
+}
+export function trainingPolicyTaskViews(taskset) {
+    return taskset.tasks
+        .filter((task) => task.split !== "frozen_eval")
+        .map(policyTaskView);
+}

package/dist/types/common.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare const MAX_PORTABLE_PATH_BYTES = 2000;
+export declare const MAX_PORTABLE_ASSET_BYTES = 250000000;
+export declare const ReleaseIdSchema: z.ZodString;
+export declare const ReleaseHashSchema: z.ZodString;
+export declare const ReleaseTimestampSchema: z.ZodString;
+export declare const MetadataSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare const ImmutableReleaseRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const ImmutableAssetRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    path: z.ZodString;
+    contentHash: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    mediaType: z.ZodString;
+    visibility: z.ZodEnum<{
+        policy: "policy";
+        verifier: "verifier";
+        host_private: "host_private";
+    }>;
+}, z.core.$strict>;
+export declare const ImmutableArtifactRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+    mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+export declare const FailureClassSchema: z.ZodEnum<{
+    policy_failure: "policy_failure";
+    grader_failure: "grader_failure";
+    environment_failure: "environment_failure";
+    infrastructure_failure: "infrastructure_failure";
+    timeout: "timeout";
+    cancelled: "cancelled";
+}>;
+export declare function canonicalJson(value: unknown): string;
+export declare function sha256(value: string | Uint8Array): string;
+export declare function contentHash(value: unknown): string;
+export declare function withContentHash<T extends Record<string, unknown>>(value: T): T & {
+    contentHash: string;
+};
+export declare function assertContentHash(value: {
+    contentHash: string;
+} & Record<string, unknown>, label: string): void;
+export type ImmutableReleaseRef = z.infer<typeof ImmutableReleaseRefSchema>;
+export type ImmutableAssetRef = z.infer<typeof ImmutableAssetRefSchema>;
+export type ImmutableArtifactRef = z.infer<typeof ImmutableArtifactRefSchema>;
+export type FailureClass = z.infer<typeof FailureClassSchema>;
+//# sourceMappingURL=common.d.ts.map

package/dist/types/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB,OAAQ,CAAC;AAC7C,eAAO,MAAM,wBAAwB,YAAc,CAAC;AACpD,eAAO,MAAM,eAAe,aAAoC,CAAC;AACjE,eAAO,MAAM,iBAAiB,aAAqC,CAAC;AACpE,eAAO,MAAM,sBAAsB,aAAwC,CAAC;AAC5E,eAAO,MAAM,cAAc,sDAAgD,CAAC;AAE5E,eAAO,MAAM,yBAAyB;;;kBAG3B,CAAC;AAEZ,eAAO,MAAM,uBAAuB;;;;;;;;;;;kBAOzB,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;kBAK5B,CAAC;AAEZ,eAAO,MAAM,kBAAkB;;;;;;;EAO7B,CAAC;AAEH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAEzD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElD;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAExG;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI/G;AAkBD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}