@open-agent-toolkit/cli 0.2.51 → 0.2.53

package/dist/providers/identity/codex-runtime-observation.js

@@ -0,0 +1,255 @@
+import { observationIdentifier as observedValue } from './oat-dispatch-record.js';
+/**
+ * Codex rollout metadata parsing.
+ *
+ * Field paths here are taken from captured Codex 0.152.1 rollouts, not from
+ * assumption; see `codex-runtime-observation.fixtures.ts` for the sanitized
+ * captures the tests run against.
+ *
+ * Four accepted paths are UNVERIFIED against any captured rollout and appear
+ * zero times in the operator's local corpus (1,596 rollouts spanning cli_version
+ * 0.142.4-0.152.x, as of 2026-09-02, on the capturing operator's machine): `turn_context.service_tier`,
+ * `turn_context.serviceTier`, `turn_context.reasoning_effort`, and
+ * `session_meta.request_id`. They are retained as forward-compatible readers
+ * and all fail closed to `null`, so no Codex rollout observed to date reports a
+ * service tier, and Codex request correlation is caller-asserted in practice.
+ * They are labelled here for the same reason `CLAUDE_INIT_KEYS` is labelled:
+ * an unverified path must not read as a captured one. An earlier revision of this parser read
+ * `payload.parent_id` and `payload.role`, which Codex does not emit, so every
+ * subagent was misreported as a root with no role while hand-written fixtures
+ * agreed with the parser instead of with the world.
+ *
+ * The parser reads session and turn metadata only. Entries are classified by
+ * their `type` discriminator alone, and the payload of any entry outside
+ * {@link CODEX_METADATA_ENTRY_TYPES} is never touched, so conversation content,
+ * instructions, and tool output cannot be reached from here. Every extracted
+ * value is a short provider identifier validated against a closed shape before
+ * it can become durable evidence.
+ *
+ * Everything this module produces is per-run, non-authoritative corroboration.
+ * A failed or partial parse yields `not-reported`; it never falls back to the
+ * configured invocation, so a requested value cannot masquerade as an
+ * observation.
+ */
+/** Entry types whose payloads are metadata rather than conversation content. */
+export const CODEX_METADATA_ENTRY_TYPES = [
+    'session_meta',
+    'turn_context',
+];
+export const CODEX_OBSERVATION_SOURCE = 'codex-rollout-metadata';
+const MAX_AGENT_PATH_LENGTH = 1024;
+const MAX_AGENT_PATH_SEGMENTS = 64;
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0
+        ? value
+        : null;
+}
+function metadataEntryType(entry) {
+    if (!isRecord(entry))
+        return null;
+    const type = entry.type;
+    return typeof type === 'string' &&
+        CODEX_METADATA_ENTRY_TYPES.includes(type)
+        ? type
+        : null;
+}
+function metadataPayload(entry) {
+    const payload = entry.payload;
+    return isRecord(payload) ? payload : null;
+}
+/**
+ * `source` is either a plain string for a user-started session (`exec`, `cli`,
+ * `vscode`) or a tagged object for a spawned one. Only the tagged object form
+ * carries spawn metadata.
+ */
+function threadSpawn(payload) {
+    const source = payload.source;
+    if (!isRecord(source))
+        return null;
+    const subagent = source.subagent;
+    if (!isRecord(subagent))
+        return null;
+    const spawn = subagent.thread_spawn;
+    return isRecord(spawn) ? spawn : null;
+}
+/**
+ * Depth implied by `agent_path`, whose first segment is the root. Used only to
+ * corroborate a declared depth; it is never stored and never stands alone.
+ */
+function agentPathDepth(value) {
+    if (typeof value !== 'string')
+        return null;
+    if (value.length === 0 || value.length > MAX_AGENT_PATH_LENGTH)
+        return null;
+    const segments = value.split('/').filter((segment) => segment.length > 0);
+    if (segments.length === 0 || segments.length > MAX_AGENT_PATH_SEGMENTS) {
+        return null;
+    }
+    return segments.length - 1;
+}
+function sessionFrame(payload) {
+    const spawn = threadSpawn(payload);
+    return {
+        id: observedValue(payload.id),
+        parentThreadId: observedValue(payload.parent_thread_id) ??
+            observedValue(spawn?.parent_thread_id),
+        forkedFromId: observedValue(payload.forked_from_id),
+        threadSource: observedValue(payload.thread_source),
+        subagentSource: spawn !== null,
+        declaredDepth: nonNegativeInteger(spawn?.depth),
+        agentPathSegments: agentPathDepth(payload.agent_path) ?? agentPathDepth(spawn?.agent_path),
+        role: observedValue(payload.agent_role) ?? observedValue(spawn?.agent_role),
+        // UNVERIFIED path; Codex declares no OAT request id in any capture.
+        requestId: observedValue(payload.request_id),
+        historyStartOrdinal: nonNegativeInteger(payload.subagent_history_start_ordinal),
+    };
+}
+/**
+ * A session is a child when it says so, when it carries spawn metadata, or when
+ * it names a parent thread. Root is the absence of all three — never the
+ * presence of a `session_id`, which on a subagent holds the *root's* id and
+ * would classify every child as a root.
+ */
+function isChildSession(frame) {
+    return (frame.threadSource === 'subagent' ||
+        frame.subagentSource ||
+        frame.parentThreadId !== null);
+}
+/**
+ * Resolve lineage for the applicable session.
+ *
+ * The provider-declared `depth` is authoritative: it is a fact the runtime
+ * states about itself, so it is used rather than re-derived. When `agent_path`
+ * is also present the two are reconciled, and a disagreement yields
+ * `depth-unknown` rather than a choice between two contradictory sources. The
+ * parent-thread chain walk is only a fallback for a child that declares no
+ * depth, and a parent named but absent from this rollout stays `depth-unknown`.
+ */
+function childLineage(frame, byId) {
+    if (!isChildSession(frame))
+        return 'root';
+    if (frame.declaredDepth !== null) {
+        if (frame.agentPathSegments !== null &&
+            frame.agentPathSegments !== frame.declaredDepth) {
+            return 'depth-unknown';
+        }
+        return frame.declaredDepth === 0 ? 'root' : `depth-${frame.declaredDepth}`;
+    }
+    if (frame.parentThreadId === null)
+        return 'depth-unknown';
+    let depth = 0;
+    let current = frame;
+    const visited = new Set();
+    while (current.parentThreadId !== null) {
+        if (current.id !== null) {
+            if (visited.has(current.id))
+                return 'depth-unknown';
+            visited.add(current.id);
+        }
+        const parent = byId.get(current.parentThreadId);
+        depth += 1;
+        if (!parent || depth > MAX_AGENT_PATH_SEGMENTS)
+            return 'depth-unknown';
+        current = parent;
+    }
+    return `depth-${depth}`;
+}
+/**
+ * Select the turn contexts that belong to the applicable session.
+ *
+ * A subagent rollout embeds its parent's history, including the parent's turn
+ * context. `subagent_history_start_ordinal` marks where the session's own
+ * records begin, which is how a depth-1 rollout is kept from reporting its
+ * parent's model. Confirmed against the captured depth-1 rollout, whose
+ * embedded parent turn context sits below that ordinal and whose own turn
+ * context sits above it.
+ */
+function applicableTurns(turns, historyStartOrdinal) {
+    if (historyStartOrdinal === null)
+        return turns;
+    const own = turns.filter((turn) => turn.ordinal !== null && turn.ordinal >= historyStartOrdinal);
+    return own.length > 0 ? own : turns;
+}
+/**
+ * Extract the applicable child's metadata from Codex rollout entries.
+ *
+ * The applicable session is the *first* `session_meta`: a rollout's own header
+ * is written at ordinal 0, and any embedded parent history follows it.
+ */
+export function extractCodexRuntimeMetadata(entries) {
+    if (!Array.isArray(entries))
+        return null;
+    const frames = [];
+    const turns = [];
+    for (const entry of entries) {
+        // Classification is by discriminator alone. A conversation entry's payload
+        // is never read.
+        const type = metadataEntryType(entry);
+        if (type === null)
+            continue;
+        const record = entry;
+        const payload = metadataPayload(record);
+        if (payload === null)
+            continue;
+        if (type === 'session_meta') {
+            frames.push(sessionFrame(payload));
+            continue;
+        }
+        turns.push({
+            ordinal: nonNegativeInteger(record.ordinal),
+            model: observedValue(payload.model),
+            effort: observedValue(payload.effort) ??
+                observedValue(payload.reasoning_effort),
+            serviceTier: observedValue(payload.service_tier) ??
+                observedValue(payload.serviceTier),
+        });
+    }
+    const applicable = frames[0];
+    if (!applicable)
+        return null;
+    const byId = new Map();
+    for (const frame of frames) {
+        if (frame.id !== null && !byId.has(frame.id))
+            byId.set(frame.id, frame);
+    }
+    let model = null;
+    let effort = null;
+    let serviceTier = null;
+    for (const turn of applicableTurns(turns, applicable.historyStartOrdinal)) {
+        model = turn.model ?? model;
+        effort = turn.effort ?? effort;
+        serviceTier = turn.serviceTier ?? serviceTier;
+    }
+    return {
+        childLineage: childLineage(applicable, byId),
+        role: applicable.role,
+        model,
+        effort,
+        serviceTier,
+        requestId: applicable.requestId,
+        threadSource: applicable.threadSource,
+        forkedFromId: applicable.forkedFromId,
+    };
+}
+/**
+ * Neutral observation facts for the cross-provider projection.
+ *
+ * Nothing of the rollout's own shape escapes this module: the caller receives
+ * only the closed fact set owned by `runtime-observation.ts`.
+ */
+export function observeCodexRuntimeFacts(entries) {
+    const metadata = extractCodexRuntimeMetadata(entries);
+    if (metadata === null)
+        return null;
+    return {
+        lineage: metadata.childLineage,
+        role: metadata.role,
+        model: metadata.model,
+        effort: metadata.effort,
+        serviceTier: metadata.serviceTier,
+        correlation: metadata.requestId,
+    };
+}

package/dist/providers/identity/generic-dispatch-record.d.ts

@@ -0,0 +1,313 @@
+import { z } from 'zod';
+/**
+ * Whole-record ceiling, applied at every parse entry point so no combination
+ * of individually legal fields can produce an unbounded journal revision.
+ */
+export declare function assertBoundedDispatchRecordSize(value: unknown): void;
+export declare const genericDispatchRecordSchema: z.ZodEffects<z.ZodObject<{
+    request_id: z.ZodString;
+    caller: z.ZodString;
+    scope: z.ZodString;
+    objective: z.ZodString;
+    action: z.ZodString;
+    role_name: z.ZodString;
+    role_class: z.ZodString;
+    provider: z.ZodString;
+    dispatch_context: z.ZodString;
+    dispatch_policy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    dispatch_ceiling: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    catalog_snapshot: z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        observed_at: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        source: string;
+        observed_at: string;
+    }, {
+        id: string;
+        source: string;
+        observed_at: string;
+    }>;
+    authority: z.ZodString;
+    role_selector: z.ZodNullable<z.ZodString>;
+    model_selector: z.ZodNullable<z.ZodString>;
+    model_selector_granularity: z.ZodNullable<z.ZodString>;
+    effort_selector: z.ZodNullable<z.ZodString>;
+    reasoning_mode_selector: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    service_tier_selector: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    guidance_reference: z.ZodOptional<z.ZodString>;
+    guidance_version: z.ZodOptional<z.ZodString>;
+    guidance_verified_at: z.ZodOptional<z.ZodString>;
+    guidance_status: z.ZodOptional<z.ZodEnum<["fresh", "review-required", "stale"]>>;
+    selection_source: z.ZodEnum<["native-default", "policy-resolved", "explicit-user"]>;
+    candidates_considered: z.ZodArray<z.ZodString, "many">;
+    selection_reason: z.ZodEnum<["native-catalog", "native-catalog-unsatisfying", "pre-start-rejection", "inherit", "gate-target"]>;
+    selected_route: z.ZodString;
+    deadline_seconds: z.ZodNumber;
+    retry_limit: z.ZodNumber;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    launch_status: z.ZodEnum<["planned", "accepted", "blocked-before-start"]>;
+    child_outcome: z.ZodNullable<z.ZodString>;
+    configured_invocation_evidence: z.ZodArray<z.ZodUnknown, "many">;
+    runtime_confirmation: z.ZodString;
+    diagnostics: z.ZodArray<z.ZodString, "many">;
+    continuation_events: z.ZodArray<z.ZodUnknown, "many">;
+    fallback: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        allow_below_task_class_floor: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    }, {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    }>>;
+    task_class: z.ZodOptional<z.ZodEnum<["mechanical-recon", "intelligent-recon", "default-implementation", "hard-reasoning", "consequential"]>>;
+    model_class_floor: z.ZodOptional<z.ZodString>;
+    classification_source: z.ZodOptional<z.ZodLiteral<"caller">>;
+    classification_reason: z.ZodOptional<z.ZodString>;
+    floor_satisfaction: z.ZodOptional<z.ZodEnum<["satisfied", "unsatisfied"]>>;
+    authorization_scope: z.ZodOptional<z.ZodString>;
+    expected_output: z.ZodOptional<z.ZodString>;
+    verification_evidence: z.ZodOptional<z.ZodString>;
+    escalate_when: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+}, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+}>, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+}, {
+    request_id: string;
+    caller: string;
+    scope: string;
+    objective: string;
+    action: string;
+    role_name: string;
+    role_class: string;
+    provider: string;
+    dispatch_context: string;
+    dispatch_policy?: string | null | undefined;
+    dispatch_ceiling?: string | null | undefined;
+    catalog_snapshot: {
+        id: string;
+        source: string;
+        observed_at: string;
+    };
+    authority: string;
+    role_selector: string | null;
+    model_selector: string | null;
+    model_selector_granularity: string | null;
+    effort_selector: string | null;
+    reasoning_mode_selector?: string | null | undefined;
+    service_tier_selector?: string | null | undefined;
+    guidance_reference?: string | undefined;
+    guidance_version?: string | undefined;
+    guidance_verified_at?: string | undefined;
+    guidance_status?: "fresh" | "review-required" | "stale" | undefined;
+    selection_source: "explicit-user" | "native-default" | "policy-resolved";
+    candidates_considered: string[];
+    selection_reason: "gate-target" | "inherit" | "native-catalog" | "native-catalog-unsatisfying" | "pre-start-rejection";
+    selected_route: string;
+    deadline_seconds: number;
+    retry_limit: number;
+    payload: Record<string, unknown>;
+    launch_status: "accepted" | "blocked-before-start" | "planned";
+    child_outcome: string | null;
+    configured_invocation_evidence: unknown[];
+    runtime_confirmation: string;
+    diagnostics: string[];
+    continuation_events: unknown[];
+    fallback?: {
+        mode: string;
+        target?: string | undefined;
+        allow_below_task_class_floor?: boolean | undefined;
+    } | undefined;
+    task_class?: "consequential" | "default-implementation" | "hard-reasoning" | "intelligent-recon" | "mechanical-recon" | undefined;
+    model_class_floor?: string | undefined;
+    classification_source?: "caller" | undefined;
+    classification_reason?: string | undefined;
+    floor_satisfaction?: "satisfied" | "unsatisfied" | undefined;
+    authorization_scope?: string | undefined;
+    expected_output?: string | undefined;
+    verification_evidence?: string | undefined;
+    escalate_when?: string[] | undefined;
+}>;
+export type GenericDispatchRecord = z.infer<typeof genericDispatchRecordSchema>;
+export declare function normalizeDispatchKey(key: string): string;
+export declare function isSensitiveDispatchKey(key: string): boolean;
+export declare function assertNoSensitiveDispatchContent(value: unknown, path?: string): void;
+/**
+ * The persistence-boundary path sanitizer for the generic record.
+ *
+ * NFR1 is enforced here rather than in each producer, for the same reason
+ * redaction became a boundary in Phase 6: a guarantee implemented as a
+ * per-producer obligation regresses the moment a call site is added.
+ */
+export declare function identityFieldsOf(record: GenericDispatchRecord): Record<string, unknown>;
+export declare function sanitizeDispatchRecordPaths(record: GenericDispatchRecord): GenericDispatchRecord;
+export declare function parseGenericDispatchRecord(value: unknown): GenericDispatchRecord;
+//# sourceMappingURL=generic-dispatch-record.d.ts.map

package/dist/providers/identity/generic-dispatch-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-dispatch-record.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/generic-dispatch-record.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4KxB;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAOpE;AAUD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6HpC,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAwFhF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD;AAuGD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAS3D;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,IAAI,SAAa,GAChB,IAAI,CAwBN;AAyBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,qBAAqB,GAC5B,qBAAqB,CAYvB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,qBAAqB,CAavB"}