@statedelta-actions/actions 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -0,0 +1,96 @@
+# @statedelta-actions/actions
+
+## 0.6.0
+
+### Minor Changes
+
+- a3a818b: `HandlerDefinition` is now a discriminated union by execution mode
+
+  `HandlerDefinition<TCtx>` is `SyncHandlerDefinition<TCtx> | AsyncHandlerDefinition<TCtx> | InteractiveHandlerDefinition<TCtx>` — the `async` / `interactive` flags discriminate, and `execute` refines its return type per mode (`ApplyResult` for sync, `Promise<ApplyResult>` for async, `Generator<unknown, ApplyResult, unknown> | AsyncGenerator<unknown, ApplyResult, unknown>` for interactive). Consumers that call `handler.execute(...)` directly (tests, wrappers) — typing the handler as a subtype, or narrowing the union via the flags — no longer get the wide `ApplyResult | Promise<ApplyResult>` union for a handler they know is sync.
+
+  New exports: `HandlerBaseDefinition`, `SyncHandlerDefinition`, `AsyncHandlerDefinition`, `InteractiveHandlerDefinition`, `SyncHandlerExecute`, `AsyncHandlerExecute`, `InteractiveHandlerExecute`.
+
+  **Breaking (minor, pre-1.0):**
+  - A V2 handler that is `async` or `interactive` must now declare the `async: true` / `interactive: true` flag to satisfy the type. `{ async execute() {} }` without `async: true` no longer matches `HandlerDefinition` (it matches no subtype: sync requires a sync return, async/interactive require the flag). Runtime auto-detection via `isAsyncFunction` / `isGeneratorFunction` still works as a safety net — the type just forces the declaration to be explicit for V2.
+  - `HandlerDefinition<TCtx>["execute"]` is wider than before (it now includes the `Generator | AsyncGenerator` arm) — code that assigned `handler.execute` to `(...) => ApplyResult | Promise<ApplyResult>` needs to narrow or use a subtype. (This also fixes a latent bug: interactive handlers' `execute` previously violated the declared type silently.)
+  - V1 handlers (plain functions) and `HandlerInput<TCtx>` are unchanged.
+
+### Patch Changes
+
+- 26c579a: Polish published package metadata and READMEs
+  - `@statedelta-actions/core` now ships a README (was missing on npm).
+  - `@statedelta-actions/analyzer` README: fixed pervasive missing accents.
+  - `graph` and `events` READMEs: titles are now the package name (`# @statedelta-actions/graph` / `# @statedelta-actions/events`) instead of a conceptual name.
+  - All packages: added `keywords`, `homepage`, `bugs`; package.json keys reordered to a canonical layout.
+  - All packages: `CHANGELOG.md` added to `files` so it ships to npm; a `LICENSE` (MIT) file is included in the repo root and in each package.
+
+- Updated dependencies [26c579a]
+  - @statedelta-actions/core@0.5.1
+
+## 0.5.0
+
+### Minor Changes
+
+- f8c2b4a: Fail-fast register errors, controlled `action-not-found`, atomic registration, and events async/interactive modes
+  - **actions** — A missing handler for a directive type now throws at register
+    time (was a collected error) — fail-fast for typos and forgotten handlers.
+    Invoking an unknown action id returns `aborted: true, abortedBy:
+"action-not-found"` instead of a soft failure. `isActionAsync` is exposed on
+    the engine ref handed to handlers (symmetric with `isActionInteractive`).
+  - **rules** — `register()` is atomic: it builds a staging set, delegates to the
+    ActionEngine, then indexes locally only on success. Structural errors from the
+    ActionEngine propagate as a throw with no local state mutated.
+  - **events** — `register()`/`defineEvents()` are atomic the same way.
+    Async detection is now per-listener transitive via the ActionEngine mini-graph,
+    so hybrid engines keep `processEvents`/`processEventsAsync` viable for
+    listeners whose subtree is fully sync. New `processEventsInteractive()` returns
+    a drainable iterator (sync or async generator) — pauses from `type:"pause"` or
+    an interactive handler flow via `yield*` up to the consumer; halt scoping is
+    preserved (a pause stops the listeners of that event, following events
+    continue). New `isInteractive` getter.
+  - **core** — `ActionEngineRef` gains an optional `isActionAsync?` accessor.
+  - **sdk** — re-exports the new event types/surface; barrel deps moved to
+    `dependencies` (`workspace:^`).
+
+### Patch Changes
+
+- Updated dependencies [f8c2b4a]
+  - @statedelta-actions/core@0.5.0
+
+## 0.3.0
+
+### Minor Changes
+
+- Split types em definitions + engine em cada package; novo subpath sdk/definitions
+  - core: RegisterWarning movido pra core/types/engine.ts (tipo shared entre packages)
+  - actions: types.ts → types/definitions.ts + types/engine.ts
+  - rules: types.ts → types/definitions.ts + types/engine.ts
+  - events: types.ts → types/definitions.ts + types/engine.ts
+  - sdk: novo subpath ./definitions com re-export de definition types puros (zero runtime)
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @statedelta-actions/core@0.3.0
+
+## 0.2.0
+
+### Minor Changes
+
+- Sync all packages to 0.2.0 (match SDK version)
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @statedelta-actions/core@0.2.0
+
+## 0.3.0
+
+### Minor Changes
+
+- Sync all packages to 0.2.0 (match SDK version)
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @statedelta-actions/core@0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anderson D. Rosa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { Directive, ExecutionFrame, RuleEngineRef, ApplyResult, RegisterWarning, ActionEngineRef, DirectiveResult, HookFn, InterceptResult, AbortDecision, FrameLimits, SlotAnalysis } from '@statedelta-actions/core';
+import { Directive, ExecutionFrame, ActionEngineRef, ApplyResult, RuleEngineRef, RegisterWarning, DirectiveResult, HookFn, InterceptResult, AbortDecision, FrameLimits, SlotAnalysis } from '@statedelta-actions/core';
 export { RegisterWarning } from '@statedelta-actions/core';
 
 type DirectiveHandler<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: RuleEngineRef<TCtx>) => ApplyResult | Promise<ApplyResult>;
@@ -12,52 +12,82 @@ interface ValidationResult {
     error?: string;
     warnings?: string[];
 }
-interface HandlerDefinition<TCtx> {
+/**
+ * Campos comuns a todo handler V2, independente do modo de execução.
+ * `execute` fica nos subtipos — cada modo refina seu retorno. Não é genérico
+ * porque nenhuma das fases (`analyze`/`validate`/`compile`) usa `TCtx`.
+ */
+interface HandlerBaseDefinition {
     /** Register-time: extrai capabilities e dependências. */
     analyze?: (directive: Directive) => HandlerAnalysis;
     /** Register-time: valida estrutura da directive. */
     validate?: (directive: Directive) => ValidationResult | void;
     /** JIT-time: contribui código inline per-action (Fase 2c). */
     compile?: (directive: Directive, compiler: unknown) => string | void;
-    /**
-     * Marca o handler como assíncrono (opt-in explícito).
-     *
-     * Quando true (ou quando `execute` é uma `async function`), o engine:
-     * - inclui este handler no async handler set;
-     * - força `isAsync = true` no engine inteiro;
-     * - emite `await` ao invocar este handler no interpreter async e nos JITs.
-     *
-     * Auto-detecção via `isAsyncFunction(execute)` cobre `async function`.
-     * Use a flag para wrappers que retornam `Promise<ApplyResult>` sem
-     * serem `async function` (ex: factory que retorna função normal que
-     * delega pra um await internamente via `.then`).
-     *
-     * Sem flag e sem `async function`: handler é tratado como sync.
-     */
+}
+/** Função `execute` de um handler sync — retorna `ApplyResult` direto. */
+type SyncHandlerExecute<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => ApplyResult;
+/** Função `execute` de um handler async — retorna `Promise<ApplyResult>`. */
+type AsyncHandlerExecute<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => Promise<ApplyResult>;
+/**
+ * Função `execute` de um handler interactive — generator (sync ou async).
+ * O yield é `unknown`: o handler controla o protocol (o que yielda, o que
+ * recebe via `next`). O engine apenas empacota o yield como `PauseEvent.payload`
+ * pro consumer no nível raiz (ver ADR-024). O return é o `ApplyResult` final.
+ */
+type InteractiveHandlerExecute<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => Generator<unknown, ApplyResult, unknown> | AsyncGenerator<unknown, ApplyResult, unknown>;
+/**
+ * Handler sync — `execute` retorna `ApplyResult` direto. É o modo default:
+ * sem flag e sem `async function`/`function*`, o handler é tratado como sync.
+ */
+interface SyncHandlerDefinition<TCtx> extends HandlerBaseDefinition {
+    async?: false;
+    interactive?: false;
+    execute: SyncHandlerExecute<TCtx>;
+}
+/**
+ * Handler async — `execute` retorna `Promise<ApplyResult>`. Marcado com
+ * `async: true` ou detectado via `isAsyncFunction(execute)` (cobre
+ * `async function`). Use a flag pra wrappers que retornam Promise sem serem
+ * `async function` (ex: factory que delega via `.then`).
+ *
+ * Quando o engine vê um handler async: inclui no async handler set, força
+ * `isAsync = true` no engine inteiro, e emite `await` ao invocá-lo no
+ * interpreter async e nos JITs.
+ */
+interface AsyncHandlerDefinition<TCtx> extends HandlerBaseDefinition {
+    async: true;
+    interactive?: false;
+    execute: AsyncHandlerExecute<TCtx>;
+}
+/**
+ * Handler interactive — `execute` é generator (sync ou async). Marcado com
+ * `interactive: true` ou detectado via `isGeneratorFunction(execute)` (cobre
+ * `function*` e `async function*`). Use a flag pra wrappers que retornam
+ * iterator sem serem generator function. Pode também ser `async` (generator
+ * async) — daí `async: true` junto.
+ *
+ * Quando o engine vê um handler interactive: inclui no interactive handler set,
+ * propaga `_interactiveActions` transitivamente no mini-graph, emite
+ * `yield* handler(...)` ao invocá-lo nas actions interactive, e exige
+ * `engine.invokeInteractive()` em actions cuja sub-árvore o use. Handler
+ * `interactive: true` em engine sem `interactive` config → erro no constructor
+ * (fail-fast).
+ */
+interface InteractiveHandlerDefinition<TCtx> extends HandlerBaseDefinition {
+    interactive: true;
     async?: boolean;
-    /**
-     * Marca o handler como interativo (opt-in explícito).
-     *
-     * Quando true (ou quando `execute` é uma `function*` / `async function*`),
-     * o engine:
-     * - inclui este handler no interactive handler set;
-     * - propaga transitividade `_interactiveActions` no mini-graph;
-     * - emite `yield* handler(...)` ao invocar nas actions interactive;
-     * - exige `engine.invokeInteractive()` em actions cuja sub-árvore use o handler.
-     *
-     * Auto-detecção via `isGeneratorFunction(execute)` cobre `function*` e
-     * `async function*`. Use a flag para wrappers que retornam iterator sem
-     * serem generator function.
-     *
-     * Handler com `interactive: true` em engine sem `interactive` config →
-     * erro no constructor (fail-fast).
-     *
-     * Sem flag e sem generator function: handler é tratado como regular.
-     */
-    interactive?: boolean;
-    /** Runtime: executa a directive (obrigatório). */
-    execute: (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => ApplyResult | Promise<ApplyResult>;
+    execute: InteractiveHandlerExecute<TCtx>;
 }
+/**
+ * Handler V2 (objeto com fases). Discriminated union pelo modo de execução —
+ * `async` e `interactive` discriminam, `execute` refina seu retorno conforme
+ * o modo. Tipar como `HandlerDefinition<TCtx>` continua válido (é o agregado);
+ * narrowing pelos flags refina pro subtipo. Quem sabe o modo do seu handler
+ * pode tipar diretamente como `SyncHandlerDefinition` etc. e chamar
+ * `handler.execute(...)` sem `await`/narrowing.
+ */
+type HandlerDefinition<TCtx> = SyncHandlerDefinition<TCtx> | AsyncHandlerDefinition<TCtx> | InteractiveHandlerDefinition<TCtx>;
 /**
  * Aceita handler V1 (função) ou V2 (objeto com fases).
  * Backwards compat: função simples é tratada como { execute: fn }.
@@ -565,4 +595,4 @@ interface GeneratedActionExecutor {
  */
 declare function buildActionExecutor(directives: readonly Directive[], analysis: SlotAnalysis, typeField: string, asyncHandlerSet?: ReadonlySet<string>, actionUsesAsyncOverride?: boolean, actionIsInteractive?: boolean, interactiveHandlerSet?: ReadonlySet<string>): GeneratedActionExecutor;
 
-export { type ActionDefinition, type ActionHooks, type ActionInterceptResult, type AsyncInteractiveSession, type DirectiveExecutorFn, type DirectiveHandler, type DirectiveHandlerMap, type DirectiveHooks, type DirectivePermission, type DirectivePermissionConfig, type DirectivePermissionEntry, type DirectivePermissionStatus, type DirectiveRunnerFn, type EngineEventMap, type EngineEventName, type GeneratedActionExecutor, type GeneratedDirectiveExecutor, type HandlerAnalysis, type HandlerDefinition, type HandlerInput, type HandlerInputMap, type IActionEngine, type IActionEngineConfig, type InteractiveApplyResult, type InteractiveConfig, type InteractiveSession, type Listener, type PauseEvent, RESERVED_TYPES, type RegisterError, type RegisterEvent, type RegisterResult, type Responder, SimpleEmitter, type UnregisterEvent, type ValidationResult, buildActionExecutor, buildDirectiveExecutor, createActionEngine, createDirectiveInterpreter, drainAsync, drainSync, normalizeDirectives, replayResponder };
+export { type ActionDefinition, type ActionHooks, type ActionInterceptResult, type AsyncHandlerDefinition, type AsyncHandlerExecute, type AsyncInteractiveSession, type DirectiveExecutorFn, type DirectiveHandler, type DirectiveHandlerMap, type DirectiveHooks, type DirectivePermission, type DirectivePermissionConfig, type DirectivePermissionEntry, type DirectivePermissionStatus, type DirectiveRunnerFn, type EngineEventMap, type EngineEventName, type GeneratedActionExecutor, type GeneratedDirectiveExecutor, type HandlerAnalysis, type HandlerBaseDefinition, type HandlerDefinition, type HandlerInput, type HandlerInputMap, type IActionEngine, type IActionEngineConfig, type InteractiveApplyResult, type InteractiveConfig, type InteractiveHandlerDefinition, type InteractiveHandlerExecute, type InteractiveSession, type Listener, type PauseEvent, RESERVED_TYPES, type RegisterError, type RegisterEvent, type RegisterResult, type Responder, SimpleEmitter, type SyncHandlerDefinition, type SyncHandlerExecute, type UnregisterEvent, type ValidationResult, buildActionExecutor, buildDirectiveExecutor, createActionEngine, createDirectiveInterpreter, drainAsync, drainSync, normalizeDirectives, replayResponder };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Directive, ExecutionFrame, RuleEngineRef, ApplyResult, RegisterWarning, ActionEngineRef, DirectiveResult, HookFn, InterceptResult, AbortDecision, FrameLimits, SlotAnalysis } from '@statedelta-actions/core';
+import { Directive, ExecutionFrame, ActionEngineRef, ApplyResult, RuleEngineRef, RegisterWarning, DirectiveResult, HookFn, InterceptResult, AbortDecision, FrameLimits, SlotAnalysis } from '@statedelta-actions/core';
 export { RegisterWarning } from '@statedelta-actions/core';
 
 type DirectiveHandler<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: RuleEngineRef<TCtx>) => ApplyResult | Promise<ApplyResult>;
@@ -12,52 +12,82 @@ interface ValidationResult {
     error?: string;
     warnings?: string[];
 }
-interface HandlerDefinition<TCtx> {
+/**
+ * Campos comuns a todo handler V2, independente do modo de execução.
+ * `execute` fica nos subtipos — cada modo refina seu retorno. Não é genérico
+ * porque nenhuma das fases (`analyze`/`validate`/`compile`) usa `TCtx`.
+ */
+interface HandlerBaseDefinition {
     /** Register-time: extrai capabilities e dependências. */
     analyze?: (directive: Directive) => HandlerAnalysis;
     /** Register-time: valida estrutura da directive. */
     validate?: (directive: Directive) => ValidationResult | void;
     /** JIT-time: contribui código inline per-action (Fase 2c). */
     compile?: (directive: Directive, compiler: unknown) => string | void;
-    /**
-     * Marca o handler como assíncrono (opt-in explícito).
-     *
-     * Quando true (ou quando `execute` é uma `async function`), o engine:
-     * - inclui este handler no async handler set;
-     * - força `isAsync = true` no engine inteiro;
-     * - emite `await` ao invocar este handler no interpreter async e nos JITs.
-     *
-     * Auto-detecção via `isAsyncFunction(execute)` cobre `async function`.
-     * Use a flag para wrappers que retornam `Promise<ApplyResult>` sem
-     * serem `async function` (ex: factory que retorna função normal que
-     * delega pra um await internamente via `.then`).
-     *
-     * Sem flag e sem `async function`: handler é tratado como sync.
-     */
+}
+/** Função `execute` de um handler sync — retorna `ApplyResult` direto. */
+type SyncHandlerExecute<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => ApplyResult;
+/** Função `execute` de um handler async — retorna `Promise<ApplyResult>`. */
+type AsyncHandlerExecute<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => Promise<ApplyResult>;
+/**
+ * Função `execute` de um handler interactive — generator (sync ou async).
+ * O yield é `unknown`: o handler controla o protocol (o que yielda, o que
+ * recebe via `next`). O engine apenas empacota o yield como `PauseEvent.payload`
+ * pro consumer no nível raiz (ver ADR-024). O return é o `ApplyResult` final.
+ */
+type InteractiveHandlerExecute<TCtx> = (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => Generator<unknown, ApplyResult, unknown> | AsyncGenerator<unknown, ApplyResult, unknown>;
+/**
+ * Handler sync — `execute` retorna `ApplyResult` direto. É o modo default:
+ * sem flag e sem `async function`/`function*`, o handler é tratado como sync.
+ */
+interface SyncHandlerDefinition<TCtx> extends HandlerBaseDefinition {
+    async?: false;
+    interactive?: false;
+    execute: SyncHandlerExecute<TCtx>;
+}
+/**
+ * Handler async — `execute` retorna `Promise<ApplyResult>`. Marcado com
+ * `async: true` ou detectado via `isAsyncFunction(execute)` (cobre
+ * `async function`). Use a flag pra wrappers que retornam Promise sem serem
+ * `async function` (ex: factory que delega via `.then`).
+ *
+ * Quando o engine vê um handler async: inclui no async handler set, força
+ * `isAsync = true` no engine inteiro, e emite `await` ao invocá-lo no
+ * interpreter async e nos JITs.
+ */
+interface AsyncHandlerDefinition<TCtx> extends HandlerBaseDefinition {
+    async: true;
+    interactive?: false;
+    execute: AsyncHandlerExecute<TCtx>;
+}
+/**
+ * Handler interactive — `execute` é generator (sync ou async). Marcado com
+ * `interactive: true` ou detectado via `isGeneratorFunction(execute)` (cobre
+ * `function*` e `async function*`). Use a flag pra wrappers que retornam
+ * iterator sem serem generator function. Pode também ser `async` (generator
+ * async) — daí `async: true` junto.
+ *
+ * Quando o engine vê um handler interactive: inclui no interactive handler set,
+ * propaga `_interactiveActions` transitivamente no mini-graph, emite
+ * `yield* handler(...)` ao invocá-lo nas actions interactive, e exige
+ * `engine.invokeInteractive()` em actions cuja sub-árvore o use. Handler
+ * `interactive: true` em engine sem `interactive` config → erro no constructor
+ * (fail-fast).
+ */
+interface InteractiveHandlerDefinition<TCtx> extends HandlerBaseDefinition {
+    interactive: true;
     async?: boolean;
-    /**
-     * Marca o handler como interativo (opt-in explícito).
-     *
-     * Quando true (ou quando `execute` é uma `function*` / `async function*`),
-     * o engine:
-     * - inclui este handler no interactive handler set;
-     * - propaga transitividade `_interactiveActions` no mini-graph;
-     * - emite `yield* handler(...)` ao invocar nas actions interactive;
-     * - exige `engine.invokeInteractive()` em actions cuja sub-árvore use o handler.
-     *
-     * Auto-detecção via `isGeneratorFunction(execute)` cobre `function*` e
-     * `async function*`. Use a flag para wrappers que retornam iterator sem
-     * serem generator function.
-     *
-     * Handler com `interactive: true` em engine sem `interactive` config →
-     * erro no constructor (fail-fast).
-     *
-     * Sem flag e sem generator function: handler é tratado como regular.
-     */
-    interactive?: boolean;
-    /** Runtime: executa a directive (obrigatório). */
-    execute: (directive: Directive, frame: ExecutionFrame<TCtx>, engine: ActionEngineRef<TCtx>) => ApplyResult | Promise<ApplyResult>;
+    execute: InteractiveHandlerExecute<TCtx>;
 }
+/**
+ * Handler V2 (objeto com fases). Discriminated union pelo modo de execução —
+ * `async` e `interactive` discriminam, `execute` refina seu retorno conforme
+ * o modo. Tipar como `HandlerDefinition<TCtx>` continua válido (é o agregado);
+ * narrowing pelos flags refina pro subtipo. Quem sabe o modo do seu handler
+ * pode tipar diretamente como `SyncHandlerDefinition` etc. e chamar
+ * `handler.execute(...)` sem `await`/narrowing.
+ */
+type HandlerDefinition<TCtx> = SyncHandlerDefinition<TCtx> | AsyncHandlerDefinition<TCtx> | InteractiveHandlerDefinition<TCtx>;
 /**
  * Aceita handler V1 (função) ou V2 (objeto com fases).
  * Backwards compat: função simples é tratada como { execute: fn }.
@@ -565,4 +595,4 @@ interface GeneratedActionExecutor {
  */
 declare function buildActionExecutor(directives: readonly Directive[], analysis: SlotAnalysis, typeField: string, asyncHandlerSet?: ReadonlySet<string>, actionUsesAsyncOverride?: boolean, actionIsInteractive?: boolean, interactiveHandlerSet?: ReadonlySet<string>): GeneratedActionExecutor;
 
-export { type ActionDefinition, type ActionHooks, type ActionInterceptResult, type AsyncInteractiveSession, type DirectiveExecutorFn, type DirectiveHandler, type DirectiveHandlerMap, type DirectiveHooks, type DirectivePermission, type DirectivePermissionConfig, type DirectivePermissionEntry, type DirectivePermissionStatus, type DirectiveRunnerFn, type EngineEventMap, type EngineEventName, type GeneratedActionExecutor, type GeneratedDirectiveExecutor, type HandlerAnalysis, type HandlerDefinition, type HandlerInput, type HandlerInputMap, type IActionEngine, type IActionEngineConfig, type InteractiveApplyResult, type InteractiveConfig, type InteractiveSession, type Listener, type PauseEvent, RESERVED_TYPES, type RegisterError, type RegisterEvent, type RegisterResult, type Responder, SimpleEmitter, type UnregisterEvent, type ValidationResult, buildActionExecutor, buildDirectiveExecutor, createActionEngine, createDirectiveInterpreter, drainAsync, drainSync, normalizeDirectives, replayResponder };
+export { type ActionDefinition, type ActionHooks, type ActionInterceptResult, type AsyncHandlerDefinition, type AsyncHandlerExecute, type AsyncInteractiveSession, type DirectiveExecutorFn, type DirectiveHandler, type DirectiveHandlerMap, type DirectiveHooks, type DirectivePermission, type DirectivePermissionConfig, type DirectivePermissionEntry, type DirectivePermissionStatus, type DirectiveRunnerFn, type EngineEventMap, type EngineEventName, type GeneratedActionExecutor, type GeneratedDirectiveExecutor, type HandlerAnalysis, type HandlerBaseDefinition, type HandlerDefinition, type HandlerInput, type HandlerInputMap, type IActionEngine, type IActionEngineConfig, type InteractiveApplyResult, type InteractiveConfig, type InteractiveHandlerDefinition, type InteractiveHandlerExecute, type InteractiveSession, type Listener, type PauseEvent, RESERVED_TYPES, type RegisterError, type RegisterEvent, type RegisterResult, type Responder, SimpleEmitter, type SyncHandlerDefinition, type SyncHandlerExecute, type UnregisterEvent, type ValidationResult, buildActionExecutor, buildDirectiveExecutor, createActionEngine, createDirectiveInterpreter, drainAsync, drainSync, normalizeDirectives, replayResponder };

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "@statedelta-actions/actions",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Directive execution engine with JIT compilation and BailHook interception",
+  "keywords": [
+    "statedelta",
+    "directive-engine",
+    "jit",
+    "rule-engine",
+    "state-machine",
+    "action-engine"
+  ],
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -15,10 +23,11 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "dependencies": {
-    "@statedelta-actions/core": "0.5.0"
+    "@statedelta-actions/core": "0.5.1"
   },
   "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
   "license": "MIT",
@@ -27,6 +36,10 @@
     "url": "https://github.com/andersondrosa/statedelta-actions.git",
     "directory": "packages/actions"
   },
+  "homepage": "https://github.com/andersondrosa/statedelta-actions/tree/main/packages/actions#readme",
+  "bugs": {
+    "url": "https://github.com/andersondrosa/statedelta-actions/issues"
+  },
   "sideEffects": false,
   "engines": {
     "node": ">=18"