@almadar/ui 5.79.0 → 5.79.1

package/dist/hooks/useUISlots.d.ts

@@ -1,214 +0,0 @@
-/**
- * useUISlots Hook
- *
- * Core hook for managing UI slot rendering in the trait-driven architecture.
- * Traits use render_ui effects to dynamically render content into slots.
- *
- * Slots:
- * - main: Primary content area
- * - sidebar: Left/right sidebar
- * - modal: Modal overlay
- * - drawer: Slide-in drawer
- * - overlay: Full-screen overlay
- * - center: Centered popup
- * - toast: Toast notifications
- * - hud-top: Game HUD top bar
- * - hud-bottom: Game HUD bottom bar
- * - floating: Draggable floating panel
- *
- * Multi-source model (2026-04-24):
- * A slot can receive renders from multiple source traits across independent
- * batches (e.g. in the playground, ProbeCreate renders "main" on INIT, then
- * later ProbePersistor cascades a render into "main" too). Prior code stored
- * a single SlotContent per slot and last-writer-wins silently dropped
- * earlier traits' frames. Internally the manager now holds a
- * `Record<UISlot, Record<sourceKey, SlotContent>>` map and consumers see an
- * aggregated view: a single SlotContent for single-source slots, or a
- * synthetic `stack` wrapper when 2+ sources are active simultaneously.
- * This mirrors the compiled-path page layout's VStack-of-trait-views.
- *
- * @packageDocumentation
- */
-import type React from 'react';
-import type { EventPayloadValue, RenderItemLambda, UISlot } from '@almadar/core';
-export type { UISlot };
-/**
- * Animation types for slot transitions
- */
-export type SlotAnimation = 'fade' | 'slide' | 'scale' | 'none';
-/**
- * Render-prop callback after fn-form-lambda conversion or
- * `wrapCallbackForEvent` wrapping. Pattern components consume these as
- * `renderItem` / `onTabChange` / `onClick` / etc. The arg list is
- * contravariant (`never[]` accepts any caller shape — event handlers,
- * 2-arg `(item, index)` render-props, etc.); the return is the union of
- * shapes seen at this layer. Pattern-level prop types narrow the
- * signature for each consumer downstream.
- */
-export type SlotCallback = (...args: never[]) => void | React.ReactNode | EventPayloadValue;
-/**
- * Render-ui prop value: any leaf flowing from a `(render-ui slot {...})`
- * effect into a React pattern component. The union enumerates every
- * shape the renderer can receive — no `unknown` escape hatch.
- *
- * - JSON primitives (`string`, `number`, `boolean`, `Date`, `null`,
- *   `undefined`) come through `BindingResolver`.
- * - `RenderItemLambda` is the unconverted tuple form `["fn", arg, body]`;
- *   `SlotCallback` is the post-conversion callable form.
- * - `React.ReactNode` covers substituted `<TraitFrame>` elements.
- * - The recursive array + object branches mirror the `EventPayloadValue`
- *   shape but with `SlotPropValue` leaves so functions and React nodes
- *   can appear at any depth (e.g. `tabs[].content: "@trait.X"` surviving
- *   substitution into a `ReactElement`).
- */
-export type SlotPropValue = string | number | boolean | Date | null | undefined | RenderItemLambda | SlotCallback | React.ReactElement | ReadonlyArray<SlotPropValue> | {
-    readonly [key: string]: SlotPropValue;
-};
-/**
- * Pattern-specific props carried by a rendered slot. The slot manager
- * routes these from `(render-ui slot {...})` effects to React pattern
- * components without coercion.
- */
-export type SlotProps = Record<string, SlotPropValue>;
-/**
- * Content rendered in a slot
- */
-export interface SlotContent {
-    /** Unique ID for this content */
-    id: string;
-    /** Pattern/component type to render */
-    pattern: string;
-    /** Props to pass to the pattern component */
-    props: SlotProps;
-    /** Priority for conflict resolution (higher wins) */
-    priority: number;
-    /** Animation for showing/hiding */
-    animation?: SlotAnimation;
-    /** Auto-dismiss timestamp (for toasts) */
-    autoDismissAt?: number;
-    /** Callback when dismissed */
-    onDismiss?: () => void;
-    /** Source trait that rendered this content */
-    sourceTrait?: string;
-    /** Stable node ID from the schema pattern tree (for edit mode overlay targeting) */
-    nodeId?: string;
-    /** Slot this content was rendered into (= SlotRenderConfig.target) — contextual-edit address. */
-    slot?: string;
-    /** Transition event key that produced this render (raw, as fired). */
-    transitionEvent?: string;
-    /** State the trait was in when this render fired (the from-state). */
-    fromState?: string;
-    /** linkedEntity of the source trait — contextual-edit address. */
-    entity?: string;
-}
-/**
- * Configuration for render_ui effect
- */
-export interface SlotRenderConfig {
-    /** Target slot */
-    target: UISlot;
-    /** Pattern/component to render */
-    pattern: string;
-    /** Props for the pattern */
-    props?: SlotProps;
-    /** Priority (default: 0) */
-    priority?: number;
-    /** Animation type */
-    animation?: SlotAnimation;
-    /** Auto-dismiss after ms (for toasts) */
-    autoDismissMs?: number;
-    /** Callback on dismiss */
-    onDismiss?: () => void;
-    /** Source trait name */
-    sourceTrait?: string;
-    /** Transition event key that produced this render (raw, as fired). */
-    transitionEvent?: string;
-    /** State the trait was in when this render fired (the from-state). */
-    fromState?: string;
-    /** linkedEntity of the source trait. */
-    entity?: string;
-}
-/**
- * Callback for slot changes
- */
-export type SlotChangeCallback = (slot: UISlot, content: SlotContent | null) => void;
-/**
- * Fires when a specific trait's current render-ui output changes.
- * Used by `<TraitFrame>` to subscribe only to the trait it embeds,
- * avoiding wide re-renders when unrelated slots update.
- *
- * Per-trait index stores exactly one entry per trait (the most recent
- * render), so the callback signature carries just the new content —
- * no per-slot disambiguation needed.
- */
-export type TraitChangeCallback = (content: SlotContent | null) => void;
-/**
- * UI Slot Manager interface
- */
-export interface UISlotManager {
-    /**
-     * Current aggregate content for each slot. Single-source slots hold
-     * that source's SlotContent; multi-source slots hold a synthetic
-     * `stack` wrapper whose `children` prop is the list of per-source
-     * pattern configs in insertion order. Single consumers can continue
-     * to read `slots[slot]` without knowing the slot is multi-source.
-     */
-    slots: Partial<Record<UISlot, SlotContent | null>>;
-    /** Render content to a slot */
-    render: (config: SlotRenderConfig) => string;
-    /** Clear all source entries from a slot */
-    clear: (slot: UISlot) => void;
-    /** Clear a single source's contribution from a slot, keeping others */
-    clearBySource: (slot: UISlot, sourceTrait: string) => void;
-    /** Clear content by ID */
-    clearById: (id: string) => void;
-    /** Clear all slots */
-    clearAll: () => void;
-    /** Subscribe to slot changes */
-    subscribe: (callback: SlotChangeCallback) => () => void;
-    /** Check if a slot has content */
-    hasContent: (slot: UISlot) => boolean;
-    /** Get aggregated content for a slot (single or synthetic stack) */
-    getContent: (slot: UISlot) => SlotContent | null;
-    /**
-     * Look up the most recent `render-ui` output a given trait produced,
-     * keyed by `SlotContent.sourceTrait`. Returns `null` when the trait
-     * hasn't rendered yet.
-     *
-     * Backs the `@trait.X` binding's client-side resolution via
-     * `<TraitFrame>`. See `docs/Almadar_Std_Gaps.md` §3.8. The binding is
-     * single-segment — there's intentionally no slot disambiguation.
-     */
-    getTraitContent: (traitName: string) => SlotContent | null;
-    /**
-     * Subscribe to changes in a specific trait's render output. Returns
-     * an unsubscribe function.
-     *
-     * Scoped per-trait so `<TraitFrame>` components only re-render when
-     * the trait they embed actually changes — not on every slot update.
-     */
-    subscribeTrait: (traitName: string, callback: TraitChangeCallback) => () => void;
-    /**
-     * Update only the per-trait sidecar without writing to any slot.
-     *
-     * Used for embed-aware slot routing: when a trait is referenced via
-     * `@trait.X` by a sibling layout's render-ui, its render output should
-     * not stack into the same slot the layout writes — the layout owns the
-     * slot and embeds the trait's frame via `<TraitFrame>`. This method
-     * keeps the per-trait sidecar (`traitIndexRef`) up-to-date so
-     * `<TraitFrame>` re-renders, while leaving `slots[target]` untouched.
-     *
-     * Mirrors what the compiled-path codegen does structurally — atoms
-     * inlined as JSX inside the layout's pattern, not writing slots.
-     */
-    updateTraitContent: (traitName: string, content: Omit<SlotContent, 'id' | 'sourceTrait'>) => string;
-}
-declare const DEFAULT_SLOTS: Partial<Record<UISlot, SlotContent | null>>;
-/**
- * Create a UI Slot Manager instance.
- *
- * This is the internal hook that creates the manager.
- * Use `useUISlots()` from context in components.
- */
-export declare function useUISlotManager(): UISlotManager;
-export { DEFAULT_SLOTS };

package/dist/hooks/useValidation.d.ts

@@ -1,46 +0,0 @@
-export interface LLMErrorContext {
-    rawValuePreview?: string;
-    expectedType?: string;
-    actualType?: string;
-    source?: {
-        agent: 'requirements' | 'builder' | 'view-planner';
-        operation: string;
-        promptHash?: string;
-    };
-    tokenUsage?: {
-        prompt: number;
-        completion: number;
-    };
-}
-export interface ValidationError {
-    code: string;
-    message: string;
-    path?: string;
-    severity: 'error' | 'warning';
-    suggestion?: string;
-    validValues?: string[];
-    expectedShape?: string;
-    fixGuidance?: string;
-    llmContext?: LLMErrorContext;
-}
-export interface ValidationResult {
-    valid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-}
-export type ValidationStage = 'idle' | 'validating' | 'fixing' | 'complete';
-export interface UseValidationResult {
-    result: ValidationResult | null;
-    isValidating: boolean;
-    error: string | null;
-    stage: ValidationStage;
-    isFixing: boolean;
-    progressMessage: string | null;
-    errors: ValidationError[];
-    warnings: ValidationError[];
-    isValid: boolean;
-    validate: (appId: string) => Promise<ValidationResult>;
-    clearResult: () => void;
-    reset: () => void;
-}
-export declare function useValidation(): UseValidationResult;

package/dist/lib/api-client.d.ts

@@ -1,43 +0,0 @@
-/**
- * API Client - HTTP client for backend API calls
- *
- * Provides typed methods for making API requests.
- * All requests go through the backend server, NOT directly to Firestore.
- *
- * @packageDocumentation
- */
-import type { FieldValue } from '@almadar/core';
-/**
- * API Error class for handling HTTP errors
- */
-export declare class ApiError extends Error {
-    status: number;
-    statusText: string;
-    constructor(status: number, statusText: string, message?: string);
-}
-/**
- * API client with typed methods
- */
-export declare const apiClient: {
-    /**
-     * GET request
-     */
-    get<T>(endpoint: string): Promise<T>;
-    /**
-     * POST request
-     */
-    post<T>(endpoint: string, data?: Record<string, FieldValue>): Promise<T>;
-    /**
-     * PUT request
-     */
-    put<T>(endpoint: string, data?: Record<string, FieldValue>): Promise<T>;
-    /**
-     * PATCH request
-     */
-    patch<T>(endpoint: string, data?: Record<string, FieldValue>): Promise<T>;
-    /**
-     * DELETE request
-     */
-    delete<T = void>(endpoint: string): Promise<T>;
-};
-export default apiClient;

package/dist/lib/client-effect-executor.d.ts

@@ -1,57 +0,0 @@
-/**
- * Client Effect Executor
- *
- * Executes client effects returned from the server.
- * This is the core of the dual execution model - the server processes
- * events and returns client effects, which this module executes.
- *
- * Used by both Builder preview and compiled shells.
- *
- * @packageDocumentation
- */
-import type { FieldValue } from '@almadar/core';
-import type { ClientEffect, ClientEffectExecutorConfig, PatternConfig, NotifyOptions } from '../types/renderer-types';
-/**
- * Execute an array of client effects.
- *
- * Effects are executed sequentially in order.
- * Errors in one effect don't prevent subsequent effects from executing.
- *
- * @param effects - Array of client effects to execute
- * @param config - Configuration providing implementations for each effect type
- *
- * @example
- * ```typescript
- * executeClientEffects(
- *   [
- *     ['render-ui', 'main', { type: 'entity-table', entity: 'Task' }],
- *     ['notify', 'Tasks loaded!', { type: 'success' }]
- *   ],
- *   {
- *     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) }
- *   }
- * );
- * ```
- */
-export declare function executeClientEffects(effects: ClientEffect[], config: ClientEffectExecutorConfig): void;
-/**
- * Parse a raw effect array into a typed ClientEffect.
- * Handles unknown effect formats gracefully.
- */
-export declare function parseClientEffect(raw: FieldValue[]): ClientEffect | null;
-/**
- * Parse an array of raw effects into typed ClientEffects.
- * Filters out invalid effects.
- */
-export declare function parseClientEffects(raw: FieldValue[] | undefined): ClientEffect[];
-/**
- * Get all render-ui effects.
- */
-export declare function getRenderUIEffects(effects: ClientEffect[]): Array<['render-ui', string, PatternConfig | null]>;
-/**
- * Get all notify effects.
- */
-export declare function getNotifyEffects(effects: ClientEffect[]): Array<['notify', string, NotifyOptions?]>;

package/dist/lib/cn.d.ts

@@ -1,6 +0,0 @@
-import { type ClassValue } from 'clsx';
-/**
- * Utility function to merge Tailwind CSS classes
- * Combines clsx for conditional classes with tailwind-merge to handle conflicts
- */
-export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib/createClientEffectHandlers.d.ts

@@ -1,42 +0,0 @@
-/**
- * Client Effect Handlers Factory
- *
- * Creates the standard effect handler set for client-side trait execution.
- *
- * @packageDocumentation
- */
-import type { EventPayload, EntityRow, FieldValue, ServiceParams, PatternConfig } from '@almadar/core';
-import type { EffectHandlers } from '@almadar/runtime';
-export interface ClientEventBus {
-    emit: (type: string, payload?: EventPayload) => void;
-}
-export interface SlotSetter {
-    addPattern: (slot: string, pattern: PatternConfig | null, props?: Record<string, FieldValue | undefined>) => void;
-    clearSlot: (slot: string) => void;
-}
-export interface CreateClientEffectHandlersOptions {
-    eventBus: ClientEventBus;
-    slotSetter: SlotSetter;
-    navigate?: (path: string, params?: Record<string, string>) => void;
-    notify?: (message: string, type: 'success' | 'error' | 'warning' | 'info') => void;
-    /**
-     * Live client-entity write target for `[runtime]` entities. `(set
-     * @entity.<field> value)` runs entirely in the browser for in-memory
-     * entities (game boards, wizards): there is no server row to persist to,
-     * so the canonical client `set` must mutate THIS object — the same object
-     * `EffectExecutor` reads `@entity.*` from for the current `executeAll` and
-     * the next tick seeds from. When omitted, `set` is a no-op (bridge mode:
-     * the server owns persistence). One store, read live by render-ui, guards,
-     * and ticks — no guard-vs-render split.
-     */
-    liveEntity?: EntityRow;
-    /**
-     * Optional consumer-supplied call-service handler. When set, it runs
-     * instead of the default mock fallback — use to wire the playground
-     * to real backends. When omitted, `callService` returns a synthetic
-     * mock result so service-atom chains advance end-to-end in offline /
-     * standalone-preview mode (see OrbitalServerRuntime's mock parallel).
-     */
-    callService?: (service: string, action: string, params?: ServiceParams) => Promise<EventPayload>;
-}
-export declare function createClientEffectHandlers(options: CreateClientEffectHandlersOptions): EffectHandlers;

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

@@ -1,55 +0,0 @@
-/**
- * Data Resolver
- *
- * Resolves entity data for pattern rendering.
- * Supports multiple data sources with priority:
- * 1. Server-provided data (from EventResponse.data)
- * 2. Entity store (Builder in-memory mock data)
- * 3. Empty array (fallback)
- *
- * Used by both Builder's PatternRenderer and compiled shell's UISlotRenderer.
- *
- * @packageDocumentation
- */
-import type { EntityRow } from '@almadar/core';
-import type { DataContext, DataResolution } from '../types/renderer-types';
-/**
- * Resolve entity data from available sources.
- *
- * Priority:
- * 1. fetchedData (from server response) - highest priority
- * 2. entityStore (Builder mock data)
- * 3. Empty array (fallback)
- *
- * @param entityName - Name of the entity to resolve data for
- * @param context - Data context with available sources
- * @returns Resolved data with loading state
- *
- * @example
- * ```typescript
- * const { data, loading } = resolveEntityData('Task', {
- *   fetchedData: response.data,
- *   entityStore: mockStore
- * });
- * ```
- */
-export declare function resolveEntityData(entityName: string, context: DataContext): DataResolution;
-/**
- * Resolve entity data with query filtering.
- *
- * Applies query singleton filters if available.
- *
- * @param entityName - Name of the entity
- * @param queryRef - Optional query reference for filtering
- * @param context - Data context
- * @returns Filtered resolved data
- */
-export declare function resolveEntityDataWithQuery(entityName: string, queryRef: string | undefined, context: DataContext): DataResolution;
-/**
- * Get a single entity record by ID.
- */
-export declare function resolveEntityById(entityName: string, id: string | number, context: DataContext): EntityRow | null;
-/**
- * Check if any entities exist for a given entity name.
- */
-export declare function hasEntities(entityName: string, context: DataContext): boolean;

package/dist/lib/debug.d.ts

@@ -1,36 +0,0 @@
-/**
- * Legacy debug helpers, now routed through `@almadar/logger`.
- *
- * The variadic `debug(...args)` shape is preserved for the many existing
- * call sites (Form.tsx, RelationSelect.tsx, game helpers, etc.), but the
- * gate is no longer a separate localStorage check — every helper here
- * runs through the same priority/namespace gate the rest of the codebase
- * uses. `setLogLevel('WARN')` silences them. `globalThis.__ALMADAR_DEBUG__`
- * filters them by namespace.
- *
- * Namespace: `almadar:ui:debug` (plus per-area suffixes for input,
- * collision, physics, game-state).
- */
-export declare function isDebugEnabled(): boolean;
-/**
- * Variadic legacy debug. The first arg is the message; the rest is
- * stringified into the LogData. Routes through the shared gate.
- */
-export declare function debug(...args: unknown[]): void;
-export declare function debugGroup(label: string): void;
-export declare function debugGroupEnd(): void;
-export declare function debugWarn(...args: unknown[]): void;
-export declare function debugError(...args: unknown[]): void;
-export declare function debugTable(data: unknown): void;
-export declare function debugTime(label: string): void;
-export declare function debugTimeEnd(label: string): void;
-export declare function debugInput(inputType: string, data: unknown): void;
-export declare function debugCollision(entityA: {
-    id?: string;
-    type?: string;
-}, entityB: {
-    id?: string;
-    type?: string;
-}, details?: unknown): void;
-export declare function debugPhysics(entityId: string, physics: unknown): void;
-export declare function debugGameState(stateName: string, value: unknown): void;

package/dist/lib/debugRegistry.d.ts

@@ -1,30 +0,0 @@
-/**
- * Debug Registry - Central event log for debugging
- *
- * @packageDocumentation
- */
-import type { FieldValue } from '@almadar/core';
-export type DebugEventType = 'state-change' | 'event-fired' | 'effect-executed' | 'guard-evaluated' | 'error' | 'warning' | 'info';
-export interface DebugEvent {
-    id: string;
-    type: DebugEventType;
-    source: string;
-    message: string;
-    data?: Record<string, FieldValue>;
-    timestamp: number;
-}
-type ChangeListener = () => void;
-export declare function logDebugEvent(type: DebugEventType, source: string, message: string, data?: Record<string, FieldValue>): void;
-export declare function logStateChange(source: string, from: string, to: string, event?: string): void;
-export declare function logEventFired(source: string, eventName: string, payload?: FieldValue): void;
-export declare function logEffectExecuted(source: string, effectType: string, details?: FieldValue): void;
-export declare function logError(source: string, message: string, error?: Error | null): void;
-export declare function logWarning(source: string, message: string, data?: Record<string, FieldValue>): void;
-export declare function logInfo(source: string, message: string, data?: Record<string, FieldValue>): void;
-export declare function getDebugEvents(): DebugEvent[];
-export declare function getRecentEvents(count: number): DebugEvent[];
-export declare function getEventsByType(type: DebugEventType): DebugEvent[];
-export declare function getEventsBySource(source: string): DebugEvent[];
-export declare function subscribeToDebugEvents(listener: ChangeListener): () => void;
-export declare function clearDebugEvents(): void;
-export {};

package/dist/lib/debugUtils.d.ts

@@ -1,27 +0,0 @@
-/**
- * Debug Utilities - Functions for toggling and checking debug mode
- *
- * @packageDocumentation
- */
-type DebugToggleListener = (enabled: boolean) => void;
-/**
- * Check if debug mode is enabled
- */
-export declare function isDebugEnabled(): boolean;
-/**
- * Enable or disable debug mode
- */
-export declare function setDebugEnabled(enabled: boolean): void;
-/**
- * Toggle debug mode
- */
-export declare function toggleDebug(): boolean;
-/**
- * Subscribe to debug mode changes
- */
-export declare function onDebugToggle(listener: DebugToggleListener): () => void;
-/**
- * Initialize debug mode from keyboard shortcut (Ctrl+Shift+D)
- */
-export declare function initDebugShortcut(): () => void;
-export {};

package/dist/lib/embedded-traits.d.ts

@@ -1,39 +0,0 @@
-/**
- * Embed-aware slot routing — static analysis pass.
- *
- * Walks every trait's `transitions[].effects` looking for `render-ui`
- * patterns whose tree contains `@trait.<Name>` string literals. Returns
- * the flat set of trait names that are referenced this way by some
- * sibling layout.
- *
- * Used by `<OrbPreview>` to route `applyServerEffects` — when an
- * embedded trait's render-ui effect arrives, the runtime updates that
- * trait's per-trait sidecar (`traitIndexRef`) only and skips the slot
- * write. The sibling layout owns the slot and embeds the trait's frame
- * via `<TraitFrame>`. Mirrors the compiled-path codegen which inlines
- * the atom views as JSX inside the layout's pattern, never having them
- * write a shared slot.
- *
- * The walker is a structural twin of
- * `packages/almadar-runtime/src/resolver/reference-resolver.ts`'s
- * `renameEventsInRenderUiConfig` — same recursive pattern shape, just
- * collecting `@trait.X` substrings instead of renaming events.
- *
- * @packageDocumentation
- */
-import type { OrbitalSchema, ResolvedTrait } from '@almadar/core';
-/**
- * Collect the `@trait.X` names referenced by a single resolved trait's
- * render-ui effects (transitions + initial + ticks). Used to pull embed-routed
- * sibling traits into a page's state-machine binding set so their own state
- * machines register + subscribe (otherwise their fetch-success is never heard).
- */
-export declare function collectTraitRefsFromResolvedTrait(trait: ResolvedTrait): Set<string>;
-/**
- * Build the flat set of trait names that are referenced via `@trait.X`
- * by at least one trait's render-ui in the resolved schema.
- *
- * Safe to call on the resolved (post-inline) schema. Memoize by
- * reference at the call site.
- */
-export declare function collectEmbeddedTraits(schema: OrbitalSchema | undefined | null): ReadonlySet<string>;

package/dist/lib/entityDebug.d.ts

@@ -1,39 +0,0 @@
-/**
- * Entity Debug - Provides entity state snapshots for debugging
- *
- * @packageDocumentation
- */
-import type { FieldValue, EntityRow } from '@almadar/core';
-export interface EntityState {
-    id: string;
-    type: string;
-    fields: Record<string, FieldValue>;
-    lastUpdated: number;
-}
-export interface RuntimeEntity {
-    id: string;
-    type: string;
-    data: Record<string, FieldValue>;
-}
-export interface PersistentEntityInfo {
-    loaded: boolean;
-    count: number;
-}
-export interface EntitySnapshot {
-    entities: EntityState[];
-    timestamp: number;
-    totalCount: number;
-    /** Singleton entities by name */
-    singletons: Record<string, EntityRow>;
-    /** Runtime entities (in-memory) */
-    runtime: RuntimeEntity[];
-    /** Persistent entities info by type */
-    persistent: Record<string, PersistentEntityInfo>;
-}
-type EntityProvider = () => EntityState[];
-export declare function setEntityProvider(provider: EntityProvider): void;
-export declare function clearEntityProvider(): void;
-export declare function getEntitySnapshot(): EntitySnapshot | null;
-export declare function getEntityById(id: string): EntityState | undefined;
-export declare function getEntitiesByType(type: string): EntityState[];
-export {};

package/dist/lib/fn-form-lambda.d.ts

@@ -1,27 +0,0 @@
-/**
- * fn-form lambda → React render-prop conversion at the render-ui
- * dispatch site, before the pattern lands in `useUISlots`.
- *
- * `.lolo` authors per-row render functions for DataGrid/DataList/Carousel
- * as `["fn", argName, body]`. By converting them to functions here,
- * SlotContent's props match what consumer components expect (children =
- * real function) without depending on a render-time conversion pass.
- *
- * @packageDocumentation
- */
-import type { EntityRow, RenderItemLambda } from "@almadar/core";
-import type { SlotProps, SlotPropValue } from "../hooks/useUISlots";
-export declare function isFnFormLambda(value: SlotPropValue): value is RenderItemLambda;
-/**
- * Walk a pattern body replacing every `@<argName>.path` string with the
- * value at `path` of `arg`. Mirrors the compiler's inline substitution
- * for `renderItem` lambda bodies.
- */
-export declare function resolveLambdaBindings(body: SlotPropValue, params: readonly string[], item: EntityRow, index: number): SlotPropValue;
-/**
- * Walk a pattern's props (and recursively their nested children),
- * converting every fn-form lambda value into a React render-prop
- * function. Pure on inputs without lambdas: returns the props object
- * unchanged by reference.
- */
-export declare function convertFnFormLambdasInProps(props: SlotProps): SlotProps;