@hyperfixi/core 3.3.0 → 4.0.1

package/dist/types/hooks.d.ts

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

@@ -1,32 +0,0 @@
-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 { 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, EvaluationResult } 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 } from '../lib/morph-adapter';
-export type { TransitionCallback } 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/program.d.ts

@@ -1,8 +0,0 @@
-import type { ExecutionContext } from './core';
-import type { ExecutionResult } from './result';
-export type Op = (context: ExecutionContext) => Promise<ExecutionResult<unknown>>;
-export interface Program {
-    readonly run: Op;
-}
-export type BodyOps = ReadonlyArray<Op | undefined>;
-//# sourceMappingURL=program.d.ts.map

package/dist/types/result.d.ts

@@ -1,73 +0,0 @@
-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 type Completion<T = unknown> = 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

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

@@ -1,162 +0,0 @@
-import type { BaseTypedExpression, TypedExpressionContext, EvaluationResult, ValidationResult, LLMDocumentation } from './base-types';
-import type { HyperScriptValue } from './command-types';
-import type { ExecutionContext } from './core.ts';
-export interface TemplateExecutionContext extends TypedExpressionContext {
-    readonly templateBuffer: string[];
-    readonly templateDepth: number;
-    readonly iterationContext?: {
-        collection: HyperScriptValue;
-        currentIndex: number;
-        currentItem: HyperScriptValue;
-        totalItems: number;
-    };
-    readonly conditionalContext?: {
-        conditionMet: boolean;
-        elseAllowed: boolean;
-        branchExecuted: boolean;
-    } | undefined;
-    readonly templateMeta: {
-        templateName?: string;
-        compiledAt: number;
-        executionStartTime: number;
-        directiveStack: string[];
-    };
-}
-export type TemplateDirectiveType = '@if' | '@else' | '@repeat' | '@include' | '@end';
-export type TemplateRenderStrategy = 'replace' | 'append' | 'conditional' | 'iterate';
-export interface EnhancedTemplateDirective<TInput = unknown, TOutput = string> extends BaseTypedExpression<TOutput> {
-    readonly directiveType: TemplateDirectiveType;
-    readonly renderStrategy: TemplateRenderStrategy;
-    readonly createsScope: boolean;
-    readonly allowsNesting: boolean;
-    readonly allowedNext: TemplateDirectiveType[];
-    executeTemplate(context: TemplateExecutionContext, input: TInput, templateContent: string): Promise<EvaluationResult<string>>;
-    validateTemplateContext(context: TemplateExecutionContext, input: TInput): ValidationResult;
-}
-export declare const IfDirectiveInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
-    [x: string]: unknown;
-}>;
-export interface IfDirectiveInput {
-    condition: unknown;
-    templateContent: string;
-}
-export declare const ElseDirectiveInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
-    [x: string]: unknown;
-}>;
-export interface ElseDirectiveInput {
-    templateContent: string;
-}
-export declare const RepeatDirectiveInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
-    [x: string]: unknown;
-}>;
-export interface RepeatDirectiveInput {
-    collection: unknown;
-    iteratorVariable?: string;
-    templateContent: string;
-}
-export interface EnhancedCompiledTemplate {
-    directives: EnhancedTemplateDirective[];
-    content: string[];
-    interpolations: Array<{
-        expression: string;
-        startIndex: number;
-        endIndex: number;
-        evaluatedType?: string;
-    }>;
-    metadata: {
-        originalTemplate: string;
-        compiledAt: number;
-        directiveCount: number;
-        interpolationCount: number;
-        estimatedComplexity: 'simple' | 'medium' | 'complex';
-    };
-    dependencies: {
-        requiredVariables: string[];
-        usedFeatures: string[];
-        nestedTemplates: string[];
-    };
-}
-export interface TemplateError {
-    readonly name: 'TemplateCompilationError' | 'TemplateExecutionError' | 'TemplateValidationError';
-    readonly message: string;
-    readonly code: string;
-    readonly templateName?: string;
-    readonly lineNumber?: number;
-    readonly columnNumber?: number;
-    readonly directiveType?: TemplateDirectiveType;
-    readonly suggestions: string[];
-    readonly context?: {
-        originalTemplate: string;
-        compiledDirectives: string[];
-        executionStack: string[];
-    };
-}
-export interface TemplatePerformanceMetrics {
-    readonly compilationTime: number;
-    readonly executionTime: number;
-    readonly renderTime: number;
-    readonly memoryUsage: number;
-    readonly cacheHits: number;
-    readonly cacheMisses: number;
-    readonly directiveExecutions: Record<TemplateDirectiveType, number>;
-}
-export interface EnhancedTemplateConfig {
-    enableCaching: boolean;
-    maxCacheSize: number;
-    enableMetrics: boolean;
-    enableValidation: boolean;
-    executionTimeout: number;
-    maxNestingDepth: number;
-    customDirectives: Record<string, EnhancedTemplateDirective>;
-    preprocessors: Array<(template: string) => string>;
-    postprocessors: Array<(result: string) => string>;
-}
-export interface TemplateContextBridge {
-    toTemplateContext(context: ExecutionContext, options?: {
-        templateName?: string;
-        initialBuffer?: string[];
-        iterationContext?: TemplateExecutionContext['iterationContext'];
-    }): TemplateExecutionContext;
-    fromTemplateContext(templateContext: TemplateExecutionContext, originalContext: ExecutionContext): ExecutionContext;
-}
-export interface TemplateDirectiveRegistry {
-    register<T extends EnhancedTemplateDirective>(directive: T): void;
-    get(directiveType: TemplateDirectiveType): EnhancedTemplateDirective | undefined;
-    has(directiveType: TemplateDirectiveType): boolean;
-    list(): TemplateDirectiveType[];
-    validate(directiveType: TemplateDirectiveType, input: unknown): ValidationResult;
-}
-export interface TemplateLLMDocumentation extends LLMDocumentation {
-    patterns: Array<{
-        name: string;
-        template: string;
-        context: Record<string, unknown>;
-        expectedOutput: string;
-        explanation: string;
-    }>;
-    combinations: Array<{
-        directives: TemplateDirectiveType[];
-        description: string;
-        example: string;
-        useCase: string;
-    }>;
-    troubleshooting: Array<{
-        error: string;
-        cause: string;
-        solution: string;
-        prevention: string;
-    }>;
-}
-export type TemplateStringLiteral<T extends string> = T;
-export type InterpolationPattern = `\${${string}}`;
-export type DirectivePattern = `@${string}`;
-export type TemplateDataTypes = string | number | boolean | null | undefined | Array<string | number | boolean | null | undefined | Record<string, unknown>> | Record<string, string | number | boolean | null | undefined | Array<unknown>>;
-export interface StandardTemplateContext {
-    readonly data: Record<string, TemplateDataTypes>;
-    readonly parent?: StandardTemplateContext;
-    readonly helpers: Record<string, (...args: unknown[]) => unknown>;
-    readonly partials: Record<string, string>;
-    readonly options: Record<string, unknown>;
-}
-export type { BaseTypedExpression, TypedExpressionContext, ExpressionMetadata, ValidationResult, LLMDocumentation, } from './expression-types';
-//# sourceMappingURL=template-types.d.ts.map

package/dist/types/type-guards.d.ts

@@ -1,24 +0,0 @@
-export declare function isInputElement(el: unknown): el is HTMLInputElement;
-export declare function isFormElement(el: unknown): el is HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
-export declare function isHTMLElement(el: unknown): el is HTMLElement;
-export declare function isDOMElement(value: unknown): value is Element;
-export declare function isDOMNode(value: unknown): value is Node;
-export declare function isOptionElement(el: unknown): el is HTMLOptionElement;
-export declare function isArrayLike(value: unknown): value is ArrayLike<unknown>;
-export declare function isNodeList(value: unknown): value is NodeList;
-export declare function isHTMLCollection(value: unknown): value is HTMLCollection;
-export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
-export declare function isObject(value: unknown): value is object;
-export declare function isFunction(value: unknown): value is Function;
-export declare function isPromiseLike(value: unknown): value is PromiseLike<unknown>;
-export declare function getProperty<T = unknown>(obj: unknown, key: string): T | undefined;
-export declare function setProperty<T = unknown>(obj: unknown, key: string, value: T): boolean;
-export declare function hasProperty(obj: unknown, key: string): boolean;
-export declare function toNumber(value: unknown): number | undefined;
-export declare function compareValues(left: unknown, right: unknown, op: '<' | '>' | '<=' | '>='): boolean | undefined;
-export declare function getFormValue(el: unknown): string | undefined;
-export declare function getChecked(el: unknown): boolean | undefined;
-export declare function getDisabled(el: unknown): boolean | undefined;
-export declare function getSelected(el: unknown): boolean | undefined;
-export declare function getHidden(el: unknown): boolean | undefined;
-//# sourceMappingURL=type-guards.d.ts.map

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

@@ -1,91 +0,0 @@
-import type { ExecutionContext, ValidationError, ValidationResult } from './base-types';
-export type { CoreExecutionContext } from './core-context';
-export { createCoreContext, isCoreExecutionContext, assertHTMLElement, asHTMLElement, } from './core-context';
-export type { ValidationError, ValidationResult } from './base-types';
-export type HyperScriptValueType = 'string' | 'number' | 'boolean' | 'element' | 'element-list' | 'array' | 'object' | 'promise' | 'fragment' | 'null' | 'undefined' | 'function' | 'event' | 'error' | 'unknown';
-export type EvaluationType = HyperScriptValueType | 'Any' | 'Context' | 'Command' | 'Expression';
-export type HyperScriptValue = string | number | boolean | HTMLElement | HTMLElement[] | unknown[] | Record<string, unknown> | Promise<unknown> | DocumentFragment | null | undefined | Function | Event;
-export type { ExecutionContext, TypedExecutionContext } from './base-types';
-export interface Result<T = unknown> {
-    readonly success: boolean;
-    readonly value?: T;
-    readonly error?: {
-        readonly name: string;
-        readonly message: string;
-        readonly code?: string;
-        readonly suggestions?: string[];
-    };
-    readonly type?: string;
-}
-export interface TypedResult<T = unknown> extends Result<T> {
-    readonly errors?: ValidationError[];
-    readonly suggestions?: readonly string[] | string[];
-}
-export type CommandCategory = 'dom-manipulation' | 'event-handling' | 'data-processing' | 'control-flow' | 'animation' | 'network' | 'utility' | 'navigation' | 'templates' | 'advanced';
-export type SideEffect = 'dom-mutation' | 'network-request' | 'local-storage' | 'global-state' | 'event-emission' | 'timer-creation' | 'navigation' | 'dom-query' | 'history' | 'async' | 'attribute-transfer';
-export type ExpressionCategory = 'Reference' | 'Property' | 'Logical' | 'Mathematical' | 'Conversion' | 'Positional' | 'Special' | 'Template';
-export interface ExpressionMetadata {
-    readonly category: ExpressionCategory;
-    readonly complexity: 'simple' | 'medium' | 'complex';
-    readonly sideEffects?: SideEffect[];
-    readonly dependencies?: string[];
-    readonly returnTypes?: EvaluationType[];
-    readonly examples?: Array<{
-        readonly input: string;
-        readonly description: string;
-        readonly expectedOutput: unknown;
-        readonly context?: Partial<ExecutionContext>;
-    }>;
-    readonly relatedExpressions?: string[];
-    readonly performance?: {
-        readonly averageTime: number;
-        readonly complexity: string;
-    };
-}
-export interface ASTNode {
-    readonly type: string;
-    readonly line?: number;
-    readonly column?: number;
-    readonly start?: number;
-    readonly end?: number;
-    readonly raw?: string;
-    readonly [key: string]: unknown;
-}
-export interface ParseError {
-    readonly name?: string;
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-    readonly position?: number;
-    readonly source?: string;
-}
-export interface LLMDocumentation {
-    readonly summary: string;
-    readonly parameters: Array<{
-        readonly name: string;
-        readonly type: string;
-        readonly description: string;
-        readonly optional: boolean;
-        readonly examples: string[];
-    }>;
-    readonly returns: {
-        readonly type: string;
-        readonly description: string;
-        readonly examples: string[];
-    };
-    readonly examples: Array<{
-        readonly title: string;
-        readonly code: string;
-        readonly explanation: string;
-        readonly output: unknown;
-    }>;
-    readonly seeAlso: string[];
-    readonly tags: string[];
-}
-export declare function isValidationResult<T>(value: unknown): value is ValidationResult<T>;
-export declare function isExecutionContext(value: unknown): value is ExecutionContext;
-export declare const CoreTypes: {
-    isValidationResult: typeof isValidationResult;
-    isExecutionContext: typeof isExecutionContext;
-};
-//# sourceMappingURL=unified-types.d.ts.map

package/dist/utils/beep.d.ts

@@ -1,8 +0,0 @@
-export interface BeepOutput {
-    value: unknown;
-    type: string;
-    representation: string;
-}
-export declare function beepValues(me: unknown, values: readonly unknown[]): BeepOutput[];
-export declare function describeBeepValue(value: unknown): BeepOutput;
-//# sourceMappingURL=beep.d.ts.map

package/dist/utils/debug-events.d.ts

@@ -1,41 +0,0 @@
-export interface SemanticParseEventDetail {
-    input: string;
-    language: string;
-    confidence: number;
-    threshold: number;
-    semanticSuccess: boolean;
-    fallbackTriggered: boolean;
-    command?: string;
-    roles?: Record<string, string>;
-    errors?: string[];
-    timestamp: number;
-    duration?: number;
-}
-export interface ParseCompleteEventDetail {
-    input: string;
-    method: 'semantic' | 'traditional' | 'expression';
-    success: boolean;
-    command?: string;
-    errors?: string[];
-    timestamp: number;
-    duration?: number;
-}
-export declare function enableDebugEvents(target?: EventTarget): void;
-export declare function disableDebugEvents(): void;
-export declare function isDebugEnabled(): boolean;
-export declare function emitSemanticParseEvent(detail: SemanticParseEventDetail): void;
-export declare function emitParseCompleteEvent(detail: ParseCompleteEventDetail): void;
-export interface DebugStats {
-    totalParses: number;
-    semanticSuccesses: number;
-    semanticFallbacks: number;
-    traditionalParses: number;
-    averageConfidence: number;
-    confidenceHistory: number[];
-}
-export declare function updateDebugStats(event: SemanticParseEventDetail): void;
-export declare function getDebugStats(): Readonly<DebugStats>;
-export declare function resetDebugStats(): void;
-export declare function getEventHistory(): readonly SemanticParseEventDetail[];
-export declare function replayEvents(callback: (event: SemanticParseEventDetail) => void): void;
-//# sourceMappingURL=debug-events.d.ts.map

package/dist/utils/debug.d.ts

@@ -1,35 +0,0 @@
-export declare const DEBUG: {
-    commands: boolean;
-    events: boolean;
-    parsing: boolean;
-    expressions: boolean;
-    styles: boolean;
-    runtime: boolean;
-    loops: boolean;
-    async: boolean;
-};
-export declare const debug: {
-    command: (...args: any[]) => void;
-    event: (...args: any[]) => void;
-    parse: (...args: any[]) => void;
-    expr: (...args: any[]) => void;
-    expressions: (...args: any[]) => void;
-    style: (...args: any[]) => void;
-    runtime: (...args: any[]) => void;
-    loop: (...args: any[]) => void;
-    async: (...args: any[]) => void;
-};
-export declare const debugGroup: {
-    start: (label: string) => void;
-    end: () => void;
-};
-export declare const debugControl: {
-    enable(): void;
-    disable(): void;
-    isEnabled(): boolean;
-    status(): {
-        enabled: boolean;
-        source: string;
-    };
-};
-//# sourceMappingURL=debug.d.ts.map

package/dist/utils/dom-utils.d.ts

@@ -1,16 +0,0 @@
-import type { TypedExecutionContext } from '../types/command-types.ts';
-export declare function asHTMLElement(element: Element | null): HTMLElement | null;
-export declare function asHTMLElement(element: Element | undefined): HTMLElement | undefined;
-export declare function requireHTMLElement(element: Element | null | undefined, context?: string): HTMLElement;
-export declare function asHTMLElements(elements: Element[]): HTMLElement[];
-export declare function isHTMLElement(element: Element | null | undefined): element is HTMLElement;
-export interface ResolveTargetsOptions {
-    allowEmpty?: boolean;
-    contextRequired?: boolean;
-}
-export declare function resolveTargets(context: TypedExecutionContext, target?: unknown, options?: ResolveTargetsOptions): HTMLElement[];
-export declare function isValidClassName(className: string): boolean;
-export declare function parseClasses(classExpression: unknown, validate?: boolean): string[];
-export declare function isValidAttributeName(name: string): boolean;
-export declare function isValidCSSSelector(selector: string): boolean;
-//# sourceMappingURL=dom-utils.d.ts.map

package/dist/utils/element-check.d.ts

@@ -1,8 +0,0 @@
-export declare function isHTMLElement(value: unknown): value is HTMLElement;
-export declare function isNode(value: unknown): value is Node;
-export declare function isElement(value: unknown): value is Element;
-export declare function isInsertableNode(value: unknown): value is Node;
-export declare function isEventTarget(value: unknown): value is EventTarget;
-export declare function isNodeList(value: unknown): value is NodeList;
-export declare function isDocumentFragment(value: unknown): value is DocumentFragment;
-//# sourceMappingURL=element-check.d.ts.map

package/dist/utils/keyboard-shortcuts.d.ts

@@ -1,18 +0,0 @@
-export interface KeyboardShortcut {
-    key: string;
-    ctrl: boolean;
-    shift: boolean;
-    alt: boolean;
-    meta: boolean;
-    originalSyntax: string;
-}
-export declare function parseKeyboardShortcut(syntax: string): KeyboardShortcut | null;
-export declare function createKeyboardFilter(shortcut: KeyboardShortcut): (event: KeyboardEvent) => boolean;
-export declare function createFilterExpression(shortcut: KeyboardShortcut): string;
-export declare function transformKeyboardEvent(eventType: string): {
-    type: string;
-    filter?: string;
-};
-export declare function isKeyboardShortcut(syntax: string): boolean;
-export declare function getShortcutDescription(shortcut: KeyboardShortcut): string;
-//# sourceMappingURL=keyboard-shortcuts.d.ts.map

package/dist/utils/performance.d.ts

@@ -1,40 +0,0 @@
-export interface PoolMetrics {
-    allocations: number;
-    reuses: number;
-    peakPoolSize: number;
-    hitRate: number;
-}
-export declare class ObjectPool<T extends object> {
-    private pool;
-    private index;
-    private factory;
-    private reset;
-    private metrics;
-    constructor(factory: () => T, reset?: (obj: T) => void, initialSize?: number);
-    get(): T;
-    releaseAll(): void;
-    getMetrics(): PoolMetrics;
-    clear(): void;
-}
-export declare class StyleBatcher {
-    private pending;
-    private rafId;
-    private stylePool;
-    add(element: HTMLElement, styles: Record<string, string>): void;
-    private flush;
-    cancel(): void;
-    getPendingCount(): number;
-    getPoolMetrics(): PoolMetrics;
-}
-export declare const styleBatcher: StyleBatcher;
-export declare class EventQueue {
-    private listeners;
-    wait(eventName: string, target: EventTarget): Promise<Event>;
-    private setupListener;
-    private getKey;
-    cleanup(target: EventTarget, eventName: string): void;
-    cleanupAll(): void;
-    getListenerCount(): number;
-}
-export declare const eventQueue: EventQueue;
-//# sourceMappingURL=performance.d.ts.map