vapor-chamber 0.1.0

package/README.md

@@ -0,0 +1,301 @@
+# Vapor Chamber
+
+A lightweight command bus designed for [Vue Vapor](https://github.com/vuejs/vue-vapor). ~1KB core.
+
+## What is Vue Vapor?
+
+Vue Vapor is Vue's upcoming compilation strategy that eliminates the Virtual DOM. Instead of diffing virtual trees, Vapor compiles templates to direct DOM operations using **signals** - reactive primitives that update only what changed.
+
+**Vapor Chamber** embraces this philosophy: minimal abstraction, direct updates, signal-native reactivity.
+
+## Why a Command Bus?
+
+Traditional event systems scatter logic across components. A command bus centralizes it:
+
+```
+Event-driven (scattered)          Command bus (centralized)
+─────────────────────────         ─────────────────────────
+Component A emits 'add'    →      dispatch('cart.add', product)
+Component B listens...            ↓
+Component C also listens...       Handler executes once
+Who handles what? When?           Plugins observe/modify
+                                  Result returned
+```
+
+**Benefits:**
+- **Semantic actions** - `cart.add` is clearer than `emit('add')`
+- **Single handler** - One place to look, debug, test
+- **Plugin pipeline** - Cross-cutting concerns (logging, validation, analytics) without cluttering handlers
+- **Undo/redo** - Command history is natural when actions are explicit
+
+## Install
+
+```bash
+npm install vapor-chamber
+```
+
+## Quick Start
+
+```typescript
+import { createCommandBus, logger, validator } from 'vapor-chamber';
+
+const bus = createCommandBus();
+
+// Add plugins
+bus.use(logger());
+bus.use(validator({
+  'cart.add': (cmd) => cmd.payload?.quantity > 0 ? null : 'Quantity required'
+}));
+
+// Register handler
+bus.register('cart.add', (cmd) => {
+  cart.items.push({ ...cmd.target, quantity: cmd.payload.quantity });
+  return cart.items;
+});
+
+// Dispatch
+const result = bus.dispatch('cart.add', product, { quantity: 2 });
+if (result.ok) {
+  console.log('Added:', result.value);
+} else {
+  console.error('Failed:', result.error);
+}
+```
+
+## Core Concepts
+
+### Commands
+
+A command has three parts:
+
+```typescript
+bus.dispatch(
+  'cart.add',      // action - what to do
+  product,         // target - what to act on
+  { quantity: 2 }  // payload - additional data (optional)
+);
+```
+
+### Handlers
+
+One handler per action. Returns a value or throws:
+
+```typescript
+bus.register('cart.add', (cmd) => {
+  // cmd.action  = 'cart.add'
+  // cmd.target  = product
+  // cmd.payload = { quantity: 2 }
+
+  cart.items.push(cmd.target);
+  return cart.items; // becomes result.value
+});
+```
+
+### Results
+
+Every dispatch returns a result:
+
+```typescript
+type CommandResult = {
+  ok: boolean;     // success or failure
+  value?: any;     // handler return value (if ok)
+  error?: Error;   // error thrown (if not ok)
+};
+```
+
+### Plugins
+
+Plugins wrap handlers. They can modify commands, short-circuit execution, observe results, or transform output:
+
+```typescript
+const timingPlugin: Plugin = (cmd, next) => {
+  const start = Date.now();
+  const result = next();  // call next plugin or handler
+  console.log(`${cmd.action} took ${Date.now() - start}ms`);
+  return result;
+};
+
+bus.use(timingPlugin);
+```
+
+Plugins execute in order: first added = outermost wrapper.
+
+## Built-in Plugins
+
+| Plugin | Description |
+|--------|-------------|
+| `logger(options?)` | Log commands to console |
+| `validator(rules)` | Validate commands before execution |
+| `history(options?)` | Track command history for undo/redo |
+| `debounce(actions, wait)` | Delay execution until activity stops |
+| `throttle(actions, wait)` | Limit execution frequency |
+
+### logger
+
+```typescript
+bus.use(logger({ collapsed: true, filter: (cmd) => cmd.action.startsWith('cart.') }));
+```
+
+### validator
+
+```typescript
+bus.use(validator({
+  'cart.add': (cmd) => {
+    if (!cmd.target?.id) return 'Product must have an ID';
+    return null;  // null = valid
+  }
+}));
+```
+
+### history
+
+```typescript
+const historyPlugin = history({ maxSize: 100 });
+bus.use(historyPlugin);
+
+historyPlugin.undo();
+historyPlugin.redo();
+historyPlugin.getState(); // { past, future, canUndo, canRedo }
+```
+
+### debounce
+
+```typescript
+bus.use(debounce(['search.query'], 300)); // wait 300ms after last call
+```
+
+### throttle
+
+```typescript
+bus.use(throttle(['ui.scroll'], 100)); // max once per 100ms
+```
+
+## Async Command Bus
+
+For async handlers (API calls, IndexedDB, etc.):
+
+```typescript
+import { createAsyncCommandBus } from 'vapor-chamber';
+
+const bus = createAsyncCommandBus();
+
+bus.register('user.fetch', async (cmd) => {
+  const response = await fetch(`/api/users/${cmd.target.id}`);
+  return response.json();
+});
+
+const result = await bus.dispatch('user.fetch', { id: 123 });
+```
+
+## Vapor Composables
+
+For Vue Vapor components:
+
+### useCommand
+
+```vue
+<script setup>
+import { useCommand } from 'vapor-chamber';
+
+const { dispatch, loading, lastError } = useCommand();
+</script>
+
+<template>
+  <button @click="dispatch('save', doc)" :disabled="loading.value">Save</button>
+  <p v-if="lastError.value">{{ lastError.value.message }}</p>
+</template>
+```
+
+### useCommandState
+
+```vue
+<script setup>
+import { useCommandState } from 'vapor-chamber';
+
+const { state: cart } = useCommandState(
+  { items: [], total: 0 },
+  {
+    'cart.add': (state, cmd) => ({
+      items: [...state.items, cmd.target],
+      total: state.total + cmd.target.price
+    })
+  }
+);
+</script>
+```
+
+### useCommandHistory
+
+```vue
+<script setup>
+import { useCommandHistory } from 'vapor-chamber';
+
+const { canUndo, canRedo, undo, redo } = useCommandHistory({
+  filter: (cmd) => cmd.action.startsWith('editor.')
+});
+</script>
+```
+
+## Examples
+
+See the [`examples/`](./examples) folder for complete, runnable examples:
+
+| Example | Description |
+|---------|-------------|
+| [`shopping-cart.ts`](./examples/shopping-cart.ts) | Cart with validation, history, and undo/redo |
+| [`form-validation.ts`](./examples/form-validation.ts) | Form validation with error handling |
+| [`async-api.ts`](./examples/async-api.ts) | Async handlers with retry plugin |
+| [`realtime-search.ts`](./examples/realtime-search.ts) | Debounced search queries |
+| [`custom-plugins.ts`](./examples/custom-plugins.ts) | Analytics, auth guard, rate limiter plugins |
+| [`vue-vapor-component.vue`](./examples/vue-vapor-component.vue) | Full Vue Vapor todo app |
+
+Run TypeScript examples with:
+```bash
+npx ts-node examples/shopping-cart.ts
+```
+
+## API Reference
+
+### Core
+
+| Function | Description |
+|----------|-------------|
+| `createCommandBus()` | Create a synchronous command bus |
+| `createAsyncCommandBus()` | Create an async command bus |
+
+### Command Bus Methods
+
+| Method | Description |
+|--------|-------------|
+| `dispatch(action, target, payload?)` | Execute a command |
+| `register(action, handler)` | Register a handler (returns unregister fn) |
+| `use(plugin)` | Add a plugin (returns unsubscribe fn) |
+| `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 |
+| `getCommandBus()` | Get shared bus instance |
+| `setCommandBus(bus)` | Set shared bus instance |
+
+## Documentation
+
+See the [`docs/`](./docs) folder for detailed documentation:
+
+- [Whitepaper](./docs/whitepaper.md) - Design philosophy and architecture
+
+## Design Goals
+
+1. **Minimal** - ~1KB core, no dependencies
+2. **Vapor-native** - Built for signals, not VDOM
+3. **Composable** - Plugins for everything
+4. **Type-safe** - Full TypeScript support
+5. **Predictable** - Sync by default, explicit async
+
+## License
+
+[GNU Lesser General Public License v2.1](https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html)

package/dist/chamber.d.ts

@@ -0,0 +1,49 @@
+/**
+ * vapor-chamber - Vue Vapor integration
+ *
+ * Note: Vue Vapor is still in development. This integration uses
+ * 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> = {
+    value: T;
+};
+export declare function getCommandBus(): CommandBus;
+export declare function setCommandBus(bus: CommandBus): void;
+/**
+ * useCommand - dispatch commands with reactive loading/error state
+ */
+export declare function useCommand(): {
+    dispatch: (action: string, target: any, payload?: any) => CommandResult;
+    loading: Signal<boolean>;
+    lastError: Signal<Error | null>;
+    register: (action: string, handler: Handler) => () => void;
+    use: (plugin: Plugin) => () => void;
+};
+/**
+ * useCommandState - create reactive state that updates via commands
+ */
+export declare function useCommandState<T>(initial: T, handlers: {
+    [action: string]: (state: T, cmd: Command) => T;
+}): {
+    state: Signal<T>;
+    dispose: () => void;
+};
+/**
+ * useCommandHistory - undo/redo with reactive state
+ */
+export declare function useCommandHistory(options?: {
+    maxSize?: number;
+    filter?: (cmd: Command) => boolean;
+}): {
+    past: Signal<Command[]>;
+    future: Signal<Command[]>;
+    canUndo: Signal<boolean>;
+    canRedo: Signal<boolean>;
+    undo: () => Command | undefined;
+    redo: () => Command | undefined;
+    clear: () => void;
+    dispose: () => void;
+};
+export {};
+//# sourceMappingURL=chamber.d.ts.map

package/dist/chamber.d.ts.map

@@ -0,0 +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"}

package/dist/chamber.js

@@ -0,0 +1,149 @@
+/**
+ * vapor-chamber - Vue Vapor integration
+ *
+ * Note: Vue Vapor is still in development. This integration uses
+ * 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));
+            }
+        };
+    };
+}
+const signal = getSignalFn();
+/**
+ * Shared command bus instance
+ */
+let sharedBus = null;
+export function getCommandBus() {
+    if (!sharedBus) {
+        sharedBus = createCommandBus();
+    }
+    return sharedBus;
+}
+export function setCommandBus(bus) {
+    sharedBus = bus;
+}
+/**
+ * useCommand - dispatch commands with reactive loading/error state
+ */
+export function useCommand() {
+    const bus = getCommandBus();
+    const loading = signal(false);
+    const lastError = signal(null);
+    function dispatch(action, target, payload) {
+        loading.value = true;
+        lastError.value = null;
+        const result = bus.dispatch(action, target, payload);
+        loading.value = false;
+        if (!result.ok) {
+            lastError.value = result.error ?? null;
+        }
+        return result;
+    }
+    return {
+        dispatch,
+        loading,
+        lastError,
+        register: bus.register,
+        use: bus.use,
+    };
+}
+/**
+ * useCommandState - create reactive state that updates via commands
+ */
+export function useCommandState(initial, handlers) {
+    const bus = getCommandBus();
+    const state = signal(initial);
+    // Register handlers that update state
+    const unregisters = [];
+    for (const [action, handler] of Object.entries(handlers)) {
+        const unregister = bus.register(action, (cmd) => {
+            state.value = handler(state.value, cmd);
+            return state.value;
+        });
+        unregisters.push(unregister);
+    }
+    // Cleanup function
+    const dispose = () => {
+        unregisters.forEach(fn => fn());
+    };
+    return { state, dispose };
+}
+/**
+ * useCommandHistory - undo/redo with reactive state
+ */
+export function useCommandHistory(options = {}) {
+    const { maxSize = 50, filter } = options;
+    const bus = getCommandBus();
+    const past = signal([]);
+    const future = signal([]);
+    const canUndo = signal(false);
+    const canRedo = signal(false);
+    // Track commands via afterHook
+    const unsubscribe = bus.onAfter((cmd, result) => {
+        if (result.ok && (!filter || filter(cmd))) {
+            const newPast = [...past.value, cmd];
+            if (newPast.length > maxSize)
+                newPast.shift();
+            past.value = newPast;
+            future.value = [];
+            canUndo.value = true;
+            canRedo.value = false;
+        }
+    });
+    function undo() {
+        const p = [...past.value];
+        const cmd = p.pop();
+        if (cmd) {
+            past.value = p;
+            future.value = [...future.value, cmd];
+            canUndo.value = p.length > 0;
+            canRedo.value = true;
+        }
+        return cmd;
+    }
+    function redo() {
+        const f = [...future.value];
+        const cmd = f.pop();
+        if (cmd) {
+            future.value = f;
+            past.value = [...past.value, cmd];
+            canUndo.value = true;
+            canRedo.value = f.length > 0;
+        }
+        return cmd;
+    }
+    function clear() {
+        past.value = [];
+        future.value = [];
+        canUndo.value = false;
+        canRedo.value = false;
+    }
+    return {
+        past,
+        future,
+        canUndo,
+        canRedo,
+        undo,
+        redo,
+        clear,
+        dispose: unsubscribe,
+    };
+}

package/dist/command-bus.d.ts

@@ -0,0 +1,38 @@
+/**
+ * vapor-chamber - Command Bus for Vue Vapor
+ * ~1KB - Commands + Plugins + Hooks
+ */
+export type Command = {
+    action: string;
+    target: any;
+    payload?: any;
+};
+export type CommandResult = {
+    ok: boolean;
+    value?: any;
+    error?: Error;
+};
+export type Handler = (cmd: Command) => any;
+export type AsyncHandler = (cmd: Command) => any | 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>;
+export interface CommandBus {
+    dispatch: (action: string, target: any, payload?: any) => CommandResult;
+    register: (action: string, handler: Handler) => () => void;
+    use: (plugin: Plugin) => () => void;
+    onAfter: (hook: Hook) => () => void;
+}
+export interface AsyncCommandBus {
+    dispatch: (action: string, target: any, payload?: any) => Promise<CommandResult>;
+    register: (action: string, handler: AsyncHandler) => () => void;
+    use: (plugin: AsyncPlugin) => () => void;
+    onAfter: (hook: AsyncHook) => () => void;
+}
+export declare function createCommandBus(): CommandBus;
+/**
+ * Async command bus - supports async handlers, plugins, and hooks
+ */
+export declare function createAsyncCommandBus(): AsyncCommandBus;
+//# sourceMappingURL=command-bus.d.ts.map

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

@@ -0,0 +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"}

package/dist/command-bus.js

@@ -0,0 +1,119 @@
+/**
+ * vapor-chamber - Command Bus for Vue Vapor
+ * ~1KB - Commands + Plugins + Hooks
+ */
+export function createCommandBus() {
+    const handlers = new Map();
+    const plugins = [];
+    const afterHooks = [];
+    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}`) };
+            }
+            try {
+                const value = handler(cmd);
+                return { ok: true, value };
+            }
+            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
+        for (const hook of afterHooks) {
+            try {
+                hook(cmd, result);
+            }
+            catch (e) {
+                console.error('[vapor-chamber] Hook error:', e);
+            }
+        }
+        return result;
+    }
+    function register(action, handler) {
+        handlers.set(action, handler);
+        return () => handlers.delete(action);
+    }
+    function use(plugin) {
+        plugins.push(plugin);
+        return () => {
+            const i = plugins.indexOf(plugin);
+            if (i !== -1)
+                plugins.splice(i, 1);
+        };
+    }
+    function onAfter(hook) {
+        afterHooks.push(hook);
+        return () => {
+            const i = afterHooks.indexOf(hook);
+            if (i !== -1)
+                afterHooks.splice(i, 1);
+        };
+    }
+    return { dispatch, register, use, onAfter };
+}
+/**
+ * Async command bus - supports async handlers, plugins, and hooks
+ */
+export function createAsyncCommandBus() {
+    const handlers = new Map();
+    const plugins = [];
+    const afterHooks = [];
+    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}`) };
+            }
+            try {
+                const value = await handler(cmd);
+                return { ok: true, value };
+            }
+            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
+        for (const hook of afterHooks) {
+            try {
+                await hook(cmd, result);
+            }
+            catch (e) {
+                console.error('[vapor-chamber] Hook error:', e);
+            }
+        }
+        return result;
+    }
+    function register(action, handler) {
+        handlers.set(action, handler);
+        return () => handlers.delete(action);
+    }
+    function use(plugin) {
+        plugins.push(plugin);
+        return () => {
+            const i = plugins.indexOf(plugin);
+            if (i !== -1)
+                plugins.splice(i, 1);
+        };
+    }
+    function onAfter(hook) {
+        afterHooks.push(hook);
+        return () => {
+            const i = afterHooks.indexOf(hook);
+            if (i !== -1)
+                afterHooks.splice(i, 1);
+        };
+    }
+    return { dispatch, register, use, onAfter };
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * vapor-chamber - Lightweight command bus for Vue Vapor
+ *
+ * A ~1KB command bus with plugins, hooks, and Vapor-native reactivity.
+ */
+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 { logger, validator, history, debounce, throttle, type HistoryState, } from './plugins';
+export { getCommandBus, setCommandBus, useCommand, useCommandState, useCommandHistory, } from './chamber';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * vapor-chamber - Lightweight command bus for Vue Vapor
+ *
+ * A ~1KB command bus with plugins, hooks, and Vapor-native reactivity.
+ */
+// Core
+export { createCommandBus, createAsyncCommandBus, } from './command-bus';
+// Plugins
+export { logger, validator, history, debounce, throttle, } from './plugins';
+// Vapor integration
+export { getCommandBus, setCommandBus, useCommand, useCommandState, useCommandHistory, } from './chamber';