@logixjs/test 0.0.1

package/dist/Assertions-OpNAhiI_.d.ts

@@ -0,0 +1,16 @@
+import { Effect } from 'effect';
+import * as Logix from '@logixjs/core';
+import { W as WaitUntilOptions, w as waitUntil } from './waitUntil-CjpwZxCu.js';
+
+declare const assertState: <Sh extends Logix.AnyModuleShape>(actual: Logix.StateOf<Sh>, predicate: (s: Logix.StateOf<Sh>) => boolean, message?: string) => Effect.Effect<void, Error>;
+declare const assertSignal: (actual: unknown, expectedType: string, expectedPayload?: unknown) => Effect.Effect<void, Error>;
+
+declare const Assertions_WaitUntilOptions: typeof WaitUntilOptions;
+declare const Assertions_assertSignal: typeof assertSignal;
+declare const Assertions_assertState: typeof assertState;
+declare const Assertions_waitUntil: typeof waitUntil;
+declare namespace Assertions {
+  export { Assertions_WaitUntilOptions as WaitUntilOptions, Assertions_assertSignal as assertSignal, Assertions_assertState as assertState, Assertions_waitUntil as waitUntil };
+}
+
+export { Assertions as A, assertSignal as a, assertState as b };

package/dist/Assertions-uDVCBadW.d.cts

@@ -0,0 +1,16 @@
+import { Effect } from 'effect';
+import * as Logix from '@logixjs/core';
+import { W as WaitUntilOptions, w as waitUntil } from './waitUntil-CjpwZxCu.cjs';
+
+declare const assertState: <Sh extends Logix.AnyModuleShape>(actual: Logix.StateOf<Sh>, predicate: (s: Logix.StateOf<Sh>) => boolean, message?: string) => Effect.Effect<void, Error>;
+declare const assertSignal: (actual: unknown, expectedType: string, expectedPayload?: unknown) => Effect.Effect<void, Error>;
+
+declare const Assertions_WaitUntilOptions: typeof WaitUntilOptions;
+declare const Assertions_assertSignal: typeof assertSignal;
+declare const Assertions_assertState: typeof assertState;
+declare const Assertions_waitUntil: typeof waitUntil;
+declare namespace Assertions {
+  export { Assertions_WaitUntilOptions as WaitUntilOptions, Assertions_assertSignal as assertSignal, Assertions_assertState as assertState, Assertions_waitUntil as waitUntil };
+}
+
+export { Assertions as A, assertSignal as a, assertState as b };

package/dist/Assertions.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Assertions.ts
+var Assertions_exports = {};
+__export(Assertions_exports, {
+  assertSignal: () => assertSignal,
+  assertState: () => assertState,
+  waitUntil: () => waitUntil
+});
+module.exports = __toCommonJS(Assertions_exports);
+
+// src/internal/utils/assertions.ts
+var import_effect = require("effect");
+var assertState = (actual, predicate, message) => {
+  return import_effect.Effect.suspend(() => {
+    if (predicate(actual)) {
+      return import_effect.Effect.void;
+    }
+    return import_effect.Effect.fail(new Error(message || `State assertion failed. Actual: ${JSON.stringify(actual)}`));
+  });
+};
+var assertSignal = (actual, expectedType, expectedPayload) => {
+  return import_effect.Effect.suspend(() => {
+    const candidate = actual;
+    if (candidate && typeof candidate === "object" && typeof candidate._tag === "string" && candidate._tag === expectedType) {
+      if (expectedPayload !== void 0) {
+        if (import_effect.Equal.equals(candidate.payload, expectedPayload)) {
+          return import_effect.Effect.void;
+        }
+        return import_effect.Effect.fail(
+          new Error(
+            `Signal payload mismatch. Expected: ${JSON.stringify(expectedPayload)}, Actual: ${JSON.stringify(
+              candidate.payload
+            )}`
+          )
+        );
+      }
+      return import_effect.Effect.void;
+    }
+    return import_effect.Effect.fail(
+      new Error(`Signal assertion failed. Expected type: ${expectedType}, Actual: ${JSON.stringify(actual)}`)
+    );
+  });
+};
+
+// src/internal/utils/waitUntil.ts
+var import_effect2 = require("effect");
+var waitUntil = (check, options = {}) => import_effect2.Effect.gen(function* () {
+  const maxAttempts = options.maxAttempts ?? 20;
+  const step = options.step ?? "10 millis";
+  let lastError;
+  for (let i = 0; i < maxAttempts; i++) {
+    const result = yield* check.pipe(import_effect2.Effect.exit);
+    if (result._tag === "Success") {
+      return result.value;
+    }
+    lastError = result.cause;
+    yield* import_effect2.TestClock.adjust(step);
+    yield* import_effect2.Effect.yieldNow();
+  }
+  return yield* import_effect2.Effect.fail(lastError);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertSignal,
+  assertState,
+  waitUntil
+});

package/dist/Assertions.d.cts

@@ -0,0 +1,4 @@
+export { a as assertSignal, b as assertState } from './Assertions-uDVCBadW.cjs';
+export { W as WaitUntilOptions, w as waitUntil } from './waitUntil-CjpwZxCu.cjs';
+import 'effect';
+import '@logixjs/core';

package/dist/Assertions.d.ts

@@ -0,0 +1,4 @@
+export { a as assertSignal, b as assertState } from './Assertions-OpNAhiI_.js';
+export { W as WaitUntilOptions, w as waitUntil } from './waitUntil-CjpwZxCu.js';
+import 'effect';
+import '@logixjs/core';

package/dist/Assertions.js

@@ -0,0 +1,12 @@
+import "./chunk-WVD5DTP4.js";
+import {
+  assertSignal,
+  assertState,
+  waitUntil
+} from "./chunk-DU6VSL4D.js";
+import "./chunk-FOYMJMJR.js";
+export {
+  assertSignal,
+  assertState,
+  waitUntil
+};

package/dist/Execution-Cu-n-UYb.d.ts

@@ -0,0 +1,18 @@
+import { E as ExecutionResult, T as TraceEvent, e as expectActionSequence, a as expectActionTag, b as expectNoActionTag, c as expectNoError, g as getActionsByTag, d as getErrors, h as hasAction, f as hasError, m as make } from './ExecutionResult-BRC-Jzsv.js';
+
+declare const Execution_ExecutionResult: typeof ExecutionResult;
+declare const Execution_TraceEvent: typeof TraceEvent;
+declare const Execution_expectActionSequence: typeof expectActionSequence;
+declare const Execution_expectActionTag: typeof expectActionTag;
+declare const Execution_expectNoActionTag: typeof expectNoActionTag;
+declare const Execution_expectNoError: typeof expectNoError;
+declare const Execution_getActionsByTag: typeof getActionsByTag;
+declare const Execution_getErrors: typeof getErrors;
+declare const Execution_hasAction: typeof hasAction;
+declare const Execution_hasError: typeof hasError;
+declare const Execution_make: typeof make;
+declare namespace Execution {
+  export { Execution_ExecutionResult as ExecutionResult, Execution_TraceEvent as TraceEvent, Execution_expectActionSequence as expectActionSequence, Execution_expectActionTag as expectActionTag, Execution_expectNoActionTag as expectNoActionTag, Execution_expectNoError as expectNoError, Execution_getActionsByTag as getActionsByTag, Execution_getErrors as getErrors, Execution_hasAction as hasAction, Execution_hasError as hasError, Execution_make as make };
+}
+
+export { Execution as E };

package/dist/Execution-FfEGGSS7.d.cts

@@ -0,0 +1,18 @@
+import { E as ExecutionResult, T as TraceEvent, e as expectActionSequence, a as expectActionTag, b as expectNoActionTag, c as expectNoError, g as getActionsByTag, d as getErrors, h as hasAction, f as hasError, m as make } from './ExecutionResult-BRC-Jzsv.cjs';
+
+declare const Execution_ExecutionResult: typeof ExecutionResult;
+declare const Execution_TraceEvent: typeof TraceEvent;
+declare const Execution_expectActionSequence: typeof expectActionSequence;
+declare const Execution_expectActionTag: typeof expectActionTag;
+declare const Execution_expectNoActionTag: typeof expectNoActionTag;
+declare const Execution_expectNoError: typeof expectNoError;
+declare const Execution_getActionsByTag: typeof getActionsByTag;
+declare const Execution_getErrors: typeof getErrors;
+declare const Execution_hasAction: typeof hasAction;
+declare const Execution_hasError: typeof hasError;
+declare const Execution_make: typeof make;
+declare namespace Execution {
+  export { Execution_ExecutionResult as ExecutionResult, Execution_TraceEvent as TraceEvent, Execution_expectActionSequence as expectActionSequence, Execution_expectActionTag as expectActionTag, Execution_expectNoActionTag as expectNoActionTag, Execution_expectNoError as expectNoError, Execution_getActionsByTag as getActionsByTag, Execution_getErrors as getErrors, Execution_hasAction as hasAction, Execution_hasError as hasError, Execution_make as make };
+}
+
+export { Execution as E };

package/dist/Execution.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Execution.ts
+var Execution_exports = {};
+__export(Execution_exports, {
+  expectActionSequence: () => expectActionSequence,
+  expectActionTag: () => expectActionTag,
+  expectNoActionTag: () => expectNoActionTag,
+  expectNoError: () => expectNoError,
+  getActionsByTag: () => getActionsByTag,
+  getErrors: () => getErrors,
+  hasAction: () => hasAction,
+  hasError: () => hasError,
+  make: () => make
+});
+module.exports = __toCommonJS(Execution_exports);
+
+// src/internal/api/ExecutionResult.ts
+var make = (state, actions, trace) => ({
+  state,
+  actions,
+  trace
+});
+var hasAction = (result, predicate) => result.actions.some(predicate);
+var getActionsByTag = (result, tag) => result.actions.filter((action) => typeof action._tag === "string" && action._tag === tag);
+var hasError = (result) => result.trace.some((event) => event._tag === "Error");
+var getErrors = (result) => result.trace.filter((event) => event._tag === "Error");
+var actionTagOf = (action) => {
+  const value = action;
+  if (typeof value?._tag === "string") {
+    return value._tag;
+  }
+  if (typeof value?.type === "string") {
+    return value.type;
+  }
+  return void 0;
+};
+var expectActionTag = (result, tag, options = {}) => {
+  const actions = getActionsByTag(result, tag);
+  if (actions.length === 0) {
+    throw new Error(`Expected at least one action with tag "${tag}", but found none.`);
+  }
+  if (options.times !== void 0 && actions.length !== options.times) {
+    throw new Error(`Expected ${options.times} actions with tag "${tag}", but found ${actions.length}.`);
+  }
+};
+var expectNoActionTag = (result, tag) => {
+  const actions = getActionsByTag(result, tag);
+  if (actions.length > 0) {
+    throw new Error(`Expected no actions with tag "${tag}", but found ${actions.length}.`);
+  }
+};
+var expectActionSequence = (result, tags) => {
+  const actualTags = result.actions.map((action) => actionTagOf(action)).filter((tag) => typeof tag === "string");
+  if (actualTags.length !== tags.length) {
+    throw new Error(`Expected action tag sequence [${tags.join(", ")}], but got [${actualTags.join(", ")}].`);
+  }
+  for (let i = 0; i < tags.length; i++) {
+    if (actualTags[i] !== tags[i]) {
+      throw new Error(`Expected action tag sequence [${tags.join(", ")}], but got [${actualTags.join(", ")}].`);
+    }
+  }
+};
+var expectNoError = (result) => {
+  const errors = getErrors(result);
+  if (errors.length > 0) {
+    throw new Error(`Expected no errors, but found ${errors.length}. First error cause: ${String(errors[0]?.cause)}`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expectActionSequence,
+  expectActionTag,
+  expectNoActionTag,
+  expectNoError,
+  getActionsByTag,
+  getErrors,
+  hasAction,
+  hasError,
+  make
+});

package/dist/Execution.d.cts

@@ -0,0 +1,2 @@
+export { E as ExecutionResult, T as TraceEvent, e as expectActionSequence, a as expectActionTag, b as expectNoActionTag, c as expectNoError, g as getActionsByTag, d as getErrors, h as hasAction, f as hasError, m as make } from './ExecutionResult-BRC-Jzsv.cjs';
+import '@logixjs/core';

package/dist/Execution.d.ts

@@ -0,0 +1,2 @@
+export { E as ExecutionResult, T as TraceEvent, e as expectActionSequence, a as expectActionTag, b as expectNoActionTag, c as expectNoError, g as getActionsByTag, d as getErrors, h as hasAction, f as hasError, m as make } from './ExecutionResult-BRC-Jzsv.js';
+import '@logixjs/core';

package/dist/Execution.js

@@ -0,0 +1,24 @@
+import "./chunk-J5AZHNSA.js";
+import {
+  expectActionSequence,
+  expectActionTag,
+  expectNoActionTag,
+  expectNoError,
+  getActionsByTag,
+  getErrors,
+  hasAction,
+  hasError,
+  make
+} from "./chunk-RG24KSEB.js";
+import "./chunk-FOYMJMJR.js";
+export {
+  expectActionSequence,
+  expectActionTag,
+  expectNoActionTag,
+  expectNoError,
+  getActionsByTag,
+  getErrors,
+  hasAction,
+  hasError,
+  make
+};

package/dist/ExecutionResult-BRC-Jzsv.d.cts

@@ -0,0 +1,35 @@
+import * as Logix from '@logixjs/core';
+
+interface ExecutionResult<Sh extends Logix.AnyModuleShape> {
+    readonly trace: ReadonlyArray<TraceEvent<Sh>>;
+    readonly state: Logix.StateOf<Sh>;
+    readonly actions: ReadonlyArray<Logix.ActionOf<Sh>>;
+}
+type TraceEvent<Sh extends Logix.AnyModuleShape> = {
+    _tag: 'Action';
+    action: Logix.ActionOf<Sh>;
+    timestamp: number;
+} | {
+    _tag: 'State';
+    state: Logix.StateOf<Sh>;
+    timestamp: number;
+} | {
+    _tag: 'Error';
+    cause: unknown;
+    timestamp: number;
+};
+declare const make: <Sh extends Logix.AnyModuleShape>(state: Logix.StateOf<Sh>, actions: ReadonlyArray<Logix.ActionOf<Sh>>, trace: ReadonlyArray<TraceEvent<Sh>>) => ExecutionResult<Sh>;
+declare const hasAction: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, predicate: (action: Logix.ActionOf<Sh>) => boolean) => boolean;
+declare const getActionsByTag: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tag: string) => ReadonlyArray<Logix.ActionOf<Sh>>;
+declare const hasError: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>) => boolean;
+declare const getErrors: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>) => ReadonlyArray<Extract<TraceEvent<Sh>, {
+    _tag: "Error";
+}>>;
+declare const expectActionTag: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tag: string, options?: {
+    readonly times?: number;
+}) => void;
+declare const expectNoActionTag: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tag: string) => void;
+declare const expectActionSequence: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tags: ReadonlyArray<string>) => void;
+declare const expectNoError: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>) => void;
+
+export { type ExecutionResult as E, type TraceEvent as T, expectActionTag as a, expectNoActionTag as b, expectNoError as c, getErrors as d, expectActionSequence as e, hasError as f, getActionsByTag as g, hasAction as h, make as m };

package/dist/ExecutionResult-BRC-Jzsv.d.ts

@@ -0,0 +1,35 @@
+import * as Logix from '@logixjs/core';
+
+interface ExecutionResult<Sh extends Logix.AnyModuleShape> {
+    readonly trace: ReadonlyArray<TraceEvent<Sh>>;
+    readonly state: Logix.StateOf<Sh>;
+    readonly actions: ReadonlyArray<Logix.ActionOf<Sh>>;
+}
+type TraceEvent<Sh extends Logix.AnyModuleShape> = {
+    _tag: 'Action';
+    action: Logix.ActionOf<Sh>;
+    timestamp: number;
+} | {
+    _tag: 'State';
+    state: Logix.StateOf<Sh>;
+    timestamp: number;
+} | {
+    _tag: 'Error';
+    cause: unknown;
+    timestamp: number;
+};
+declare const make: <Sh extends Logix.AnyModuleShape>(state: Logix.StateOf<Sh>, actions: ReadonlyArray<Logix.ActionOf<Sh>>, trace: ReadonlyArray<TraceEvent<Sh>>) => ExecutionResult<Sh>;
+declare const hasAction: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, predicate: (action: Logix.ActionOf<Sh>) => boolean) => boolean;
+declare const getActionsByTag: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tag: string) => ReadonlyArray<Logix.ActionOf<Sh>>;
+declare const hasError: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>) => boolean;
+declare const getErrors: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>) => ReadonlyArray<Extract<TraceEvent<Sh>, {
+    _tag: "Error";
+}>>;
+declare const expectActionTag: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tag: string, options?: {
+    readonly times?: number;
+}) => void;
+declare const expectNoActionTag: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tag: string) => void;
+declare const expectActionSequence: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>, tags: ReadonlyArray<string>) => void;
+declare const expectNoError: <Sh extends Logix.AnyModuleShape>(result: ExecutionResult<Sh>) => void;
+
+export { type ExecutionResult as E, type TraceEvent as T, expectActionTag as a, expectNoActionTag as b, expectNoError as c, getErrors as d, expectActionSequence as e, hasError as f, getActionsByTag as g, hasAction as h, make as m };

package/dist/TestProgram-BLXiWhJQ.d.cts

@@ -0,0 +1,31 @@
+import { Effect, Duration, TestClock, Scope } from 'effect';
+import * as Logix from '@logixjs/core';
+import { AnyModuleShape } from '@logixjs/core';
+import { ProgramRunContext, OpenProgramOptions } from '@logixjs/core/Runtime';
+import { E as ExecutionResult } from './ExecutionResult-BRC-Jzsv.cjs';
+import { W as WaitUntilOptions } from './waitUntil-CjpwZxCu.cjs';
+
+interface TestApi<Sh extends Logix.AnyModuleShape> {
+    readonly ctx: ProgramRunContext<Sh>;
+    readonly dispatch: (action: Logix.ActionOf<Sh>) => Effect.Effect<void>;
+    /**
+     * Advances the test clock (must run under TestContext).
+     *
+     * Notes:
+     * - For logic that depends on `Effect.sleep` / `Schedule.addDelay`, you must explicitly advance TestClock
+     *   for time to move forward.
+     * - The runner does not implicitly keep-alive / auto-advance time, keeping time semantics controllable and explainable.
+     */
+    readonly advance: (duration: Duration.DurationInput) => Effect.Effect<void, never, TestClock.TestClock>;
+    readonly assert: {
+        readonly state: (predicate: (s: Logix.StateOf<Sh>) => boolean, options?: WaitUntilOptions) => Effect.Effect<void, Error, TestClock.TestClock>;
+        readonly signal: (expectedType: string, expectedPayload?: unknown, options?: WaitUntilOptions) => Effect.Effect<void, Error, TestClock.TestClock>;
+    };
+}
+
+type TestProgramOptions = Omit<OpenProgramOptions, 'handleSignals'> & {
+    readonly handleSignals?: boolean;
+};
+declare const runProgram: <Sh extends AnyModuleShape>(program: Logix.ModuleImpl<any, Sh, any> | Logix.AnyModule, body: (api: TestApi<Sh>) => Effect.Effect<void, any, any>, options?: TestProgramOptions) => Effect.Effect<ExecutionResult<Sh>, unknown, Scope.Scope>;
+
+export { type TestApi as T, type TestProgramOptions as a, runProgram as r };

package/dist/TestProgram-CPvVAbfI.d.cts

@@ -0,0 +1,10 @@
+import { T as TestApi, a as TestProgramOptions, r as runProgram } from './TestProgram-BLXiWhJQ.cjs';
+
+declare const TestProgram_TestApi: typeof TestApi;
+declare const TestProgram_TestProgramOptions: typeof TestProgramOptions;
+declare const TestProgram_runProgram: typeof runProgram;
+declare namespace TestProgram {
+  export { TestProgram_TestApi as TestApi, TestProgram_TestProgramOptions as TestProgramOptions, TestProgram_runProgram as runProgram };
+}
+
+export { TestProgram as T };

package/dist/TestProgram-DJAm0dIS.d.ts

@@ -0,0 +1,10 @@
+import { T as TestApi, a as TestProgramOptions, r as runProgram } from './TestProgram-X35n_2Js.js';
+
+declare const TestProgram_TestApi: typeof TestApi;
+declare const TestProgram_TestProgramOptions: typeof TestProgramOptions;
+declare const TestProgram_runProgram: typeof runProgram;
+declare namespace TestProgram {
+  export { TestProgram_TestApi as TestApi, TestProgram_TestProgramOptions as TestProgramOptions, TestProgram_runProgram as runProgram };
+}
+
+export { TestProgram as T };

package/dist/TestProgram-X35n_2Js.d.ts

@@ -0,0 +1,31 @@
+import { Effect, Duration, TestClock, Scope } from 'effect';
+import * as Logix from '@logixjs/core';
+import { AnyModuleShape } from '@logixjs/core';
+import { ProgramRunContext, OpenProgramOptions } from '@logixjs/core/Runtime';
+import { E as ExecutionResult } from './ExecutionResult-BRC-Jzsv.js';
+import { W as WaitUntilOptions } from './waitUntil-CjpwZxCu.js';
+
+interface TestApi<Sh extends Logix.AnyModuleShape> {
+    readonly ctx: ProgramRunContext<Sh>;
+    readonly dispatch: (action: Logix.ActionOf<Sh>) => Effect.Effect<void>;
+    /**
+     * Advances the test clock (must run under TestContext).
+     *
+     * Notes:
+     * - For logic that depends on `Effect.sleep` / `Schedule.addDelay`, you must explicitly advance TestClock
+     *   for time to move forward.
+     * - The runner does not implicitly keep-alive / auto-advance time, keeping time semantics controllable and explainable.
+     */
+    readonly advance: (duration: Duration.DurationInput) => Effect.Effect<void, never, TestClock.TestClock>;
+    readonly assert: {
+        readonly state: (predicate: (s: Logix.StateOf<Sh>) => boolean, options?: WaitUntilOptions) => Effect.Effect<void, Error, TestClock.TestClock>;
+        readonly signal: (expectedType: string, expectedPayload?: unknown, options?: WaitUntilOptions) => Effect.Effect<void, Error, TestClock.TestClock>;
+    };
+}
+
+type TestProgramOptions = Omit<OpenProgramOptions, 'handleSignals'> & {
+    readonly handleSignals?: boolean;
+};
+declare const runProgram: <Sh extends AnyModuleShape>(program: Logix.ModuleImpl<any, Sh, any> | Logix.AnyModule, body: (api: TestApi<Sh>) => Effect.Effect<void, any, any>, options?: TestProgramOptions) => Effect.Effect<ExecutionResult<Sh>, unknown, Scope.Scope>;
+
+export { type TestApi as T, type TestProgramOptions as a, runProgram as r };