@syrin/cli 1.3.0

package/dist/runtime/analysis/indexer.js

@@ -0,0 +1,62 @@
+/**
+ * Index builder.
+ * Builds fast lookup indexes for analysis rules.
+ */
+/**
+ * Extract keywords from tool name and description.
+ */
+function extractKeywords(tool) {
+    const keywords = new Set();
+    const text = `${tool.name} ${tool.description}`.toLowerCase();
+    // Extract words (alphanumeric sequences)
+    const words = text.match(/\b\w{3,}\b/g) || [];
+    for (const word of words) {
+        keywords.add(word);
+    }
+    return keywords;
+}
+/**
+ * Build indexes from normalized tools.
+ */
+export function buildIndexes(tools) {
+    const toolIndex = new Map();
+    const inputIndex = new Map();
+    const outputIndex = new Map();
+    const keywordIndex = new Map();
+    for (const tool of tools) {
+        // Build tool index
+        toolIndex.set(tool.name.toLowerCase(), tool);
+        // Build input index
+        for (const input of tool.inputs) {
+            const fieldName = input.name.toLowerCase();
+            if (!inputIndex.has(fieldName)) {
+                inputIndex.set(fieldName, []);
+            }
+            inputIndex.get(fieldName).push(input);
+        }
+        // Build output index
+        for (const output of tool.outputs) {
+            const fieldName = output.name.toLowerCase();
+            if (!outputIndex.has(fieldName)) {
+                outputIndex.set(fieldName, []);
+            }
+            outputIndex.get(fieldName).push(output);
+        }
+        // Build keyword index
+        const keywords = extractKeywords(tool);
+        const toolNameLower = tool.name.toLowerCase();
+        for (const keyword of keywords) {
+            if (!keywordIndex.has(keyword)) {
+                keywordIndex.set(keyword, new Set());
+            }
+            keywordIndex.get(keyword).add(toolNameLower);
+        }
+    }
+    return {
+        toolIndex,
+        inputIndex,
+        outputIndex,
+        keywordIndex,
+    };
+}
+//# sourceMappingURL=indexer.js.map

package/dist/runtime/analysis/loader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP tool loader.
+ * Loads raw tool metadata from MCP servers.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { RawTool } from './types.js';
+/**
+ * Load raw tools from MCP server.
+ * This is the entry point that fetches tool metadata without execution.
+ *
+ * @param client - Connected MCP client
+ * @returns Array of raw tool definitions
+ */
+export declare function loadMCPTools(client: Client): Promise<RawTool[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/runtime/analysis/loader.js

@@ -0,0 +1,47 @@
+/**
+ * MCP tool loader.
+ * Loads raw tool metadata from MCP servers.
+ */
+import { listTools } from '../../runtime/mcp/list.js';
+/**
+ * Load raw tools from MCP server.
+ * This is the entry point that fetches tool metadata without execution.
+ *
+ * @param client - Connected MCP client
+ * @returns Array of raw tool definitions
+ */
+export async function loadMCPTools(client) {
+    let result;
+    try {
+        result = await listTools(client);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load tools from MCP server: ${errorMessage}`, {
+            cause: error,
+        });
+    }
+    const tools = result.tools || [];
+    // Validate each tool before mapping
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        if (!tool) {
+            throw new Error(`Tool at index ${i} is undefined`);
+        }
+        if (!tool.name) {
+            const toolSummary = JSON.stringify({
+                description: tool.description,
+                inputSchema: tool.inputSchema ? 'present' : 'missing',
+                outputSchema: tool.outputSchema ? 'present' : 'missing',
+            });
+            throw new Error(`Missing tool.name at index ${i}: ${toolSummary}`);
+        }
+    }
+    return tools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+    }));
+}
+//# sourceMappingURL=loader.js.map

package/dist/runtime/analysis/normalizer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Schema normalizer.
+ * Normalizes and extracts fields from JSON Schema definitions.
+ */
+import type { RawTool, ToolSpec } from './types.js';
+/**
+ * Normalize a raw tool into a ToolSpec.
+ */
+export declare function normalizeTool(rawTool: RawTool): Promise<ToolSpec>;
+/**
+ * Normalize multiple raw tools.
+ */
+export declare function normalizeTools(rawTools: RawTool[]): Promise<ToolSpec[]>;
+//# sourceMappingURL=normalizer.d.ts.map

package/dist/runtime/analysis/normalizer.js

@@ -0,0 +1,184 @@
+/**
+ * Schema normalizer.
+ * Normalizes and extracts fields from JSON Schema definitions.
+ */
+import $RefParser from '@apidevtools/json-schema-ref-parser';
+/**
+ * Type guard to check if object is a JSONSchemaField.
+ * Performs structural check for expected JSON Schema field properties.
+ */
+function isJSONSchemaField(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        ('type' in obj || 'properties' in obj || 'items' in obj || '$ref' in obj));
+}
+/**
+ * Extract tokens from text for similarity matching.
+ */
+function extractTokens(text) {
+    const tokens = text
+        .toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(token => token.length > 2); // Filter out short tokens
+    return new Set(tokens);
+}
+/**
+ * Normalize a JSON Schema type to a string representation.
+ * Handles string, string[], and undefined types.
+ *
+ * @param type - The type to normalize (string, string[], or undefined)
+ * @returns Normalized type string ('any' for empty/undefined, joined types for arrays)
+ */
+function normalizeType(type) {
+    if (Array.isArray(type)) {
+        // Empty array defaults to 'any'
+        if (type.length === 0) {
+            return 'any';
+        }
+        // Filter out 'null' and join remaining types
+        const nonNullTypes = type.filter(t => t !== 'null');
+        // If only 'null' remains, return 'null', otherwise join non-null types
+        return nonNullTypes.length > 0 ? nonNullTypes.join('|') : 'null';
+    }
+    // String or undefined: return type or 'any' as fallback
+    return type || 'any';
+}
+/**
+ * Extract field specifications from a JSON Schema object.
+ */
+async function extractFieldsFromSchema(schema, toolName, isInput) {
+    const fields = [];
+    if (!schema || typeof schema !== 'object') {
+        return fields;
+    }
+    // Resolve $ref if present
+    let resolvedSchema = schema;
+    try {
+        resolvedSchema = await $RefParser.dereference(schema);
+    }
+    catch {
+        // If dereference fails, use original schema
+        resolvedSchema = schema;
+    }
+    if (!isJSONSchemaField(resolvedSchema)) {
+        return fields;
+    }
+    // Handle object type with properties
+    if (resolvedSchema.type === 'object' &&
+        resolvedSchema.properties &&
+        typeof resolvedSchema.properties === 'object') {
+        const required = new Set(Array.isArray(resolvedSchema.required) ? resolvedSchema.required : []);
+        const properties = resolvedSchema.properties;
+        for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+            // Handle fields that might not have a type but have other properties (like title)
+            // In JSON Schema, fields without explicit type default to 'any'
+            if (typeof fieldSchema !== 'object' || fieldSchema === null) {
+                continue;
+            }
+            // If field doesn't pass isJSONSchemaField check but is in properties,
+            // it might still be a valid field (e.g., only has 'title' but no 'type')
+            // We'll treat it as a field with type 'any' (undefined type normalizes to 'any')
+            // Create a field object that will work with our processing
+            const field = isJSONSchemaField(fieldSchema)
+                ? fieldSchema
+                : {
+                    ...fieldSchema,
+                    type: undefined, // Will normalize to 'any'
+                };
+            // Determine nullable: true if explicitly set, or if type is an array containing 'null'
+            // Do not infer nullable from single type === 'null' (that means value must be null)
+            const isNullable = field.nullable === true ||
+                (Array.isArray(field.type) && field.type.includes('null'));
+            // Normalize type using helper function
+            const normalizedType = normalizeType(field.type);
+            const fieldSpec = {
+                tool: toolName,
+                name: fieldName,
+                type: normalizedType,
+                required: required.has(fieldName),
+                description: field.description,
+                nullable: isNullable,
+            };
+            // Extract enum values
+            if (Array.isArray(field.enum)) {
+                fieldSpec.enum = field.enum.map(String);
+            }
+            // Extract pattern
+            if (field.pattern) {
+                fieldSpec.pattern = String(field.pattern);
+            }
+            // Extract example
+            if (Array.isArray(field.examples) && field.examples.length > 0) {
+                fieldSpec.example = field.examples[0];
+            }
+            else if (field.example !== undefined) {
+                fieldSpec.example = field.example;
+            }
+            // Handle nested object properties
+            // Check if type is 'object' (either directly or in an array)
+            const isObjectType = (Array.isArray(field.type) && field.type.includes('object')) ||
+                field.type === 'object';
+            if (isObjectType && field.properties) {
+                fieldSpec.properties = await extractFieldsFromSchema(field, toolName, isInput);
+            }
+            fields.push(fieldSpec);
+        }
+    }
+    else if (resolvedSchema.type) {
+        // Handle non-object types (simple types)
+        // Normalize type using helper function
+        const normalizedType = normalizeType(resolvedSchema.type);
+        const fieldSpec = {
+            tool: toolName,
+            name: isInput ? 'input' : 'output',
+            type: normalizedType,
+            required: !isInput, // Outputs are always "required" conceptually
+            description: resolvedSchema.description,
+            nullable: resolvedSchema.nullable === true,
+        };
+        if (Array.isArray(resolvedSchema.enum)) {
+            fieldSpec.enum = resolvedSchema.enum.map(String);
+        }
+        if (resolvedSchema.pattern) {
+            fieldSpec.pattern = String(resolvedSchema.pattern);
+        }
+        if (resolvedSchema.examples &&
+            Array.isArray(resolvedSchema.examples) &&
+            resolvedSchema.examples.length > 0) {
+            fieldSpec.example = resolvedSchema.examples[0];
+        }
+        else if (resolvedSchema.example !== undefined) {
+            fieldSpec.example = resolvedSchema.example;
+        }
+        fields.push(fieldSpec);
+    }
+    return fields;
+}
+/**
+ * Normalize a raw tool into a ToolSpec.
+ */
+export async function normalizeTool(rawTool) {
+    const description = rawTool.description || '';
+    const inputs = rawTool.inputSchema
+        ? await extractFieldsFromSchema(rawTool.inputSchema, rawTool.name, true)
+        : [];
+    const outputs = rawTool.outputSchema
+        ? await extractFieldsFromSchema(rawTool.outputSchema, rawTool.name, false)
+        : [];
+    return {
+        name: rawTool.name,
+        description,
+        inputs,
+        outputs,
+        descriptionTokens: extractTokens(rawTool.name + ' ' + description),
+    };
+}
+/**
+ * Normalize multiple raw tools.
+ */
+export async function normalizeTools(rawTools) {
+    const normalized = await Promise.all(rawTools.map(normalizeTool));
+    return normalized;
+}
+//# sourceMappingURL=normalizer.js.map

package/dist/runtime/analysis/rules/__test-helpers__.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared test helpers for analysis rule tests.
+ */
+import type { ToolSpec, FieldSpec } from '../types.js';
+/**
+ * Build indexes from tools for testing.
+ */
+export declare function buildIndexesFromTools(tools: ToolSpec[]): {
+    toolIndex: Map<string, ToolSpec>;
+    inputIndex: Map<string, FieldSpec[]>;
+    outputIndex: Map<string, FieldSpec[]>;
+    keywordIndex: Map<string, Set<string>>;
+};
+/**
+ * Setup mocks for analysis tests.
+ * Note: Mocks should be set up in individual test files using vi.mock()
+ */
+//# sourceMappingURL=__test-helpers__.d.ts.map

package/dist/runtime/analysis/rules/__test-helpers__.js

@@ -0,0 +1,40 @@
+/**
+ * Shared test helpers for analysis rule tests.
+ */
+/**
+ * Build indexes from tools for testing.
+ */
+export function buildIndexesFromTools(tools) {
+    const toolIndex = new Map();
+    const inputIndex = new Map();
+    const outputIndex = new Map();
+    const keywordIndex = new Map();
+    for (const tool of tools) {
+        toolIndex.set(tool.name.toLowerCase(), tool);
+        for (const input of tool.inputs || []) {
+            const fieldName = input.name.toLowerCase();
+            if (!inputIndex.has(fieldName)) {
+                inputIndex.set(fieldName, []);
+            }
+            inputIndex.get(fieldName).push(input);
+        }
+        for (const output of tool.outputs || []) {
+            const fieldName = output.name.toLowerCase();
+            if (!outputIndex.has(fieldName)) {
+                outputIndex.set(fieldName, []);
+            }
+            outputIndex.get(fieldName).push(output);
+        }
+    }
+    return {
+        toolIndex,
+        inputIndex,
+        outputIndex,
+        keywordIndex,
+    };
+}
+/**
+ * Setup mocks for analysis tests.
+ * Note: Mocks should be set up in individual test files using vi.mock()
+ */
+//# sourceMappingURL=__test-helpers__.js.map

package/dist/runtime/analysis/rules/base.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Rule engine base types and interfaces.
+ */
+import type { AnalysisContext, Diagnostic } from '../types.js';
+/**
+ * Base interface for all analysis rules.
+ */
+export interface Rule {
+    /** Rule ID (e.g., "E001", "W001") */
+    id: string;
+    /** Severity level */
+    severity: 'error' | 'warning';
+    /** Human-readable rule name */
+    ruleName: string;
+    /** Rule description */
+    description: string;
+    /**
+     * Check function that returns diagnostics for violations.
+     * @param ctx - Analysis context
+     * @returns Array of diagnostics (empty if no violations)
+     */
+    check(ctx: AnalysisContext): Diagnostic[];
+}
+/**
+ * Base rule implementation helper.
+ */
+export declare abstract class BaseRule implements Rule {
+    abstract readonly id: string;
+    abstract readonly severity: 'error' | 'warning';
+    abstract readonly ruleName: string;
+    abstract readonly description: string;
+    abstract check(ctx: AnalysisContext): Diagnostic[];
+    /**
+     * Create a diagnostic.
+     */
+    protected createDiagnostic(message: string, tool?: string, field?: string, suggestion?: string, context?: Record<string, unknown>, severity?: 'error' | 'warning'): Diagnostic;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/runtime/analysis/rules/base.js

@@ -0,0 +1,23 @@
+/**
+ * Rule engine base types and interfaces.
+ */
+/**
+ * Base rule implementation helper.
+ */
+export class BaseRule {
+    /**
+     * Create a diagnostic.
+     */
+    createDiagnostic(message, tool, field, suggestion, context, severity) {
+        return {
+            code: this.id,
+            severity: severity ?? this.severity,
+            message,
+            tool,
+            field,
+            suggestion,
+            context,
+        };
+    }
+}
+//# sourceMappingURL=base.js.map

package/dist/runtime/analysis/rules/error-codes.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Error code constants.
+ * Centralized definition of all error codes used in the analysis system.
+ * Organized by category (similar to HTTP status codes) for future expansion.
+ * This ensures type safety, prevents typos, and provides a single source of truth.
+ */
+/**
+ * Error codes for analysis rules.
+ * Organized in categories with ranges for future expansion.
+ */
+export declare const ERROR_CODES: {
+    readonly E000: "E000";
+    readonly E100: "E100";
+    readonly E101: "E101";
+    readonly E102: "E102";
+    readonly E103: "E103";
+    readonly E104: "E104";
+    readonly E105: "E105";
+    readonly E106: "E106";
+    readonly E107: "E107";
+    readonly E108: "E108";
+    readonly E109: "E109";
+    readonly E110: "E110";
+    readonly E200: "E200";
+    readonly E300: "E300";
+    readonly E301: "E301";
+    readonly E400: "E400";
+    readonly E403: "E403";
+    readonly E500: "E500";
+    readonly E501: "E501";
+    readonly E600: "E600";
+};
+/**
+ * Warning code constants.
+ */
+export declare const WARNING_CODES: {
+    readonly W100: "W100";
+    readonly W101: "W101";
+    readonly W102: "W102";
+    readonly W103: "W103";
+    readonly W104: "W104";
+    readonly W105: "W105";
+    readonly W106: "W106";
+    readonly W107: "W107";
+    readonly W108: "W108";
+    readonly W109: "W109";
+    readonly W110: "W110";
+    readonly W300: "W300";
+    readonly W301: "W301";
+};
+/**
+ * Error code type for type safety.
+ */
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+/**
+ * Warning code type for type safety.
+ */
+export type WarningCode = (typeof WARNING_CODES)[keyof typeof WARNING_CODES];
+/**
+ * Error type to error code mapping.
+ * Maps friendly error type names (as used in test expectations) to error codes.
+ */
+export declare const ERROR_TYPE_TO_CODE: Record<string, ErrorCode>;
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/runtime/analysis/rules/error-codes.js

@@ -0,0 +1,73 @@
+/**
+ * Error code constants.
+ * Centralized definition of all error codes used in the analysis system.
+ * Organized by category (similar to HTTP status codes) for future expansion.
+ * This ensures type safety, prevents typos, and provides a single source of truth.
+ */
+/**
+ * Error codes for analysis rules.
+ * Organized in categories with ranges for future expansion.
+ */
+export const ERROR_CODES = {
+    // 0xx: Configuration & Setup Errors
+    E000: 'E000', // Tool Not Found
+    // 1xx: Schema & Contract Errors (Static Analysis)
+    E100: 'E100', // Missing Output Schema
+    E101: 'E101', // Missing Tool Description
+    E102: 'E102', // Underspecified Required Input
+    E103: 'E103', // Type Mismatch
+    E104: 'E104', // Parameter Not In Description
+    E105: 'E105', // Free Text Propagation
+    E106: 'E106', // Output Not Guaranteed
+    E107: 'E107', // Circular Dependency
+    E108: 'E108', // Implicit User Input
+    E109: 'E109', // Non-Serializable
+    E110: 'E110', // Tool Ambiguity
+    // 2xx: Input Validation Errors
+    E200: 'E200', // Input Validation Failed
+    // 3xx: Output Validation Errors
+    E300: 'E300', // Output Validation Failed
+    E301: 'E301', // Output Explosion
+    // 4xx: Execution Errors
+    E400: 'E400', // Tool Execution Failed
+    E403: 'E403', // Unbounded Execution
+    // 5xx: Behavioral Errors (Side Effects & Dependencies)
+    E500: 'E500', // Side Effect Detected
+    E501: 'E501', // Hidden Dependency
+    // 6xx: Test & Validation Framework Errors
+    E600: 'E600', // Unexpected Test Result
+};
+/**
+ * Warning code constants.
+ */
+export const WARNING_CODES = {
+    // 1xx: Schema & Contract Warnings (Static Analysis)
+    W100: 'W100', // Implicit Dependency
+    W101: 'W101', // Free Text Without Normalization
+    W102: 'W102', // Missing Examples
+    W103: 'W103', // Overloaded Responsibility
+    W104: 'W104', // Generic Description
+    W105: 'W105', // Optional As Required
+    W106: 'W106', // Broad Output Schema
+    W107: 'W107', // Multiple Entry Points
+    W108: 'W108', // Hidden Side Effects
+    W109: 'W109', // Output Not Reusable
+    W110: 'W110', // Weak Schema
+    // 3xx: Output Validation Warnings
+    W300: 'W300', // High Entropy Output
+    W301: 'W301', // Unstable Defaults
+};
+/**
+ * Error type to error code mapping.
+ * Maps friendly error type names (as used in test expectations) to error codes.
+ */
+export const ERROR_TYPE_TO_CODE = {
+    side_effect: ERROR_CODES.E500,
+    output_explosion: ERROR_CODES.E301,
+    hidden_dependency: ERROR_CODES.E501,
+    unbounded_execution: ERROR_CODES.E403,
+    output_validation: ERROR_CODES.E300,
+    input_validation: ERROR_CODES.E200,
+    execution_error: ERROR_CODES.E400,
+};
+//# sourceMappingURL=error-codes.js.map

package/dist/runtime/analysis/rules/errors/e000-tool-not-found.d.ts

@@ -0,0 +1,35 @@
+/**
+ * E000: Tool Not Found
+ *
+ * Condition: Tool is not found in MCP server
+ *
+ * Why this is fatal:
+ * - Tool contract exists but tool is not registered in server
+ * - Indicates configuration mismatch or missing tool implementation
+ * - Cannot test or validate a tool that doesn't exist
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+/**
+ * Context for tool not found detection.
+ */
+export interface ToolNotFoundContext {
+    /** Tool name */
+    toolName: string;
+    /** MCP server script name */
+    scriptName: string;
+}
+declare class E000ToolNotFoundRule extends BaseRule {
+    readonly id: "E000";
+    readonly severity: "error";
+    readonly ruleName = "Tool Not Found";
+    readonly description = "Tool is not found in MCP server. Tool contract exists but tool is not registered in the server script.";
+    check(_ctx: AnalysisContext): Diagnostic[];
+    /**
+     * Check with runtime context (called from test orchestrator).
+     */
+    checkWithRuntimeContext(runtimeCtx: ToolNotFoundContext): Diagnostic[];
+}
+export declare const E000ToolNotFound: E000ToolNotFoundRule;
+export {};
+//# sourceMappingURL=e000-tool-not-found.d.ts.map

package/dist/runtime/analysis/rules/errors/e000-tool-not-found.js

@@ -0,0 +1,32 @@
+/**
+ * E000: Tool Not Found
+ *
+ * Condition: Tool is not found in MCP server
+ *
+ * Why this is fatal:
+ * - Tool contract exists but tool is not registered in server
+ * - Indicates configuration mismatch or missing tool implementation
+ * - Cannot test or validate a tool that doesn't exist
+ */
+import { BaseRule } from '../base.js';
+import { ERROR_CODES } from '../error-codes.js';
+class E000ToolNotFoundRule extends BaseRule {
+    id = ERROR_CODES.E000;
+    severity = 'error';
+    ruleName = 'Tool Not Found';
+    description = 'Tool is not found in MCP server. Tool contract exists but tool is not registered in the server script.';
+    check(_ctx) {
+        // This rule requires runtime context (checked in orchestrator)
+        return [];
+    }
+    /**
+     * Check with runtime context (called from test orchestrator).
+     */
+    checkWithRuntimeContext(runtimeCtx) {
+        const diagnostics = [];
+        diagnostics.push(this.createDiagnostic(`Tool "${runtimeCtx.toolName}" not found in MCP server (running: ${runtimeCtx.scriptName}). Ensure the tool is registered in the server script.`, runtimeCtx.toolName, undefined, `Verify that "${runtimeCtx.toolName}" is registered in your MCP server script (${runtimeCtx.scriptName}). If the tool is in a different server file, update the 'script' configuration in syrin.yaml.`));
+        return diagnostics;
+    }
+}
+export const E000ToolNotFound = new E000ToolNotFoundRule();
+//# sourceMappingURL=e000-tool-not-found.js.map

package/dist/runtime/analysis/rules/errors/e001-missing-output-schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * E001: Missing Output Schema
+ *
+ * Condition: Tool does not declare an output schema
+ *
+ * Why this is fatal:
+ * - Downstream tools cannot reason about outputs
+ * - LLM will invent structure
+ * - Reproducibility is impossible
+ */
+import { BaseRule } from '../base.js';
+import type { AnalysisContext, Diagnostic } from '../../types.js';
+declare class E001MissingOutputSchemaRule extends BaseRule {
+    readonly id: "E001";
+    readonly severity: "error";
+    readonly ruleName = "Missing Output Schema";
+    readonly description = "Tool does not declare an output schema. Downstream tools cannot safely consume its output.";
+    check(ctx: AnalysisContext): Diagnostic[];
+}
+export declare const E001MissingOutputSchema: E001MissingOutputSchemaRule;
+export {};
+//# sourceMappingURL=e001-missing-output-schema.d.ts.map