@vielzeug/codex 2.1.1 → 2.1.4

package/data/catalog.json

@@ -196,7 +196,7 @@
         "refine"
       ],
       "slug": "codex",
-      "version": "2.1.0"
+      "version": "2.1.3"
     },
     {
       "availableDocPages": [
@@ -479,7 +479,7 @@
         "courier"
       ],
       "slug": "flux",
-      "version": "2.0.2"
+      "version": "2.0.3"
     },
     {
       "availableDocPages": [
@@ -663,7 +663,7 @@
         "vault"
       ],
       "slug": "ledger",
-      "version": "2.1.0"
+      "version": "2.1.1"
     },
     {
       "availableDocPages": [
@@ -787,7 +787,7 @@
         "prism"
       ],
       "slug": "orbit",
-      "version": "2.0.0"
+      "version": "2.0.1"
     },
     {
       "availableDocPages": [
@@ -855,7 +855,7 @@
         "orbit"
       ],
       "slug": "ore",
-      "version": "2.0.2"
+      "version": "2.0.4"
     },
     {
       "availableDocPages": [
@@ -911,7 +911,7 @@
         "orbit"
       ],
       "slug": "prism",
-      "version": "2.1.0"
+      "version": "2.1.1"
     },
     {
       "availableDocPages": [
@@ -966,7 +966,7 @@
         "clockwork"
       ],
       "slug": "pulse",
-      "version": "2.1.0"
+      "version": "2.1.1"
     },
     {
       "availableDocPages": [
@@ -1064,7 +1064,7 @@
         "keymap"
       ],
       "slug": "refine",
-      "version": "2.0.2"
+      "version": "2.1.1"
     },
     {
       "availableDocPages": [
@@ -1074,7 +1074,7 @@
         "examples"
       ],
       "category": "state",
-      "description": "Framework-agnostic signals, derived values, effects, scopes, async resources, and immutable state.",
+      "description": "Framework-agnostic signals, derived values, effects, scopes, watchers, and async resources.",
       "exampleIds": [
         "async-resource",
         "basic-signal",
@@ -1092,6 +1092,8 @@
         "batch",
         "createScope",
         "untrack",
+        "watch",
+        "resource",
         "isReactive"
       ],
       "hasSource": true,
@@ -1103,6 +1105,8 @@
         "graph",
         "scope",
         "batch",
+        "watch",
+        "resource",
         "async"
       ],
       "name": "@vielzeug/ripple",
@@ -1112,7 +1116,7 @@
         "ledger"
       ],
       "slug": "ripple",
-      "version": "2.0.1"
+      "version": "2.1.0"
     },
     {
       "availableDocPages": [
@@ -1266,7 +1270,7 @@
         "ripple"
       ],
       "slug": "scout",
-      "version": "2.1.0"
+      "version": "2.1.1"
     },
     {
       "availableDocPages": [
@@ -1321,7 +1325,7 @@
         "refine"
       ],
       "slug": "scroll",
-      "version": "2.0.0"
+      "version": "2.0.1"
     },
     {
       "availableDocPages": [
@@ -1681,5 +1685,5 @@
       "version": "2.0.0"
     }
   ],
-  "version": "2.1.0"
+  "version": "2.1.3"
 }

package/data/llms-full.txt

@@ -1,6 +1,6 @@
 # Vielzeug — Full Documentation
 
-> Complete documentation for 32 packages. Version: 2.1.0
+> Complete documentation for 32 packages. Version: 2.1.3
 
 ---
 
@@ -14826,7 +14826,6 @@ ripple.dispose();
 - `createScope()` groups owned reactive work.
 - `watch()` observes one selected source transition.
 - `resource()` loads async values with stale-work cancellation.
-- `createStore()` wraps explicit value replacement and updater functions.
 
 ## Documentation
 
@@ -14856,17 +14855,13 @@ ripple.dispose();
 | `untrack()` | Read without tracking | Sync | Read still happens immediately |
 | `watch()` | Observe selected output | Sync | Use `effect()` for broad reads |
 | `resource()` | Load async source | Async | Read dependencies in source callback |
-| `createStore()` | Hold replacement-based state | Sync | Return replacement objects from updates |
 | `isReactive()` | Test `Readable` identity | Sync | Does not test arbitrary objects |
 
 ## Package Entry Point
 
 | Import | Purpose |
 | --- | --- |
-| `@vielzeug/ripple` | Default graph APIs, isolated graph factory, types, and errors |
-| `@vielzeug/ripple/watch` | `watch()` and `WatchOptions` |
-| `@vielzeug/ripple/async` | `resource()`, `Resource`, `AsyncState`, `ResourceOptions` |
-| `@vielzeug/ripple/store` | `createStore()`, `Store`, `StoreOptions` |
+| `@vielzeug/ripple` | All primitives, types, and errors — signals, computed, effects, scopes, watch, resource, and the isolated graph factory |
 
 ## Graph Creation
 
@@ -14926,7 +14921,7 @@ console.log(isReactive(signal(0)));
 function signal(initial: T, options?: SignalOptions): Signal;
 ```
 
-Creates writable state on the default graph.
+Creates writable state on the default graph. Use `update()` for immutable replacement patterns.
 
 **Returns:** `Signal`.
 
@@ -14937,6 +14932,9 @@ import { signal } from '@vielzeug/ripple';
 
 const count = signal(0);
 count.value += 1;
+
+const cart = signal({ items: 0 });
+cart.update((state) => ({ ...state, items: state.items + 1 }));
 ```
 
 ---
@@ -14966,7 +14964,7 @@ console.log(doubled.value);
 ### `effect(callback, options?)`
 
 ```ts
-function effect(callback: () => Cleanup | void, options?: EffectOptions): EffectHandle;
+function effect(callback: () => Cleanup | undefined, options?: EffectOptions): EffectHandle;
 ```
 
 Runs immediately and reruns when its tracked reads change. A returned cleanup runs before the next callback or disposal.
@@ -15042,7 +15040,7 @@ scope.run(() => effect(() => console.log(count.value)));
 scope.dispose();
 ```
 
-## Watch, Resources, and Stores
+## Watch and Resources
 
 ### `watch(source, callback, options?)`
 
@@ -15061,8 +15059,7 @@ Observes selected output changes using the default graph or a `Ripple.watch()` m
 **Example:**
 
 ```ts
-import { signal } from '@vielzeug/ripple';
-import { watch } from '@vielzeug/ripple/watch';
+import { signal, watch } from '@vielzeug/ripple';
 
 const count = signal(0);
 const stop = watch(count, (value, previous) => console.log(previous, value), { immediate: true });
@@ -15088,8 +15085,7 @@ Tracks `source`, aborts stale loader work, and exposes `AsyncState`. Source and
 **Example:**
 
 ```ts
-import { signal } from '@vielzeug/ripple';
-import { resource } from '@vielzeug/ripple/async';
+import { resource, signal } from '@vielzeug/ripple';
 
 const userId = signal('42');
 const user = resource(() => userId.value, async (id) => ({ id }));
@@ -15098,27 +15094,6 @@ if (user.value.status === 'error') console.error(user.value.error);
 user.dispose();
 ```
 
----
-
-### `createStore(initial, options?)`
-
-```ts
-function createStore(initial: T, options?: StoreOptions): Store;
-```
-
-Creates one writable value wrapper with explicit `set()` and `update()` operations.
-
-**Returns:** `Store`.
-
-**Example:**
-
-```ts
-import { createStore } from '@vielzeug/ripple/store';
-
-const user = createStore({ name: 'Ada', visits: 0 });
-user.update((value) => ({ ...value, visits: value.visits + 1 }));
-```
-
 ## Types
 
 ```ts
@@ -15131,7 +15106,6 @@ type ComputedOptions = { equals?: Equality; name?: string };
 type EffectOptions = { name?: string; scheduler?: 'microtask' | 'sync' };
 type WatchOptions = { equals?: Equality; immediate?: boolean; name?: string; once?: boolean };
 type ResourceOptions = { name?: string };
-type StoreOptions = { name?: string };
 
 type ReactiveEvent =
   | { readonly kind: 'compute'; readonly name?: string }
@@ -15155,19 +15129,17 @@ interface Readable {
   readonly value: T;
 }
 
-interface Signal extends Readable { value: T }
+interface Signal extends Readable { update(updater: (prev: T) => T): void; value: T }
 interface Disposable { dispose(): void; readonly disposed: boolean; readonly disposalSignal: AbortSignal; [Symbol.dispose](): void }
 type EffectHandle = Disposable;
 interface Scope extends Disposable { run(fn: () => T): T }
 
 interface Resource extends Readable>, Disposable { reload(): void }
-interface Store extends Readable { set(value: T): void; update(updater: (value: T) => T): void }
 
 interface Ripple {
   batch(fn: () => T): T;
   computed(derive: () => T, options?: ComputedOptions): Readable;
   createScope(name?: string): Scope;
-  createStore(initial: T, options?: StoreOptions): Store;
   dispose(): void;
   readonly disposed: boolean;
   effect(callback: () => Cleanup | void, options?: EffectOptions): EffectHandle;
@@ -15298,14 +15270,14 @@ user.dispose();
 
 ## Object State
 
-`createStore()` holds one value and exposes `set()` and `update()`. Return replacement objects from `update()` when object consumers depend on immutable updates.
+`signal()` with `update()` holds one value and supports immutable replacement patterns. Return replacement objects from `update()` when object consumers depend on immutable updates.
 
 ```ts
-const cart = ripple.createStore({ items: 0, label: 'empty' });
+const cart = ripple.signal({ items: 0, label: 'empty' });
 const items = ripple.computed(() => cart.value.items);
 
 cart.update((state) => ({ ...state, items: state.items + 1 }));
-cart.set({ items: 3, label: 'ready' });
+cart.value = { items: 3, label: 'ready' };
 
 console.log(items.value);
 ```
@@ -15431,7 +15403,7 @@ ripple.dispose();
 - [Batch and Untrack](./examples/batch-and-untrack.md)
 - [Scope Ownership](./examples/scope-ownership.md)
 - [Watch Selected Value](./examples/watch-selected-value.md)
-- [Replacement-Based Store](./examples/immutable-store.md)
+- [Immutable State](./examples/immutable-store.md)
 - [Isolated Graph](./examples/isolated-runtime.md)
 - [Async Resource](./examples/async-resource.md)
 
@@ -15442,7 +15414,7 @@ ripple.dispose();
 - Batch & Untrack (id: `batch-untrack`)
 - Microtask Effect (id: `effect-options`)
 - Nested Effect Ownership (id: `scope-ownership`)
-- Immutable Store (id: `store-basics`)
+- Immutable State (id: `store-basics`)
 - Watch Selected Value (id: `watch-selected-value`)
 
 ---

package/data/llms.txt

@@ -1,6 +1,6 @@
 # Vielzeug
 
-> 32 focused TypeScript packages. Version: 2.1.0
+> 32 focused TypeScript packages. Version: 2.1.3
 
 Install any package independently: `pnpm add @vielzeug/<name>`
 
@@ -27,7 +27,7 @@ Install any package independently: `pnpm add @vielzeug/<name>`
 - [@vielzeug/prism](/prism/): Reactive SVG charting library — line, bar, and area charts. Signal-driven updates, CSS-themeable, accessible.
 - [@vielzeug/pulse](/pulse/): Explicitly connected, typed WebSocket sessions with scoped channels, presence, reconnect restoration, and heartbeat.
 - [@vielzeug/refine](/refine/): Accessible, themeable web components built with Ore for framework and vanilla DOM apps.
-- [@vielzeug/ripple](/ripple/): Framework-agnostic signals, derived values, effects, scopes, async resources, and immutable state.
+- [@vielzeug/ripple](/ripple/): Framework-agnostic signals, derived values, effects, scopes, watchers, and async resources.
 - [@vielzeug/rune](/rune/): Browser/Node logger with levels, namespaces, pluggable transports, lazy bindings, and timing helpers.
 - [@vielzeug/sandbox](/sandbox/): Isolated iframe runtime with a typed postMessage bridge for safe execution of untrusted HTML — component previews, playgrounds, plugin sandboxes, and more.
 - [@vielzeug/scout](/scout/): Trigram-indexed fuzzy search with per-field weights, match highlighting, and an optional reactive layer.

package/data/manifest.json

@@ -4,5 +4,5 @@
   "refine": "refine.json",
   "schemaVersion": 1,
   "search": "search.json",
-  "version": "2.1.0"
+  "version": "2.1.3"
 }

package/data/packages/arsenal.json

@@ -161,7 +161,7 @@
   "typeSignatures": {
     "ArsenalError": "export class ArsenalError extends Error {\n  constructor(message: string, opts?: ErrorOptions) {\n    super(message, opts);\n    this.name = new.target.name;\n    Object.setPrototypeOf(this, new.target.prototype);\n  }\n\n  static is(err: unknown): err is ArsenalError {\n    return err instanceof ArsenalError;\n  }\n}",
     "ArsenalSerializationError": "export class ArsenalSerializationError extends ArsenalError {}",
-    "chunk": "export function chunk(input: string, size?: number): string[];\n\nexport function chunk<T>(input: T[], size?: number): T[][];\n\nexport function chunk<T>(input: T[] | string, size = 2): string[] | T[][] {\n  if (!Array.isArray(input) && typeof input !== 'string')\n    throw new TypeError('chunk: argument must be an array or string');\n\n  if (!Number.isInteger(size) || size < 1) throw new RangeError('chunk: size must be a positive integer');\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) => input.slice(i * size, i * size + size)) as\n    string[] | T[][];\n}",
+    "chunk": "export function chunk(input: string, size?: number): string[];\n\nexport function chunk<T>(input: T[], size?: number): T[][];\n\nexport function chunk<T>(input: T[] | string, size = 2): string[] | T[][] {\n  if (!Array.isArray(input) && typeof input !== 'string')\n    throw new TypeError('chunk: argument must be an array or string');\n\n  if (!Number.isInteger(size) || size < 1) throw new RangeError('chunk: size must be a positive integer');\n\n  return Array.from({ length: Math.ceil(input.length / size) }, (_, i) => input.slice(i * size, i * size + size)) as\n    | string[]\n    | T[][];\n}",
     "filterMap": "export function filterMap<T, R>(array: T[], callback: (item: T, index: number, array: T[]) => R | undefined): R[] {\n  const result: R[] = [];\n\n  for (let index = 0; index < array.length; index++) {\n    const value = callback(array[index], index, array);\n\n    if (value !== undefined) {\n      result.push(value);\n    }\n  }\n\n  return result;\n}",
     "groupBy": "export function groupBy<T>(array: T[], selector: (item: T) => Primitive): Record<string, T[]> {\n  const result: Record<string, T[]> = {};\n\n  for (const item of array) {\n    const rawKey = selector(item);\n    const key = rawKey === undefined || rawKey === null ? '_' : String(rawKey);\n\n    if (isUnsafeKey(key)) continue;\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}",
     "indexBy": "export function indexBy<T>(array: T[], selector: (item: T) => Primitive): Record<string, T> {\n  const result: Record<string, T> = {};\n\n  for (const item of array) {\n    const key = String(selector(item));\n\n    if (isUnsafeKey(key)) continue;\n\n    result[key] = item;\n  }\n\n  return result;\n}",

package/data/packages/assay.json

@@ -1,5 +1,5 @@
 {
-  "apiSource": "export { AssayError, AssayQueryError, AssayTimeoutError } from './errors';\n\nexport {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';\nexport { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';\nexport {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';\n",
+  "apiSource": "export { AssayError, AssayQueryError, AssayTimeoutError } from './errors';\n\nexport {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';\nexport { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';\nexport {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';\n",
   "docs": {
     "index": "---\ntitle: Assay — Framework-agnostic DOM testing primitives\ndescription: Scoped DOM queries, exact event dispatch, and cancellable async waiting for browser tests.\npackage: assay\ncategory: testing\nkeywords: [testing, dom, events, queries, custom-elements]\nrelated: [ore, refine]\nexports:\n  [\n    within,\n    queryInShadow,\n    queryAllInShadow,\n    queryPart,\n    getSlotted,\n    dispatch,\n    fireBlur,\n    fireChange,\n    fireClick,\n    fireCustom,\n    fireFocus,\n    fireInput,\n    fireKeyDown,\n    fireKeyUp,\n    fireSubmit,\n    waitUntil,\n    retry,\n    waitForEvent,\n    delay,\n    nextTick,\n    AssayError,\n    AssayQueryError,\n    AssayTimeoutError,\n  ]\nenvironments: [browser]\n---\n\n<!-- markdownlint-disable MD025 MD033 MD060 -->\n\n<PackageHero package=\"assay\" />\n\n## Why Assay?\n\nAssay provides focused DOM test primitives that work with vanilla elements, custom elements, and framework-rendered output. It scopes queries, dispatches exact browser event classes, and waits on explicit conditions without imposing a renderer or browser automation stack.\n\n```ts\n// Before\nbutton.dispatchEvent(new MouseEvent('click', { bubbles: true }));\nawait new Promise((resolve) => setTimeout(resolve, 100));\n\n// After\nfireClick(view.get('button.submit'));\nawait waitUntil(() => view.queryByText('Saved') !== null);\n```\n\n| Feature             | Assay                                        | Testing Library DOM                      | Browser automation                       |\n| ------------------- | -------------------------------------------- | ---------------------------------------- | ---------------------------------------- |\n| Bundle size         | <PackageInfo package=\"assay\" type=\"size\" />  | Larger query layer                       | Browser runtime required                 |\n| Zero dependencies   | <ore-icon name=\"check\" size=\"16\"></ore-icon> | <ore-icon name=\"x\" size=\"16\"></ore-icon> | <ore-icon name=\"x\" size=\"16\"></ore-icon> |\n| Scoped DOM queries  | `within()` and shadow helpers                | Renderer-oriented queries                | Manual selectors                         |\n| Deterministic waits | `waitUntil()` and `waitForEvent()`           | Framework-dependent                      | Full browser timing                      |\n\n<div class=\"decision-callout\">\n\n**Use Assay when** a DOM unit test needs readable queries, dispatched events, or a bounded async wait without adopting a rendering framework.\n\n**Consider browser integration tests when** correctness depends on browser default actions, focus behavior, pointer capture, layout, or accessibility-tree behavior.\n\n</div>\n\n## Installation\n\n::: code-group\n\n```sh [pnpm]\npnpm add -D @vielzeug/assay\n```\n\n```sh [npm]\nnpm install -D @vielzeug/assay\n```\n\n```sh [yarn]\nyarn add -D @vielzeug/assay\n```\n\n:::\n\n## Quick Start\n\nScope a test fixture, dispatch an event, and wait for resulting DOM state.\n\n```ts\nimport { fireClick, waitUntil, within } from '@vielzeug/assay';\n\nconst panel = document.createElement('section');\npanel.innerHTML = '<button>Save</button><output></output>';\npanel.querySelector('button')!.addEventListener('click', () => {\n  panel.querySelector('output')!.textContent = 'Saved';\n});\n\nconst view = within(panel);\nfireClick(view.get('button'));\nawait waitUntil(() => view.queryByText('Saved') !== null);\n```\n\n## Features\n\n<div class=\"features-grid\">\n\n- `within(root)` scopes nullable and required DOM queries.\n- `queryInShadow`, `queryPart`, and `getSlotted` cross custom-element boundaries explicitly.\n- `fireClick`, `fireInput`, `fireKeyDown`, and peers dispatch exact synchronous events.\n- `waitUntil`, `retry`, and `waitForEvent` provide bounded, abortable async waiting.\n- `delay` and `nextTick` model explicit timer and microtask scheduling.\n- `AssayError`, `AssayQueryError`, and `AssayTimeoutError` provide typed failures.\n\n</div>\n\n## Documentation\n\n<div class=\"doc-links\">\n\n- [Usage Guide](./usage.md)\n- [API Reference](./api.md)\n- [Examples](./examples.md)\n- [Migration Guide](./migration.md)\n\n</div>\n\n## See Also\n\n<div class=\"see-also\">\n\n- [Ore](/ore/) — component authoring and test fixtures that pair with Assay DOM helpers.\n- [Refine](/refine/) — accessible components with component-specific test assertions.\n\n</div>\n\n<!-- markdownlint-enable MD025 MD033 MD060 -->\n",
     "api": "---\ntitle: Assay — API Reference\ndescription: API reference for @vielzeug/assay queries, event dispatch, and async waiting.\n---\n\n[[toc]]\n\n## API Overview\n\n| Symbol                                       | Purpose                                     | Execution mode | Common gotcha                                    |\n| -------------------------------------------- | ------------------------------------------- | -------------- | ------------------------------------------------ |\n| `within`                                     | Creates scoped query API                    | Sync           | Required `get*` methods throw `AssayQueryError`  |\n| `queryInShadow` / `queryPart` / `getSlotted` | Crosses custom-element boundaries           | Sync           | Open shadow roots are required                   |\n| `fire*` / `dispatch`                         | Dispatches platform event instances         | Sync           | Does not reproduce browser default behavior      |\n| `waitUntil` / `retry` / `waitForEvent`       | Waits for conditions, assertions, or events | Async          | Use a signal or timeout for bounded waits        |\n| `delay` / `nextTick`                         | Schedules timers or microtasks              | Async          | Prefer `nextTick()` for microtask-scheduled work |\n\n## Package Entry Point\n\n| Import            | Purpose                                              |\n| ----------------- | ---------------------------------------------------- |\n| `@vielzeug/assay` | DOM queries, events, wait helpers, errors, and types |\n\n## Queries\n\n### `within(root)`\n\nCreates a `QueryScope` for an `Element`, `ShadowRoot`, `Document`, or `DocumentFragment`.\n\n| Method                            | Returns           | Use                                          |\n| --------------------------------- | ----------------- | -------------------------------------------- |\n| `get(selector)`                   | `Element`         | Required CSS match; throws `AssayQueryError` |\n| `query(selector)`                 | `Element \\| null` | Optional CSS match                           |\n| `queryAll(selector)`              | `Element[]`       | All CSS matches                              |\n| `getByText(text, selector?)`      | `Element`         | Required exact trimmed-text match            |\n| `queryByText(text, selector?)`    | `Element \\| null` | Optional exact trimmed-text match            |\n| `queryAllByText(text, selector?)` | `Element[]`       | All exact trimmed-text matches               |\n| `getByTestId(id)`                 | `Element`         | Required `data-testid` match                 |\n| `queryByTestId(id)`               | `Element \\| null` | Optional `data-testid` match                 |\n| `queryAllByTestId(id)`            | `Element[]`       | All `data-testid` matches                    |\n\nText selectors default to `'*'`. Required-query failures include the lookup and a bounded view of the scoped DOM.\n\n### Shadow and slot helpers\n\n| Function                           | Returns           | Description                                          |\n| ---------------------------------- | ----------------- | ---------------------------------------------------- |\n| `queryInShadow(host, selector)`    | `Element \\| null` | First match in an open shadow root                   |\n| `queryAllInShadow(host, selector)` | `Element[]`       | All matches in an open shadow root                   |\n| `queryPart(host, part)`            | `Element \\| null` | First shadow element whose `part` token matches      |\n| `getSlotted(host, slotName?)`      | `Element[]`       | Direct light-DOM children in a named or default slot |\n\nThese helpers return `null` or `[]` when there is no shadow root. Dynamic test IDs, parts, and slot names are matched\nas attribute values rather than interpolated into CSS selectors.\n\n## Event dispatch\n\nAll event helpers synchronously return `dispatchEvent()`'s boolean result.\n\n```ts\nimport {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from '@vielzeug/assay';\n\nfireClick(button, { clientX: 20 });\nfireInput(input);\nfireKeyDown(input, { key: 'Enter' });\nfireCustom(element, { detail: { id: '42' }, type: 'item-added' });\ndispatch(element, new Event('ready'));\n```\n\n| Function                    | Event class     | Defaults                                               |\n| --------------------------- | --------------- | ------------------------------------------------------ |\n| `fireBlur` / `fireFocus`    | `FocusEvent`    | Platform defaults (`bubbles: false`)                   |\n| `fireChange`                | `Event`         | `bubbles: true`                                        |\n| `fireInput`                 | `InputEvent`    | `bubbles: true`                                        |\n| `fireClick`                 | `MouseEvent`    | `bubbles: true`, `cancelable: true`                    |\n| `fireKeyDown` / `fireKeyUp` | `KeyboardEvent` | `bubbles: true`, `cancelable: true`                    |\n| `fireSubmit`                | `SubmitEvent`   | `bubbles: true`, `cancelable: true`                    |\n| `fireCustom`                | `CustomEvent`   | `bubbles: true`, `cancelable: true`, `composed: false` |\n\n`fireCustom(target, { type, ...init })` requires the event type in its options object. Assay intentionally does not\nprovide browser-default or fallback pointer/touch simulation.\n\n## Async waiting\n\n```ts\nawait waitUntil(() => ready, { interval: 20, signal, timeout: 1000 });\nawait retry(() => expect(spy).toHaveBeenCalled(), { signal, timeout: 1000 });\nawait waitForEvent(target, 'ready', { signal, timeout: 1000 });\nawait delay(100, { signal });\nawait nextTick();\n```\n\n| Function                               | Success condition        | Options                                    |\n| -------------------------------------- | ------------------------ | ------------------------------------------ |\n| `waitUntil(predicate, options?)`       | Predicate returns `true` | `timeout`, `interval`, `signal`            |\n| `retry(assertion, options?)`           | Assertion stops throwing | `timeout`, `interval`, `signal`, `message` |\n| `waitForEvent(target, type, options?)` | Target emits `type`      | `timeout`, `signal`                        |\n| `delay(ms?, options?)`                 | Timer elapses            | `signal`                                   |\n| `nextTick()`                           | Next microtask           | none                                       |\n\n`waitUntil`, `retry`, and `waitForEvent` reject with `AssayTimeoutError` when their timeout expires. A supplied abort\nsignal rejects with its reason and removes timers and event listeners.\n\n## Types\n\n```ts\nexport interface QueryScope {\n  get(selector: string): Element;\n  query(selector: string): Element | null;\n  queryAll(selector: string): Element[];\n  getByText(text: string, selector?: string): Element;\n  queryByText(text: string, selector?: string): Element | null;\n  queryAllByText(text: string, selector?: string): Element[];\n  getByTestId(id: string): Element;\n  queryByTestId(id: string): Element | null;\n  queryAllByTestId(id: string): Element[];\n}\n```\n\n`CustomEventOptions`, `DelayOptions`, `RetryOptions`, and `WaitOptions` are exported option types for event and wait helpers.\n\n## Errors\n\n| Error               | Meaning                                |\n| ------------------- | -------------------------------------- |\n| `AssayError`        | Base class for Assay-originated errors |\n| `AssayQueryError`   | A required `get*` query had no match   |\n| `AssayTimeoutError` | A wait operation reached its timeout   |\n\n`AssayError.is(value)` narrows any value to the Assay error hierarchy.\n",
@@ -11,30 +11,30 @@
     "AssayError": "export { AssayError, AssayQueryError, AssayTimeoutError } from './errors';",
     "AssayQueryError": "export { AssayError, AssayQueryError, AssayTimeoutError } from './errors';",
     "AssayTimeoutError": "export { AssayError, AssayQueryError, AssayTimeoutError } from './errors';",
-    "dispatch": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireBlur": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireChange": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireClick": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireCustom": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireFocus": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireInput": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireKeyDown": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireKeyUp": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "fireSubmit": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "CustomEventOptions": "export {\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n  type CustomEventOptions,\n} from './events';",
-    "within": "export { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';",
-    "queryInShadow": "export { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';",
-    "queryAllInShadow": "export { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';",
-    "queryPart": "export { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';",
-    "getSlotted": "export { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';",
-    "QueryScope": "export { within, queryInShadow, queryAllInShadow, queryPart, getSlotted, type QueryScope } from './query';",
-    "delay": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "nextTick": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "retry": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "waitForEvent": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "waitUntil": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "DelayOptions": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "RetryOptions": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';",
-    "WaitOptions": "export {\n  delay,\n  nextTick,\n  retry,\n  waitForEvent,\n  waitUntil,\n  type DelayOptions,\n  type RetryOptions,\n  type WaitOptions,\n} from './wait';"
+    "CustomEventOptions": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "dispatch": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireBlur": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireChange": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireClick": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireCustom": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireFocus": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireInput": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireKeyDown": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireKeyUp": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "fireSubmit": "export {\n  type CustomEventOptions,\n  dispatch,\n  fireBlur,\n  fireChange,\n  fireClick,\n  fireCustom,\n  fireFocus,\n  fireInput,\n  fireKeyDown,\n  fireKeyUp,\n  fireSubmit,\n} from './events';",
+    "getSlotted": "export { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';",
+    "QueryScope": "export { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';",
+    "queryAllInShadow": "export { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';",
+    "queryInShadow": "export { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';",
+    "queryPart": "export { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';",
+    "within": "export { getSlotted, type QueryScope, queryAllInShadow, queryInShadow, queryPart, within } from './query';",
+    "DelayOptions": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "delay": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "nextTick": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "RetryOptions": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "retry": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "WaitOptions": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "waitForEvent": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';",
+    "waitUntil": "export {\n  type DelayOptions,\n  delay,\n  nextTick,\n  type RetryOptions,\n  retry,\n  type WaitOptions,\n  waitForEvent,\n  waitUntil,\n} from './wait';"
   }
 }

package/data/packages/clockwork.json

@@ -1,5 +1,5 @@
 {
-  "apiSource": "export { ClockworkError } from './errors.js';\nexport { defineMachine } from './interpret.js';\nexport type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';\nexport type { ClockworkErrorCode } from './errors.js';\n",
+  "apiSource": "export type { ClockworkErrorCode } from './errors.js';\nexport { ClockworkError } from './errors.js';\nexport { defineMachine } from './interpret.js';\nexport type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';\n",
   "docs": {
     "index": "---\ntitle: Clockwork — Typed finite state machines for TypeScript\ndescription: Framework-neutral typed state machines with pure transitions, actor-owned runtime work, timers, invokes, and explicit effects.\npackage: clockwork\ncategory: state\nkeywords: [state-machine, finite-state, typed, actor, async-tasks]\nrelated: [herald, ripple, ward]\nexports: [defineMachine, ClockworkError, Machine, Actor, MachineConfig, MachineSnapshot, TransitionResult]\nenvironments: [browser, node, ssr, deno]\n---\n\n<!-- markdownlint-disable MD025 MD033 MD060 -->\n\n<PackageHero package=\"clockwork\" />\n\n## Why Clockwork?\n\nApplication workflows often mix state changes with timers, requests, rendering, and cleanup. Clockwork keeps transition logic pure while each disposable actor owns runtime work. You can test state decisions without starting effects or invokes.\n\n```ts\nimport { defineMachine } from '@vielzeug/clockwork';\n\n// Before\nif (status === 'idle') status = 'loading';\nfetchItems().then((items) => {\n  status = 'ready';\n  data = items;\n});\n\n// After\ntype Event = { type: 'FETCH' } | { items: string[]; type: 'DONE' };\nconst machine = defineMachine<{ items: string[] }, Event>()({\n  context: { items: [] },\n  initial: 'idle',\n  states: {\n    idle: { on: { FETCH: { target: 'loading' } } },\n    loading: {\n      invoke: [{\n        src: ({ signal }) => fetch('/api/items', { signal }).then((response) => response.json() as Promise<string[]>),\n        onDone: ({ result }) => ({ items: result, type: 'DONE' }),\n      }],\n      on: { DONE: { reduce: ({ event }) => ({ items: event.items }), target: 'ready' } },\n    },\n    ready: {},\n  },\n});\n```\n\n| Feature | Clockwork | XState | Zustand |\n| --- | --- | --- | --- |\n| Bundle size | <PackageInfo package=\"clockwork\" type=\"size\" /> | Larger actor/statechart runtime | Smaller store runtime |\n| Zero dependencies | <ore-icon name=\"check\" size=\"16\"></ore-icon> | <ore-icon name=\"x\" size=\"16\"></ore-icon> | <ore-icon name=\"check\" size=\"16\"></ore-icon> |\n| Pure transition API | <ore-icon name=\"check\" size=\"16\"></ore-icon> | <ore-icon name=\"triangle-alert\" size=\"16\"></ore-icon> Statechart-focused | <ore-icon name=\"x\" size=\"16\"></ore-icon> |\n| Owned cancellation | <ore-icon name=\"check\" size=\"16\"></ore-icon> Actor disposal | <ore-icon name=\"check\" size=\"16\"></ore-icon> | <ore-icon name=\"x\" size=\"16\"></ore-icon> |\n| Framework coupling | <ore-icon name=\"check\" size=\"16\"></ore-icon> None | <ore-icon name=\"check\" size=\"16\"></ore-icon> None | <ore-icon name=\"check\" size=\"16\"></ore-icon> None |\n\n<div class=\"decision-callout\">\n\n**Use Clockwork when** your feature has explicit workflow states, cancellable work, or effects that must run after a state commit.\n\n**Consider XState when** you need statecharts, visual tooling, or its broader actor ecosystem.\n\n</div>\n\n## Installation\n\n::: code-group\n\n```sh [pnpm]\npnpm add @vielzeug/clockwork\n```\n\n```sh [npm]\nnpm install @vielzeug/clockwork\n```\n\n```sh [yarn]\nyarn add @vielzeug/clockwork\n```\n\n:::\n\n## Quick Start\n\nDefine the context and event union, create an actor, observe its snapshot, then dispose it when its owner ends.\n\n```ts\nimport { defineMachine } from '@vielzeug/clockwork';\n\ntype Event = { type: 'DEC' } | { type: 'INC' };\n\nconst counter = defineMachine<{ count: number }, Event>()({\n  context: { count: 0 },\n  initial: 'idle',\n  states: {\n    idle: {\n      on: {\n        DEC: { reduce: ({ context }) => ({ count: context.count - 1 }), target: 'idle' },\n        INC: { reduce: ({ context }) => ({ count: context.count + 1 }), target: 'idle' },\n      },\n    },\n  },\n});\n\nusing actor = counter.createActor();\nactor.subscribe((snapshot) => console.log(snapshot));\nactor.send({ type: 'INC' });\n// { context: { count: 1 }, state: 'idle' }\n```\n\n## Features\n\n<div class=\"features-grid\">\n\n- **`defineMachine()`** — validates and compiles one flat machine definition.\n- **`machine.transition()`** — evaluates a transition without actor runtime work.\n- **`machine.createActor()`** — creates isolated, disposable runtime ownership.\n- **`reduce`** — returns a replacement context from a transition.\n- **`effects`** — run only after the actor commits and notifies subscribers.\n- **`invoke`** — runs cancellable asynchronous work on state entry.\n- **`after`** — schedules cancellable delayed transitions.\n- **`actor.snapshot`** — exposes the current readonly state/context value.\n\n</div>\n\n## Documentation\n\n<div class=\"doc-links\">\n\n- [Usage Guide](./usage.md)\n- [API Reference](./api.md)\n- [Examples](./examples.md)\n- [Migration Guide](./migration.md)\n\n</div>\n\n## See Also\n\n<div class=\"see-also\">\n\n- [Herald](/herald/) — publish events between independent actors without coupling machine definitions.\n- [Ripple](/ripple/) — bridge actor snapshots into a reactive graph when you need fine-grained rendering.\n- [Ward](/ward/) — call authorization predicates from transition guards.\n\n</div>\n\n<!-- markdownlint-enable MD025 MD033 MD060 -->\n",
     "api": "---\ntitle: Clockwork — API Reference\ndescription: Reference for Clockwork machine definitions, actors, devtools, and types.\n---\n\n[[toc]]\n\n## API Overview\n\n| Symbol | Purpose | Execution mode | Common gotcha |\n| --- | --- | --- | --- |\n| `defineMachine()` | Compile a typed flat machine definition | Sync | Call the generic factory before supplying the definition |\n| `Machine.transition()` | Resolve a pure next snapshot | Sync | Does not run effects, invokes, or timers |\n| `Machine.createActor()` | Create a runtime owner | Sync | Fresh and restored actors have different entry behavior |\n| `Actor.send()` | Dispatch an event | Sync | Returns `void`; re-entrant events queue internally |\n| `debugActor()` | Observe committed snapshots | Sync | Observes only; it does not trace sends or errors |\n| `ClockworkError` | Report definition and snapshot validation failures | Sync | Use `code`, not message text |\n\n## Package Entry Points\n\n| Import | Purpose |\n| --- | --- |\n| `@vielzeug/clockwork` | Machine compiler, actor runtime, errors, and types |\n| `@vielzeug/clockwork/devtools` | Opt-in snapshot observation through `debugActor()` |\n\n## Core Functions\n\n### `defineMachine()`\n\n```ts\nfunction defineMachine<\n  Context extends Record<string, unknown> = Record<string, never>,\n  Event extends MachineEvent = MachineEvent,\n>(): <State extends string>(definition: MachineConfig<State, Context, Event>) => Machine<State, Context, Event>;\n```\n\nReturns a factory that validates and compiles a typed flat machine definition. Context must be a non-array record. Omit `context` only when the context type has no keys.\n\n**Returns:** A definition function that returns `Machine`.\n\n**Example:**\n\n```ts\nimport { defineMachine } from '@vielzeug/clockwork';\n\ntype Event = { type: 'START' };\n\nconst machine = defineMachine<Record<string, never>, Event>()({\n  initial: 'idle',\n  states: { idle: { on: { START: { target: 'running' } } }, running: {} },\n});\n```\n\nThrows `ClockworkError` when a definition has an invalid context, initial state, target, transition, effect, invoke, or timer delay.\n\n---\n\n### `debugActor()`\n\n```ts\nfunction debugActor<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent>(\n  actor: Actor<State, Context, Event>,\n  options?: DebugActorOptions<State, Context>,\n): () => void;\n```\n\nSubscribes to committed actor snapshots and logs each one with `console.debug` by default. It does not modify actor behavior and does not observe dispatched events or runtime errors.\n\n**Returns:** An unsubscribe cleanup function.\n\n**Example:**\n\n```ts\nimport { defineMachine } from '@vielzeug/clockwork';\nimport { debugActor } from '@vielzeug/clockwork/devtools';\n\nconst machine = defineMachine<Record<string, never>, { type: 'NEXT' }>()({\n  initial: 'idle',\n  states: { idle: { on: { NEXT: { target: 'idle' } } } },\n});\n\nconst actor = machine.createActor();\nconst stopDebugging = debugActor(actor);\nactor.send({ type: 'NEXT' });\nstopDebugging();\nactor.dispose();\n```\n\n## Machine Methods\n\n### `machine.transition()`\n\n```ts\ntransition(\n  snapshot: MachineSnapshot<State, Context>,\n  event: Event,\n): TransitionResult<State, Context>;\n```\n\nResolves a snapshot for one user event without actor runtime work.\n\n| Parameter | Type | Description |\n| --- | --- | --- |\n| `snapshot` | `MachineSnapshot<State, Context>` | Input state and context |\n| `event` | `Event` | User event to evaluate |\n\n**Returns:** A `TransitionResult` with `transition` or `ignored` type.\n\n**Example:**\n\n```ts\nconst result = machine.transition(machine.initialSnapshot, { type: 'START' });\n```\n\n---\n\n### `machine.can()`\n\n```ts\ncan(snapshot: MachineSnapshot<State, Context>, event: Event): boolean;\n```\n\nReturns whether a transition exists and its guard passes.\n\n**Returns:** `true` when the supplied snapshot accepts the event.\n\n---\n\n### `machine.createActor()`\n\n```ts\ncreateActor(options?: ActorOptions<State, Context, Event>): Actor<State, Context, Event>;\n```\n\nCreates an independent actor for event dispatch, timers, invokes, effects, subscriptions, and disposal. A fresh actor starts the initial state's entry effects and resources. An actor restored with `options.snapshot` starts only the restored state's resources: invokes and timers, not entry effects.\n\n| Parameter | Type | Description |\n| --- | --- | --- |\n| `options.snapshot` | `MachineSnapshot<State, Context>` | Optional restored actor snapshot |\n| `options.maxTransitions` | `number` | Positive queued-transition limit for one synchronous flush |\n| `options.onError` | `(error, context) => 'continue' \\| 'dispose'` | Explicit disposition for runtime failures |\n\n**Returns:** Disposable `Actor`.\n\n**Example:**\n\n```ts\nconst actor = machine.createActor({\n  onError(error, { phase, state }) {\n    console.error(phase, state, error);\n    return 'continue';\n  },\n  snapshot: { context: {}, state: 'idle' },\n});\n```\n\n## Actor Methods\n\n### `actor.send()`\n\n```ts\nsend(event: Event): void;\n```\n\nDispatches a user event to the current actor state. Events sent while the actor is processing queue and flush synchronously; sends to a disposed actor are ignored. Use `actor.snapshot` after sending to read the current snapshot.\n\n**Returns:** Nothing.\n\n---\n\n### `actor.can()`\n\n```ts\ncan(event: Event): boolean;\n```\n\nReturns whether the current actor snapshot accepts an event. Returns `false` after disposal.\n\n**Returns:** Boolean transition availability.\n\n---\n\n### `actor.subscribe()`\n\n```ts\nsubscribe(listener: (snapshot: MachineSnapshot<State, Context>) => void): () => void;\n```\n\nRegisters a listener for committed snapshots. The listener does not run immediately.\n\n**Returns:** An unsubscribe function.\n\n---\n\n### `actor.dispose()`\n\n```ts\ndispose(): void;\n[Symbol.dispose](): void;\n```\n\nCancels timers and invokes, clears queued events and listeners, and aborts `disposalSignal`.\n\n**Returns:** Nothing. Idempotent.\n\n## Types\n\n### `MachineEvent`\n\n```ts\ntype MachineEvent = { readonly type: string };\n```\n\nBase constraint for event unions.\n\n### `EventType<Event>` and `EventByType<Event, Type>`\n\n```ts\ntype EventType<Event extends MachineEvent> = Event['type'] & string;\n\ntype EventByType<Event extends MachineEvent, Type extends EventType<Event>> =\n  Extract<Event, { type: Type }>;\n```\n\nExtract event type names and a matching event from an event union.\n\n### `MachineSnapshot<State, Context>`\n\n```ts\ntype MachineSnapshot<State extends string, Context extends Record<string, unknown>> = {\n  readonly context: Readonly<Context>;\n  readonly state: State;\n};\n```\n\nThe plain readonly snapshot value used by machines and actors. Readonly is a TypeScript contract; Clockwork does not copy or freeze snapshots at runtime.\n\n### `Guard<Context, Event>` and `Reducer<Context, Event>`\n\n```ts\ntype Guard<Context extends Record<string, unknown>, Event> = (args: {\n  readonly context: Readonly<Context>;\n  readonly event: Event;\n}) => boolean;\n\ntype Reducer<Context extends Record<string, unknown>, Event> = (args: {\n  readonly context: Readonly<Context>;\n  readonly event: Event;\n}) => Context;\n```\n\nA guard selects a transition. A reducer returns replacement context, which must be a non-array record.\n\n### `EffectArgs<Context, Event>` and `Effect<Context, Event>`\n\n```ts\ntype EffectArgs<Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  readonly context: Readonly<Context>;\n  readonly event: Event | undefined;\n  readonly send: (event: Event) => void;\n  readonly signal: AbortSignal;\n};\n\ntype Effect<Context extends Record<string, unknown>, Event extends MachineEvent> =\n  (args: EffectArgs<Context, Event>) => void;\n```\n\nPost-commit effects receive `undefined` for initial entry and actor timer transitions. They cannot update machine context directly.\n\n### `Transition<State, Context, Event, Type>` and `TransitionInput`\n\n```ts\ntype Transition<\n  State extends string,\n  Context extends Record<string, unknown>,\n  Event extends MachineEvent,\n  Type extends EventType<Event> = EventType<Event>,\n> = {\n  readonly effects?: readonly Effect<Context, Event>[];\n  readonly guard?: Guard<Context, EventByType<Event, Type>>;\n  readonly reduce?: Reducer<Context, EventByType<Event, Type>>;\n  readonly target: State;\n};\n\ntype TransitionInput<\n  State extends string,\n  Context extends Record<string, unknown>,\n  Event extends MachineEvent,\n  Type extends EventType<Event> = EventType<Event>,\n> = Transition<State, Context, Event, Type> | readonly Transition<State, Context, Event, Type>[];\n```\n\nAn ordered transition array selects the first guard that passes.\n\n### `After<State, Context, Event>`\n\n```ts\ntype After<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  readonly delay: number;\n  readonly effects?: readonly Effect<Context, Event>[];\n  readonly guard?: Guard<Context, Event | undefined>;\n  readonly reduce?: Reducer<Context, Event | undefined>;\n  readonly target: State;\n};\n```\n\nA delayed state transition. Its guard and reducer receive `event: undefined`.\n\n### `InvokeArgs<Context, Event>` and `Invoke<Context, Event, Result>`\n\n```ts\ntype InvokeArgs<Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  readonly context: Readonly<Context>;\n  readonly event: Event | undefined;\n  readonly signal: AbortSignal;\n};\n\ntype Invoke<Context extends Record<string, unknown>, Event extends MachineEvent, Result = unknown> = {\n  readonly onDone?: (args: { readonly context: Readonly<Context>; readonly result: Result }) => Event;\n  readonly onError?: (args: { readonly context: Readonly<Context>; readonly error: unknown }) => Event;\n  readonly src: (args: InvokeArgs<Context, Event>) => Promise<Result> | Result;\n};\n```\n\nAn actor-owned task started on state entry. `event` is the triggering event or `undefined` for initial or restored resources.\n\n### `StateNode<State, Context, Event>` and `MachineConfig<State, Context, Event>`\n\n```ts\ntype StateNode<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  readonly after?: readonly After<State, Context, Event>[];\n  readonly entry?: readonly Effect<Context, Event>[];\n  readonly exit?: readonly Effect<Context, Event>[];\n  readonly invoke?: readonly Invoke<Context, Event>[];\n  readonly on?: Partial<{ [Type in EventType<Event>]: TransitionInput<State, Context, Event, Type> }>;\n};\n\ntype MachineConfig<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent> =\n  (keyof Context extends never ? { readonly context?: Context } : { readonly context: Context }) & {\n    readonly initial: State;\n    readonly states: Record<State, StateNode<State, Context, Event>>;\n  };\n```\n\nA flat machine definition. State nodes cannot contain child states.\n\n### `TransitionResult<State, Context>`\n\n```ts\ntype TransitionResult<State extends string, Context extends Record<string, unknown>> = {\n  readonly snapshot: MachineSnapshot<State, Context>;\n  readonly type: 'ignored' | 'transition';\n};\n```\n\nResult of a pure user-event transition. It contains no effect plan.\n\n### `ActorErrorContext<State, Event>`, `ActorErrorDisposition`, and `ActorOptions<State, Context, Event>`\n\n```ts\ntype ActorErrorContext<State extends string, Event extends MachineEvent> = {\n  readonly event?: Event;\n  readonly phase: 'effect' | 'invoke' | 'subscriber' | 'transition';\n  readonly state: State;\n};\n\ntype ActorErrorDisposition = 'continue' | 'dispose';\n\ntype ActorOptions<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  readonly maxTransitions?: number;\n  readonly onError?: (error: unknown, context: ActorErrorContext<State, Event>) => ActorErrorDisposition;\n  readonly snapshot?: MachineSnapshot<State, Context>;\n};\n```\n\n`onError` must explicitly return `'continue'` to keep the actor alive or `'dispose'` to end it. Without an error handler, Clockwork disposes the actor silently.\n\n### `Actor<State, Context, Event>`\n\n```ts\ntype Actor<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  [Symbol.dispose](): void;\n  can(event: Event): boolean;\n  readonly disposalSignal: AbortSignal;\n  dispose(): void;\n  readonly disposed: boolean;\n  send(event: Event): void;\n  readonly snapshot: MachineSnapshot<State, Context>;\n  subscribe(listener: (snapshot: MachineSnapshot<State, Context>) => void): () => void;\n};\n```\n\nAn actor's `snapshot` is the current plain readonly snapshot.\n\n### `Machine<State, Context, Event>`\n\n```ts\ntype Machine<State extends string, Context extends Record<string, unknown>, Event extends MachineEvent> = {\n  can(snapshot: MachineSnapshot<State, Context>, event: Event): boolean;\n  createActor(options?: ActorOptions<State, Context, Event>): Actor<State, Context, Event>;\n  readonly initialSnapshot: MachineSnapshot<State, Context>;\n  transition(snapshot: MachineSnapshot<State, Context>, event: Event): TransitionResult<State, Context>;\n};\n```\n\nA compiled, reusable machine. Its transition lookup is map-based, so unknown or poison event names such as `__proto__` are safely ignored when no transition exists.\n\n### `DebugActorOptions<State, Context>`\n\n```ts\ntype DebugActorOptions<State extends string, Context extends Record<string, unknown>> = {\n  readonly logger?: (snapshot: MachineSnapshot<State, Context>) => void;\n};\n```\n\nOptional logger for `debugActor()`. Logger failures are ignored so observation cannot affect the actor's error policy.\n\n## Errors\n\n### `ClockworkError`\n\n`ClockworkError` reports invalid definitions, contexts, snapshots, and actor transition limits. It has `code`, `details`, and standard `Error` fields. Use `ClockworkError.is(error)` to narrow an unknown error.\n\n```ts\nif (ClockworkError.is(error)) {\n  console.error(error.code, error.details);\n}\n```\n",
@@ -39,6 +39,7 @@
     }
   ],
   "typeSignatures": {
+    "ClockworkErrorCode": "export type { ClockworkErrorCode } from './errors.js';",
     "ClockworkError": "export { ClockworkError } from './errors.js';",
     "defineMachine": "export { defineMachine } from './interpret.js';",
     "Actor": "export type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';",
@@ -61,7 +62,6 @@
     "StateNode": "export type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';",
     "Transition": "export type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';",
     "TransitionInput": "export type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';",
-    "TransitionResult": "export type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';",
-    "ClockworkErrorCode": "export type { ClockworkErrorCode } from './errors.js';"
+    "TransitionResult": "export type {\n  Actor,\n  ActorErrorContext,\n  ActorErrorDisposition,\n  ActorOptions,\n  After,\n  Effect,\n  EffectArgs,\n  EventByType,\n  EventType,\n  Guard,\n  Invoke,\n  InvokeArgs,\n  Machine,\n  MachineConfig,\n  MachineEvent,\n  MachineSnapshot,\n  Reducer,\n  StateNode,\n  Transition,\n  TransitionInput,\n  TransitionResult,\n} from './types.js';"
   }
 }