@fragno-dev/test 2.0.0 → 2.0.2

package/src/durable-hooks.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createDurableHooksProcessor } from "@fragno-dev/db/dispatchers/node";
+
+import { drainDurableHooks } from "./durable-hooks";
+
+const drainMock = vi.fn<() => Promise<void>>();
+const wakeMock = vi.fn<() => Promise<void>>();
+
+vi.mock("@fragno-dev/db/dispatchers/node", () => ({
+  createDurableHooksProcessor: vi.fn(() => ({
+    drain: drainMock,
+    wake: wakeMock,
+  })),
+}));
+
+describe("drainDurableHooks", () => {
+  beforeEach(() => {
+    drainMock.mockReset();
+    wakeMock.mockReset();
+    vi.mocked(createDurableHooksProcessor).mockClear();
+  });
+
+  it("no-ops when durable hooks are not configured", async () => {
+    await expect(
+      drainDurableHooks({
+        $internal: {},
+      } as never),
+    ).resolves.toBeUndefined();
+
+    expect(createDurableHooksProcessor).not.toHaveBeenCalled();
+    expect(drainMock).not.toHaveBeenCalled();
+    expect(wakeMock).not.toHaveBeenCalled();
+  });
+
+  it("drains until idle by default", async () => {
+    await drainDurableHooks({
+      $internal: { durableHooksToken: {} },
+    } as never);
+
+    expect(createDurableHooksProcessor).toHaveBeenCalledTimes(1);
+    expect(wakeMock).not.toHaveBeenCalled();
+    expect(drainMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("supports single-pass draining", async () => {
+    await drainDurableHooks(
+      {
+        $internal: { durableHooksToken: {} },
+      } as never,
+      { mode: "singlePass" },
+    );
+
+    expect(createDurableHooksProcessor).toHaveBeenCalledTimes(1);
+    expect(wakeMock).toHaveBeenCalledTimes(1);
+    expect(drainMock).not.toHaveBeenCalled();
+  });
+});

package/src/durable-hooks.ts

@@ -1,13 +1,28 @@
-import {
-  createDurableHooksProcessor,
-  type AnyFragnoInstantiatedDatabaseFragment,
-} from "@fragno-dev/db";
+import { createDurableHooksProcessor } from "@fragno-dev/db/dispatchers/node";
+
 import type { AnyFragnoInstantiatedFragment } from "@fragno-dev/core";
+import { type AnyFragnoInstantiatedDatabaseFragment } from "@fragno-dev/db";
+
+export type DrainDurableHooksMode = "untilIdle" | "singlePass";
+
+export type DrainDurableHooksOptions = {
+  mode?: DrainDurableHooksMode;
+};
 
-export async function drainDurableHooks(fragment: AnyFragnoInstantiatedFragment): Promise<void> {
-  const processor = createDurableHooksProcessor(fragment as AnyFragnoInstantiatedDatabaseFragment);
-  if (!processor) {
+export async function drainDurableHooks(
+  fragment: AnyFragnoInstantiatedFragment,
+  options: DrainDurableHooksOptions = {},
+): Promise<void> {
+  const internal = fragment.$internal as { durableHooksToken?: object } | undefined;
+  if (!internal?.durableHooksToken) {
+    return;
+  }
+  const dispatcher = createDurableHooksProcessor([
+    fragment as AnyFragnoInstantiatedDatabaseFragment,
+  ]);
+  if (options.mode === "singlePass") {
+    await dispatcher.wake();
     return;
   }
-  await processor.drain();
+  await dispatcher.drain();
 }

package/src/index.test.ts

@@ -1,10 +1,14 @@
 import { describe, expect, expectTypeOf, it } from "vitest";
+
+import type { ExtractFragmentServices } from "@fragno-dev/core/route";
 import { column, idColumn, schema } from "@fragno-dev/db/schema";
-import { Cursor, withDatabase } from "@fragno-dev/db";
+
 import { defineFragment } from "@fragno-dev/core";
 import { instantiate } from "@fragno-dev/core";
+import { Cursor, withDatabase } from "@fragno-dev/db";
+
 import { buildDatabaseFragmentsTest } from "./db-test";
-import type { ExtractFragmentServices } from "@fragno-dev/core/route";
+import { drainDurableHooks } from "./durable-hooks";
 
 // Test schema with multiple versions
 const testSchema = schema("test", (s) => {
@@ -25,32 +29,41 @@ const testSchema = schema("test", (s) => {
 // Test fragment definition
 const testFragmentDef = defineFragment<{}>("test-fragment")
   .extend(withDatabase(testSchema))
-  .providesBaseService(({ deps }) => {
-    return {
-      createUser: async (data: { name: string; email: string; age?: number | null }) => {
-        const id = await deps.db.create("users", data);
-        return { ...data, id: id.valueOf() };
+  .providesBaseService(({ defineService }) =>
+    defineService({
+      createUser: function (data: { name: string; email: string; age?: number | null }) {
+        return this.serviceTx(testSchema)
+          .mutate(({ uow }) => uow.create("users", data))
+          .transform(({ mutateResult }) => ({ ...data, id: mutateResult.valueOf() }))
+          .build();
       },
-      getUsers: async () => {
-        const users = await deps.db.find("users", (b) =>
-          b.whereIndex("idx_users_all", (eb) => eb("id", "!=", "")),
-        );
-        return users.map((u) => ({ ...u, id: u.id.valueOf() }));
+      getUsers: function () {
+        return this.serviceTx(testSchema)
+          .retrieve((uow) =>
+            uow.find("users", (b) => b.whereIndex("idx_users_all", (eb) => eb("id", "!=", ""))),
+          )
+          .transformRetrieve(([users]) => users.map((u) => ({ ...u, id: u.id.valueOf() })))
+          .build();
       },
-      getUsersWithCursor: async (cursor?: Cursor | string) => {
-        return deps.db.findWithCursor("users", (b) => {
-          let builder = b
-            .whereIndex("idx_users_name")
-            .orderByIndex("idx_users_name", "asc")
-            .pageSize(2);
-          if (cursor) {
-            builder = builder.after(cursor);
-          }
-          return builder;
-        });
+      getUsersWithCursor: function (cursor?: Cursor | string) {
+        return this.serviceTx(testSchema)
+          .retrieve((uow) =>
+            uow.findWithCursor("users", (b) => {
+              let builder = b
+                .whereIndex("idx_users_name")
+                .orderByIndex("idx_users_name", "asc")
+                .pageSize(2);
+              if (cursor) {
+                builder = builder.after(cursor);
+              }
+              return builder;
+            }),
+          )
+          .transformRetrieve(([result]) => result)
+          .build();
       },
-    };
-  })
+    }),
+  )
   .build();
 
 describe("buildDatabaseFragmentsTest", () => {
@@ -63,11 +76,13 @@ describe("buildDatabaseFragmentsTest", () => {
     const fragment = fragments.test;
 
     // Should be able to create and query users
-    const user = await fragment.services.createUser({
-      name: "Test User",
-      email: "test@example.com",
-      age: 25,
-    });
+    const user = await fragment.fragment.callServices(() =>
+      fragment.services.createUser({
+        name: "Test User",
+        email: "test@example.com",
+        age: 25,
+      }),
+    );
 
     expect(user).toMatchObject({
       id: expect.any(String),
@@ -76,13 +91,24 @@ describe("buildDatabaseFragmentsTest", () => {
       age: 25,
     });
 
-    const users = await fragment.services.getUsers();
+    const users = await fragment.fragment.callServices(() => fragment.services.getUsers());
     expect(users).toHaveLength(1);
     expect(users[0]).toMatchObject(user);
 
     await test.cleanup();
   });
 
+  it("should no-op drainDurableHooks when durable hooks are not configured", async () => {
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    await expect(drainDurableHooks(fragments.test.fragment)).resolves.toBeUndefined();
+
+    await test.cleanup();
+  });
+
   it("should throw error for non-database fragment", async () => {
     const nonDbFragmentDef = defineFragment<{}>("non-db-fragment")
       .providesBaseService(() => ({}))
@@ -102,11 +128,13 @@ describe("buildDatabaseFragmentsTest", () => {
       .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
       .build();
 
-    const user = await fragments.test.services.createUser({
-      name: "Memory User",
-      email: "memory@example.com",
-      age: 31,
-    });
+    const user = await fragments.test.fragment.callServices(() =>
+      fragments.test.services.createUser({
+        name: "Memory User",
+        email: "memory@example.com",
+        age: 31,
+      }),
+    );
 
     expect(user).toMatchObject({
       id: expect.any(String),
@@ -115,7 +143,9 @@ describe("buildDatabaseFragmentsTest", () => {
       age: 31,
     });
 
-    const users = await fragments.test.services.getUsers();
+    const users = await fragments.test.fragment.callServices(() =>
+      fragments.test.services.getUsers(),
+    );
     expect(users).toHaveLength(1);
     expect(users[0]).toMatchObject(user);
 
@@ -139,20 +169,26 @@ describe("buildDatabaseFragmentsTest", () => {
     ];
 
     for (const user of users) {
-      await fragment.services.createUser(user);
+      await fragment.fragment.callServices(() => fragment.services.createUser(user));
     }
 
-    const firstPage = await fragment.services.getUsersWithCursor();
+    const firstPage = await fragment.fragment.callServices(() =>
+      fragment.services.getUsersWithCursor(),
+    );
     expect(firstPage.items.map((item) => item.name)).toEqual(["Alice", "Brett"]);
     expect(firstPage.hasNextPage).toBe(true);
     expect(firstPage.cursor).toBeDefined();
 
-    const secondPage = await fragment.services.getUsersWithCursor(firstPage.cursor);
+    const secondPage = await fragment.fragment.callServices(() =>
+      fragment.services.getUsersWithCursor(firstPage.cursor),
+    );
     expect(secondPage.items.map((item) => item.name)).toEqual(["Cora", "Dylan"]);
     expect(secondPage.hasNextPage).toBe(true);
     expect(secondPage.cursor).toBeDefined();
 
-    const thirdPage = await fragment.services.getUsersWithCursor(secondPage.cursor);
+    const thirdPage = await fragment.fragment.callServices(() =>
+      fragment.services.getUsersWithCursor(secondPage.cursor),
+    );
     expect(thirdPage.items.map((item) => item.name)).toEqual(["Emma"]);
     expect(thirdPage.hasNextPage).toBe(false);
     expect(thirdPage.cursor).toBeUndefined();
@@ -169,28 +205,30 @@ describe("buildDatabaseFragmentsTest", () => {
     const fragment = fragments.test;
 
     // Create some users
-    await fragment.services.createUser({
-      name: "User 1",
-      email: "user1@example.com",
-      age: 25,
-    });
+    await fragment.fragment.callServices(() =>
+      fragment.services.createUser({
+        name: "User 1",
+        email: "user1@example.com",
+        age: 25,
+      }),
+    );
 
     // Verify users exist
-    let users = await fragment.services.getUsers();
+    let users = await fragment.fragment.callServices(() => fragment.services.getUsers());
     expect(users).toHaveLength(1);
 
     // Reset the database
     await test.resetDatabase();
 
     // Verify database is empty
-    users = await fragment.services.getUsers();
+    users = await fragment.fragment.callServices(() => fragment.services.getUsers());
     expect(users).toHaveLength(0);
 
     // Cleanup
     await test.cleanup();
   });
 
-  it("should expose db property for direct ORM queries", async () => {
+  it("should allow handlerTx direct ORM queries", async () => {
     const { fragments, test } = await buildDatabaseFragmentsTest()
       .withTestAdapter({ type: "kysely-sqlite" })
       .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
@@ -198,20 +236,34 @@ describe("buildDatabaseFragmentsTest", () => {
 
     const fragment = fragments.test;
 
-    // Test creating a record directly using test.db
-    const userId = await fragment.db.create("users", {
-      name: "Direct DB User",
-      email: "direct@example.com",
-      age: 28,
+    // Test creating a record directly using handlerTx
+    const userId = await fragment.fragment.inContext(async function () {
+      return await this.handlerTx()
+        .mutate(({ forSchema }) =>
+          forSchema(testSchema).create("users", {
+            name: "Direct DB User",
+            email: "direct@example.com",
+            age: 28,
+          }),
+        )
+        .transform(({ mutateResult }) => mutateResult)
+        .execute();
     });
 
     expect(userId).toBeDefined();
     expect(typeof userId.valueOf()).toBe("string");
 
-    // Test finding records using test.db
-    const users = await fragment.db.find("users", (b) =>
-      b.whereIndex("idx_users_all", (eb) => eb("id", "=", userId)),
-    );
+    // Test finding records using handlerTx
+    const users = await fragment.fragment.inContext(async function () {
+      return await this.handlerTx()
+        .retrieve(({ forSchema }) =>
+          forSchema(testSchema).find("users", (b) =>
+            b.whereIndex("idx_users_all", (eb) => eb("id", "=", userId)),
+          ),
+        )
+        .transformRetrieve(([result]) => result)
+        .execute();
+    });
 
     expect(users).toHaveLength(1);
     expect(users[0]).toMatchObject({
@@ -246,20 +298,32 @@ describe("buildDatabaseFragmentsTest", () => {
 
     const authFragmentDef = defineFragment<{}>("auth-test")
       .extend(withDatabase(authSchema))
-      .providesBaseService(({ deps }) => {
-        return {
-          createUser: async (email: string, passwordHash: string) => {
-            const id = await deps.db.create("user", { email, passwordHash });
-            return { id: id.valueOf(), email, passwordHash };
+      .providesBaseService(({ defineService }) =>
+        defineService({
+          createUser: function (email: string, passwordHash: string) {
+            return this.serviceTx(authSchema)
+              .mutate(({ uow }) => uow.create("user", { email, passwordHash }))
+              .transform(({ mutateResult }) => ({
+                id: mutateResult.valueOf(),
+                email,
+                passwordHash,
+              }))
+              .build();
           },
-          createSession: async (userId: string) => {
+          createSession: function (userId: string) {
             const expiresAt = new Date();
             expiresAt.setDate(expiresAt.getDate() + 30);
-            const id = await deps.db.create("session", { userId, expiresAt });
-            return { id: id.valueOf(), userId, expiresAt };
+            return this.serviceTx(authSchema)
+              .mutate(({ uow }) => uow.create("session", { userId, expiresAt }))
+              .transform(({ mutateResult }) => ({
+                id: mutateResult.valueOf(),
+                userId,
+                expiresAt,
+              }))
+              .build();
           },
-        };
-      })
+        }),
+      )
       .build();
 
     const { fragments, test } = await buildDatabaseFragmentsTest()
@@ -270,7 +334,9 @@ describe("buildDatabaseFragmentsTest", () => {
     const fragment = fragments.auth;
 
     // Create a user
-    const user = await fragment.services.createUser("test@test.com", "hashed-password");
+    const user = await fragment.fragment.callServices(() =>
+      fragment.services.createUser("test@test.com", "hashed-password"),
+    );
     expect(user).toMatchObject({
       id: expect.any(String),
       email: "test@test.com",
@@ -278,7 +344,9 @@ describe("buildDatabaseFragmentsTest", () => {
     });
 
     // Create a session for the user
-    const session = await fragment.services.createSession(user.id);
+    const session = await fragment.fragment.callServices(() =>
+      fragment.services.createSession(user.id),
+    );
     expect(session).toMatchObject({
       id: expect.any(String),
       userId: user.id,
@@ -313,38 +381,46 @@ describe("multi-fragment tests", () => {
 
   const userFragmentDef = defineFragment<{}>("user-fragment")
     .extend(withDatabase(userSchema))
-    .providesBaseService(({ deps }) => {
-      return {
-        createUser: async (data: { name: string; email: string }) => {
-          const id = await deps.db.create("user", data);
-          return { ...data, id: id.valueOf() };
+    .providesBaseService(({ defineService }) =>
+      defineService({
+        createUser: function (data: { name: string; email: string }) {
+          return this.serviceTx(userSchema)
+            .mutate(({ uow }) => uow.create("user", data))
+            .transform(({ mutateResult }) => ({ ...data, id: mutateResult.valueOf() }))
+            .build();
         },
-        getUsers: async () => {
-          const users = await deps.db.find("user", (b) =>
-            b.whereIndex("idx_user_all", (eb) => eb("id", "!=", "")),
-          );
-          return users.map((u) => ({ ...u, id: u.id.valueOf() }));
+        getUsers: function () {
+          return this.serviceTx(userSchema)
+            .retrieve((uow) =>
+              uow.find("user", (b) => b.whereIndex("idx_user_all", (eb) => eb("id", "!=", ""))),
+            )
+            .transformRetrieve(([users]) => users.map((u) => ({ ...u, id: u.id.valueOf() })))
+            .build();
         },
-      };
-    })
+      }),
+    )
     .build();
 
   const postFragmentDef = defineFragment<{}>("post-fragment")
     .extend(withDatabase(postSchema))
-    .providesBaseService(({ deps }) => {
-      return {
-        createPost: async (data: { title: string; userId: string }) => {
-          const id = await deps.db.create("post", data);
-          return { ...data, id: id.valueOf() };
+    .providesBaseService(({ defineService }) =>
+      defineService({
+        createPost: function (data: { title: string; userId: string }) {
+          return this.serviceTx(postSchema)
+            .mutate(({ uow }) => uow.create("post", data))
+            .transform(({ mutateResult }) => ({ ...data, id: mutateResult.valueOf() }))
+            .build();
         },
-        getPosts: async () => {
-          const posts = await deps.db.find("post", (b) =>
-            b.whereIndex("idx_post_all", (eb) => eb("id", "!=", "")),
-          );
-          return posts.map((p) => ({ ...p, id: p.id.valueOf() }));
+        getPosts: function () {
+          return this.serviceTx(postSchema)
+            .retrieve((uow) =>
+              uow.find("post", (b) => b.whereIndex("idx_post_all", (eb) => eb("id", "!=", ""))),
+            )
+            .transformRetrieve(([posts]) => posts.map((p) => ({ ...p, id: p.id.valueOf() })))
+            .build();
         },
-      };
-    })
+      }),
+    )
     .build();
 
   const adapters = [
@@ -363,10 +439,12 @@ describe("multi-fragment tests", () => {
         .build();
 
       // Create a user
-      const user = await fragments.user.services.createUser({
-        name: "John Doe",
-        email: "john@example.com",
-      });
+      const user = await fragments.user.fragment.callServices(() =>
+        fragments.user.services.createUser({
+          name: "John Doe",
+          email: "john@example.com",
+        }),
+      );
 
       expect(user).toMatchObject({
         id: expect.any(String),
@@ -375,10 +453,12 @@ describe("multi-fragment tests", () => {
       });
 
       // Create a post with the user's ID
-      const post = await fragments.post.services.createPost({
-        title: "My First Post",
-        userId: user.id,
-      });
+      const post = await fragments.post.fragment.callServices(() =>
+        fragments.post.services.createPost({
+          title: "My First Post",
+          userId: user.id,
+        }),
+      );
 
       expect(post).toMatchObject({
         id: expect.any(String),
@@ -387,10 +467,14 @@ describe("multi-fragment tests", () => {
       });
 
       // Verify data exists
-      const users = await fragments.user.services.getUsers();
+      const users = await fragments.user.fragment.callServices(() =>
+        fragments.user.services.getUsers(),
+      );
       expect(users).toHaveLength(1);
 
-      const posts = await fragments.post.services.getPosts();
+      const posts = await fragments.post.fragment.callServices(() =>
+        fragments.post.services.getPosts(),
+      );
       expect(posts).toHaveLength(1);
       expect(posts[0]!.userId).toBe(user.id);
 

package/src/index.ts

@@ -1,4 +1,8 @@
+import type { SimpleQueryInterface } from "@fragno-dev/db/query";
 import type { AnySchema } from "@fragno-dev/db/schema";
+
+import type { DatabaseAdapter } from "@fragno-dev/db";
+
 import type {
   SupportedAdapter,
   AdapterContext,
@@ -7,8 +11,6 @@ import type {
   DrizzlePgliteAdapter,
   InMemoryAdapterConfig,
 } from "./adapters";
-import type { DatabaseAdapter } from "@fragno-dev/db";
-import type { SimpleQueryInterface } from "@fragno-dev/db/query";
 
 // Re-export utilities from @fragno-dev/core/test
 export {
@@ -29,7 +31,9 @@ export type {
 
 // Re-export new builder-based database test utilities
 export { buildDatabaseFragmentsTest, DatabaseFragmentsTestBuilder } from "./db-test";
+export type { AnyFragmentResult } from "./db-test";
 export { drainDurableHooks } from "./durable-hooks";
+export type { DrainDurableHooksMode, DrainDurableHooksOptions } from "./durable-hooks";
 export {
   runModelChecker,
   defaultStateHasher,

package/src/model-checker-actors.test.ts

@@ -1,8 +1,11 @@
 import { describe, expect, it } from "vitest";
-import { InMemoryAdapter } from "@fragno-dev/db";
+
 import { column, idColumn, schema } from "@fragno-dev/db/schema";
-import { ModelCheckerAdapter } from "./model-checker-adapter";
+
+import { InMemoryAdapter } from "@fragno-dev/db";
+
 import { runModelCheckerWithActors } from "./model-checker-actors";
+import { ModelCheckerAdapter } from "./model-checker-adapter";
 
 const testSchema = schema("test", (s) =>
   s.addTable("items", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),

package/src/model-checker-actors.ts

@@ -1,6 +1,7 @@
-import type { AnySchema } from "@fragno-dev/db/schema";
 import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
 import type { UOWInstrumentationContext } from "@fragno-dev/db/unit-of-work";
+
 import {
   defaultStateHasher,
   type ModelCheckerBounds,

package/src/model-checker-adapter.ts

@@ -1,3 +1,4 @@
+import type { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
 import type {
   DatabaseAdapter,
   DatabaseAdapterMetadata,
@@ -7,15 +8,15 @@ import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
 } from "@fragno-dev/db/adapters";
-import type { AnySchema } from "@fragno-dev/db/schema";
 import type { SimpleQueryInterface } from "@fragno-dev/db/query";
-import type { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+import type { AnySchema } from "@fragno-dev/db/schema";
 import type {
   UOWInstrumentation,
   UOWInstrumentationContext,
   UOWInstrumentationInjection,
   UOWInstrumentationFinalizer,
 } from "@fragno-dev/db/unit-of-work";
+
 import type { ModelCheckerPhase } from "./model-checker";
 
 type SchedulerHook = (ctx: UOWInstrumentationContext, phase: ModelCheckerPhase) => Promise<void>;

package/src/model-checker.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it, vi } from "vitest";
-import { InMemoryAdapter } from "@fragno-dev/db";
+
 import { column, idColumn, schema, type FragnoId } from "@fragno-dev/db/schema";
 import type { UnitOfWorkConfig } from "@fragno-dev/db/unit-of-work";
+
+import { InMemoryAdapter } from "@fragno-dev/db";
+
 import {
   createRawUowTransaction,
   defaultStateHasher,

package/src/model-checker.ts

@@ -1,13 +1,14 @@
-import type { FragnoRuntime } from "@fragno-dev/core";
 import {
   runWithTraceRecorder,
   type FragnoCoreTraceEvent,
 } from "@fragno-dev/core/internal/trace-context";
-import { FragnoId, FragnoReference, type AnySchema } from "@fragno-dev/db/schema";
 import type { SimpleQueryInterface } from "@fragno-dev/db/query";
-import type { TypedUnitOfWork } from "@fragno-dev/db";
+import { FragnoId, FragnoReference, type AnySchema } from "@fragno-dev/db/schema";
 import type { MutationOperation } from "@fragno-dev/db/unit-of-work";
 
+import type { FragnoRuntime } from "@fragno-dev/core";
+import type { TypedUnitOfWork } from "@fragno-dev/db";
+
 export type ModelCheckerMode = "exhaustive" | "bounded-exhaustive" | "random" | "infinite";
 export type ModelCheckerPhase = "retrieve" | "mutate";