@claudexor/schema 1.0.0

package/dist/task.d.ts

@@ -0,0 +1,565 @@
+import { z } from "zod";
+export declare const SuccessCriterion: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    text: string;
+    required: boolean;
+}, {
+    id: string;
+    text: string;
+    required?: boolean | undefined;
+}>;
+export type SuccessCriterion = z.infer<typeof SuccessCriterion>;
+export declare const TestCommand: z.ZodObject<{
+    id: z.ZodString;
+    command: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    command: string;
+    required: boolean;
+}, {
+    id: string;
+    command: string;
+    required?: boolean | undefined;
+}>;
+export type TestCommand = z.infer<typeof TestCommand>;
+export declare const ProtectedPathApproval: z.ZodObject<{
+    /** Glob approved by the operator/user for this run; consumed only by the
+     * auto-protected gate/test path policy, not by built-in critical-path gates. */
+    path: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    reason?: string | undefined;
+}, {
+    path: string;
+    reason?: string | undefined;
+}>;
+export type ProtectedPathApproval = z.infer<typeof ProtectedPathApproval>;
+export declare const TaskConstraints: z.ZodObject<{
+    /** Globs whose changes escalate risk to a human-approval gate (wired into
+     * classifyRisk/requireHuman). These are spec/config-owned and cannot be
+     * suppressed by per-run protected-path approvals. The other constraint kinds
+     * were unwired and removed. */
+    protected_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Engine-derived gate/test path protections. Per-run approvals can narrow
+     * only this auto-protected set, never spec/config-owned protected_paths. */
+    auto_protected_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Per-run typed approvals for protected gate/test path changes. These are
+     * produced by explicit surfaces (CLI/control/IDE), then consumed by policy. */
+    protected_path_approvals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        /** Glob approved by the operator/user for this run; consumed only by the
+         * auto-protected gate/test path policy, not by built-in critical-path gates. */
+        path: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        reason?: string | undefined;
+    }, {
+        path: string;
+        reason?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    protected_paths: string[];
+    auto_protected_paths: string[];
+    protected_path_approvals: {
+        path: string;
+        reason?: string | undefined;
+    }[];
+}, {
+    protected_paths?: string[] | undefined;
+    auto_protected_paths?: string[] | undefined;
+    protected_path_approvals?: {
+        path: string;
+        reason?: string | undefined;
+    }[] | undefined;
+}>;
+export type TaskConstraints = z.infer<typeof TaskConstraints>;
+export declare const ConvergencePredicate: z.ZodObject<{
+    require_tests_pass: z.ZodDefault<z.ZodBoolean>;
+    require_no_accepted_block_open: z.ZodDefault<z.ZodBoolean>;
+    require_no_accepted_fix_first_open: z.ZodDefault<z.ZodBoolean>;
+    require_final_cross_family_clean_review: z.ZodDefault<z.ZodBoolean>;
+    require_final_diff_stable_after_review: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Block convergence while an accepted NEEDS_HUMAN escalation is still open.
+     * Closes the v0.8 hole where, with cross-family clean review disabled, a run
+     * could converge to success with an open NEEDS_HUMAN finding.
+     */
+    require_no_accepted_needs_human_open: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    require_tests_pass: boolean;
+    require_no_accepted_block_open: boolean;
+    require_no_accepted_fix_first_open: boolean;
+    require_final_cross_family_clean_review: boolean;
+    require_final_diff_stable_after_review: boolean;
+    require_no_accepted_needs_human_open: boolean;
+}, {
+    require_tests_pass?: boolean | undefined;
+    require_no_accepted_block_open?: boolean | undefined;
+    require_no_accepted_fix_first_open?: boolean | undefined;
+    require_final_cross_family_clean_review?: boolean | undefined;
+    require_final_diff_stable_after_review?: boolean | undefined;
+    require_no_accepted_needs_human_open?: boolean | undefined;
+}>;
+export type ConvergencePredicate = z.infer<typeof ConvergencePredicate>;
+/** One node of the spec-derived task graph; edges are `depends_on`. */
+export declare const TaskGraphNode: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodDefault<z.ZodString>;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    depends_on: string[];
+}, {
+    id: string;
+    title?: string | undefined;
+    depends_on?: string[] | undefined;
+}>;
+export type TaskGraphNode = z.infer<typeof TaskGraphNode>;
+/** A topologically-ordered task graph built from a frozen SpecPack's tasks. */
+export declare const TaskGraph: z.ZodObject<{
+    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodDefault<z.ZodString>;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        depends_on: string[];
+    }, {
+        id: string;
+        title?: string | undefined;
+        depends_on?: string[] | undefined;
+    }>, "many">>;
+    /** Topological execution order (node ids); empty when there are no tasks. */
+    order: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    nodes: {
+        id: string;
+        title: string;
+        depends_on: string[];
+    }[];
+    order: string[];
+}, {
+    nodes?: {
+        id: string;
+        title?: string | undefined;
+        depends_on?: string[] | undefined;
+    }[] | undefined;
+    order?: string[] | undefined;
+}>;
+export type TaskGraph = z.infer<typeof TaskGraph>;
+/**
+ * Immutable contract describing a single run. Built once, hashed, never mutated.
+ */
+export declare const TaskContract: z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    task_id: z.ZodString;
+    created_at: z.ZodString;
+    repo: z.ZodObject<{
+        root: z.ZodString;
+        base_ref: z.ZodString;
+        base_sha: z.ZodOptional<z.ZodString>;
+        dirty_policy: z.ZodDefault<z.ZodEnum<["refuse", "snapshot"]>>;
+    }, "strip", z.ZodTypeAny, {
+        root: string;
+        base_ref: string;
+        dirty_policy: "refuse" | "snapshot";
+        base_sha?: string | undefined;
+    }, {
+        root: string;
+        base_ref: string;
+        base_sha?: string | undefined;
+        dirty_policy?: "refuse" | "snapshot" | undefined;
+    }>;
+    mode: z.ZodObject<{
+        kind: z.ZodEnum<["ask", "plan", "audit", "agent", "orchestrate"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "ask" | "plan" | "audit" | "agent" | "orchestrate";
+    }, {
+        kind: "ask" | "plan" | "audit" | "agent" | "orchestrate";
+    }>;
+    user_intent: z.ZodObject<{
+        raw: z.ZodString;
+        normalized: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        raw: string;
+        normalized?: string | undefined;
+    }, {
+        raw: string;
+        normalized?: string | undefined;
+    }>;
+    spec: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        hash: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path?: string | undefined;
+        id?: string | undefined;
+        hash?: string | undefined;
+    }, {
+        path?: string | undefined;
+        id?: string | undefined;
+        hash?: string | undefined;
+    }>>;
+    success_criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        text: string;
+        required: boolean;
+    }, {
+        id: string;
+        text: string;
+        required?: boolean | undefined;
+    }>, "many">>;
+    non_goals: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    forbidden_approaches: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    decided_tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Spec-derived task graph; null until a frozen SpecPack with tasks is resolved. */
+    task_graph: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodDefault<z.ZodString>;
+            depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            title: string;
+            depends_on: string[];
+        }, {
+            id: string;
+            title?: string | undefined;
+            depends_on?: string[] | undefined;
+        }>, "many">>;
+        /** Topological execution order (node ids); empty when there are no tasks. */
+        order: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        nodes: {
+            id: string;
+            title: string;
+            depends_on: string[];
+        }[];
+        order: string[];
+    }, {
+        nodes?: {
+            id: string;
+            title?: string | undefined;
+            depends_on?: string[] | undefined;
+        }[] | undefined;
+        order?: string[] | undefined;
+    }>>>;
+    constraints: z.ZodDefault<z.ZodObject<{
+        /** Globs whose changes escalate risk to a human-approval gate (wired into
+         * classifyRisk/requireHuman). These are spec/config-owned and cannot be
+         * suppressed by per-run protected-path approvals. The other constraint kinds
+         * were unwired and removed. */
+        protected_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Engine-derived gate/test path protections. Per-run approvals can narrow
+         * only this auto-protected set, never spec/config-owned protected_paths. */
+        auto_protected_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Per-run typed approvals for protected gate/test path changes. These are
+         * produced by explicit surfaces (CLI/control/IDE), then consumed by policy. */
+        protected_path_approvals: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            /** Glob approved by the operator/user for this run; consumed only by the
+             * auto-protected gate/test path policy, not by built-in critical-path gates. */
+            path: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            path: string;
+            reason?: string | undefined;
+        }, {
+            path: string;
+            reason?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        protected_paths: string[];
+        auto_protected_paths: string[];
+        protected_path_approvals: {
+            path: string;
+            reason?: string | undefined;
+        }[];
+    }, {
+        protected_paths?: string[] | undefined;
+        auto_protected_paths?: string[] | undefined;
+        protected_path_approvals?: {
+            path: string;
+            reason?: string | undefined;
+        }[] | undefined;
+    }>>;
+    tests: z.ZodDefault<z.ZodObject<{
+        commands: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            command: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            command: string;
+            required: boolean;
+        }, {
+            id: string;
+            command: string;
+            required?: boolean | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        commands: {
+            id: string;
+            command: string;
+            required: boolean;
+        }[];
+    }, {
+        commands?: {
+            id: string;
+            command: string;
+            required?: boolean | undefined;
+        }[] | undefined;
+    }>>;
+    access: z.ZodDefault<z.ZodObject<{
+        requested_profile: z.ZodDefault<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>>;
+        /** Profile actually enforced by the engine (mode/trust clamps applied; never client-supplied). */
+        effective_profile: z.ZodDefault<z.ZodEnum<["readonly", "workspace_write", "full", "external_sandbox_full", "inherit_native"]>>;
+    }, "strip", z.ZodTypeAny, {
+        requested_profile: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native";
+        effective_profile: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native";
+    }, {
+        requested_profile?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+        effective_profile?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    }>>;
+    external_context: z.ZodDefault<z.ZodObject<{
+        policy: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+        web_required: z.ZodDefault<z.ZodBoolean>;
+        /** Mode the selected route actually executes (disclosed upgrades, e.g. claude cached->live). */
+        effective_mode: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+    }, "strip", z.ZodTypeAny, {
+        policy: "off" | "auto" | "cached" | "live";
+        web_required: boolean;
+        effective_mode: "off" | "auto" | "cached" | "live";
+    }, {
+        policy?: "off" | "auto" | "cached" | "live" | undefined;
+        web_required?: boolean | undefined;
+        effective_mode?: "off" | "auto" | "cached" | "live" | undefined;
+    }>>;
+    tool_permission_policy: z.ZodDefault<z.ZodObject<{
+        web: z.ZodDefault<z.ZodEnum<["off", "auto", "cached", "live"]>>;
+        allow: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        deny: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        web: "off" | "auto" | "cached" | "live";
+        allow: string[];
+        deny: string[];
+    }, {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        allow?: string[] | undefined;
+        deny?: string[] | undefined;
+    }>>;
+    budget: z.ZodDefault<z.ZodObject<{
+        portfolio: z.ZodDefault<z.ZodEnum<["daily-rich", "balanced", "cheapest", "strongest", "burn", "subscription-first", "api-overflow", "conserve-claude", "conserve-codex"]>>;
+        max_usd: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        max_usd: number | null;
+        portfolio: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex";
+    }, {
+        max_usd?: number | null | undefined;
+        portfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    }>>;
+    /** Resolved harness-scoped model map for this run (harness id → model id),
+     * after scalar→primary expansion. The contract is the SSOT the route spec
+     * builder reads; empty = every route uses its per-harness settings default. */
+    routing_models: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    convergence: z.ZodDefault<z.ZodObject<{
+        require_tests_pass: z.ZodDefault<z.ZodBoolean>;
+        require_no_accepted_block_open: z.ZodDefault<z.ZodBoolean>;
+        require_no_accepted_fix_first_open: z.ZodDefault<z.ZodBoolean>;
+        require_final_cross_family_clean_review: z.ZodDefault<z.ZodBoolean>;
+        require_final_diff_stable_after_review: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Block convergence while an accepted NEEDS_HUMAN escalation is still open.
+         * Closes the v0.8 hole where, with cross-family clean review disabled, a run
+         * could converge to success with an open NEEDS_HUMAN finding.
+         */
+        require_no_accepted_needs_human_open: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        require_tests_pass: boolean;
+        require_no_accepted_block_open: boolean;
+        require_no_accepted_fix_first_open: boolean;
+        require_final_cross_family_clean_review: boolean;
+        require_final_diff_stable_after_review: boolean;
+        require_no_accepted_needs_human_open: boolean;
+    }, {
+        require_tests_pass?: boolean | undefined;
+        require_no_accepted_block_open?: boolean | undefined;
+        require_no_accepted_fix_first_open?: boolean | undefined;
+        require_final_cross_family_clean_review?: boolean | undefined;
+        require_final_diff_stable_after_review?: boolean | undefined;
+        require_no_accepted_needs_human_open?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    access: {
+        requested_profile: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native";
+        effective_profile: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native";
+    };
+    tool_permission_policy: {
+        web: "off" | "auto" | "cached" | "live";
+        allow: string[];
+        deny: string[];
+    };
+    mode: {
+        kind: "ask" | "plan" | "audit" | "agent" | "orchestrate";
+    };
+    schema_version: 2;
+    created_at: string;
+    repo: {
+        root: string;
+        base_ref: string;
+        dirty_policy: "refuse" | "snapshot";
+        base_sha?: string | undefined;
+    };
+    task_id: string;
+    tests: {
+        commands: {
+            id: string;
+            command: string;
+            required: boolean;
+        }[];
+    };
+    budget: {
+        max_usd: number | null;
+        portfolio: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex";
+    };
+    user_intent: {
+        raw: string;
+        normalized?: string | undefined;
+    };
+    success_criteria: {
+        id: string;
+        text: string;
+        required: boolean;
+    }[];
+    non_goals: string[];
+    forbidden_approaches: string[];
+    decided_tradeoffs: string[];
+    task_graph: {
+        nodes: {
+            id: string;
+            title: string;
+            depends_on: string[];
+        }[];
+        order: string[];
+    } | null;
+    constraints: {
+        protected_paths: string[];
+        auto_protected_paths: string[];
+        protected_path_approvals: {
+            path: string;
+            reason?: string | undefined;
+        }[];
+    };
+    external_context: {
+        policy: "off" | "auto" | "cached" | "live";
+        web_required: boolean;
+        effective_mode: "off" | "auto" | "cached" | "live";
+    };
+    routing_models: Record<string, string>;
+    convergence: {
+        require_tests_pass: boolean;
+        require_no_accepted_block_open: boolean;
+        require_no_accepted_fix_first_open: boolean;
+        require_final_cross_family_clean_review: boolean;
+        require_final_diff_stable_after_review: boolean;
+        require_no_accepted_needs_human_open: boolean;
+    };
+    spec?: {
+        path?: string | undefined;
+        id?: string | undefined;
+        hash?: string | undefined;
+    } | undefined;
+}, {
+    mode: {
+        kind: "ask" | "plan" | "audit" | "agent" | "orchestrate";
+    };
+    schema_version: 2;
+    created_at: string;
+    repo: {
+        root: string;
+        base_ref: string;
+        base_sha?: string | undefined;
+        dirty_policy?: "refuse" | "snapshot" | undefined;
+    };
+    task_id: string;
+    user_intent: {
+        raw: string;
+        normalized?: string | undefined;
+    };
+    spec?: {
+        path?: string | undefined;
+        id?: string | undefined;
+        hash?: string | undefined;
+    } | undefined;
+    access?: {
+        requested_profile?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+        effective_profile?: "readonly" | "workspace_write" | "full" | "external_sandbox_full" | "inherit_native" | undefined;
+    } | undefined;
+    tool_permission_policy?: {
+        web?: "off" | "auto" | "cached" | "live" | undefined;
+        allow?: string[] | undefined;
+        deny?: string[] | undefined;
+    } | undefined;
+    tests?: {
+        commands?: {
+            id: string;
+            command: string;
+            required?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+    budget?: {
+        max_usd?: number | null | undefined;
+        portfolio?: "daily-rich" | "balanced" | "cheapest" | "strongest" | "burn" | "subscription-first" | "api-overflow" | "conserve-claude" | "conserve-codex" | undefined;
+    } | undefined;
+    success_criteria?: {
+        id: string;
+        text: string;
+        required?: boolean | undefined;
+    }[] | undefined;
+    non_goals?: string[] | undefined;
+    forbidden_approaches?: string[] | undefined;
+    decided_tradeoffs?: string[] | undefined;
+    task_graph?: {
+        nodes?: {
+            id: string;
+            title?: string | undefined;
+            depends_on?: string[] | undefined;
+        }[] | undefined;
+        order?: string[] | undefined;
+    } | null | undefined;
+    constraints?: {
+        protected_paths?: string[] | undefined;
+        auto_protected_paths?: string[] | undefined;
+        protected_path_approvals?: {
+            path: string;
+            reason?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    external_context?: {
+        policy?: "off" | "auto" | "cached" | "live" | undefined;
+        web_required?: boolean | undefined;
+        effective_mode?: "off" | "auto" | "cached" | "live" | undefined;
+    } | undefined;
+    routing_models?: Record<string, string> | undefined;
+    convergence?: {
+        require_tests_pass?: boolean | undefined;
+        require_no_accepted_block_open?: boolean | undefined;
+        require_no_accepted_fix_first_open?: boolean | undefined;
+        require_final_cross_family_clean_review?: boolean | undefined;
+        require_final_diff_stable_after_review?: boolean | undefined;
+        require_no_accepted_needs_human_open?: boolean | undefined;
+    } | undefined;
+}>;
+export type TaskContract = z.infer<typeof TaskContract>;
+//# sourceMappingURL=task.d.ts.map

package/dist/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../src/task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAMgC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,eAAO,MAAM,WAAW;;;;;;;;;;;;EAMgD,CAAC;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,qBAAqB;IAE9B;oFACgF;;;;;;;;;EAOmB,CAAC;AACxG,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,eAAe;IAExB;;;mCAG+B;;IAO/B;gFAC4E;;IAK5E;mFAC+E;;QA9B/E;wFACgF;;;;;;;;;;;;;;;;;;;;;;;;EAmCxB,CAAC;AAC7D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,eAAO,MAAM,oBAAoB;;;;;;IAmB7B;;;;OAIG;;;;;;;;;;;;;;;;EAMsF,CAAC;AAC9F,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,uEAAuE;AACvE,eAAO,MAAM,aAAa;;;;;;;;;;;;EAMmD,CAAC;AAC9E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,+EAA+E;AAC/E,eAAO,MAAM,SAAS;;;;;;;;;;;;;;IAGlB,6EAA6E;;;;;;;;;;;;;;;;EAGM,CAAC;AACxF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgCrB,oFAAoF;;;;;;;;;;;;;;;QAzCpF,6EAA6E;;;;;;;;;;;;;;;;;;QAxE7E;;;uCAG+B;;QAO/B;oFAC4E;;QAK5E;uFAC+E;;YA9B/E;4FACgF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyI5E,kGAAkG;;;;;;;;;;;;QAclG,gGAAgG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsBpG;;mFAE+E;;;;;;;;QAtH/E;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2HsF,CAAC;AAC9F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}