@hyperfixi/core 2.0.0

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

@@ -0,0 +1,207 @@
+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

@@ -0,0 +1,155 @@
+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

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

@@ -0,0 +1,81 @@
+import type { RuntimeValidator } from '../validation/lightweight-validators';
+import type { ValidationResult, EvaluationResult, CommandMetadata, LLMDocumentation } from './command-types';
+export interface TypedFeatureContext {
+    me: HTMLElement | null;
+    it: unknown;
+    you: HTMLElement | null;
+    result: unknown;
+    event?: Event;
+    variables: Map<string, unknown>;
+    locals: Map<string, unknown>;
+    globals: Map<string, unknown>;
+    feature: string;
+    syntax: string;
+    element: HTMLElement;
+    errors: Error[];
+    featureHistory: FeatureExecution[];
+    validationMode: 'strict' | 'permissive';
+}
+export interface FeatureExecution {
+    featureName: string;
+    timestamp: number;
+    duration?: number;
+    success: boolean;
+    input: unknown[];
+    output?: unknown;
+    error?: Error;
+}
+export interface FeatureMetadata extends CommandMetadata {
+    syntaxElements: {
+        keywords: string[];
+        modifiers: string[];
+        expressions: string[];
+    };
+    triggerTypes: string[];
+    scope: 'element' | 'document' | 'global';
+    lifecycle: 'immediate' | 'deferred' | 'continuous';
+}
+export interface TypedFeatureImplementation<TInput = unknown, TOutput = unknown, TContext extends TypedFeatureContext = TypedFeatureContext> {
+    readonly name: string;
+    readonly syntax: string;
+    readonly description: string;
+    readonly inputSchema: RuntimeValidator<TInput>;
+    readonly outputType: string;
+    readonly metadata: FeatureMetadata;
+    readonly documentation?: LLMDocumentation;
+    parse(syntaxString: string, element: HTMLElement): Promise<EvaluationResult<TInput>>;
+    execute(context: TContext, input: TInput): Promise<EvaluationResult<TOutput>>;
+    validate(input: unknown): ValidationResult;
+    cleanup?(context: TContext, registration: TOutput): Promise<void>;
+}
+export interface FeatureRegistration {
+    id: string;
+    featureName: string;
+    element: HTMLElement;
+    syntax: string;
+    active: boolean;
+    cleanup?: () => Promise<void>;
+}
+export interface FeatureValidationError {
+    type: 'syntax-error' | 'type-mismatch' | 'semantic-error' | 'runtime-error';
+    message: string;
+    position?: {
+        start: number;
+        end: number;
+        line?: number;
+        column?: number;
+        suggestions: [];
+    };
+    suggestion: string;
+    code?: string;
+}
+export interface FeatureValidationResult {
+    isValid: boolean;
+    errors: FeatureValidationError[];
+    suggestions: string[];
+    parsedSyntax?: {
+        tokens: string[];
+        structure: Record<string, any>;
+    };
+}
+//# sourceMappingURL=feature-types.d.ts.map

package/dist/types/hooks.d.ts

@@ -0,0 +1,45 @@
+import type { ExecutionContext } from './base-types';
+export interface HookContext {
+    commandName: string;
+    element: Element | null;
+    args: unknown[];
+    modifiers: Record<string, unknown>;
+    event?: Event;
+    executionContext: ExecutionContext;
+}
+export type BeforeExecuteHook = (ctx: HookContext) => void | Promise<void>;
+export type AfterExecuteHook = (ctx: HookContext, result: unknown) => void | Promise<void>;
+export type OnErrorHook = (ctx: HookContext, error: Error) => void | Error | Promise<void | Error>;
+export type InterceptCommandHook = (commandName: string, ctx: HookContext) => boolean;
+export interface RuntimeHooks {
+    beforeExecute?: BeforeExecuteHook;
+    afterExecute?: AfterExecuteHook;
+    onError?: OnErrorHook;
+    interceptCommand?: InterceptCommandHook;
+}
+export declare class HookRegistry {
+    private hooks;
+    private beforeExecuteHooks;
+    private afterExecuteHooks;
+    private onErrorHooks;
+    private interceptCommandHooks;
+    register(name: string, hooks: RuntimeHooks): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    runBeforeExecute(ctx: HookContext): Promise<void>;
+    runAfterExecute(ctx: HookContext, result: unknown): Promise<void>;
+    runOnError(ctx: HookContext, error: Error): Promise<Error>;
+    shouldIntercept(commandName: string, ctx: HookContext): boolean;
+    getRegisteredNames(): string[];
+    clear(): void;
+}
+export declare function createHooks(config: {
+    name?: string;
+    beforeExecute?: BeforeExecuteHook;
+    afterExecute?: AfterExecuteHook;
+    onError?: OnErrorHook;
+    interceptCommand?: InterceptCommandHook;
+}): RuntimeHooks;
+export declare const loggingHooks: RuntimeHooks;
+export declare function createTimingHooks(onTiming: (commandName: string, durationMs: number) => void): RuntimeHooks;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/types/index.d.ts

@@ -0,0 +1,32 @@
+import type { ValidationResult, ValidationError, EvaluationResult, ExecutionContext } from './base-types';
+export type { CoreExecutionContext } from './core-context';
+export { createCoreContext, isCoreExecutionContext, assertHTMLElement, asHTMLElement, } from './core-context';
+export type { ValidationError, ValidationResult, HyperScriptValueType, EvaluationType, HyperScriptValue, ExecutionContext, TypedExecutionContext, TypedResult, CommandCategory, SideEffect, ExpressionCategory, ExpressionMetadata, ASTNode, ParseError, LLMDocumentation, } from './unified-types';
+export { Validator, isValidationResult, isExecutionContext } from './unified-types';
+export { isInputElement, isFormElement, isHTMLElement, isDOMElement, isDOMNode, isOptionElement, isArrayLike, isNodeList, isHTMLCollection, isPlainObject, isObject, isFunction, isPromiseLike, getProperty, setProperty, hasProperty, toNumber, compareValues, getFormValue, getChecked, getDisabled, getSelected, getHidden, } from './type-guards';
+export type { ExpressionNode, CommandNode, EvaluationResult, EventHandlerNode, BehaviorNode, DefNode, } from './base-types';
+export type ValidResult<T> = ValidationResult<T>;
+export type ExecContext = ExecutionContext;
+export type ValidError = ValidationError;
+export type AsyncResult<T> = Promise<EvaluationResult<T>>;
+export type AsyncValidResult<T> = Promise<ValidationResult<T>>;
+export type ValidationFunction<T> = (input: unknown) => ValidationResult<T>;
+export type AsyncValidationFunction<T> = (input: unknown) => Promise<ValidationResult<T>>;
+export { CoreTypes } from './unified-types';
+export type { Result, Ok, Err, ExecutionSignal, HaltSignal, ExitSignal, BreakSignal, ContinueSignal, ReturnSignal, ExecutionResult, OperationResult, ExecutionError, ExecutionErrorContext, } from './result';
+export { ok, err, halt, exit, breakLoop, continueLoop, returnValue, isOk, isErr, isSignal, isSignalResult, unwrap, unwrapOr, unwrapOrElse, map, mapErr, andThen, fromPromise, fromThrowable, fromAsyncThrowable, } from './result';
+export { ErrorCodes, ErrorMessages, ErrorSuggestions, createError, getSuggestions, wrapError, isExecutionError, getErrorChain, formatErrorChain, } from './error-codes';
+export type { HookContext, BeforeExecuteHook, AfterExecuteHook, OnErrorHook, InterceptCommandHook, RuntimeHooks, } from './hooks';
+export { HookRegistry, createHooks, loggingHooks, createTimingHooks } from './hooks';
+export type { CodeActionKind, TextRange, TextEdit, FixCommand, CodeFix, FixableError, DiagnosticWithFixes, DiagnosticResponseWithFixes, } from './code-fix';
+export type { CommandCategory as StandardCommandCategory, CommandSideEffect, CommandMetadata, MetadataValidationResult, CommandRegistryEntry, } from './command-metadata';
+export { COMMAND_CATEGORIES, COMMAND_SIDE_EFFECTS, validateCommandMetadata, normalizeCategory, createCommandMetadata, mergeCommandMetadata, getSyntaxArray, formatMetadataForDocs, CommandMetadataRegistry, commandMetadataRegistry, } from './command-metadata';
+export type { SwapStrategy, SwapExecutionOptions } from '../lib/swap-executor';
+export type { MorphOptions, MorphEngine } from '../lib/morph-adapter';
+export type { TransitionCallback, ViewTransitionOptions, ViewTransitionsConfig, } from '../lib/view-transitions';
+export type { HistorySwapConfig, HistorySwapInstance } from '../behaviors/history-swap';
+export type { BoostedConfig, BoostedInstance } from '../behaviors/boosted';
+export type { SwapCommandInput } from '../commands/dom/swap';
+export type { HistoryCommandInput, HistoryMode, PushUrlCommandInput, } from '../commands/navigation/push-url';
+export type { ReplaceUrlCommandInput } from '../commands/navigation/replace-url';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/result.d.ts

@@ -0,0 +1,72 @@
+export type Result<T, E = Error> = Ok<T> | Err<E>;
+export interface Ok<T> {
+    readonly ok: true;
+    readonly value: T;
+}
+export interface Err<E> {
+    readonly ok: false;
+    readonly error: E;
+}
+export type ExecutionSignal = HaltSignal | ExitSignal | BreakSignal | ContinueSignal | ReturnSignal;
+export interface HaltSignal {
+    readonly type: 'halt';
+}
+export interface ExitSignal {
+    readonly type: 'exit';
+    readonly returnValue?: unknown;
+}
+export interface BreakSignal {
+    readonly type: 'break';
+}
+export interface ContinueSignal {
+    readonly type: 'continue';
+}
+export interface ReturnSignal {
+    readonly type: 'return';
+    readonly returnValue?: unknown;
+}
+export type ExecutionResult<T> = Result<T, ExecutionSignal>;
+export interface ControlFlowError extends Error {
+    isHalt?: true;
+    isExit?: true;
+    isBreak?: true;
+    isContinue?: true;
+    isReturn?: true;
+    returnValue?: unknown;
+}
+export declare function asControlFlowError(e: unknown): ControlFlowError | null;
+export type OperationResult<T> = Result<T, ExecutionError>;
+export interface ExecutionError {
+    readonly code: string;
+    readonly message: string;
+    readonly cause?: ExecutionError | Error;
+    readonly context?: ExecutionErrorContext;
+}
+export interface ExecutionErrorContext {
+    command?: string;
+    input?: unknown;
+    element?: string;
+    phase?: 'parse' | 'validate' | 'execute';
+    [key: string]: unknown;
+}
+export declare function ok<T>(value: T): Ok<T>;
+export declare function err<E>(error: E): Err<E>;
+export declare function halt(): Err<HaltSignal>;
+export declare function exit(returnValue?: unknown): Err<ExitSignal>;
+export declare function breakLoop(): Err<BreakSignal>;
+export declare function continueLoop(): Err<ContinueSignal>;
+export declare function returnValue(value?: unknown): Err<ReturnSignal>;
+export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+export declare function isSignal(error: unknown): error is ExecutionSignal;
+export declare function isSignalResult<T>(result: Result<T, unknown>): result is Err<ExecutionSignal>;
+export declare function unwrap<T, E>(result: Result<T, E>): T;
+export declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+export declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
+export declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+export declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+export declare function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+export declare function fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>>;
+export declare function fromThrowable<T, A extends unknown[]>(fn: (...args: A) => T): (...args: A) => Result<T, Error>;
+export declare function fromAsyncThrowable<T, A extends unknown[]>(fn: (...args: A) => Promise<T>): (...args: A) => Promise<Result<T, Error>>;
+//# sourceMappingURL=result.d.ts.map