@hyperfixi/core 2.0.0

package/dist/runtime/temporal-modifiers.d.ts

@@ -0,0 +1,37 @@
+export interface TemporalState {
+    id: string;
+    command: string;
+    element: HTMLElement;
+    originalState: any;
+    untilEvent: string;
+    untilTarget?: HTMLElement | Document | Window | undefined;
+    cleanup: () => void;
+    timestamp: number;
+}
+export interface TemporalModifierOptions {
+    command: string;
+    element: HTMLElement;
+    untilEvent: string;
+    untilTarget?: HTMLElement | Document | Window | undefined;
+    stateCapture: () => any;
+    stateRestore: (state: any) => void;
+}
+export declare class TemporalModifierManager {
+    private static instance;
+    private activeStates;
+    private nextId;
+    private constructor();
+    static getInstance(): TemporalModifierManager;
+    register(options: TemporalModifierOptions): string;
+    unregister(id: string): boolean;
+    getActiveStates(): TemporalState[];
+    getStatesForElement(element: HTMLElement): TemporalState[];
+    clearAll(): void;
+    get activeCount(): number;
+}
+export declare function createToggleUntil(element: HTMLElement, targetType: 'class' | 'attribute', targetName: string, untilEvent: string, untilTarget?: HTMLElement | Document | Window): string;
+export declare function createAddUntil(element: HTMLElement, targetType: 'class' | 'attribute', targetName: string, targetValue: string | undefined, untilEvent: string, untilTarget?: HTMLElement | Document | Window): string;
+export declare function createRemoveUntil(element: HTMLElement, targetType: 'class' | 'attribute', targetName: string, untilEvent: string, untilTarget?: HTMLElement | Document | Window): string;
+export declare const temporalModifierManager: TemporalModifierManager;
+export default TemporalModifierManager;
+//# sourceMappingURL=temporal-modifiers.d.ts.map

package/dist/scripts/code-generator.d.ts

@@ -0,0 +1,64 @@
+export interface LSPCommand {
+    id: string;
+    name: string;
+    description: string;
+    syntax_canonical: string;
+    example_usage: string[];
+    elementType: string;
+    tags?: string[];
+    status?: string;
+    purpose?: string;
+}
+export interface LSPFeature {
+    id: string;
+    name: string;
+    description: string;
+    syntax_canonical: string;
+    example_usage: string[];
+    elementType: string;
+    tags?: string[];
+}
+export interface ParsedCommand {
+    name: string;
+    syntax: string;
+    description: string;
+    examples: string[];
+    category: string;
+}
+export interface ParsedFeature {
+    name: string;
+    syntax: string;
+    description: string;
+    examples: string[];
+}
+export interface GeneratedCommand {
+    code: string;
+    filePath: string;
+}
+export interface GeneratedTest {
+    code: string;
+    filePath: string;
+    testCases: string[];
+}
+export interface FilePaths {
+    implementation: string;
+    test: string;
+}
+export declare class CodeGenerator {
+    private commandCategories;
+    parseCommand(data: LSPCommand): ParsedCommand;
+    parseFeature(data: LSPFeature): ParsedFeature;
+    categorizeCommand(commandName: string): string;
+    generateFilePaths(name: string, type: 'command' | 'feature'): FilePaths;
+    generateCommandInterface(data: LSPCommand): GeneratedCommand;
+    generateCommandTest(data: LSPCommand): GeneratedTest;
+    private generateTestCase;
+    loadLSPData(): {
+        commands: LSPCommand[];
+        features: LSPFeature[];
+    };
+    generateMissingCommands(): void;
+    private capitalizeFirst;
+    private escapeString;
+}
+//# sourceMappingURL=code-generator.d.ts.map

package/dist/scripts/generate-missing-commands.d.ts

@@ -0,0 +1,4 @@
+declare function generatePriorityCommands(): void;
+declare function analyzeImplementationGap(): void;
+export { generatePriorityCommands, analyzeImplementationGap };
+//# sourceMappingURL=generate-missing-commands.d.ts.map

package/dist/test-setup.d.ts

@@ -0,0 +1,45 @@
+declare global {
+    namespace Vi {
+        interface AsymmetricMatchersContaining {
+            toBeValidHyperscriptAST(): any;
+            toExecuteSuccessfully(): any;
+        }
+    }
+}
+export declare const createTestElement: (html: string) => HTMLElement;
+export declare const waitForEvent: (target: EventTarget, eventName: string, timeout?: number) => Promise<Event>;
+export declare const createMockHyperscriptContext: (element?: HTMLElement) => {
+    me: HTMLElement | null;
+    it: any;
+    you: HTMLElement | null;
+    result: any;
+    locals: Map<string, any>;
+    globals: Map<string, any>;
+    flags: {
+        halted: boolean;
+        breaking: boolean;
+        continuing: boolean;
+        returning: boolean;
+        async: boolean;
+    };
+};
+export declare const createTypedExecutionContext: (element?: HTMLElement) => {
+    me: HTMLElement | null;
+    it: any;
+    you: HTMLElement | null;
+    result: any;
+    locals: Map<string, any>;
+    globals: Map<string, any>;
+    flags: {
+        halted: boolean;
+        breaking: boolean;
+        continuing: boolean;
+        returning: boolean;
+        async: boolean;
+    };
+    expressionStack: string[];
+    evaluationDepth: number;
+    validationMode: "strict";
+    evaluationHistory: any[];
+};
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test-utilities.d.ts

@@ -0,0 +1,52 @@
+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;
+    expressionStack?: string[];
+    evaluationDepth?: number;
+    validationMode?: 'strict' | 'permissive';
+    evaluationHistory?: Array<{
+        expressionName: string;
+        category: string;
+        input: unknown;
+        output: unknown;
+        timestamp: number;
+        duration: number;
+        success: boolean;
+    }>;
+    meta?: Record<string, 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/tokenizer.d.ts

@@ -0,0 +1,49 @@
+export interface Token {
+    type: string;
+    value: string;
+    start: number;
+    end: number;
+    column: number;
+    line: number;
+    op?: boolean;
+    template?: boolean;
+}
+export declare class Lexer {
+    static isAlpha(c: string): boolean;
+    static isNumeric(c: string): boolean;
+    static isWhitespace(c: string): boolean;
+    static isNewline(c: string): boolean;
+    static isIdentifierChar(c: string): boolean;
+    static isReservedChar(c: string): boolean;
+    static isValidCSSClassChar(c: string): boolean;
+    static isValidCSSIDChar(c: string): boolean;
+    static isValidSingleQuoteStringStart(tokens: Token[]): boolean;
+    static tokenize(source: string, template?: boolean): Tokens;
+}
+export declare class Tokens {
+    private tokens;
+    private consumed;
+    private source;
+    private lastConsumed?;
+    constructor(tokens: Token[], consumed: number, source: string);
+    hasMore(): boolean;
+    token(n?: number, dontIgnoreWhitespace?: boolean): Token;
+    currentToken(): Token;
+    consumeToken(): Token;
+    consumeWhitespace(): void;
+    lastMatch(): Token | undefined;
+    matchToken(value: string, type?: string): Token | null;
+    matchTokenType(...types: string[]): Token | null;
+    matchOpToken(value: string): Token | null;
+    requireToken(value: string, type?: string): Token;
+    requireTokenType(type: string): Token;
+    requireOpToken(value: string): Token;
+    consumeUntil(value?: string, type?: string): Token[];
+    consumeUntilWhitespace(): Token[];
+    lastWhitespace(): string;
+    raiseError(message: string): never;
+    static sourceFor(tokens: Token[]): string;
+    static lineFor(token: Token): string;
+    static positionString(token: Token): string;
+}
+//# sourceMappingURL=tokenizer.d.ts.map

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

@@ -0,0 +1,336 @@
+import type { RuntimeValidator } from '../validation/lightweight-validators';
+import type { CoreExecutionContext } from './core-context';
+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 ExecutionContext extends CoreExecutionContext {
+    result: unknown;
+    readonly halted?: boolean;
+    readonly returned?: boolean;
+    readonly broke?: boolean;
+    readonly continued?: boolean;
+    readonly async?: boolean;
+    readonly variables?: Map<string, unknown>;
+    readonly events?: Map<string, {
+        target: HTMLElement;
+        event: string;
+        handler: Function;
+    }>;
+    readonly parent?: ExecutionContext;
+    readonly meta?: Record<string, unknown>;
+    readonly flags?: {
+        halted: boolean;
+        breaking: boolean;
+        continuing: boolean;
+        returning: boolean;
+        async: boolean;
+    };
+}
+export interface TypedExecutionContext extends ExecutionContext {
+    readonly expressionStack?: string[];
+    readonly evaluationDepth?: number;
+    readonly validationMode?: 'strict' | 'permissive';
+    readonly evaluationHistory?: Array<{
+        expressionName: string;
+        category: string;
+        input: unknown;
+        output: unknown;
+        timestamp: number;
+        duration: number;
+        success: boolean;
+    }>;
+    readonly typeRegistry?: Map<string, unknown>;
+    readonly validationCache?: Map<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 ASTNode {
+    readonly type: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly start?: number;
+    readonly end?: number;
+    readonly raw?: string;
+    [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 interface TypedExpressionContext extends TypedExecutionContext {
+}
+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 BinaryExpressionNode extends ASTNode {
+    readonly type: 'binaryExpression';
+    readonly operator: string;
+    readonly left: ASTNode;
+    readonly right: ASTNode;
+}
+export interface UnaryExpressionNode extends ASTNode {
+    readonly type: 'unaryExpression';
+    readonly operator: string;
+    readonly operand: ASTNode;
+}
+export interface PropertyAccessNode extends ASTNode {
+    readonly type: 'propertyAccess';
+    readonly object: ASTNode;
+    readonly property: string;
+}
+export interface MemberExpressionNode extends ASTNode {
+    readonly type: 'memberExpression';
+    readonly expression: ASTNode;
+    readonly member: string;
+}
+export interface ContextReferenceNode extends ASTNode {
+    readonly type: 'contextReference';
+    readonly contextType: 'me' | 'you' | 'it' | 'target' | 'event';
+}
+export interface CommandNode extends ASTNode {
+    readonly type: 'command';
+    readonly name: string;
+    readonly args?: ASTNode[];
+    readonly source?: string;
+}
+export interface ExpressionNode extends ASTNode {
+    readonly type: 'expression';
+    readonly value?: unknown;
+    readonly operator?: string;
+    readonly operands?: ExpressionNode[];
+}
+export interface LiteralNode extends ASTNode {
+    readonly type: 'literal';
+    readonly value: string | number | boolean;
+}
+export interface EventHandlerNode extends ASTNode {
+    readonly type: 'eventHandler';
+    readonly event: string;
+    readonly events?: string[];
+    readonly target?: string;
+    readonly selector?: string;
+    readonly condition?: ASTNode;
+    readonly attributeName?: string;
+    readonly watchTarget?: ASTNode;
+    readonly args?: string[];
+    readonly commands: ASTNode[];
+    readonly customEventSource?: string;
+    readonly modifiers?: {
+        once?: boolean;
+        prevent?: boolean;
+        stop?: boolean;
+        debounce?: number;
+        throttle?: number;
+    };
+}
+export interface BehaviorNode extends ASTNode {
+    readonly type: 'behavior';
+    readonly name: string;
+    readonly parameters: string[];
+    readonly eventHandlers: EventHandlerNode[];
+    readonly initBlock?: ASTNode;
+    readonly namespace?: string;
+}
+export interface DefNode extends ASTNode {
+    readonly type: 'def';
+    readonly name: string;
+    readonly params: string[];
+    readonly body: CommandNode[];
+    readonly errorSymbol?: string;
+    readonly errorHandler?: CommandNode[];
+    readonly finallyHandler?: CommandNode[];
+}
+export interface TypedASTNode extends ASTNode {
+    readonly evaluationType: EvaluationType;
+    readonly validationResult: ValidationResult;
+    readonly metadata?: Record<string, unknown>;
+}
+export declare class TypeSystemBridge {
+    static toEnhanced(context: ExecutionContext): TypedExecutionContext;
+    static toLegacy(context: TypedExecutionContext): ExecutionContext;
+    static normalizeValidationResult(result: unknown): ValidationResult;
+    static toHyperScriptType(evaluationType: EvaluationType): HyperScriptValueType;
+    static createTypedResult<T>(success: boolean, value?: T, error?: string | EnhancedError, type?: HyperScriptValueType): TypedResult<T>;
+}
+export declare function createExecutionContext(me?: Element | null, overrides?: Partial<ExecutionContext>): ExecutionContext;
+export declare function createTypedExecutionContext(base?: Partial<ExecutionContext>, overrides?: Partial<TypedExecutionContext>): TypedExecutionContext;
+export declare function isTypedExecutionContext(context: ExecutionContext | TypedExecutionContext): context is TypedExecutionContext;
+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

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

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