@hyperfixi/core 2.0.0

package/dist/registry/multilingual/examples.d.ts

@@ -0,0 +1,16 @@
+import { type MultilingualCommand } from './index';
+export declare const queryCommand: MultilingualCommand;
+export declare const sendEmailCommand: MultilingualCommand;
+export declare const logCommand: MultilingualCommand;
+export declare const cacheCommand: MultilingualCommand;
+export declare const completeServerPlugin: import("../index").LokaScriptPlugin;
+export declare const usageExamples: {
+    english: string;
+    japanese: string;
+    spanish: string;
+    arabic: string;
+    korean: string;
+    chinese: string;
+};
+export declare const expressIntegration = "\nimport express from 'express';\nimport { getDefaultRegistry } from '@hyperfixi/core/registry';\nimport { createMultilingualServerPlugin } from '@hyperfixi/core/registry/multilingual';\nimport { createRequestEventSource } from '@hyperfixi/core/registry/examples/server-event-source';\n\nconst app = express();\nconst registry = getDefaultRegistry();\n\n// Install multilingual server plugin\nconst serverPlugin = createMultilingualServerPlugin({\n  languages: ['en', 'ja', 'es', 'ar'],\n});\nregistry.use(serverPlugin);\n\n// Create and register request event source\nconst requestSource = createRequestEventSource();\nregistry.eventSources.register('request', requestSource);\n\n// Middleware to inject context\napp.use((req, res, next) => {\n  // Register request/response in context\n  registry.context.register('request', () => req);\n  registry.context.register('response', () => res);\n  next();\n});\n\n// Route hyperscript handler\napp.use('/api/*', (req, res) => {\n  const handled = requestSource.handleRequest(\n    {\n      method: req.method,\n      url: req.url,\n      path: req.path,\n      query: req.query,\n      params: req.params,\n      headers: req.headers,\n      body: req.body,\n    },\n    {\n      status: (code) => { res.status(code); return res; },\n      header: (name, value) => { res.set(name, value); return res; },\n      json: (data) => res.json(data),\n      html: (content) => res.send(content),\n      text: (content) => res.send(content),\n      redirect: (url, code) => res.redirect(code ?? 302, url),\n      send: (data) => res.send(data),\n    }\n  );\n\n  if (!handled) {\n    res.status(404).json({ error: 'Not found' });\n  }\n});\n";
+//# sourceMappingURL=examples.d.ts.map

package/dist/registry/multilingual/index.d.ts

@@ -0,0 +1,68 @@
+import type { LokaScriptPlugin, ContextProviderFn } from '../index';
+import type { CommandWithParseInput } from '../../runtime/command-adapter';
+import type { EventSource } from '../event-source-registry';
+export type LanguageCode = 'en' | 'ja' | 'ko' | 'ar' | 'zh' | 'es' | 'pt' | 'fr' | 'de' | 'id' | 'qu' | 'sw' | 'th' | 'tl' | 'tr' | 'vi' | 'bn' | 'hi' | 'it' | 'ms' | 'pl' | 'ru' | 'uk';
+export interface MultilingualKeyword {
+    primary: string;
+    alternatives?: string[];
+}
+export type MultilingualKeywordMap = Partial<Record<LanguageCode, MultilingualKeyword | string>>;
+export interface MultilingualCommand extends CommandWithParseInput {
+    keywords?: MultilingualKeywordMap;
+    semanticRoles?: {
+        primary?: 'patient' | 'destination' | 'content' | 'source';
+        optional?: Array<'destination' | 'source' | 'condition' | 'style' | 'quantity'>;
+    };
+}
+export interface MultilingualEventSource extends EventSource {
+    patterns?: MultilingualKeywordMap;
+}
+export interface MultilingualServerPluginOptions {
+    languages?: LanguageCode[];
+    customKeywords?: {
+        respond?: MultilingualKeywordMap;
+        redirect?: MultilingualKeywordMap;
+        setHeader?: MultilingualKeywordMap;
+        request?: MultilingualKeywordMap;
+    };
+    commands?: MultilingualCommand[];
+    eventSources?: MultilingualEventSource[];
+    contextProviders?: Array<{
+        name: string;
+        provide: ContextProviderFn;
+        keywords?: MultilingualKeywordMap;
+    }>;
+}
+export declare const respondKeywords: MultilingualKeywordMap;
+export declare const redirectKeywords: MultilingualKeywordMap;
+export declare const setHeaderKeywords: MultilingualKeywordMap;
+export declare const requestKeywords: MultilingualKeywordMap;
+export declare class KeywordAliasRegistry {
+    private aliases;
+    private byCommand;
+    register(command: string, keyword: string, language: LanguageCode): void;
+    registerFromMap(command: string, keywords: MultilingualKeywordMap): void;
+    lookup(keyword: string): {
+        command: string;
+        language: LanguageCode;
+    } | undefined;
+    getKeywords(command: string, language: LanguageCode): string[];
+    getLanguages(command: string): LanguageCode[];
+}
+export declare function createMultilingualServerPlugin(options?: MultilingualServerPluginOptions): LokaScriptPlugin & {
+    keywordRegistry: KeywordAliasRegistry;
+};
+export declare function detectLanguage(input: string, keywordRegistry: KeywordAliasRegistry): LanguageCode;
+export declare function getWordOrder(language: LanguageCode): 'SVO' | 'SOV' | 'VSO' | 'V2';
+export declare function getTextDirection(language: LanguageCode): 'ltr' | 'rtl';
+export declare const serverRoles: {
+    content: "content";
+    destination: "destination";
+    status: "status";
+    headerName: "headerName";
+    headerValue: "headerValue";
+    method: "method";
+    pattern: "pattern";
+};
+export declare const roleMarkers: Record<LanguageCode, Partial<Record<string, string[]>>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/registry/runtime-integration.d.ts

@@ -0,0 +1,30 @@
+import type { ExecutionContext } from '../types/core';
+import type { EventSource, EventSourceSubscribeOptions } from './event-source-registry';
+import type { ContextProviderRegistry } from './context-provider-registry';
+import type { EventSourceRegistry } from './event-source-registry';
+export interface RegistryIntegrationOptions {
+    enableContextProviders?: boolean;
+    enableEventSources?: boolean;
+    registry?: {
+        context?: ContextProviderRegistry;
+        eventSources?: EventSourceRegistry;
+    };
+}
+export declare class RegistryIntegration {
+    private options;
+    private contextRegistry;
+    private eventSourceRegistry;
+    private contextCache;
+    constructor(options?: RegistryIntegrationOptions);
+    enhanceContext(baseContext: ExecutionContext): ExecutionContext;
+    getEventSource(eventName: string): EventSource | undefined;
+    hasEventSource(eventName: string): boolean;
+    subscribeToEventSource(eventSourceName: string, options: EventSourceSubscribeOptions, context: ExecutionContext): import("./event-source-registry").EventSourceSubscription;
+    getEventSourceNames(): string[];
+    getContextProviderNames(): string[];
+    destroy(): void;
+}
+export declare function createRegistryIntegration(options?: RegistryIntegrationOptions): RegistryIntegration;
+export declare function getDefaultRegistryIntegration(): RegistryIntegration;
+export declare function resetDefaultRegistryIntegration(): void;
+//# sourceMappingURL=runtime-integration.d.ts.map

package/dist/registry/universal-types.d.ts

@@ -0,0 +1,34 @@
+import type { EventSourcePayload, EventSourceHandler, EventSource, RuntimeEnvironment } from './event-source-registry';
+import type { ExecutionContext } from '../types/core';
+export type UniversalEventPayload = EventSourcePayload<'universal'>;
+export type UniversalEventHandler = EventSourceHandler<'universal'>;
+export interface UniversalEventSource<TEnv extends RuntimeEnvironment = 'universal'> extends EventSource {
+}
+export interface TypedRegistry<TEnv extends RuntimeEnvironment = 'universal'> {
+    eventSources: {
+        register(name: string, source: UniversalEventSource<TEnv>): void;
+        get(name: string): UniversalEventSource<TEnv> | undefined;
+        has(name: string): boolean;
+        getSourceNames(): string[];
+    };
+    context: {
+        register<T>(name: string, provide: (ctx: ExecutionContext) => T, options?: {
+            description?: string;
+            cache?: boolean;
+        }): void;
+        has(name: string): boolean;
+        getProviderNames(): string[];
+    };
+    commands: {
+        register(command: any): void;
+        has(name: string): boolean;
+        getCommandNames(): string[];
+    };
+}
+export declare function createTimerEventSource(name: string, interval: number): UniversalEventSource;
+export declare function createAdaptiveEventSource(name: string, options?: {
+    description?: string;
+}): UniversalEventSource;
+export declare function isBrowserLikePayload(payload: UniversalEventPayload): boolean;
+export declare function isServerLikePayload(payload: UniversalEventPayload): boolean;
+//# sourceMappingURL=universal-types.d.ts.map

package/dist/registry/universal-types.js

@@ -0,0 +1,91 @@
+'use strict';
+
+function isBrowserEnvironment() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function isNodeEnvironment() {
+    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
+}
+
+function createTimerEventSource(name, interval) {
+    return {
+        name,
+        description: `Timer that fires every ${interval}ms`,
+        supportedEvents: [name],
+        subscribe(options, context) {
+            const handler = () => {
+                const payload = {
+                    type: name,
+                    data: { timestamp: Date.now() },
+                    target: isBrowserEnvironment() && typeof document !== 'undefined' ? document.body : {},
+                };
+                options.handler(payload, context);
+            };
+            const timerId = setInterval(handler, interval);
+            return {
+                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                source: name,
+                event: name,
+                unsubscribe: () => clearInterval(timerId),
+            };
+        },
+        supports(event) {
+            return event === name;
+        },
+    };
+}
+function createAdaptiveEventSource(name, options) {
+    return {
+        name,
+        description: options?.description ?? `Adaptive ${name} events`,
+        supportedEvents: [name],
+        subscribe(subscribeOptions, context) {
+            let unsubscribe;
+            if (isBrowserEnvironment()) {
+                const handler = (e) => {
+                    const customEvent = e;
+                    const payload = {
+                        type: name,
+                        data: customEvent.detail,
+                        target: e.target instanceof Element ? e.target : null,
+                        nativeEvent: e,
+                    };
+                    subscribeOptions.handler(payload, context);
+                };
+                document.addEventListener(name, handler);
+                unsubscribe = () => document.removeEventListener(name, handler);
+            }
+            else if (isNodeEnvironment()) {
+                unsubscribe = () => {
+                };
+            }
+            else {
+                unsubscribe = () => { };
+            }
+            return {
+                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                source: name,
+                event: name,
+                unsubscribe,
+            };
+        },
+        supports(event) {
+            return event === name;
+        },
+    };
+}
+function isBrowserLikePayload(payload) {
+    return isBrowserEnvironment() && (payload.target == null || payload.target instanceof Element);
+}
+function isServerLikePayload(payload) {
+    return (isNodeEnvironment() &&
+        typeof payload.data === 'object' &&
+        payload.data !== null &&
+        'request' in payload.data);
+}
+
+exports.createAdaptiveEventSource = createAdaptiveEventSource;
+exports.createTimerEventSource = createTimerEventSource;
+exports.isBrowserLikePayload = isBrowserLikePayload;
+exports.isServerLikePayload = isServerLikePayload;
+//# sourceMappingURL=universal-types.js.map

package/dist/registry/universal-types.mjs

@@ -0,0 +1,86 @@
+function isBrowserEnvironment() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function isNodeEnvironment() {
+    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
+}
+
+function createTimerEventSource(name, interval) {
+    return {
+        name,
+        description: `Timer that fires every ${interval}ms`,
+        supportedEvents: [name],
+        subscribe(options, context) {
+            const handler = () => {
+                const payload = {
+                    type: name,
+                    data: { timestamp: Date.now() },
+                    target: isBrowserEnvironment() && typeof document !== 'undefined' ? document.body : {},
+                };
+                options.handler(payload, context);
+            };
+            const timerId = setInterval(handler, interval);
+            return {
+                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                source: name,
+                event: name,
+                unsubscribe: () => clearInterval(timerId),
+            };
+        },
+        supports(event) {
+            return event === name;
+        },
+    };
+}
+function createAdaptiveEventSource(name, options) {
+    return {
+        name,
+        description: options?.description ?? `Adaptive ${name} events`,
+        supportedEvents: [name],
+        subscribe(subscribeOptions, context) {
+            let unsubscribe;
+            if (isBrowserEnvironment()) {
+                const handler = (e) => {
+                    const customEvent = e;
+                    const payload = {
+                        type: name,
+                        data: customEvent.detail,
+                        target: e.target instanceof Element ? e.target : null,
+                        nativeEvent: e,
+                    };
+                    subscribeOptions.handler(payload, context);
+                };
+                document.addEventListener(name, handler);
+                unsubscribe = () => document.removeEventListener(name, handler);
+            }
+            else if (isNodeEnvironment()) {
+                unsubscribe = () => {
+                };
+            }
+            else {
+                unsubscribe = () => { };
+            }
+            return {
+                id: `${name}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                source: name,
+                event: name,
+                unsubscribe,
+            };
+        },
+        supports(event) {
+            return event === name;
+        },
+    };
+}
+function isBrowserLikePayload(payload) {
+    return isBrowserEnvironment() && (payload.target == null || payload.target instanceof Element);
+}
+function isServerLikePayload(payload) {
+    return (isNodeEnvironment() &&
+        typeof payload.data === 'object' &&
+        payload.data !== null &&
+        'request' in payload.data);
+}
+
+export { createAdaptiveEventSource, createTimerEventSource, isBrowserLikePayload, isServerLikePayload };
+//# sourceMappingURL=universal-types.mjs.map

package/dist/runtime/cleanup-registry.d.ts

@@ -0,0 +1,47 @@
+export type CleanupType = 'listener' | 'observer' | 'interval' | 'timeout' | 'custom';
+export interface CleanupEntry {
+    type: CleanupType;
+    cleanup: () => void;
+    target?: EventTarget;
+    eventName?: string;
+    description?: string;
+}
+export interface CleanupStats {
+    elementsTracked: number;
+    listeners: number;
+    observers: number;
+    intervals: number;
+    timeouts: number;
+    custom: number;
+    global: number;
+}
+export declare class CleanupRegistry {
+    private elementCleanups;
+    private elementCount;
+    private typeCounts;
+    private globalCleanups;
+    private debugMode;
+    constructor(options?: {
+        debug?: boolean;
+    });
+    registerListener(element: Element, target: EventTarget, eventName: string, handler: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    registerObserver(element: Element, observer: MutationObserver): void;
+    registerInterval(element: Element, intervalId: ReturnType<typeof setInterval>): void;
+    registerTimeout(element: Element, timeoutId: ReturnType<typeof setTimeout>): void;
+    registerCustom(element: Element, cleanup: () => void, description?: string): void;
+    registerGlobal(cleanup: () => void, type?: CleanupType, description?: string): void;
+    private addCleanup;
+    cleanupElement(element: Element): number;
+    cleanupElementTree(element: Element): number;
+    cleanupGlobal(): number;
+    cleanupAll(): number;
+    hasCleanups(element: Element): boolean;
+    getCleanupCount(element: Element): number;
+    getStats(): CleanupStats;
+    setDebugMode(enabled: boolean): void;
+}
+export declare function createAutoCleanupRegistry(options?: {
+    debug?: boolean;
+    root?: Element;
+}): CleanupRegistry;
+//# sourceMappingURL=cleanup-registry.d.ts.map

package/dist/runtime/command-adapter.d.ts

@@ -0,0 +1,63 @@
+import type { ExecutionContext, TypedExecutionContext, ValidationResult } from '../types/core';
+import type { ASTNode } from '../types/base-types';
+import { HookRegistry } from '../types/hooks';
+import { ExpressionEvaluator } from '../core/expression-evaluator';
+export interface RuntimeCommand {
+    name: string;
+    execute(context: ExecutionContext, ...args: unknown[]): Promise<unknown>;
+    validate?(input: unknown): ValidationResult<unknown>;
+    metadata?: {
+        description: string;
+        examples: string[];
+        syntax: string;
+    };
+}
+export interface CommandWithParseInput {
+    name: string;
+    parseInput?(raw: {
+        args: ASTNode[];
+        modifiers: Record<string, any>;
+        commandName?: string;
+    }, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<any>;
+    execute(input: any, context: TypedExecutionContext): Promise<unknown>;
+    validate?(input: unknown): ValidationResult<unknown>;
+    metadata?: any;
+}
+export declare class ContextBridge {
+    static toTyped(context: ExecutionContext): TypedExecutionContext;
+    static fromTyped(typedContext: TypedExecutionContext, originalContext: ExecutionContext): ExecutionContext;
+}
+export declare class CommandAdapterV2 implements RuntimeCommand {
+    private impl;
+    private expressionEvaluator;
+    private hookRegistry;
+    constructor(impl: CommandWithParseInput, sharedEvaluator?: ExpressionEvaluator, hookRegistry?: HookRegistry);
+    setHookRegistry(registry: HookRegistry): void;
+    private createHookContext;
+    get name(): string;
+    get metadata(): {
+        description: any;
+        examples: any;
+        syntax: any;
+    };
+    execute(context: ExecutionContext, ...args: unknown[]): Promise<unknown>;
+    validate(input: unknown): ValidationResult<unknown>;
+}
+export declare class CommandRegistryV2 {
+    private adapters;
+    private implementations;
+    private sharedEvaluator?;
+    private hookRegistry?;
+    constructor(sharedEvaluator?: ExpressionEvaluator, hookRegistry?: HookRegistry);
+    setHookRegistry(registry: HookRegistry): void;
+    getHookRegistry(): HookRegistry | undefined;
+    register(impl: any): void;
+    getAdapter(name: string): CommandAdapterV2 | undefined;
+    has(name: string): boolean;
+    getCommandNames(): string[];
+    getImplementation(name: string): CommandWithParseInput | undefined;
+    getAdapters(): Map<string, CommandAdapterV2>;
+    validateCommand(name: string, input: unknown): ValidationResult<unknown>;
+}
+export declare function createCommandRegistryV2(commands: CommandWithParseInput[], sharedEvaluator?: ExpressionEvaluator, hookRegistry?: HookRegistry): CommandRegistryV2;
+//# sourceMappingURL=command-adapter.d.ts.map

package/dist/runtime/environment.d.ts

@@ -0,0 +1,75 @@
+export declare const isDeno: boolean;
+export declare const isNode: string | false;
+export declare const isBrowser: boolean;
+export interface RuntimeInfo {
+    name: 'deno' | 'node' | 'browser' | 'unknown';
+    version: string;
+    hasDOM: boolean;
+    hasWebAPIs: boolean;
+    hasFileSystem: boolean;
+    hasNetworking: boolean;
+    typescript: boolean;
+    supportsESM: boolean;
+    supportsWorkers: boolean;
+}
+export declare function getRuntimeInfo(): RuntimeInfo;
+export declare const logger: {
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+};
+export declare const performance: {
+    now: () => number;
+    mark: (name: string) => void;
+    measure: (name: string, startMark?: string, endMark?: string) => void;
+};
+export declare class UniversalEventTarget {
+    private listeners;
+    addEventListener(type: string, listener: (event: any) => void): void;
+    removeEventListener(type: string, listener: (event: any) => void): void;
+    dispatchEvent(event: {
+        type: string;
+        [key: string]: any;
+    }): boolean;
+}
+export declare function getLLMRuntimeInfo(): {
+    runtime: "unknown" | "node" | "browser" | "deno";
+    version: string;
+    typescript: boolean;
+    capabilities: {
+        dom: boolean;
+        webapis: boolean;
+        filesystem: boolean;
+        networking: boolean;
+        workers: boolean;
+        esm: boolean;
+    };
+    features: {
+        dom?: boolean | undefined;
+        webapis?: boolean | undefined;
+        serviceWorkers?: boolean | undefined;
+        webAssembly?: boolean | undefined;
+        npm?: boolean | undefined;
+        packageJson?: boolean | undefined;
+        nodeModules?: boolean | undefined;
+        builtinModules?: boolean | undefined;
+        permissions?: string | undefined;
+        builtinTypescript?: boolean | undefined;
+        standardLibrary?: string | undefined;
+        jsr?: boolean | undefined;
+        denoDeploy?: boolean | undefined;
+    };
+    patterns: {
+        imports: string;
+        testing: string;
+        bundling: string;
+    };
+};
+export declare function importForEnvironment<T>(imports: {
+    deno?: () => Promise<T>;
+    node?: () => Promise<T>;
+    browser?: () => Promise<T>;
+    fallback?: () => Promise<T>;
+}): Promise<T>;
+//# sourceMappingURL=environment.d.ts.map

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

@@ -0,0 +1,78 @@
+import type { ASTNode, ExecutionContext, CommandNode, EventHandlerNode } from '../types/base-types';
+import type { ExecutionResult, ExecutionSignal, ControlFlowError } from '../types/result';
+import type { RuntimeHooks } from '../types/hooks';
+import { HookRegistry } from '../types/hooks';
+import { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
+export declare function isControlFlowError(e: unknown): e is ControlFlowError;
+import { CommandRegistryV2 as CommandRegistry } from './command-adapter';
+import { CleanupRegistry } from './cleanup-registry';
+import { RegistryIntegration, type RegistryIntegrationOptions } from '../registry/runtime-integration';
+export declare function unwrapCommandResult(result: unknown): unknown | undefined;
+export interface RuntimeBaseOptions {
+    registry: CommandRegistry;
+    enableAsyncCommands?: boolean;
+    commandTimeout?: number;
+    enableErrorReporting?: boolean;
+    enableResultPattern?: boolean;
+    expressionEvaluator: BaseExpressionEvaluator;
+    hooks?: RuntimeHooks;
+    enableAutoCleanup?: boolean;
+    registryIntegration?: RegistryIntegrationOptions | boolean;
+}
+export declare class RuntimeBase {
+    protected options: RuntimeBaseOptions;
+    protected registry: CommandRegistry;
+    protected expressionEvaluator: BaseExpressionEvaluator;
+    behaviorRegistry: Map<string, any>;
+    behaviorAPI: any;
+    protected globalVariables: Map<string, any>;
+    protected hookRegistry: HookRegistry;
+    protected cleanupRegistry: CleanupRegistry;
+    private autoCleanupObserver;
+    protected registryIntegration: RegistryIntegration | null;
+    constructor(options: RuntimeBaseOptions);
+    private setupAutoCleanup;
+    registerHooks(name: string, hooks: RuntimeHooks): void;
+    unregisterHooks(name: string): boolean;
+    getRegisteredHooks(): string[];
+    cleanup(element: Element): number;
+    cleanupTree(element: Element): number;
+    getCleanupStats(): ReturnType<CleanupRegistry['getStats']>;
+    destroy(): void;
+    execute(node: ASTNode, context: ExecutionContext): Promise<unknown>;
+    protected processCommand(node: CommandNode, context: ExecutionContext): Promise<unknown>;
+    protected toSignal(error: unknown): ExecutionSignal | null;
+    protected processCommandWithResult(node: CommandNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
+    protected executeCommandSequenceWithResult(commands: ASTNode[], context: ExecutionContext): Promise<ExecutionResult<unknown>>;
+    protected evaluateExpression(node: ASTNode, context: ExecutionContext): Promise<unknown>;
+    protected evaluateExpressionWithResult(node: ASTNode, context: ExecutionContext): Promise<ExecutionResult<unknown>>;
+    protected executeCommandFromPattern(commandName: string, selector: string, context: ExecutionContext): Promise<unknown>;
+    protected executeProgram(node: any, context: ExecutionContext): Promise<unknown>;
+    protected executeBlock(node: {
+        commands?: ASTNode[];
+    }, context: ExecutionContext): Promise<void>;
+    protected executeCommandSequence(node: {
+        commands: ASTNode[];
+    }, context: ExecutionContext): Promise<unknown>;
+    protected executeObjectLiteral(node: {
+        properties: Array<{
+            key: ASTNode;
+            value: ASTNode;
+        }>;
+    }, context: ExecutionContext): Promise<Record<string, unknown>>;
+    protected enhanceContext(baseContext: ExecutionContext): ExecutionContext;
+    protected executeBehaviorDefinition(node: ASTNode & {
+        name: string;
+        parameters?: string[];
+        eventHandlers?: EventHandlerNode[];
+        initBlock?: ASTNode;
+    }, _context: ExecutionContext): Promise<void>;
+    protected installBehaviorOnElement(behaviorName: string, element: HTMLElement, parameters: Record<string, any>): Promise<void>;
+    protected executeEventHandler(node: EventHandlerNode, context: ExecutionContext): Promise<void>;
+    private static createEventHandler;
+    protected setupMutationObserver(targets: HTMLElement[], attr: string, commands: ASTNode[], context: ExecutionContext): void;
+    protected setupChangeObserver(watchTarget: ASTNode, commands: ASTNode[], context: ExecutionContext): Promise<void>;
+    protected queryElements(selector: string, context: ExecutionContext): HTMLElement[];
+    protected isElement(obj: unknown): obj is HTMLElement;
+}
+//# sourceMappingURL=runtime-base.d.ts.map

package/dist/runtime/runtime-experimental.d.ts

@@ -0,0 +1,18 @@
+import { RuntimeBase } from './runtime-base';
+import { CommandRegistryV2 } from './command-adapter';
+import { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
+export interface RuntimeExperimentalOptions {
+    lazyLoad?: boolean;
+    expressionPreload?: 'core' | 'all' | 'common' | 'none';
+    expressionEvaluator?: BaseExpressionEvaluator;
+    registry?: CommandRegistryV2;
+    enableAsyncCommands?: boolean;
+    commandTimeout?: number;
+    enableErrorReporting?: boolean;
+}
+export declare class RuntimeExperimental extends RuntimeBase {
+    constructor(options?: RuntimeExperimentalOptions);
+}
+export declare function createRuntimeExperimental(options?: RuntimeExperimentalOptions): RuntimeExperimental;
+export declare function createMinimalRuntime(commands: any[], options?: Omit<RuntimeExperimentalOptions, 'registry'>): RuntimeExperimental;
+//# sourceMappingURL=runtime-experimental.d.ts.map

package/dist/runtime/runtime-factory.d.ts

@@ -0,0 +1,30 @@
+import { RuntimeBase } from './runtime-base';
+import type { BaseExpressionEvaluator } from '../core/base-expression-evaluator';
+import type { ParserInterface } from '../parser/parser-interface';
+import type { ExecutionContext } from '../types/core';
+export interface TreeShakeableRuntimeOptions {
+    expressionEvaluator: BaseExpressionEvaluator;
+    enableAsyncCommands?: boolean;
+    commandTimeout?: number;
+    enableErrorReporting?: boolean;
+    enableResultPattern?: boolean;
+}
+export interface RuntimeOptions {
+    commands: Array<() => any>;
+    expressions?: Record<string, any>[];
+    parser?: ParserInterface;
+    enableAsyncCommands?: boolean;
+    commandTimeout?: number;
+    enableErrorReporting?: boolean;
+}
+export interface LokaScriptRuntime {
+    runtime: RuntimeBase;
+    parser?: ParserInterface;
+    run(code: string, element?: Element): Promise<unknown>;
+    execute(ast: any, context: ExecutionContext): Promise<unknown>;
+    parse(code: string): any;
+}
+export declare function createTreeShakeableRuntime(commands: any[], options: TreeShakeableRuntimeOptions): RuntimeBase;
+export declare function createRuntime(options: RuntimeOptions): LokaScriptRuntime;
+export type { BaseExpressionEvaluator, ParserInterface };
+//# sourceMappingURL=runtime-factory.d.ts.map

package/dist/runtime/runtime.d.ts

@@ -0,0 +1,19 @@
+import { RuntimeBase } from './runtime-base';
+import { CommandRegistryV2, type CommandWithParseInput } from './command-adapter';
+export interface RuntimeOptions {
+    enableAsyncCommands?: boolean;
+    commandTimeout?: number;
+    enableErrorReporting?: boolean;
+    lazyLoad?: boolean;
+    expressionPreload?: 'core' | 'common' | 'all' | 'none';
+    registry?: CommandRegistryV2;
+    useEnhancedCommands?: boolean;
+    commands?: string[];
+}
+export declare class Runtime extends RuntimeBase {
+    constructor(options?: RuntimeOptions);
+    getRegistry(): CommandRegistryV2;
+}
+export declare function createRuntime(options?: RuntimeOptions): Runtime;
+export declare function createMinimalRuntime(commands: CommandWithParseInput[], options?: Omit<RuntimeOptions, 'registry'>): Runtime;
+//# sourceMappingURL=runtime.d.ts.map