tracelattice 1.2.5

package/dist/sanitize.js

@@ -0,0 +1,14 @@
+const DANGEROUS_TAG_REGEX = /<\/?(script|iframe|img|style|svg|embed|object|link|meta|base|form)(\s[^>]*)?\s*\/?>/gi;
+const CONTROL_CHAR_REGEX = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
+function stripDangerousTags(input) {
+    return input.replace(DANGEROUS_TAG_REGEX, '');
+}
+function stripControlChars(input) {
+    return input.replace(CONTROL_CHAR_REGEX, '');
+}
+function sanitizeString(input) {
+    return stripDangerousTags(stripControlChars(input));
+}
+export { sanitizeString, stripControlChars, stripDangerousTags };
+
+//# sourceMappingURL=sanitize.js.map

package/dist/sanitize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.js","sources":["../src/sanitize.ts"],"sourcesContent":["/**\n * Input sanitization for the sequential thinking MCP tool.\n *\n * Provides pure functions for stripping dangerous content from free-text fields.\n * Uses a targeted blocklist approach: only removes HTML tags that can execute code,\n * while preserving generic angle-bracket content like TypeScript generics (`Array<string>`),\n * mathematical comparisons (`x < 5`), and markdown formatting.\n *\n * @module sanitize\n */\n\n/**\n * Regex matching dangerous HTML tags that can execute JavaScript or load external resources.\n * Targets: script, iframe, img, style, svg, embed, object, link, meta, base, form.\n * Preserves: `Array<string>`, `x < 5 && y > 3`, `<details>`, `<code>`, `<pre>`, etc.\n */\nconst DANGEROUS_TAG_REGEX =\n\t/<\\/?(script|iframe|img|style|svg|embed|object|link|meta|base|form)(\\s[^>]*)?\\s*\\/?>/gi;\n\n/**\n * Null bytes and C0 control characters (except tab \\t, newline \\n, carriage return \\r).\n * These can cause truncation in C bindings, file I/O, and some databases.\n */\n// eslint-disable-next-line no-control-regex -- intentional: matches C0 control chars to strip them\nconst CONTROL_CHAR_REGEX = /[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F]/g;\n\n/**\n * Strip dangerous HTML tags that can execute JavaScript or load external resources.\n *\n * Uses a targeted blocklist to remove only tags known to be dangerous (script, iframe,\n * img, style, svg, embed, object, link, meta, base, form) while preserving safe\n * angle-bracket content like TypeScript generics and mathematical comparisons.\n *\n * @param input - The string to sanitize\n * @returns The input with dangerous HTML tags removed\n *\n * @example\n * ```ts\n * stripDangerousTags('<script>alert(1)</script>hello'); // 'hello'\n * stripDangerousTags('Array<string>'); // 'Array<string>' (preserved)\n * stripDangerousTags('x < 5 && y > 3'); // 'x < 5 && y > 3' (preserved)\n * ```\n */\nexport function stripDangerousTags(input: string): string {\n\treturn input.replace(DANGEROUS_TAG_REGEX, '');\n}\n\n/**\n * Strip null bytes and C0 control characters from a string.\n *\n * Removes characters in the range U+0000–U+0008, U+000B, U+000C, U+000E–U+001F.\n * Preserves tab (`\\t`, U+0009), newline (`\\n`, U+000A), and carriage return (`\\r`, U+000D)\n * as these are commonly used in thought content.\n *\n * @param input - The string to sanitize\n * @returns The input with control characters removed\n *\n * @example\n * ```ts\n * stripControlChars('a\\x00b'); // 'ab'\n * stripControlChars('a\\tb\\nc'); // 'a\\tb\\nc' (tab and newline preserved)\n * ```\n */\nexport function stripControlChars(input: string): string {\n\treturn input.replace(CONTROL_CHAR_REGEX, '');\n}\n\n/**\n * Sanitize a string by stripping both control characters and dangerous HTML tags.\n *\n * Composes {@link stripControlChars} and {@link stripDangerousTags} in sequence.\n * Does not trim whitespace — thought content may depend on leading/trailing spaces.\n * Always returns a string, even if the input is empty.\n *\n * @param input - The string to sanitize\n * @returns The fully sanitized string\n *\n * @example\n * ```ts\n * sanitizeString('<script>alert(1)</script>hello\\x00world'); // 'helloworld'\n * sanitizeString('Array<string>\\x00'); // 'Array<string>'\n * ```\n */\nexport function sanitizeString(input: string): string {\n\treturn stripDangerousTags(stripControlChars(input));\n}\n"],"names":["DANGEROUS_TAG_REGEX","CONTROL_CHAR_REGEX","stripDangerousTags","input","stripControlChars","sanitizeString"],"mappings":"AAgBA,MAAMA,sBACL;AAOD,MAAMC,qBAAqB;AAmBpB,SAASC,mBAAmBC,KAAa;IAC/C,OAAOA,MAAM,OAAO,CAACH,qBAAqB;AAC3C;AAkBO,SAASI,kBAAkBD,KAAa;IAC9C,OAAOA,MAAM,OAAO,CAACF,oBAAoB;AAC1C;AAkBO,SAASI,eAAeF,KAAa;IAC3C,OAAOD,mBAAmBE,kBAAkBD;AAC7C"}

package/dist/schema.d.ts

@@ -0,0 +1,531 @@
+/**
+ * Valibot validation schemas for the sequential thinking MCP tool.
+ *
+ * This module defines the validation schemas used for the sequential thinking tool,
+ * including schemas for tool recommendations, skill recommendations, step recommendations,
+ * and the main sequential thinking input. All schemas use Valibot for runtime validation
+ * and provide detailed descriptions for MCP protocol compatibility.
+ *
+ * @remarks
+ * **Schema Overview:**
+ * - `ToolRecommendationSchema` - Validates tool recommendation objects with confidence scores
+ * - `SkillRecommendationSchema` - Validates skill recommendation objects
+ * - `StepRecommendationSchema` - Validates step coordination structures
+ * - `SequentialThinkingSchema` - Main schema for thought input validation
+ * - Reasoning enhancement fields: thought_type, quality_score, confidence, hypothesis_id, etc.
+ *
+ * @example
+ * ```typescript
+ * import { SequentialThinkingSchema } from './schema.js';
+ * import { safeParse } from 'valibot';
+ *
+ * const result = safeParse(SequentialThinkingSchema, inputData);
+ * if (result.success) {
+ *   const thought = result.output;
+ *   // Process the valid thought
+ * } else {
+ *   console.error('Validation failed:', result.issues);
+ * }
+ * ```
+ * @module schema
+ */
+import * as v from 'valibot';
+import type { Tool } from './types/tool.js';
+/**
+ * Valibot schema for validating tool recommendation objects.
+ *
+ * Validates that a tool recommendation has:
+ * - A tool name (string)
+ * - A confidence score between 0 and 1
+ * - A rationale explaining the recommendation
+ * - A priority number for ordering
+ * - Optional suggested input parameters
+ * - Optional alternative tools
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { ToolRecommendationSchema } from './schema.js';
+ *
+ * const result = safeParse(ToolRecommendationSchema, {
+ *   tool_name: 'mcp__tavily-mcp__tavily-search',
+ *   confidence: 0.9,
+ *   rationale: 'Best for web search',
+ *   priority: 1
+ * });
+ * ```
+ */
+export declare const ToolRecommendationSchema: v.ObjectSchema<{
+    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+    readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+    readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+        [x: string]: unknown;
+    }, "Optional suggested parameters">]>, undefined>;
+    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+}, undefined>;
+/**
+ * Valibot schema for validating skill recommendation objects.
+ *
+ * Validates that a skill recommendation has:
+ * - A skill name (string)
+ * - A confidence score between 0 and 1
+ * - A rationale explaining the recommendation
+ * - A priority number for ordering
+ * - Optional alternative skills
+ * - Optional allowed tools list
+ * - Optional user invocable flag
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { SkillRecommendationSchema } from './schema.js';
+ *
+ * const result = safeParse(SkillRecommendationSchema, {
+ *   skill_name: 'commit',
+ *   confidence: 0.95,
+ *   rationale: 'Handles git commit workflow',
+ *   priority: 1,
+ *   user_invocable: true
+ * });
+ * ```
+ */
+export declare const SkillRecommendationSchema: v.ObjectSchema<{
+    readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+    readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+    readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+}, undefined>;
+/**
+ * Valibot schema for validating step recommendation objects.
+ *
+ * Validates that a step recommendation has:
+ * - A step description
+ * - An array of recommended tools
+ * - An optional array of recommended skills
+ * - An expected outcome
+ * - Optional conditions for the next step
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { StepRecommendationSchema } from './schema.js';
+ *
+ * const result = safeParse(StepRecommendationSchema, {
+ *   step_description: 'Search for TypeScript files',
+ *   recommended_tools: [{ ... }],
+ *   expected_outcome: 'List of all TypeScript files'
+ * });
+ * ```
+ */
+export declare const StepRecommendationSchema: v.ObjectSchema<{
+    readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+    readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+        readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+        readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+        readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+        readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+            [x: string]: unknown;
+        }, "Optional suggested parameters">]>, undefined>;
+        readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        tool_name: string;
+        confidence: number;
+        rationale: string;
+        priority?: number | undefined;
+        suggested_inputs?: {
+            [x: string]: unknown;
+        } | undefined;
+        alternatives?: string[] | undefined;
+    }[], "Tools recommended for this step">]>;
+    readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+        readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+        readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+        readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+        readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+        readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+        readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        skill_name: string;
+        confidence?: number | undefined;
+        rationale?: string | undefined;
+        priority?: number | undefined;
+        alternatives?: string[] | undefined;
+        allowed_tools?: string[] | undefined;
+        user_invocable?: boolean | undefined;
+    }[], "Skills recommended for this step">]>, undefined>;
+    readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+    readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+}, undefined>;
+/**
+ * Valibot schema for validating partial tool recommendation objects.
+ *
+ * This is a lenient version of ToolRecommendationSchema used for previous_steps,
+ * where LLMs naturally provide partial/skeletal data. Only tool_name and rationale
+ * are required, while confidence and priority are optional with default values.
+ *
+ * Validates that a partial tool recommendation has:
+ * - A tool name (required)
+ * - A rationale explaining the recommendation (required)
+ * - An optional confidence score (defaults to 0.5)
+ * - An optional priority number (defaults to 999)
+ * - Optional suggested input parameters
+ * - Optional alternative tools
+ *
+ * @remarks
+ * **Design Rationale:**
+ * LLMs tend to provide complete data for current_step but only partial data
+ * for previous_steps (historical context). This schema accommodates that natural
+ * LLM behavior while maintaining data integrity through sensible defaults.
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { PartialToolRecommendationSchema } from './schema.js';
+ *
+ * // Minimal valid input (LLM often generates this for previous_steps)
+ * const result = safeParse(PartialToolRecommendationSchema, {
+ *   tool_name: 'Read',
+ *   rationale: 'Read the file'
+ * });
+ * // confidence and priority will be filled in by the normalizer
+ * ```
+ */
+export declare const PartialToolRecommendationSchema: v.ObjectSchema<{
+    readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+    readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended (default: empty string)">]>, undefined>;
+    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+    readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+    readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+        [x: string]: unknown;
+    }, "Optional suggested parameters">]>, undefined>;
+    readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+}, undefined>;
+/**
+ * Valibot schema for validating partial step recommendation objects.
+ *
+ * This is a lenient version of StepRecommendationSchema used for previous_steps,
+ * where LLMs naturally provide partial/skeletal data. Only step_description is
+ * strictly required, while expected_outcome and tool recommendation fields are
+ * optional with default values.
+ *
+ * Validates that a partial step recommendation has:
+ * - A step description (required)
+ * - An array of recommended tools (with optional confidence/priority)
+ * - An optional array of recommended skills
+ * - An optional expected outcome (defaults to empty string)
+ * - Optional conditions for the next step
+ *
+ * @remarks
+ * **Design Rationale:**
+ * LLMs provide complete, detailed data for current_step but only brief summaries
+ * for previous_steps. This schema allows the natural LLM behavior while the
+ * InputNormalizer fills in sensible defaults for missing fields.
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { PartialStepRecommendationSchema } from './schema.js';
+ *
+ * // Minimal valid input (LLM often generates this for previous_steps)
+ * const result = safeParse(PartialStepRecommendationSchema, {
+ *   step_description: 'Read the file',
+ *   recommended_tools: [{
+ *     tool_name: 'Read',
+ *     rationale: 'Read the file'
+ *   }]
+ * });
+ * // confidence, priority, and expected_outcome will be filled in by normalizer
+ * ```
+ */
+export declare const PartialStepRecommendationSchema: v.ObjectSchema<{
+    readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+    readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+        readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended (default: empty string)">]>, undefined>;
+        readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+        readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+        readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+            [x: string]: unknown;
+        }, "Optional suggested parameters">]>, undefined>;
+        readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        tool_name: string;
+        rationale?: string | undefined;
+        confidence?: number | undefined;
+        priority?: number | undefined;
+        suggested_inputs?: {
+            [x: string]: unknown;
+        } | undefined;
+        alternatives?: string[] | undefined;
+    }[], "Tools recommended for this step">]>;
+    readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+        readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+        readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+        readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+        readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+        readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+        readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        skill_name: string;
+        confidence?: number | undefined;
+        rationale?: string | undefined;
+        priority?: number | undefined;
+        alternatives?: string[] | undefined;
+        allowed_tools?: string[] | undefined;
+        user_invocable?: boolean | undefined;
+    }[], "Skills recommended for this step">]>, undefined>;
+    readonly expected_outcome: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step (default: empty string)">]>, undefined>;
+    readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+}, undefined>;
+/**
+ * Main Valibot schema for validating sequential thinking tool input.
+ *
+ * This is the primary schema used for the sequential thinking MCP tool.
+ * It validates all thought data including:
+ * - Optional available tools and skills arrays
+ * - The thought content (required)
+ * - Thought numbering (thought_number, total_thoughts)
+ * - Revision and branching metadata
+ * - Current, previous, and remaining step recommendations
+ *
+ * @remarks
+ * **Validation Rules:**
+ * - `thought_number` must be >= 1
+ * - `total_thoughts` must be >= 1
+ * - `branch_id` must be 1-50 characters, alphanumeric/hyphens/underscores only
+ * - `confidence` values must be between 0 and 1
+ * - `thought_type` must be one of: regular, hypothesis, verification, critique, synthesis, meta
+ * - `quality_score` and `confidence` must be between 0 and 1
+ * - `hypothesis_id` must be 1-50 characters, alphanumeric/hyphens/underscores only
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { SequentialThinkingSchema } from './schema.js';
+ *
+ * const result = safeParse(SequentialThinkingSchema, {
+ *   thought: 'I need to analyze the problem',
+ *   thought_number: 1,
+ *   total_thoughts: 5,
+ *   next_thought_needed: true,
+ *   available_mcp_tools: ['Read', 'Write', 'Grep']
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Valid thought:', result.output);
+ * } else {
+ *   console.error('Validation errors:', result.issues);
+ * }
+ * ```
+ */
+export declare const SequentialThinkingSchema: v.ObjectSchema<{
+    readonly available_mcp_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of MCP tool names available for use (e.g., [\"mcp-omnisearch\", \"mcp-turso-cloud\"])">]>, undefined>;
+    readonly available_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Array of skill names available for use (e.g., [\"commit\", \"review-pr\", \"pdf\"])">]>, undefined>;
+    readonly thought: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Your current thinking step">]>;
+    readonly next_thought_needed: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether another thought step is needed (defaults to true if not provided)">]>, undefined>;
+    readonly thought_number: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Current thought number">]>;
+    readonly total_thoughts: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Estimated total thoughts needed">]>;
+    readonly is_revision: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this revises previous thinking">]>, undefined>;
+    readonly revises_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Which thought is being reconsidered">]>, undefined>;
+    readonly branch_from_thought: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Branching point thought number">]>, undefined>;
+    readonly branch_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Branch ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Branch identifier (alphanumeric, hyphens, underscores only, max 50 chars)">]>, undefined>;
+    readonly needs_more_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "If more thoughts are needed">]>, undefined>;
+    readonly current_step: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+        readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+            readonly confidence: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation">]>;
+            readonly rationale: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended">]>;
+            readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+            readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+                [x: string]: unknown;
+            }, "Optional suggested parameters">]>, undefined>;
+            readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            tool_name: string;
+            confidence: number;
+            rationale: string;
+            priority?: number | undefined;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[], "Tools recommended for this step">]>;
+        readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+            readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+            readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+            readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+            readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+            readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+            readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            skill_name: string;
+            confidence?: number | undefined;
+            rationale?: string | undefined;
+            priority?: number | undefined;
+            alternatives?: string[] | undefined;
+            allowed_tools?: string[] | undefined;
+            user_invocable?: boolean | undefined;
+        }[], "Skills recommended for this step">]>, undefined>;
+        readonly expected_outcome: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step">]>;
+        readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+    }, undefined>, v.DescriptionAction<{
+        step_description: string;
+        recommended_tools: {
+            tool_name: string;
+            confidence: number;
+            rationale: string;
+            priority?: number | undefined;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[];
+        recommended_skills?: {
+            skill_name: string;
+            confidence?: number | undefined;
+            rationale?: string | undefined;
+            priority?: number | undefined;
+            alternatives?: string[] | undefined;
+            allowed_tools?: string[] | undefined;
+            user_invocable?: boolean | undefined;
+        }[] | undefined;
+        expected_outcome: string;
+        next_step_conditions?: string[] | undefined;
+    }, "Current step recommendation">]>, undefined>;
+    readonly previous_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly step_description: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What needs to be done">]>;
+        readonly recommended_tools: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly tool_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the tool being recommended">]>;
+            readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this tool is recommended (default: empty string)">]>, undefined>;
+            readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+            readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+            readonly suggested_inputs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>, v.DescriptionAction<{
+                [x: string]: unknown;
+            }, "Optional suggested parameters">]>, undefined>;
+            readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative tools that could be used">]>, undefined>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            tool_name: string;
+            rationale?: string | undefined;
+            confidence?: number | undefined;
+            priority?: number | undefined;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[], "Tools recommended for this step">]>;
+        readonly recommended_skills: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+            readonly skill_name: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Name of the skill being recommended">]>;
+            readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "0-1 indicating confidence in recommendation (default: 0.5)">]>, undefined>;
+            readonly rationale: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Why this skill is recommended (default: empty string)">]>, undefined>;
+            readonly priority: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Order in the recommendation sequence (default: 999)">]>, undefined>;
+            readonly alternatives: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Alternative skills that could be used">]>, undefined>;
+            readonly allowed_tools: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Tools this skill is allowed to use (from skill frontmatter)">]>, undefined>;
+            readonly user_invocable: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "Whether this skill can be user-invoked">]>, undefined>;
+        }, undefined>, undefined>, v.DescriptionAction<{
+            skill_name: string;
+            confidence?: number | undefined;
+            rationale?: string | undefined;
+            priority?: number | undefined;
+            alternatives?: string[] | undefined;
+            allowed_tools?: string[] | undefined;
+            user_invocable?: boolean | undefined;
+        }[], "Skills recommended for this step">]>, undefined>;
+        readonly expected_outcome: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "What to expect from this step (default: empty string)">]>, undefined>;
+        readonly next_step_conditions: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "Conditions to consider for the next step">]>, undefined>;
+    }, undefined>, undefined>, v.DescriptionAction<{
+        step_description: string;
+        recommended_tools: {
+            tool_name: string;
+            rationale?: string | undefined;
+            confidence?: number | undefined;
+            priority?: number | undefined;
+            suggested_inputs?: {
+                [x: string]: unknown;
+            } | undefined;
+            alternatives?: string[] | undefined;
+        }[];
+        recommended_skills?: {
+            skill_name: string;
+            confidence?: number | undefined;
+            rationale?: string | undefined;
+            priority?: number | undefined;
+            alternatives?: string[] | undefined;
+            allowed_tools?: string[] | undefined;
+            user_invocable?: boolean | undefined;
+        }[] | undefined;
+        expected_outcome?: string | undefined;
+        next_step_conditions?: string[] | undefined;
+    }[], "Steps already recommended (lenient schema - allows partial data with defaults)">]>, undefined>;
+    readonly remaining_steps: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.DescriptionAction<string[], "High-level descriptions of upcoming steps">]>, undefined>;
+    readonly thought_type: v.OptionalSchema<v.SchemaWithPipe<readonly [v.PicklistSchema<["regular", "hypothesis", "verification", "critique", "synthesis", "meta"], undefined>, v.DescriptionAction<"regular" | "hypothesis" | "verification" | "critique" | "synthesis" | "meta", "Classified purpose: regular, hypothesis, verification, critique, synthesis, meta">]>, undefined>;
+    readonly quality_score: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "Self-assessed quality score (0-1)">]>, undefined>;
+    readonly confidence: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>, v.DescriptionAction<number, "Explicit confidence in correctness (0-1)">]>, undefined>;
+    readonly hypothesis_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Hypothesis ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 50, undefined>, v.DescriptionAction<string, "Identifier linking hypothesis to verification thoughts">]>, undefined>;
+    readonly verification_target: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.DescriptionAction<number, "Thought number being verified or critiqued">]>, undefined>;
+    readonly synthesis_sources: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, v.DescriptionAction<number[], "Thought numbers being synthesized">]>, undefined>;
+    readonly merge_from_thoughts: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, undefined>, v.DescriptionAction<number[], "Thought numbers from other branches being merged (DAG)">]>, undefined>;
+    readonly merge_branch_ids: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, undefined>, v.MaxLengthAction<string, 50, undefined>]>, undefined>, v.DescriptionAction<string[], "Branch IDs being merged into current context">]>, undefined>;
+    readonly meta_observation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Metacognitive observation about reasoning process">]>, undefined>;
+    readonly reasoning_depth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.PicklistSchema<["shallow", "moderate", "deep"], undefined>, v.DescriptionAction<"shallow" | "moderate" | "deep", "Effort signal: how deep reasoning should go">]>, undefined>;
+    readonly session_id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "Session ID must contain only letters, numbers, hyphens, and underscores">, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>, v.DescriptionAction<string, "Optional session identifier for state isolation. When provided, thought history, branches, and statistics are scoped to this session. Omitting preserves global behavior.">]>, undefined>;
+    readonly reset_state: v.OptionalSchema<v.SchemaWithPipe<readonly [v.BooleanSchema<undefined>, v.DescriptionAction<boolean, "When true, clears all state for the target session before processing this thought. The thought is then processed as the first in a fresh session.">]>, undefined>;
+}, undefined>;
+/**
+ * The sequential thinking tool definition for MCP registration.
+ *
+ * This object defines the tool that is registered with the MCP server.
+ * The inputSchema is left empty as the schema is handled by tmcp
+ * when registering the tool using the Valibot adapter.
+ *
+ * @example
+ * ```typescript
+ * import { SEQUENTIAL_THINKING_TOOL } from './schema.js';
+ * import { McpServer } from 'tmcp';
+ *
+ * const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+ * server.tool({
+ *   name: SEQUENTIAL_THINKING_TOOL.name,
+ *   description: SEQUENTIAL_THINKING_TOOL.description,
+ *   schema: SequentialThinkingSchema
+ * }, handler);
+ * ```
+ */
+export declare const SEQUENTIAL_THINKING_TOOL: Tool;
+/**
+ * Valibot schema for validating JSON-RPC 2.0 request messages.
+ *
+ * Validates that a JSON-RPC request has:
+ * - A jsonrpc version (must be "2.0")
+ * - A method name (string)
+ * - Optional params (object or array)
+ * - Optional id (string, number, or null for notifications)
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from 'valibot';
+ * import { JsonRpcRequestSchema } from './schema.js';
+ *
+ * const result = safeParse(JsonRpcRequestSchema, {
+ *   jsonrpc: '2.0',
+ *   method: 'tools/list',
+ *   id: 1
+ * });
+ * ```
+ */
+export declare const JsonRpcRequestSchema: v.ObjectSchema<{
+    readonly jsonrpc: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.LiteralSchema<"2.0", undefined>, v.DescriptionAction<"2.0", "JSON-RPC protocol version (must be \"2.0\")">]>;
+    readonly method: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.DescriptionAction<string, "Method name to invoke">]>;
+    readonly params: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.ObjectSchema<{}, undefined>, v.ArraySchema<v.UnknownSchema, undefined>], undefined>, v.DescriptionAction<unknown[] | {}, "Method parameters (object or array)">]>, undefined>;
+    readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, v.DescriptionAction<string | number | null, "Request ID (omit for notifications)">]>, undefined>;
+}, undefined>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAC7B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAgH5C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;aAkBnC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;aA4BpC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAanC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;aAsB1C,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAe1C,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA8JnC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,wBAAwB,EAAE,IAItC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB;;;;;aAmB/B,CAAC"}