@hyperfixi/core 3.3.0 → 4.0.1

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

@@ -1,106 +0,0 @@
-import type { RuntimeValidator } from '../validation/lightweight-validators';
-import type { TypedExpressionContext, EvaluationType, ExpressionMetadata, ValidationResult } from './expression-types';
-import type { LLMDocumentation } from './command-types';
-import type { EvaluationResult } from './base-types';
-export type { EvaluationResult } from './base-types';
-export type ContextCategory = 'Frontend' | 'Backend' | 'Universal' | 'SSR' | 'Testing';
-export interface ContextMetadata extends Omit<ExpressionMetadata, 'category'> {
-    category: ContextCategory;
-    relatedContexts?: string[];
-    frameworkDependencies?: string[];
-    environmentRequirements?: {
-        browser?: boolean;
-        server?: boolean;
-        nodejs?: boolean;
-        python?: boolean;
-    };
-}
-export interface TypedContextImplementation<TInput, TOutput> {
-    readonly name: string;
-    readonly category: ContextCategory;
-    readonly description: string;
-    readonly inputSchema: RuntimeValidator<TInput>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ContextMetadata;
-    readonly documentation?: LLMDocumentation;
-    initialize(input: TInput): Promise<EvaluationResult<TOutput>>;
-    validate(input: unknown): ValidationResult;
-    trackPerformance?(startTime: number, success: boolean, output?: any): void;
-}
-export declare abstract class ContextBase<TInput, TOutput> implements TypedContextImplementation<TInput, TOutput> {
-    abstract readonly name: string;
-    abstract readonly category: ContextCategory;
-    abstract readonly description: string;
-    abstract readonly inputSchema: RuntimeValidator<TInput>;
-    abstract readonly outputType: EvaluationType;
-    abstract readonly metadata: ContextMetadata;
-    abstract readonly documentation?: LLMDocumentation;
-    protected evaluationHistory: Array<{
-        contextName: string;
-        category: ContextCategory;
-        input: string;
-        output: any;
-        timestamp: number;
-        duration: number;
-        success: boolean;
-    }>;
-    abstract initialize(input: TInput): Promise<EvaluationResult<TOutput>>;
-    validate(input: unknown): ValidationResult;
-    protected validateContextSpecific(_data: TInput): ValidationResult;
-    protected generateValidationSuggestions(error: any): string[];
-    trackPerformance(startTime: number, success: boolean, output?: any): void;
-    getPerformanceMetrics(): {
-        totalInitializations: number;
-        successRate: number;
-        averageDuration: number;
-        recentPerformance: {
-            contextName: string;
-            category: ContextCategory;
-            input: string;
-            output: any;
-            timestamp: number;
-            duration: number;
-            success: boolean;
-        }[];
-    };
-}
-export declare const BaseContextInputSchema: RuntimeValidator<{
-    [x: string]: unknown;
-}>;
-export declare const BaseContextOutputSchema: RuntimeValidator<{
-    [x: string]: unknown;
-}>;
-export type BaseContextInput = any;
-export type BaseContextOutput = any;
-export interface ExtendedTypedExpressionContext extends TypedExpressionContext {
-    contextCategory?: ContextCategory;
-    framework?: {
-        name: 'django' | 'flask' | 'express' | 'fastapi' | 'vanilla';
-        version?: string;
-        capabilities?: string[];
-    };
-    performanceTracking?: {
-        enabled: boolean;
-        includeMemoryUsage: boolean;
-        includeNetworkMetrics: boolean;
-    };
-    services?: {
-        logger?: any;
-        cache?: any;
-        database?: any;
-        queue?: any;
-    };
-}
-export interface ContextRegistry {
-    register<T extends TypedContextImplementation<any, any>>(context: T): void;
-    get<_T>(name: string): TypedContextImplementation<any, any> | null;
-    listByCategory(category: ContextCategory): TypedContextImplementation<any, any>[];
-    validate<T extends TypedContextImplementation<any, any>>(context: T): ValidationResult;
-}
-export interface ContextFilter {
-    category?: ContextCategory;
-    environment?: 'frontend' | 'backend' | 'universal';
-    framework?: string;
-    capabilities?: string[];
-}
-//# sourceMappingURL=context-types.d.ts.map

package/dist/types/core-context.d.ts

@@ -1,22 +0,0 @@
-export interface CoreExecutionContext {
-    me: Element | null;
-    owner?: Element | null;
-    you: Element | null;
-    it: unknown;
-    readonly event?: Event | null;
-    readonly locals: Map<string, unknown>;
-    readonly globals: Map<string, unknown>;
-}
-export interface CoreContextOptions {
-    me?: Element | null;
-    you?: Element | null;
-    it?: unknown;
-    event?: Event | null;
-    locals?: Map<string, unknown>;
-    globals?: Map<string, unknown>;
-}
-export declare function createCoreContext(options?: CoreContextOptions): CoreExecutionContext;
-export declare function isCoreExecutionContext(value: unknown): value is CoreExecutionContext;
-export declare function assertHTMLElement(element: Element | null, name?: string): HTMLElement;
-export declare function asHTMLElement(element: Element | null): HTMLElement | null;
-//# sourceMappingURL=core-context.d.ts.map

package/dist/types/core.d.ts

@@ -1,143 +0,0 @@
-export type { ExecutionContext, Scope, TypedExecutionContext, EvaluationType, HyperScriptValueType, ValidationResult, ValidationError, TypedResult, EnhancedError, PerformanceCharacteristics, ASTNode, ParseError, ExpressionNode, } from './base-types';
-import type { ExecutionContext, ASTNode, ExpressionNode, EvaluationType, ParseError } from './base-types';
-export type ElementType = 'command' | 'expression' | 'feature' | 'keyword' | 'special_symbol';
-export type ElementStatus = 'Draft' | 'Review' | 'Approved' | 'Deprecated';
-export type ExpressionCategory = 'Arithmetic' | 'Logical' | 'Comparison' | 'Reference' | 'Conversion' | 'Special';
-export type Associativity = 'Left' | 'Right' | 'None';
-export interface ExtendedExecutionContext extends ExecutionContext {
-    variables?: Map<string, unknown>;
-    events?: Map<string, {
-        target: HTMLElement;
-        event: string;
-        handler: Function;
-    }>;
-    parent?: ExtendedExecutionContext;
-    meta?: Record<string, unknown>;
-    flags?: {
-        halted: boolean;
-        breaking: boolean;
-        continuing: boolean;
-        returning: boolean;
-        async: boolean;
-    };
-}
-export interface CommandNode extends ASTNode {
-    type: 'command';
-    name: string;
-    args: ExpressionNode[];
-    body?: StatementNode[];
-    implicitTarget?: ExpressionNode;
-    isBlocking: boolean;
-    modifiers?: Record<string, ExpressionNode>;
-    originalCommand?: string;
-}
-export interface FeatureNode extends ASTNode {
-    type: 'feature';
-    name: string;
-    trigger?: string;
-    body: StatementNode[];
-    scope: 'global' | 'local' | 'behavior';
-}
-export interface StatementNode extends ASTNode {
-    type: 'statement';
-    command: CommandNode;
-    conditions?: ExpressionNode[];
-}
-export interface ExpressionImplementation {
-    name: string;
-    category: ExpressionCategory;
-    evaluatesTo: EvaluationType;
-    evaluate: (context: ExecutionContext, ...args: unknown[]) => Promise<unknown>;
-    precedence?: number;
-    associativity?: Associativity;
-    operators?: string[];
-    validate?: (args: unknown[]) => string | null;
-}
-export interface Token {
-    kind: string;
-    value: string;
-    start: number;
-    end: number;
-    line: number;
-    column: number;
-}
-export interface ParseWarning {
-    type: string;
-    message: string;
-    suggestions: string[];
-    severity: 'info' | 'warning' | 'error';
-    code?: string;
-    line?: number;
-    column?: number;
-}
-export interface ParseResult<T = ASTNode> {
-    success: boolean;
-    node?: T;
-    ast?: T;
-    error?: ParseError;
-    errors?: ParseError[];
-    recovered?: boolean;
-    warnings?: ParseWarning[];
-    tokens: Token[];
-}
-export interface Parser {
-    parse(input: string): ParseResult<FeatureNode[]>;
-    parseExpression(input: string): ParseResult<ExpressionNode>;
-    parseCommand(input: string): ParseResult<CommandNode>;
-    tokenize(input: string): Token[];
-}
-export interface LSPElement {
-    id: number;
-    name: string;
-    description: string;
-    syntax_canonical: string;
-    status: ElementStatus;
-    tags: string[];
-    examples: LSPExample[];
-}
-export interface LSPCommand extends LSPElement {
-    purpose: string;
-    has_body: boolean;
-    is_blocking: boolean;
-    implicit_target?: string;
-    implicit_result_target?: string;
-    arguments?: LSPArgument[];
-}
-export interface LSPExpression extends LSPElement {
-    category: ExpressionCategory;
-    evaluates_to_type: EvaluationType;
-    precedence?: number;
-    associativity?: Associativity;
-    operators?: string[];
-}
-export interface LSPFeature extends LSPElement {
-    trigger?: string;
-    structure_description?: string;
-    scope_impact?: string;
-}
-export interface LSPExample {
-    id: number;
-    element_id: number;
-    element_type: ElementType;
-    example: string;
-    description?: string;
-    difficulty?: 'Beginner' | 'Intermediate' | 'Advanced';
-    html_context?: string;
-}
-export interface LSPArgument {
-    name: string;
-    type: string;
-    description: string;
-    optional: boolean;
-    default_value?: unknown;
-}
-export interface HyperscriptEvent extends CustomEvent {
-    detail: {
-        element: HTMLElement;
-        context: ExecutionContext;
-        command?: string;
-        result?: unknown;
-        error?: Error;
-    };
-}
-//# sourceMappingURL=core.d.ts.map

package/dist/types/error-codes.d.ts

@@ -1,207 +0,0 @@
-import type { ValidationError } from './unified-types';
-import type { ExecutionError, ExecutionErrorContext } from './result';
-export declare const ErrorCodes: {
-    readonly EXECUTION: {
-        readonly ADD_FAILED: "ADD_EXECUTION_FAILED";
-        readonly GO_FAILED: "GO_EXECUTION_FAILED";
-        readonly HIDE_FAILED: "HIDE_EXECUTION_FAILED";
-        readonly PUT_FAILED: "PUT_EXECUTION_FAILED";
-        readonly REMOVE_FAILED: "REMOVE_EXECUTION_FAILED";
-        readonly SEND_FAILED: "SEND_EXECUTION_FAILED";
-        readonly SHOW_FAILED: "SHOW_EXECUTION_FAILED";
-        readonly TAKE_FAILED: "TAKE_EXECUTION_FAILED";
-        readonly TOGGLE_FAILED: "TOGGLE_EXECUTION_FAILED";
-        readonly TRIGGER_FAILED: "TRIGGER_EXECUTION_FAILED";
-        readonly WAIT_FAILED: "WAIT_FAILED";
-        readonly FETCH_FAILED: "FETCH_FAILED";
-        readonly IF_FAILED: "IF_EXECUTION_FAILED";
-        readonly ELSE_FAILED: "ELSE_EXECUTION_FAILED";
-        readonly REPEAT_FAILED: "REPEAT_EXECUTION_FAILED";
-        readonly SCROLL_FAILED: "SCROLL_EXECUTION_FAILED";
-    };
-    readonly VALIDATION: {
-        readonly ADD_FAILED: "ADD_VALIDATION_FAILED";
-        readonly GO_FAILED: "GO_VALIDATION_FAILED";
-        readonly PUT_FAILED: "PUT_VALIDATION_FAILED";
-        readonly REMOVE_FAILED: "REMOVE_VALIDATION_FAILED";
-        readonly SEND_FAILED: "SEND_VALIDATION_FAILED";
-        readonly TAKE_FAILED: "TAKE_VALIDATION_FAILED";
-        readonly TOGGLE_FAILED: "TOGGLE_VALIDATION_FAILED";
-        readonly TRIGGER_FAILED: "TRIGGER_VALIDATION_FAILED";
-        readonly IF_FAILED: "IF_VALIDATION_FAILED";
-        readonly ELSE_FAILED: "ELSE_VALIDATION_FAILED";
-        readonly REPEAT_FAILED: "REPEAT_VALIDATION_FAILED";
-        readonly GENERIC: "VALIDATION_ERROR";
-        readonly PARTIAL_LAYOUT_ELEMENT: "PARTIAL_LAYOUT_ELEMENT";
-        readonly PARTIAL_DUPLICATE_SEMANTIC: "PARTIAL_DUPLICATE_SEMANTIC";
-        readonly PARTIAL_METADATA_ELEMENT: "PARTIAL_METADATA_ELEMENT";
-    };
-    readonly OPERATION: {
-        readonly CLASS_ADD_FAILED: "CLASS_ADD_FAILED";
-        readonly CLASS_REMOVE_FAILED: "CLASS_REMOVE_FAILED";
-        readonly CLASS_TOGGLE_FAILED: "CLASS_TOGGLE_FAILED";
-        readonly ATTRIBUTE_ADD_FAILED: "ATTRIBUTE_ADD_FAILED";
-        readonly ATTRIBUTE_TOGGLE_FAILED: "ATTRIBUTE_TOGGLE_FAILED";
-        readonly CSS_PROPERTY_TOGGLE_FAILED: "CSS_PROPERTY_TOGGLE_FAILED";
-        readonly ELEMENT_HIDE_FAILED: "ELEMENT_HIDE_FAILED";
-        readonly ELEMENT_SHOW_FAILED: "ELEMENT_SHOW_FAILED";
-        readonly EVENT_DISPATCH_FAILED: "EVENT_DISPATCH_FAILED";
-        readonly EVENT_TRIGGER_FAILED: "EVENT_TRIGGER_FAILED";
-        readonly NAVIGATION_FAILED: "NAVIGATION_FAILED";
-        readonly HISTORY_NAVIGATION_FAILED: "HISTORY_NAVIGATION_FAILED";
-        readonly URL_NAVIGATION_FAILED: "URL_NAVIGATION_FAILED";
-        readonly SCROLL_FAILED: "SCROLL_FAILED";
-        readonly SCROLL_OFFSET_FAILED: "SCROLL_OFFSET_FAILED";
-        readonly PROPERTY_TAKE_FAILED: "PROPERTY_TAKE_FAILED";
-        readonly PROPERTY_PUT_FAILED: "PROPERTY_PUT_FAILED";
-        readonly STYLE_ADD_FAILED: "STYLE_ADD_FAILED";
-        readonly OPERATION_FAILED: "OPERATION_FAILED";
-        readonly PARSE_FAILED: "PARSE_FAILED";
-        readonly ARGUMENT_PARSE_FAILED: "ARGUMENT_PARSE_FAILED";
-    };
-    readonly RESOLUTION: {
-        readonly TARGET_RESOLUTION_FAILED: "TARGET_RESOLUTION_FAILED";
-        readonly SOURCE_RESOLUTION_FAILED: "SOURCE_RESOLUTION_FAILED";
-        readonly RESOLUTION_FAILED: "RESOLUTION_FAILED";
-    };
-    readonly INVALID: {
-        readonly CONTEXT_ELEMENT: "INVALID_CONTEXT_ELEMENT";
-        readonly CLASS_NAME: "INVALID_CLASS_NAME";
-        readonly ATTRIBUTE_NAME: "INVALID_ATTRIBUTE_NAME";
-        readonly ELEMENT_REFERENCE: "INVALID_ELEMENT_REFERENCE";
-        readonly POSITION: "INVALID_POSITION";
-        readonly PROPERTY: "INVALID_PROPERTY";
-        readonly PROPERTY_POSITION: "INVALID_PROPERTY_POSITION";
-        readonly SELECTOR: "INVALID_SELECTOR";
-        readonly TARGET_TYPE: "INVALID_TARGET_TYPE";
-        readonly URL: "INVALID_URL";
-    };
-    readonly MISSING: {
-        readonly URL: "MISSING_URL";
-        readonly ARGUMENTS: "NO_ARGUMENTS";
-    };
-    readonly NOT_FOUND: {
-        readonly ELEMENT: "ELEMENT_NOT_FOUND";
-        readonly TARGET_ELEMENT: "NO_TARGET_ELEMENT";
-        readonly TARGET_ELEMENTS: "NO_TARGET_ELEMENTS";
-        readonly TARGET: "TARGET_NOT_FOUND";
-    };
-    readonly NO_VALID: {
-        readonly ATTRIBUTES: "NO_VALID_ATTRIBUTES";
-        readonly CLASSES: "NO_VALID_CLASSES";
-        readonly CSS_PROPERTY: "NO_VALID_CSS_PROPERTY";
-    };
-    readonly CONTEXT: {
-        readonly IF_INVALID: "IF_CONTEXT_INVALID";
-        readonly ELSE_INVALID: "ELSE_CONTEXT_INVALID";
-        readonly REPEAT_INVALID: "REPEAT_CONTEXT_INVALID";
-        readonly REPEAT_COLLECTION_INVALID: "REPEAT_COLLECTION_INVALID";
-    };
-    readonly UNSUPPORTED: {
-        readonly CSS_PROPERTY: "UNSUPPORTED_CSS_PROPERTY";
-        readonly HISTORY_API: "HISTORY_API_UNAVAILABLE";
-    };
-};
-export declare const ErrorMessages: {
-    readonly ADD_EXECUTION_FAILED: "Failed to execute add command";
-    readonly GO_EXECUTION_FAILED: "Failed to execute go command";
-    readonly HIDE_EXECUTION_FAILED: "Failed to execute hide command";
-    readonly PUT_EXECUTION_FAILED: "Failed to execute put command";
-    readonly REMOVE_EXECUTION_FAILED: "Failed to execute remove command";
-    readonly SEND_EXECUTION_FAILED: "Failed to execute send command";
-    readonly SHOW_EXECUTION_FAILED: "Failed to execute show command";
-    readonly TAKE_EXECUTION_FAILED: "Failed to execute take command";
-    readonly TOGGLE_EXECUTION_FAILED: "Failed to execute toggle command";
-    readonly TRIGGER_EXECUTION_FAILED: "Failed to execute trigger command";
-    readonly WAIT_FAILED: "Wait command failed";
-    readonly FETCH_FAILED: "Fetch command failed";
-    readonly IF_EXECUTION_FAILED: "Failed to execute if directive";
-    readonly ELSE_EXECUTION_FAILED: "Failed to execute else directive";
-    readonly REPEAT_EXECUTION_FAILED: "Failed to execute repeat directive";
-    readonly SCROLL_EXECUTION_FAILED: "Failed to execute scroll operation";
-    readonly ADD_VALIDATION_FAILED: "Add command validation failed";
-    readonly GO_VALIDATION_FAILED: "Go command validation failed";
-    readonly PUT_VALIDATION_FAILED: "Put command validation failed";
-    readonly REMOVE_VALIDATION_FAILED: "Remove command validation failed";
-    readonly SEND_VALIDATION_FAILED: "Send command validation failed";
-    readonly TAKE_VALIDATION_FAILED: "Take command validation failed";
-    readonly TOGGLE_VALIDATION_FAILED: "Toggle command validation failed";
-    readonly TRIGGER_VALIDATION_FAILED: "Trigger command validation failed";
-    readonly IF_VALIDATION_FAILED: "If directive validation failed";
-    readonly ELSE_VALIDATION_FAILED: "Else directive validation failed";
-    readonly REPEAT_VALIDATION_FAILED: "Repeat directive validation failed";
-    readonly VALIDATION_ERROR: "Validation error";
-    readonly PARTIAL_LAYOUT_ELEMENT: "Partial contains layout element: {0}";
-    readonly PARTIAL_DUPLICATE_SEMANTIC: "Partial may create duplicate semantic landmark: {0}";
-    readonly PARTIAL_METADATA_ELEMENT: "Partial contains metadata element: {0}";
-    readonly CLASS_ADD_FAILED: "Failed to add class to element";
-    readonly CLASS_REMOVE_FAILED: "Failed to remove class from element";
-    readonly CLASS_TOGGLE_FAILED: "Failed to toggle class on element";
-    readonly ATTRIBUTE_ADD_FAILED: "Failed to add attribute to element";
-    readonly ATTRIBUTE_TOGGLE_FAILED: "Failed to toggle attribute on element";
-    readonly CSS_PROPERTY_TOGGLE_FAILED: "Failed to toggle CSS property";
-    readonly ELEMENT_HIDE_FAILED: "Failed to hide element";
-    readonly ELEMENT_SHOW_FAILED: "Failed to show element";
-    readonly EVENT_DISPATCH_FAILED: "Failed to dispatch event";
-    readonly EVENT_TRIGGER_FAILED: "Failed to trigger event on element";
-    readonly NAVIGATION_FAILED: "Navigation failed";
-    readonly HISTORY_NAVIGATION_FAILED: "History navigation failed";
-    readonly URL_NAVIGATION_FAILED: "URL navigation failed";
-    readonly SCROLL_FAILED: "Scroll operation failed";
-    readonly SCROLL_OFFSET_FAILED: "Failed to scroll with offset";
-    readonly PROPERTY_TAKE_FAILED: "Failed to take property from element";
-    readonly PROPERTY_PUT_FAILED: "Failed to put property on element";
-    readonly STYLE_ADD_FAILED: "Failed to add style to element";
-    readonly OPERATION_FAILED: "Operation failed";
-    readonly PARSE_FAILED: "Failed to parse input";
-    readonly ARGUMENT_PARSE_FAILED: "Failed to parse arguments";
-    readonly TARGET_RESOLUTION_FAILED: "Failed to resolve target element";
-    readonly SOURCE_RESOLUTION_FAILED: "Failed to resolve source element";
-    readonly RESOLUTION_FAILED: "Element resolution failed";
-    readonly INVALID_CONTEXT_ELEMENT: "Invalid context element";
-    readonly INVALID_CLASS_NAME: "Invalid class name: \"{0}\"";
-    readonly INVALID_ATTRIBUTE_NAME: "Invalid attribute name: \"{0}\"";
-    readonly INVALID_ELEMENT_REFERENCE: "Invalid element reference";
-    readonly INVALID_POSITION: "Invalid position: \"{0}\"";
-    readonly INVALID_PROPERTY: "Invalid property: \"{0}\"";
-    readonly INVALID_PROPERTY_POSITION: "Invalid property position";
-    readonly INVALID_SELECTOR: "Invalid selector: \"{0}\"";
-    readonly INVALID_TARGET_TYPE: "Invalid target type";
-    readonly INVALID_URL: "Invalid URL: \"{0}\"";
-    readonly MISSING_URL: "Missing URL";
-    readonly NO_ARGUMENTS: "No arguments provided";
-    readonly ELEMENT_NOT_FOUND: "Element not found";
-    readonly NO_TARGET_ELEMENT: "No target element found";
-    readonly NO_TARGET_ELEMENTS: "No target elements found";
-    readonly TARGET_NOT_FOUND: "Target not found: \"{0}\"";
-    readonly NO_VALID_ATTRIBUTES: "No valid attributes provided";
-    readonly NO_VALID_CLASSES: "No valid classes provided to {0}";
-    readonly NO_VALID_CSS_PROPERTY: "No valid CSS property provided";
-    readonly IF_CONTEXT_INVALID: "Invalid context for if directive";
-    readonly ELSE_CONTEXT_INVALID: "Invalid context for else directive";
-    readonly REPEAT_CONTEXT_INVALID: "Invalid context for repeat directive";
-    readonly REPEAT_COLLECTION_INVALID: "Invalid collection for repeat directive";
-    readonly UNSUPPORTED_CSS_PROPERTY: "Unsupported CSS property: \"{0}\"";
-    readonly HISTORY_API_UNAVAILABLE: "History API is not available";
-};
-export declare const ErrorSuggestions: {
-    readonly ELEMENT_NOT_FOUND: readonly ["Check if target selector is valid", "Ensure elements exist in DOM", "Verify element has correct ID or class"];
-    readonly INVALID_SELECTOR: readonly ["Use valid CSS selector syntax like \"#id\", \".class\", or \"element\"", "Check CSS selector syntax", "Use document.querySelector() test"];
-    readonly NO_TARGET: readonly ["Provide a valid target element", "Check if element exists", "Verify selector matches an element"];
-    readonly INVALID_CLASS: readonly ["Use valid CSS class names", "Check for special characters", "Class names must start with letter, underscore, or hyphen"];
-    readonly INVALID_ATTRIBUTE: readonly ["Use valid HTML attribute names", "Check for special characters", "Attribute names must not contain spaces"];
-    readonly NO_VALID_VALUES: readonly ["Provide valid class names or attributes", "Check input syntax", "Ensure values are not empty"];
-    readonly CONTEXT_INVALID: readonly ["Check if context element exists", "Verify context is properly initialized", "Ensure \"me\" reference is valid"];
-    readonly NAVIGATION_ERROR: readonly ["Check if URL is valid and accessible", "Verify browser supports requested navigation", "Ensure History API is available"];
-    readonly EXECUTION_FAILED: readonly ["Check if element exists", "Verify element is not null", "Ensure element is still in DOM"];
-    readonly VALIDATION_FAILED: readonly ["Check argument types and syntax", "Ensure arguments match expected types", "Verify required arguments are provided"];
-    readonly PARTIAL_LAYOUT: readonly ["Remove layout elements (html, body, head) from partial response", "Return only content fragments, not full page HTML", "Check server endpoint is returning partial content"];
-    readonly PARTIAL_SEMANTIC: readonly ["Check if page already has this semantic landmark", "Consider if landmark is needed in partial or should be static", "Review partial content for duplicate header/footer/main/nav/aside"];
-};
-export declare function createError(errorCode: string, customMessage?: string, placeholders?: (string | number)[], suggestions?: string[]): ValidationError;
-export declare function getSuggestions(errorCode: string): readonly string[];
-export declare function wrapError(code: string, message: string, cause: Error | ExecutionError, context?: ExecutionErrorContext): ExecutionError;
-export declare function isExecutionError(error: unknown): error is ExecutionError;
-export declare function getErrorChain(error: ExecutionError | Error, maxDepth?: number): Array<ExecutionError | Error>;
-export declare function formatErrorChain(error: ExecutionError | Error): string;
-//# sourceMappingURL=error-codes.d.ts.map

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

@@ -1,155 +0,0 @@
-import type { RuntimeValidator } from '../validation/lightweight-validators';
-import type { ValidationResult, EvaluationResult, LLMDocumentation, ExecutionContext, TypedExpressionContext, EvaluationType } from './base-types';
-export type { ValidationResult, EvaluationResult, LLMDocumentation, ExecutionContext, TypedExecutionContext, TypedExpressionContext, EvaluationType, HyperScriptValueType, } from './base-types';
-export type ExpressionCategory = 'Reference' | 'Logical' | 'Conversion' | 'Positional' | 'Property' | 'Special' | 'Template';
-export interface TypedError {
-    name: string;
-    message: string;
-    code: string;
-    suggestions: string[];
-}
-export interface BaseTypedExpression<T> {
-    readonly name: string;
-    readonly category: string;
-    readonly syntax: string;
-    readonly outputType: string;
-    readonly inputSchema: RuntimeValidator<unknown>;
-    readonly metadata: ExpressionMetadata;
-    readonly documentation?: LLMDocumentation;
-    evaluate(context: TypedExpressionContext, input: unknown): Promise<EvaluationResult<T>>;
-    validate(input: unknown): ValidationResult;
-}
-export interface ExpressionEvaluation {
-    expressionName: string;
-    category: ExpressionCategory;
-    input: unknown;
-    output: unknown;
-    timestamp: number;
-    duration: number;
-    success: boolean;
-    error?: Error;
-}
-export interface ExpressionMetadata {
-    category: ExpressionCategory;
-    complexity: 'simple' | 'medium' | 'complex';
-    sideEffects?: string[];
-    dependencies?: string[];
-    returnTypes?: EvaluationType[];
-    examples?: {
-        input: string;
-        description: string;
-        expectedOutput: unknown;
-        context?: Partial<ExecutionContext>;
-    }[];
-    relatedExpressions?: string[];
-    performance?: {
-        averageTime: number;
-        complexity: 'O(1)' | 'O(n)' | 'O(log n)' | 'O(n²)';
-    };
-}
-export interface TypedExpressionImplementation<TInput = unknown, TOutput = unknown, TContext extends TypedExpressionContext = TypedExpressionContext> {
-    readonly name: string;
-    readonly category: ExpressionCategory;
-    readonly syntax: string;
-    readonly description: string;
-    readonly inputSchema: RuntimeValidator<TInput>;
-    readonly outputType: EvaluationType;
-    readonly metadata: ExpressionMetadata;
-    readonly documentation?: LLMDocumentation;
-    evaluate(context: TContext, input: TInput): Promise<EvaluationResult<TOutput>>;
-    validate(input: unknown): ValidationResult;
-    parse?(expressionString: string): Promise<EvaluationResult<TInput>>;
-    canHandle?(input: unknown): boolean;
-}
-export interface ExpressionValidationError {
-    type: 'type-mismatch' | 'missing-argument' | 'invalid-syntax' | 'runtime-error' | 'syntax-error' | 'security-warning';
-    message: string;
-    position?: {
-        line: number;
-        column: number;
-        source: string;
-        start?: number;
-        end?: number;
-        suggestions: [];
-    };
-    suggestions: string[];
-    code?: string;
-    severity: 'error' | 'warning' | 'info';
-}
-export interface ExpressionValidationResult extends ValidationResult<unknown> {
-    errors: ExpressionValidationError[];
-    warnings?: ExpressionValidationError[];
-    suggestions: string[];
-}
-export interface EnhancedExpressionRegistry {
-    register<TInput, TOutput, TContext extends TypedExpressionContext>(expression: TypedExpressionImplementation<TInput, TOutput, TContext>): void;
-    get(name: string): TypedExpressionImplementation | undefined;
-    has(name: string): boolean;
-    getExpressionNames(): string[];
-    getByCategory(category: ExpressionCategory): TypedExpressionImplementation[];
-    validateExpression(name: string, input: unknown): ExpressionValidationResult;
-    getMetadata(name: string): ExpressionMetadata | undefined;
-    findByReturnType(returnType: EvaluationType): TypedExpressionImplementation[];
-}
-export interface ExpressionEvaluationOptions {
-    validationMode?: 'strict' | 'permissive';
-    maxDepth?: number;
-    timeout?: number;
-    caching?: boolean;
-    debugging?: boolean;
-}
-export interface ExpressionContextBridge {
-    toTyped(context: ExecutionContext, options?: ExpressionEvaluationOptions): TypedExpressionContext;
-    fromTyped(typedContext: TypedExpressionContext, originalContext: ExecutionContext): ExecutionContext;
-}
-export interface ExpressionFactory {
-    createReferenceExpression<T = HTMLElement>(name: string, evaluator: (context: TypedExpressionContext, input: unknown) => Promise<T>): TypedExpressionImplementation;
-    createLogicalExpression(name: string, evaluator: (context: TypedExpressionContext, left: unknown, right: unknown) => Promise<boolean>): TypedExpressionImplementation;
-    createConversionExpression<TFrom, TTo>(name: string, fromType: EvaluationType, toType: EvaluationType, converter: (context: TypedExpressionContext, input: TFrom) => Promise<TTo>): TypedExpressionImplementation;
-}
-export interface ExpressionProfiler {
-    startProfiling(expressionName: string, input: unknown): string;
-    endProfiling(profilingId: string, result: EvaluationResult<unknown>): void;
-    getStats(expressionName?: string): {
-        totalEvaluations: number;
-        averageTime: number;
-        slowestEvaluation: number;
-        fastestEvaluation: number;
-        errorRate: number;
-    };
-    clearStats(): void;
-}
-export type ExpressionImplementationMap<T = TypedExpressionImplementation> = {
-    [key: string]: T;
-};
-export type ExpressionCategoryMap = {
-    [K in ExpressionCategory]: TypedExpressionImplementation[];
-};
-export interface ExpressionCache {
-    get(key: string): EvaluationResult<unknown> | undefined;
-    set(key: string, result: EvaluationResult<unknown>, ttl?: number): void;
-    clear(): void;
-    size(): number;
-}
-export interface ExpressionDebugger {
-    enable(expressionNames: string[]): void;
-    disable(): void;
-    getLastEvaluation(): ExpressionEvaluation | undefined;
-    getHistory(limit?: number): ExpressionEvaluation[];
-    setBreakpoint(expressionName: string, condition?: (context: TypedExpressionContext) => boolean): void;
-}
-export declare const CommonInputSchemas: {
-    readonly NoInput: RuntimeValidator<unknown>;
-    readonly StringInput: RuntimeValidator<string>;
-    readonly NumberInput: RuntimeValidator<number>;
-    readonly BooleanInput: RuntimeValidator<boolean>;
-    readonly ElementInput: RuntimeValidator<unknown>;
-    readonly SelectorInput: RuntimeValidator<string>;
-    readonly ComparisonInput: RuntimeValidator<{
-        [x: string]: unknown;
-    }>;
-    readonly LogicalInput: RuntimeValidator<{
-        [x: string]: unknown;
-    }>;
-};
-//# sourceMappingURL=expression-types.d.ts.map