@alwatr/action 9.13.0 → 9.14.0

package/README.md

@@ -19,26 +19,27 @@
 
 ## How It Works
 
+### Action Bus
+
+The action bus is powered by a [`ChannelSignal`](../signal/README.md) from `@alwatr/signal`. Dispatching action `'A'` performs a single `Map.get('A')` lookup and invokes only the handlers registered for that specific action — **O(1) per dispatch**, regardless of how many other actions are subscribed.
+
 ### Global Event Delegation
 
-Instead of attaching one listener per element, a single capture-phase listener is registered on `document.body` for each event type. When an event fires anywhere on the page, the handler walks up from `event.target` using `closest('[on-action]')` to find the nearest element with an `on-action` attribute, parses the attribute, runs modifiers, resolves the payload, and calls `dispatchAction`.
+A single capture-phase listener on `document.body` handles all `on-action` elements. When an event fires, the handler walks up from `event.target` using `closest('[on-action]')`, parses the attribute, runs modifiers, resolves the payload, and dispatches the action.
 
 ```
 User clicks a button
         │
         ▼
-document.body capture listener (1 listener total)
+document.body capture listener  (1 listener per event type)
         │
-        └─ closest('[on-action]') → finds element
+        └─ closest('[on-action^=click]') → finds element
            parse attribute → 'click->add-to-cart:42'
            run modifiers   → none
            resolve payload → '42'
-           dispatchAction('add-to-cart', '42')
+           internalChannel_.dispatch('add-to-cart', '42')
                 │
-                ▼
-          ChannelSignal.dispatch('add-to-cart', '42')  [O(1)]
-                │
-                └─ Map.get('add-to-cart') → invoke only matching handlers
+                └─ Map.get('add-to-cart') → O(1) → invoke only matching handlers
 ```
 
 ### Complexity
@@ -48,10 +49,11 @@ document.body capture listener (1 listener total)
 | Boot time       | O(N elements)         | **O(1)**             |
 | Memory          | O(N listeners)        | **O(1)**             |
 | Dynamic content | Requires re-bootstrap | **Works out-of-box** |
+| `once` modifier | Native option         | Remove attribute     |
 
-### Action Bus
+### `once` modifier
 
-The action bus is powered by a [`ChannelSignal`](../signal/README.md) from `@alwatr/signal`. Dispatching action `'A'` performs a single `Map.get('A')` lookup and invokes only the handlers registered for that specific action — **O(1) per dispatch**, regardless of how many other actions are subscribed.
+In delegation mode, `once` is implemented by removing the `on-action` attribute from the element after the first fire. This is simpler than a `WeakSet` cache and naturally handles element reuse — if the element is re-rendered with the attribute, it fires again.
 
 ---
 
@@ -69,7 +71,7 @@ npm i @alwatr/action
 
 ### 1. Register your action types
 
-Create a declaration file in your package to extend `ActionRecord`. This gives you full type safety and IDE autocomplete across the entire app:
+Extend `ActionRecord` via declaration merging. This gives you full type safety and IDE autocomplete — passing an undeclared action name is a **compile error**.
 
 ```ts
 // src/action-record.ts
@@ -83,22 +85,18 @@ declare module '@alwatr/action' {
 }
 ```
 
-Passing an action name not declared in `ActionRecord` is a **compile error** — there is no string fallback.
-
 ### 2. Bootstrap delegation
 
 ```ts
 import {setupActionDelegation, onAction} from '@alwatr/action';
 import './action-record.js'; // ensure the declaration is loaded
 
-// One call — the entire page is covered, including future dynamic content.
 setupActionDelegation();
 
-// Payload types are inferred automatically from ActionRecord — no generics needed.
+// Payload types are inferred from ActionRecord — no generics needed.
 onAction('open-drawer', (panel) => openDrawer(panel)); // panel: string
-onAction('search-query', (query) => performSearch(query)); // query: string
 onAction('add-to-cart', (item) => {
-  cartService.add(item.productId, item.qty); // fully typed, no `!`
+  cartService.add(item.productId, item.qty); // fully typed
 });
 ```
 
@@ -126,19 +124,20 @@ onAction('add-to-cart', (item) => {
   />
   <button type="submit">Save</button>
 </form>
+
+<!-- Fires only once — attribute is removed after first click -->
+<button on-action="click.once->welcome-dismissed">Got it</button>
 ```
 
-### 3. Programmatic dispatch
+### 4. Programmatic dispatch
 
 ```ts
 import {dispatchAction} from '@alwatr/action';
 
-// Trigger actions from code — after async ops, from service layers, etc.
 await uploadFile(file);
 dispatchAction('upload-complete', fileId);
 
 dispatchAction('navigate', '/dashboard');
-dispatchAction<{code: number}>('show-error', {code: 404});
 ```
 
 ---
@@ -158,15 +157,11 @@ on-action="eventType[.modifier…]->actionId[:payload]"
 
 ### Built-in modifiers
 
-| Modifier    | Behavior                                                             |
-| ----------- | -------------------------------------------------------------------- |
-| `.prevent`  | Calls `event.preventDefault()`                                       |
-| `.stop`     | Calls `event.stopPropagation()`                                      |
-| `.once`     | Dispatches the action only once per element (emulated via `WeakSet`) |
-| `.validate` | Cancels dispatch if the nearest `<form>` fails `checkValidity()`     |
-
-> **Note:** `.passive` is not supported in delegation mode because all delegated
-> listeners must be non-passive to allow `.prevent` to work.
+| Modifier    | Behavior                                                                         |
+| ----------- | -------------------------------------------------------------------------------- |
+| `.prevent`  | Calls `event.preventDefault()`                                                   |
+| `.once`     | Removes the `on-action` attribute after first fire — action dispatches only once |
+| `.validate` | Cancels dispatch if the nearest `<form>` fails `checkValidity()`                 |
 
 ### Built-in payload resolvers
 
@@ -181,31 +176,22 @@ on-action="eventType[.modifier…]->actionId[:payload]"
 
 ### `ActionRecord` (interface)
 
-The global action type registry. Extend it via declaration merging to register your application's actions and unlock full type safety in `onAction` and `dispatchAction`.
+The global action type registry. Extend via declaration merging to register typed actions.
 
 ```ts
-// src/action-record.ts
 declare module '@alwatr/action' {
   interface ActionRecord {
     'open-drawer': string;
-    'add-to-cart': {productId: number; qty: number};
     'logout': void;
   }
 }
 ```
 
-Once declared:
-
-- `onAction('open-drawer', (panel) => …)` — `panel` is inferred as `string`
-- `dispatchAction('add-to-cart', {productId: 42, qty: 1})` — payload type enforced
-- `dispatchAction('unknown-action', …)` — **compile error**
-
 ---
 
 ### `setupActionDelegation(eventTypes?)`
 
-Registers global event delegation on `document.body`. Call once at bootstrap.
-Subsequent calls with the same event types are no-ops (idempotent).
+Registers global event delegation on `document.body`. Call once at bootstrap. Idempotent.
 
 ```ts
 function setupActionDelegation(eventTypes?: readonly string[]): void;
@@ -216,18 +202,14 @@ Defaults to `DEFAULT_DELEGATED_EVENTS`: `['click', 'submit', 'input', 'change']`
 ```ts
 import {setupActionDelegation, DEFAULT_DELEGATED_EVENTS} from '@alwatr/action';
 
-// Default events
-setupActionDelegation();
-
-// Add extra event types
-setupActionDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown', 'pointerup']);
+setupActionDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown']);
 ```
 
 ---
 
 ### `teardownActionDelegation()`
 
-Removes all delegation listeners. Useful in tests or micro-frontend teardown.
+Removes all delegation listeners and clears the descriptor cache. Useful in tests or micro-frontend teardown.
 
 ```ts
 function teardownActionDelegation(): void;
@@ -237,54 +219,32 @@ function teardownActionDelegation(): void;
 
 ### `onAction(actionId, handler)`
 
-Subscribes to a named action. Uses `ChannelSignal.on()` for O(1) routing.
+Subscribes to a named action. O(1) routing via `ChannelSignal`.
 
 ```ts
-function onAction<T = string>(actionId: string, handler: (payload?: T) => void): SubscribeResult;
+function onAction<K extends keyof ActionRecord>(
+  actionId: K,
+  handler: (payload: ActionRecord[K]) => void,
+): SubscribeResult;
 ```
 
 ```ts
 const sub = onAction('open-drawer', (panel) => openDrawer(panel));
-
-// Unsubscribe when no longer needed (prevents memory leaks)
-sub.unsubscribe();
+sub.unsubscribe(); // prevent memory leaks
 ```
 
 ---
 
 ### `dispatchAction(actionId, payload?)`
 
-Dispatches a named action to all matching `onAction` subscribers.
-
-```ts
-function dispatchAction<T = string>(actionId: string, actionPayload?: T): void;
-```
-
----
-
-### `dispatchPageId(element?)`
-
-Reads the `page-id` attribute from `element` (defaults to `document.body`) and
-dispatches a `'page-ready'` action with the page identifier as payload.
+Dispatches a named action. Payload type is enforced by `ActionRecord`.
 
 ```ts
-function dispatchPageId(element?: HTMLElement): void;
-```
-
-```html
-<body page-id="home">
-  …
-</body>
-```
+// With payload
+dispatchAction('open-drawer', 'settings');
 
-```ts
-import {dispatchPageId, onAction} from '@alwatr/action';
-
-dispatchPageId(); // → dispatchAction('page-ready', 'home')
-
-onAction('page-ready', (pageId) => {
-  console.log('navigated to:', pageId); // 'home'
-});
+// Void payload — no second argument
+dispatchAction('logout');
 ```
 
 ---
@@ -292,40 +252,44 @@ onAction('page-ready', (pageId) => {
 ### `registerModifier(name, handler)`
 
 Registers a custom modifier. Return `false` to cancel the dispatch.
-Works with both delegation and programmatic dispatch.
+
+Handler signature: `(event: Event, element: HTMLElement) => boolean`
 
 ```ts
 import {registerModifier} from '@alwatr/action';
 
-registerModifier('confirm', function () {
-  return window.confirm('Are you sure?');
+// Arrow function — no `this` binding needed
+registerModifier('not-disabled', (_event, element) => {
+  return !(element as HTMLButtonElement).disabled;
 });
 ```
 
 ```html
-<button on-action="click.confirm->delete-item:42">Delete</button>
-```
-
-The handler receives an `ActionContext` as `this`:
-
-```ts
-interface ActionContext {
-  readonly element: HTMLElement; // the element with the on-action attribute
-}
+<button
+  on-action="click.not-disabled->select-item:$data-id"
+  data-id="42"
+>
+  Select
+</button>
 ```
 
 ---
 
 ### `registerPayloadResolver(name, resolver)`
 
-Registers a custom payload resolver. The return value becomes the action payload.
-Works with both delegation and programmatic dispatch.
+Registers a custom payload resolver.
+
+Handler signature: `(event: Event, element: HTMLElement) => unknown`
 
 ```ts
 import {registerPayloadResolver} from '@alwatr/action';
 
-registerPayloadResolver('$checked', function () {
-  return (this.element as HTMLInputElement).checked;
+registerPayloadResolver('$checked', (_event, element) => {
+  return (element as HTMLInputElement).checked;
+});
+
+registerPayloadResolver('$data-id', (_event, element) => {
+  return (element as HTMLElement).dataset.id ?? null;
 });
 ```
 
@@ -334,6 +298,12 @@ registerPayloadResolver('$checked', function () {
   type="checkbox"
   on-action="change->toggle-feature:$checked"
 />
+<li
+  on-action="click->select-item:$data-id"
+  data-id="42"
+>
+  Item
+</li>
 ```
 
 ---
@@ -349,11 +319,11 @@ registerPayloadResolver('$checked', function () {
                          ▼
 ┌─────────────────────────────────────────────────────────┐
 │              Action Layer (@alwatr/action)               │
-│  document.body capture listener (1 listener total)      │
-│  → closest('[on-action]') → parse → run modifiers       │
-│  → dispatchAction('add-to-cart', '42')          [O(1)] │
+│  document.body capture listener (1 per event type)      │
+│  → closest('[on-action]') → parse → modifiers           │
+│  → internalChannel_.dispatch('add-to-cart', '42') [O(1)]│
 └────────────────────────┬────────────────────────────────┘
-                         │ action signal (O(1) routing)
+                         │ O(1) routing via ChannelSignal
                          ▼
 ┌─────────────────────────────────────────────────────────┐
 │                   Business Logic Layer                  │
@@ -372,62 +342,45 @@ registerPayloadResolver('$checked', function () {
 
 ---
 
-## Migration from Previous Versions
-
-### `registerActionDirective` / `registerPageIdDirective` removed
-
-The directive-based approach has been replaced by global delegation.
+## Page Identity
 
-**Before:**
+For page-ready signals in SSG/SSR apps (reading `page-id` attribute and notifying
+page-specific handlers), use [`@alwatr/page-ready`](../page-ready/README.md) instead.
+It is intentionally separate from the action bus — page identity is a routing/lifecycle
+concern, not a user-interaction action.
 
-```ts
-import {registerActionDirective, registerPageIdDirective} from '@alwatr/action';
-import {bootstrapDirectives} from '@alwatr/directive';
-
-registerActionDirective();
-registerPageIdDirective();
-bootstrapDirectives();
-```
-
-**After:**
-
-```ts
-import {setupActionDelegation, dispatchPageId} from '@alwatr/action';
-
-setupActionDelegation();
-dispatchPageId();
-```
-
-### `ActionDirective` / `PageIdDirective` removed
+---
 
-These classes are no longer exported. Use `setupActionDelegation()` and
-`dispatchPageId()` instead.
+## Migration from Previous Versions
 
-### `ModifierHandler` / `PayloadResolver` context changed
+### `ActionContext` removed
 
-The `this` context in custom modifier and resolver functions changed from
-`ActionDirective` to `ActionContext`:
+The `this` context in modifier and resolver handlers changed to explicit parameters:
 
 **Before:**
 
 ```ts
 registerModifier('not-disabled', function () {
-  return !(this.element_ as HTMLButtonElement).disabled; // this.element_
+  return !(this.element as HTMLButtonElement).disabled;
 });
 ```
 
 **After:**
 
 ```ts
-registerModifier('not-disabled', function () {
-  return !(this.element as HTMLButtonElement).disabled; // this.element (no underscore)
+registerModifier('not-disabled', (_event, element) => {
+  return !(element as HTMLButtonElement).disabled;
 });
 ```
 
-### `ActionSignalPayload` removed
+### `once` behavior changed
+
+Previously tracked via `WeakSet`. Now removes the `on-action` attribute after first fire.
+Behavior is equivalent for typical use cases.
+
+### `page-ready` moved to `@alwatr/page-ready`
 
-This type was an implementation detail of the old `EventSignal`-based bus and
-is no longer needed. Use `onAction` and `dispatchAction` directly.
+`dispatchPageId` / `onPageReady` are no longer part of this package.
 
 ---
 

package/dist/action-record.d.ts

@@ -33,8 +33,9 @@
  * Extend this interface via declaration merging to register your application's
  * actions and gain full type safety in `onAction` and `dispatchAction`.
  *
- * Built-in system actions are declared here. Application-level actions should
- * be declared in a dedicated `action-record.ts` file within each feature package.
+ * This interface is intentionally empty in the base package — all actions are
+ * application-specific and should be declared in a dedicated `action-record.ts`
+ * file within each feature package.
  *
  * @example — registering actions in a feature package
  * ```ts
@@ -49,18 +50,5 @@
  * ```
  */
 export interface ActionRecord {
-    /**
-     * Dispatched by `dispatchPageId()` when the page identity is read from the
-     * `page-id` HTML attribute. Payload is the page identifier string.
-     *
-     * @example
-     * ```html
-     * <body page-id="home">…</body>
-     * ```
-     * ```ts
-     * onAction('page-ready', (pageId) => router.setPage(pageId));
-     * ```
-     */
-    'page-ready': string;
 }
 //# sourceMappingURL=action-record.d.ts.map

package/dist/action-record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-record.d.ts","sourceRoot":"","sources":["../src/action-record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;;;;;OAWG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB"}
+{"version":3,"file":"action-record.d.ts","sourceRoot":"","sources":["../src/action-record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,YAAY;CAAG"}

package/dist/lib.d.ts

@@ -1,4 +1,3 @@
-import type { ActionRecord } from './action-record.js';
 /**
  * Module-scoped logger for `@alwatr/action`.
  * Scoped to `'alwatr-action'` so log lines are easy to filter in the console.
@@ -17,12 +16,7 @@ export declare const logger_: import("@alwatr/logger").AlwatrLogger;
  * single `Map.get('A')` lookup and invokes only the handlers registered for
  * that specific action — never handlers for `'B'`, `'C'`, etc.
  *
- * `ActionRecord & Record<string, unknown>` satisfies the `ChannelSignal`
- * constraint (which requires an index signature) while keeping the public API
- * strictly limited to declared keys — the `Record<string, unknown>` part is
- * only visible to the internal channel, not to `onAction`/`dispatchAction`.
- *
  * @internal — not part of the public API; use `onAction` / `dispatchAction` instead.
  */
-export declare const internalChannel_: import("@alwatr/signal").ChannelSignal<ActionRecord & Record<string, unknown>>;
+export declare const internalChannel_: import("@alwatr/signal").ChannelSignal<Record<string, unknown>>;
 //# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,uCAAgC,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,gFAAuF,CAAC"}
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,eAAO,MAAM,OAAO,uCAAgC,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,iEAAwE,CAAC"}

package/dist/main.d.ts

@@ -1,12 +1,11 @@
 /**
  * @alwatr/action — Declarative DOM action-dispatch for Unidirectional Data Flow.
  *
- * ## Two ways to activate `on-action` attributes
+ * ## Activating `on-action` attributes
  *
- * ### 1. Global delegation (recommended)
- *
- * One listener on `document.body` handles every `on-action` element — past,
- * present, and future. O(1) boot time regardless of element count.
+ * Call `setupActionDelegation()` once at bootstrap. A single capture-phase
+ * listener on `document.body` handles every `on-action` element — including
+ * elements added dynamically after bootstrap — with O(1) initialization cost.
  *
  * ```ts
  * import {setupActionDelegation, onAction} from '@alwatr/action';
@@ -15,22 +14,20 @@
  * onAction('open-drawer', (panel) => openDrawer(panel));
  * ```
  *
- * ### 2. Programmatic dispatch
- *
- * Dispatch actions from code without any HTML attribute:
+ * ## Programmatic dispatch
  *
  * ```ts
- * import {dispatchAction, onAction} from '@alwatr/action';
+ * import {dispatchAction} from '@alwatr/action';
  *
  * dispatchAction('navigate', '/dashboard');
- * onAction('navigate', (path) => router.push(path));
  * ```
  *
  * ## Registering typed actions
  *
- * Extend `ActionMap` via declaration merging to get full type safety:
+ * Extend `ActionRecord` via declaration merging to get full type safety:
  *
  * ```ts
+ * // src/action-record.ts
  * declare module '@alwatr/action' {
  *   interface ActionRecord {
  *     'open-drawer': string;
@@ -46,11 +43,13 @@
  * - `setupActionDelegation` / `teardownActionDelegation` — global delegation lifecycle
  * - `DEFAULT_DELEGATED_EVENTS` — default event types covered by delegation
  * - `onAction` / `dispatchAction` — subscribe to and dispatch named actions
- * - `dispatchPageId` — read `page-id` attribute and dispatch `'page-ready'`
  * - `registerModifier` / `registerPayloadResolver` — extend the attribute syntax
+ *
+ * ## Page identity
+ *
+ * For page-ready signals in SSG/SSR apps, use `@alwatr/page-ready` instead.
  */
+export type { ActionRecord } from './action-record.js';
 export * from './method.js';
 export * from './delegate.js';
-export * from './page-ready.js';
-export * from './action-record.js';
 //# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,YAAY,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC"}

package/dist/main.js

@@ -1,5 +1,5 @@
-/* 📦 @alwatr/action v9.13.0 */
-import{createLogger as F}from"@alwatr/logger";import{createChannelSignal as L}from"@alwatr/signal";var G=F("alwatr-action"),W=L({name:"alwatr-action"});var K=new Map,N=new Map;K.set("prevent",(M)=>{return M.preventDefault(),!0});K.set("validate",function(M,q){let x=q instanceof HTMLFormElement?q:q.closest("form");if(!x)return!1;return x.checkValidity()});N.set("$value",function(M,q){return"value"in q?q.value:null});N.set("$formdata",function(M,q){let x=q instanceof HTMLFormElement?q:q.closest("form");return x?Object.fromEntries(new FormData(x).entries()):null});function f(M,q){return G.logMethodArgs?.("onAction",{actionId:M}),W.on(M,q)}function V(M,q){G.logMethodArgs?.("dispatchAction",{actionId:M,actionPayload:q}),W.dispatch(M,q)}function b(M,q){if(G.logMethodArgs?.("registerModifier",{name:M}),K.has(M))G.accident("registerModifier","modifier_already_registered",{name:M});K.set(M,q)}function p(M,q){if(G.logMethodArgs?.("registerPayloadResolver",{name:M}),N.has(M))G.accident("registerPayloadResolver","payload_resolver_already_registered",{name:M});N.set(M,q)}var S=/^([a-z0-9.-]+)->([a-z0-9-]+)(?::(.+))?$/,P=new Map;function j(M){G.logMethodArgs?.("parseDescriptor__",{attributeValue:M});let q=P.get(M);if(q!==void 0)return q;let x=M.match(S);if(!x)return G.accident("parseDescriptor__","invalid_syntax",{attributeValue:M}),P.set(M,null),null;let[z,...D]=x[1].split(".");if(!z)return G.accident("parseDescriptor__","missing_event_type",{attributeValue:M}),P.set(M,null),null;let H=new Set(D),O=x[2],J=x[3],Q={eventType:z,modifiers:H,actionId:O,payload:J};return P.set(M,Q),Q}var Z="on-action";function U(M){let q=M.type;G.logMethodArgs?.("handleDelegatedEvent__",{eventType:q});let x=M.target;if(!x)return;let z=x.closest?.(`[${Z}^=${q}]`);if(!z)return;let D=z.getAttribute?.(Z)?.trim();if(!D){G.accident("handleDelegatedEvent__","empty_attribute",{eventType:q,attributeValue:D,actionElement:z});return}if(!(z instanceof HTMLElement)){G.accident("handleDelegatedEvent__","target_not_html_element",{eventType:q,attributeValue:D,actionElement:z});return}let H=j(D);if(!H){G.accident("handleDelegatedEvent__","invalid_attribute",{eventType:q,attributeValue:D,actionElement:z});return}if(H.eventType!==q)return;if(G.logMethodArgs?.("handleDelegatedEvent__.action",H),H.modifiers.has("once"))z.removeAttribute(Z),P.delete(D);for(let J of H.modifiers){if(J==="once")continue;let Q=K.get(J);if(!Q){G.accident("handleDelegatedEvent__","unknown_modifier",{modifier:J,attributeValue:D});return}if(Q(M,z)===!1)return}let O=H.payload;if(O){let J=N.get(O);if(J)O=J(M,z)}W.dispatch(H.actionId,O)}var X=new Set,w=["click","submit","input","change"];function h(M=w){G.logMethodArgs?.("setupActionDelegation",{eventTypes:M});for(let q of M){if(X.has(q))continue;X.add(q),document.body.addEventListener(q,U,{capture:!0})}}function v(){G.logMethod?.("teardownActionDelegation");for(let M of X)document.body.removeEventListener(M,U,{capture:!0});X.clear(),P.clear()}import{createLogger as A}from"@alwatr/logger";import{createChannelSignal as $}from"@alwatr/signal";var Y=A("page-ready"),B=$({name:"page-ready"});function c(M,q){Y.logMethodArgs?.("onPageReady",{pageId:M}),B.on(M,q)}function s(){Y.logMethod?.("dispatchPageReady");let M=document.querySelector("[page-id]");if(!M){Y.incident?.("dispatchPageReady","element_not_found");return}let q=M.getAttribute("page-id")?.trim();if(!q){Y.accident("dispatchPageReady","empty_page_id",{element:M});return}B.dispatch(q)}export{v as teardownActionDelegation,h as setupActionDelegation,p as registerPayloadResolver,b as registerModifier,c as onPageReady,f as onAction,s as dispatchPageReady,V as dispatchAction,w as DEFAULT_DELEGATED_EVENTS};
+/* 📦 @alwatr/action v9.14.0 */
+import{createLogger as U}from"@alwatr/logger";import{createChannelSignal as w}from"@alwatr/signal";var D=U("alwatr-action"),Z=w({name:"alwatr-action"});var N=new Map,Q=new Map;N.set("prevent",(q)=>{return q.preventDefault(),!0});N.set("validate",(q,z)=>{let G=z instanceof HTMLFormElement?z:z.closest("form");if(!G)return!1;return G.checkValidity()});Q.set("$value",(q,z)=>{return"value"in z?z.value:null});Q.set("$formdata",(q,z)=>{let G=z instanceof HTMLFormElement?z:z.closest("form");return G?Object.fromEntries(new FormData(G).entries()):null});function R(q,z){return D.logMethodArgs?.("onAction",{actionId:q}),Z.on(q,z)}function k(...q){let[z,G]=q;D.logMethodArgs?.("dispatchAction",{actionId:z,actionPayload:G}),Z.dispatch(z,G)}function E(q,z){if(D.logMethodArgs?.("registerModifier",{name:q}),N.has(q))D.accident("registerModifier","modifier_already_registered",{name:q});N.set(q,z)}function V(q,z){if(D.logMethodArgs?.("registerPayloadResolver",{name:q}),Q.has(q))D.accident("registerPayloadResolver","payload_resolver_already_registered",{name:q});Q.set(q,z)}var x=/^([a-z0-9.-]+)->([a-z0-9-]+)(?::(.+))?$/,X=new Map;function B(q){D.logMethodArgs?.("parseDescriptor__",{attributeValue:q});let z=X.get(q);if(z!==void 0)return z;let G=q.match(x);if(!G)return D.accident("parseDescriptor__","invalid_syntax",{attributeValue:q}),X.set(q,null),null;let[S,...F]=G[1].split(".");if(!S)return D.accident("parseDescriptor__","missing_event_type",{attributeValue:q}),X.set(q,null),null;let J=new Set(F),W=G[2],K=G[3],Y={eventType:S,modifiers:J,actionId:W,payload:K};return X.set(q,Y),Y}var M="on-action";function O(q){let z=q.type;D.logMethodArgs?.("handleDelegatedEvent__",{eventType:z});let G=q.target;if(!G)return;let S=G.closest?.(`[${M}^=${z}]`);if(!S)return;let F=S.getAttribute?.(M)?.trim();if(!F){D.accident("handleDelegatedEvent__","empty_attribute",{eventType:z,attributeValue:F,actionElement:S});return}if(!(S instanceof HTMLElement)){D.accident("handleDelegatedEvent__","target_not_html_element",{eventType:z,attributeValue:F,actionElement:S});return}let J=B(F);if(!J){D.accident("handleDelegatedEvent__","invalid_attribute",{eventType:z,attributeValue:F,actionElement:S});return}if(J.eventType!==z)return;if(D.logMethodArgs?.("handleDelegatedEvent__.action",J),J.modifiers.has("once"))S.removeAttribute(M),X.delete(F);for(let K of J.modifiers){if(K==="once")continue;let Y=N.get(K);if(!Y){D.accident("handleDelegatedEvent__","unknown_modifier",{modifier:K,attributeValue:F});return}if(Y(q,S)===!1)return}let W=J.payload;if(W){let K=Q.get(W);if(K)W=K(q,S)}Z.dispatch(J.actionId,W)}var H=new Set,P=["click","submit","input","change"];function y(q=P){D.logMethodArgs?.("setupActionDelegation",{eventTypes:q});for(let z of q){if(H.has(z))continue;H.add(z),document.body.addEventListener(z,O,{capture:!0})}}function p(){D.logMethod?.("teardownActionDelegation");for(let q of H)document.body.removeEventListener(q,O,{capture:!0});H.clear(),X.clear()}export{p as teardownActionDelegation,y as setupActionDelegation,V as registerPayloadResolver,E as registerModifier,R as onAction,k as dispatchAction,P as DEFAULT_DELEGATED_EVENTS};
 
-//# debugId=2E017DAE8A17903F64756E2164756E21
+//# debugId=7E5E853AFB39285764756E2164756E21
 //# sourceMappingURL=main.js.map

package/dist/main.js.map

@@ -1,14 +1,13 @@
 {
   "version": 3,
-  "sources": ["../src/lib.ts", "../src/registry.ts", "../src/method.ts", "../src/delegate.ts", "../src/page-ready.ts"],
+  "sources": ["../src/lib.ts", "../src/registry.ts", "../src/method.ts", "../src/delegate.ts"],
   "sourcesContent": [
-    "import {createLogger} from '@alwatr/logger';\nimport {createChannelSignal} from '@alwatr/signal';\nimport type {ActionRecord} from './action-record.js';\n\n/**\n * Module-scoped logger for `@alwatr/action`.\n * Scoped to `'alwatr-action'` so log lines are easy to filter in the console.\n *\n * @internal\n */\nexport const logger_ = createLogger('alwatr-action');\n\n/**\n * The action channel — a `ChannelSignal` strictly typed by `ActionRecord`.\n *\n * Only action names declared in `ActionRecord` (via declaration merging) are\n * accepted at compile time. Passing an unknown action name to `onAction` or\n * `dispatchAction` is a **compile error** — there is no string fallback.\n *\n * Uses `ChannelSignal` for O(1) routing: dispatching action `'A'` performs a\n * single `Map.get('A')` lookup and invokes only the handlers registered for\n * that specific action — never handlers for `'B'`, `'C'`, etc.\n *\n * `ActionRecord & Record<string, unknown>` satisfies the `ChannelSignal`\n * constraint (which requires an index signature) while keeping the public API\n * strictly limited to declared keys — the `Record<string, unknown>` part is\n * only visible to the internal channel, not to `onAction`/`dispatchAction`.\n *\n * @internal — not part of the public API; use `onAction` / `dispatchAction` instead.\n */\nexport const internalChannel_ = createChannelSignal<ActionRecord & Record<string, unknown>>({name: 'alwatr-action'});\n",
-    "// ─── Type Definitions ────────────────────────────────────────────────────────\n\n/**\n * A modifier handler used in `on-action` attribute syntax.\n *\n * Called with an `ActionContext` as `this` and the triggering DOM `event`.\n * Return `true` (or any truthy value) to allow the action to proceed,\n * or `false` to cancel the dispatch.\n *\n * @example\n * ```ts\n * // A modifier that only allows the action when the element is not disabled\n * const notDisabledHandler: ModifierHandler = function () {\n *   return !(this.element as HTMLButtonElement).disabled;\n * };\n * ```\n */\nexport type ModifierHandler = (event: Event, element: HTMLElement) => boolean;\n\n/**\n * A payload resolver used in `on-action` attribute syntax.\n *\n * Called with an `ActionContext` as `this` and the triggering DOM `event`\n * at dispatch time. The return value becomes the `actionPayload` passed to\n * `onAction` subscribers. Use this to compute dynamic payloads from DOM state.\n *\n * @example\n * ```ts\n * // A resolver that returns the element's dataset id\n * const dataIdResolver: PayloadResolver = function () {\n *   return (this.element as HTMLElement).dataset.id ?? null;\n * };\n * ```\n */\nexport type PayloadResolver = (event: Event, element: HTMLElement) => unknown;\n\n// ─── Registries ──────────────────────────────────────────────────────────────\n\n/**\n * Registry of all named modifier handlers.\n *\n * Keys are modifier names used in the `on-action` attribute syntax\n * (e.g. `click.prevent->action-id`). Values are `ModifierHandler` functions.\n * Populated at module load with built-in modifiers; extended at runtime via\n * `registerModifier`.\n *\n * @internal\n */\nexport const modifierRegistry = new Map<string, ModifierHandler>();\n\n/**\n * Registry of all named payload resolvers.\n *\n * Keys are resolver tokens used in the `on-action` attribute syntax\n * (e.g. `click->action-id:$value`). Values are `PayloadResolver` functions.\n * Populated at module load with built-in resolvers; extended at runtime via\n * `registerPayloadResolver`.\n *\n * @internal\n */\nexport const payloadRegistry = new Map<string, PayloadResolver>();\n\n// ─── Built-in Modifiers ───────────────────────────────────────────────────────\n\n/**\n * `prevent` — calls `event.preventDefault()` before dispatching.\n *\n * Use it to suppress the browser's default behaviour (e.g. form submission,\n * link navigation, context menu).\n *\n * @example `<form on-action=\"submit.prevent->submit-form\">`\n */\nmodifierRegistry.set('prevent', (event) => {\n  event.preventDefault();\n  return true;\n});\n\n/**\n * `validate` — cancels the dispatch if the nearest `<form>` fails validation.\n *\n * Looks for a `<form>` ancestor (or the element itself if it is a form) and\n * calls `checkValidity()`. If the form is invalid the action is not dispatched,\n * allowing native constraint-validation UI to surface errors. If no form is\n * found the dispatch is also cancelled.\n *\n * Pair with `.prevent` on `submit` events to avoid page reloads:\n *\n * @example `<form on-action=\"submit.prevent.validate->submit-form:$formdata\" novalidate>`\n */\nmodifierRegistry.set('validate', function (_, element) {\n  const form = element instanceof HTMLFormElement ? element : element.closest('form');\n  if (!form) return false;\n  return form.checkValidity();\n});\n\n// ─── Built-in Payload Resolvers ───────────────────────────────────────────────\n\n/**\n * `$value` — resolves to the element's `.value` property at dispatch time.\n *\n * Works with any element that exposes a `value` property: `<input>`,\n * `<textarea>`, `<select>`. Returns `null` for elements without `.value`.\n *\n * @example `<input on-action=\"input->search-query:$value\" />`\n */\npayloadRegistry.set('$value', function (_, element) {\n  return 'value' in element ? (element as {value: unknown}).value : null;\n});\n\n/**\n * `$formdata` — resolves to a plain object of all fields in the nearest `<form>`.\n *\n * Collects entries via `FormData` and converts them to a `Record<string, FormDataEntryValue>`.\n * Looks for a `<form>` ancestor (or the element itself). Returns `null` when no\n * form is found.\n *\n * @example `<form on-action=\"submit.prevent.validate->submit-form:$formdata\">`\n * ```ts\n * onAction<Record<string, FormDataEntryValue>>('submit-form', (data) => {\n *   console.log(data); // {username: 'ali', password: '…'}\n * });\n * ```\n */\npayloadRegistry.set('$formdata', function (_, element) {\n  const form = element instanceof HTMLFormElement ? element : element.closest('form');\n  return form ? Object.fromEntries(new FormData(form).entries()) : null;\n});\n",
-    "import {internalChannel_, logger_} from './lib.js';\nimport type {SubscribeResult} from '@alwatr/signal';\nimport {modifierRegistry, payloadRegistry, type ModifierHandler, type PayloadResolver} from './registry.js';\nimport type {ActionRecord} from './action-record.js';\n\n// Re-export extension types so consumers can import them from the package root.\nexport type {ModifierHandler, PayloadResolver};\n\n// ─── Core Action API ──────────────────────────────────────────────────────────\n\n/**\n * Subscribes to a named action dispatched anywhere in the application.\n *\n * `actionId` must be a key of `ActionRecord`. The handler's `payload` parameter\n * is automatically typed to the corresponding `ActionRecord` value — no manual\n * generic annotation needed:\n *\n * ```ts\n * // ActionRecord declares: 'add-to-cart': {productId: number; qty: number}\n * onAction('add-to-cart', (item) => {\n *   cartService.add(item.productId, item.qty); // fully typed, no `!` needed\n * });\n * ```\n *\n * Passing an action name not declared in `ActionRecord` is a **compile error**.\n * Register new actions by extending `ActionRecord` via declaration merging:\n *\n * ```ts\n * // src/action-record.ts\n * declare module '@alwatr/action' {\n *   interface ActionRecord {\n *     'open-drawer': string;\n *   }\n * }\n * ```\n *\n * Internally delegates to `ChannelSignal.on()` for **O(1) routing** — dispatching\n * action `'A'` never invokes handlers registered for action `'B'`.\n *\n * @param actionId - A key of `ActionRecord`.\n * @param handler  - Callback invoked with the typed payload on each dispatch.\n * @returns A `SubscribeResult` with an `unsubscribe()` method for cleanup.\n *\n * @example\n * ```ts\n * import {onAction} from '@alwatr/action';\n *\n * const sub = onAction('page-ready', (pageId) => {\n *   router.setPage(pageId); // pageId: string — inferred from ActionRecord\n * });\n *\n * sub.unsubscribe(); // stop listening when no longer needed\n * ```\n */\nexport function onAction<K extends keyof ActionRecord>(\n  actionId: K,\n  handler: (payload: ActionRecord[K]) => void,\n): SubscribeResult {\n  logger_.logMethodArgs?.('onAction', {actionId});\n  // Cast through `unknown` to bridge the gap between the strict public signature\n  // (ActionRecord[K]) and the internal channel's wider type (ActionRecord & Record<string, unknown>).\n  return internalChannel_.on(actionId as string, handler as (payload: unknown) => void);\n}\n\n/**\n * Dispatches a named action to all `onAction` subscribers with a matching `actionId`.\n *\n * `actionId` must be a key of `ActionRecord`. The `payload` parameter is\n * automatically typed — passing the wrong type is a **compile error**:\n *\n * ```ts\n * // ActionRecord declares: 'add-to-cart': {productId: number; qty: number}\n * dispatchAction('add-to-cart', {productId: 42, qty: 1}); // ✅\n * dispatchAction('add-to-cart', 'wrong');                  // ❌ compile error\n * dispatchAction('unknown-action', 'x');                   // ❌ compile error\n * ```\n *\n * Register new actions by extending `ActionRecord` via declaration merging:\n *\n * ```ts\n * // src/action-record.ts\n * declare module '@alwatr/action' {\n *   interface ActionRecord {\n *     'navigate': string;\n *     'logout': void;\n *   }\n * }\n * ```\n *\n * Use `dispatchAction` when triggering an action from code — e.g. after an\n * async operation, from a service layer, or in tests. For DOM-driven actions,\n * use the `on-action` HTML attribute with `setupActionDelegation`.\n *\n * @param actionId      - A key of `ActionRecord`.\n * @param actionPayload - The payload; type is enforced by `ActionRecord`.\n *\n * @example — with payload\n * ```ts\n * import {dispatchAction} from '@alwatr/action';\n *\n * dispatchAction('page-ready', 'home');\n * dispatchAction('navigate', '/dashboard');\n * ```\n *\n * @example — void payload (no second argument)\n * ```ts\n * dispatchAction('logout');\n * ```\n */\n// Overload for actions with a void/undefined payload — second argument omitted.\nexport function dispatchAction<K extends keyof ActionRecord>(\n  ...args: ActionRecord[K] extends void | undefined ? [actionId: K] : [actionId: K, actionPayload: ActionRecord[K]]\n): void;\n// Implementation\nexport function dispatchAction(actionId: keyof ActionRecord, actionPayload?: unknown): void {\n  logger_.logMethodArgs?.('dispatchAction', {actionId, actionPayload});\n  internalChannel_.dispatch(actionId as string, actionPayload);\n}\n\n// ─── Extension API ────────────────────────────────────────────────────────────\n\n/**\n * Registers a custom modifier that can be used in `on-action` attribute syntax.\n *\n * A modifier is a dot-chained token placed after the event type\n * (e.g. `click.mymod->action-id`). Its handler runs before the payload is\n * resolved and the action is dispatched. Returning `false` cancels the dispatch.\n *\n * Built-in modifiers (`prevent`, `stop`, `validate`, `once`) are always\n * available. This function lets you add domain-specific ones.\n *\n * Registering the same name twice logs an accident and overwrites the previous\n * handler — avoid duplicate registrations in production code.\n *\n * @param name    - The modifier token (lowercase, no dots or arrows).\n * @param handler - The `ModifierHandler` function bound to an `ActionContext`.\n *\n * @example — a `confirm` modifier that shows a browser dialog\n * ```ts\n * import {registerModifier} from '@alwatr/action';\n *\n * registerModifier('confirm', function () {\n *   return window.confirm('Are you sure?');\n * });\n * ```\n * ```html\n * <button on-action=\"click.confirm->delete-item:42\">Delete</button>\n * ```\n */\nexport function registerModifier(name: string, handler: ModifierHandler): void {\n  logger_.logMethodArgs?.('registerModifier', {name});\n  if (modifierRegistry.has(name)) {\n    logger_.accident('registerModifier', 'modifier_already_registered', {name});\n  }\n  modifierRegistry.set(name, handler);\n}\n\n/**\n * Registers a custom payload resolver that can be used in `on-action` attribute syntax.\n *\n * A payload resolver is a colon-suffixed token in the attribute value\n * (e.g. `click->action-id:$mytoken`). Its function is called at dispatch time\n * with an `ActionContext` as `this` and the DOM event as the argument.\n * The return value becomes the `actionPayload` passed to `onAction` subscribers.\n *\n * Built-in resolvers (`$value`, `$formdata`) are always available. This function\n * lets you add domain-specific ones.\n *\n * Registering the same name twice logs an accident and overwrites the previous\n * resolver — avoid duplicate registrations in production code.\n *\n * @param name     - The resolver token (should start with `$` by convention).\n * @param resolver - The `PayloadResolver` function bound to an `ActionContext`.\n *\n * @example — a `$checked` resolver for checkbox state\n * ```ts\n * import {registerPayloadResolver} from '@alwatr/action';\n *\n * registerPayloadResolver('$checked', function () {\n *   return (this.element as HTMLInputElement).checked;\n * });\n * ```\n * ```html\n * <input type=\"checkbox\" on-action=\"change->toggle-feature:$checked\" />\n * ```\n */\nexport function registerPayloadResolver(name: string, resolver: PayloadResolver): void {\n  logger_.logMethodArgs?.('registerPayloadResolver', {name});\n  if (payloadRegistry.has(name)) {\n    logger_.accident('registerPayloadResolver', 'payload_resolver_already_registered', {name});\n  }\n  payloadRegistry.set(name, resolver);\n}\n",
-    "/**\n * @file delegate.ts\n *\n * Global Event Delegation engine for `@alwatr/action`.\n *\n * ## Why delegation instead of per-element listeners?\n *\n * The classic directive approach attaches one `addEventListener` per element.\n * With 100 buttons on a page, that means 100 listener registrations at boot\n * time — O(N) initialization cost, O(N) memory for listener references, and\n * zero support for elements added after bootstrap.\n *\n * This module implements the **Qwik-inspired global delegation** pattern:\n * - A single listener per event type is attached to `document.body` with\n *   `capture: true` (so it fires even for non-bubbling events).\n * - When an event fires, the handler walks up the DOM from `event.target`\n *   using `closest()` to find the nearest element with an `on-action`\n *   attribute whose event type matches.\n * - Modifiers and payload resolvers run in the same pipeline as before.\n * - `dispatchAction` is called with the resolved payload.\n *\n * ## Complexity\n *\n * | Metric          | Per-element listeners | Global delegation |\n * | --------------- | --------------------- | ----------------- |\n * | Boot time       | O(N elements)         | O(1) — 1 loop     |\n * | Memory          | O(N listeners)        | O(1) — 1 handler  |\n * | Dynamic content | Requires re-bootstrap | Works out-of-box  |\n * | `once` modifier | Native option         | Manual tracking   |\n *\n * ## Trade-offs vs. the directive approach\n *\n * - `passive` is not supported as a per-element option (all delegated listeners\n *   are non-passive so that `prevent` can call `preventDefault()`).\n * - `stop` stops further bubbling but the delegation handler has already\n *   captured the event at `body` level — it does not prevent other delegation\n *   handlers from running on the same element.\n * - `once` is emulated by delete attribute elements after first fire.\n */\n\nimport {internalChannel_, logger_} from './lib.js';\nimport {modifierRegistry, payloadRegistry} from './registry.js';\n\n// ─── Syntax Parser ────────────────────────────────────────────────────────────\n\n/**\n * Parses the `on-action` attribute value into its three segments.\n *\n * Full syntax: `eventType[.modifier…]->actionId[:payload]`\n *\n * | Capture group | Matches                                     | Example              |\n * | ------------- | ------------------------------------------- | -------------------- |\n * | 1             | Event type + optional dot-chained modifiers | `click.prevent.once` |\n * | 2             | Action identifier                           | `open-drawer`        |\n * | 3             | Optional payload token or literal           | `main` / `$value`    |\n *\n * @example\n * ```\n * 'click.prevent.once->open-drawer:main' → ['click.prevent.once', 'open-drawer', 'main']\n * 'input->search-query:$value'           → ['input',              'search-query', '$value']\n * 'submit.prevent->submit-form'          → ['submit.prevent',     'submit-form',  undefined]\n * ```\n */\nconst syntaxRegex = /^([a-z0-9.-]+)->([a-z0-9-]+)(?::(.+))?$/;\n\n// ─── Parsed Action Descriptor ─────────────────────────────────────────────────\n\n/**\n * Parsed and cached representation of a single `on-action` attribute value.\n *\n * Caching avoids re-parsing the same attribute string on every event fire.\n * The cache is keyed by the raw attribute string so identical values share\n * the same descriptor object.\n */\ninterface ActionDescriptor {\n  /** The DOM event type to listen for (e.g. `'click'`, `'input'`). */\n  readonly eventType: string;\n  /** Set of active modifier names (e.g. `{'prevent', 'once'}`). */\n  readonly modifiers: ReadonlySet<string>;\n  /** The action identifier dispatched to `onAction` subscribers. */\n  readonly actionId: string;\n  /** Raw payload token from the attribute (literal string or `$`-resolver key). */\n  readonly payload: string | undefined;\n}\n\n/**\n * LRU-style cache for parsed `on-action` attribute values.\n *\n * Attribute strings are typically repeated across many elements (e.g. every\n * \"add to cart\" button shares the same `on-action` value). Caching the parsed\n * descriptor avoids redundant regex work on every event.\n *\n * Using a plain `Map` here is intentional — attribute strings are short-lived\n * keys and the map size is bounded by the number of distinct `on-action` values\n * in the page, which is typically small.\n *\n * @internal\n */\nconst descriptorCache__ = new Map<string, ActionDescriptor | null>();\n\n/**\n * Parses an `on-action` attribute value into an `ActionDescriptor`.\n *\n * Returns `null` when the syntax is invalid. Results are cached by the raw\n * attribute string so repeated calls for the same value are O(1).\n *\n * @internal\n */\nfunction parseDescriptor__(attributeValue: string): ActionDescriptor | null {\n  logger_.logMethodArgs?.('parseDescriptor__', {attributeValue});\n\n  const cached = descriptorCache__.get(attributeValue);\n  // Explicit `undefined` check: `null` means \"already parsed and invalid\".\n  if (cached !== undefined) return cached;\n\n  const match = attributeValue.match(syntaxRegex);\n  if (!match) {\n    logger_.accident('parseDescriptor__', 'invalid_syntax', {attributeValue});\n    descriptorCache__.set(attributeValue, null);\n    return null;\n  }\n\n  const [eventType, ...modifierList] = match[1].split('.');\n  if (!eventType) {\n    logger_.accident('parseDescriptor__', 'missing_event_type', {attributeValue});\n    descriptorCache__.set(attributeValue, null);\n    return null;\n  }\n\n  const modifiers = new Set(modifierList);\n  const actionId = match[2];\n  const payload: string | undefined = match[3];\n\n  const descriptor: ActionDescriptor = {\n    eventType,\n    modifiers,\n    actionId,\n    payload,\n  };\n\n  descriptorCache__.set(attributeValue, descriptor);\n  return descriptor;\n}\n\n// ─── Core Delegation Handler ──────────────────────────────────────────────────\n\nconst onActionAttrib__ = 'on-action';\n/**\n * Central event handler attached to `document.body` for every delegated event type.\n *\n * Execution flow for each incoming event:\n * 1. Walk up from `event.target` to find the nearest element with an\n *    `on-action` attribute whose event type matches the current event.\n * 2. Parse (or retrieve from cache) the `ActionDescriptor` for that attribute.\n * 3. Run each modifier in order; if any returns `false`, abort.\n * 4. Resolve the payload token (literal or `$`-resolver).\n * 5. Call `dispatchAction(actionId, payload)`.\n *\n * @internal\n */\nfunction handleDelegatedEvent__(event: Event): void {\n  const eventType = event.type;\n  logger_.logMethodArgs?.('handleDelegatedEvent__', {eventType});\n\n  // Walk up the DOM to find the closest element with a matching on-action attribute.\n  // We use `closest` on the composedPath target to support Shadow DOM correctly.\n  const target = event.target as Element | null;\n  if (!target) return;\n\n  // Find the nearest ancestor (or self) that has an on-action attribute\n  const actionElement = target.closest?.(`[${onActionAttrib__}^=${eventType}]`);\n  if (!actionElement) return;\n\n  const attributeValue = actionElement.getAttribute?.(onActionAttrib__)?.trim();\n  if (!attributeValue) {\n    logger_.accident('handleDelegatedEvent__', 'empty_attribute', {eventType, attributeValue, actionElement});\n    return;\n  }\n\n  if (!(actionElement instanceof HTMLElement)) {\n    logger_.accident('handleDelegatedEvent__', 'target_not_html_element', {eventType, attributeValue, actionElement});\n    return;\n  }\n\n  const descriptor = parseDescriptor__(attributeValue);\n  if (!descriptor) {\n    logger_.accident('handleDelegatedEvent__', 'invalid_attribute', {eventType, attributeValue, actionElement});\n    return;\n  }\n\n  if (descriptor.eventType !== eventType) return;\n\n  logger_.logMethodArgs?.('handleDelegatedEvent__.action', descriptor);\n\n  // Step 1: handle once modifier\n  if (descriptor.modifiers.has('once')) {\n    actionElement.removeAttribute(onActionAttrib__); // remove on-action to prevent repeat the action\n    descriptorCache__.delete(attributeValue); // free memory for once\n  }\n\n  // Step 2: run modifiers\n  for (const modifier of descriptor.modifiers) {\n    if (modifier === 'once') continue; // handled separately\n    const handler = modifierRegistry.get(modifier);\n    if (!handler) {\n      logger_.accident('handleDelegatedEvent__', 'unknown_modifier', {modifier, attributeValue});\n      return; // unknown modifier — abort to avoid silent misbehaviour\n    }\n    if (handler(event, actionElement) === false) return;\n  }\n\n  // Step 3: resolve payload\n  let payload: unknown = descriptor.payload;\n  if (payload) {\n    const resolver = payloadRegistry.get(payload as string);\n    if (resolver) payload = resolver(event, actionElement);\n  }\n\n  // Step 4: dispatch\n  internalChannel_.dispatch(descriptor.actionId, payload);\n}\n\n// ─── Setup ────────────────────────────────────────────────────────────────────\n\n/**\n * The set of event types currently delegated to `document.body`.\n *\n * Tracked so that `setupActionDelegation` is idempotent — calling it multiple\n * times with the same event types does not register duplicate listeners.\n *\n * @internal\n */\nconst delegatedEventTypes__ = new Set<string>();\n\n/**\n * Default DOM event types that cover the vast majority of interactive elements.\n *\n * - `click` — buttons, links, checkboxes, custom interactive elements\n * - `submit` — form submission\n * - `input` — live text input, range sliders\n * - `change` — select boxes, checkboxes, radio buttons (fires on commit)\n *\n * Pass additional types to `setupActionDelegation` when your app uses other\n * events (e.g. `'keydown'`, `'pointerup'`).\n */\nexport const DEFAULT_DELEGATED_EVENTS: readonly string[] = ['click', 'submit', 'input', 'change'];\n\n/**\n * Registers global event delegation for `on-action` attributes.\n *\n * Attaches a single `capture`-phase listener on `document.body` for each\n * event type in `eventTypes`. All `on-action` processing — modifier execution,\n * payload resolution, and `dispatchAction` — happens inside that one handler.\n *\n * **Call this once at application bootstrap**, before any user interaction.\n * Subsequent calls with the same event types are no-ops (idempotent).\n *\n * ### Why `capture: true`?\n *\n * Capture-phase listeners fire before bubble-phase listeners and also catch\n * events that do not bubble (e.g. `focus`, `blur`). This ensures the delegation\n * handler always runs, even when a child element calls `stopPropagation()`.\n *\n * ### Dynamic content\n *\n * Because the listener lives on `document.body`, any element added to the DOM\n * after this call — via `innerHTML`, `lit-html`, a framework renderer, or\n * server-sent HTML — is automatically covered. No re-bootstrap is needed.\n *\n * @param eventTypes - Event types to delegate. Defaults to `DEFAULT_DELEGATED_EVENTS`.\n *\n * @example — minimal bootstrap\n * ```ts\n * import {setupActionDelegation, onAction} from '@alwatr/action';\n *\n * // One call activates the entire page.\n * setupActionDelegation();\n *\n * onAction('open-drawer', (panel) => openDrawer(panel));\n * ```\n *\n * @example — with extra event types\n * ```ts\n * import {setupActionDelegation, DEFAULT_DELEGATED_EVENTS} from '@alwatr/action';\n *\n * setupActionDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown', 'pointerup']);\n * ```\n */\nexport function setupActionDelegation(eventTypes: readonly string[] = DEFAULT_DELEGATED_EVENTS): void {\n  logger_.logMethodArgs?.('setupActionDelegation', {eventTypes});\n\n  for (const eventType of eventTypes) {\n    if (delegatedEventTypes__.has(eventType)) continue; // already registered — skip\n    delegatedEventTypes__.add(eventType);\n    // capture: true — fires before bubble-phase listeners and catches non-bubbling events.\n    document.body.addEventListener(eventType, handleDelegatedEvent__, {capture: true});\n  }\n}\n\n/**\n * Removes all global delegation listeners registered by `setupActionDelegation`.\n *\n * Useful in test environments where each test needs a clean slate, or in\n * micro-frontend setups where a sub-app is unmounted.\n *\n * After calling this, `setupActionDelegation` can be called again to re-register.\n */\nexport function teardownActionDelegation(): void {\n  logger_.logMethod?.('teardownActionDelegation');\n  for (const eventType of delegatedEventTypes__) {\n    document.body.removeEventListener(eventType, handleDelegatedEvent__, {capture: true});\n  }\n  delegatedEventTypes__.clear();\n  descriptorCache__.clear();\n}\n",
-    "import {createLogger} from '@alwatr/logger';\nimport {createChannelSignal} from '@alwatr/signal';\n\nconst logger = createLogger('page-ready');\n\nconst pageReadyChannel_ = createChannelSignal<Record<string, undefined>>({\n  name: 'page-ready',\n});\n\nexport function onPageReady<T extends string>(pageId: T, handler: () => void) {\n  logger.logMethodArgs?.('onPageReady', {pageId});\n  pageReadyChannel_.on(pageId, handler);\n}\n\nexport function dispatchPageReady(): void {\n  logger.logMethod?.('dispatchPageReady');\n  const element = document.querySelector('[page-id]');\n  if (!element) {\n    logger.incident?.('dispatchPageReady', 'element_not_found');\n    return;\n  }\n\n  const pageId = element.getAttribute('page-id')?.trim();\n\n  if (!pageId) {\n    logger.accident('dispatchPageReady', 'empty_page_id', {element});\n    return;\n  }\n\n  pageReadyChannel_.dispatch(pageId);\n}\n"
+    "import {createLogger} from '@alwatr/logger';\nimport {createChannelSignal} from '@alwatr/signal';\n\n/**\n * Module-scoped logger for `@alwatr/action`.\n * Scoped to `'alwatr-action'` so log lines are easy to filter in the console.\n *\n * @internal\n */\nexport const logger_ = createLogger('alwatr-action');\n\n/**\n * The action channel — a `ChannelSignal` strictly typed by `ActionRecord`.\n *\n * Only action names declared in `ActionRecord` (via declaration merging) are\n * accepted at compile time. Passing an unknown action name to `onAction` or\n * `dispatchAction` is a **compile error** — there is no string fallback.\n *\n * Uses `ChannelSignal` for O(1) routing: dispatching action `'A'` performs a\n * single `Map.get('A')` lookup and invokes only the handlers registered for\n * that specific action — never handlers for `'B'`, `'C'`, etc.\n *\n * @internal — not part of the public API; use `onAction` / `dispatchAction` instead.\n */\nexport const internalChannel_ = createChannelSignal<Record<string, unknown>>({name: 'alwatr-action'});\n",
+    "// ─── Type Definitions ────────────────────────────────────────────────────────\n\n/**\n * A modifier handler used in `on-action` attribute syntax.\n *\n * Receives the triggering DOM `event` and the `element` that owns the\n * `on-action` attribute. Return `true` (or any truthy value) to allow the\n * action to proceed, or `false` to cancel the dispatch.\n *\n * Using explicit parameters instead of `this` binding makes handlers\n * compatible with arrow functions and easier to test in isolation.\n *\n * @example\n * ```ts\n * // A modifier that only allows the action when the element is not disabled\n * const notDisabledHandler: ModifierHandler = (_event, element) => {\n *   return !(element as HTMLButtonElement).disabled;\n * };\n * ```\n */\nexport type ModifierHandler = (event: Event, element: HTMLElement) => boolean;\n\n/**\n * A payload resolver used in `on-action` attribute syntax.\n *\n * Receives the triggering DOM `event` and the `element` that owns the\n * `on-action` attribute. The return value becomes the `actionPayload` passed\n * to `onAction` subscribers. Use this to compute dynamic payloads from DOM state.\n *\n * Using explicit parameters instead of `this` binding makes resolvers\n * compatible with arrow functions and easier to test in isolation.\n *\n * @example\n * ```ts\n * // A resolver that returns the element's dataset id\n * const dataIdResolver: PayloadResolver = (_event, element) => {\n *   return (element as HTMLElement).dataset.id ?? null;\n * };\n * ```\n */\nexport type PayloadResolver = (event: Event, element: HTMLElement) => unknown;\n\n// ─── Registries ──────────────────────────────────────────────────────────────\n\n/**\n * Registry of all named modifier handlers.\n *\n * Keys are modifier names used in the `on-action` attribute syntax\n * (e.g. `click.prevent->action-id`). Values are `ModifierHandler` functions.\n * Populated at module load with built-in modifiers; extended at runtime via\n * `registerModifier`.\n *\n * @internal\n */\nexport const modifierRegistry = new Map<string, ModifierHandler>();\n\n/**\n * Registry of all named payload resolvers.\n *\n * Keys are resolver tokens used in the `on-action` attribute syntax\n * (e.g. `click->action-id:$value`). Values are `PayloadResolver` functions.\n * Populated at module load with built-in resolvers; extended at runtime via\n * `registerPayloadResolver`.\n *\n * @internal\n */\nexport const payloadRegistry = new Map<string, PayloadResolver>();\n\n// ─── Built-in Modifiers ───────────────────────────────────────────────────────\n\n/**\n * `prevent` — calls `event.preventDefault()` before dispatching.\n *\n * Use it to suppress the browser's default behaviour (e.g. form submission,\n * link navigation, context menu).\n *\n * @example `<form on-action=\"submit.prevent->submit-form\">`\n */\nmodifierRegistry.set('prevent', (event) => {\n  event.preventDefault();\n  return true;\n});\n\n/**\n * `validate` — cancels the dispatch if the nearest `<form>` fails validation.\n *\n * Looks for a `<form>` ancestor (or the element itself if it is a form) and\n * calls `checkValidity()`. If the form is invalid the action is not dispatched,\n * allowing native constraint-validation UI to surface errors. If no form is\n * found the dispatch is also cancelled.\n *\n * Pair with `.prevent` on `submit` events to avoid page reloads:\n *\n * @example `<form on-action=\"submit.prevent.validate->submit-form:$formdata\" novalidate>`\n */\nmodifierRegistry.set('validate', (_event, element) => {\n  const form = element instanceof HTMLFormElement ? element : element.closest('form');\n  if (!form) return false;\n  return form.checkValidity();\n});\n\n// ─── Built-in Payload Resolvers ───────────────────────────────────────────────\n\n/**\n * `$value` — resolves to the element's `.value` property at dispatch time.\n *\n * Works with any element that exposes a `value` property: `<input>`,\n * `<textarea>`, `<select>`. Returns `null` for elements without `.value`.\n *\n * @example `<input on-action=\"input->search-query:$value\" />`\n */\npayloadRegistry.set('$value', (_event, element) => {\n  return 'value' in element ? (element as {value: unknown}).value : null;\n});\n\n/**\n * `$formdata` — resolves to a plain object of all fields in the nearest `<form>`.\n *\n * Collects entries via `FormData` and converts them to a `Record<string, FormDataEntryValue>`.\n * Looks for a `<form>` ancestor (or the element itself). Returns `null` when no\n * form is found.\n *\n * @example `<form on-action=\"submit.prevent.validate->submit-form:$formdata\">`\n * ```ts\n * onAction('submit-form', (data) => {\n *   console.log(data); // {username: 'ali', password: '…'}\n * });\n * ```\n */\npayloadRegistry.set('$formdata', (_event, element) => {\n  const form = element instanceof HTMLFormElement ? element : element.closest('form');\n  return form ? Object.fromEntries(new FormData(form).entries()) : null;\n});\n",
+    "import type {Awaitable} from '@alwatr/type-helper';\nimport {internalChannel_, logger_} from './lib.js';\nimport type {SubscribeResult} from '@alwatr/signal';\nimport {modifierRegistry, payloadRegistry, type ModifierHandler, type PayloadResolver} from './registry.js';\nimport type {ActionRecord} from './action-record.js';\n\n// Re-export extension types so consumers can import them from the package root.\nexport type {ModifierHandler, PayloadResolver};\n\n// ─── Core Action API ──────────────────────────────────────────────────────────\n\n/**\n * Subscribes to a named action dispatched anywhere in the application.\n *\n * `actionId` must be a key of `ActionRecord`. The handler's `payload` parameter\n * is automatically typed to the corresponding `ActionRecord` value — no manual\n * generic annotation needed:\n *\n * ```ts\n * // ActionRecord declares: 'add-to-cart': {productId: number; qty: number}\n * onAction('add-to-cart', (item) => {\n *   cartService.add(item.productId, item.qty); // fully typed, no `!` needed\n * });\n * ```\n *\n * Passing an action name not declared in `ActionRecord` is a **compile error**.\n * Register new actions by extending `ActionRecord` via declaration merging:\n *\n * ```ts\n * // src/action-record.ts\n * declare module '@alwatr/action' {\n *   interface ActionRecord {\n *     'open-drawer': string;\n *   }\n * }\n * ```\n *\n * Internally delegates to `ChannelSignal.on()` for **O(1) routing** — dispatching\n * action `'A'` never invokes handlers registered for action `'B'`.\n *\n * @param actionId - A key of `ActionRecord`.\n * @param handler  - Callback invoked with the typed payload on each dispatch.\n * @returns A `SubscribeResult` with an `unsubscribe()` method for cleanup.\n *\n * @example\n * ```ts\n * import {onAction} from '@alwatr/action';\n *\n * const sub = onAction('page-ready', (pageId) => {\n *   router.setPage(pageId); // pageId: string — inferred from ActionRecord\n * });\n *\n * sub.unsubscribe(); // stop listening when no longer needed\n * ```\n */\nexport function onAction<K extends keyof ActionRecord>(\n  actionId: K,\n  handler: (payload: ActionRecord[K]) => Awaitable<void>,\n): SubscribeResult {\n  logger_.logMethodArgs?.('onAction', {actionId});\n  return internalChannel_.on(actionId, handler as (payload: unknown) => Awaitable<void>);\n}\n\n/**\n * Dispatches a named action to all `onAction` subscribers with a matching `actionId`.\n *\n * `actionId` must be a key of `ActionRecord`. The `payload` parameter is\n * automatically typed — passing the wrong type is a **compile error**:\n *\n * ```ts\n * // ActionRecord declares: 'add-to-cart': {productId: number; qty: number}\n * dispatchAction('add-to-cart', {productId: 42, qty: 1}); // ✅\n * dispatchAction('add-to-cart', 'wrong');                  // ❌ compile error\n * dispatchAction('unknown-action', 'x');                   // ❌ compile error\n * ```\n *\n * Register new actions by extending `ActionRecord` via declaration merging:\n *\n * ```ts\n * // src/action-record.ts\n * declare module '@alwatr/action' {\n *   interface ActionRecord {\n *     'navigate': string;\n *     'logout': void;\n *   }\n * }\n * ```\n *\n * Use `dispatchAction` when triggering an action from code — e.g. after an\n * async operation, from a service layer, or in tests. For DOM-driven actions,\n * use the `on-action` HTML attribute with `setupActionDelegation`.\n *\n * @param actionId      - A key of `ActionRecord`.\n * @param actionPayload - The payload; type is enforced by `ActionRecord`.\n *\n * @example — with payload\n * ```ts\n * import {dispatchAction} from '@alwatr/action';\n *\n * dispatchAction('page-ready', 'home');\n * dispatchAction('navigate', '/dashboard');\n * ```\n *\n * @example — void payload (no second argument)\n * ```ts\n * dispatchAction('logout');\n * ```\n */\nexport function dispatchAction<K extends keyof ActionRecord>(\n  ...args: ActionRecord[K] extends void | undefined ? [actionId: K] : [actionId: K, actionPayload: ActionRecord[K]]\n): void {\n  const [actionId, actionPayload] = args;\n  logger_.logMethodArgs?.('dispatchAction', {actionId, actionPayload});\n  internalChannel_.dispatch(actionId, actionPayload);\n}\n\n// ─── Extension API ────────────────────────────────────────────────────────────\n\n/**\n * Registers a custom modifier that can be used in `on-action` attribute syntax.\n *\n * A modifier is a dot-chained token placed after the event type\n * (e.g. `click.mymod->action-id`). Its handler runs before the payload is\n * resolved and the action is dispatched. Returning `false` cancels the dispatch.\n *\n * Built-in modifiers (`prevent`, `stop`, `validate`, `once`) are always\n * available. This function lets you add domain-specific ones.\n *\n * Registering the same name twice logs an accident and overwrites the previous\n * handler — avoid duplicate registrations in production code.\n *\n * @param name    - The modifier token (lowercase, no dots or arrows).\n * @param handler - A `ModifierHandler` receiving `(event, element)`.\n *\n * @example — a `confirm` modifier that shows a browser dialog\n * ```ts\n * import {registerModifier} from '@alwatr/action';\n *\n * registerModifier('confirm', () => window.confirm('Are you sure?'));\n * ```\n * ```html\n * <button on-action=\"click.confirm->delete-item:42\">Delete</button>\n * ```\n */\nexport function registerModifier(name: string, handler: ModifierHandler): void {\n  logger_.logMethodArgs?.('registerModifier', {name});\n  if (modifierRegistry.has(name)) {\n    logger_.accident('registerModifier', 'modifier_already_registered', {name});\n  }\n  modifierRegistry.set(name, handler);\n}\n\n/**\n * Registers a custom payload resolver that can be used in `on-action` attribute syntax.\n *\n * A payload resolver is a colon-suffixed token in the attribute value\n * (e.g. `click->action-id:$mytoken`). Its function is called at dispatch time\n * with an `ActionContext` as `this` and the DOM event as the argument.\n * The return value becomes the `actionPayload` passed to `onAction` subscribers.\n *\n * Built-in resolvers (`$value`, `$formdata`) are always available. This function\n * lets you add domain-specific ones.\n *\n * Registering the same name twice logs an accident and overwrites the previous\n * resolver — avoid duplicate registrations in production code.\n *\n * @param name     - The resolver token (should start with `$` by convention).\n * @param resolver - A `PayloadResolver` receiving `(event, element)`.\n *\n * @example — a `$checked` resolver for checkbox state\n * ```ts\n * import {registerPayloadResolver} from '@alwatr/action';\n *\n * registerPayloadResolver('$checked', (_event, element) => {\n *   return (element as HTMLInputElement).checked;\n * });\n * ```\n * ```html\n * <input type=\"checkbox\" on-action=\"change->toggle-feature:$checked\" />\n * ```\n */\nexport function registerPayloadResolver(name: string, resolver: PayloadResolver): void {\n  logger_.logMethodArgs?.('registerPayloadResolver', {name});\n  if (payloadRegistry.has(name)) {\n    logger_.accident('registerPayloadResolver', 'payload_resolver_already_registered', {name});\n  }\n  payloadRegistry.set(name, resolver);\n}\n",
+    "/**\n * @file delegate.ts\n *\n * Global Event Delegation engine for `@alwatr/action`.\n *\n * ## Why delegation instead of per-element listeners?\n *\n * The classic directive approach attaches one `addEventListener` per element.\n * With 100 buttons on a page, that means 100 listener registrations at boot\n * time — O(N) initialization cost, O(N) memory for listener references, and\n * zero support for elements added after bootstrap.\n *\n * This module implements the **Qwik-inspired global delegation** pattern:\n * - A single listener per event type is attached to `document.body` with\n *   `capture: true` (so it fires even for non-bubbling events).\n * - When an event fires, the handler walks up the DOM from `event.target`\n *   using `closest()` to find the nearest element with an `on-action`\n *   attribute whose event type matches.\n * - Modifiers and payload resolvers run in the same pipeline as before.\n * - `dispatchAction` is called with the resolved payload.\n *\n * ## Complexity\n *\n * | Metric          | Per-element listeners | Global delegation |\n * | --------------- | --------------------- | ----------------- |\n * | Boot time       | O(N elements)         | O(1) — 1 loop     |\n * | Memory          | O(N listeners)        | O(1) — 1 handler  |\n * | Dynamic content | Requires re-bootstrap | Works out-of-box  |\n * | `once` modifier | Native option         | Manual tracking   |\n *\n * ## Trade-offs vs. the directive approach\n *\n * - `passive` is not supported as a per-element option (all delegated listeners\n *   are non-passive so that `prevent` can call `preventDefault()`).\n * - `stop` stops further bubbling but the delegation handler has already\n *   captured the event at `body` level — it does not prevent other delegation\n *   handlers from running on the same element.\n * - `once` is emulated by delete attribute elements after first fire.\n */\n\nimport {internalChannel_, logger_} from './lib.js';\nimport {modifierRegistry, payloadRegistry} from './registry.js';\n\n// ─── Syntax Parser ────────────────────────────────────────────────────────────\n\n/**\n * Parses the `on-action` attribute value into its three segments.\n *\n * Full syntax: `eventType[.modifier…]->actionId[:payload]`\n *\n * | Capture group | Matches                                     | Example              |\n * | ------------- | ------------------------------------------- | -------------------- |\n * | 1             | Event type + optional dot-chained modifiers | `click.prevent.once` |\n * | 2             | Action identifier                           | `open-drawer`        |\n * | 3             | Optional payload token or literal           | `main` / `$value`    |\n *\n * @example\n * ```\n * 'click.prevent.once->open-drawer:main' → ['click.prevent.once', 'open-drawer', 'main']\n * 'input->search-query:$value'           → ['input',              'search-query', '$value']\n * 'submit.prevent->submit-form'          → ['submit.prevent',     'submit-form',  undefined]\n * ```\n */\nconst syntaxRegex = /^([a-z0-9.-]+)->([a-z0-9-]+)(?::(.+))?$/;\n\n// ─── Parsed Action Descriptor ─────────────────────────────────────────────────\n\n/**\n * Parsed and cached representation of a single `on-action` attribute value.\n *\n * Caching avoids re-parsing the same attribute string on every event fire.\n * The cache is keyed by the raw attribute string so identical values share\n * the same descriptor object.\n */\ninterface ActionDescriptor {\n  /** The DOM event type to listen for (e.g. `'click'`, `'input'`). */\n  readonly eventType: string;\n  /** Set of active modifier names (e.g. `{'prevent', 'once'}`). */\n  readonly modifiers: ReadonlySet<string>;\n  /** The action identifier dispatched to `onAction` subscribers. */\n  readonly actionId: string;\n  /** Raw payload token from the attribute (literal string or `$`-resolver key). */\n  readonly payload: string | undefined;\n}\n\n/**\n * LRU-style cache for parsed `on-action` attribute values.\n *\n * Attribute strings are typically repeated across many elements (e.g. every\n * \"add to cart\" button shares the same `on-action` value). Caching the parsed\n * descriptor avoids redundant regex work on every event.\n *\n * Using a plain `Map` here is intentional — attribute strings are short-lived\n * keys and the map size is bounded by the number of distinct `on-action` values\n * in the page, which is typically small.\n *\n * @internal\n */\nconst descriptorCache__ = new Map<string, ActionDescriptor | null>();\n\n/**\n * Parses an `on-action` attribute value into an `ActionDescriptor`.\n *\n * Returns `null` when the syntax is invalid. Results are cached by the raw\n * attribute string so repeated calls for the same value are O(1).\n *\n * @internal\n */\nfunction parseDescriptor__(attributeValue: string): ActionDescriptor | null {\n  logger_.logMethodArgs?.('parseDescriptor__', {attributeValue});\n\n  const cached = descriptorCache__.get(attributeValue);\n  // Explicit `undefined` check: `null` means \"already parsed and invalid\".\n  if (cached !== undefined) return cached;\n\n  const match = attributeValue.match(syntaxRegex);\n  if (!match) {\n    logger_.accident('parseDescriptor__', 'invalid_syntax', {attributeValue});\n    descriptorCache__.set(attributeValue, null);\n    return null;\n  }\n\n  const [eventType, ...modifierList] = match[1].split('.');\n  if (!eventType) {\n    logger_.accident('parseDescriptor__', 'missing_event_type', {attributeValue});\n    descriptorCache__.set(attributeValue, null);\n    return null;\n  }\n\n  const modifiers = new Set(modifierList);\n  const actionId = match[2];\n  const payload: string | undefined = match[3];\n\n  const descriptor: ActionDescriptor = {\n    eventType,\n    modifiers,\n    actionId,\n    payload,\n  };\n\n  descriptorCache__.set(attributeValue, descriptor);\n  return descriptor;\n}\n\n// ─── Core Delegation Handler ──────────────────────────────────────────────────\n\nconst onActionAttrib__ = 'on-action';\n/**\n * Central event handler attached to `document.body` for every delegated event type.\n *\n * Execution flow for each incoming event:\n * 1. Walk up from `event.target` to find the nearest element with an\n *    `on-action` attribute whose event type matches the current event.\n * 2. Parse (or retrieve from cache) the `ActionDescriptor` for that attribute.\n * 3. Run each modifier in order; if any returns `false`, abort.\n * 4. Resolve the payload token (literal or `$`-resolver).\n * 5. Call `dispatchAction(actionId, payload)`.\n *\n * @internal\n */\nfunction handleDelegatedEvent__(event: Event): void {\n  const eventType = event.type;\n  logger_.logMethodArgs?.('handleDelegatedEvent__', {eventType});\n\n  // Walk up the DOM to find the closest element with a matching on-action attribute.\n  // We use `closest` on the composedPath target to support Shadow DOM correctly.\n  const target = event.target as Element | null;\n  if (!target) return;\n\n  // Find the nearest ancestor (or self) that has an on-action attribute\n  const actionElement = target.closest?.(`[${onActionAttrib__}^=${eventType}]`);\n  if (!actionElement) return;\n\n  const attributeValue = actionElement.getAttribute?.(onActionAttrib__)?.trim();\n  if (!attributeValue) {\n    logger_.accident('handleDelegatedEvent__', 'empty_attribute', {eventType, attributeValue, actionElement});\n    return;\n  }\n\n  if (!(actionElement instanceof HTMLElement)) {\n    logger_.accident('handleDelegatedEvent__', 'target_not_html_element', {eventType, attributeValue, actionElement});\n    return;\n  }\n\n  const descriptor = parseDescriptor__(attributeValue);\n  if (!descriptor) {\n    logger_.accident('handleDelegatedEvent__', 'invalid_attribute', {eventType, attributeValue, actionElement});\n    return;\n  }\n\n  if (descriptor.eventType !== eventType) return;\n\n  logger_.logMethodArgs?.('handleDelegatedEvent__.action', descriptor);\n\n  // Step 1: handle once modifier\n  if (descriptor.modifiers.has('once')) {\n    actionElement.removeAttribute(onActionAttrib__); // remove on-action to prevent repeat the action\n    descriptorCache__.delete(attributeValue); // free memory for once\n  }\n\n  // Step 2: run modifiers\n  for (const modifier of descriptor.modifiers) {\n    if (modifier === 'once') continue; // handled separately\n    const handler = modifierRegistry.get(modifier);\n    if (!handler) {\n      logger_.accident('handleDelegatedEvent__', 'unknown_modifier', {modifier, attributeValue});\n      return; // unknown modifier — abort to avoid silent misbehaviour\n    }\n    if (handler(event, actionElement) === false) return;\n  }\n\n  // Step 3: resolve payload\n  let payload: unknown = descriptor.payload;\n  if (payload) {\n    const resolver = payloadRegistry.get(payload as string);\n    if (resolver) payload = resolver(event, actionElement);\n  }\n\n  // Step 4: dispatch\n  internalChannel_.dispatch(descriptor.actionId, payload);\n}\n\n// ─── Setup ────────────────────────────────────────────────────────────────────\n\n/**\n * The set of event types currently delegated to `document.body`.\n *\n * Tracked so that `setupActionDelegation` is idempotent — calling it multiple\n * times with the same event types does not register duplicate listeners.\n *\n * @internal\n */\nconst delegatedEventTypes__ = new Set<string>();\n\n/**\n * Default DOM event types that cover the vast majority of interactive elements.\n *\n * - `click` — buttons, links, checkboxes, custom interactive elements\n * - `submit` — form submission\n * - `input` — live text input, range sliders\n * - `change` — select boxes, checkboxes, radio buttons (fires on commit)\n *\n * Pass additional types to `setupActionDelegation` when your app uses other\n * events (e.g. `'keydown'`, `'pointerup'`).\n */\nexport const DEFAULT_DELEGATED_EVENTS: readonly string[] = ['click', 'submit', 'input', 'change'];\n\n/**\n * Registers global event delegation for `on-action` attributes.\n *\n * Attaches a single `capture`-phase listener on `document.body` for each\n * event type in `eventTypes`. All `on-action` processing — modifier execution,\n * payload resolution, and `dispatchAction` — happens inside that one handler.\n *\n * **Call this once at application bootstrap**, before any user interaction.\n * Subsequent calls with the same event types are no-ops (idempotent).\n *\n * ### Why `capture: true`?\n *\n * Capture-phase listeners fire before bubble-phase listeners and also catch\n * events that do not bubble (e.g. `focus`, `blur`). This ensures the delegation\n * handler always runs, even when a child element calls `stopPropagation()`.\n *\n * ### Dynamic content\n *\n * Because the listener lives on `document.body`, any element added to the DOM\n * after this call — via `innerHTML`, `lit-html`, a framework renderer, or\n * server-sent HTML — is automatically covered. No re-bootstrap is needed.\n *\n * @param eventTypes - Event types to delegate. Defaults to `DEFAULT_DELEGATED_EVENTS`.\n *\n * @example — minimal bootstrap\n * ```ts\n * import {setupActionDelegation, onAction} from '@alwatr/action';\n *\n * // One call activates the entire page.\n * setupActionDelegation();\n *\n * onAction('open-drawer', (panel) => openDrawer(panel));\n * ```\n *\n * @example — with extra event types\n * ```ts\n * import {setupActionDelegation, DEFAULT_DELEGATED_EVENTS} from '@alwatr/action';\n *\n * setupActionDelegation([...DEFAULT_DELEGATED_EVENTS, 'keydown', 'pointerup']);\n * ```\n */\nexport function setupActionDelegation(eventTypes: readonly string[] = DEFAULT_DELEGATED_EVENTS): void {\n  logger_.logMethodArgs?.('setupActionDelegation', {eventTypes});\n\n  for (const eventType of eventTypes) {\n    if (delegatedEventTypes__.has(eventType)) continue; // already registered — skip\n    delegatedEventTypes__.add(eventType);\n    // capture: true — fires before bubble-phase listeners and catches non-bubbling events.\n    document.body.addEventListener(eventType, handleDelegatedEvent__, {capture: true});\n  }\n}\n\n/**\n * Removes all global delegation listeners registered by `setupActionDelegation`.\n *\n * Useful in test environments where each test needs a clean slate, or in\n * micro-frontend setups where a sub-app is unmounted.\n *\n * After calling this, `setupActionDelegation` can be called again to re-register.\n */\nexport function teardownActionDelegation(): void {\n  logger_.logMethod?.('teardownActionDelegation');\n  for (const eventType of delegatedEventTypes__) {\n    document.body.removeEventListener(eventType, handleDelegatedEvent__, {capture: true});\n  }\n  delegatedEventTypes__.clear();\n  descriptorCache__.clear();\n}\n"
   ],
-  "mappings": "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",
-  "debugId": "2E017DAE8A17903F64756E2164756E21",
+  "mappings": "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",
+  "debugId": "7E5E853AFB39285764756E2164756E21",
   "names": []
 }

package/dist/method.d.ts

@@ -1,3 +1,4 @@
+import type { Awaitable } from '@alwatr/type-helper';
 import type { SubscribeResult } from '@alwatr/signal';
 import { type ModifierHandler, type PayloadResolver } from './registry.js';
 import type { ActionRecord } from './action-record.js';
@@ -46,7 +47,7 @@ export type { ModifierHandler, PayloadResolver };
  * sub.unsubscribe(); // stop listening when no longer needed
  * ```
  */
-export declare function onAction<K extends keyof ActionRecord>(actionId: K, handler: (payload: ActionRecord[K]) => void): SubscribeResult;
+export declare function onAction<K extends keyof ActionRecord>(actionId: K, handler: (payload: ActionRecord[K]) => Awaitable<void>): SubscribeResult;
 /**
  * Dispatches a named action to all `onAction` subscribers with a matching `actionId`.
  *
@@ -107,15 +108,13 @@ export declare function dispatchAction<K extends keyof ActionRecord>(...args: Ac
  * handler — avoid duplicate registrations in production code.
  *
  * @param name    - The modifier token (lowercase, no dots or arrows).
- * @param handler - The `ModifierHandler` function bound to an `ActionContext`.
+ * @param handler - A `ModifierHandler` receiving `(event, element)`.
  *
  * @example — a `confirm` modifier that shows a browser dialog
  * ```ts
  * import {registerModifier} from '@alwatr/action';
  *
- * registerModifier('confirm', function () {
- *   return window.confirm('Are you sure?');
- * });
+ * registerModifier('confirm', () => window.confirm('Are you sure?'));
  * ```
  * ```html
  * <button on-action="click.confirm->delete-item:42">Delete</button>
@@ -137,14 +136,14 @@ export declare function registerModifier(name: string, handler: ModifierHandler)
  * resolver — avoid duplicate registrations in production code.
  *
  * @param name     - The resolver token (should start with `$` by convention).
- * @param resolver - The `PayloadResolver` function bound to an `ActionContext`.
+ * @param resolver - A `PayloadResolver` receiving `(event, element)`.
  *
  * @example — a `$checked` resolver for checkbox state
  * ```ts
  * import {registerPayloadResolver} from '@alwatr/action';
  *
- * registerPayloadResolver('$checked', function () {
- *   return (this.element as HTMLInputElement).checked;
+ * registerPayloadResolver('$checked', (_event, element) => {
+ *   return (element as HTMLInputElement).checked;
  * });
  * ```
  * ```html

package/dist/method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../src/method.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAoC,KAAK,eAAe,EAAE,KAAK,eAAe,EAAC,MAAM,eAAe,CAAC;AAC5G,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAGrD,YAAY,EAAC,eAAe,EAAE,eAAe,EAAC,CAAC;AAI/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,YAAY,EACnD,QAAQ,EAAE,CAAC,EACX,OAAO,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,GAC1C,eAAe,CAKjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,YAAY,EACzD,GAAG,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,SAAS,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,GAChH,IAAI,CAAC;AASR;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAM7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAMrF"}
+{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../src/method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAoC,KAAK,eAAe,EAAE,KAAK,eAAe,EAAC,MAAM,eAAe,CAAC;AAC5G,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAGrD,YAAY,EAAC,eAAe,EAAE,eAAe,EAAC,CAAC;AAI/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,YAAY,EACnD,QAAQ,EAAE,CAAC,EACX,OAAO,EAAE,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC,GACrD,eAAe,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,YAAY,EACzD,GAAG,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,SAAS,IAAI,GAAG,SAAS,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,GAChH,IAAI,CAIN;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAM7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAMrF"}

package/dist/registry.d.ts

@@ -1,15 +1,18 @@
 /**
  * A modifier handler used in `on-action` attribute syntax.
  *
- * Called with an `ActionContext` as `this` and the triggering DOM `event`.
- * Return `true` (or any truthy value) to allow the action to proceed,
- * or `false` to cancel the dispatch.
+ * Receives the triggering DOM `event` and the `element` that owns the
+ * `on-action` attribute. Return `true` (or any truthy value) to allow the
+ * action to proceed, or `false` to cancel the dispatch.
+ *
+ * Using explicit parameters instead of `this` binding makes handlers
+ * compatible with arrow functions and easier to test in isolation.
  *
  * @example
  * ```ts
  * // A modifier that only allows the action when the element is not disabled
- * const notDisabledHandler: ModifierHandler = function () {
- *   return !(this.element as HTMLButtonElement).disabled;
+ * const notDisabledHandler: ModifierHandler = (_event, element) => {
+ *   return !(element as HTMLButtonElement).disabled;
  * };
  * ```
  */
@@ -17,15 +20,18 @@ export type ModifierHandler = (event: Event, element: HTMLElement) => boolean;
 /**
  * A payload resolver used in `on-action` attribute syntax.
  *
- * Called with an `ActionContext` as `this` and the triggering DOM `event`
- * at dispatch time. The return value becomes the `actionPayload` passed to
- * `onAction` subscribers. Use this to compute dynamic payloads from DOM state.
+ * Receives the triggering DOM `event` and the `element` that owns the
+ * `on-action` attribute. The return value becomes the `actionPayload` passed
+ * to `onAction` subscribers. Use this to compute dynamic payloads from DOM state.
+ *
+ * Using explicit parameters instead of `this` binding makes resolvers
+ * compatible with arrow functions and easier to test in isolation.
  *
  * @example
  * ```ts
  * // A resolver that returns the element's dataset id
- * const dataIdResolver: PayloadResolver = function () {
- *   return (this.element as HTMLElement).dataset.id ?? null;
+ * const dataIdResolver: PayloadResolver = (_event, element) => {
+ *   return (element as HTMLElement).dataset.id ?? null;
  * };
  * ```
  */

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;AAE9E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;AAI9E;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,8BAAqC,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,8BAAqC,CAAC"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;AAE9E;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC;AAI9E;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,8BAAqC,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,8BAAqC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alwatr/action",
-  "version": "9.13.0",
+  "version": "9.14.0",
   "description": "Declarative DOM action-dispatch — bridge HTML attributes to typed signal handlers.",
   "license": "MPL-2.0",
   "author": "S. Ali Mihandoost <ali.mihandoost@gmail.com> (https://ali.mihandoost.com)",
@@ -21,13 +21,13 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@alwatr/logger": "9.11.2",
-    "@alwatr/signal": "9.13.0"
+    "@alwatr/logger": "9.14.0",
+    "@alwatr/signal": "9.14.0"
   },
   "devDependencies": {
-    "@alwatr/nano-build": "9.10.1",
-    "@alwatr/standard": "9.11.2",
-    "@alwatr/type-helper": "9.11.2",
+    "@alwatr/nano-build": "9.14.0",
+    "@alwatr/standard": "9.14.0",
+    "@alwatr/type-helper": "9.14.0",
     "typescript": "^6.0.3"
   },
   "scripts": {
@@ -79,5 +79,5 @@
     "vanilla-js",
     "web-development"
   ],
-  "gitHead": "da284d23e3173d589fa69376e51a098c5e89649d"
+  "gitHead": "4e499b23191d4460ea60f34cde8a99b472741f1a"
 }

package/src/action-record.ts

@@ -34,8 +34,9 @@
  * Extend this interface via declaration merging to register your application's
  * actions and gain full type safety in `onAction` and `dispatchAction`.
  *
- * Built-in system actions are declared here. Application-level actions should
- * be declared in a dedicated `action-record.ts` file within each feature package.
+ * This interface is intentionally empty in the base package — all actions are
+ * application-specific and should be declared in a dedicated `action-record.ts`
+ * file within each feature package.
  *
  * @example — registering actions in a feature package
  * ```ts
@@ -49,18 +50,5 @@
  * }
  * ```
  */
-export interface ActionRecord {
-  /**
-   * Dispatched by `dispatchPageId()` when the page identity is read from the
-   * `page-id` HTML attribute. Payload is the page identifier string.
-   *
-   * @example
-   * ```html
-   * <body page-id="home">…</body>
-   * ```
-   * ```ts
-   * onAction('page-ready', (pageId) => router.setPage(pageId));
-   * ```
-   */
-  'page-ready': string;
-}
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ActionRecord {}

package/src/lib.ts

@@ -1,6 +1,5 @@
 import {createLogger} from '@alwatr/logger';
 import {createChannelSignal} from '@alwatr/signal';
-import type {ActionRecord} from './action-record.js';
 
 /**
  * Module-scoped logger for `@alwatr/action`.
@@ -21,11 +20,6 @@ export const logger_ = createLogger('alwatr-action');
  * single `Map.get('A')` lookup and invokes only the handlers registered for
  * that specific action — never handlers for `'B'`, `'C'`, etc.
  *
- * `ActionRecord & Record<string, unknown>` satisfies the `ChannelSignal`
- * constraint (which requires an index signature) while keeping the public API
- * strictly limited to declared keys — the `Record<string, unknown>` part is
- * only visible to the internal channel, not to `onAction`/`dispatchAction`.
- *
  * @internal — not part of the public API; use `onAction` / `dispatchAction` instead.
  */
-export const internalChannel_ = createChannelSignal<ActionRecord & Record<string, unknown>>({name: 'alwatr-action'});
+export const internalChannel_ = createChannelSignal<Record<string, unknown>>({name: 'alwatr-action'});

package/src/main.ts

@@ -1,12 +1,11 @@
 /**
  * @alwatr/action — Declarative DOM action-dispatch for Unidirectional Data Flow.
  *
- * ## Two ways to activate `on-action` attributes
+ * ## Activating `on-action` attributes
  *
- * ### 1. Global delegation (recommended)
- *
- * One listener on `document.body` handles every `on-action` element — past,
- * present, and future. O(1) boot time regardless of element count.
+ * Call `setupActionDelegation()` once at bootstrap. A single capture-phase
+ * listener on `document.body` handles every `on-action` element — including
+ * elements added dynamically after bootstrap — with O(1) initialization cost.
  *
  * ```ts
  * import {setupActionDelegation, onAction} from '@alwatr/action';
@@ -15,22 +14,20 @@
  * onAction('open-drawer', (panel) => openDrawer(panel));
  * ```
  *
- * ### 2. Programmatic dispatch
- *
- * Dispatch actions from code without any HTML attribute:
+ * ## Programmatic dispatch
  *
  * ```ts
- * import {dispatchAction, onAction} from '@alwatr/action';
+ * import {dispatchAction} from '@alwatr/action';
  *
  * dispatchAction('navigate', '/dashboard');
- * onAction('navigate', (path) => router.push(path));
  * ```
  *
  * ## Registering typed actions
  *
- * Extend `ActionMap` via declaration merging to get full type safety:
+ * Extend `ActionRecord` via declaration merging to get full type safety:
  *
  * ```ts
+ * // src/action-record.ts
  * declare module '@alwatr/action' {
  *   interface ActionRecord {
  *     'open-drawer': string;
@@ -46,10 +43,12 @@
  * - `setupActionDelegation` / `teardownActionDelegation` — global delegation lifecycle
  * - `DEFAULT_DELEGATED_EVENTS` — default event types covered by delegation
  * - `onAction` / `dispatchAction` — subscribe to and dispatch named actions
- * - `dispatchPageId` — read `page-id` attribute and dispatch `'page-ready'`
  * - `registerModifier` / `registerPayloadResolver` — extend the attribute syntax
+ *
+ * ## Page identity
+ *
+ * For page-ready signals in SSG/SSR apps, use `@alwatr/page-ready` instead.
  */
+export type {ActionRecord} from './action-record.js';
 export * from './method.js';
 export * from './delegate.js';
-export * from './page-ready.js';
-export * from './action-record.js';

package/src/method.ts

@@ -1,3 +1,4 @@
+import type {Awaitable} from '@alwatr/type-helper';
 import {internalChannel_, logger_} from './lib.js';
 import type {SubscribeResult} from '@alwatr/signal';
 import {modifierRegistry, payloadRegistry, type ModifierHandler, type PayloadResolver} from './registry.js';
@@ -54,12 +55,10 @@ export type {ModifierHandler, PayloadResolver};
  */
 export function onAction<K extends keyof ActionRecord>(
   actionId: K,
-  handler: (payload: ActionRecord[K]) => void,
+  handler: (payload: ActionRecord[K]) => Awaitable<void>,
 ): SubscribeResult {
   logger_.logMethodArgs?.('onAction', {actionId});
-  // Cast through `unknown` to bridge the gap between the strict public signature
-  // (ActionRecord[K]) and the internal channel's wider type (ActionRecord & Record<string, unknown>).
-  return internalChannel_.on(actionId as string, handler as (payload: unknown) => void);
+  return internalChannel_.on(actionId, handler as (payload: unknown) => Awaitable<void>);
 }
 
 /**
@@ -107,14 +106,12 @@ export function onAction<K extends keyof ActionRecord>(
  * dispatchAction('logout');
  * ```
  */
-// Overload for actions with a void/undefined payload — second argument omitted.
 export function dispatchAction<K extends keyof ActionRecord>(
   ...args: ActionRecord[K] extends void | undefined ? [actionId: K] : [actionId: K, actionPayload: ActionRecord[K]]
-): void;
-// Implementation
-export function dispatchAction(actionId: keyof ActionRecord, actionPayload?: unknown): void {
+): void {
+  const [actionId, actionPayload] = args;
   logger_.logMethodArgs?.('dispatchAction', {actionId, actionPayload});
-  internalChannel_.dispatch(actionId as string, actionPayload);
+  internalChannel_.dispatch(actionId, actionPayload);
 }
 
 // ─── Extension API ────────────────────────────────────────────────────────────
@@ -133,15 +130,13 @@ export function dispatchAction(actionId: keyof ActionRecord, actionPayload?: unk
  * handler — avoid duplicate registrations in production code.
  *
  * @param name    - The modifier token (lowercase, no dots or arrows).
- * @param handler - The `ModifierHandler` function bound to an `ActionContext`.
+ * @param handler - A `ModifierHandler` receiving `(event, element)`.
  *
  * @example — a `confirm` modifier that shows a browser dialog
  * ```ts
  * import {registerModifier} from '@alwatr/action';
  *
- * registerModifier('confirm', function () {
- *   return window.confirm('Are you sure?');
- * });
+ * registerModifier('confirm', () => window.confirm('Are you sure?'));
  * ```
  * ```html
  * <button on-action="click.confirm->delete-item:42">Delete</button>
@@ -170,14 +165,14 @@ export function registerModifier(name: string, handler: ModifierHandler): void {
  * resolver — avoid duplicate registrations in production code.
  *
  * @param name     - The resolver token (should start with `$` by convention).
- * @param resolver - The `PayloadResolver` function bound to an `ActionContext`.
+ * @param resolver - A `PayloadResolver` receiving `(event, element)`.
  *
  * @example — a `$checked` resolver for checkbox state
  * ```ts
  * import {registerPayloadResolver} from '@alwatr/action';
  *
- * registerPayloadResolver('$checked', function () {
- *   return (this.element as HTMLInputElement).checked;
+ * registerPayloadResolver('$checked', (_event, element) => {
+ *   return (element as HTMLInputElement).checked;
  * });
  * ```
  * ```html

package/src/registry.ts

@@ -3,15 +3,18 @@
 /**
  * A modifier handler used in `on-action` attribute syntax.
  *
- * Called with an `ActionContext` as `this` and the triggering DOM `event`.
- * Return `true` (or any truthy value) to allow the action to proceed,
- * or `false` to cancel the dispatch.
+ * Receives the triggering DOM `event` and the `element` that owns the
+ * `on-action` attribute. Return `true` (or any truthy value) to allow the
+ * action to proceed, or `false` to cancel the dispatch.
+ *
+ * Using explicit parameters instead of `this` binding makes handlers
+ * compatible with arrow functions and easier to test in isolation.
  *
  * @example
  * ```ts
  * // A modifier that only allows the action when the element is not disabled
- * const notDisabledHandler: ModifierHandler = function () {
- *   return !(this.element as HTMLButtonElement).disabled;
+ * const notDisabledHandler: ModifierHandler = (_event, element) => {
+ *   return !(element as HTMLButtonElement).disabled;
  * };
  * ```
  */
@@ -20,15 +23,18 @@ export type ModifierHandler = (event: Event, element: HTMLElement) => boolean;
 /**
  * A payload resolver used in `on-action` attribute syntax.
  *
- * Called with an `ActionContext` as `this` and the triggering DOM `event`
- * at dispatch time. The return value becomes the `actionPayload` passed to
- * `onAction` subscribers. Use this to compute dynamic payloads from DOM state.
+ * Receives the triggering DOM `event` and the `element` that owns the
+ * `on-action` attribute. The return value becomes the `actionPayload` passed
+ * to `onAction` subscribers. Use this to compute dynamic payloads from DOM state.
+ *
+ * Using explicit parameters instead of `this` binding makes resolvers
+ * compatible with arrow functions and easier to test in isolation.
  *
  * @example
  * ```ts
  * // A resolver that returns the element's dataset id
- * const dataIdResolver: PayloadResolver = function () {
- *   return (this.element as HTMLElement).dataset.id ?? null;
+ * const dataIdResolver: PayloadResolver = (_event, element) => {
+ *   return (element as HTMLElement).dataset.id ?? null;
  * };
  * ```
  */
@@ -87,7 +93,7 @@ modifierRegistry.set('prevent', (event) => {
  *
  * @example `<form on-action="submit.prevent.validate->submit-form:$formdata" novalidate>`
  */
-modifierRegistry.set('validate', function (_, element) {
+modifierRegistry.set('validate', (_event, element) => {
   const form = element instanceof HTMLFormElement ? element : element.closest('form');
   if (!form) return false;
   return form.checkValidity();
@@ -103,7 +109,7 @@ modifierRegistry.set('validate', function (_, element) {
  *
  * @example `<input on-action="input->search-query:$value" />`
  */
-payloadRegistry.set('$value', function (_, element) {
+payloadRegistry.set('$value', (_event, element) => {
   return 'value' in element ? (element as {value: unknown}).value : null;
 });
 
@@ -116,12 +122,12 @@ payloadRegistry.set('$value', function (_, element) {
  *
  * @example `<form on-action="submit.prevent.validate->submit-form:$formdata">`
  * ```ts
- * onAction<Record<string, FormDataEntryValue>>('submit-form', (data) => {
+ * onAction('submit-form', (data) => {
  *   console.log(data); // {username: 'ali', password: '…'}
  * });
  * ```
  */
-payloadRegistry.set('$formdata', function (_, element) {
+payloadRegistry.set('$formdata', (_event, element) => {
   const form = element instanceof HTMLFormElement ? element : element.closest('form');
   return form ? Object.fromEntries(new FormData(form).entries()) : null;
 });

package/dist/page-ready.d.ts

@@ -1,3 +0,0 @@
-export declare function onPageReady<T extends string>(pageId: T, handler: () => void): void;
-export declare function dispatchPageReady(): void;
-//# sourceMappingURL=page-ready.d.ts.map

package/dist/page-ready.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"page-ready.d.ts","sourceRoot":"","sources":["../src/page-ready.ts"],"names":[],"mappings":"AASA,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,QAG3E;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAgBxC"}

package/src/page-ready.ts

@@ -1,31 +0,0 @@
-import {createLogger} from '@alwatr/logger';
-import {createChannelSignal} from '@alwatr/signal';
-
-const logger = createLogger('page-ready');
-
-const pageReadyChannel_ = createChannelSignal<Record<string, undefined>>({
-  name: 'page-ready',
-});
-
-export function onPageReady<T extends string>(pageId: T, handler: () => void) {
-  logger.logMethodArgs?.('onPageReady', {pageId});
-  pageReadyChannel_.on(pageId, handler);
-}
-
-export function dispatchPageReady(): void {
-  logger.logMethod?.('dispatchPageReady');
-  const element = document.querySelector('[page-id]');
-  if (!element) {
-    logger.incident?.('dispatchPageReady', 'element_not_found');
-    return;
-  }
-
-  const pageId = element.getAttribute('page-id')?.trim();
-
-  if (!pageId) {
-    logger.accident('dispatchPageReady', 'empty_page_id', {element});
-    return;
-  }
-
-  pageReadyChannel_.dispatch(pageId);
-}