@allternit/ix 0.1.0 → 0.1.1

package/dist/renderer/renderer.js.bak

@@ -1,232 +0,0 @@
-/**
- * UI Renderer
- *
- * Core renderer for A2R-IX UI IR. Platform-agnostic base that delegates
-to platform-specific renderers (React, Vue, etc.).
- */
-/**
- * Create UI renderer
- */
-export function createUIRenderer(config) {
-    let currentRoot = null;
-    let currentContainer = null;
-    let destroyed = false;
-    const stateStore = config.stateStore;
-    const catalog = config.catalog;
-    const platform = config.platform;
-    function render(root, container) {
-        if (destroyed) {
-            throw new Error('Renderer has been destroyed');
-        }
-        currentRoot = root;
-        currentContainer = container;
-        // Initialize state
-        if (stateStore && root.state?.initial) {
-            Object.entries(root.state.initial).forEach(([path, value]) => {
-                stateStore.set(path, value);
-            });
-        }
-        // Render component tree
-        const elements = root.components.map((comp) => renderComponent(comp));
-        const rootElement = platform.createElement('Fragment', {}, elements);
-        platform.render(rootElement, container);
-    }
-    function renderComponent(component, context) {
-        try {
-            // Validate component against catalog
-            if (catalog && !catalog.validate(component.type, component.props)) {
-                throw new Error(`Invalid props for component type: ${component.type}`);
-            }
-            // Build props with context evaluation
-            const props = {};
-            if (component.props) {
-                Object.entries(component.props).forEach(([key, value]) => {
-                    props[key] = evaluateValue(value, context || {});
-                });
-            }
-            // Add bindings
-            if (component.bindings && stateStore) {
-                component.bindings.forEach((binding) => {
-                    const value = stateStore.get(binding.statePath);
-                    props[binding.prop] = value;
-                    if (binding.direction === 'two-way') {
-                        // Add onChange handler
-                        props[`on${capitalize(binding.prop)}Change`] = (newValue) => {
-                            stateStore.set(binding.statePath, newValue);
-                        };
-                    }
-                });
-            }
-            // Add event handlers
-            if (component.events) {
-                component.events.forEach((event) => {
-                    props[event.event] = (...args) => {
-                        handleEvent(event.action, event.params, args);
-                    };
-                });
-            }
-            // Render children
-            let children = [];
-            if (component.children) {
-                children = component.children.map(child => renderComponent(child, context));
-            }
-            // Handle repeat
-            if (component.repeat && stateStore) {
-                const items = stateStore.get(component.repeat.items) || [];
-                children = items.map((item, index) => {
-                    const itemContext = {
-                        ...context,
-                        [component.repeat.as]: item,
-                        ...(component.repeat.indexAs ? { [component.repeat.indexAs]: index } : {}),
-                    };
-                    return renderComponent(component.children?.[0] || { id: generateId(), type: 'Fragment', props: {} }, itemContext);
-                });
-            }
-            // Add key/id
-            props.key = component.id;
-            // Create element
-            return platform.createElement(component.type, props, children);
-        }
-        catch (error) {
-            config.onError?.(error, component.id);
-            return platform.createElement('ErrorBoundary', { error }, []);
-        }
-    }
-    function handleEvent(actionId, params, eventArgs) {
-        if (!currentRoot)
-            return;
-        const action = currentRoot.actions.find((a) => a.id === actionId);
-        if (!action) {
-            config.onError?.(new Error(`Action not found: ${actionId}`));
-            return;
-        }
-        executeAction(action, params, eventArgs);
-    }
-    function executeAction(action, params, eventArgs) {
-        const { handler } = action;
-        switch (handler.type) {
-            case 'setState': {
-                if (stateStore) {
-                    // Evaluate value expression with params and event
-                    const context = { params, event: eventArgs[0], ...stateStore.snapshot() };
-                    const value = evaluateValue(handler.value, context);
-                    stateStore.set(handler.path, value);
-                }
-                break;
-            }
-            case 'emitEvent': {
-                const context = { params, event: eventArgs[0], ...stateStore?.snapshot() };
-                const payload = evaluateValue(handler.payload, context);
-                config.onEvent?.(handler.name, payload);
-                break;
-            }
-            case 'navigate': {
-                // Navigation handled by platform
-                break;
-            }
-            case 'validate': {
-                // Validation logic
-                break;
-            }
-            case 'custom': {
-                config.onEvent?.(action.id, { params, event: eventArgs[0] });
-                break;
-            }
-        }
-    }
-    function update(patch) {
-        if (!stateStore || destroyed)
-            return;
-        // Apply patch to state
-        const snapshot = stateStore.snapshot();
-        patch.forEach((op) => {
-            if (op.op === 'add' || op.op === 'replace') {
-                const path = op.path.slice(1).replace(/\//g, '.');
-                stateStore.set(path, op.value);
-            }
-            else if (op.op === 'remove') {
-                const path = op.path.slice(1).replace(/\//g, '.');
-                stateStore.set(path, undefined);
-            }
-        });
-        // Re-render if needed
-        if (currentRoot && currentContainer) {
-            render(currentRoot, currentContainer);
-        }
-    }
-    function dispatch(actionId, params) {
-        handleEvent(actionId, params, []);
-    }
-    function getState(path) {
-        if (!stateStore)
-            return undefined;
-        return path ? stateStore.get(path) : stateStore.snapshot();
-    }
-    function setState(path, value) {
-        stateStore?.set(path, value);
-    }
-    function subscribe(path, callback) {
-        if (!stateStore)
-            return () => { };
-        return stateStore.subscribe(path, callback);
-    }
-    function destroy() {
-        if (currentContainer) {
-            platform.unmount(currentContainer);
-        }
-        destroyed = true;
-        currentRoot = null;
-        currentContainer = null;
-    }
-    return {
-        render,
-        update,
-        dispatch,
-        getState,
-        setState,
-        subscribe,
-        destroy,
-    };
-}
-/**
- * Evaluate value expression
- */
-function evaluateValue(value, context) {
-    if (value === null || typeof value !== 'object') {
-        return value;
-    }
-    if ('$path' in value) {
-        const path = value.$path;
-        return path.split('.').reduce((acc, key) => {
-            if (acc && typeof acc === 'object') {
-                return acc[key];
-            }
-            return undefined;
-        }, context);
-    }
-    if ('$expr' in value) {
-        const expr = value.$expr;
-        try {
-            // Simple expression evaluation
-            const fn = new Function('context', `with(context) { return ${expr}; }`);
-            return fn(context);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return value;
-}
-/**
- * Generate unique ID
- */
-function generateId() {
-    return `comp_${Math.random().toString(36).substr(2, 9)}`;
-}
-/**
- * Capitalize string
- */
-function capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-//# sourceMappingURL=renderer.js.map

package/dist/runtime/capsule-runtime.d.ts.bak

@@ -1,227 +0,0 @@
-/**
- * IX Capsule Runtime
- *
- * Integration with P3.9 MCP Apps capsule infrastructure for sandboxed
- * execution of A2R-IX UI capsules.
- */
-import type { UIRoot } from '../types';
-import type { StateStore } from '../state/store';
-import type { JSONPatch } from '../state/patch';
-import type { PolicyGate } from './policy-gates';
-export interface IXCapsuleConfig {
-    /** Capsule ID */
-    id: string;
-    /** UI definition */
-    ui: UIRoot;
-    /** Policy gates for security */
-    policyGates?: PolicyGate[];
-    /** State store (isolated per capsule) */
-    stateStore: StateStore;
-    /** Event handler for capsule events */
-    onEvent?: (event: IXCapsuleEvent) => void;
-    /** State change handler */
-    onStateChange?: (path: string, value: unknown) => void;
-    /** Destroy handler */
-    onDestroy?: () => void;
-}
-export interface IXCapsuleEvent {
-    type: 'action' | 'state-change' | 'error' | 'lifecycle';
-    capsuleId: string;
-    action?: string;
-    params?: Record<string, unknown>;
-    path?: string;
-    value?: unknown;
-    error?: Error;
-    lifecycle?: 'mount' | 'unmount' | 'update';
-}
-export interface IXCapsule {
-    /** Capsule ID */
-    id: string;
-    /** Get current UI definition */
-    getUI: () => UIRoot;
-    /** Update UI with new definition */
-    updateUI: (ui: UIRoot) => void;
-    /** Apply state patch */
-    applyPatch: (patch: JSONPatch) => void;
-    /** Get state value */
-    getState: (path: string) => unknown;
-    /** Set state value */
-    setState: (path: string, value: unknown) => void;
-    /** Dispatch action */
-    dispatch: (actionId: string, params?: Record<string, unknown>) => Promise<boolean>;
-    /** Subscribe to capsule events */
-    subscribe: (callback: (event: IXCapsuleEvent) => void) => () => void;
-    /** Destroy capsule */
-    destroy: () => void;
-    /** Check if capsule is active */
-    isActive: () => boolean;
-    /** GAP-62: Get capsule metrics */
-    getMetrics: () => IXCapsuleMetrics;
-}
-/**
- * GAP-62: Extended capsule metrics
- */
-export interface IXCapsuleMetrics {
-    /** Number of renders */
-    renderCount: number;
-    /** Number of actions dispatched */
-    actionCount: number;
-    /** Number of state updates */
-    stateUpdateCount: number;
-    /** Number of errors */
-    errorCount: number;
-    /** Capsule start time (ms timestamp) */
-    startTime: number;
-    /** Last activity time (ms timestamp) */
-    lastActivity: number;
-    /** GAP-63: CPU usage metrics */
-    cpu?: {
-        /** User CPU time used (milliseconds) */
-        userTime: number;
-        /** System CPU time used (milliseconds) */
-        systemTime: number;
-        /** Total CPU time (user + system) */
-        totalTime: number;
-        /** CPU usage percentage (approximate) */
-        usagePercent: number;
-    };
-    /** GAP-63: Memory usage metrics */
-    memory?: {
-        /** Heap used in bytes */
-        heapUsed: number;
-        /** Heap total in bytes */
-        heapTotal: number;
-        /** External memory in bytes */
-        external: number;
-        /** RSS (Resident Set Size) in bytes */
-        rss: number;
-        /** Array buffer memory in bytes */
-        arrayBuffers: number;
-    };
-    /** GAP-63: Network metrics (for capsules making network requests) */
-    network?: {
-        /** Number of requests made */
-        requestCount: number;
-        /** Number of successful responses */
-        successCount: number;
-        /** Number of failed requests */
-        errorCount: number;
-        /** Total bytes sent */
-        bytesSent: number;
-        /** Total bytes received */
-        bytesReceived: number;
-        /** Average response time (ms) */
-        avgResponseTime: number;
-    };
-    /** Uptime in milliseconds */
-    uptime: number;
-}
-/**
- * Create IX Capsule
- */
-export declare function createIXCapsule(config: IXCapsuleConfig): IXCapsule;
-/**
- * IX Capsule Registry
- */
-export declare class IXCapsuleRegistry {
-    private capsules;
-    private defaultPolicyGates;
-    /**
-     * Set default policy gates for all capsules
-     */
-    setDefaultPolicyGates(gates: PolicyGate[]): void;
-    /**
-     * Create and register capsule
-     */
-    create(config: Omit<IXCapsuleConfig, 'policyGates'> & {
-        policyGates?: PolicyGate[];
-    }): IXCapsule;
-    /**
-     * Get capsule by ID
-     */
-    get(id: string): IXCapsule | undefined;
-    /**
-     * Check if capsule exists
-     */
-    has(id: string): boolean;
-    /**
-     * Remove capsule
-     */
-    remove(id: string): boolean;
-    /**
-     * List all capsules
-     */
-    list(): IXCapsule[];
-    /**
-     * Get active capsules
-     */
-    getActive(): IXCapsule[];
-    /**
-     * Broadcast patch to all capsules
-     */
-    broadcastPatch(patch: JSONPatch): void;
-    /**
-     * Destroy all capsules
-     */
-    clear(): void;
-    /**
-     * GAP-62/64: Get metrics for all capsules
-     * Returns aggregated metrics for all registered capsules
-     */
-    getMetrics(): Record<string, IXCapsuleMetrics>;
-    /**
-     * GAP-64: Get aggregated metrics across all capsules
-     * Returns summary statistics for the entire registry
-     */
-    getAggregatedMetrics(): IXAggregatedMetrics;
-    /**
-     * GAP-64: Export metrics for external monitoring systems
-     * Returns metrics in a format suitable for Prometheus, DataDog, etc.
-     */
-    exportMetrics(): IXMetricsExport;
-    /**
-     * Convert metrics to Prometheus format
-     */
-    private toPrometheusFormat;
-}
-/**
- * GAP-64: Aggregated metrics interface
- */
-export interface IXAggregatedMetrics {
-    /** Total number of capsules in registry */
-    totalCapsules: number;
-    /** Number of currently active capsules */
-    activeCapsules: number;
-    /** Total renders across all capsules */
-    totalRenders: number;
-    /** Total actions across all capsules */
-    totalActions: number;
-    /** Total state updates across all capsules */
-    totalStateUpdates: number;
-    /** Total errors across all capsules */
-    totalErrors: number;
-    /** Average uptime in milliseconds */
-    avgUptime: number;
-    /** Total memory used in bytes */
-    totalMemoryUsed: number;
-    /** Average CPU usage percentage */
-    avgCpuUsage: number;
-}
-/**
- * GAP-64: Metrics export format
- */
-export interface IXMetricsExport {
-    /** Export timestamp */
-    timestamp: number;
-    /** Summary statistics */
-    summary: IXAggregatedMetrics;
-    /** Individual capsule metrics */
-    capsules: Record<string, IXCapsuleMetrics>;
-    /** Prometheus-formatted metrics */
-    prometheus: string;
-}
-/**
- * Global capsule registry
- */
-export declare const globalCapsuleRegistry: IXCapsuleRegistry;
-//# sourceMappingURL=capsule-runtime.d.ts.map