@logixjs/test 0.0.1 → 1.0.0

package/dist/index.cjs

@@ -147,6 +147,7 @@ var require_dist = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Act: () => Act_exports,
   Assertions: () => Assertions_exports,
   Execution: () => Execution_exports,
   TestProgram: () => TestProgram_exports,
@@ -163,8 +164,9 @@ __export(TestRuntime_exports, {
 
 // src/internal/runtime/runTest.ts
 var import_effect = require("effect");
+var import_testing = require("effect/testing");
 var runTest = (effect) => {
-  const program = import_effect.Effect.scoped(effect).pipe(import_effect.Effect.provide(import_effect.TestContext.TestContext));
+  const program = import_effect.Effect.scoped(effect).pipe(import_effect.Effect.provide(import_testing.TestClock.layer()));
   return import_effect.Effect.runPromise(program);
 };
 
@@ -176,6 +178,7 @@ __export(TestProgram_exports, {
 
 // src/internal/api/TestProgram.ts
 var import_effect4 = require("effect");
+var import_testing3 = require("effect/testing");
 var Logix = __toESM(require("@logixjs/core"), 1);
 
 // src/internal/api/ExecutionResult.ts
@@ -267,6 +270,7 @@ var assertSignal = (actual, expectedType, expectedPayload) => {
 
 // src/internal/utils/waitUntil.ts
 var import_effect3 = require("effect");
+var import_testing2 = require("effect/testing");
 var waitUntil = (check, options = {}) => import_effect3.Effect.gen(function* () {
   const maxAttempts = options.maxAttempts ?? 20;
   const step = options.step ?? "10 millis";
@@ -277,8 +281,8 @@ var waitUntil = (check, options = {}) => import_effect3.Effect.gen(function* ()
       return result.value;
     }
     lastError = result.cause;
-    yield* import_effect3.TestClock.adjust(step);
-    yield* import_effect3.Effect.yieldNow();
+    yield* import_testing2.TestClock.adjust(step);
+    yield* import_effect3.Effect.yieldNow;
   }
   return yield* import_effect3.Effect.fail(lastError);
 });
@@ -287,7 +291,7 @@ var waitUntil = (check, options = {}) => import_effect3.Effect.gen(function* ()
 var defaultOptions = (options) => {
   const base = options ?? {};
   const userLayer = base.layer ?? import_effect4.Layer.empty;
-  const layer = import_effect4.Layer.mergeAll(import_effect4.TestContext.TestContext, userLayer);
+  const layer = import_effect4.Layer.mergeAll(import_testing3.TestClock.layer(), userLayer);
   return {
     ...base,
     layer,
@@ -319,7 +323,7 @@ var makeTestApi = (ctx, actionsRef) => {
   return {
     ctx,
     dispatch: ctx.module.dispatch,
-    advance: (duration) => import_effect4.TestClock.adjust(duration).pipe(import_effect4.Effect.asVoid),
+    advance: (duration) => import_testing3.TestClock.adjust(duration).pipe(import_effect4.Effect.asVoid),
     assert: {
       state: assertStateEffect,
       signal: assertSignalEffect
@@ -335,7 +339,7 @@ var startTraceCollectors = (ctx, traceRef, actionsRef) => import_effect4.Effect.
       yield* import_effect4.Ref.update(traceRef, import_effect4.Chunk.append(event));
       yield* import_effect4.Ref.update(actionsRef, import_effect4.Chunk.append(action));
     })
-  ).pipe(import_effect4.Effect.forkScoped, import_effect4.Scope.extend(ctx.scope));
+  ).pipe((effect) => import_effect4.Effect.forkIn(effect, ctx.scope), import_effect4.Effect.asVoid);
   yield* import_effect4.Stream.runForEach(
     ctx.module.changes((s) => s),
     (state) => import_effect4.Effect.gen(function* () {
@@ -343,10 +347,14 @@ var startTraceCollectors = (ctx, traceRef, actionsRef) => import_effect4.Effect.
       const event = { _tag: "State", state, timestamp };
       yield* import_effect4.Ref.update(traceRef, import_effect4.Chunk.append(event));
     })
-  ).pipe(import_effect4.Effect.forkScoped, import_effect4.Scope.extend(ctx.scope));
-  yield* import_effect4.TestClock.adjust(1);
-  yield* import_effect4.Effect.yieldNow();
+  ).pipe((effect) => import_effect4.Effect.forkIn(effect, ctx.scope), import_effect4.Effect.asVoid);
+  yield* import_testing3.TestClock.adjust(1);
+  yield* import_effect4.Effect.yieldNow;
 });
+var runInProgramScope = (ctx, effect) => import_effect4.Effect.tryPromise({
+  try: () => ctx.runtime.runPromise(import_effect4.Effect.provideService(effect, import_effect4.Scope.Scope, ctx.scope)),
+  catch: (e) => e
+}).pipe(import_effect4.Effect.orDie);
 var runProgram = (program, body, options) => import_effect4.Effect.gen(function* () {
   const traceRef = yield* import_effect4.Ref.make(import_effect4.Chunk.empty());
   const actionsRef = yield* import_effect4.Ref.make(import_effect4.Chunk.empty());
@@ -367,31 +375,22 @@ var runProgram = (program, body, options) => import_effect4.Effect.gen(function*
     }
   };
   const resolved = defaultOptions(options);
-  const ctx = yield* import_effect4.Effect.locally(Logix.Debug.internal.currentDebugSinks, [debugSink])(
-    Logix.Runtime.openProgram(program, resolved)
+  const ctx = yield* import_effect4.Effect.provideService(
+    Logix.Runtime.openProgram(program, resolved),
+    Logix.Debug.internal.currentDebugSinks,
+    [debugSink]
   );
-  yield* import_effect4.Effect.tryPromise({
-    try: () => ctx.runtime.runPromise(startTraceCollectors(ctx, traceRef, actionsRef)),
-    catch: (e) => e
-  }).pipe(import_effect4.Effect.orDie);
+  yield* runInProgramScope(ctx, startTraceCollectors(ctx, traceRef, actionsRef));
   const api = makeTestApi(ctx, actionsRef);
-  yield* import_effect4.Effect.tryPromise({
-    try: () => ctx.runtime.runPromise(body(api).pipe(import_effect4.Scope.extend(ctx.scope))),
-    catch: (e) => e
-  }).pipe(import_effect4.Effect.orDie);
-  yield* import_effect4.Effect.tryPromise({
-    try: () => ctx.runtime.runPromise(
-      import_effect4.Effect.gen(function* () {
-        yield* import_effect4.TestClock.adjust(1);
-        yield* import_effect4.Effect.yieldNow();
-      })
-    ),
-    catch: (e) => e
-  }).pipe(import_effect4.Effect.orDie);
-  const finalState = yield* import_effect4.Effect.tryPromise({
-    try: () => ctx.runtime.runPromise(ctx.module.getState),
-    catch: (e) => e
-  }).pipe(import_effect4.Effect.orDie);
+  yield* runInProgramScope(ctx, body(api));
+  yield* runInProgramScope(
+    ctx,
+    import_effect4.Effect.gen(function* () {
+      yield* import_testing3.TestClock.adjust(1);
+      yield* import_effect4.Effect.yieldNow;
+    })
+  );
+  const finalState = yield* runInProgramScope(ctx, ctx.module.getState);
   const actionsChunk = yield* import_effect4.Ref.get(actionsRef);
   const traceChunk = yield* import_effect4.Ref.get(traceRef);
   return make(
@@ -3392,8 +3391,63 @@ var itProgramResult = (name, program, body, assert2, options) => {
     assert2(result);
   });
 };
+
+// src/Act.ts
+var Act_exports = {};
+__export(Act_exports, {
+  advanceTicks: () => advanceTicks,
+  flushAllHostScheduler: () => flushAllHostScheduler,
+  makeTestHostScheduler: () => makeTestHostScheduler,
+  testHostSchedulerLayer: () => testHostSchedulerLayer,
+  tickSchedulerTestLayer: () => tickSchedulerTestLayer
+});
+var import_effect5 = require("effect");
+var Logix2 = __toESM(require("@logixjs/core"), 1);
+var makeTestHostScheduler = () => Logix2.InternalContracts.makeDeterministicHostScheduler();
+var testHostSchedulerLayer = (scheduler) => Logix2.InternalContracts.hostSchedulerTestLayer(scheduler);
+var tickSchedulerTestLayer = (config) => Logix2.InternalContracts.tickSchedulerTestLayer(config);
+var flushAllHostScheduler = (scheduler, options) => import_effect5.Effect.gen(function* () {
+  const maxTurns = options?.maxTurns ?? 1e3;
+  const settleYields = options?.settleYields ?? 8;
+  for (let turn = 0; turn < maxTurns; turn += 1) {
+    yield* import_effect5.Effect.sync(() => {
+      scheduler.flushAll({ maxTurns });
+    });
+    yield* import_effect5.Effect.yieldNow;
+    const { microtasks: microtasks2, macrotasks: macrotasks2 } = scheduler.getQueueSize();
+    if (microtasks2 !== 0 || macrotasks2 !== 0) {
+      continue;
+    }
+    for (let i = 0; i < settleYields; i += 1) {
+      yield* import_effect5.Effect.yieldNow;
+    }
+    const after = scheduler.getQueueSize();
+    if (after.microtasks === 0 && after.macrotasks === 0) {
+      return;
+    }
+  }
+  const { microtasks, macrotasks } = scheduler.getQueueSize();
+  throw new Error(
+    `[LogixTest.Act.flushAllHostScheduler] Exceeded maxTurns=${maxTurns} (microtasks=${microtasks}, macrotasks=${macrotasks}).`
+  );
+}).pipe(import_effect5.Effect.asVoid);
+var advanceTicks = (args) => import_effect5.Effect.gen(function* () {
+  const start = args.getTickSeq();
+  const expected = start + Math.max(0, args.n);
+  const maxTurns = args.maxTurns ?? 1e3;
+  for (let turn = 0; turn < maxTurns; turn += 1) {
+    yield* flushAllHostScheduler(args.scheduler, { maxTurns });
+    const current = args.getTickSeq();
+    if (current >= expected) {
+      return;
+    }
+  }
+  const end = args.getTickSeq();
+  throw new Error(`[LogixTest.Act.advanceTicks] Expected >=${args.n} ticks, got ${end - start}.`);
+}).pipe(import_effect5.Effect.asVoid);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Act,
   Assertions,
   Execution,
   TestProgram,

package/dist/index.d.cts

@@ -1,11 +1,13 @@
 export { T as TestRuntime } from './TestRuntime-CyYCUXdT.cjs';
-export { T as TestProgram } from './TestProgram-CPvVAbfI.cjs';
+export { T as TestProgram } from './TestProgram-DHhYdhOm.cjs';
 export { E as Execution } from './Execution-FfEGGSS7.cjs';
-export { A as Assertions } from './Assertions-uDVCBadW.cjs';
-export { V as Vitest } from './Vitest-BiBMIx3C.cjs';
+export { A as Assertions } from './Assertions-CzVzJ0dQ.cjs';
+export { V as Vitest } from './Vitest-2U7CpZsz.cjs';
+export { A as Act } from './Act-65bCRtuC.cjs';
 import 'effect';
-import './TestProgram-BLXiWhJQ.cjs';
+import './TestProgram-BNm-06UK.cjs';
 import '@logixjs/core';
 import '@logixjs/core/Runtime';
 import './ExecutionResult-BRC-Jzsv.cjs';
-import './waitUntil-CjpwZxCu.cjs';
+import 'effect/testing';
+import './waitUntil-CZQDLJ7j.cjs';

package/dist/index.d.ts

@@ -1,11 +1,13 @@
 export { T as TestRuntime } from './TestRuntime-CyYCUXdT.js';
-export { T as TestProgram } from './TestProgram-DJAm0dIS.js';
+export { T as TestProgram } from './TestProgram-zI8wr33R.js';
 export { E as Execution } from './Execution-Cu-n-UYb.js';
-export { A as Assertions } from './Assertions-OpNAhiI_.js';
-export { V as Vitest } from './Vitest-BXBtxem-.js';
+export { A as Assertions } from './Assertions-D2zfasOD.js';
+export { V as Vitest } from './Vitest-Dr3jUgWl.js';
+export { A as Act } from './Act-65bCRtuC.js';
 import 'effect';
-import './TestProgram-X35n_2Js.js';
+import './TestProgram-DolBjSUH.js';
 import '@logixjs/core';
 import '@logixjs/core/Runtime';
 import './ExecutionResult-BRC-Jzsv.js';
-import './waitUntil-CjpwZxCu.js';
+import 'effect/testing';
+import './waitUntil-CZQDLJ7j.js';

package/dist/index.js

@@ -1,24 +1,28 @@
+import {
+  Act_exports
+} from "./chunk-AJNVZ6GR.js";
 import {
   Assertions_exports
-} from "./chunk-WVD5DTP4.js";
+} from "./chunk-CRWKRQEB.js";
 import {
   Execution_exports
 } from "./chunk-J5AZHNSA.js";
 import {
   TestProgram_exports
-} from "./chunk-5XFEOVH5.js";
+} from "./chunk-JX3RZZWB.js";
 import {
   TestRuntime_exports
-} from "./chunk-42QGM623.js";
+} from "./chunk-PPQRMDUV.js";
 import {
   Vitest_exports
-} from "./chunk-TDYES47J.js";
-import "./chunk-CZJ37XWT.js";
-import "./chunk-DU6VSL4D.js";
+} from "./chunk-SP6DKYGN.js";
+import "./chunk-3XOKB7L4.js";
+import "./chunk-5I2BFXGD.js";
 import "./chunk-RG24KSEB.js";
-import "./chunk-DKT5EFOF.js";
+import "./chunk-OO3UZI3U.js";
 import "./chunk-FOYMJMJR.js";
 export {
+  Act_exports as Act,
   Assertions_exports as Assertions,
   Execution_exports as Execution,
   TestProgram_exports as TestProgram,

package/dist/{waitUntil-CjpwZxCu.d.cts → waitUntil-CZQDLJ7j.d.cts}

@@ -1,8 +1,9 @@
-import { Effect, Duration, TestClock } from 'effect';
+import { Effect, Duration } from 'effect';
+import { TestClock } from 'effect/testing';
 
 interface WaitUntilOptions {
     readonly maxAttempts?: number;
-    readonly step?: Duration.DurationInput;
+    readonly step?: Duration.Input;
 }
 /**
  * Repeatedly runs an assertion under TestContext by advancing TestClock and yielding the scheduler,

package/dist/{waitUntil-CjpwZxCu.d.ts → waitUntil-CZQDLJ7j.d.ts}

@@ -1,8 +1,9 @@
-import { Effect, Duration, TestClock } from 'effect';
+import { Effect, Duration } from 'effect';
+import { TestClock } from 'effect/testing';
 
 interface WaitUntilOptions {
     readonly maxAttempts?: number;
-    readonly step?: Duration.DurationInput;
+    readonly step?: Duration.Input;
 }
 /**
  * Repeatedly runs an assertion under TestContext by advancing TestClock and yielding the scheduler,

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "@logixjs/test",
-  "version": "0.0.1",
+  "version": "1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yoyooyooo/logix",
+    "directory": "packages/logix-test"
+  },
+  "license": "Apache-2.0",
   "description": "Testing utilities for Logix v3",
   "files": [
     "dist/**"
@@ -47,18 +53,18 @@
     "access": "public"
   },
   "dependencies": {
-    "effect": "^3.19.8",
-    "@logixjs/core": "0.0.1"
+    "effect": "4.0.0-beta.28",
+    "@logixjs/core": "1.0.0"
   },
   "devDependencies": {
-    "@effect/vitest": "^0.27.0",
+    "@effect/vitest": "4.0.0-beta.28",
     "tsup": "^8.0.0",
     "typescript": "^5.4.0",
     "vitest": "^4.0.15"
   },
   "peerDependencies": {
-    "effect": "^3.19.8",
-    "@logixjs/core": "0.0.1"
+    "effect": "4.0.0-beta.28",
+    "@logixjs/core": "1.0.0"
   },
   "scripts": {
     "build": "tsup",