vapor-chamber 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,10 @@
-# Vapor Chamber
+<p align="center">
+  <img src="assets/vapor-chamber.png" alt="Vapor Chamber">
+</p>
 
-A lightweight command bus designed for [Vue Vapor](https://github.com/vuejs/vue-vapor). ~1KB core.
+<p align="center">
+  A lightweight command bus designed for <a href="https://github.com/vuejs/vue-vapor">Vue Vapor</a>. ~2KB gzipped. Optional DevTools integration.
+</p>
 
 ## What is Vue Vapor?
 
@@ -8,6 +12,45 @@ Vue Vapor is Vue's upcoming compilation strategy that eliminates the Virtual DOM
 
 **Vapor Chamber** embraces this philosophy: minimal abstraction, direct updates, signal-native reactivity.
 
+## Migrating from Vue 3 emitters
+
+If you're already using Vue 3's `emit` / `eventBus` pattern, here's the before and after:
+
+```
+// Before — Vue 3 emitter
+// cart.vue
+emit('cart:add', product);
+
+// App.vue
+bus.on('cart:add', (product) => {
+  cart.items.push(product);
+  analytics.track('add');
+  validate(product);  // where does this live?
+});
+
+// ProductList.vue — also listens?
+bus.on('cart:add', updateBadge);  // now two handlers, hard to trace
+```
+
+```
+// After — Vapor Chamber
+// Anywhere in the app
+bus.dispatch('cart.add', product, { quantity: 1 });
+
+// One place, once:
+bus.register('cart.add', (cmd) => {
+  cart.items.push(cmd.target);
+  return cart.items;
+});
+
+// Cross-cutting concerns as plugins, not scattered listeners:
+bus.use(logger());
+bus.use(validator({ 'cart.add': (cmd) => cmd.target.id ? null : 'Missing ID' }));
+bus.use(analyticsPlugin);
+```
+
+**The key difference:** `emit` is fire-and-forget with many listeners. `dispatch` has one handler and a composable plugin pipeline — one place to look, debug, and test.
+
 ## Why a Command Bus?
 
 Traditional event systems scatter logic across components. A command bus centralizes it:
@@ -118,7 +161,13 @@ const timingPlugin: Plugin = (cmd, next) => {
 bus.use(timingPlugin);
 ```
 
-Plugins execute in order: first added = outermost wrapper.
+Plugins execute by priority (highest first), then registration order for equal priorities:
+
+```typescript
+bus.use(validatorPlugin, { priority: 10 }); // runs first
+bus.use(analyticsPlugin, { priority: 1 });  // runs after validation
+bus.use(loggerPlugin);                       // priority 0 (default, runs last)
+```
 
 ## Built-in Plugins
 
@@ -170,6 +219,50 @@ bus.use(debounce(['search.query'], 300)); // wait 300ms after last call
 bus.use(throttle(['ui.scroll'], 100)); // max once per 100ms
 ```
 
+## Batch Dispatch
+
+Dispatch multiple commands as a unit. Stops on the first failure:
+
+```typescript
+const result = bus.dispatchBatch([
+  { action: 'cart.add',        target: cart, payload: item },
+  { action: 'totals.update',   target: cart },
+  { action: 'analytics.track', target: session, payload: item },
+]);
+
+if (result.ok) {
+  console.log('All succeeded:', result.results);
+} else {
+  console.error('Stopped at failure:', result.error);
+  console.log('Partial results:', result.results);
+}
+```
+
+Works on both sync and async buses.
+
+## Dead Letter Handling
+
+Configure what happens when a command has no registered handler:
+
+```typescript
+// Default: returns { ok: false, error }
+createCommandBus()
+
+// Throw instead of returning an error result
+createCommandBus({ onMissing: 'throw' })
+
+// Silently succeed (useful for optional commands)
+createCommandBus({ onMissing: 'ignore' })
+
+// Custom fallback
+createCommandBus({
+  onMissing: (cmd) => {
+    console.warn(`Unhandled: ${cmd.action}`);
+    return { ok: true, value: null };
+  }
+})
+```
+
 ## Async Command Bus
 
 For async handlers (API calls, IndexedDB, etc.):
@@ -236,6 +329,81 @@ const { canUndo, canRedo, undo, redo } = useCommandHistory({
 </script>
 ```
 
+### useCommandBus
+
+Lightweight composable for the "toolbox" pattern — import only when needed, tree-shaken out of builds that don't use it. Returns the shared bus directly:
+
+```typescript
+import { useCommandBus } from 'vapor-chamber';
+
+const bus = useCommandBus();
+bus.dispatch('cart.add', product, { quantity: 1 });
+```
+
+Use `useCommand()` when you need reactive `loading`/`lastError` signals. Use `useCommandBus()` when you just need to dispatch.
+
+### configureSignal
+
+Inject Vue Vapor's native signal factory once at app setup. Falls back to a built-in shim automatically in non-Vapor environments (standard Vue 3, tests, SSR):
+
+```typescript
+import { signal } from 'vue-vapor';
+import { configureSignal } from 'vapor-chamber';
+
+configureSignal(signal);
+```
+
+### Testing
+
+`createTestBus()` records all dispatched commands without executing real handlers. Use it to test components that call `dispatch` without wiring up the full application:
+
+```typescript
+import { createTestBus, setCommandBus } from 'vapor-chamber';
+import { describe, it, expect, beforeEach } from 'vitest';
+
+describe('CartButton', () => {
+  let bus: TestBus;
+
+  beforeEach(() => {
+    bus = createTestBus();
+    setCommandBus(bus);
+  });
+
+  it('dispatches cart.add on click', () => {
+    // ... render component, click button ...
+    expect(bus.wasDispatched('cart.add')).toBe(true);
+    expect(bus.getDispatched('cart.add')[0].cmd.payload).toEqual({ quantity: 1 });
+  });
+});
+```
+
+Register real handlers for actions you want to test deeply:
+
+```typescript
+bus.register('cart.add', (cmd) => {
+  // real handler logic
+});
+```
+
+### setupDevtools
+
+Connect a bus to Vue DevTools. Adds a **Commands** timeline layer and a **Vapor Chamber** inspector panel. Requires `@vue/devtools-api` — silently no-ops if not installed:
+
+```typescript
+import { createApp } from 'vue';
+import { getCommandBus, setupDevtools } from 'vapor-chamber';
+
+const app = createApp(App);
+setupDevtools(getCommandBus(), app);
+app.mount('#app');
+```
+
+The inspector shows:
+- Every dispatched command with its action, target, payload, and result
+- Green `ok` / red `error` tags at a glance
+- Full detail (value or error message) when a command is selected
+- Filterable tree by action name
+
 ## Examples
 
 See the [`examples/`](./examples) folder for complete, runnable examples:
@@ -260,33 +428,58 @@ npx ts-node examples/shopping-cart.ts
 
 | Function | Description |
 |----------|-------------|
-| `createCommandBus()` | Create a synchronous command bus |
-| `createAsyncCommandBus()` | Create an async command bus |
+| `createCommandBus(options?)` | Create a synchronous command bus |
+| `createAsyncCommandBus(options?)` | Create an async command bus |
+| `createTestBus(options?)` | Create a test bus that records dispatches (see [Testing](#testing)) |
+
+**`CommandBusOptions`**
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `onMissing` | `'error' \| 'throw' \| 'ignore' \| fn` | `'error'` | Behavior when no handler is registered for an action |
 
 ### Command Bus Methods
 
 | Method | Description |
 |--------|-------------|
 | `dispatch(action, target, payload?)` | Execute a command |
+| `dispatchBatch(commands[])` | Execute multiple commands; stops on first failure |
 | `register(action, handler)` | Register a handler (returns unregister fn) |
-| `use(plugin)` | Add a plugin (returns unsubscribe fn) |
+| `use(plugin, options?)` | Add a plugin (returns unsubscribe fn). `options.priority` controls order — higher runs first |
 | `onAfter(hook)` | Run callback after every command |
 
 ### Composables
 
 | Composable | Description |
 |------------|-------------|
-| `useCommand()` | Dispatch with reactive loading/error state |
-| `useCommandState(initial, handlers)` | State managed by commands |
-| `useCommandHistory(options?)` | Reactive undo/redo |
+| `useCommandBus()` | Get the shared bus — lightweight, tree-shakeable |
+| `useCommand()` | Dispatch with reactive loading/error state. Returns `dispose()` to clean up registered handlers/plugins |
+| `useCommandState(initial, handlers)` | State managed by commands. Returns `dispose()` to unregister handlers |
+| `useCommandHistory(options?)` | Reactive undo/redo. Returns `dispose()` to unsubscribe |
 | `getCommandBus()` | Get shared bus instance |
 | `setCommandBus(bus)` | Set shared bus instance |
+| `configureSignal(fn)` | Inject a custom signal factory (e.g. Vue Vapor's native `signal`) |
+| `setupDevtools(bus, app)` | Connect bus to Vue DevTools. No-ops automatically in production builds |
+
+## Roadmap
+
+| Feature | Status |
+|---------|--------|
+| DevTools integration | ✅ Done |
+| DevTools production strip (0KB in prod) | ✅ Done |
+| Command batching (`dispatchBatch`) | ✅ Done |
+| Middleware priority/ordering | ✅ Done |
+| Dead letter handling (`onMissing`) | ✅ Done |
+| Testing utilities (`createTestBus`) | ✅ Done |
+| Persistence plugin (localStorage / IndexedDB) | Planned |
+| SSR support | Planned (pending Vue Vapor stabilization) |
 
 ## Documentation
 
 See the [`docs/`](./docs) folder for detailed documentation:
 
 - [Whitepaper](./docs/whitepaper.md) - Design philosophy and architecture
+- [SSR Guide](./docs/ssr.md) - Server-side rendering and hydration
 
 ## Design Goals
 

package/dist/chamber.d.ts

@@ -5,9 +5,21 @@
  * the expected signal-based API. Update imports when Vapor stabilizes.
  */
 import { type CommandBus, type Command, type CommandResult, type Handler, type Plugin } from './command-bus';
-type Signal<T> = {
+export type Signal<T> = {
     value: T;
 };
+export type CreateSignal = <T>(initial: T) => Signal<T>;
+/**
+ * Configure the signal factory used by vapor-chamber composables.
+ * Call this once at app setup when Vue Vapor's signal API is available.
+ *
+ * @example
+ * import { signal } from 'vue-vapor';
+ * import { configureSignal } from 'vapor-chamber';
+ * configureSignal(signal);
+ */
+export declare function configureSignal(fn: CreateSignal): void;
+export declare const signal: CreateSignal;
 export declare function getCommandBus(): CommandBus;
 export declare function setCommandBus(bus: CommandBus): void;
 /**
@@ -19,6 +31,7 @@ export declare function useCommand(): {
     lastError: Signal<Error | null>;
     register: (action: string, handler: Handler) => () => void;
     use: (plugin: Plugin) => () => void;
+    dispose: () => void;
 };
 /**
  * useCommandState - create reactive state that updates via commands
@@ -29,6 +42,19 @@ export declare function useCommandState<T>(initial: T, handlers: {
     state: Signal<T>;
     dispose: () => void;
 };
+/**
+ * useCommandBus - lightweight composable wrapper around the shared bus.
+ *
+ * Designed for the "toolbox" pattern: import only when needed, tree-shaken
+ * out of builds that don't use it. Provides the full bus API plus reactive
+ * loading/error signals — without the automatic cleanup tracking of useCommand.
+ *
+ * @example
+ * import { useCommandBus } from 'vapor-chamber';
+ * const bus = useCommandBus();
+ * bus.dispatch('cart.add', product, { quantity: 1 });
+ */
+export declare function useCommandBus(): CommandBus;
 /**
  * useCommandHistory - undo/redo with reactive state
  */
@@ -45,5 +71,4 @@ export declare function useCommandHistory(options?: {
     clear: () => void;
     dispose: () => void;
 };
-export {};
 //# sourceMappingURL=chamber.d.ts.map

package/dist/chamber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chamber.d.ts","sourceRoot":"","sources":["../src/chamber.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI/H,KAAK,MAAM,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AAkC9B,wBAAgB,aAAa,IAAI,UAAU,CAK1C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAEnD;AAED;;GAEG;AACH,wBAAgB,UAAU;uBAKE,MAAM,UAAU,GAAG,YAAY,GAAG,KAAG,aAAa;;;;;EAqB7E;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,CAAC,EACV,QAAQ,EAAE;IACR,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,KAAK,CAAC,CAAC;CACjD;;;EAsBF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC/B;;;;;gBAqBa,OAAO,GAAG,SAAS;gBAYnB,OAAO,GAAG,SAAS;;;EA6BrC"}
+{"version":3,"file":"chamber.d.ts","sourceRoot":"","sources":["../src/chamber.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAoB,KAAK,UAAU,EAAE,KAAK,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAI/H,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AACrC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC;AAkBxD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAEtD;AAED,eAAO,MAAM,MAAM,EAAE,YAAoD,CAAC;AAO1E,wBAAgB,aAAa,IAAI,UAAU,CAK1C;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAEnD;AAED;;GAEG;AACH,wBAAgB,UAAU;uBAKE,MAAM,UAAU,GAAG,YAAY,GAAG,KAAG,aAAa;;;uBAgBlD,MAAM,WAAW,OAAO,KAAG,MAAM,IAAI;kBAM1C,MAAM,KAAG,MAAM,IAAI;;EAmBzC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,CAAC,EACV,QAAQ,EAAE;IACR,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,OAAO,KAAK,CAAC,CAAC;CACjD;;;EAsBF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,eAE5B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC/B;;;;;gBAqBa,OAAO,GAAG,SAAS;gBAYnB,OAAO,GAAG,SAAS;;;EA6BrC"}

package/dist/chamber.js

@@ -5,28 +5,33 @@
  * the expected signal-based API. Update imports when Vapor stabilizes.
  */
 import { createCommandBus } from './command-bus';
-// Detect environment and get signal function
-function getSignalFn() {
-    // Try Vapor's signal first (when available)
-    // @ts-ignore - Vapor not yet typed
-    if (typeof window !== 'undefined' && window.__VUE_VAPOR__?.signal) {
-        // @ts-ignore
-        return window.__VUE_VAPOR__.signal;
-    }
-    // Fallback: simple signal implementation for testing/non-Vapor
-    return (initial) => {
-        let _value = initial;
-        const listeners = [];
-        return {
-            get value() { return _value; },
-            set value(v) {
-                _value = v;
-                listeners.forEach(fn => fn(v));
-            }
-        };
+// Fallback signal implementation used when Vapor is not available.
+// Uses a plain getter/setter — Vapor's compiler tracks reads/writes itself,
+// so no listener array is needed here.
+const fallbackSignal = (initial) => {
+    let _value = initial;
+    return {
+        get value() { return _value; },
+        set value(v) { _value = v; }
     };
+};
+// Allow explicit configuration of the signal factory — avoids probing
+// private/internal globals (e.g. window.__VUE_VAPOR__) which can break
+// proxy traps and is not a stable public API.
+let _signalFn = fallbackSignal;
+/**
+ * Configure the signal factory used by vapor-chamber composables.
+ * Call this once at app setup when Vue Vapor's signal API is available.
+ *
+ * @example
+ * import { signal } from 'vue-vapor';
+ * import { configureSignal } from 'vapor-chamber';
+ * configureSignal(signal);
+ */
+export function configureSignal(fn) {
+    _signalFn = fn;
 }
-const signal = getSignalFn();
+export const signal = (initial) => _signalFn(initial);
 /**
  * Shared command bus instance
  */
@@ -57,12 +62,28 @@ export function useCommand() {
         }
         return result;
     }
+    const cleanups = [];
+    function register(action, handler) {
+        const unregister = bus.register(action, handler);
+        cleanups.push(unregister);
+        return unregister;
+    }
+    function use(plugin) {
+        const remove = bus.use(plugin);
+        cleanups.push(remove);
+        return remove;
+    }
+    function dispose() {
+        cleanups.forEach(fn => fn());
+        cleanups.length = 0;
+    }
     return {
         dispatch,
         loading,
         lastError,
-        register: bus.register,
-        use: bus.use,
+        register,
+        use,
+        dispose,
     };
 }
 /**
@@ -86,6 +107,21 @@ export function useCommandState(initial, handlers) {
     };
     return { state, dispose };
 }
+/**
+ * useCommandBus - lightweight composable wrapper around the shared bus.
+ *
+ * Designed for the "toolbox" pattern: import only when needed, tree-shaken
+ * out of builds that don't use it. Provides the full bus API plus reactive
+ * loading/error signals — without the automatic cleanup tracking of useCommand.
+ *
+ * @example
+ * import { useCommandBus } from 'vapor-chamber';
+ * const bus = useCommandBus();
+ * bus.dispatch('cart.add', product, { quantity: 1 });
+ */
+export function useCommandBus() {
+    return getCommandBus();
+}
 /**
  * useCommandHistory - undo/redo with reactive state
  */

package/dist/command-bus.d.ts

@@ -1,6 +1,6 @@
 /**
  * vapor-chamber - Command Bus for Vue Vapor
- * ~1KB - Commands + Plugins + Hooks
+ * ~2KB gzipped (core + plugins + composables) — DevTools loaded dynamically
  */
 export type Command = {
     action: string;
@@ -13,26 +13,55 @@ export type CommandResult = {
     error?: Error;
 };
 export type Handler = (cmd: Command) => any;
-export type AsyncHandler = (cmd: Command) => any | Promise<any>;
+export type AsyncHandler = (cmd: Command) => Promise<any>;
 export type Plugin = (cmd: Command, next: () => CommandResult) => CommandResult;
 export type AsyncPlugin = (cmd: Command, next: () => CommandResult | Promise<CommandResult>) => CommandResult | Promise<CommandResult>;
 export type Hook = (cmd: Command, result: CommandResult) => void;
 export type AsyncHook = (cmd: Command, result: CommandResult) => void | Promise<void>;
+/** Options for plugin registration. Higher priority runs first (outermost). Default: 0. */
+export type PluginOptions = {
+    priority?: number;
+};
+/** Batch dispatch input */
+export type BatchCommand = {
+    action: string;
+    target: any;
+    payload?: any;
+};
+/** Result of a batch dispatch */
+export type BatchResult = {
+    ok: boolean;
+    results: CommandResult[];
+    error?: Error;
+};
+/**
+ * Dead letter mode — what to do when a command has no registered handler.
+ * - `'error'` (default): returns `{ ok: false, error }`
+ * - `'throw'`: throws the error
+ * - `'ignore'`: returns `{ ok: true, value: undefined }`
+ * - function: called with the command, return value used as result
+ */
+export type DeadLetterMode = 'error' | 'throw' | 'ignore' | ((cmd: Command) => CommandResult);
+export type CommandBusOptions = {
+    onMissing?: DeadLetterMode;
+};
 export interface CommandBus {
     dispatch: (action: string, target: any, payload?: any) => CommandResult;
+    dispatchBatch: (commands: BatchCommand[]) => BatchResult;
     register: (action: string, handler: Handler) => () => void;
-    use: (plugin: Plugin) => () => void;
+    use: (plugin: Plugin, options?: PluginOptions) => () => void;
     onAfter: (hook: Hook) => () => void;
 }
 export interface AsyncCommandBus {
     dispatch: (action: string, target: any, payload?: any) => Promise<CommandResult>;
+    dispatchBatch: (commands: BatchCommand[]) => Promise<BatchResult>;
     register: (action: string, handler: AsyncHandler) => () => void;
-    use: (plugin: AsyncPlugin) => () => void;
+    use: (plugin: AsyncPlugin, options?: PluginOptions) => () => void;
     onAfter: (hook: AsyncHook) => () => void;
 }
-export declare function createCommandBus(): CommandBus;
+export declare function createCommandBus(options?: CommandBusOptions): CommandBus;
 /**
  * Async command bus - supports async handlers, plugins, and hooks
  */
-export declare function createAsyncCommandBus(): AsyncCommandBus;
+export declare function createAsyncCommandBus(options?: CommandBusOptions): AsyncCommandBus;
 //# sourceMappingURL=command-bus.d.ts.map

package/dist/command-bus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command-bus.d.ts","sourceRoot":"","sources":["../src/command-bus.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,GAAG,CAAC;IACZ,OAAO,CAAC,EAAE,GAAG,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,GAAG,CAAC;AAC5C,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;AAChE,MAAM,MAAM,MAAM,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,KAAK,aAAa,CAAC;AAChF,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,KAAK,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AACvI,MAAM,MAAM,IAAI,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;AACjE,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtF,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,aAAa,CAAC;IACxE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;IAC3D,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,IAAI,CAAC;IACpC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IACjF,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,KAAK,MAAM,IAAI,CAAC;IAChE,GAAG,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM,IAAI,CAAC;IACzC,OAAO,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,IAAI,CAAC;CAC1C;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAgE7C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,eAAe,CAgEvD"}
+{"version":3,"file":"command-bus.d.ts","sourceRoot":"","sources":["../src/command-bus.ts"],"names":[],"mappings":"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"}

package/dist/command-bus.js

@@ -1,31 +1,57 @@
 /**
  * vapor-chamber - Command Bus for Vue Vapor
- * ~1KB - Commands + Plugins + Hooks
+ * ~2KB gzipped (core + plugins + composables) — DevTools loaded dynamically
  */
-export function createCommandBus() {
+// Build a runner once per plugin-list change. On each dispatch the runner
+// receives cmd and execute as arguments — no per-dispatch closure allocation.
+function buildRunner(plugins) {
+    return function run(cmd, execute) {
+        let i = 0;
+        function next() {
+            const plugin = plugins[i++];
+            return plugin ? plugin(cmd, next) : execute();
+        }
+        return next();
+    };
+}
+export function createCommandBus(options = {}) {
     const handlers = new Map();
-    const plugins = [];
+    const pluginEntries = [];
     const afterHooks = [];
+    // Cached runner — rebuilt only when plugins are added or removed
+    let runner = buildRunner([]);
+    function handleMissing(cmd) {
+        const mode = options.onMissing ?? 'error';
+        if (mode === 'ignore')
+            return { ok: true, value: undefined };
+        if (mode === 'throw')
+            throw new Error(`No handler: ${cmd.action}`);
+        if (typeof mode === 'function')
+            return mode(cmd);
+        // 'error' (default)
+        return { ok: false, error: new Error(`No handler: ${cmd.action}`) };
+    }
+    function rebuildRunner() {
+        const sorted = pluginEntries
+            .slice()
+            .sort((a, b) => b.priority - a.priority)
+            .map(e => e.plugin);
+        runner = buildRunner(sorted);
+    }
     function dispatch(action, target, payload) {
         const cmd = { action, target, payload };
         const handler = handlers.get(action);
-        // Build execution chain: plugins wrap the handler
         const execute = () => {
-            if (!handler) {
-                return { ok: false, error: new Error(`No handler: ${action}`) };
-            }
+            if (!handler)
+                return handleMissing(cmd);
             try {
-                const value = handler(cmd);
-                return { ok: true, value };
+                return { ok: true, value: handler(cmd) };
             }
             catch (e) {
                 return { ok: false, error: e };
             }
         };
-        // Apply plugins (right to left, so first plugin is outermost)
-        const chain = plugins.reduceRight((next, plugin) => () => plugin(cmd, next), execute);
-        const result = chain();
-        // Run after hooks
+        const result = runner(cmd, execute);
         for (const hook of afterHooks) {
             try {
                 hook(cmd, result);
@@ -36,16 +62,30 @@ export function createCommandBus() {
         }
         return result;
     }
+    function dispatchBatch(commands) {
+        const results = [];
+        for (const { action, target, payload } of commands) {
+            const result = dispatch(action, target, payload);
+            results.push(result);
+            if (!result.ok)
+                return { ok: false, results, error: result.error };
+        }
+        return { ok: true, results };
+    }
     function register(action, handler) {
         handlers.set(action, handler);
         return () => handlers.delete(action);
     }
-    function use(plugin) {
-        plugins.push(plugin);
+    function use(plugin, opts = {}) {
+        const entry = { plugin, priority: opts.priority ?? 0 };
+        pluginEntries.push(entry);
+        rebuildRunner();
         return () => {
-            const i = plugins.indexOf(plugin);
-            if (i !== -1)
-                plugins.splice(i, 1);
+            const i = pluginEntries.indexOf(entry);
+            if (i !== -1) {
+                pluginEntries.splice(i, 1);
+                rebuildRunner();
+            }
         };
     }
     function onAfter(hook) {
@@ -56,35 +96,58 @@ export function createCommandBus() {
                 afterHooks.splice(i, 1);
         };
     }
-    return { dispatch, register, use, onAfter };
+    return { dispatch, dispatchBatch, register, use, onAfter };
+}
+function buildAsyncRunner(plugins) {
+    return function run(cmd, execute) {
+        let i = 0;
+        function next() {
+            const plugin = plugins[i++];
+            return plugin ? plugin(cmd, next) : execute();
+        }
+        return Promise.resolve(next());
+    };
 }
 /**
  * Async command bus - supports async handlers, plugins, and hooks
  */
-export function createAsyncCommandBus() {
+export function createAsyncCommandBus(options = {}) {
     const handlers = new Map();
-    const plugins = [];
+    const pluginEntries = [];
     const afterHooks = [];
+    // Cached runner — rebuilt only when plugins are added or removed
+    let runner = buildAsyncRunner([]);
+    function handleMissing(cmd) {
+        const mode = options.onMissing ?? 'error';
+        if (mode === 'ignore')
+            return { ok: true, value: undefined };
+        if (mode === 'throw')
+            throw new Error(`No handler: ${cmd.action}`);
+        if (typeof mode === 'function')
+            return mode(cmd);
+        return { ok: false, error: new Error(`No handler: ${cmd.action}`) };
+    }
+    function rebuildRunner() {
+        const sorted = pluginEntries
+            .slice()
+            .sort((a, b) => b.priority - a.priority)
+            .map(e => e.plugin);
+        runner = buildAsyncRunner(sorted);
+    }
     async function dispatch(action, target, payload) {
         const cmd = { action, target, payload };
         const handler = handlers.get(action);
-        // Build execution chain: plugins wrap the handler
         const execute = async () => {
-            if (!handler) {
-                return { ok: false, error: new Error(`No handler: ${action}`) };
-            }
+            if (!handler)
+                return handleMissing(cmd);
             try {
-                const value = await handler(cmd);
-                return { ok: true, value };
+                return { ok: true, value: await handler(cmd) };
             }
             catch (e) {
                 return { ok: false, error: e };
             }
         };
-        // Apply plugins (right to left, so first plugin is outermost)
-        const chain = plugins.reduceRight((next, plugin) => () => plugin(cmd, next), execute);
-        const result = await chain();
-        // Run after hooks
+        const result = await runner(cmd, execute);
         for (const hook of afterHooks) {
             try {
                 await hook(cmd, result);
@@ -95,16 +158,30 @@ export function createAsyncCommandBus() {
         }
         return result;
     }
+    async function dispatchBatch(commands) {
+        const results = [];
+        for (const { action, target, payload } of commands) {
+            const result = await dispatch(action, target, payload);
+            results.push(result);
+            if (!result.ok)
+                return { ok: false, results, error: result.error };
+        }
+        return { ok: true, results };
+    }
     function register(action, handler) {
         handlers.set(action, handler);
         return () => handlers.delete(action);
     }
-    function use(plugin) {
-        plugins.push(plugin);
+    function use(plugin, opts = {}) {
+        const entry = { plugin, priority: opts.priority ?? 0 };
+        pluginEntries.push(entry);
+        rebuildRunner();
         return () => {
-            const i = plugins.indexOf(plugin);
-            if (i !== -1)
-                plugins.splice(i, 1);
+            const i = pluginEntries.indexOf(entry);
+            if (i !== -1) {
+                pluginEntries.splice(i, 1);
+                rebuildRunner();
+            }
         };
     }
     function onAfter(hook) {
@@ -115,5 +192,5 @@ export function createAsyncCommandBus() {
                 afterHooks.splice(i, 1);
         };
     }
-    return { dispatch, register, use, onAfter };
+    return { dispatch, dispatchBatch, register, use, onAfter };
 }

package/dist/devtools.d.ts

@@ -0,0 +1,33 @@
+/**
+ * vapor-chamber - Vue DevTools integration
+ *
+ * Optional. Call setupDevtools(bus, app) once at app setup.
+ * Requires @vue/devtools-api to be installed — silently no-ops if not present.
+ */
+import type { Hook } from './command-bus';
+interface Observable {
+    onAfter: (hook: Hook) => () => void;
+}
+/**
+ * Connect a command bus to Vue DevTools.
+ *
+ * - Adds a **Commands** timeline layer: every dispatch appears as an event,
+ *   green for success, red for error.
+ * - Adds a **Vapor Chamber** inspector panel: browse recent commands,
+ *   inspect target/payload/result of each one.
+ *
+ * @param bus  A CommandBus or AsyncCommandBus instance to observe.
+ * @param app  The Vue app instance (passed to setupDevtoolsPlugin).
+ * @returns    Unsubscribe function — call it to detach from the bus.
+ *
+ * @example
+ * import { createApp } from 'vue';
+ * import { getCommandBus, setupDevtools } from 'vapor-chamber';
+ *
+ * const app = createApp(App);
+ * setupDevtools(getCommandBus(), app);
+ * app.mount('#app');
+ */
+export declare function setupDevtools(bus: Observable, app: unknown): () => void;
+export {};
+//# sourceMappingURL=devtools.d.ts.map

package/dist/devtools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.d.ts","sourceRoot":"","sources":["../src/devtools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAA0B,IAAI,EAAE,MAAM,eAAe,CAAC;AAOlE,UAAU,UAAU;IAClB,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,IAAI,CAAC;CACrC;AASD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,IAAI,CAyIvE"}

package/dist/devtools.js

@@ -0,0 +1,153 @@
+/**
+ * vapor-chamber - Vue DevTools integration
+ *
+ * Optional. Call setupDevtools(bus, app) once at app setup.
+ * Requires @vue/devtools-api to be installed — silently no-ops if not present.
+ */
+const INSPECTOR_ID = 'vapor-chamber';
+const LAYER_ID = 'vapor-chamber';
+/**
+ * Connect a command bus to Vue DevTools.
+ *
+ * - Adds a **Commands** timeline layer: every dispatch appears as an event,
+ *   green for success, red for error.
+ * - Adds a **Vapor Chamber** inspector panel: browse recent commands,
+ *   inspect target/payload/result of each one.
+ *
+ * @param bus  A CommandBus or AsyncCommandBus instance to observe.
+ * @param app  The Vue app instance (passed to setupDevtoolsPlugin).
+ * @returns    Unsubscribe function — call it to detach from the bus.
+ *
+ * @example
+ * import { createApp } from 'vue';
+ * import { getCommandBus, setupDevtools } from 'vapor-chamber';
+ *
+ * const app = createApp(App);
+ * setupDevtools(getCommandBus(), app);
+ * app.mount('#app');
+ */
+export function setupDevtools(bus, app) {
+    // Guard: no-op in production. Bundlers (Vite, webpack, Rollup) replace
+    // process.env.NODE_ENV with 'production' in prod builds, making this entire
+    // function body dead code that tree-shakers eliminate for a true 0KB footprint.
+    // globalThis cast avoids requiring @types/node while preserving the replacement target.
+    const env = globalThis.process?.env?.NODE_ENV;
+    if (env === 'production') {
+        return () => { };
+    }
+    const entries = [];
+    let counter = 0;
+    let devApi = null;
+    // Hook into the bus — this runs even before devtools loads
+    const unsubscribe = bus.onAfter((cmd, result) => {
+        const entry = {
+            id: counter++,
+            cmd,
+            result,
+            time: Date.now(),
+        };
+        entries.unshift(entry);
+        if (entries.length > 100)
+            entries.pop(); // keep last 100 commands
+        if (devApi) {
+            devApi.addTimelineEvent({
+                layerId: LAYER_ID,
+                event: {
+                    time: Date.now(),
+                    title: cmd.action,
+                    subtitle: result.ok ? '✓' : '✗ error',
+                    data: {
+                        action: cmd.action,
+                        target: cmd.target,
+                        ...(cmd.payload !== undefined ? { payload: cmd.payload } : {}),
+                        ok: result.ok,
+                        ...(result.ok
+                            ? { value: result.value }
+                            : { error: result.error?.message }),
+                    },
+                    logType: result.ok ? 'default' : 'error',
+                },
+            });
+            devApi.sendInspectorTree(INSPECTOR_ID);
+        }
+    });
+    // Dynamic import — zero cost if @vue/devtools-api is not installed.
+    // Using a variable prevents TypeScript from attempting module resolution
+    // on an optional peer dependency that may not be installed.
+    const devtoolsModule = '@vue/devtools-api';
+    import(devtoolsModule)
+        .then(({ setupDevtoolsPlugin }) => {
+        setupDevtoolsPlugin({
+            id: 'vapor-chamber',
+            label: 'Vapor Chamber',
+            packageName: 'vapor-chamber',
+            homepage: 'https://github.com/lucianofedericopereira/vapor-chamber',
+            app,
+        }, (api) => {
+            devApi = api;
+            // Timeline layer: one event per dispatched command
+            api.addTimelineLayer({
+                id: LAYER_ID,
+                color: 0x41b883, // Vue green
+                label: 'Commands',
+            });
+            // Inspector panel: browse and inspect recent commands
+            api.addInspector({
+                id: INSPECTOR_ID,
+                label: 'Vapor Chamber',
+                icon: 'mediation',
+                treeFilterPlaceholder: 'Filter by action',
+            });
+            // Build the inspector tree from buffered entries
+            api.on.getInspectorTree((payload) => {
+                if (payload.inspectorId !== INSPECTOR_ID)
+                    return;
+                const filter = (payload.filter ?? '').toLowerCase();
+                payload.rootNodes = entries
+                    .filter(e => !filter || e.cmd.action.toLowerCase().includes(filter))
+                    .map(e => ({
+                    id: String(e.id),
+                    label: e.cmd.action,
+                    tags: [
+                        {
+                            label: e.result.ok ? 'ok' : 'error',
+                            textColor: 0xffffff,
+                            backgroundColor: e.result.ok ? 0x41b883 : 0xff4444,
+                        },
+                    ],
+                }));
+            });
+            // Show full detail when a node is selected in the inspector
+            api.on.getInspectorState((payload) => {
+                if (payload.inspectorId !== INSPECTOR_ID)
+                    return;
+                const entry = entries.find(e => String(e.id) === payload.nodeId);
+                if (!entry)
+                    return;
+                payload.state = {
+                    command: [
+                        { key: 'action', value: entry.cmd.action },
+                        { key: 'target', value: entry.cmd.target },
+                        ...(entry.cmd.payload !== undefined
+                            ? [{ key: 'payload', value: entry.cmd.payload }]
+                            : []),
+                    ],
+                    result: [
+                        { key: 'ok', value: entry.result.ok },
+                        ...(entry.result.ok
+                            ? [{ key: 'value', value: entry.result.value }]
+                            : [{ key: 'error', value: entry.result.error?.message }]),
+                    ],
+                    meta: [
+                        { key: 'time', value: new Date(entry.time).toISOString() },
+                        { key: 'index', value: entry.id },
+                    ],
+                };
+            });
+        });
+    })
+        .catch(() => {
+        // @vue/devtools-api not installed — silently no-op in production
+    });
+    return unsubscribe;
+}

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 /**
  * vapor-chamber - Lightweight command bus for Vue Vapor
  *
- * A ~1KB command bus with plugins, hooks, and Vapor-native reactivity.
+ * ~2KB gzipped (core + plugins + composables). DevTools loaded dynamically.
  */
-export { createCommandBus, createAsyncCommandBus, type Command, type CommandResult, type CommandBus, type AsyncCommandBus, type Handler, type AsyncHandler, type Plugin, type AsyncPlugin, type Hook, type AsyncHook, } from './command-bus';
+export { createCommandBus, createAsyncCommandBus, type Command, type CommandResult, type CommandBus, type AsyncCommandBus, type Handler, type AsyncHandler, type Plugin, type AsyncPlugin, type Hook, type AsyncHook, type PluginOptions, type BatchCommand, type BatchResult, type DeadLetterMode, type CommandBusOptions, } from './command-bus';
+export { createTestBus, type TestBus, type RecordedDispatch } from './testing';
 export { logger, validator, history, debounce, throttle, type HistoryState, } from './plugins';
-export { getCommandBus, setCommandBus, useCommand, useCommandState, useCommandHistory, } from './chamber';
+export { signal, configureSignal, type Signal, type CreateSignal, getCommandBus, setCommandBus, useCommandBus, useCommand, useCommandState, useCommandHistory, } from './chamber';
+export { setupDevtools } from './devtools';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,IAAI,EACT,KAAK,SAAS,GACf,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,MAAM,EACN,SAAS,EACT,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,KAAK,YAAY,GAClB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,aAAa,EACb,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,WAAW,EAChB,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAG/E,OAAO,EACL,MAAM,EACN,SAAS,EACT,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,KAAK,YAAY,GAClB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,MAAM,EACN,eAAe,EACf,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,aAAa,EACb,aAAa,EACb,aAAa,EACb,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,11 +1,15 @@
 /**
  * vapor-chamber - Lightweight command bus for Vue Vapor
  *
- * A ~1KB command bus with plugins, hooks, and Vapor-native reactivity.
+ * ~2KB gzipped (core + plugins + composables). DevTools loaded dynamically.
  */
 // Core
 export { createCommandBus, createAsyncCommandBus, } from './command-bus';
+// Testing utilities
+export { createTestBus } from './testing';
 // Plugins
 export { logger, validator, history, debounce, throttle, } from './plugins';
 // Vapor integration
-export { getCommandBus, setCommandBus, useCommand, useCommandState, useCommandHistory, } from './chamber';
+export { signal, configureSignal, getCommandBus, setCommandBus, useCommandBus, useCommand, useCommandState, useCommandHistory, } from './chamber';
+// DevTools integration (optional — requires @vue/devtools-api)
+export { setupDevtools } from './devtools';

package/dist/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,EAAE,MAAM,eAAe,CAAC;AAEpE;;GAEG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC/B,GAAG,MAAM,CAwBd;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAC/B,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;CACnD,GAAG,MAAM,CAWT;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,OAAO,CAAC,OAAO,GAAE;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC/B,GAAG,MAAM,GAAG;IAChB,QAAQ,EAAE,MAAM,YAAY,CAAC;IAC7B,IAAI,EAAE,MAAM,OAAO,GAAG,SAAS,CAAC;IAChC,IAAI,EAAE,MAAM,OAAO,GAAG,SAAS,CAAC;IAChC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAwCA;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,CAwBR;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,CAmBR"}
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,EAAE,MAAM,eAAe,CAAC;AAEpE;;GAEG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC/B,GAAG,MAAM,CAwBd;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE;IAC/B,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI,CAAC;CACnD,GAAG,MAAM,CAWT;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,OAAO,CAAC,OAAO,GAAE;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC/B,GAAG,MAAM,GAAG;IAChB,QAAQ,EAAE,MAAM,YAAY,CAAC;IAC7B,IAAI,EAAE,MAAM,OAAO,GAAG,SAAS,CAAC;IAChC,IAAI,EAAE,MAAM,OAAO,GAAG,SAAS,CAAC;IAChC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAwCA;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,CA0BR;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,CAqBR"}

package/dist/plugins.js

@@ -102,6 +102,8 @@ export function debounce(actions, wait) {
             const result = next();
             results.set(key, result);
             timers.delete(key);
+            // Clean up result after one render cycle to avoid unbounded map growth
+            setTimeout(() => results.delete(key), 0);
         }, wait));
         // Return pending status synchronously (check results map for actual result)
         return results.get(key) ?? { ok: true, value: { pending: true, key } };
@@ -122,6 +124,8 @@ export function throttle(actions, wait) {
         const last = lastRun.get(key) ?? 0;
         if (now - last >= wait) {
             lastRun.set(key, now);
+            // Schedule removal after the window so the map doesn't grow unbounded
+            setTimeout(() => lastRun.delete(key), wait);
             return next();
         }
         // Throttled - return skipped status

package/dist/testing.d.ts

@@ -0,0 +1,44 @@
+/**
+ * vapor-chamber - Testing utilities
+ *
+ * createTestBus() creates a command bus that records all dispatched commands
+ * without executing real handlers. Useful for unit-testing components that
+ * use useCommand() without wiring up the full application logic.
+ *
+ * @example
+ * const bus = createTestBus();
+ * setCommandBus(bus);
+ *
+ * // Dispatch something under test
+ * bus.dispatch('cart:add', cart, { id: 1 });
+ *
+ * // Assert
+ * expect(bus.wasDispatched('cart:add')).toBe(true);
+ * expect(bus.getDispatched('cart:add')[0].cmd.payload).toEqual({ id: 1 });
+ */
+import type { Command, CommandResult, CommandBus } from './command-bus';
+export interface RecordedDispatch {
+    cmd: Command;
+    result: CommandResult;
+}
+export interface TestBus extends CommandBus {
+    /** All dispatched commands in order */
+    readonly recorded: RecordedDispatch[];
+    /** True if any command with this action was dispatched */
+    wasDispatched(action: string): boolean;
+    /** All recorded dispatches for a given action */
+    getDispatched(action: string): RecordedDispatch[];
+    /** Clear the recorded list */
+    clear(): void;
+}
+/**
+ * Creates a test bus that stubs all handlers (returning `{ ok: true }`) unless
+ * you register your own via `bus.register()`. All dispatches are recorded.
+ *
+ * Pass `{ passthroughHandlers: true }` to execute real handlers while still
+ * recording every dispatch.
+ */
+export declare function createTestBus(opts?: {
+    passthroughHandlers?: boolean;
+}): TestBus;
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAmE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEzI,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,MAAM,WAAW,OAAQ,SAAQ,UAAU;IACzC,uCAAuC;IACvC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IACtC,0DAA0D;IAC1D,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,iDAAiD;IACjD,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAAC;IAClD,8BAA8B;IAC9B,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,GAAE;IAAE,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CAuGnF"}

package/dist/testing.js

@@ -0,0 +1,126 @@
+/**
+ * vapor-chamber - Testing utilities
+ *
+ * createTestBus() creates a command bus that records all dispatched commands
+ * without executing real handlers. Useful for unit-testing components that
+ * use useCommand() without wiring up the full application logic.
+ *
+ * @example
+ * const bus = createTestBus();
+ * setCommandBus(bus);
+ *
+ * // Dispatch something under test
+ * bus.dispatch('cart:add', cart, { id: 1 });
+ *
+ * // Assert
+ * expect(bus.wasDispatched('cart:add')).toBe(true);
+ * expect(bus.getDispatched('cart:add')[0].cmd.payload).toEqual({ id: 1 });
+ */
+/**
+ * Creates a test bus that stubs all handlers (returning `{ ok: true }`) unless
+ * you register your own via `bus.register()`. All dispatches are recorded.
+ *
+ * Pass `{ passthroughHandlers: true }` to execute real handlers while still
+ * recording every dispatch.
+ */
+export function createTestBus(opts = {}) {
+    const handlers = new Map();
+    const plugins = [];
+    const afterHooks = [];
+    const recorded = [];
+    function buildRunner(sortedPlugins) {
+        return function run(cmd, execute) {
+            let i = 0;
+            function next() {
+                const plugin = sortedPlugins[i++];
+                return plugin ? plugin(cmd, next) : execute();
+            }
+            return next();
+        };
+    }
+    let runner = buildRunner([]);
+    function rebuildRunner() {
+        const sorted = plugins.slice().sort((a, b) => b.priority - a.priority).map(e => e.plugin);
+        runner = buildRunner(sorted);
+    }
+    function dispatch(action, target, payload) {
+        const cmd = { action, target, payload };
+        const handler = handlers.get(action);
+        const execute = () => {
+            if (opts.passthroughHandlers && handler) {
+                try {
+                    return { ok: true, value: handler(cmd) };
+                }
+                catch (e) {
+                    return { ok: false, error: e };
+                }
+            }
+            // Stub: return ok:true if no real handler registered, run it if one is
+            if (handler) {
+                try {
+                    return { ok: true, value: handler(cmd) };
+                }
+                catch (e) {
+                    return { ok: false, error: e };
+                }
+            }
+            return { ok: true, value: undefined };
+        };
+        const result = runner(cmd, execute);
+        recorded.push({ cmd, result });
+        for (const hook of afterHooks) {
+            try {
+                hook(cmd, result);
+            }
+            catch (e) {
+                console.error('[vapor-chamber/test] Hook error:', e);
+            }
+        }
+        return result;
+    }
+    function dispatchBatch(commands) {
+        const results = [];
+        for (const { action, target, payload } of commands) {
+            const result = dispatch(action, target, payload);
+            results.push(result);
+            if (!result.ok)
+                return { ok: false, results, error: result.error };
+        }
+        return { ok: true, results };
+    }
+    function register(action, handler) {
+        handlers.set(action, handler);
+        return () => handlers.delete(action);
+    }
+    function use(plugin, options = {}) {
+        const entry = { plugin, priority: options.priority ?? 0 };
+        plugins.push(entry);
+        rebuildRunner();
+        return () => {
+            const i = plugins.indexOf(entry);
+            if (i !== -1) {
+                plugins.splice(i, 1);
+                rebuildRunner();
+            }
+        };
+    }
+    function onAfter(hook) {
+        afterHooks.push(hook);
+        return () => {
+            const i = afterHooks.indexOf(hook);
+            if (i !== -1)
+                afterHooks.splice(i, 1);
+        };
+    }
+    return {
+        dispatch,
+        dispatchBatch,
+        register,
+        use,
+        onAfter,
+        recorded,
+        wasDispatched: (action) => recorded.some(r => r.cmd.action === action),
+        getDispatched: (action) => recorded.filter(r => r.cmd.action === action),
+        clear: () => recorded.splice(0),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vapor-chamber",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Lightweight command bus for Vue Vapor - plugins, hooks, undo/redo",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,6 +15,7 @@
   "files": [
     "dist"
   ],
+  "sideEffects": false,
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
@@ -47,11 +48,15 @@
   },
   "homepage": "https://github.com/lucianofedericopereira/vapor-chamber#readme",
   "peerDependencies": {
-    "vue": ">=3.5.0"
+    "vue": ">=3.5.0",
+    "@vue/devtools-api": ">=6.0.0"
   },
   "peerDependenciesMeta": {
     "vue": {
       "optional": true
+    },
+    "@vue/devtools-api": {
+      "optional": true
     }
   },
   "devDependencies": {