@almadar/ui 5.78.0 → 5.79.1

package/dist/lib/init.d.ts

@@ -1,14 +0,0 @@
-/**
- * Pattern Resolver Initialization
- *
- * Loads pattern registry and component mapping from orbital-shared/patterns/
- * and initializes the pattern resolver at app startup.
- *
- * @packageDocumentation
- */
-/**
- * Initialize the pattern resolver with shared pattern data.
- * Must be called once at app startup before any pattern rendering.
- * @returns The number of patterns initialized
- */
-export declare function initializePatterns(): number;

package/dist/lib/jazari/index.d.ts

@@ -1,5 +0,0 @@
-export { computeJazariLayout } from './layout.js';
-export type { LayoutState, LayoutTransition, LayoutInput } from './layout.js';
-export { gearTeethPath, lockIconPath, brainIconPath, pipeIconPath, eightPointedStarPath, arrowheadPath, } from './svg-paths.js';
-export type { JazariLayout, JazariGearLayout, JazariArmLayout, JazariGuardInfo, JazariEffectInfo, } from './types.js';
-export { JAZARI_COLORS } from './types.js';

package/dist/lib/jazari/layout.d.ts

@@ -1,31 +0,0 @@
-/**
- * Layout algorithm for the Al-Jazari state machine visualization.
- * Pure TypeScript — zero React/DOM dependencies.
- *
- * 1. BFS from initial state to order states by graph distance.
- * 2. Horizontal distribution of gears along the golden axis.
- * 3. Transition arm routing: forward arcs above, backward arcs below, self-loops above.
- * 4. Guard icons at 30% along arm, effect icons at 70%.
- */
-import type { FieldValue } from '@almadar/core';
-import type { JazariLayout } from './types.js';
-export interface LayoutState {
-    name: string;
-    isInitial?: boolean;
-    isTerminal?: boolean;
-    isFinal?: boolean;
-}
-export interface LayoutTransition {
-    from: string;
-    to: string;
-    event: string;
-    guard?: FieldValue;
-    effects?: FieldValue[];
-}
-export interface LayoutInput {
-    states: LayoutState[];
-    transitions: LayoutTransition[];
-    entityFields?: string[];
-    direction?: 'ltr' | 'rtl';
-}
-export declare function computeJazariLayout(input: LayoutInput): JazariLayout;

package/dist/lib/jazari/svg-paths.d.ts

@@ -1,61 +0,0 @@
-/**
- * SVG path generators for the Al-Jazari state machine visualization.
- * Pure TypeScript — zero React/DOM dependencies.
- *
- * Generates paths for gear teeth, arabesque borders, pipe shapes, and lock icons.
- */
-/**
- * Generate an SVG path for gear teeth around a circle.
- *
- * @param cx - Center X
- * @param cy - Center Y
- * @param innerRadius - Inner radius (base circle)
- * @param outerRadius - Outer radius (tip of teeth)
- * @param numTeeth - Number of teeth around the gear
- * @returns SVG path d attribute string
- */
-export declare function gearTeethPath(cx: number, cy: number, innerRadius: number, outerRadius: number, numTeeth: number): string;
-/**
- * Generate an SVG path for a small gear-shaped lock icon.
- *
- * @param cx - Center X
- * @param cy - Center Y
- * @param size - Overall size of the lock icon
- * @returns SVG path d attribute for the lock body + shackle
- */
-export declare function lockIconPath(cx: number, cy: number, size: number): string;
-/**
- * Generate a simple brain-like icon path.
- *
- * @param cx - Center X
- * @param cy - Center Y
- * @param size - Overall size
- * @returns SVG path d attribute
- */
-export declare function brainIconPath(cx: number, cy: number, size: number): string;
-/**
- * Generate a simple pipe/tube icon path.
- *
- * @param cx - Center X
- * @param cy - Center Y
- * @param size - Overall size
- * @returns SVG path d attribute
- */
-export declare function pipeIconPath(cx: number, cy: number, size: number): string;
-/**
- * Generate a single 8-pointed star path for the arabesque border pattern.
- *
- * @param cx - Center X
- * @param cy - Center Y
- * @param outerR - Outer radius (star tips)
- * @param innerR - Inner radius (star valleys)
- * @returns SVG path d attribute
- */
-export declare function eightPointedStarPath(cx: number, cy: number, outerR: number, innerR: number): string;
-/**
- * Generate a simple arrowhead path for transition arm endpoints.
- *
- * @param size - Arrow size
- * @returns SVG path d attribute
- */
-export declare function arrowheadPath(size: number): string;

package/dist/lib/jazari/types.d.ts

@@ -1,91 +0,0 @@
-/**
- * Shared types for the Al-Jazari state machine visualization.
- * Pure TypeScript — zero React/DOM dependencies.
- */
-/** Layout for a single gear (state node) */
-export interface JazariGearLayout {
-    /** State name */
-    name: string;
-    /** Center X coordinate */
-    cx: number;
-    /** Center Y coordinate */
-    cy: number;
-    /** Gear outer radius */
-    radius: number;
-    /** Whether this is the initial state */
-    isInitial: boolean;
-    /** Whether this is a terminal state */
-    isTerminal: boolean;
-}
-/** Guard info attached to an arm */
-export interface JazariGuardInfo {
-    /** Position X along the arm (30% point) */
-    x: number;
-    /** Position Y along the arm (30% point) */
-    y: number;
-    /** Whether this is an AI guard (call-service) vs deterministic */
-    isAI: boolean;
-}
-/** Effect info attached to an arm */
-export interface JazariEffectInfo {
-    /** Position X along the arm (70% point) */
-    x: number;
-    /** Position Y along the arm (70% point) */
-    y: number;
-    /** Number of effects */
-    count: number;
-    /** Effect labels for tooltip display */
-    names: string[];
-}
-/** Layout for a single transition arm */
-export interface JazariArmLayout {
-    /** Source state name */
-    from: string;
-    /** Target state name */
-    to: string;
-    /** Event name label */
-    event: string;
-    /** SVG path d attribute for the arm curve */
-    path: string;
-    /** Label position X (midpoint of arm) */
-    labelX: number;
-    /** Label position Y (midpoint of arm) */
-    labelY: number;
-    /** Guard info if transition has guards */
-    guard: JazariGuardInfo | null;
-    /** Effect info if transition has effects */
-    effect: JazariEffectInfo | null;
-    /** Whether this is a self-loop */
-    isSelfLoop: boolean;
-}
-/** Complete layout result for an entire state machine diagram */
-export interface JazariLayout {
-    /** Total SVG width */
-    width: number;
-    /** Total SVG height */
-    height: number;
-    /** All gear positions */
-    gears: JazariGearLayout[];
-    /** All transition arm paths */
-    arms: JazariArmLayout[];
-    /** Golden axis Y position */
-    axisY: number;
-    /** Golden axis start X */
-    axisStartX: number;
-    /** Golden axis end X */
-    axisEndX: number;
-    /** Entity field labels to display on the axis */
-    entityFields: string[];
-    /** Text direction */
-    direction: 'ltr' | 'rtl';
-}
-/** Al-Jazari color palette constants */
-export declare const JAZARI_COLORS: {
-    readonly brass: "#B87333";
-    readonly gold: "#C8A951";
-    readonly sky: "#0EA5E9";
-    readonly crimson: "#DC2626";
-    readonly lapis: "#1E40AF";
-    readonly ivory: "#FFFBEB";
-    readonly darkBg: "#1a1a2e";
-};

package/dist/lib/offline-executor.d.ts

@@ -1,239 +0,0 @@
-/**
- * Offline Effect Executor
- *
- * Enables client-only mode for applications that need to work without
- * server connectivity. Provides:
- * - Mock data providers for simulating server responses
- * - Local effect execution without server round-trip
- * - Sync queue for effects that need server persistence when back online
- *
- * Used by both Builder preview (offline mode) and compiled shells (PWA mode).
- *
- * @packageDocumentation
- */
-import type { EntityRow, FieldValue } from '@almadar/core';
-import type { ClientEffect, ClientEffectExecutorConfig, EventResponse } from '../types/renderer-types';
-/**
- * Effect that needs to be synced to server when online
- */
-export interface PendingSyncEffect {
-    /** Unique ID for this effect */
-    id: string;
-    /** Timestamp when effect was queued */
-    timestamp: number;
-    /** Effect type (persist, call-service, etc.) */
-    type: string;
-    /** Effect payload */
-    payload: Record<string, FieldValue>;
-    /** Number of retry attempts */
-    retries: number;
-    /** Maximum retries before giving up */
-    maxRetries: number;
-}
-/**
- * Configuration for offline executor
- */
-export interface OfflineExecutorConfig extends ClientEffectExecutorConfig {
-    /**
-     * Mock data provider for simulating fetch responses.
-     * Returns data for a given entity name.
-     */
-    mockDataProvider?: (entityName: string) => EntityRow[];
-    /**
-     * Whether to queue server effects for sync when online.
-     * Default: true
-     */
-    enableSyncQueue?: boolean;
-    /**
-     * Maximum number of effects to queue before dropping oldest.
-     * Default: 100
-     */
-    maxQueueSize?: number;
-    /**
-     * Callback when an effect is added to sync queue.
-     */
-    onEffectQueued?: (effect: PendingSyncEffect) => void;
-    /**
-     * Callback when sync queue changes.
-     */
-    onQueueChange?: (queue: PendingSyncEffect[]) => void;
-}
-/**
- * Offline executor state
- */
-export interface OfflineExecutorState {
-    /** Whether we're in offline mode */
-    isOffline: boolean;
-    /** Pending effects waiting for sync */
-    syncQueue: PendingSyncEffect[];
-    /** Number of effects processed locally */
-    localEffectsProcessed: number;
-    /** Number of effects synced to server */
-    effectsSynced: number;
-    /** Last sync attempt timestamp */
-    lastSyncAttempt?: number;
-    /** Last successful sync timestamp */
-    lastSuccessfulSync?: number;
-}
-/**
- * OfflineExecutor - Handles effects in offline/client-only mode.
- *
- * Features:
- * - Executes client effects immediately (render-ui, navigate, notify, emit)
- * - Queues server effects (persist, fetch, call-service) for later sync
- * - Provides mock data for fetch effects when offline
- * - Syncs queued effects when connection is restored
- *
- * @example
- * ```typescript
- * const executor = new OfflineExecutor({
- *   renderToSlot: (slot, pattern) => slotManager.render(slot, pattern),
- *   navigate: (path) => router.push(path),
- *   notify: (message, opts) => toast.show(message, opts),
- *   eventBus: { emit: (event, payload) => bus.emit(event, payload) },
- *   mockDataProvider: (entityName) => mockStore.getAll(entityName),
- * });
- *
- * // Process effects locally
- * const response = executor.processEventOffline('LOAD', { id: '123' });
- *
- * // When back online
- * await executor.syncPendingEffects(serverUrl);
- * ```
- */
-export declare class OfflineExecutor {
-    private config;
-    private state;
-    private storage;
-    constructor(config: OfflineExecutorConfig);
-    /**
-     * Check if we're online (browser API)
-     */
-    private checkOnline;
-    /**
-     * Handle going online
-     */
-    private handleOnline;
-    /**
-     * Handle going offline
-     */
-    private handleOffline;
-    /**
-     * Load sync queue from localStorage
-     */
-    private loadSyncQueue;
-    /**
-     * Save sync queue to localStorage
-     */
-    private saveSyncQueue;
-    /**
-     * Add an effect to the sync queue
-     */
-    private queueForSync;
-    /**
-     * Execute client effects immediately.
-     */
-    executeClientEffects(effects: ClientEffect[]): void;
-    /**
-     * Process an event in offline mode.
-     *
-     * Returns a simulated EventResponse with mock data.
-     * Client effects are executed immediately.
-     * Server effects are queued for sync.
-     */
-    processEventOffline(event: string, payload?: Record<string, FieldValue>, effects?: Array<FieldValue[]>): EventResponse;
-    /**
-     * Sync pending effects to server.
-     *
-     * @param serverUrl - Base URL for the orbital server
-     * @param authToken - Optional auth token for requests
-     * @returns Number of successfully synced effects
-     */
-    syncPendingEffects(serverUrl: string, authToken?: string): Promise<number>;
-    /**
-     * Get current executor state
-     */
-    getState(): OfflineExecutorState;
-    /**
-     * Get number of pending effects
-     */
-    getPendingCount(): number;
-    /**
-     * Clear the sync queue
-     */
-    clearQueue(): void;
-    /**
-     * Dispose the executor and clean up listeners
-     */
-    dispose(): void;
-}
-/**
- * Create an offline executor with sensible defaults.
- *
- * @example
- * ```typescript
- * const executor = createOfflineExecutor({
- *   renderToSlot: slotManager.render,
- *   navigate: router.push,
- *   notify: toast.show,
- *   eventBus: { emit: bus.emit },
- *   mockDataProvider: (entity) => store.getAll(entity),
- * });
- * ```
- */
-export declare function createOfflineExecutor(config: OfflineExecutorConfig): OfflineExecutor;
-/**
- * Options for useOfflineExecutor hook
- */
-export interface UseOfflineExecutorOptions extends OfflineExecutorConfig {
-    /** Server URL for syncing */
-    serverUrl?: string;
-    /** Auth token for server requests */
-    authToken?: string;
-    /** Auto-sync when coming back online */
-    autoSync?: boolean;
-}
-/**
- * Result of useOfflineExecutor hook
- */
-export interface UseOfflineExecutorResult {
-    /** Current executor state */
-    state: OfflineExecutorState;
-    /** Whether we're offline */
-    isOffline: boolean;
-    /** Number of pending effects */
-    pendingCount: number;
-    /** Execute client effects */
-    executeClientEffects: (effects: ClientEffect[]) => void;
-    /** Process event offline */
-    processEventOffline: (event: string, payload?: Record<string, FieldValue>, effects?: Array<FieldValue[]>) => EventResponse;
-    /** Manually trigger sync */
-    sync: () => Promise<number>;
-    /** Clear the queue */
-    clearQueue: () => void;
-}
-/**
- * React hook for offline effect execution.
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { isOffline, pendingCount, processEventOffline, sync } = useOfflineExecutor({
- *     renderToSlot: slotManager.render,
- *     navigate: router.push,
- *     notify: toast.show,
- *     eventBus: { emit: bus.emit },
- *     serverUrl: '/api/orbitals',
- *     autoSync: true,
- *   });
- *
- *   return (
- *     <div>
- *       {isOffline && <Banner>Offline - {pendingCount} changes pending</Banner>}
- *       <button onClick={() => processEventOffline('SAVE', data)}>Save</button>
- *     </div>
- *   );
- * }
- * ```
- */
-export declare function useOfflineExecutor(options: UseOfflineExecutorOptions): UseOfflineExecutorResult;

package/dist/lib/orbitalsByTrait.d.ts

@@ -1,34 +0,0 @@
-/**
- * Build the `trait name → owning orbital` map used to form the qualified
- * `UI:<orbital>.<trait>.<event>` bus keys that trait state machines subscribe
- * to. Pure + dependency-free so it can be unit-tested without a React render.
- *
- * Critically, it backfills from the RESOLVED page bindings, not just the source
- * `schema.orbitals[].traits`. An auto-pulled sibling trait (e.g. an embedded
- * `@trait.X` calendar lifted into the orbital by the compiler's sibling-pull)
- * is absent from the source orbital's `traits[]`, so a source-only map misses
- * it — leaving its self-subscription unregistered and its own fetch-success
- * (e.g. `CalendarEventLoaded`) unheard, so the trait sticks in `loading`. A
- * pulled sibling lands in the same orbital as the page that references it, so
- * we backfill from the resolved page's owning orbital. Source-declared mappings
- * win; the IR only fills gaps.
- */
-export interface OrbitalsByTraitSchema {
-    orbitals?: ReadonlyArray<{
-        name: string;
-        traits?: ReadonlyArray<string | {
-            ref?: string;
-            name?: string;
-        }>;
-        pages?: ReadonlyArray<string | {
-            path?: string;
-        }>;
-    }>;
-}
-export interface ResolvedPageTraits {
-    /** Page route path, matched against the source orbital's page paths. */
-    path?: string;
-    /** Resolved trait names mounted on the page (includes pulled siblings). */
-    traitNames: readonly string[];
-}
-export declare function buildOrbitalsByTrait(schema: OrbitalsByTraitSchema | undefined, resolvedPages?: ReadonlyArray<ResolvedPageTraits>): Record<string, string>;

package/dist/lib/parseContentSegments.d.ts

@@ -1,42 +0,0 @@
-/**
- * Content Segment Parsing Utilities
- *
- * Parses rich content with code blocks and quiz tags into structured
- * segments for rendering. Detects orbital schemas in JSON code blocks
- * and marks them for JazariStateMachine rendering.
- */
-import type { OrbitalSchema } from '@almadar/core';
-/** Segment types for content rendering */
-export type ContentSegment = {
-    type: 'markdown';
-    content: string;
-} | {
-    type: 'code';
-    language: string;
-    content: string;
-} | {
-    type: 'orbital';
-    language: string;
-    content: string;
-    schema: OrbitalSchema;
-} | {
-    type: 'quiz';
-    question: string;
-    answer: string;
-};
-/**
- * Parse markdown content to extract code blocks.
- *
- * Splits markdown into segments of plain markdown and fenced code blocks.
- * JSON/orb code blocks containing orbital schemas are tagged as 'orbital'.
- */
-export declare function parseMarkdownWithCodeBlocks(content: string | undefined | null): ContentSegment[];
-/**
- * Parse content to extract all segments including quiz tags and code blocks.
- *
- * Supported tags:
- * - <question>q</question><answer>a</answer> — Quiz Q&A
- *
- * Also handles fenced code blocks (```language...```) with orbital detection.
- */
-export declare function parseContentSegments(content: string | undefined | null): ContentSegment[];

package/dist/lib/pattern-resolver.d.ts

@@ -1,88 +0,0 @@
-/**
- * Pattern Resolver
- *
- * Resolves pattern configurations to component information.
- * Uses the central pattern registry and component mapping from orbital-shared/patterns/.
- *
- * This is the shared logic used by both Builder's PatternRenderer and
- * the compiled shell's UISlotRenderer.
- *
- * @packageDocumentation
- */
-import type { PatternPropDef } from '@almadar/patterns';
-import type { PatternConfig, MappedPattern } from '../types/renderer-types';
-/**
- * Component mapping entry from component-mapping.json
- */
-interface ComponentMappingEntry {
-    component: string;
-    importPath: string;
-    category: string;
-    deprecated?: boolean;
-    replacedBy?: string;
-}
-/**
- * Pattern definition from registry.json
- */
-interface PatternDefinition {
-    type: string;
-    category: string;
-    description: string;
-    propsSchema?: Record<string, PatternPropDef>;
-}
-/**
- * Initialize the pattern resolver with mappings.
- * Called at app startup with data from JSON files.
- */
-export declare function initializePatternResolver(config: {
-    componentMapping: Record<string, ComponentMappingEntry>;
-    patternRegistry: Record<string, PatternDefinition>;
-}): void;
-/**
- * Set component mapping (alternative to full initialization).
- */
-export declare function setComponentMapping(mapping: Record<string, ComponentMappingEntry>): void;
-/**
- * Set pattern registry (alternative to full initialization).
- */
-export declare function setPatternRegistry(registry: Record<string, PatternDefinition>): void;
-/**
- * Resolve a pattern configuration to component information.
- *
- * @param config - Pattern configuration from render-ui effect
- * @returns Resolved pattern with component name, import path, and validated props
- * @throws Error if pattern type is unknown
- *
- * @example
- * ```typescript
- * const resolved = resolvePattern({
- *   type: 'entity-table',
- *   entity: 'Task',
- *   columns: ['title', 'status']
- * });
- * // resolved.component === 'DataTable'
- * // resolved.importPath === '@/components/organisms/DataTable'
- * ```
- */
-export declare function resolvePattern(config: PatternConfig): MappedPattern;
-/**
- * Check if a pattern type is known.
- */
-export declare function isKnownPattern(type: string): boolean;
-/**
- * Get all known pattern types.
- */
-export declare function getKnownPatterns(): string[];
-/**
- * Get patterns by category.
- */
-export declare function getPatternsByCategory(category: string): string[];
-/**
- * Get the component mapping for a pattern type.
- */
-export declare function getPatternMapping(type: string): ComponentMappingEntry | undefined;
-/**
- * Get the pattern definition from the registry.
- */
-export declare function getPatternDefinition(type: string): PatternDefinition | undefined;
-export {};

package/dist/lib/perf.d.ts

@@ -1,32 +0,0 @@
-/**
- * @almadar/ui/runtime — perf instrumentation
- *
- * Ring buffer of timing events for the canvas render path, plus mark/measure
- * helpers and a React.Profiler onRender callback. All gated behind
- * `createLogger('almadar:perf:canvas')` so production (LOG_LEVEL >= WARN)
- * skips both `performance.*` calls and the ring write.
- */
-import type { ProfilerOnRenderCallback } from 'react';
-export declare const PERF_NAMESPACE = "almadar:perf:canvas";
-export interface PerfEntry {
-    readonly name: string;
-    readonly durationMs: number;
-    readonly ts: number;
-    readonly detail?: Readonly<Record<string, unknown>>;
-}
-/**
- * Start a phase. Returns an opaque token; pass to {@link perfEnd}.
- * Returns -1 when the namespace is gated off, so call sites pay only one comparison.
- */
-export declare function perfStart(name: string): number;
-export declare function perfEnd(name: string, startToken: number, detail?: Record<string, unknown>): void;
-/** Synchronous wrapper that times a fn end-to-end. */
-export declare function perfTime<T>(name: string, fn: () => T, detail?: Record<string, unknown>): T;
-/**
- * React.Profiler `onRender` callback. Records `actualDuration` per commit.
- * Phase is `"mount" | "update" | "nested-update"`.
- */
-export declare const profilerOnRender: ProfilerOnRenderCallback;
-/** React hook: returns the current ring snapshot, re-renders on push. */
-export declare function usePerfBuffer(): readonly PerfEntry[];
-export declare function clearPerf(): void;