@almadar/ui 2.14.0 → 2.15.1

package/dist/runtime/TraitProvider.d.ts

@@ -0,0 +1,52 @@
+/**
+ * TraitProvider Component
+ *
+ * Provides trait state machines to child components via React context.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { ResolvedTrait, ResolvedTraitBinding, ResolvedEntity } from './types';
+export interface TraitInstance {
+    /** Trait name */
+    name: string;
+    /** Current state */
+    currentState: string;
+    /** Available events (can be triggered) */
+    availableEvents: string[];
+    /** Dispatch an event to the state machine */
+    dispatch: (eventKey: string, payload?: Record<string, unknown>) => void;
+    /** Check if an event can be dispatched */
+    canDispatch: (eventKey: string) => boolean;
+    /** Get the full trait definition */
+    trait: ResolvedTrait;
+}
+export interface TraitContextValue {
+    /** All trait instances on this page */
+    traits: Map<string, TraitInstance>;
+    /** Get a trait instance by name */
+    getTrait: (name: string) => TraitInstance | undefined;
+    /** Dispatch an event to a specific trait */
+    dispatchToTrait: (traitName: string, eventKey: string, payload?: Record<string, unknown>) => void;
+    /** Check if an event can be dispatched to a trait */
+    canDispatch: (traitName: string, eventKey: string) => boolean;
+}
+export declare const TraitContext: React.Context<TraitContextValue | null>;
+export interface TraitProviderProps {
+    /** Trait bindings for this page */
+    traits: ResolvedTraitBinding[];
+    /** Entity map for context */
+    entities: Map<string, ResolvedEntity>;
+    /** Children to render */
+    children: React.ReactNode;
+}
+export declare function TraitProvider({ traits: traitBindings, children, }: TraitProviderProps): React.ReactElement;
+/**
+ * Access the trait context from within the TraitProvider.
+ */
+export declare function useTraitContext(): TraitContextValue;
+/**
+ * Access a specific trait instance.
+ */
+export declare function useTrait(traitName: string): TraitInstance | undefined;
+export default TraitProvider;

package/dist/runtime/createClientEffectHandlers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Client Effect Handlers Factory
+ *
+ * Creates the standard effect handler set for client-side trait execution.
+ *
+ * @packageDocumentation
+ */
+import type { EffectHandlers } from '@almadar/runtime';
+export interface ClientEventBus {
+    emit: (type: string, payload?: Record<string, unknown>) => void;
+}
+export interface SlotSetter {
+    addPattern: (slot: string, pattern: unknown, props?: Record<string, unknown>) => void;
+    clearSlot: (slot: string) => void;
+}
+export interface CreateClientEffectHandlersOptions {
+    eventBus: ClientEventBus;
+    slotSetter: SlotSetter;
+    navigate?: (path: string, params?: Record<string, unknown>) => void;
+    notify?: (message: string, type: 'success' | 'error' | 'warning' | 'info') => void;
+    enrichPattern?: (pattern: unknown) => unknown;
+}
+export declare function createClientEffectHandlers(options: CreateClientEffectHandlersOptions): EffectHandlers;

package/dist/runtime/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @almadar/ui Runtime
+ *
+ * Client-side runtime components for rendering Orbital schemas.
+ * Provides trait state machines, slot management, and pattern rendering.
+ *
+ * @packageDocumentation
+ */
+export { useTraitStateMachine, type UseTraitStateMachineOptions, type TraitStateMachineResult } from './useTraitStateMachine';
+export { useResolvedSchema, type ResolvedSchemaResult, clearSchemaCache } from './useResolvedSchema';
+export { EntitySchemaProvider, useEntitySchema, useEntityDefinition, type EntitySchemaContextValue, type EntitySchemaProviderProps, } from './EntitySchemaContext';
+export { TraitProvider, TraitContext, useTraitContext, useTrait, type TraitContextValue, type TraitInstance, type TraitProviderProps, } from './TraitProvider';
+export { SlotsProvider, useSlots, useSlotContent, useSlotsActions, type SlotsState, type SlotState, type SlotPatternEntry, type SlotSource, type SlotsActions, type SlotsProviderProps, } from './ui/SlotsContext';
+export { createClientEffectHandlers, type ClientEventBus, type SlotSetter, type CreateClientEffectHandlersOptions, } from './createClientEffectHandlers';
+export type { ResolvedTraitBinding, ResolvedTrait, ResolvedEntity, ResolvedPage, ResolvedIR, } from './types';

package/dist/runtime/index.js

@@ -1,15 +1,15 @@
 import '../chunk-IRIGCHP4.js';
 import '../chunk-N7MVUW4R.js';
 import '../chunk-3HJHHULT.js';
-import { useFetchedDataContext } from '../chunk-M7MOIE46.js';
-import '../chunk-SKWPSQHQ.js';
+import { useFetchedDataContext } from '../chunk-2KQPOTRM.js';
+import '../chunk-FP3PNF7I.js';
 import '../chunk-4N3BAPDB.js';
 import '../chunk-DKQN5FVU.js';
 import '../chunk-QU2X55WH.js';
 import { useEventBus } from '../chunk-YXZM3WCF.js';
 import '../chunk-3JGAROCW.js';
-import { registerTrait, unregisterTrait, updateTraitState, recordTransition } from '../chunk-XL7WB2O5.js';
 import '../chunk-2XXSUIOK.js';
+import { registerTrait, unregisterTrait, updateTraitState, recordTransition } from '../chunk-XL7WB2O5.js';
 import '../chunk-K2D5D3WK.js';
 import '../chunk-PKBMQBKP.js';
 import { createContext, useMemo, useContext, useState, useRef, useEffect, useCallback } from 'react';

package/dist/runtime/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * OrbitalRuntime Types
+ *
+ * Re-exports IR types from @almadar/core.
+ * This ensures runtime uses the same types as the compiler.
+ *
+ * @packageDocumentation
+ */
+export type { TransitionFrom, ResolvedField, ResolvedEntity, ResolvedEntityBinding, ResolvedTraitState, ResolvedTraitEvent, ResolvedTraitTransition, ResolvedTraitGuard, ResolvedTraitTick, ResolvedTraitListener, ResolvedTraitDataEntity, ResolvedTraitUIBinding, ResolvedTrait, ResolvedTraitBinding, ResolvedPattern, ResolvedSectionEvent, ResolvedSection, ResolvedNavigation, ResolvedPage, ResolvedIR, } from '@almadar/core';
+export { createEmptyResolvedTrait, createEmptyResolvedPage, createResolvedField, inferTsType, isResolvedIR, } from '@almadar/core';

package/dist/runtime/ui/SlotsContext.d.ts

@@ -0,0 +1,71 @@
+/**
+ * SlotsContext - React state-based UI slot management
+ *
+ * Replaces the UIEnvironment observable store with plain React state.
+ * No stacking logic, no priority system, no source tracking for arbitration.
+ *
+ * A transition's effects produce the COMPLETE content for each slot.
+ * The runtime collects all render-ui effects from a transition, groups by slot,
+ * and sets each slot's patterns array in one atomic operation.
+ *
+ * @packageDocumentation
+ */
+import React from 'react';
+import type { PatternConfig } from '@almadar/core';
+import type { ResolvedTrait } from '@almadar/core';
+/** A single pattern entry in a slot */
+export interface SlotPatternEntry {
+    pattern: PatternConfig;
+    props: Record<string, unknown>;
+}
+/**
+ * Source metadata for a rendered slot.
+ * Used by the Slot Inspector to show debug info.
+ */
+export interface SlotSource {
+    trait: string;
+    state: string;
+    transition: string;
+    effects?: unknown[];
+    /** Full trait definition for inspector */
+    traitDefinition?: ResolvedTrait;
+}
+/** Full state of a single slot */
+export interface SlotState {
+    patterns: SlotPatternEntry[];
+    source?: SlotSource;
+}
+/** All slots state */
+export type SlotsState = Record<string, SlotState>;
+/** Mutation functions for slots (stable references, won't trigger re-renders) */
+export interface SlotsActions {
+    /** Set all patterns for a slot atomically (replaces previous content) */
+    setSlotPatterns: (slot: string, patterns: SlotPatternEntry[], source?: SlotSource) => void;
+    /** Clear a single slot */
+    clearSlot: (slot: string) => void;
+    /** Clear all slots */
+    clearAllSlots: () => void;
+}
+export interface SlotsProviderProps {
+    children: React.ReactNode;
+}
+/**
+ * SlotsProvider - Manages UI slot state via React useState.
+ *
+ * Replaces UIEnvironmentProvider. No observable store, no stacking logic.
+ * Slots are set atomically per transition — React diffs and re-renders.
+ */
+export declare function SlotsProvider({ children }: SlotsProviderProps): React.ReactElement;
+/**
+ * Get the full slots state. Triggers re-render on ANY slot change.
+ * Prefer useSlotContent(name) for individual slot subscriptions.
+ */
+export declare function useSlots(): SlotsState;
+/**
+ * Get content for a specific slot. Returns null if slot is empty.
+ */
+export declare function useSlotContent(slotName: string): SlotState | null;
+/**
+ * Get slot mutation actions. Stable reference — never triggers re-renders.
+ */
+export declare function useSlotsActions(): SlotsActions;

package/dist/runtime/useResolvedSchema.d.ts

@@ -0,0 +1,45 @@
+/**
+ * useResolvedSchema Hook
+ *
+ * Resolves OrbitalSchema to IR for the OrbitalRuntime.
+ * Uses the shared resolver to ensure consistency with the compiler.
+ *
+ * TRAIT-DRIVEN ARCHITECTURE:
+ * - Pages have traits, NOT sections
+ * - UI is produced by trait effects (render_ui)
+ * - No backwards compatibility with legacy formats
+ *
+ * @packageDocumentation
+ */
+import type { OrbitalSchema } from '@almadar/core';
+import type { ResolvedIR, ResolvedPage, ResolvedTrait, ResolvedEntity, ResolvedTraitBinding } from './types';
+export interface ResolvedSchemaResult {
+    /** The resolved page (or undefined if not found) */
+    page: ResolvedPage | undefined;
+    /** Trait bindings for this page */
+    traits: ResolvedTraitBinding[];
+    /** Entities used by this page */
+    entities: Map<string, ResolvedEntity>;
+    /** All entities from schema */
+    allEntities: Map<string, ResolvedEntity>;
+    /** All resolved traits */
+    allTraits: Map<string, ResolvedTrait>;
+    /** Loading state */
+    loading: boolean;
+    /** Error message if resolution failed */
+    error: string | null;
+    /** Full IR (for debugging) */
+    ir: ResolvedIR | null;
+}
+/**
+ * Hook to resolve an OrbitalSchema to IR.
+ *
+ * @param schema - The OrbitalSchema to resolve
+ * @param pageName - Optional page name (defaults to first page or initial page)
+ * @returns Resolved schema data including page, traits, and entities
+ */
+export declare function useResolvedSchema(schema: OrbitalSchema | null | undefined, pageName?: string): ResolvedSchemaResult;
+/**
+ * Clear the schema resolution cache
+ */
+export declare function clearSchemaCache(): void;

package/dist/runtime/useTraitStateMachine.d.ts

@@ -0,0 +1,48 @@
+/**
+ * useTraitStateMachine Hook
+ *
+ * Manages trait state machines with event-driven transitions.
+ * Subscribes to eventBus events and executes effects when transitions occur.
+ *
+ * CONSOLIDATED RUNTIME:
+ * - Uses StateMachineManager from @almadar/runtime for state management
+ * - Uses the same state machine logic as the server runtime (OrbitalServerRuntime)
+ * - Ensures consistent behavior between client preview and server execution
+ *
+ * SLOT MANAGEMENT:
+ * - Collects all render-ui effects from a transition, groups by slot
+ * - Sets each slot's patterns array atomically via SlotsActions
+ * - No stacking logic, no priority system — transition produces complete slot content
+ *
+ * @packageDocumentation
+ */
+import { type TraitState } from '@almadar/runtime';
+import type { ResolvedTraitBinding } from './types';
+import type { SlotsActions } from './ui/SlotsContext';
+export type { TraitState };
+export interface TraitStateMachineResult {
+    /** Current state for each trait */
+    traitStates: Map<string, TraitState>;
+    /** Send an event to trigger a transition */
+    sendEvent: (eventKey: string, payload?: Record<string, unknown>) => void;
+    /** Get current state for a specific trait */
+    getTraitState: (traitName: string) => TraitState | undefined;
+    /** Check if a trait can handle an event from its current state */
+    canHandleEvent: (traitName: string, eventKey: string) => boolean;
+}
+export interface UseTraitStateMachineOptions {
+    /** Callback invoked after each event is processed (for server forwarding) */
+    onEventProcessed?: (eventKey: string, payload?: Record<string, unknown>) => void;
+    /** Router navigate function for navigate effects */
+    navigate?: (path: string, params?: Record<string, unknown>) => void;
+    /** Notification function for notify effects */
+    notify?: (message: string, type?: 'success' | 'error' | 'warning' | 'info') => void;
+}
+/**
+ * useTraitStateMachine - Manages state machines for multiple traits
+ *
+ * Uses the shared StateMachineManager for consistent behavior with server runtime.
+ * Collects render-ui effects per transition and sets slot content atomically.
+ */
+export declare function useTraitStateMachine(traitBindings: ResolvedTraitBinding[], slotsActions: SlotsActions, options?: UseTraitStateMachineOptions): TraitStateMachineResult;
+export default useTraitStateMachine;

package/dist/scripts/generate-design-system.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Unified Design System Generator
+ *
+ * Generates a complete client-specific design system from an .orb schema:
+ * 1. Generates custom theme CSS
+ * 2. Suggests domain-specific components
+ * 3. Generates component stubs
+ * 4. Builds Storybook documentation
+ * 5. Exports static design system package
+ */
+interface GeneratorOptions {
+    schemaPath: string;
+    outputDir: string;
+    clientName?: string;
+    buildStorybook?: boolean;
+    generateComponents?: boolean;
+    clientOnly?: boolean;
+}
+interface GeneratorResult {
+    themePath: string;
+    suggestedComponents: number;
+    generatedComponents: number;
+    storybookPath?: string;
+}
+/**
+ * Main generator function
+ */
+export declare function generateDesignSystem(options: GeneratorOptions): Promise<GeneratorResult>;
+export {};

package/dist/scripts/generate-theme-from-schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Theme Generator from OrbitalSchema
+ *
+ * Analyzes an .orb schema file and generates a client-specific theme CSS file.
+ * The theme is derived from the domain, entity names, and any explicit style hints.
+ */
+/**
+ * Main function to generate theme from schema
+ */
+export declare function generateThemeFromSchema(schemaPath: string, outputPath?: string): string;

package/dist/scripts/generate.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env npx tsx
+/**
+ * Design System Generator
+ *
+ * Reads a config file from a project folder and outputs a customized
+ * design system to that project.
+ *
+ * Usage:
+ *   npx tsx generate.ts --config <path-to-config>
+ *   npm run generate -- --config ../../projects/winning-11/design-system.config.ts
+ */
+export {};

package/dist/scripts/suggest-components.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Component Suggester
+ *
+ * Analyzes an .orb schema and suggests domain-specific components
+ * that should be added to the design system for this client.
+ */
+interface ComponentSuggestion {
+    name: string;
+    description: string;
+    category: 'atoms' | 'molecules' | 'organisms' | 'templates';
+    props: Array<{
+        name: string;
+        type: string;
+        description: string;
+    }>;
+    reasoning: string;
+    priority: 'high' | 'medium' | 'low';
+    codeSketch: string;
+}
+/**
+ * Suggest components based on schema analysis
+ */
+export declare function suggestComponents(schemaPath: string): {
+    domains: string[];
+    suggestions: ComponentSuggestion[];
+};
+/**
+ * Generate component stubs from suggestions
+ */
+export declare function generateComponentStubs(suggestions: ComponentSuggestion[], outputDir: string): void;
+export {};

package/dist/scripts/types.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Design System Generator Types
+ *
+ * Input configuration for generating a customized design system
+ * that gets output to a project folder.
+ */
+export interface DesignSystemConfig {
+    /** Project/client name (e.g., "winning-11") */
+    projectName: string;
+    /** Output directory for the generated design system */
+    outputDir: string;
+    /** Theme configuration */
+    theme: ThemeConfig;
+    /** Custom components not in the standard library */
+    customComponents?: CustomComponentConfig[];
+    /** Which standard components to include (default: all) */
+    includeComponents?: ComponentFilter;
+    /** Storybook configuration */
+    storybook?: StorybookConfig;
+}
+export interface ThemeConfig {
+    /** Theme name (used in data-design-theme attribute) */
+    name: string;
+    /** Theme display name for documentation */
+    displayName?: string;
+    /** Design metaphor/style description */
+    metaphor?: string;
+    /** Color palette */
+    colors: {
+        primary: string;
+        primaryHover?: string;
+        primaryForeground?: string;
+        secondary: string;
+        secondaryHover?: string;
+        secondaryForeground?: string;
+        accent: string;
+        accentForeground?: string;
+        muted: string;
+        mutedForeground?: string;
+        background: string;
+        foreground: string;
+        card?: string;
+        cardForeground?: string;
+        border: string;
+        input?: string;
+        ring?: string;
+        /** Semantic colors */
+        success?: string;
+        warning?: string;
+        error?: string;
+        info?: string;
+        /** Custom domain-specific colors */
+        custom?: Record<string, string>;
+    };
+    /** Shadow style preset or custom shadows */
+    shadows?: 'soft-organic' | 'minimal' | 'corporate' | 'playful' | 'dramatic' | 'soft' | ShadowConfig;
+    /** Border radius preset or custom radii */
+    radius?: 'organic' | 'gentle' | 'sharp' | 'rounded' | 'friendly' | RadiusConfig;
+    /** Typography overrides */
+    typography?: {
+        fontFamily?: string;
+        fontWeightNormal?: number;
+        fontWeightMedium?: number;
+        fontWeightBold?: number;
+    };
+    /** Dark mode variant */
+    darkMode?: Partial<ThemeConfig['colors']>;
+}
+export interface ShadowConfig {
+    main: string;
+    sm: string;
+    lg: string;
+    hover: string;
+    inner?: string;
+    active?: string;
+}
+export interface RadiusConfig {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+}
+export interface CustomComponentConfig {
+    /** Component name (PascalCase) */
+    name: string;
+    /** Component description */
+    description: string;
+    /** Category in the component library */
+    category: 'atoms' | 'molecules' | 'organisms' | 'templates';
+    /** Component props */
+    props: ComponentProp[];
+    /** Why this component is needed */
+    reasoning?: string;
+    /** Priority for implementation */
+    priority?: 'high' | 'medium' | 'low';
+    /** Optional implementation code */
+    implementation?: string;
+    /** Optional Storybook stories */
+    stories?: string;
+}
+export interface ComponentProp {
+    name: string;
+    type: string;
+    description: string;
+    required?: boolean;
+    defaultValue?: string;
+}
+export interface ComponentFilter {
+    /** Include all components (default: true) */
+    all?: boolean;
+    /** Specific categories to include */
+    categories?: ('atoms' | 'molecules' | 'organisms' | 'templates')[];
+    /** Specific components to include (by name) */
+    include?: string[];
+    /** Specific components to exclude (by name) */
+    exclude?: string[];
+}
+export interface StorybookConfig {
+    /** Build Storybook (default: true) */
+    build?: boolean;
+    /** Include Storybook source in output (default: true) */
+    includeSource?: boolean;
+    /** Custom Storybook title */
+    title?: string;
+}
+/**
+ * Example configuration for Winning-11 (Garden theme)
+ */
+export declare const WINNING_11_CONFIG: DesignSystemConfig;

package/dist/stores/entityStore.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Entity Store
+ *
+ * Simple module-level store for runtime entities.
+ * No providers needed - hooks import and use directly.
+ *
+ * NOTE: Mutations create new Map instances to trigger React rerenders
+ * when using useSyncExternalStore.
+ */
+import { type EntityFilterValue, type FilterOperator, type EntityFilters, applyFilters, createFilter } from './filtering';
+export type { EntityFilterValue, FilterOperator, EntityFilters };
+export { applyFilters, createFilter };
+export interface Entity {
+    id: string;
+    type: string;
+    [key: string]: unknown;
+}
+type Listener = () => void;
+/**
+ * Subscribe to store changes
+ */
+export declare function subscribe(listener: Listener): () => void;
+/**
+ * Get all entities
+ */
+export declare function getEntities(): Map<string, Entity>;
+/**
+ * Get entity by ID
+ */
+export declare function getEntity(id: string): Entity | undefined;
+/**
+ * Get entities by type
+ */
+export declare function getByType(type: string | string[]): Entity[];
+/**
+ * Get all entities as array
+ */
+export declare function getAllEntities(): Entity[];
+/**
+ * Get singleton entity by type (first of that type)
+ */
+export declare function getSingleton(type: string): Entity | undefined;
+/**
+ * Spawn a new entity
+ */
+export declare function spawnEntity(config: {
+    type: string;
+    id?: string;
+    [key: string]: unknown;
+}): string;
+/**
+ * Update an entity
+ */
+export declare function updateEntity(id: string, updates: Partial<Entity>): void;
+/**
+ * Update singleton entity by type
+ */
+export declare function updateSingleton(type: string, updates: Partial<Entity>): void;
+/**
+ * Remove an entity
+ */
+export declare function removeEntity(id: string): void;
+/**
+ * Clear all entities
+ */
+export declare function clearEntities(): void;
+/**
+ * Set a filter for an entity type
+ * @param entityType - The entity type to filter (e.g., "Player", "Enemy")
+ * @param field - The filter key (e.g., 'status' or 'date_from')
+ * @param value - The filter value
+ * @param operator - The comparison operator
+ * @param targetField - The actual record field to compare (defaults to field)
+ */
+export declare function setFilter(entityType: string, field: string, value: unknown, operator?: FilterOperator, targetField?: string): void;
+/**
+ * Clear a specific filter
+ */
+export declare function clearFilter(entityType: string, field: string): void;
+/**
+ * Clear all filters for an entity type
+ */
+export declare function clearAllFilters(entityType: string): void;
+/**
+ * Get active filters for an entity type
+ */
+export declare function getFilters(entityType: string): EntityFilters;
+/**
+ * Get entities by type with optional filtering
+ */
+export declare function getByTypeFiltered(type: string | string[]): Entity[];
+/**
+ * Get snapshot for React useSyncExternalStore
+ */
+export declare function getSnapshot(): Map<string, Entity>;
+/**
+ * Get filter snapshot for React useSyncExternalStore
+ */
+export declare function getFilterSnapshot(): Map<string, EntityFilters>;

package/dist/stores/filtering.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Entity Filtering Utilities
+ *
+ * Provides filter types and utility functions for filtering entity records.
+ * Used by EntityStore and can be imported by runtime preview.
+ */
+/** Filter value for a single field (entity filtering) */
+export interface EntityFilterValue {
+    /** The field key (may include suffix like _from, _to for date ranges) */
+    field: string;
+    /** The actual record field to compare against (defaults to field if not specified) */
+    targetField?: string;
+    value: unknown;
+    /** Comparison operator for filtering
+     * - eq: exact match (default)
+     * - contains: substring match for strings
+     * - in: value is in array
+     * - date_eq: same date (ignoring time)
+     * - date_gte: on or after date
+     * - date_lte: on or before date
+     */
+    operator?: FilterOperator;
+}
+/** Operator type for filter */
+export type FilterOperator = 'eq' | 'contains' | 'in' | 'date_eq' | 'date_gte' | 'date_lte' | 'search';
+/** Filter state for an entity - Map of field key to filter value */
+export type EntityFilters = Map<string, EntityFilterValue>;
+/** Record type that can be filtered */
+export interface FilterableRecord {
+    id: string;
+    [key: string]: unknown;
+}
+/**
+ * Extract date part from ISO string or Date object.
+ * Returns format: "YYYY-MM-DD"
+ */
+export declare function getDateString(value: unknown): string | null;
+/**
+ * Apply a single filter to check if a record matches.
+ * Returns true if the record passes the filter.
+ */
+export declare function matchesFilter(record: FilterableRecord, filter: EntityFilterValue): boolean;
+/**
+ * Apply all filters to a list of records.
+ * Returns only records that match ALL filters.
+ */
+export declare function applyFilters<T extends FilterableRecord>(records: T[], entityFilters: EntityFilters): T[];
+/**
+ * Create a filter value with proper defaults.
+ */
+export declare function createFilter(field: string, value: unknown, operator?: FilterOperator, targetField?: string): EntityFilterValue;

package/dist/stores/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Stores
+ *
+ * Module-level state management for entities and filtering.
+ */
+export * from './filtering';
+export * from './entityStore';

package/dist/tsup.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("tsup").Options | import("tsup").Options[] | ((overrideOptions: import("tsup").Options) => import("tsup").Options | import("tsup").Options[] | Promise<import("tsup").Options | import("tsup").Options[]>);
+export default _default;

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;