createTestRuntime

Stable · since 0.1.0

Constructs a Runtime extended with three test helpers — mockCondition, mockAction, and flushMicrotasks. This is the standard entry point for writing trigger tests without React: every test gets its own runtime, every condition and action is stubbed explicitly, and the microtask queue is drained on demand.

The base runtime accepts the same RuntimeOptions as createRuntime.

Import

import { createTestRuntime } from '@triggery/testing';

Signature

function createTestRuntime(options?: TestRuntimeOptions): TestRuntime;

type TestRuntimeOptions = RuntimeOptions;

type TestRuntime = Runtime & {
  mockCondition<S, K>(
    trigger: Trigger<S>,
    name: K,
    valueOrGetter: ConditionMap<S>[K] | (() => ConditionMap<S>[K]),
  ): RegistrationToken;

  mockAction<S, K>(
    trigger: Trigger<S>,
    name: K,
    handler: ActionFn<ActionMap<S>[K]>,
  ): RegistrationToken;

  flushMicrotasks(): Promise<void>;
};

Parameters

Param	Type	Default	Description
`options`	`RuntimeOptions`	`{}`	Same options as `createRuntime`.

Returns

A TestRuntime — Runtime plus three helpers. See mockCondition, mockAction, flushMicrotasks.

Examples

Basic test

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';
import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime } from '@triggery/testing';
import { describeconst describe: SuiteAPICreates a suite of tests, allowing for grouping and hierarchical organization of tests.
Suites can contain both tests and other suites, enabling complex test structures.
@paramname - The name of the suite, used for identification and reporting.@paramfn - A function that defines the tests and suites within this suite.@example```ts
// Define a suite with two tests
describe('Math operations', () => {
  test('should add two numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  test('should subtract two numbers', () => {
    expect(subtract(5, 2)).toBe(3);
  });
});
```@example```ts
// Define nested suites
describe('String operations', () => {
  describe('Trimming', () => {
    test('should trim whitespace from start and end', () => {
      expect('  hello  '.trim()).toBe('hello');
    });
  });

  describe('Concatenation', () => {
    test('should concatenate two strings', () => {
      expect('hello' + ' ' + 'world').toBe('hello world');
    });
  });
});
```, expectconst expect: ExpectStatic, itconst it: TestAPIDefines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```, viconst vi: VitestUtils } from 'vitest';

describedescribe<object>(name: string | Function, fn?: SuiteFactory<object> | undefined, options?: number): SuiteCollector<object> (+1 overload)Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
Suites can contain both tests and other suites, enabling complex test structures.
@paramname - The name of the suite, used for identification and reporting.@paramfn - A function that defines the tests and suites within this suite.@example```ts
// Define a suite with two tests
describe('Math operations', () => {
  test('should add two numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  test('should subtract two numbers', () => {
    expect(subtract(5, 2)).toBe(3);
  });
});
```@example```ts
// Define nested suites
describe('String operations', () => {
  describe('Trimming', () => {
    test('should trim whitespace from start and end', () => {
      expect('  hello  '.trim()).toBe('hello');
    });
  });

  describe('Concatenation', () => {
    test('should concatenate two strings', () => {
      expect('hello' + ' ' + 'world').toBe('hello world');
    });
  });
});
```('demo trigger', () => {
  itit<object>(name: string | Function, fn?: TestFunction<object> | undefined, options?: number): void (+1 overload)Defines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```('fires the action when the condition matches', () => {
    const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
    const tconst t: Trigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}> = createTriggercreateTrigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>(config: CreateTriggerConfig<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
      eventsevents: {
    tick: number;
}: { ticktick: number: number };
      conditionsconditions: {
    enabled: boolean;
}: { enabledenabled: boolean: boolean };
      actionsactions: {
    log: number;
}: { loglog: number: number };
    }>(
      {
        idid: string: 'demo',
        eventsevents: readonly "tick"[]: ['tick'],
        requiredrequired?: readonly "enabled"[] | undefinedRequired condition keys. The trigger will not run unless all of them are registered.: ['enabled'],
        handlerhandler: TriggerHandler<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}, never>({ eventevent: {
    readonly name: "tick";
    readonly payload: number;
}, conditionsconditions: ConditionsCtx<{
    enabled: boolean;
}, never>, actionsactions: ActionsCtx<{
    log: number;
}> }) {
          if (!conditionsconditions: ConditionsCtx<{
    enabled: boolean;
}, never>.enabledenabled?: boolean | undefined) return;
          actionsactions: ActionsCtx<{
    log: number;
}>.loglog?: ((payload: number) => void) | undefined?.(eventevent: {
    readonly name: "tick";
    readonly payload: number;
}.payloadpayload: number);
        },
      },
      rtconst rt: TestRuntime,
    );

    rtconst rt: TestRuntime.mockConditionmockCondition<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}, "enabled">(trigger: Trigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>, name: "enabled", valueOrGetter: boolean | (() => boolean)): RegistrationTokenRegister a condition for a trigger.

Accepts either a static value or a zero-argument getter. When the
condition's value type is itself a zero-argument function, pass an
explicit getter so the runtime knows which one you mean — otherwise the
heuristic below would call your value as if it were the getter.(tconst t: Trigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>, 'enabled', true);
    const logconst log: Mock<Procedure> = viconst vi: VitestUtils.fnVitestUtils.fn: <Procedure>(originalImplementation?: Procedure | undefined) => Mock<Procedure>Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).

If no function is given, mock will return `undefined`, when invoked.
@example```ts
const getApples = vi.fn(() => 0)

getApples()

expect(getApples).toHaveBeenCalled()
expect(getApples).toHaveReturnedWith(0)

getApples.mockReturnValueOnce(5)

expect(getApples()).toBe(5)
expect(getApples).toHaveNthReturnedWith(2, 5)
```();
    rtconst rt: TestRuntime.mockActionmockAction<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}, "log">(trigger: Trigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>, name: "log", handler: (payload: number) => void): RegistrationTokenRegister an action handler — typically a `vi.fn()`.(tconst t: Trigger<{
    events: {
        tick: number;
    };
    conditions: {
        enabled: boolean;
    };
    actions: {
        log: number;
    };
}>, 'log', logconst log: Mock<Procedure>);

    rtconst rt: TestRuntime.fireSyncfunction fireSync(eventName: string, payload?: unknown): voidRun dispatch synchronously (for tests and benchmarks).('tick', 42);
    expectexpect<Mock<Procedure>>(actual: Mock<Procedure>, message?: string): Assertion<Mock<Procedure>> (+1 overload)(logconst log: Mock<Procedure>).toHaveBeenCalledWithJestAssertion<Mock<Procedure>>.toHaveBeenCalledWith: <[number]>(args_0: number) => voidEnsure that a mock function is called with specific arguments.

Also under the alias `expect.toBeCalledWith`.
@exampleexpect(mockFunc).toHaveBeenCalledWith('arg1', 42);(42);
  });
});

Async dispatch with microtask flush

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';
import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime } from '@triggery/testing';
import { expectconst expect: ExpectStatic, itconst it: TestAPIDefines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```, viconst vi: VitestUtils } from 'vitest';

itit<object>(name: string | Function, fn?: TestFunction<object> | undefined, options?: number): void (+1 overload)Defines a test case with a given name and test function. The test function can optionally be configured with test options.
@paramname - The name of the test or a function that will be used as a test name.@paramoptionsOrFn - Optional. The test options or the test function if no explicit name is provided.@paramoptionsOrTest - Optional. The test function or options, depending on the previous parameters.@throws{Error} If called inside another test function.@example```ts
// Define a simple test
it('adds two numbers', () => {
  expect(add(1, 2)).toBe(3);
});
```@example```ts
// Define a test with options
it('subtracts two numbers', { retry: 3 }, () => {
  expect(subtract(5, 2)).toBe(3);
});
```('drains microtasks before assertion', async () => {
  const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
  const tconst t: Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}> = createTriggercreateTrigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>(config: CreateTriggerConfig<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>, runtime?: Runtime): Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
```<{
    eventsevents: {
    tick: void;
}: { ticktick: void: void };
    actionsactions: {
    log: void;
}: { loglog: void: void };
  }>(
    {
      idid: string: 'demo',
      eventsevents: readonly "tick"[]: ['tick'],
      handlerhandler: TriggerHandler<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}, never>({ actionsactions: ActionsCtx<{
    log: void;
}> }) {
        actionsactions: ActionsCtx<{
    log: void;
}>.loglog?: (() => void) | undefined?.();
      },
    },
    rtconst rt: TestRuntime,
  );

  const logconst log: Mock<Procedure> = viconst vi: VitestUtils.fnVitestUtils.fn: <Procedure>(originalImplementation?: Procedure | undefined) => Mock<Procedure>Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).

If no function is given, mock will return `undefined`, when invoked.
@example```ts
const getApples = vi.fn(() => 0)

getApples()

expect(getApples).toHaveBeenCalled()
expect(getApples).toHaveReturnedWith(0)

getApples.mockReturnValueOnce(5)

expect(getApples()).toBe(5)
expect(getApples).toHaveNthReturnedWith(2, 5)
```();
  rtconst rt: TestRuntime.mockActionmockAction<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}, "log">(trigger: Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>, name: "log", handler: () => void): RegistrationTokenRegister an action handler — typically a `vi.fn()`.(tconst t: Trigger<{
    events: {
        tick: void;
    };
    actions: {
        log: void;
    };
}>, 'log', logconst log: Mock<Procedure>);

  rtconst rt: TestRuntime.firefunction fire(eventName: string, payload?: unknown): voidFire an event asynchronously (through the scheduler).('tick');            // microtask scheduler — handler not yet ran
  await rtconst rt: TestRuntime.flushMicrotasksfunction flushMicrotasks(): Promise<void>Flush pending microtasks. The default scheduler uses `queueMicrotask` —
after `rt.fire(...)` you await `flushMicrotasks()` before asserting.

`fireSync` does not need this: it runs handlers immediately.();
  expectexpect<Mock<Procedure>>(actual: Mock<Procedure>, message?: string): Assertion<Mock<Procedure>> (+1 overload)(logconst log: Mock<Procedure>).toHaveBeenCalledTimesJestAssertion<Mock<Procedure>>.toHaveBeenCalledTimes: (times: number) => voidEnsures that a mock function is called an exact number of times.

Also under the alias `expect.toBeCalledTimes`.
@exampleexpect(mockFunc).toHaveBeenCalledTimes(2);(1);
});

Cleanup between tests

import { createTriggerfunction createTrigger<S extends TriggerSchema>(config: CreateTriggerConfig<S>, runtime?: Runtime): Trigger<S>Create a trigger and register it in a runtime (the default runtime if none is passed).
@example```ts
const messageTrigger = createTrigger<{
  events: { 'new-message': { author: string; text: string } };
  conditions: { user: { id: string }; settings: { sound: boolean } };
  actions: { showToast: { title: string }; playSound: void };
}>({
  id: 'message-received',
  events: ['new-message'],
  required: ['user', 'settings'],
  handler({ event, conditions, actions, check }) {
    if (!conditions.user || !conditions.settings) return; // V1: manual narrowing
    if (check.is('settings', (s) => s.sound)) actions.playSound?.();
    actions.showToast?.({ title: event.payload.author });
  },
});
``` } from '@triggery/core';
import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime, type TestRuntimetype TestRuntime = Runtime & {
    mockCondition<S extends TriggerSchema, K extends ConditionKey<S>>(trigger: Trigger<S>, name: K, valueOrGetter: ConditionMap<S>[K] | (() => ConditionMap<S>[K])): RegistrationToken;
    mockAction<S extends TriggerSchema, K extends ActionKey<S>>(trigger: Trigger<S>, name: K, handler: ActionFn<ActionMap<S>[K]>): RegistrationToken;
    flushMicrotasks(): Promise<void>;
} } from '@triggery/testing';
import { afterEachfunction afterEach<ExtraContext = object>(fn: AfterEachListener<ExtraContext>, timeout?: number): voidRegisters a callback function to be executed after each test within the current suite has completed.
This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.

**Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
@paramfn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.@paramtimeout - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.@returns@example```ts
// Example of using afterEach to delete temporary files created during a test
afterEach(async () => {
  await fileSystem.deleteTempFiles();
});
```, beforeEachfunction beforeEach<ExtraContext = object>(fn: BeforeEachListener<ExtraContext>, timeout?: number): voidRegisters a callback function to be executed before each test within the current suite.
This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.

**Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
@paramfn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.@paramtimeout - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.@returns@example```ts
// Example of using beforeEach to reset a database state
beforeEach(async () => {
  await database.reset();
});
``` } from 'vitest';

let rtlet rt: TestRuntime: TestRuntimetype TestRuntime = Runtime & {
    mockCondition<S extends TriggerSchema, K extends ConditionKey<S>>(trigger: Trigger<S>, name: K, valueOrGetter: ConditionMap<S>[K] | (() => ConditionMap<S>[K])): RegistrationToken;
    mockAction<S extends TriggerSchema, K extends ActionKey<S>>(trigger: Trigger<S>, name: K, handler: ActionFn<ActionMap<S>[K]>): RegistrationToken;
    flushMicrotasks(): Promise<void>;
};

beforeEachbeforeEach<object>(fn: BeforeEachListener<object>, timeout?: number): voidRegisters a callback function to be executed before each test within the current suite.
This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.

**Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
@paramfn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.@paramtimeout - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.@returns@example```ts
// Example of using beforeEach to reset a database state
beforeEach(async () => {
  await database.reset();
});
```(() => {
  rtlet rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime();
});
afterEachafterEach<object>(fn: AfterEachListener<object>, timeout?: number): voidRegisters a callback function to be executed after each test within the current suite has completed.
This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.

**Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
@paramfn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.@paramtimeout - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.@returns@example```ts
// Example of using afterEach to delete temporary files created during a test
afterEach(async () => {
  await fileSystem.deleteTempFiles();
});
```(() => {
  rtlet rt: TestRuntime.disposefunction dispose(): voidTear down the runtime completely.(); // aborts in-flight handlers, drops registrations
});

With middleware

import { createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime } from '@triggery/testing';
import type { Middlewaretype Middleware = {
    readonly name: string;
    onFire?(ctx: FireContext): void | {
        cancel: true;
        reason: string;
    };
    onBeforeMatch?(ctx: MatchContext): void;
    onSkip?(ctx: SkipContext): void;
    onActionStart?(ctx: ActionContext): void;
    onActionEnd?(ctx: ActionContext & {
        durationMs: number;
        result?: unknown;
    }): void;
    onError?(ctx: ActionContext & {
        error: unknown;
    }): void;
    onCascade?(ctx: CascadeContext): void;
} } from '@triggery/core';

const traceconst trace: Middleware: Middlewaretype Middleware = {
    readonly name: string;
    onFire?(ctx: FireContext): void | {
        cancel: true;
        reason: string;
    };
    onBeforeMatch?(ctx: MatchContext): void;
    onSkip?(ctx: SkipContext): void;
    onActionStart?(ctx: ActionContext): void;
    onActionEnd?(ctx: ActionContext & {
        durationMs: number;
        result?: unknown;
    }): void;
    onError?(ctx: ActionContext & {
        error: unknown;
    }): void;
    onCascade?(ctx: CascadeContext): void;
} = {
  namename: string: 'trace',
  onActionEndonActionEnd?(ctx: ActionContext & {
    durationMs: number;
    result?: unknown;
}): void({ actionNameactionName: string, durationMsdurationMs: number }) {
    consolevar console: Console.logConsole.log(...data: any[]): voidThe **`console.log()`** static method outputs a message to the console.

[MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)(actionNameactionName: string, durationMsdurationMs: number);
  },
};

const rtconst rt: TestRuntime = createTestRuntimefunction createTestRuntime(options?: TestRuntimeOptions): TestRuntime({ middlewaremiddleware?: readonly Middleware[] | undefinedGlobal middleware applied to every trigger in this runtime.: [traceconst trace: Middleware] });

Notes

mockCondition Stub a condition for tests.

mockAction Stub an action handler.

flushMicrotasks Drain pending microtasks.

createFakeScheduler Virtual-clock scheduler for debounce / throttle tests.