@kilnai/cli 1.0.4 → 2.0.0

package/dist/application/work-governance-context.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { buildWorkGovernanceContext, buildWorkGovernanceContextCandidate, withWorkGovernanceContext, } from "./work-governance-context.js";
+describe("work-governance-context", () => {
+    it("projects orchestration policy as required instruction context", () => {
+        const candidate = buildWorkGovernanceContextCandidate({
+            defaultPosture: "orchestrate",
+            directExecution: {
+                maxFiles: 1,
+                maxRisk: "low",
+            },
+            requireDelegationFor: ["architecture", "managed-agents"],
+            requiredEvidence: ["surface-map", "residual-risk"],
+        });
+        expect(candidate).toMatchObject({
+            kind: "instruction",
+            source: "work-governance:resolved-kiln-config#workGovernance",
+            required: true,
+            score: 0.97,
+        });
+        expect(candidate?.content).toContain("Default posture: orchestrate");
+        expect(candidate?.content).toContain("Require orchestration/delegation for: architecture, managed-agents");
+        expect(candidate?.content).toContain("work_profile.list and work_item.update/list/complete");
+        expect(candidate?.content).toContain("use its managedInvocationRequest with managed_agent.invoke");
+        expect(candidate?.content).toContain("Model self-confidence is not evidence");
+    });
+    it("does not add context when no work governance config exists", () => {
+        const appConfig = {
+            createRegistry: () => {
+                throw new Error("not used");
+            },
+        };
+        expect(buildWorkGovernanceContext(undefined)).toBeUndefined();
+        expect(withWorkGovernanceContext(appConfig, undefined)).toBe(appConfig);
+    });
+    it("preserves existing context candidates when adding work governance", () => {
+        const appConfig = {
+            createRegistry: () => {
+                throw new Error("not used");
+            },
+            contextCandidates: [{
+                    kind: "instruction",
+                    source: "existing",
+                    content: "Existing context",
+                    score: 1,
+                }],
+        };
+        const wrapped = withWorkGovernanceContext(appConfig, {
+            defaultPosture: "orchestrate",
+        });
+        expect(wrapped.contextCandidates).toHaveLength(2);
+        expect(wrapped.contextCandidates?.[0]?.source).toBe("existing");
+        expect(wrapped.contextCandidates?.[1]?.source).toBe("work-governance:resolved-kiln-config#workGovernance");
+    });
+});
+//# sourceMappingURL=work-governance-context.test.js.map

package/dist/application/work-governance-context.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-governance-context.test.js","sourceRoot":"","sources":["../../src/application/work-governance-context.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EACL,0BAA0B,EAC1B,mCAAmC,EACnC,yBAAyB,GAC1B,MAAM,8BAA8B,CAAC;AAGtC,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;IACvC,EAAE,CAAC,+DAA+D,EAAE,GAAG,EAAE;QACvE,MAAM,SAAS,GAAG,mCAAmC,CAAC;YACpD,cAAc,EAAE,aAAa;YAC7B,eAAe,EAAE;gBACf,QAAQ,EAAE,CAAC;gBACX,OAAO,EAAE,KAAK;aACf;YACD,oBAAoB,EAAE,CAAC,cAAc,EAAE,gBAAgB,CAAC;YACxD,gBAAgB,EAAE,CAAC,aAAa,EAAE,eAAe,CAAC;SACnD,CAAC,CAAC;QAEH,MAAM,CAAC,SAAS,CAAC,CAAC,aAAa,CAAC;YAC9B,IAAI,EAAE,aAAa;YACnB,MAAM,EAAE,qDAAqD;YAC7D,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;QACH,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,8BAA8B,CAAC,CAAC;QACrE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,oEAAoE,CAAC,CAAC;QAC3G,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,sDAAsD,CAAC,CAAC;QAC7F,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,4DAA4D,CAAC,CAAC;QACnG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,uCAAuC,CAAC,CAAC;IAChF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4DAA4D,EAAE,GAAG,EAAE;QACpE,MAAM,SAAS,GAAkB;YAC/B,cAAc,EAAE,GAAG,EAAE;gBACnB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC;YAC9B,CAAC;SACF,CAAC;QAEF,MAAM,CAAC,0BAA0B,CAAC,SAAS,CAAC,CAAC,CAAC,aAAa,EAAE,CAAC;QAC9D,MAAM,CAAC,yBAAyB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC1E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mEAAmE,EAAE,GAAG,EAAE;QAC3E,MAAM,SAAS,GAAkB;YAC/B,cAAc,EAAE,GAAG,EAAE;gBACnB,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC;YAC9B,CAAC;YACD,iBAAiB,EAAE,CAAC;oBAClB,IAAI,EAAE,aAAa;oBACnB,MAAM,EAAE,UAAU;oBAClB,OAAO,EAAE,kBAAkB;oBAC3B,KAAK,EAAE,CAAC;iBACT,CAAC;SACH,CAAC;QAEF,MAAM,OAAO,GAAG,yBAAyB,CAAC,SAAS,EAAE;YACnD,cAAc,EAAE,aAAa;SAC9B,CAAC,CAAC;QAEH,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAClD,MAAM,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChE,MAAM,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;IAC7G,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/application/work-governance-policy.d.ts

@@ -0,0 +1,15 @@
+import type { KilnWorkGovernanceConfig, KilnWorkGovernanceEvidence, KilnWorkGovernanceRisk, KilnWorkGovernanceTrigger } from "../kiln-yaml-types.js";
+export interface WorkGovernanceAssessmentInput {
+    readonly summary: string;
+    readonly estimatedFiles?: number;
+    readonly risk?: KilnWorkGovernanceRisk;
+    readonly triggers?: readonly KilnWorkGovernanceTrigger[];
+}
+export interface WorkGovernanceAssessment {
+    readonly recommendation: "direct" | "orchestrate";
+    readonly reasons: readonly string[];
+    readonly triggers: readonly KilnWorkGovernanceTrigger[];
+    readonly requiredEvidence: readonly KilnWorkGovernanceEvidence[];
+}
+export declare function assessWorkGovernance(config: KilnWorkGovernanceConfig | undefined, input: WorkGovernanceAssessmentInput): WorkGovernanceAssessment;
+//# sourceMappingURL=work-governance-policy.d.ts.map

package/dist/application/work-governance-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-governance-policy.d.ts","sourceRoot":"","sources":["../../src/application/work-governance-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC1B,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,sBAAsB,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,yBAAyB,EAAE,CAAC;CAC1D;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,cAAc,EAAE,QAAQ,GAAG,aAAa,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,SAAS,yBAAyB,EAAE,CAAC;IACxD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,0BAA0B,EAAE,CAAC;CAClE;AAQD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,KAAK,EAAE,6BAA6B,GACnC,wBAAwB,CAsC1B"}

package/dist/application/work-governance-policy.js

@@ -0,0 +1,53 @@
+const RISK_RANK = {
+    low: 1,
+    medium: 2,
+    high: 3,
+};
+export function assessWorkGovernance(config, input) {
+    const triggers = unique(input.triggers ?? []);
+    const reasons = [];
+    const directExecution = config?.directExecution;
+    if ((config?.defaultPosture ?? "direct") === "orchestrate") {
+        reasons.push("default posture is orchestrate");
+    }
+    const matchedDelegationTriggers = triggers.filter((trigger) => (config?.requireDelegationFor ?? []).includes(trigger));
+    if (matchedDelegationTriggers.length > 0) {
+        reasons.push(`delegation trigger matched: ${matchedDelegationTriggers.join(", ")}`);
+    }
+    if (directExecution?.maxFiles !== undefined
+        && input.estimatedFiles !== undefined
+        && input.estimatedFiles > directExecution.maxFiles) {
+        reasons.push(`estimated file count ${input.estimatedFiles} exceeds direct max ${directExecution.maxFiles}`);
+    }
+    if (directExecution?.maxRisk
+        && input.risk
+        && RISK_RANK[input.risk] > RISK_RANK[directExecution.maxRisk]) {
+        reasons.push(`risk ${input.risk} exceeds direct max ${directExecution.maxRisk}`);
+    }
+    const shouldOrchestrate = reasons.length > 0;
+    return {
+        recommendation: shouldOrchestrate ? "orchestrate" : "direct",
+        reasons: shouldOrchestrate ? reasons : ["inside direct-execution envelope"],
+        triggers,
+        requiredEvidence: requiredEvidenceFor(config, triggers),
+    };
+}
+function requiredEvidenceFor(config, triggers) {
+    const evidence = new Set(config?.requiredEvidence ?? []);
+    if (triggers.includes("ui"))
+        evidence.add("browser-qa");
+    if (triggers.includes("architecture")
+        || triggers.includes("security")
+        || triggers.includes("runtime")
+        || triggers.includes("provider-routing")
+        || triggers.includes("managed-agents")) {
+        evidence.add("managed-agent-review");
+    }
+    if (triggers.includes("formal-proof-candidate"))
+        evidence.add("formal-proof");
+    return [...evidence];
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+//# sourceMappingURL=work-governance-policy.js.map

package/dist/application/work-governance-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-governance-policy.js","sourceRoot":"","sources":["../../src/application/work-governance-policy.ts"],"names":[],"mappings":"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"}

package/dist/application/work-governance-tool.d.ts

@@ -0,0 +1,421 @@
+import type { DevTool, ToolInput, ToolResult, WorkItemPauseRequirementKind, WorkItemPauseRequirementStatus, WorkItemStatus } from "@kilnai/core";
+import { GoalRunStore, WorkItemStore } from "@kilnai/core";
+import type { KilnWorkGovernanceConfig, KilnWorkGovernanceEvidence, KilnWorkGovernanceRisk, KilnWorkGovernanceTrigger } from "../kiln-yaml-types.js";
+export declare function createWorkGovernanceTools(config: KilnWorkGovernanceConfig | undefined, options?: {
+    readonly workItemStore?: WorkItemStore;
+    readonly goalRunStore?: GoalRunStore;
+}): readonly DevTool[];
+export declare class WorkGovernanceAssessTool implements DevTool {
+    private readonly config;
+    readonly name = "work_governance.assess";
+    readonly description: string;
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            summary: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            estimatedFiles: {
+                type: string;
+                minimum: number;
+                description: string;
+            };
+            risk: {
+                enum: readonly KilnWorkGovernanceRisk[];
+                description: string;
+            };
+            triggers: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceTrigger[];
+                };
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    readonly outputSchema: {
+        type: string;
+        properties: {
+            recommendation: {
+                enum: string[];
+            };
+            reasons: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            triggers: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceTrigger[];
+                };
+            };
+            requiredEvidence: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    constructor(config: KilnWorkGovernanceConfig | undefined);
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+export declare class WorkProfileListTool implements DevTool {
+    readonly name = "work_profile.list";
+    readonly description: string;
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            trigger: {
+                enum: readonly KilnWorkGovernanceTrigger[];
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+export declare class WorkItemUpdateTool implements DevTool {
+    private readonly config;
+    private readonly store;
+    readonly name = "work_item.update";
+    readonly description: string;
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                description: string;
+            };
+            summary: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            status: {
+                enum: readonly WorkItemStatus[];
+                description: string;
+            };
+            workflowProfile: {
+                enum: import("./work-governance-workflows.js").WorkGovernanceWorkflowProfileId[];
+                description: string;
+            };
+            risk: {
+                enum: readonly KilnWorkGovernanceRisk[];
+                description: string;
+            };
+            triggers: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceTrigger[];
+                };
+                description: string;
+            };
+            surface: {
+                type: string;
+                description: string;
+            };
+            assignedAgentProfile: {
+                type: string;
+                description: string;
+            };
+            routeId: {
+                type: string;
+                description: string;
+            };
+            authorityProfile: {
+                type: string;
+                description: string;
+            };
+            expectedEvidence: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceEvidence[];
+                };
+                description: string;
+            };
+            providedEvidence: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceEvidence[];
+                };
+                description: string;
+            };
+            verificationGates: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            dependencies: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            residualRisk: {
+                type: string;
+                description: string;
+            };
+            pauseRequirements: {
+                type: string;
+                items: {
+                    type: string;
+                    properties: {
+                        id: {
+                            type: string;
+                            minLength: number;
+                        };
+                        kind: {
+                            enum: readonly WorkItemPauseRequirementKind[];
+                        };
+                        summary: {
+                            type: string;
+                            minLength: number;
+                        };
+                        status: {
+                            enum: readonly WorkItemPauseRequirementStatus[];
+                        };
+                        resolvedBy: {
+                            type: string;
+                        };
+                        resolvedAt: {
+                            type: string;
+                        };
+                        resolution: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    constructor(config: KilnWorkGovernanceConfig | undefined, store: WorkItemStore);
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+export declare class WorkItemListTool implements DevTool {
+    private readonly store;
+    readonly name = "work_item.list";
+    readonly description = "List session governed work items and their evidence status.";
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                enum: readonly WorkItemStatus[];
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    constructor(store: WorkItemStore);
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+export declare class WorkItemCompleteTool implements DevTool {
+    private readonly store;
+    readonly name = "work_item.complete";
+    readonly description: string;
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            providedEvidence: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceEvidence[];
+                };
+                description: string;
+            };
+            residualRisk: {
+                type: string;
+                description: string;
+            };
+            skippedVerificationGates: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            verificationGateResults: Record<string, unknown>;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    constructor(store: WorkItemStore);
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+export declare class WorkItemExecutionStartTool implements DevTool {
+    private readonly goalRunStore;
+    private readonly workItemStore;
+    readonly name = "work_item.execution.start";
+    readonly description: string;
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            goalRunId: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            workItemId: {
+                type: string;
+                description: string;
+            };
+            summary: {
+                type: string;
+                description: string;
+            };
+            managedInvocationId: {
+                type: string;
+                description: string;
+            };
+            managedProviderId: {
+                type: string;
+                description: string;
+            };
+            managedModel: {
+                type: string;
+                description: string;
+            };
+            managedReasoningEffort: {
+                type: string;
+                description: string;
+            };
+            managedProfile: {
+                enum: readonly ["foundation-readonly-plan", "foundation-propose-writes", "foundation-apply-approved-writes", "foundation-memory-write-proposals"];
+                description: string;
+            };
+            requestedAuthority: {
+                enum: readonly ["auto", "read_only", "audited", "destructive"];
+                description: string;
+            };
+            governanceRecommendation: {
+                enum: string[];
+                description: string;
+            };
+            governanceReasons: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            requiredEvidence: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    constructor(goalRunStore: GoalRunStore, workItemStore: WorkItemStore);
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+export declare class WorkItemExecutionFinishTool implements DevTool {
+    private readonly goalRunStore;
+    private readonly workItemStore;
+    readonly name = "work_item.execution.finish";
+    readonly description: string;
+    readonly annotations: {
+        readOnly: boolean;
+        idempotent: boolean;
+    };
+    readonly inputSchema: {
+        type: string;
+        properties: {
+            goalRunId: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            workItemId: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            attemptId: {
+                type: string;
+                minLength: number;
+                description: string;
+            };
+            providedEvidence: {
+                type: string;
+                items: {
+                    enum: readonly KilnWorkGovernanceEvidence[];
+                };
+                description: string;
+            };
+            residualRisk: {
+                type: string;
+                description: string;
+            };
+            skippedVerificationGates: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            verificationGateResults: Record<string, unknown>;
+            summary: {
+                type: string;
+                description: string;
+            };
+            closeoutSummary: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+    constructor(goalRunStore: GoalRunStore, workItemStore: WorkItemStore);
+    execute(input: ToolInput): Promise<ToolResult>;
+}
+//# sourceMappingURL=work-governance-tool.d.ts.map

package/dist/application/work-governance-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-governance-tool.d.ts","sourceRoot":"","sources":["../../src/application/work-governance-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,UAAU,EAEV,4BAA4B,EAC5B,8BAA8B,EAC9B,cAAc,EAEf,MAAM,cAAc,CAAC;AACtB,OAAO,EAEL,YAAY,EAGZ,aAAa,EAEd,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EACV,wBAAwB,EACxB,0BAA0B,EAC1B,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AA4D/B,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,OAAO,GAAE;IACP,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC;CACjC,GACL,SAAS,OAAO,EAAE,CAYpB;AAED,qBAAa,wBAAyB,YAAW,OAAO;IAoD1C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAnDnC,QAAQ,CAAC,IAAI,4BAA4B;IAEzC,QAAQ,CAAC,WAAW,SAGR;IAEZ,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyBlB;IAEF,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;MAUnB;gBAE2B,MAAM,EAAE,wBAAwB,GAAG,SAAS;IAEnE,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CAiCrD;AAED,qBAAa,mBAAoB,YAAW,OAAO;IACjD,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,QAAQ,CAAC,WAAW,SAGR;IAEZ,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;MASlB;IAEI,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CAuBrD;AAED,qBAAa,kBAAmB,YAAW,OAAO;IA8E9C,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IA9ExB,QAAQ,CAAC,IAAI,sBAAsB;IAEnC,QAAQ,CAAC,WAAW,SAGR;IAEZ,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DlB;gBAGiB,MAAM,EAAE,wBAAwB,GAAG,SAAS,EAC5C,KAAK,EAAE,aAAa;IAGjC,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CAgErD;AAED,qBAAa,gBAAiB,YAAW,OAAO;IAkBlC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjBlC,QAAQ,CAAC,IAAI,oBAAoB;IAEjC,QAAQ,CAAC,WAAW,iEAAiE;IAErF,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;MAMlB;gBAE2B,KAAK,EAAE,aAAa;IAE3C,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CAgBrD;AAED,qBAAa,oBAAqB,YAAW,OAAO;IAkCtC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjClC,QAAQ,CAAC,IAAI,wBAAwB;IAErC,QAAQ,CAAC,WAAW,SAGR;IAEZ,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmBlB;gBAE2B,KAAK,EAAE,aAAa;IAE3C,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CAiErD;AAED,qBAAa,0BAA2B,YAAW,OAAO;IA4DtD,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IA5DhC,QAAQ,CAAC,IAAI,+BAA+B;IAE5C,QAAQ,CAAC,WAAW,SAGR;IAEZ,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4ClB;gBAGiB,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,aAAa;IAGzC,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CAgGrD;AAED,qBAAa,2BAA4B,YAAW,OAAO;IAuCvD,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAvChC,QAAQ,CAAC,IAAI,gCAAgC;IAE7C,QAAQ,CAAC,WAAW,SAGR;IAEZ,QAAQ,CAAC,WAAW;;;MAGlB;IAEF,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuBlB;gBAGiB,YAAY,EAAE,YAAY,EAC1B,aAAa,EAAE,aAAa;IAGzC,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC;CA4DrD"}