@akterjs/effect 0.0.0-stage → 0.1.0

package/dist/serve/rpc/served-rpc.layer.mjs

@@ -0,0 +1,19 @@
+import { actorRpcHandlers } from "./actor-rpc.handlers.mjs";
+import { computerRpcHandlers } from "./computer/computer-rpc.layer.mjs";
+import { fileRpcHandlers } from "./file/file-rpc.layer.mjs";
+import { Effect } from "effect";
+// src/serve/rpc/served-rpc.layer.ts
+function servedHandlers(handlers) {
+	return handlers;
+}
+/** Every handler of the served actors' RPC groups: calls, reads and subscriptions, file streams and computers. */
+const servedRpcHandlers = (actors) => Effect.map(Effect.all({
+	calls: actorRpcHandlers(actors),
+	computers: computerRpcHandlers(actors),
+	files: fileRpcHandlers({ actors })
+}), ({ calls, computers, files }) => servedHandlers({
+	...calls,
+	...files,
+	...computers
+}));
+export { servedRpcHandlers };

package/dist/serve/store/actor-not-migrated.errors.d.mts

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+declare const ActorNotMigratedError_base: Schema.Class<ActorNotMigratedError, Schema.TaggedStruct<"ActorNotMigratedError", {
+  readonly actor: Schema.String;
+  readonly key: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class ActorNotMigratedError extends ActorNotMigratedError_base {}
+export {};

package/dist/serve/store/actor-not-migrated.errors.mjs

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+// src/serve/store/actor-not-migrated.errors.ts
+var ActorNotMigratedError = class extends Schema.TaggedError()("ActorNotMigratedError", {
+	actor: Schema.String,
+	key: Schema.String,
+	message: Schema.String
+}) {};
+export { ActorNotMigratedError };

package/dist/serve/store/store-migrations.layer.d.mts

@@ -0,0 +1,5 @@
+import { LocalMigration, StoreMigration } from "./store-migrations.service.mjs";
+import { FileSystem, Path, Stream } from "effect";
+type StoreMigrationOn = Stream.Stream<Stream.Success<StoreMigration>, Stream.Error<StoreMigration>, FileSystem.FileSystem | Path.Path>;
+declare const migrateStore: ({ directory, ...options }: LocalMigration) => StoreMigrationOn;
+export { migrateStore };

package/dist/serve/store/store-migrations.layer.mjs

@@ -0,0 +1,18 @@
+import { ActorMigrations } from "../../host/migration/actor-migrations.service.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { providedHandlers } from "../engine/actor-engine.layer.mjs";
+import { ActorLocation } from "../engine/actor-location.service.mjs";
+import { StoreMigrations } from "./store-migrations.service.mjs";
+import { Effect, Layer, Stream } from "effect";
+// src/serve/store/store-migrations.layer.ts
+const storeMigrations = (directory) => StoreMigrations.layer.pipe(Layer.provide([
+	providedHandlers,
+	ActorMigrations.layer,
+	ActorLocation.directory(directory),
+	SqliteDriver.layerNode
+]), Layer.fresh);
+const migrateStore = ({ directory, ...options }) => {
+	const all = Stream.unwrap(StoreMigrations.use((migrations) => Effect.succeed(migrations.migrateAll(options))));
+	return Stream.provide(all, storeMigrations(directory));
+};
+export { migrateStore };

package/dist/serve/store/store-migrations.service.d.mts

@@ -0,0 +1,26 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { ActorMigrations, MigrationStep } from "../../host/migration/actor-migrations.service.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { ActorAddress, ActorLocation } from "../engine/actor-location.service.mjs";
+import { ActorNotMigratedError } from "./actor-not-migrated.errors.mjs";
+import { StoreUnreadableError } from "./store-unreadable.errors.mjs";
+import { Context, Effect, Layer, Stream } from "effect";
+interface MigrateOptions {
+  readonly dryRun: boolean;
+}
+interface LocalMigration extends MigrateOptions {
+  readonly directory: string;
+}
+interface MigratedActor extends ActorAddress, MigrationStep {}
+type StoreMigration = Stream.Stream<MigratedActor, ActorNotMigratedError | StoreUnreadableError>;
+declare const StoreMigrations_base: Context.ServiceClass<StoreMigrations, "@akterjs/effect/serve/store/store-migrations.service/StoreMigrations", {
+  readonly migrateAll: (options: MigrateOptions) => StoreMigration;
+}> & {
+  readonly make: Effect.Effect<{
+    readonly migrateAll: (options: MigrateOptions) => StoreMigration;
+  }, never, ActorLocation | ActorMigrations | ActorRegistry | SqliteDriver>;
+};
+export declare class StoreMigrations extends StoreMigrations_base {
+  static readonly layer: Layer.Layer<StoreMigrations, never, ActorLocation | ActorMigrations | ActorRegistry | SqliteDriver>;
+}
+export type { LocalMigration, MigrateOptions, MigratedActor, StoreMigration };

package/dist/serve/store/store-migrations.service.mjs

@@ -0,0 +1,47 @@
+import { ActorRegistry } from "../../contract/actor/actor-registry.service.mjs";
+import { ActorMigrations } from "../../host/migration/actor-migrations.service.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { ActorLocation } from "../engine/actor-location.service.mjs";
+import { ActorNotMigratedError } from "./actor-not-migrated.errors.mjs";
+import { Context, Effect, Layer, Stream } from "effect";
+// src/serve/store/store-migrations.service.ts
+const notMigrated = ({ actor, key }) => (failure) => ActorNotMigratedError.make({
+	actor,
+	key,
+	message: failure.message
+});
+var StoreMigrations = class extends Context.Service()("@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, { dryRun }) {
+		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) => Stream.mapEffect(Stream.unwrap(Effect.map(location.list, Stream.fromIterable)), (address) => Effect.scoped(migrateActor(address, options)));
+	return { migrateAll };
+}) }) {
+	static layer = Layer.effect(this, this.make);
+};
+export { StoreMigrations };

package/dist/serve/store/store-unreadable.errors.d.mts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+declare const StoreUnreadableError_base: Schema.Class<StoreUnreadableError, Schema.TaggedStruct<"StoreUnreadableError", {
+  readonly directory: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+export declare class StoreUnreadableError extends StoreUnreadableError_base {}
+export {};

package/dist/serve/store/store-unreadable.errors.mjs

@@ -0,0 +1,7 @@
+import { Schema } from "effect";
+// src/serve/store/store-unreadable.errors.ts
+var StoreUnreadableError = class extends Schema.TaggedError()("StoreUnreadableError", {
+	directory: Schema.String,
+	message: Schema.String
+}) {};
+export { StoreUnreadableError };

package/dist/serve/verify/verify.layer.d.mts

@@ -0,0 +1,16 @@
+import { ActorNotRegisteredError } from "../../contract/actor/actor-not-registered.errors.mjs";
+import { Actor, ActorDefinition } from "../../contract/actor/actor.contract.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { JournalPoint, ReplayDifference, ReplayFailure, ReplayReport, ReplayWindow, ReplayedOutcome } from "../../host/command/command-replay.service.mjs";
+import { Effect, Layer } from "effect";
+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;
+declare const replay: <Provided, Name extends string, Definition extends ActorDefinition>(handlers: Layer.Layer<Provided>, source: ReplaySource<Name, Definition>) => Effect.Effect<ReplayReport, VerifyFailure>;
+export declare const Verify: {
+  readonly replay: typeof replay;
+};
+export type { JournalPoint, ReplayDifference, ReplayFailure, ReplayReport, ReplaySource, ReplayWindow, ReplayedOutcome, VerifyFailure };

package/dist/serve/verify/verify.layer.mjs

@@ -0,0 +1,36 @@
+import { ActorNotRegisteredError } from "../../contract/actor/actor-not-registered.errors.mjs";
+import { InvalidRequestError } from "../../contract/client/invalid-request.errors.mjs";
+import { CommandReplay } from "../../host/command/command-replay.service.mjs";
+import { SqliteDriver } from "../../host/sqlite/sqlite-driver.service.mjs";
+import { ActorLocation } from "../engine/actor-location.service.mjs";
+import { fileHomes } from "../../runtime/local-actor-engine.layer.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { layer } from "@effect/platform-node/NodeFileSystem";
+import { layer as layer$1 } from "@effect/platform-node/NodePath";
+// src/serve/verify/verify.layer.ts
+const platform = Layer.mergeAll(layer, layer$1);
+const verifying = (directory) => Layer.mergeAll(ActorLocation.directory(directory), CommandReplay.layer).pipe(Layer.provide(fileHomes(directory)), Layer.provide([SqliteDriver.layerNode, platform]));
+const hostedBy = Effect.fnUntraced(function* hostedBy(handlers, actor) {
+	const provided = yield* Layer.build(handlers);
+	return yield* Effect.mapError(Effect.fromOption(Context.getOption(provided, actor.handlers)), () => ActorNotRegisteredError.make({ actor: actor.name }));
+});
+const encodedKey = ({ actor, key }) => Effect.mapError(Schema.encodeEffect(actor.key)(key), (issue) => InvalidRequestError.make({
+	actor: actor.name,
+	message: issue.message
+}));
+const replay = (handlers, source) => 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
+	});
+}));
+const Verify = { replay };
+export { Verify };

package/dist/testing/story-driver.service.d.mts

@@ -0,0 +1,29 @@
+import { Actor, ActorDefinition } from "../contract/actor/actor.contract.mjs";
+import { AnyCommand, AnyQuery } from "../contract/command/command.contract.mjs";
+import { HostFailure } from "../serve/live/live-reads.service.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { Context, Duration, Effect, Layer, Schema } from "effect";
+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;
+}
+declare const StoryDriver_base: Context.ServiceClass<StoryDriver, "@akterjs/effect/testing/story-driver.service/StoryDriver", Driver>;
+export declare class StoryDriver extends StoryDriver_base {
+  static layer(directory: string): Layer.Layer<StoryDriver, never, ActorHost>;
+}
+export type { CallOptions, CreateOptions, Driver, StoryCall, StoryClient };

package/dist/testing/story-driver.service.mjs

@@ -0,0 +1,126 @@
+import { Caller } from "../contract/caller/caller.schema.mjs";
+import { exitCodec, jsonCodec } from "../contract/json-codec.pure.mjs";
+import { ActorHost } from "../serve/engine/actor-host.service.mjs";
+import { Clock, Context, Effect, Layer, Option, Record, Ref, Schema, String } from "effect";
+import { TestClock } from "effect/testing";
+// src/testing/story-driver.service.ts
+const firstCommand = 0;
+const nextCommand = 1;
+const hexadecimal = 16;
+const fieldDigits = 12;
+const timeStart = 0;
+const timeHigh = 8;
+const hexOf = (value) => String.padStart(fieldDigits, "0")(value.toString(hexadecimal));
+const storyId = (millis, serial) => {
+	const time = hexOf(millis);
+	return `${String.slice(timeStart, timeHigh)(time)}-${String.slice(timeHigh)(time)}-7000-8000-${hexOf(serial)}`;
+};
+const defaultCaller = {
+	kind: "user",
+	principal: { id: "story" }
+};
+function valueCodec(schema) {
+	return jsonCodec(schema);
+}
+function keyCodec(key) {
+	return key;
+}
+function callerCodec(schema) {
+	return jsonCodec(schema);
+}
+function replyCodec(declaration) {
+	return exitCodec(declaration);
+}
+const encoded = (schema, value) => Effect.orDie(Schema.encodeEffect(valueCodec(schema))(value));
+const targetOf = Effect.fnUntraced(function* targetOf({ actor, key, options }) {
+	const caller = options?.as ?? defaultCaller;
+	const schema = Option.match(Record.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
+	};
+}, Effect.orDie);
+const decoded = Effect.fnUntraced(function* decoded(declaration, reply) {
+	return yield* yield* Effect.orDie(Schema.decodeEffect(replyCodec(declaration))(reply));
+});
+const callOf = (declaration, send) => (payload) => Effect.gen(function* call() {
+	const reply = yield* send(yield* encoded(declaration.payload, payload));
+	return yield* decoded(declaration, reply);
+});
+const membersOf = ({ host, next }, contract, target) => {
+	return {
+		commands: Record.map(contract.commands, (declaration, member) => callOf(declaration, (payload) => Effect.flatMap(next, (commandId) => Effect.tap(host.command({
+			...target,
+			commandId,
+			member,
+			payload
+		}), () => host.drain)))),
+		queries: Record.map(contract.queries, (declaration, member) => callOf(declaration, (payload) => host.query({
+			...target,
+			member,
+			payload
+		})))
+	};
+};
+function actorOf(driving, addressed) {
+	return Effect.map(targetOf(addressed), (target) => {
+		const { commands, queries } = membersOf(driving, addressed.actor, target);
+		return {
+			...commands,
+			...queries
+		};
+	});
+}
+function createOf({ host, next }, creating) {
+	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, directory, ids) => {
+	const driving = {
+		host,
+		next: Effect.flatMap(Clock.currentTimeMillis, (now) => Ref.modify(ids, (id) => [storyId(now, id), id + nextCommand]))
+	};
+	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
+	};
+};
+var StoryDriver = class extends Context.Service()("@akterjs/effect/testing/story-driver.service/StoryDriver") {
+	static layer(directory) {
+		return Layer.effect(this, Effect.gen(function* makeStoryDriver() {
+			const host = yield* ActorHost;
+			const ids = yield* Ref.make(firstCommand);
+			return driverOf(host, directory, ids);
+		}));
+	}
+};
+export { StoryDriver };

package/dist/testing/story.layer.d.mts

@@ -0,0 +1,21 @@
+import { Actor, ActorDefinition } from "../contract/actor/actor.contract.mjs";
+import { jobs } from "../runtime/local-job-runtime.layer.mjs";
+import "../runtime/akter-local.layer.mjs";
+import { ReplayReport } from "../host/command/command-replay.service.mjs";
+import { VerifyFailure } from "../serve/verify/verify.layer.mjs";
+import { CallOptions, CreateOptions, Driver, StoryCall, StoryClient } from "./story-driver.service.mjs";
+import { Effect, Layer, Scope } from "effect";
+import { WorkflowEngine } from "effect/workflow";
+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 jobs>;
+declare 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>>;
+export declare const Story: {
+  readonly run: typeof run;
+};
+export type { CallOptions, CreateOptions, Driver, Replays, StoryCall, StoryClient, StoryTools };

package/dist/testing/story.layer.mjs

@@ -0,0 +1,42 @@
+import { actorEngine } from "../serve/engine/actor-engine.layer.mjs";
+import { jobs } from "../runtime/local-job-runtime.layer.mjs";
+import "../runtime/akter-local.layer.mjs";
+import { Verify } from "../serve/verify/verify.layer.mjs";
+import { StoryDriver } from "./story-driver.service.mjs";
+import { Clock, Context, Effect, FileSystem, Layer, Predicate } from "effect";
+import { layer } from "@effect/platform-node/NodeFileSystem";
+import { layer as layer$1 } from "@effect/platform-node/NodePath";
+import { TestClock } from "effect/testing";
+// src/testing/story.layer.ts
+const platform = Layer.mergeAll(layer, layer$1);
+const storyIn = (handlers, directory) => StoryDriver.layer(directory).pipe(Layer.provide(actorEngine(directory)), Layer.provide([handlers, platform]));
+const storyOn = Effect.fnUntraced(function* storyOn(handlers) {
+	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$1 = yield* Layer.build(jobs);
+	const provided = Layer.provideMerge(handlers, Layer.succeedContext(jobs$1));
+	const story = yield* Layer.build(storyIn(provided, directory));
+	return {
+		jobs: jobs$1,
+		tools: {
+			...Context.get(story, StoryDriver),
+			replay: (actor, key) => Verify.replay(provided, {
+				actor,
+				directory,
+				key
+			})
+		}
+	};
+});
+const ownClock = Layer.build(TestClock.layer());
+const onTestClock = (effect) => Clock.clockWith((clock) => {
+	if (Predicate.hasProperty(clock, "adjust")) return effect;
+	return Effect.scoped(Effect.flatMap(ownClock, (testClock) => Effect.provideContext(effect, testClock)));
+});
+const run = (handlers, body) => {
+	const story = Effect.scoped(Effect.flatMap(storyOn(handlers), ({ jobs, tools }) => Effect.provide(Effect.gen(() => body(tools)), jobs)));
+	return onTestClock(story);
+};
+const Story = { run };
+export { Story };

package/package.json

@@ -1,6 +1,109 @@
 {
   "name": "@akterjs/effect",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "The Effect SDK for Akter: contracts, host runtime, local engine and Story tests.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rika-Labs/akter.git",
+    "directory": "packages/effect"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "imports": {
+    "#src/*": "./dist/*.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/runtime/akter.layer.d.mts",
+      "default": "./dist/runtime/akter.layer.mjs"
+    },
+    "./contract": {
+      "types": "./dist/contract/akter.service.d.mts",
+      "default": "./dist/contract/akter.service.mjs"
+    },
+    "./contract/description": {
+      "types": "./dist/contract/description/published-contract.pure.d.mts",
+      "default": "./dist/contract/description/published-contract.pure.mjs"
+    },
+    "./contract/errors": {
+      "types": "./dist/contract/client/client-failure.contract.d.mts",
+      "default": "./dist/contract/client/client-failure.contract.mjs"
+    },
+    "./contract/actor-client": {
+      "types": "./dist/contract/client/actor-client.adapter.d.mts",
+      "default": "./dist/contract/client/actor-client.adapter.mjs"
+    },
+    "./contract/file-clients": {
+      "types": "./dist/contract/file/rpc/rpc-file-clients.layer.d.mts",
+      "default": "./dist/contract/file/rpc/rpc-file-clients.layer.mjs"
+    },
+    "./contract/computer": {
+      "types": "./dist/contract/computer/computer.schema.d.mts",
+      "default": "./dist/contract/computer/computer.schema.mjs"
+    },
+    "./contract/computer-clients": {
+      "types": "./dist/contract/computer/computer-client.adapter.d.mts",
+      "default": "./dist/contract/computer/computer-client.adapter.mjs"
+    },
+    "./contract/actor-registry": {
+      "types": "./dist/contract/actor/actor-registry.service.d.mts",
+      "default": "./dist/contract/actor/actor-registry.service.mjs"
+    },
+    "./contract/room": {
+      "types": "./dist/contract/room.contract.d.mts",
+      "default": "./dist/contract/room.contract.mjs"
+    },
+    "./host/room": {
+      "types": "./dist/host/actor/room.actor.d.mts",
+      "default": "./dist/host/actor/room.actor.mjs"
+    },
+    "./execution-authority": {
+      "types": "./dist/host/upkeep/execution-authority.pure.d.mts",
+      "default": "./dist/host/upkeep/execution-authority.pure.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing/story.layer.d.mts",
+      "default": "./dist/testing/story.layer.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@akterjs/workerd-test": "0.0.0",
+    "@effect/platform-bun": "4.1.2",
+    "@effect/platform-node": "4.1.2",
+    "@effect/vitest": "4.1.2",
+    "@vitest/browser-playwright": "5.1.0",
+    "effect": "4.1.2",
+    "esbuild": "0.28.2",
+    "mutant-cafe": "0.1.6",
+    "playwright": "1.65.0",
+    "publint": "0.3.25",
+    "tsdown": "0.23.5",
+    "vitest": "5.1.0"
+  },
+  "peerDependencies": {
+    "@effect/platform-bun": "4.1.2",
+    "@effect/platform-node": "4.1.2",
+    "effect": "4.1.2"
+  },
+  "scripts": {
+    "typecheck": "effect-tsgo tsrs --noEmit -p tsconfig.json",
+    "lint": "effect-tsgo --tsrs-lint oxlint -c ../../oxlint.config.ts --type-aware --tsconfig tsconfig.json src tests",
+    "test": "vitest run",
+    "test:browser": "vitest run --mode browser",
+    "test:workerd": "workerd-test",
+    "test:bun": "bunx --bun vitest run",
+    "build": "tsdown",
+    "contracts": "bun --conditions=@akterjs/source ../../tools/contracts/src/contract/contract-gate.cli.ts",
+    "contracts:write": "bun --conditions=@akterjs/source ../../tools/contracts/src/contract/contract-gate.cli.ts --write",
+    "mutants": "NODE_OPTIONS=--conditions=@akterjs/source VITEST_MAX_WORKERS=1 mutant-cafe --advisory && node ../../node_modules/@rikalabs/rules/src/mutants/mutants.cli.mjs --all",
+    "mutants:diff": "NODE_OPTIONS=--conditions=@akterjs/source VITEST_MAX_WORKERS=1 mutant-cafe --in-diff-range main...HEAD --advisory && node ../../node_modules/@rikalabs/rules/src/mutants/mutants.cli.mjs"
+  }
 }

package/src/contract/actor/actor-already-exists.errors.ts

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