@hyperfixi/core 3.3.0 → 4.0.1

package/dist/test-utilities.d.ts

@@ -1,39 +0,0 @@
-import type { CoreExecutionContext, ExecutionContext, TypedExecutionContext } from './types/base-types';
-export type { CoreExecutionContext, ExecutionContext, TypedExecutionContext };
-export type MutableContext<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-export type TestExpressionContext = MutableContext<TypedExecutionContext> & {
-    performanceMetrics?: {
-        totalEvaluations: number;
-        averageExecutionTime: number;
-        lastEvaluationTime: number;
-    };
-    [key: string]: unknown;
-};
-export type TypedExpressionContext = TestExpressionContext;
-export declare function createMockElement(tag?: string, properties?: Record<string, any>, attributes?: Record<string, string>): HTMLElement;
-export interface TestContextOptions {
-    me?: Element | null;
-    you?: Element | null;
-    it?: unknown;
-    event?: Event | null;
-    locals?: Map<string, unknown>;
-    globals?: Map<string, unknown>;
-    variables?: Map<string, unknown>;
-    result?: unknown;
-}
-export declare function createCoreTestContext(options?: Partial<CoreExecutionContext>): CoreExecutionContext;
-export declare function createTestContext(options?: TestContextOptions): ExecutionContext;
-export declare function createTypedExecutionContext(options?: TestContextOptions): TypedExecutionContext;
-export declare function createTypedExpressionContext(data?: Record<string, unknown>): TestExpressionContext;
-export declare function setupMockDOM(): void;
-export declare function waitForTick(): Promise<void>;
-export declare function createPerformanceContext(): {
-    mark: (name: string) => number;
-    measure: <T>(name: string, operation: () => Promise<T> | T) => Promise<{
-        result: T;
-        duration: number;
-    }>;
-};
-//# sourceMappingURL=test-utilities.d.ts.map

package/dist/types/base-types.d.ts

@@ -1,231 +0,0 @@
-import type { RuntimeValidator } from '../validation/lightweight-validators';
-import type { CoreExecutionContext } from './core-context';
-import type { ExpressionRegistry } from '../core/expression-registry';
-export type { CoreExecutionContext } from './core-context';
-export { createCoreContext, isCoreExecutionContext, assertHTMLElement, asHTMLElement, } from './core-context';
-export interface ValidationError {
-    readonly type: 'type-mismatch' | 'missing-argument' | 'runtime-error' | 'validation-error' | 'syntax-error' | 'invalid-argument' | 'invalid-input' | 'empty-config' | 'schema-validation' | 'context-error' | 'invalid-syntax' | 'security-warning';
-    readonly message: string;
-    readonly suggestions: readonly string[] | string[];
-    readonly path?: string;
-    readonly code?: string;
-    readonly name?: string;
-    readonly severity?: 'error' | 'warning' | 'info';
-}
-export interface PerformanceCharacteristics {
-    readonly evaluationCount: number;
-    readonly totalTime: number;
-    readonly averageTime: number;
-    readonly successRate: number;
-    readonly lastEvaluationTime: number;
-}
-export interface ValidationResult<T = unknown> {
-    readonly isValid: boolean;
-    readonly errors: ValidationError[];
-    readonly suggestions: readonly string[] | string[];
-    readonly warnings?: ValidationError[];
-    readonly performance?: PerformanceCharacteristics;
-    readonly success?: boolean;
-    readonly data?: T;
-    readonly error?: ValidationError;
-}
-export interface EvaluationResult<T = unknown> {
-    readonly value?: T;
-    readonly type?: HyperScriptValueType;
-    readonly success: boolean;
-    readonly error?: ValidationError;
-    readonly performance?: PerformanceCharacteristics;
-}
-export type EvaluationType = 'String' | 'Number' | 'Boolean' | 'Element' | 'ElementList' | 'Array' | 'Object' | 'Promise' | 'Context' | 'Null' | 'Undefined' | 'Any';
-export type HyperScriptValueType = 'string' | 'number' | 'boolean' | 'element' | 'element-list' | 'array' | 'object' | 'promise' | 'fragment' | 'null' | 'undefined' | 'function' | 'event' | 'error' | 'unknown';
-export declare const evaluationToHyperScriptType: Record<EvaluationType, HyperScriptValueType>;
-export type ExpressionCategory = 'Reference' | 'Logical' | 'Conversion' | 'Positional' | 'Property' | 'Special' | 'Template' | 'Mathematical';
-export interface Scope extends CoreExecutionContext {
-    result: unknown;
-    registry?: ExpressionRegistry;
-    readonly variables?: Map<string, unknown>;
-    readonly parent?: ExecutionContext;
-    readonly registerCleanup?: (element: Element, cleanup: () => void, description?: string) => void;
-}
-export type ExecutionContext = Scope;
-export type TypedExecutionContext = ExecutionContext;
-export interface ParseError {
-    readonly name?: string;
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-    readonly position?: number;
-    readonly source?: string;
-}
-export type ParseDiagnosticSeverity = 'error' | 'warning' | 'info';
-export interface ParseDiagnostic {
-    readonly message: string;
-    readonly severity: ParseDiagnosticSeverity;
-    readonly code?: string;
-    readonly line?: number;
-    readonly column?: number;
-    readonly source?: string;
-    readonly suggestions?: readonly string[];
-}
-export interface ASTNode {
-    readonly type: string;
-    readonly line?: number;
-    readonly column?: number;
-    readonly start?: number;
-    readonly end?: number;
-    readonly raw?: string;
-    readonly diagnostics?: readonly ParseDiagnostic[];
-    [key: string]: unknown;
-}
-export interface EnhancedError {
-    readonly name: string;
-    readonly message: string;
-    readonly code: string;
-    readonly suggestions: string[];
-    readonly type?: string;
-}
-export type TypedResult<T = unknown> = {
-    readonly success: true;
-    readonly value: T;
-    readonly type: HyperScriptValueType;
-} | {
-    readonly success: false;
-    readonly error: EnhancedError;
-    readonly errors?: ValidationError[];
-    readonly suggestions?: string[];
-    readonly type?: string;
-};
-export interface ExpressionMetadata {
-    readonly category: string;
-    readonly complexity: 'simple' | 'medium' | 'complex';
-    readonly sideEffects?: string[];
-    readonly dependencies?: string[];
-    readonly returnTypes?: EvaluationType[];
-    readonly examples?: Array<{
-        input: string;
-        description: string;
-        expectedOutput: unknown;
-        context?: Record<string, unknown>;
-    }>;
-    readonly relatedExpressions?: string[];
-    readonly performance?: {
-        averageTime: number;
-        complexity: string;
-    };
-    readonly environmentRequirements?: {
-        browser?: boolean;
-        server?: boolean;
-        dom?: boolean;
-    };
-}
-export interface LLMDocumentation {
-    readonly summary: string;
-    readonly parameters: Array<{
-        name: string;
-        type: string;
-        description: string;
-        optional: boolean;
-        examples: string[];
-        defaultValue?: unknown;
-    }>;
-    readonly returns: {
-        type: string;
-        description: string;
-        examples: unknown[];
-    };
-    readonly examples: Array<{
-        title: string;
-        code: string;
-        explanation: string;
-        output: unknown;
-    }>;
-    readonly seeAlso: string[];
-    readonly tags: string[];
-    readonly returnValue?: unknown;
-}
-export interface BaseTypedExpression<T = unknown> {
-    readonly name: string;
-    readonly category: string;
-    readonly syntax: string;
-    readonly outputType: EvaluationType;
-    readonly inputSchema: RuntimeValidator;
-    readonly metadata: ExpressionMetadata;
-    readonly documentation?: LLMDocumentation;
-    readonly description?: string;
-    evaluate(context: TypedExecutionContext, input: unknown): Promise<EvaluationResult<T>>;
-    validate(input: unknown): ValidationResult;
-}
-export interface ExpressionEvaluationOptions {
-    readonly validationMode?: 'strict' | 'permissive';
-    readonly timeout?: number;
-    readonly trackPerformance?: boolean;
-}
-export type TypedExpressionContext = ExecutionContext;
-export type FeatureCategory = 'Frontend' | 'Backend' | 'Data' | 'Communication' | 'Advanced';
-export interface BaseTypedFeature<TInput = unknown, TOutput = unknown> {
-    readonly name: string;
-    readonly category: FeatureCategory;
-    readonly description: string;
-    readonly inputSchema: RuntimeValidator<TInput>;
-    readonly outputType: EvaluationType;
-    readonly metadata: FeatureMetadata;
-    readonly documentation?: LLMDocumentation;
-    initialize(context: TypedExecutionContext): Promise<TypedResult<void>>;
-    execute(context: TypedExecutionContext, input: TInput): Promise<TypedResult<TOutput>>;
-    validate(input: unknown): ValidationResult;
-    cleanup?(context: TypedExecutionContext): Promise<void>;
-}
-export interface FeatureMetadata {
-    readonly version: string;
-    readonly stability: 'stable' | 'experimental' | 'deprecated';
-    readonly performance: {
-        complexity: string;
-        memoryUsage: 'low' | 'medium' | 'high';
-        async: boolean;
-    };
-    readonly compatibility: {
-        browsers: string[];
-        nodeVersion?: string;
-    };
-    readonly examples: Array<{
-        title: string;
-        description: string;
-        code: string;
-        expectedOutput: unknown;
-    }>;
-    readonly relatedFeatures: string[];
-}
-export interface CommandResult {
-    readonly success: boolean;
-    readonly value?: unknown;
-    readonly error?: string;
-    readonly context?: ExecutionContext;
-}
-export interface BaseCommand {
-    readonly name: string;
-    readonly syntax: string;
-    readonly description?: string;
-    readonly metadata?: {
-        category?: string;
-        complexity?: 'simple' | 'medium' | 'complex';
-        sideEffects?: string[];
-        dependencies?: string[];
-        examples?: Array<{
-            code: string;
-            description: string;
-        }>;
-    };
-    execute(context: ExecutionContext, ...args: unknown[]): Promise<CommandResult>;
-    validate?(args: unknown[]): ValidationResult;
-}
-export interface ExpressionNode extends ASTNode {
-    readonly type: 'expression';
-    readonly value?: unknown;
-    readonly operator?: string;
-    readonly operands?: ExpressionNode[];
-}
-export declare function createExecutionContext(me?: Element | null, overrides?: Partial<ExecutionContext>): ExecutionContext;
-export declare function createSuccessValidation(): ValidationResult;
-export declare function createFailureValidation(errors: ValidationError[], suggestions?: string[]): ValidationResult;
-export declare function createValidationError(type: ValidationError['type'], message: string, suggestions?: string[]): ValidationError;
-//# sourceMappingURL=base-types.d.ts.map

package/dist/types/code-fix.d.ts

@@ -1,39 +0,0 @@
-export type CodeActionKind = 'quickfix' | 'refactor' | 'source';
-export interface TextRange {
-    readonly start: number;
-    readonly end: number;
-}
-export interface TextEdit {
-    readonly type: 'insert' | 'replace' | 'delete';
-    readonly range?: TextRange;
-    readonly text?: string;
-}
-export interface FixCommand {
-    readonly name: string;
-    readonly arguments: readonly unknown[];
-}
-export interface CodeFix {
-    readonly code: string;
-    readonly title: string;
-    readonly kind: CodeActionKind;
-    readonly description?: string;
-    readonly edit?: TextEdit;
-    readonly command?: FixCommand;
-    readonly priority?: number;
-    readonly isPreferred?: boolean;
-}
-export interface FixableError {
-    readonly code: string;
-    readonly message: string;
-    readonly severity: 'error' | 'warning' | 'info';
-    readonly fixes?: readonly CodeFix[];
-}
-export interface DiagnosticWithFixes {
-    readonly diagnosticIndex: number;
-    readonly fixes: readonly CodeFix[];
-}
-export interface DiagnosticResponseWithFixes {
-    readonly diagnostics: readonly unknown[];
-    readonly codeActions?: readonly DiagnosticWithFixes[];
-}
-//# sourceMappingURL=code-fix.d.ts.map

package/dist/types/command-metadata.d.ts

@@ -1,57 +0,0 @@
-export type CommandCategory = 'animation' | 'async' | 'control-flow' | 'data' | 'dom' | 'content' | 'navigation' | 'utility' | 'advanced' | 'event' | 'storage' | 'execution' | 'templates' | 'behaviors';
-export declare const COMMAND_CATEGORIES: CommandCategory[];
-export type CommandSideEffect = 'dom-mutation' | 'dom-query' | 'dom-creation' | 'dom-observation' | 'element-modification' | 'context-modification' | 'context-switching' | 'context-mutation' | 'state-mutation' | 'conditional-execution' | 'iteration' | 'control-flow' | 'execution-termination' | 'time' | 'timing' | 'style-change' | 'event-listening' | 'event-dispatch' | 'event-dispatching' | 'event-prevention' | 'event-listeners' | 'custom-events' | 'command-execution' | 'code-execution' | 'function-execution' | 'method-execution' | 'async-execution' | 'data-mutation' | 'data-binding' | 'property-transfer' | 'network' | 'storage' | 'navigation' | 'clipboard' | 'clipboard-write' | 'console' | 'console-output' | 'animation' | 'focus' | 'scroll' | 'scrolling' | 'template-execution' | 'behavior-installation' | 'random-selection' | 'debugging' | 'error-throwing';
-export declare const COMMAND_SIDE_EFFECTS: CommandSideEffect[];
-export interface CommandMetadata {
-    readonly description: string;
-    readonly syntax: string | readonly string[];
-    readonly examples: readonly string[];
-    readonly category: CommandCategory;
-    readonly sideEffects?: readonly CommandSideEffect[];
-    readonly deprecated?: boolean;
-    readonly deprecationMessage?: string;
-    readonly aliases?: readonly string[];
-    readonly relatedCommands?: readonly string[];
-    readonly version?: string;
-    readonly isBlocking?: boolean;
-    readonly hasBody?: boolean;
-    readonly performance?: {
-        readonly complexity?: 'O(1)' | 'O(n)' | 'O(n log n)' | 'O(n²)';
-        readonly isAsync?: boolean;
-        readonly mayBlock?: boolean;
-    };
-    readonly compatibility?: 'standard' | 'lokascript-extension' | 'experimental';
-}
-export interface MetadataValidationResult {
-    readonly isValid: boolean;
-    readonly errors: string[];
-    readonly warnings: string[];
-}
-export declare function validateCommandMetadata(metadata: unknown, commandName: string): MetadataValidationResult;
-export declare function normalizeCategory(category: string): CommandCategory;
-export declare function createCommandMetadata(partial: Partial<CommandMetadata> & {
-    description: string;
-    syntax: string | readonly string[];
-    examples: readonly string[];
-    category: CommandCategory;
-}): CommandMetadata;
-export declare function mergeCommandMetadata(base: CommandMetadata, overrides: Partial<CommandMetadata>): CommandMetadata;
-export declare function getSyntaxArray(metadata: CommandMetadata): readonly string[];
-export declare function formatMetadataForDocs(commandName: string, metadata: CommandMetadata): string;
-export interface CommandRegistryEntry {
-    readonly name: string;
-    readonly metadata: CommandMetadata;
-    readonly implementation: unknown;
-}
-export declare class CommandMetadataRegistry {
-    private commands;
-    register(name: string, metadata: CommandMetadata, implementation: unknown): void;
-    get(name: string): CommandRegistryEntry | undefined;
-    getCommandNames(): string[];
-    getByCategory(category: CommandCategory): CommandRegistryEntry[];
-    getDeprecated(): CommandRegistryEntry[];
-    validateAll(): Map<string, MetadataValidationResult>;
-    generateDocs(): string;
-}
-export declare const commandMetadataRegistry: CommandMetadataRegistry;
-//# sourceMappingURL=command-metadata.d.ts.map

package/dist/types/command-types.d.ts

@@ -1,262 +0,0 @@
-import type { RuntimeValidator } from '../validation/lightweight-validators';
-import type { ValidationResult, ValidationError, EvaluationResult, TypedExecutionContext } from './base-types';
-export type { ExecutionContext, TypedExecutionContext, TypedExecutionContext as TypedExpressionContext, ValidationResult, TypedResult, LLMDocumentation, } from './base-types';
-export type HyperScriptValue = unknown;
-export type { EvaluationResult, EvaluationType, HyperScriptValueType } from './base-types';
-export declare const HyperScriptValueSchema: RuntimeValidator<unknown>;
-export interface ExecutionMeta {
-    readonly startTime: number;
-    readonly commandStack: string[];
-    readonly sourceLocation?: SourceLocation;
-    readonly debugMode: boolean;
-}
-export interface SourceLocation {
-    readonly line: number;
-    readonly column: number;
-    readonly source: string;
-}
-export interface CommandMetadata {
-    readonly category: CommandCategory;
-    readonly complexity: 'simple' | 'medium' | 'complex';
-    readonly sideEffects: SideEffect[];
-    readonly examples: CommandExample[];
-    readonly relatedCommands: string[];
-}
-export type CommandCategory = 'DOM' | 'Event' | 'Control' | 'Data' | 'Communication' | 'Style';
-export type SideEffect = string;
-export interface CommandExample {
-    readonly code: string;
-    readonly description: string;
-    readonly expectedOutput: HyperScriptValue;
-}
-export interface TypedExpressionImplementation<TOutput extends HyperScriptValue = HyperScriptValue, TContext extends TypedExecutionContext = TypedExecutionContext> {
-    readonly name: string;
-    readonly category: ExpressionCategory;
-    readonly precedence: number;
-    readonly associativity: 'left' | 'right' | 'none';
-    readonly outputType: string;
-    evaluate(context: TContext, ...args: HyperScriptValue[]): Promise<EvaluationResult<TOutput>>;
-    readonly analysisInfo: ExpressionAnalysisInfo;
-}
-export interface ExpressionAnalysisInfo {
-    readonly isPure: boolean;
-    readonly canThrow: boolean;
-    readonly complexity: 'O(1)' | 'O(n)' | 'O(n²)' | 'O(log n)';
-    readonly dependencies: string[];
-}
-export type ExpressionCategory = 'reference' | 'logical' | 'comparison' | 'arithmetic' | 'string' | 'array' | 'object' | 'conversion' | 'special';
-export interface EnhancedValidationError extends ValidationError {
-    readonly position?: SourceLocation;
-    readonly suggestion?: string;
-}
-export interface HyperScriptError {
-    readonly name: string;
-    readonly message: string;
-    readonly code: string;
-    readonly source?: SourceLocation;
-    readonly cause?: Error;
-    readonly suggestions: string[];
-}
-export declare class TypeChecker {
-    static getType(value: unknown): string;
-    static validateType(value: unknown, expectedType: string): ValidationResult;
-    private static getTypeSuggestion;
-}
-export interface ParameterDoc {
-    readonly name: string;
-    readonly type: string;
-    readonly description: string;
-    readonly optional: boolean;
-    readonly defaultValue?: HyperScriptValue;
-    readonly examples: string[];
-}
-export interface ReturnDoc {
-    readonly type: string;
-    readonly description: string;
-    readonly examples: HyperScriptValue[];
-}
-export interface DocumentationExample {
-    readonly title: string;
-    readonly code: string;
-    readonly explanation: string;
-    readonly output: HyperScriptValue;
-}
-export interface HyperScriptProgram {
-    readonly source: string;
-    readonly features: HyperScriptFeature[];
-    readonly metadata: ProgramMetadata;
-    readonly sourceInfo?: ProgramSourceInfo;
-    readonly state: ProgramState;
-}
-export interface HyperScriptFeature {
-    readonly type: HyperScriptFeatureType;
-    readonly id: string;
-    readonly trigger?: EventTrigger;
-    readonly commands: ParsedCommand[];
-    readonly config: FeatureConfig;
-    readonly sourceRange: SourceRange;
-    readonly metadata: FeatureMetadata;
-}
-export interface ParsedCommand {
-    readonly type: ParsedCommandType;
-    readonly name: string;
-    readonly implementation?: unknown | TypedExpressionImplementation<unknown, TypedExecutionContext>;
-    readonly args: ParsedArgument[];
-    readonly options: CommandOptions;
-    readonly sourceRange: SourceRange;
-    readonly analysis?: CommandAnalysis;
-}
-export interface ParsedArgument {
-    readonly value: HyperScriptValue;
-    readonly type: string;
-    readonly kind: 'literal' | 'expression' | 'reference';
-    readonly sourceRange?: SourceRange;
-    readonly analysis?: ArgumentAnalysis;
-}
-export type HyperScriptFeatureType = 'event' | 'behavior' | 'definition' | 'init' | 'worker' | 'socket' | 'eventsource' | 'set' | 'js' | 'custom';
-export type ParsedCommandType = 'dom-manipulation' | 'content' | 'navigation' | 'event' | 'async' | 'control-flow' | 'data' | 'expression' | 'custom';
-export interface EventTrigger {
-    readonly event: string;
-    readonly target?: string | HTMLElement;
-    readonly options: EventListenerOptions & {
-        readonly once?: boolean;
-        readonly debounce?: number;
-        readonly throttle?: number;
-    };
-    readonly filter?: EventFilter;
-}
-export interface EventFilter {
-    readonly selector?: string;
-    readonly keys?: string[];
-    readonly condition?: string;
-}
-export interface FeatureConfig {
-    readonly enabled: boolean;
-    readonly priority: number;
-    readonly options: Record<string, HyperScriptValue>;
-    readonly dependencies: string[];
-    readonly capabilities: FeatureCapabilities;
-}
-export interface FeatureCapabilities {
-    readonly requiresDOM: boolean;
-    readonly isAsync: boolean;
-    readonly modifiesGlobalState: boolean;
-    readonly requiredAPIs: string[];
-    readonly performance: PerformanceCharacteristics;
-}
-export interface PerformanceCharacteristics {
-    readonly complexity: 'low' | 'medium' | 'high';
-    readonly memoryUsage: 'minimal' | 'moderate' | 'heavy';
-    readonly cpuIntensive: boolean;
-    readonly executionTime: {
-        readonly min: number;
-        readonly max: number;
-        readonly typical: number;
-    };
-}
-export interface ProgramMetadata {
-    readonly compilation: {
-        readonly compiled: boolean;
-        readonly compiledAt?: Date;
-        readonly compiler: string;
-        readonly version: string;
-    };
-    readonly analysis: {
-        readonly complexity: number;
-        readonly estimatedExecutionTime: number;
-        readonly memoryRequirements: number;
-        readonly warnings: AnalysisWarning[];
-        readonly optimizations: string[];
-    };
-    readonly performance?: {
-        readonly lastExecutionTime: number;
-        readonly averageExecutionTime: number;
-        readonly executionCount: number;
-        readonly errorCount: number;
-    };
-}
-export interface FeatureMetadata {
-    readonly compiledAt: Date;
-    readonly stats: {
-        readonly executionCount: number;
-        readonly totalExecutionTime: number;
-        readonly averageExecutionTime: number;
-        readonly errorCount: number;
-        readonly lastExecuted?: Date;
-    };
-    readonly resolvedDependencies: string[];
-    readonly warnings: AnalysisWarning[];
-}
-export interface CommandOptions {
-    readonly validateInputs: boolean;
-    readonly trackPerformance: boolean;
-    readonly errorHandling: 'throw' | 'return' | 'ignore';
-    readonly timeout?: number;
-    readonly retry?: {
-        readonly attempts: number;
-        readonly delay: number;
-        readonly backoff: 'linear' | 'exponential';
-    };
-}
-export interface CommandAnalysis {
-    readonly complexity: number;
-    readonly requirements: string[];
-    readonly sideEffects: string[];
-    readonly typeInference: {
-        readonly inputTypes: string[];
-        readonly outputType: string;
-        readonly confidence: number;
-    };
-    readonly optimizations: string[];
-}
-export interface ArgumentAnalysis {
-    readonly isUsed: boolean;
-    readonly typeCompatibility: number;
-    readonly suggestions: string[];
-}
-export interface ProgramSourceInfo {
-    readonly element?: HTMLElement;
-    readonly attribute?: string;
-    readonly file?: string;
-    readonly position?: {
-        readonly line: number;
-        readonly column: number;
-    };
-}
-export interface SourceRange {
-    readonly start: number;
-    readonly end: number;
-    readonly lines?: {
-        readonly start: {
-            line: number;
-            column: number;
-        };
-        readonly end: {
-            line: number;
-            column: number;
-        };
-    };
-}
-export interface ProgramState {
-    readonly status: 'ready' | 'running' | 'completed' | 'error' | 'suspended';
-    readonly currentFeature?: string;
-    readonly context: {
-        readonly element: HTMLElement | null;
-        readonly variables: Map<string, HyperScriptValue>;
-        readonly callStack: string[];
-    };
-    readonly error?: HyperScriptError;
-    readonly startedAt?: Date;
-    readonly completedAt?: Date;
-}
-export interface AnalysisWarning {
-    readonly level: 'info' | 'warning' | 'error';
-    readonly message: string;
-    readonly location: SourceRange;
-    readonly suggestion?: string;
-    readonly category: 'performance' | 'compatibility' | 'security' | 'style' | 'type-safety';
-}
-export declare const HyperScriptProgramSchema: RuntimeValidator<{
-    [x: string]: unknown;
-}>;
-//# sourceMappingURL=command-types.d.ts.map