@akterjs/effect 0.0.0-stage → 0.1.0

package/src/serve/rpc/served-rpc.layer.ts

@@ -0,0 +1,34 @@
+import { Effect } from "effect";
+import type { Scope } from "effect";
+
+import type { ActorHost } from "#src/serve/engine/actor-host.service";
+import { actorRpcHandlers } from "./actor-rpc.handlers.js";
+import type { ActorRpcHandlers, ServedActor } from "./actor-rpc.handlers.js";
+import { computerRpcHandlers } from "./computer/computer-rpc.layer.js";
+import type { ComputerHandlers } from "./computer/computer-rpc.layer.js";
+import { fileRpcHandlers } from "./file/file-rpc.layer.js";
+import type { FileHandlers } from "./file/file-rpc.layer.js";
+
+type Served = Effect.Success<ReturnType<typeof actorRpcHandlers>> & FileHandlers & ComputerHandlers;
+
+function servedHandlers(handlers: Served): ActorRpcHandlers;
+function servedHandlers(handlers: Served): ActorRpcHandlers | Served {
+  return handlers;
+}
+
+/** Every handler of the served actors' RPC groups: calls, reads and subscriptions, file streams and computers. */
+const servedRpcHandlers = (
+  actors: readonly ServedActor[],
+): Effect.Effect<ActorRpcHandlers, never, ActorHost | Scope.Scope> =>
+  Effect.map(
+    Effect.all({
+      calls: actorRpcHandlers(actors),
+      computers: computerRpcHandlers(actors),
+      files: fileRpcHandlers({ actors }),
+    }),
+    ({ calls, computers, files }) => servedHandlers({ ...calls, ...files, ...computers }),
+  );
+
+export { servedRpcHandlers };
+
+export type { ServedActor } from "./actor-rpc.handlers.js";

package/src/serve/store/actor-not-migrated.errors.ts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+
+export class ActorNotMigratedError extends Schema.TaggedError<
+  ActorNotMigratedError,
+  { readonly brand: unique symbol }
+>()("ActorNotMigratedError", {
+  actor: Schema.String,
+  key: Schema.String,
+  message: Schema.String,
+}) {}

package/src/serve/store/store-migrations.layer.ts

@@ -0,0 +1,35 @@
+import { Effect, Layer, Stream } from "effect";
+import type { FileSystem, Path } from "effect";
+
+import { ActorMigrations } from "#src/host/migration/actor-migrations.service";
+import { SqliteDriver } from "#src/host/sqlite/sqlite-driver.service";
+
+import { providedHandlers } from "#src/serve/engine/actor-engine.layer";
+import { ActorLocation } from "#src/serve/engine/actor-location.service";
+import { StoreMigrations } from "./store-migrations.service.js";
+import type { LocalMigration, StoreMigration } from "./store-migrations.service.js";
+
+type StoreMigrationOn = Stream.Stream<
+  Stream.Success<StoreMigration>,
+  Stream.Error<StoreMigration>,
+  FileSystem.FileSystem | Path.Path
+>;
+
+const storeMigrations = (directory: string): Layer.Layer<StoreMigrations, never, FileSystem.FileSystem | Path.Path> =>
+  StoreMigrations.layer.pipe(
+    Layer.provide([
+      providedHandlers,
+      ActorMigrations.layer,
+      ActorLocation.directory(directory),
+      SqliteDriver.layerNode,
+    ]),
+    Layer.fresh,
+  );
+
+const migrateStore = ({ directory, ...options }: LocalMigration): StoreMigrationOn => {
+  const all = Stream.unwrap(StoreMigrations.use((migrations) => Effect.succeed(migrations.migrateAll(options))));
+
+  return Stream.provide(all, storeMigrations(directory));
+};
+
+export { migrateStore };

package/src/serve/store/store-migrations.service.ts

@@ -0,0 +1,76 @@
+import { Context, Effect, Layer, Stream } from "effect";
+
+import { ActorRegistry } from "#src/contract/actor/actor-registry.service";
+import { ActorMigrations } from "#src/host/migration/actor-migrations.service";
+import type { MigrationStep } from "#src/host/migration/actor-migrations.service";
+import { SqliteDriver } from "#src/host/sqlite/sqlite-driver.service";
+
+import { ActorLocation } from "#src/serve/engine/actor-location.service";
+import type { ActorAddress } from "#src/serve/engine/actor-location.service";
+import { ActorNotMigratedError } from "./actor-not-migrated.errors.js";
+import type { StoreUnreadableError } from "./store-unreadable.errors.js";
+
+interface MigrateOptions {
+  readonly dryRun: boolean;
+}
+
+interface LocalMigration extends MigrateOptions {
+  readonly directory: string;
+}
+
+interface MigratedActor extends ActorAddress, MigrationStep {}
+
+type StoreMigration = Stream.Stream<MigratedActor, ActorNotMigratedError | StoreUnreadableError>;
+
+const notMigrated =
+  ({ actor, key }: ActorAddress) =>
+  (failure: { readonly message: string }): ActorNotMigratedError =>
+    ActorNotMigratedError.make({ actor, key, message: failure.message });
+
+export class StoreMigrations extends Context.Service<
+  StoreMigrations,
+  {
+    readonly migrateAll: (options: MigrateOptions) => StoreMigration;
+  }
+>()("@akterjs/effect/serve/store/store-migrations.service/StoreMigrations", {
+  make: Effect.gen(function* makeStoreMigrations() {
+    const driver = yield* SqliteDriver;
+    const location = yield* ActorLocation;
+    const migrations = yield* ActorMigrations;
+    const registry = yield* ActorRegistry;
+
+    const migrateActor = Effect.fn("StoreMigrations.migrateActor")(function* migrateActor(
+      address: ActorAddress,
+      { dryRun }: MigrateOptions,
+    ) {
+      const actor = yield* Effect.mapError(registry.lookup(address.actor), () =>
+        notMigrated(address)({ message: `${address.actor} is not one of the app's actors` }),
+      );
+
+      const { database } = location.locate(address);
+
+      if (dryRun) {
+        const reader = yield* Effect.mapError(driver.openQueryOnly(database), notMigrated(address));
+        const planned = yield* Effect.mapError(migrations.plan({ actor, sql: reader }), notMigrated(address));
+
+        return { ...address, ...planned };
+      }
+
+      const sql = yield* Effect.mapError(driver.open(database), notMigrated(address));
+      const applied = yield* Effect.mapError(migrations.prepare({ actor, sql }), notMigrated(address));
+
+      return { ...address, ...applied };
+    });
+
+    const migrateAll = (options: MigrateOptions): StoreMigration =>
+      Stream.mapEffect(Stream.unwrap(Effect.map(location.list, Stream.fromIterable)), (address) =>
+        Effect.scoped(migrateActor(address, options)),
+      );
+
+    return { migrateAll } as const;
+  }),
+}) {
+  public static readonly layer = Layer.effect(this, this.make);
+}
+
+export type { LocalMigration, MigratedActor, MigrateOptions, StoreMigration };

package/src/serve/store/store-unreadable.errors.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+
+export class StoreUnreadableError extends Schema.TaggedError<StoreUnreadableError, { readonly brand: unique symbol }>()(
+  "StoreUnreadableError",
+  {
+    directory: Schema.String,
+    message: Schema.String,
+  },
+) {}

package/src/serve/verify/verify.layer.ts

@@ -0,0 +1,77 @@
+import { layer as nodeFileSystem } from "@effect/platform-node/NodeFileSystem";
+import { layer as nodePath } from "@effect/platform-node/NodePath";
+import { Context, Effect, Layer, Schema } from "effect";
+
+import { ActorNotRegisteredError } from "#src/contract/actor/actor-not-registered.errors";
+import type { Actor, ActorDefinition } from "#src/contract/actor/actor.contract";
+import { InvalidRequestError } from "#src/contract/client/invalid-request.errors";
+import { CommandReplay } from "#src/host/command/command-replay.service";
+import type { ReplayFailure, ReplayReport } from "#src/host/command/command-replay.service";
+import { SqliteDriver } from "#src/host/sqlite/sqlite-driver.service";
+
+import { ActorLocation } from "#src/serve/engine/actor-location.service";
+import { fileHomes } from "#src/runtime/local-actor-engine.layer";
+
+interface ReplaySource<Name extends string, Definition extends ActorDefinition> {
+  readonly actor: Actor<Name, Definition>;
+  readonly directory: string;
+  readonly key: Definition["key"]["Type"];
+}
+
+type VerifyFailure = ActorNotRegisteredError | InvalidRequestError | ReplayFailure;
+
+const platform = Layer.mergeAll(nodeFileSystem, nodePath);
+
+const verifying = (directory: string): Layer.Layer<ActorLocation | CommandReplay> =>
+  Layer.mergeAll(ActorLocation.directory(directory), CommandReplay.layer).pipe(
+    Layer.provide(fileHomes(directory)),
+    Layer.provide([SqliteDriver.layerNode, platform]),
+  );
+
+const hostedBy = Effect.fnUntraced(function* hostedBy<
+  Provided,
+  Name extends string,
+  Definition extends ActorDefinition,
+>(handlers: Layer.Layer<Provided>, actor: Actor<Name, Definition>) {
+  const provided = yield* Layer.build(handlers);
+
+  return yield* Effect.mapError(Effect.fromOption(Context.getOption(provided, actor.handlers)), () =>
+    ActorNotRegisteredError.make({ actor: actor.name }),
+  );
+});
+
+const encodedKey = <Name extends string, Definition extends ActorDefinition>({
+  actor,
+  key,
+}: ReplaySource<Name, Definition>): Effect.Effect<string, InvalidRequestError> =>
+  Effect.mapError(Schema.encodeEffect(actor.key)(key), (issue) =>
+    InvalidRequestError.make({ actor: actor.name, message: issue.message }),
+  );
+
+const replay = <Provided, Name extends string, Definition extends ActorDefinition>(
+  handlers: Layer.Layer<Provided>,
+  source: ReplaySource<Name, Definition>,
+): Effect.Effect<ReplayReport, VerifyFailure> =>
+  Effect.scoped(
+    Effect.gen(function* replayActor() {
+      const key = yield* encodedKey(source);
+      const actor = yield* hostedBy(handlers, source.actor);
+      const services = yield* Layer.build(verifying(source.directory));
+      const { database } = Context.get(services, ActorLocation).locate({ actor: source.actor.name, key });
+
+      return yield* Context.get(services, CommandReplay).replay({ actor, database, key });
+    }),
+  );
+
+export const Verify = { replay } as const;
+
+export type {
+  JournalPoint,
+  ReplayDifference,
+  ReplayedOutcome,
+  ReplayFailure,
+  ReplayReport,
+  ReplayWindow,
+} from "#src/host/command/command-replay.service";
+
+export type { ReplaySource, VerifyFailure };

package/src/testing/story-driver.service.ts

@@ -0,0 +1,266 @@
+import { Clock, Context, Effect, Layer, Option, Record as Rec, Ref, Schema, String as Str } from "effect";
+import type { Duration, Exit } from "effect";
+import { TestClock } from "effect/testing";
+
+import type { Actor, ActorDefinition, CallersSchemas, KeySchema } from "#src/contract/actor/actor.contract";
+import { Caller } from "#src/contract/caller/caller.schema";
+import type { AnyCommand, AnyQuery, PlainSchema } from "#src/contract/command/command.contract";
+import { exitCodec, jsonCodec } from "#src/contract/json-codec.pure";
+import { ActorHost } from "#src/serve/engine/actor-host.service";
+import type { HostFailure } from "#src/serve/engine/actor-host.service";
+
+type CallerOf<Definition extends ActorDefinition> = {
+  readonly [Kind in keyof Definition["callers"] & string]: {
+    readonly kind: Kind;
+    readonly principal: Definition["callers"][Kind]["Type"];
+  };
+}[keyof Definition["callers"] & string];
+
+interface CallOptions<Definition extends ActorDefinition> {
+  readonly as?: CallerOf<Definition>;
+}
+
+interface CreateOptions<Definition extends ActorDefinition> extends CallOptions<Definition> {
+  readonly input: Definition["create"]["Type"];
+}
+
+type PayloadOf<Declaration extends AnyCommand | AnyQuery> = Declaration["payload"] extends Schema.Void
+  ? []
+  : [payload: Declaration["payload"]["Type"]];
+
+type StoryCall<Declaration extends AnyCommand | AnyQuery> = (
+  ...payload: PayloadOf<Declaration>
+) => Effect.Effect<Declaration["success"]["Type"], Declaration["error"]["Type"] | HostFailure>;
+
+type StoryClient<Definition extends ActorDefinition> = {
+  readonly [Member in keyof Definition["commands"]]: StoryCall<Definition["commands"][Member]>;
+} & {
+  readonly [Member in keyof Definition["queries"]]: StoryCall<Definition["queries"][Member]>;
+};
+
+interface Driver {
+  readonly actor: <Name extends string, Definition extends ActorDefinition>(
+    actor: Actor<Name, Definition>,
+    key: Definition["key"]["Type"],
+    options?: CallOptions<Definition>,
+  ) => Effect.Effect<StoryClient<Definition>>;
+  readonly advance: (duration: Duration.Input) => Effect.Effect<void, HostFailure>;
+  readonly create: <Name extends string, Definition extends ActorDefinition>(
+    actor: Actor<Name, Definition>,
+    key: Definition["key"]["Type"],
+    options: CreateOptions<Definition>,
+  ) => Effect.Effect<void, HostFailure>;
+  readonly directory: string;
+}
+
+interface Value {
+  readonly value: unique symbol;
+}
+
+interface ErasedOptions {
+  readonly as?: Caller;
+}
+
+interface ErasedCreate extends ErasedOptions {
+  readonly input: Value;
+}
+
+interface Addressed<Contracted, Key, Options> {
+  readonly actor: Contracted;
+  readonly key: Key;
+  readonly options?: Options | undefined;
+}
+
+interface Creating<Contracted, Key, Options> extends Addressed<Contracted, Key, Options> {
+  readonly options: Options;
+}
+
+interface Contract {
+  readonly callers: CallersSchemas;
+  readonly commands: Readonly<Record<string, AnyCommand>>;
+  readonly create: PlainSchema;
+  readonly key: KeySchema;
+  readonly name: string;
+  readonly queries: Readonly<Record<string, AnyQuery>>;
+}
+
+type Call = (payload: Value) => Effect.Effect<Value, Value | HostFailure>;
+
+type ErasedClient = Readonly<Record<string, Call>>;
+
+interface ErasedMembers {
+  readonly commands: ErasedClient;
+  readonly queries: ErasedClient;
+}
+
+interface Target {
+  readonly actor: string;
+  readonly key: string;
+  readonly principal: string;
+}
+
+interface Driving {
+  readonly host: ActorHost["Service"];
+  readonly next: Effect.Effect<string>;
+}
+
+const firstCommand = 0;
+
+const nextCommand = 1;
+
+const hexadecimal = 16;
+
+const fieldDigits = 12;
+
+const timeStart = 0;
+
+const timeHigh = 8;
+
+const hexOf = (value: number): string => Str.padStart(fieldDigits, "0")(value.toString(hexadecimal));
+
+const storyId = (millis: number, serial: number): string => {
+  const time = hexOf(millis);
+
+  return `${Str.slice(timeStart, timeHigh)(time)}-${Str.slice(timeHigh)(time)}-7000-8000-${hexOf(serial)}`;
+};
+
+const defaultCaller: Caller = { kind: "user", principal: { id: "story" } };
+
+function valueCodec(schema: PlainSchema): Schema.Codec<Value, string>;
+function valueCodec(schema: PlainSchema): ReturnType<typeof jsonCodec> {
+  return jsonCodec(schema);
+}
+
+function keyCodec(key: KeySchema): Schema.Codec<Value, string>;
+function keyCodec(key: KeySchema): KeySchema {
+  return key;
+}
+
+function callerCodec(schema: PlainSchema): Schema.Codec<Caller, string>;
+function callerCodec(schema: PlainSchema): ReturnType<typeof jsonCodec> {
+  return jsonCodec(schema);
+}
+
+function replyCodec(declaration: AnyCommand | AnyQuery): Schema.Codec<Exit.Exit<Value, Value>, string>;
+function replyCodec(declaration: AnyCommand | AnyQuery): ReturnType<typeof exitCodec> {
+  return exitCodec(declaration);
+}
+
+const encoded = (schema: PlainSchema, value: Value): Effect.Effect<string> =>
+  Effect.orDie(Schema.encodeEffect(valueCodec(schema))(value));
+
+const targetOf = Effect.fnUntraced(function* targetOf({
+  actor,
+  key,
+  options,
+}: Addressed<Contract, Value, ErasedOptions>) {
+  const caller = options?.as ?? defaultCaller;
+
+  const schema = Option.match(Rec.get(actor.callers, caller.kind), {
+    onNone: () => Caller,
+    onSome: (principal) => Schema.Struct({ kind: Schema.String, principal }),
+  });
+
+  const principal = yield* Schema.encodeEffect(callerCodec(schema))(caller);
+
+  return {
+    actor: actor.name,
+    key: yield* Schema.encodeEffect(keyCodec(actor.key))(key),
+    principal,
+  } satisfies Target;
+}, Effect.orDie);
+
+const decoded = Effect.fnUntraced(function* decoded(declaration: AnyCommand | AnyQuery, reply: string) {
+  const exit = yield* Effect.orDie(Schema.decodeEffect(replyCodec(declaration))(reply));
+
+  return yield* exit;
+});
+
+const callOf =
+  (declaration: AnyCommand | AnyQuery, send: (payload: string) => Effect.Effect<string, HostFailure>): Call =>
+  (payload) =>
+    Effect.gen(function* call() {
+      const text = yield* encoded(declaration.payload, payload);
+      const reply = yield* send(text);
+
+      return yield* decoded(declaration, reply);
+    });
+
+const membersOf = ({ host, next }: Driving, contract: Contract, target: Target): ErasedMembers => {
+  const commands = Rec.map(contract.commands, (declaration, member) =>
+    callOf(declaration, (payload) =>
+      Effect.flatMap(next, (commandId) =>
+        Effect.tap(host.command({ ...target, commandId, member, payload }), () => host.drain),
+      ),
+    ),
+  );
+
+  const queries = Rec.map(contract.queries, (declaration, member) =>
+    callOf(declaration, (payload) => host.query({ ...target, member, payload })),
+  );
+
+  return { commands, queries };
+};
+
+function actorOf<Name extends string, Definition extends ActorDefinition>(
+  driving: Driving,
+  addressed: Addressed<Actor<Name, Definition>, Definition["key"]["Type"], CallOptions<Definition>>,
+): Effect.Effect<StoryClient<Definition>>;
+function actorOf(driving: Driving, addressed: Addressed<Contract, Value, ErasedOptions>): Effect.Effect<ErasedClient> {
+  return Effect.map(targetOf(addressed), (target) => {
+    const { commands, queries } = membersOf(driving, addressed.actor, target);
+
+    return { ...commands, ...queries };
+  });
+}
+
+function createOf<Name extends string, Definition extends ActorDefinition>(
+  driving: Driving,
+  creating: Creating<Actor<Name, Definition>, Definition["key"]["Type"], CreateOptions<Definition>>,
+): Effect.Effect<void, HostFailure>;
+function createOf(
+  { host, next }: Driving,
+  creating: Creating<Contract, Value, ErasedCreate>,
+): Effect.Effect<void, HostFailure> {
+  return Effect.gen(function* create() {
+    const target = yield* targetOf(creating);
+    const payload = yield* encoded(creating.actor.create, creating.options.input);
+    const commandId = yield* next;
+
+    yield* host.create({ ...target, commandId, member: "create", mode: "create", payload });
+    yield* host.drain;
+  });
+}
+
+const driverOf = (host: ActorHost["Service"], directory: string, ids: Ref.Ref<number>): Driver => {
+  const next = Effect.flatMap(Clock.currentTimeMillis, (now) =>
+    Ref.modify(ids, (id) => [storyId(now, id), id + nextCommand] as const),
+  );
+
+  const driving: Driving = { host, next };
+
+  return {
+    actor: (actor, key, options) => actorOf(driving, { actor, key, options }),
+    advance: (duration) => Effect.andThen(TestClock.adjust(duration), host.drain),
+    create: (actor, key, options) => createOf(driving, { actor, key, options }),
+    directory,
+  };
+};
+
+export class StoryDriver extends Context.Service<StoryDriver, Driver>()(
+  "@akterjs/effect/testing/story-driver.service/StoryDriver",
+) {
+  public static layer(directory: string): Layer.Layer<StoryDriver, never, ActorHost> {
+    return Layer.effect(
+      this,
+      Effect.gen(function* makeStoryDriver() {
+        const host = yield* ActorHost;
+        const ids = yield* Ref.make(firstCommand);
+
+        return driverOf(host, directory, ids);
+      }),
+    );
+  }
+}
+
+export type { CallOptions, CreateOptions, Driver, StoryCall, StoryClient };

package/src/testing/story.layer.ts

@@ -0,0 +1,99 @@
+import { layer as nodeFileSystem } from "@effect/platform-node/NodeFileSystem";
+import { layer as nodePath } from "@effect/platform-node/NodePath";
+import { Clock, Context, Effect, FileSystem, Layer, Predicate } from "effect";
+import type { Scope } from "effect";
+import { TestClock } from "effect/testing";
+import type { WorkflowEngine } from "effect/workflow";
+
+import type { Actor, ActorDefinition } from "#src/contract/actor/actor.contract";
+import { actorEngine } from "#src/serve/engine/actor-engine.layer";
+import { jobs as localJobs } from "#src/runtime/akter-local.layer";
+import { Verify } from "#src/serve/verify/verify.layer";
+import type { ReplayReport, VerifyFailure } from "#src/serve/verify/verify.layer";
+
+import { StoryDriver } from "./story-driver.service.js";
+import type { Driver } from "./story-driver.service.js";
+
+type ErrorOf<Eff> = [Eff] extends [never]
+  ? never
+  : [Eff] extends [Effect.Effect<infer _Success, infer Failure, infer _Services>]
+    ? Failure
+    : never;
+
+type ServicesOf<Eff> = [Eff] extends [never]
+  ? never
+  : [Eff] extends [Effect.Effect<infer _Success, infer _Failure, infer Services>]
+    ? Services
+    : never;
+
+interface Replays {
+  readonly replay: <Name extends string, Definition extends ActorDefinition>(
+    actor: Actor<Name, Definition>,
+    key: Definition["key"]["Type"],
+  ) => Effect.Effect<ReplayReport, VerifyFailure>;
+}
+
+type StoryTools = Driver & Replays;
+
+type Handlers<Provided> = Layer.Layer<Provided, never, WorkflowEngine.WorkflowEngine>;
+
+type Jobs = Layer.Success<typeof localJobs>;
+
+const platform = Layer.mergeAll(nodeFileSystem, nodePath);
+
+const storyIn = <Provided>(handlers: Layer.Layer<Provided>, directory: string): Layer.Layer<StoryDriver> =>
+  StoryDriver.layer(directory).pipe(Layer.provide(actorEngine(directory)), Layer.provide([handlers, platform]));
+
+const storyOn = Effect.fnUntraced(function* storyOn<Provided>(handlers: Handlers<Provided>) {
+  const machine = yield* Layer.build(platform);
+  const fileSystem = Context.get(machine, FileSystem.FileSystem);
+  const directory = yield* Effect.orDie(fileSystem.makeTempDirectoryScoped({ prefix: "akter-story-" }));
+  const jobs = yield* Layer.build(localJobs);
+  const provided = Layer.provideMerge(handlers, Layer.succeedContext(jobs));
+  const story = yield* Layer.build(storyIn(provided, directory));
+
+  const tools: StoryTools = {
+    ...Context.get(story, StoryDriver),
+    replay: <Name extends string, Definition extends ActorDefinition>(
+      actor: Actor<Name, Definition>,
+      key: Definition["key"]["Type"],
+    ): Effect.Effect<ReplayReport, VerifyFailure> => Verify.replay(provided, { actor, directory, key }),
+  };
+
+  return { jobs, tools };
+});
+
+const ownClock = Layer.build(TestClock.layer());
+
+const onTestClock = <Out, Failure, Services>(
+  effect: Effect.Effect<Out, Failure, Services>,
+): Effect.Effect<Out, Failure, Services> =>
+  Clock.clockWith((clock) => {
+    if (Predicate.hasProperty(clock, "adjust")) {
+      return effect;
+    }
+
+    return Effect.scoped(Effect.flatMap(ownClock, (testClock) => Effect.provideContext(effect, testClock)));
+  });
+
+const run = <Provided, Eff extends Effect.Effect<unknown, unknown, unknown>, Out>(
+  handlers: Handlers<Provided>,
+  body: (story: StoryTools) => Generator<Eff, Out, never>,
+): Effect.Effect<Out, ErrorOf<Eff>, Exclude<Exclude<ServicesOf<Eff>, Jobs>, Scope.Scope>> => {
+  const story = Effect.scoped(
+    Effect.flatMap(storyOn(handlers), ({ jobs, tools }) =>
+      Effect.provide(
+        Effect.gen(() => body(tools)),
+        jobs,
+      ),
+    ),
+  );
+
+  return onTestClock(story);
+};
+
+export const Story = { run } as const;
+
+export type { CallOptions, CreateOptions, Driver, StoryCall, StoryClient } from "./story-driver.service.js";
+
+export type { Replays, StoryTools };