@alwatr/flux 9.26.0 → 9.28.0

package/README.md

@@ -65,15 +65,15 @@ declare module '@alwatr/flux' {
 }
 
 // Get compile-time safety everywhere — handler receives the full Action object
-onAction('ui_add_to_cart', (action) => {
+actionService.on('ui_add_to_cart', (action) => {
   // action.payload is typed as {productId: number; qty: number}
   cartService.add(action.payload.productId, action.payload.qty);
   // action.context is the nearest [action-context] ancestor value (or undefined)
   console.log(action.context); // e.g. 'product-list'
 });
 
-dispatchAction({type: 'ui_add_to_cart', payload: {productId: 42, qty: 1}}); // ✅
-dispatchAction({type: 'ui_add_to_cart', payload: 'wrong'}); // ❌ Compile error
+actionService.dispatch({type: 'ui_add_to_cart', payload: {productId: 42, qty: 1}}); // ✅
+actionService.dispatch({type: 'ui_add_to_cart', payload: 'wrong'}); // ❌ Compile error
 ```
 
 ---
@@ -173,7 +173,7 @@ Connect DOM events to typed actions without writing JavaScript. Wrap elements in
 
 ```typescript
 // Handler receives the full Action object — payload, context, and meta together
-onAction('ui_slider_change', (action) => {
+actionService.on('ui_slider_change', (action) => {
   if (action.context === 'volume') audioService.setVolume(Number(action.payload));
   if (action.context === 'brightness') displayService.setBrightness(Number(action.payload));
 });
@@ -377,12 +377,71 @@ createEffect({
 });
 ```
 
+### 🤖 **Finite State Machine (FSM) & Actor Model**
+
+Flux natively aggregates `@alwatr/fsm` to eliminate ad-hoc state variables, boolean flags, and race conditions. Instead of writing unpredictable, disjointed spaghetti code, you model your application's lifecycle as a **declarative, type-safe statechart**.
+
+```typescript
+import {createFsmService} from '@alwatr/flux';
+import type {StateMachineConfig} from '@alwatr/flux';
+
+// 1. Define strict Union Types for compile-time safety
+type FetchState = 'idle' | 'loading' | 'success' | 'failed';
+type FetchEvent = {type: 'FETCH'} | {type: 'SUCCESS'} | {type: 'ERROR'};
+interface FetchContext { retries: number }
+
+// 2. Configure the machine declaratively
+const fetchConfig: StateMachineConfig<FetchState, FetchEvent, FetchContext> = {
+  name: 'api-fetch-lifecycle',
+  initial: 'idle',
+  context: {retries: 0},
+  states: {
+    idle: {
+      on: { FETCH: { target: 'loading' } },
+    },
+    loading: {
+      on: {
+        SUCCESS: { target: 'success', assigners: [({context}) => ({...context, retries: 0})] },
+        ERROR: [
+          // Guard evaluates condition; first matching transition branch is chosen
+          { target: 'loading', guard: ({context}) => context.retries < 3, assigners: [({context}) => ({...context, retries: context.retries + 1})] },
+          { target: 'failed' }
+        ],
+      },
+    },
+    success: {},
+    failed: {
+      on: { FETCH: { target: 'loading', assigners: [({context}) => ({...context, retries: 0})] } },
+    },
+  },
+};
+
+// 3. Create the reactive service (FSM Service instance)
+export const fetchService = createFsmService(fetchConfig);
+
+// 4. Surgical Reactivity: Subscribe to state changes in the view layer
+fetchService.stateSignal.subscribe((state) => {
+  console.log(`Current State: ${state.name}, Retries: ${state.context.retries}`);
+});
+
+// 5. Dispatch events to trigger atomic transitions
+fetchService.dispatch({type: 'FETCH'});
+```
+
+#### 🛡️ Why is Flux FSM a Game-Changer?
+
+- **Eliminates Race Conditions (Run-to-Completion)**: FSM events are queued and processed sequentially. Async callbacks from concurrent network fetches never overwrite or corrupt the state.
+- **Prevents State Explosion**: Ad-hoc booleans (like `isLoading`, `isError`, `hasFetched`) scale exponentially (e.g., 5 booleans = 32 states). FSM forces you to define a finite set of **valid states and transitions** (e.g., exactly 4 states).
+- **Embedded Actor Architecture**: Statecharts can spawn long-running, asynchronous, isolated lifecycles called **Actors** on state entry, complete with auto-cleanup on exit.
+- **Declarative Synergy**: The FSM's internal `stateSignal` integrates flawlessly with the `@alwatr/flux` unidirectional loop, feeding directly into your rendering template.
+
 ---
 
 ## 🏗️ Architecture Overview
 
-Flux implements a **strict layered architecture** where each layer has a single responsibility:
+Flux implements a **strict layered architecture** where each layer has a single responsibility. It supports both standard Unidirectional Data Flow (UDF) and the decentralized **Actor Model** (where components/features behave as isolated micro-services powered by FSMs).
 
+### 1. Unidirectional Data Flow (UDF) Layering
 ```
 ┌───────────────────────────────────────────────────────────┐
 │                         VIEW LAYER                        │
@@ -406,13 +465,13 @@ Flux implements a **strict layered architecture** where each layer has a single
 │  • Resolves payload ($value, $formdata)                   │
 │  • Dispatches full Action {type, payload, context, meta}  │
 └──────────────────┬────────────────────────────────────────┘
-                   │ dispatchAction({type: 'ui_add_to_cart', payload: 42, context: 'cart'})
+                   │ actionService.dispatch({type: 'ui_add_to_cart', payload: 42, context: 'cart'})
                    ▼
 ┌───────────────────────────────────────────────────────────┐
 │                     CONTROLLER LAYER                      │
 │  (Business Logic, Services, Use Cases)                    │
 │                                                           │
-│  • Subscribes to Actions via onAction()                   │
+│  • Subscribes to Actions via actionService.on()           │
 │  • Receives full Action object (type, payload, context,   │
 │    meta) — no need to pass context separately             │
 │  • Executes business logic                                │
@@ -439,13 +498,68 @@ Flux implements a **strict layered architecture** where each layer has a single
 └───────────────────────────────────────────────────────────┘
 ```
 
+### 2. Decoupled Actor Model Flow
+
+In complex applications, you can structure features as **Actors** using `@alwatr/fsm` + `@alwatr/action`. An Actor maintains private local state, receives inbound event packets from the global action bus, and broadcasts changes asynchronously back to the ecosystem.
+
+```mermaid
+graph TD
+    %% Styling
+    classDef view fill:#E1F5FE,stroke:#03A9F4,stroke-width:2px,color:#01579B;
+    classDef action fill:#FFF3E0,stroke:#FF9800,stroke-width:2px,color:#E65100;
+    classDef fsm fill:#E8F5E9,stroke:#4CAF50,stroke-width:2px,color:#1B5E20;
+    classDef actor fill:#F3E5F5,stroke:#9C27B0,stroke-width:2px,color:#4A148C;
+    classDef global fill:#ECEFF1,stroke:#607D8B,stroke-width:2px,color:#263238;
+
+    subgraph View ["View Layer (lit-html & Directives)"]
+        V[DOM / UI Elements]
+    end
+
+    subgraph Actions ["Action Bus (Global Delegation)"]
+        AB[actionService.dispatch]
+    end
+
+    subgraph Controllers ["Actor Controller Layer"]
+        C[Input Controller / Message Router]
+    end
+
+    subgraph ActorDomain ["Decoupled Actor (FSM Brain)"]
+        direction TB
+        FSM[FsmService]
+        Ctx[(Extended Context)]
+        Actors[Spawning State Actors]
+    end
+
+    subgraph State ["Reactive State Layer (Signals)"]
+        SS[stateSignal]
+    end
+
+    %% Flow
+    V -->|on-click / on-input| AB
+    AB -->|Global AFSA Message| C
+    C -->|dispatch Event| FSM
+    FSM -->|1. Run-to-Completion| Ctx
+    FSM -->|2. Entry/Exit Effects| Actors
+    FSM -->|3. Update State| SS
+    SS -->|Re-render / Update UI| V
+    Actors -.->|Asynchronous Events| AB
+
+    %% Apply Classes
+    class V view;
+    class AB action;
+    class C global;
+    class FSM,Ctx fsm;
+    class Actors actor;
+    class SS view;
+```
+
 **Key architectural benefits:**
 
-- **Zero coupling** — layers communicate only through well-defined interfaces
-- **Testability** — each layer can be tested in isolation
-- **Scalability** — add features without touching existing code
-- **Predictability** — data flows in one direction only
-- **Performance** — fine-grained updates, no full-tree reconciliation
+- **Zero coupling** — layers and actors communicate only through events, guaranteeing that features can be refactored, extended, or replaced without side effects.
+- **Run-to-Completion (RTC)** — State machines evaluate transitions atomically in a synchronous queue. Race conditions are mathematically impossible.
+- **High Testability** — Since business logic is isolated inside declarative statecharts (`StateMachineConfig`), you can test all transitions and side-effects in node/bun without mounting a DOM.
+- **Surgical Reactivity** — Only the DOM elements bound to the FSM's `stateSignal` or Context properties re-render, keeping CPU usage and memory footprints exceptionally low.
+- **AI-Agent and Developer Friendly** — The explicit separation of routing, transition, and effect layers provides clean boundaries that humans and AI agents can navigate with zero ambiguity.
 
 ---
 
@@ -480,7 +594,7 @@ interface Action<K extends keyof ActionRecord> {
 This unified structure replaces the previous two-argument `(id, payload)` API. Every handler now receives the full picture:
 
 ```typescript
-onAction('ui_add_to_cart', (action) => {
+actionService.on('ui_add_to_cart', (action) => {
   console.log(action.type); // 'ui_add_to_cart'
   console.log(action.payload); // {productId: 42, qty: 1} — fully typed
   console.log(action.context); // 'product-list' — from [action-context] ancestor
@@ -491,9 +605,9 @@ onAction('ui_add_to_cart', (action) => {
 Modifiers can enrich `meta` before the action reaches subscribers:
 
 ```typescript
-import {registerModifier} from '@alwatr/flux';
+import {actionService} from '@alwatr/flux';
 
-registerModifier('trace', (_event, _element, action) => {
+actionService.registerModifier('trace', (_event, _element, action) => {
   action.meta ??= {};
   action.meta['traceId'] = crypto.randomUUID();
   return true;
@@ -531,10 +645,10 @@ bun add @alwatr/flux
 ### 1. Bootstrap the Application
 
 ```typescript
-import {setupActionDelegation, dispatchPageReady} from '@alwatr/flux';
+import {actionService, dispatchPageReady} from '@alwatr/flux';
 
 // Activate global event delegation (call once at app start)
-setupActionDelegation();
+actionService.setupDelegation();
 
 // Dispatch page-ready signal (for MPA routing)
 dispatchPageReady();
@@ -569,19 +683,19 @@ export const counterSignal = createStateSignal({
 
 ```typescript
 // src/controllers.ts
-import {onAction} from '@alwatr/flux';
+import {actionService} from '@alwatr/flux';
 import {counterSignal} from './state.js';
 
-onAction('ui_increment', () => {
+actionService.on('ui_increment', () => {
   counterSignal.update((count) => count + 1);
 });
 
-onAction('ui_decrement', () => {
+actionService.on('ui_decrement', () => {
   counterSignal.update((count) => count - 1);
 });
 
 // Handler receives the full Action object — payload is typed from ActionRecord
-onAction('ui_set_count', (action) => {
+actionService.on('ui_set_count', (action) => {
   counterSignal.set(action.payload); // action.payload: number
 });
 ```
@@ -616,11 +730,11 @@ onAction('ui_set_count', (action) => {
 
 ```typescript
 // main.js
-import {setupActionDelegation} from '@alwatr/flux';
+import {actionService} from '@alwatr/flux';
 import {counterSignal} from './state.js';
 import './controllers.js'; // Register action handlers
 
-setupActionDelegation();
+actionService.setupDelegation();
 
 // Subscribe to state changes and update DOM
 counterSignal.subscribe((count) => {
@@ -732,38 +846,66 @@ const mapped = createMappedSignal(source, {
 });
 ```
 
+#### `createFsmService(config)`
+
+Instantiates a Finite State Machine service using the given configuration:
+
+```typescript
+import {createFsmService} from '@alwatr/flux';
+
+const myService = createFsmService({
+  name: 'my-fsm',
+  initial: 'idle',
+  context: {retries: 0},
+  states: {
+    idle: {
+      on: {START: {target: 'working'}},
+    },
+    working: {
+      on: {SUCCESS: {target: 'idle'}},
+    },
+  },
+});
+```
+
+See the complete [FSM Package README](https://github.com/Alwatr/alwatr/tree/next/pkg/fsm#readme) for advanced FSM configuration details (Persistence, Guards, Actors, etc.).
+
 ---
 
 ### Actions
 
-#### `setupActionDelegation(eventTypes?)`
+#### `actionService`
+
+The pre-instantiated singleton instance of `ActionService` exported for declarative event delegation and action dispatching.
+
+##### `actionService.setupDelegation(eventTypes?)`
 
-Activates global event delegation. Call once at app bootstrap.
+Activates global event delegation capture listeners on `document.body`.
 
 ```typescript
-import {setupActionDelegation, DEFAULT_DELEGATED_EVENTS} from '@alwatr/flux';
+import {actionService, DEFAULT_DELEGATED_EVENTS} from '@alwatr/flux';
 
 // Use defaults (click, submit, input, change)
-setupActionDelegation();
+actionService.setupDelegation();
 
 // Or add custom events
-setupActionDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown', 'focus']);
+actionService.setupDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown', 'focus']);
 ```
 
-#### `onAction<K>(type, handler)`
+##### `actionService.on(type, handler)`
 
-Subscribes to a single typed action or an array of actions. The handler receives the full `Action<K>` object.
+Subscribes to a single typed action or an array of actions.
 
 ```typescript
 // Subscribe to a single action
-const sub = onAction('ui_add_to_cart', (action) => {
+const sub = actionService.on('ui_add_to_cart', (action) => {
   cartService.add(action.payload.productId, action.payload.qty);
   console.log(action.context); // e.g. 'product-list' or undefined
   console.log(action.meta); // any metadata set by modifiers
 });
 
 // Subscribe to multiple actions with a single handler
-const multiSub = onAction(['ui_increment', 'ui_decrement'], (action) => {
+const multiSub = actionService.on(['ui_increment', 'ui_decrement'], (action) => {
   console.log('Action triggered:', action.type);
 });
 
@@ -771,16 +913,16 @@ sub.unsubscribe(); // Clean up when done
 multiSub.unsubscribe();
 ```
 
-#### `dispatchAction<K>(action)`
+##### `actionService.dispatch(action)`
 
-Dispatches a typed action programmatically. Takes a full `Action<K>` object.
+Dispatches a typed action programmatically.
 
 ```typescript
-dispatchAction({type: 'navigate', payload: '/home'});
-dispatchAction({type: 'auth_expired', payload: undefined}); // void payload
+actionService.dispatch({type: 'navigate', payload: '/home'});
+actionService.dispatch({type: 'auth_expired', payload: undefined}); // void payload
 
 // With context and meta
-dispatchAction({
+actionService.dispatch({
   type: 'upload_complete',
   payload: fileId,
   context: 'product-list',
@@ -788,17 +930,17 @@ dispatchAction({
 });
 ```
 
-#### `registerModifier(name, handler)`
+##### `actionService.registerModifier(name, handler)`
 
-Adds a custom modifier for `on-<event>` attributes. The handler receives the mutable `action` object and may write to `action.meta`.
+Adds a custom modifier for `on-<event>` attributes.
 
 ```typescript
-registerModifier('confirm', () => {
+actionService.registerModifier('confirm', () => {
   return window.confirm('Are you sure?');
 });
 
 // A modifier that stamps a trace ID into meta
-registerModifier('trace', (_event, _element, action) => {
+actionService.registerModifier('trace', (_event, _element, action) => {
   action.meta ??= {};
   action.meta['traceId'] = crypto.randomUUID();
   return true;
@@ -809,12 +951,12 @@ registerModifier('trace', (_event, _element, action) => {
 <button on-click="ui_delete_item:42; confirm,trace">Delete</button>
 ```
 
-#### `registerPayloadResolver(name, resolver)`
+##### `actionService.registerPayloadResolver(name, resolver)`
 
 Adds a custom payload resolver.
 
 ```typescript
-registerPayloadResolver('$data-id', (_event, element) => {
+actionService.registerPayloadResolver('$data-id', (_event, element) => {
   return element.dataset.id;
 });
 ```
@@ -1238,19 +1380,19 @@ export const todosSignal = createStateSignal<Todo[]>({
 });
 
 // controllers.ts
-import {onAction} from '@alwatr/flux';
+import {actionService} from '@alwatr/flux';
 import {todosSignal} from './state.js';
 
 let nextId = 1;
 
-onAction('ui_add_todo', (action) => {
+actionService.on('ui_add_todo', (action) => {
   todosSignal.update((todos) => [
     ...todos,
     {id: nextId++, text: action.payload, done: false},
   ]);
 });
 
-onAction('ui_toggle_todo', (action) => {
+actionService.on('ui_toggle_todo', (action) => {
   todosSignal.update((todos) =>
     todos.map((todo) =>
       todo.id === action.payload ? {...todo, done: !todo.done} : todo
@@ -1258,7 +1400,7 @@ onAction('ui_toggle_todo', (action) => {
   );
 });
 
-onAction('ui_remove_todo', (action) => {
+actionService.on('ui_remove_todo', (action) => {
   todosSignal.update((todos) => todos.filter((t) => t.id !== action.payload));
 });
 
@@ -1269,11 +1411,11 @@ onAction('ui_remove_todo', (action) => {
 </div>
 
 // main.ts
-import {setupActionDelegation, html, render} from '@alwatr/flux';
+import {actionService, html, render} from '@alwatr/flux';
 import {todosSignal} from './state.js';
 import './controllers.js';
 
-setupActionDelegation();
+actionService.setupDelegation();
 
 todosSignal.subscribe((todos) => {
   render(
@@ -1307,7 +1449,7 @@ todosSignal.subscribe((todos) => {
 - **[@alwatr/action](https://github.com/Alwatr/alwatr/tree/next/pkg/nanolib/action)** — Global event delegation action bus (part of Flux)
 - **[@alwatr/directive](https://github.com/Alwatr/alwatr/tree/next/pkg/nanolib/directive)** — Attribute-based DOM directives (part of Flux)
 - **[@alwatr/embedded-data](https://github.com/Alwatr/alwatr/tree/next/pkg/nanolib/embedded-data)** — Extract and validate embedded JSON from DOM script tags for SSR hydration (part of Flux)
-- **[@alwatr/fsm](https://github.com/Alwatr/alwatr/tree/next/pkg/fsm)** — Type-safe Finite State Machine
+- **[@alwatr/fsm](https://github.com/Alwatr/alwatr/tree/next/pkg/fsm)** — Type-safe Finite State Machine (part of Flux)
 - **[@alwatr/nanotron](https://github.com/Alwatr/alwatr/tree/next/pkg/nanotron)** — Lightweight API server framework
 - **[@alwatr/nitrobase](https://github.com/Alwatr/alwatr/tree/next/pkg/nitrobase)** — In-memory JSON database
 - **[@alwatr/fetch](https://github.com/Alwatr/alwatr/tree/next/pkg/nanolib/fetch)** — Enhanced fetch with retry, cache, deduplication

package/dist/main.d.ts

@@ -2,6 +2,7 @@ export * from '@alwatr/signal';
 export * from '@alwatr/action';
 export * from '@alwatr/directive';
 export * from '@alwatr/embedded-data';
+export * from '@alwatr/fsm';
 export * from '@alwatr/keyboard-shortcut';
 export * from '@alwatr/render-state';
 export * from '@alwatr/local-storage';

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAGA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,mBAAmB,qBAAqB,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAGA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,mBAAmB,qBAAqB,CAAC"}

package/dist/main.js

@@ -1,5 +1,5 @@
-/* 📦 @alwatr/flux v9.26.0 */
-export*from"@alwatr/signal";export*from"@alwatr/action";export*from"@alwatr/directive";export*from"@alwatr/embedded-data";export*from"@alwatr/keyboard-shortcut";export*from"@alwatr/render-state";export*from"@alwatr/local-storage";export*from"@alwatr/session-storage";export*from"@alwatr/page-ready";import{html as e,svg as p,mathml as a,render as f,noChange as t,nothing as n}from"lit-html";import{unsafeSVG as g}from"lit-html/directives/unsafe-svg.js";import{ifDefined as i}from"lit-html/directives/if-defined.js";import{cache as s}from"lit-html/directives/cache.js";import{classMap as b}from"lit-html/directives/class-map.js";import{when as d}from"lit-html/directives/when.js";import{repeat as I}from"lit-html/directives/repeat.js";export{d as when,g as unsafeSVG,p as svg,I as repeat,f as render,n as nothing,t as noChange,a as mathml,i as ifDefined,e as html,b as classMap,s as cache};
+/* 📦 @alwatr/flux v9.28.0 */
+export*from"@alwatr/signal";export*from"@alwatr/action";export*from"@alwatr/directive";export*from"@alwatr/embedded-data";export*from"@alwatr/fsm";export*from"@alwatr/keyboard-shortcut";export*from"@alwatr/render-state";export*from"@alwatr/local-storage";export*from"@alwatr/session-storage";export*from"@alwatr/page-ready";import{html as e,svg as p,mathml as a,render as f,noChange as t,nothing as x}from"lit-html";import{unsafeSVG as m}from"lit-html/directives/unsafe-svg.js";import{ifDefined as i}from"lit-html/directives/if-defined.js";import{cache as s}from"lit-html/directives/cache.js";import{classMap as b}from"lit-html/directives/class-map.js";import{when as d}from"lit-html/directives/when.js";import{repeat as I}from"lit-html/directives/repeat.js";export{d as when,m as unsafeSVG,p as svg,I as repeat,f as render,x as nothing,t as noChange,a as mathml,i as ifDefined,e as html,b as classMap,s as cache};
 
-//# debugId=B53609D2635793FE64756E2164756E21
+//# debugId=F1AB5B823C55946064756E2164756E21
 //# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -2,10 +2,10 @@
   "version": 3,
   "sources": ["../src/main.ts", "../src/lit-html.ts"],
   "sourcesContent": [
-    "// UI and reactive bundle — signals, actions, directives, and client-side storage.\n// This package aggregates all UI-layer nanolibs for convenient single-import usage.\n\nexport * from '@alwatr/signal';\nexport * from '@alwatr/action';\nexport * from '@alwatr/directive';\nexport * from '@alwatr/embedded-data';\nexport * from '@alwatr/keyboard-shortcut';\nexport * from '@alwatr/render-state';\nexport * from '@alwatr/local-storage';\nexport * from '@alwatr/session-storage';\nexport * from '@alwatr/page-ready';\nexport * from './lit-html.js';\nexport type * from '@alwatr/type-helper';\n",
+    "// UI and reactive bundle — signals, actions, directives, and client-side storage.\n// This package aggregates all UI-layer nanolibs for convenient single-import usage.\n\nexport * from '@alwatr/signal';\nexport * from '@alwatr/action';\nexport * from '@alwatr/directive';\nexport * from '@alwatr/embedded-data';\nexport * from '@alwatr/fsm';\nexport * from '@alwatr/keyboard-shortcut';\nexport * from '@alwatr/render-state';\nexport * from '@alwatr/local-storage';\nexport * from '@alwatr/session-storage';\nexport * from '@alwatr/page-ready';\nexport * from './lit-html.js';\nexport type * from '@alwatr/type-helper';\n",
     "/**\n * Curated re-exports from `lit-html` for use within `@alwatr/flux`.\n *\n * Only the subset of `lit-html` APIs that are commonly needed in a Flux-based\n * application is exported here. This keeps the public surface minimal and\n * avoids pulling in advanced directive utilities that most consumers never use.\n *\n * **Exported APIs:**\n * - `html` — tagged template literal that produces a `TemplateResult`\n * - `render` — renders a `TemplateResult` into a DOM container\n * - `noChange` — sentinel that tells lit-html to leave the current part value unchanged\n * - `nothing` — sentinel that renders nothing (removes the node/attribute)\n * - `ifDefined` — renders a value only when it is not `undefined`\n * - `cache` — caches rendered templates to avoid re-parsing on state changes\n * - `classMap` — efficiently sets/removes CSS classes from an object map\n * - `when` — conditional rendering helper (`when(condition, trueCase, falseCase)`)\n *\n * @example\n * ```typescript\n * import {html, render, classMap, when} from '@alwatr/flux';\n *\n * const template = (isActive: boolean) => html`\n *   <div class=${classMap({active: isActive, hidden: !isActive})}>\n *     ${when(isActive, () => html`<span>Active</span>`, () => html`<span>Inactive</span>`)}\n *   </div>\n * `;\n *\n * render(template(true), document.getElementById('app')!);\n * ```\n */\nexport {\n  html,\n  svg,\n  mathml,\n  render,\n  noChange,\n  nothing,\n  type TemplateResult,\n  type HTMLTemplateResult,\n  type SVGTemplateResult,\n  type MathMLTemplateResult,\n} from 'lit-html';\nexport {unsafeSVG} from 'lit-html/directives/unsafe-svg.js';\nexport {ifDefined} from 'lit-html/directives/if-defined.js';\nexport {cache} from 'lit-html/directives/cache.js';\nexport {classMap, type ClassInfo} from 'lit-html/directives/class-map.js';\nexport {when} from 'lit-html/directives/when.js';\nexport {repeat, type RepeatDirectiveFn, type KeyFn, type ItemTemplate} from 'lit-html/directives/repeat.js';\n"
   ],
-  "mappings": ";AAGA,4BACA,4BACA,+BACA,mCACA,uCACA,kCACA,mCACA,qCACA,gCCmBA,eACE,SACA,YACA,YACA,cACA,aACA,iBAMF,oBAAQ,0CACR,oBAAQ,0CACR,gBAAQ,qCACR,mBAAQ,yCACR,eAAQ,oCACR,iBAAQ",
-  "debugId": "B53609D2635793FE64756E2164756E21",
+  "mappings": ";AAGA,4BACA,4BACA,+BACA,mCACA,yBACA,uCACA,kCACA,mCACA,qCACA,gCCkBA,eACE,SACA,YACA,YACA,cACA,aACA,iBAMF,oBAAQ,0CACR,oBAAQ,0CACR,gBAAQ,qCACR,mBAAQ,yCACR,eAAQ,oCACR,iBAAQ",
+  "debugId": "F1AB5B823C55946064756E2164756E21",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alwatr/flux",
-  "version": "9.26.0",
+  "version": "9.28.0",
   "description": "UI and reactive library bundle for ECMAScript (JavaScript/TypeScript) projects — signals, actions, directives, and storage.",
   "license": "MPL-2.0",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com> (https://ali.mihandoost.com)",
@@ -21,12 +21,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@alwatr/action": "9.26.0",
+    "@alwatr/action": "9.28.0",
     "@alwatr/directive": "9.26.0",
     "@alwatr/embedded-data": "9.25.0",
-    "@alwatr/keyboard-shortcut": "9.26.0",
+    "@alwatr/fsm": "9.28.0",
+    "@alwatr/keyboard-shortcut": "9.28.0",
     "@alwatr/local-storage": "9.25.0",
-    "@alwatr/page-ready": "9.26.0",
+    "@alwatr/page-ready": "9.27.0",
     "@alwatr/render-state": "9.25.0",
     "@alwatr/session-storage": "9.25.0",
     "@alwatr/signal": "9.26.0",
@@ -84,5 +85,5 @@
     "ui",
     "unidirectional-data-flow"
   ],
-  "gitHead": "ef62969b649929413c640e69d241f4e99d6062e8"
+  "gitHead": "d60f1d986e5ff44f871d38231f1f2be60833140b"
 }

package/src/main.ts

@@ -5,6 +5,7 @@ export * from '@alwatr/signal';
 export * from '@alwatr/action';
 export * from '@alwatr/directive';
 export * from '@alwatr/embedded-data';
+export * from '@alwatr/fsm';
 export * from '@alwatr/keyboard-shortcut';
 export * from '@alwatr/render-state';
 export * from '@alwatr/local-storage';