effect-encore 0.1.0

package/README.md

@@ -0,0 +1,132 @@
+# effect-encore
+
+Erlang gen_server semantics over `@effect/cluster`.
+
+## Why
+
+`@effect/cluster` is powerful but low-level. Defining a single entity requires custom `Schema.Class` implementations, `Rpc.make`, `RpcGroup`, `Entity.make`, handler wiring via `entity.toLayer`, and a hand-rolled client service. A typical entity runs 100+ lines before any business logic.
+
+effect-encore compresses this into a declarative DSL:
+
+```ts
+import { Actor } from "effect-encore";
+import { Schema } from "effect";
+
+const Counter = Actor.make("Counter", {
+  Increment: {
+    payload: { amount: Schema.Number },
+    success: Schema.Number,
+  },
+});
+```
+
+Every operation supports `call` (block for reply), `cast` (fire-and-forget with receipt), and `peek`/`watch` (check or stream results). Delivery mode is the caller's choice, not the definition's — just like Erlang's `gen_server:call` vs `gen_server:cast`.
+
+## Core API
+
+### Define
+
+```ts
+// Multi-operation actor
+const OrderValidation = Actor.make("OrderValidation", {
+  Validate: {
+    payload: { orderId: Schema.String },
+    success: Schema.String,
+    error: ValidationError,
+    persisted: true,
+    primaryKey: (p) => p.orderId,
+  },
+  Cancel: {
+    payload: { orderId: Schema.String },
+    persisted: true,
+    primaryKey: (p) => p.orderId,
+  },
+});
+
+// Single-operation actor (no operation namespace on ref)
+const VectorUpdate = Actor.single("VectorUpdate", {
+  payload: { locationId: Schema.String },
+  persisted: true,
+  primaryKey: (p) => p.locationId,
+});
+
+// Delayed delivery
+const Scheduled = Actor.make("Scheduled", {
+  Process: {
+    payload: { id: Schema.String, deliverAt: Schema.DateTimeUtc },
+    primaryKey: (p) => p.id,
+    deliverAt: (p) => p.deliverAt,
+    persisted: true,
+  },
+});
+
+// Pre-built Schema.Class (escape hatch for custom symbol implementations)
+const WithCustomPayload = Actor.make("Custom", {
+  Run: { payload: MySchemaClass, success: Schema.Void },
+});
+```
+
+### Handle
+
+```ts
+// Plain handlers
+const handlers = Handlers.handlers(OrderValidation, {
+  Validate: (req) => validateOrder(req.payload.orderId),
+  Cancel: (req) => cancelOrder(req.payload.orderId),
+});
+
+// From Effect context
+const handlers = Handlers.handlers(
+  OrderValidation,
+  Effect.gen(function* () {
+    const db = yield* Database;
+    return {
+      Validate: (req) => db.validate(req.payload.orderId),
+      Cancel: (req) => db.cancel(req.payload.orderId),
+    };
+  }),
+);
+```
+
+### Call & Cast
+
+```ts
+const makeRef = yield * Actor.client(OrderValidation);
+const ref = makeRef("order-123");
+
+// call — block for reply
+const result = yield * ref.Validate.call({ orderId: "abc" });
+
+// cast — fire-and-forget, get receipt
+const receipt = yield * ref.Validate.cast({ orderId: "abc" });
+
+// peek — one-shot status check via receipt
+const status = yield * Peek.peek(OrderValidation, receipt);
+
+// watch — polling stream of status changes
+const stream = Peek.watch(OrderValidation, receipt);
+```
+
+### Test
+
+```ts
+const makeRef = yield * Testing.testClient(Counter, handlerLayer);
+const ref = yield * makeRef("counter-1");
+const result = yield * ref.Increment.call({ amount: 5 });
+```
+
+## v3 Support
+
+Import from `effect-encore/v3` for `@effect/cluster` v3 compatibility. Same API, different import paths under the hood.
+
+## Install
+
+```bash
+bun add effect-encore
+```
+
+Peer dependencies: `effect`, `@effect/cluster` (v3) or `effect` with `effect/unstable/cluster` (v4).
+
+## License
+
+MIT

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/actor.d.ts

@@ -0,0 +1,113 @@
+import { CastReceipt } from "./receipt.js";
+import { Entity, Sharding, ShardingConfig } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
+import { Context, DateTime, Effect, Layer, Schema, Scope } from "effect";
+
+//#region src/actor.d.ts
+interface OperationDef {
+  readonly payload?: Schema.Top | Schema.Struct.Fields;
+  readonly success?: Schema.Top;
+  readonly error?: Schema.Top;
+  readonly persisted?: boolean;
+  readonly primaryKey?: (payload: never) => string;
+  readonly deliverAt?: (payload: never) => DateTime.DateTime;
+}
+type OperationDefs = Record<string, OperationDef>;
+type ReservedKeys = "_tag" | "_meta" | "$is" | "Context";
+type AssertNoReservedKeys<Defs extends OperationDefs> = Extract<keyof Defs, ReservedKeys> extends never ? Defs : never;
+type PayloadOf<C extends OperationDef> = C extends {
+  readonly payload: infer P extends Schema.Top;
+} ? P : C extends {
+  readonly payload: infer F extends Schema.Struct.Fields;
+} ? Schema.Struct<F> : typeof Schema.Void;
+type SuccessOf<C extends OperationDef> = C extends {
+  readonly success: infer S extends Schema.Top;
+} ? S : typeof Schema.Void;
+type ErrorOf<C extends OperationDef> = C extends {
+  readonly error: infer E extends Schema.Top;
+} ? E : typeof Schema.Never;
+type DefRpc<Tag extends string, C extends OperationDef> = Rpc.Rpc<Tag, PayloadOf<C>, SuccessOf<C>, ErrorOf<C>>;
+type DefRpcs<Defs extends OperationDefs> = { readonly [Tag in keyof Defs & string]: DefRpc<Tag, Defs[Tag]> }[keyof Defs & string];
+declare const OperationBrandId: unique symbol;
+interface OperationBrand<Name extends string, Tag extends string, Output, Error> {
+  readonly [OperationBrandId]: {
+    readonly name: Name;
+    readonly tag: Tag;
+    readonly output: Output;
+    readonly error: Error;
+  };
+}
+type OperationOutput<V> = V extends {
+  readonly [OperationBrandId]: {
+    readonly output: infer A;
+  };
+} ? A : never;
+type OperationError<V> = V extends {
+  readonly [OperationBrandId]: {
+    readonly error: infer E;
+  };
+} ? E : never;
+type OperationValue<Name extends string, Tag extends string, C extends OperationDef> = {
+  readonly _tag: Tag;
+} & PayloadFieldsType<C> & OperationBrand<Name, Tag, Schema.Schema.Type<SuccessOf<C>>, Schema.Schema.Type<ErrorOf<C>>>;
+type PayloadFieldsType<C extends OperationDef> = C extends {
+  readonly payload: infer F extends Schema.Struct.Fields;
+} ? { readonly [K in keyof F]: Schema.Schema.Type<F[K] extends Schema.Top ? F[K] : never> } : C extends {
+  readonly payload: infer P extends Schema.Top;
+} ? Schema.Schema.Type<P> : {};
+type OperationConstructorPayload<C extends OperationDef> = C extends {
+  readonly payload: infer F extends Schema.Struct.Fields;
+} ? {} extends { [K in keyof F]: Schema.Schema.Type<F[K] extends Schema.Top ? F[K] : never> } ? [] : [payload: { readonly [K in keyof F]: Schema.Schema.Type<F[K] extends Schema.Top ? F[K] : never> }] : C extends {
+  readonly payload: infer _P extends Schema.Top;
+} ? [payload: unknown] : [];
+type OperationConstructor<Name extends string, Tag extends string, C extends OperationDef> = (...args: OperationConstructorPayload<C>) => OperationValue<Name, Tag, C>;
+type OperationUnion<Name extends string, Defs extends OperationDefs> = { [Tag in keyof Defs & string]: OperationValue<Name, Tag, Defs[Tag]> }[keyof Defs & string];
+interface ActorRef<Name extends string, Defs extends OperationDefs> {
+  readonly call: <V extends OperationUnion<Name, Defs>>(op: V) => Effect.Effect<OperationOutput<V>, OperationError<V>>;
+  readonly cast: <V extends OperationUnion<Name, Defs>>(op: V) => Effect.Effect<CastReceipt>;
+}
+type HandlerRequest<Tag extends string, C extends OperationDef> = {
+  readonly operation: {
+    readonly _tag: Tag;
+  } & PayloadFieldsType<C>;
+  readonly request: unknown;
+};
+type ActorHandlers<Defs extends OperationDefs> = { readonly [Tag in keyof Defs & string]: (req: HandlerRequest<Tag, Defs[Tag]>) => Effect.Effect<Schema.Schema.Type<SuccessOf<Defs[Tag]>>, Schema.Schema.Type<ErrorOf<Defs[Tag]>>, any> };
+interface HandlerOptions {
+  readonly spanAttributes?: Record<string, string>;
+  readonly maxIdleTime?: number;
+  readonly concurrency?: number | "unbounded";
+  readonly mailboxCapacity?: number | "unbounded";
+}
+interface ActorMeta<Name extends string, Defs extends OperationDefs, Rpcs extends Rpc.Any = DefRpcs<Defs>> {
+  readonly name: Name;
+  readonly definitions: Defs;
+  readonly entity: Entity.Entity<Name, Rpcs>;
+}
+declare const ActorClientServiceId: unique symbol;
+interface ActorClientService<Name extends string, Defs extends OperationDefs> {
+  readonly [ActorClientServiceId]: {
+    readonly name: Name;
+    readonly defs: Defs;
+  };
+}
+type ActorConstructors<Name extends string, Defs extends OperationDefs> = { readonly [Tag in keyof Defs & string]: OperationConstructor<Name, Tag, Defs[Tag]> };
+type ActorObject<Name extends string, Defs extends OperationDefs, Rpcs extends Rpc.Any = DefRpcs<Defs>> = ActorConstructors<Name, Defs> & {
+  readonly _tag: "ActorObject";
+  readonly _meta: ActorMeta<Name, Defs, Rpcs>;
+  readonly Context: Context.Service<ActorClientService<Name, Defs>, (entityId: string) => ActorRef<Name, Defs>>;
+  readonly $is: <Tag extends keyof Defs & string>(tag: Tag) => (value: unknown) => value is OperationValue<Name, Tag, Defs[Tag]>;
+};
+declare const Actor: {
+  readonly make: <const Name extends string, const Defs extends OperationDefs>(name: Name, definitions: AssertNoReservedKeys<Defs>) => ActorObject<Name, Defs>;
+  readonly toLayer: <Name extends string, Defs extends OperationDefs, Rpcs extends Rpc.Any = DefRpcs<Defs>, RX = never>(actor: ActorObject<Name, Defs, Rpcs>, build: ActorHandlers<Defs> | Effect.Effect<ActorHandlers<Defs>, never, RX>, options?: HandlerOptions) => ReturnType<Entity.Entity<Name, Rpcs>["toLayer"]>;
+  readonly Live: <Name extends string, Defs extends OperationDefs, Rpcs extends Rpc.Any = DefRpcs<Defs>>(actor: ActorObject<Name, Defs, Rpcs>) => Layer.Layer<ActorClientService<Name, Defs>, never, Scope.Scope | Rpc.MiddlewareClient<Rpcs>>;
+  readonly Test: <Name extends string, Defs extends OperationDefs, Rpcs extends Rpc.Any = DefRpcs<Defs>, LA = never, LE = never, LR = never>(actor: ActorObject<Name, Defs, Rpcs>, handlerLayer: Layer.Layer<LA, LE, LR>) => Effect.Effect<(entityId: string) => Effect.Effect<ActorRef<Name, Defs>>, LE, Scope.Scope | ShardingConfig.ShardingConfig | Exclude<LR, Sharding.Sharding> | Rpc.MiddlewareClient<Rpcs>>;
+};
+declare const fromRpcs: <const Name extends string, const Rpcs extends ReadonlyArray<Rpc.Any>>(name: Name, rpcs: Rpcs) => {
+  readonly _tag: "RawActorDefinition";
+  readonly name: Name;
+  readonly entity: Entity.Entity<Name, Rpcs[number]>;
+};
+//#endregion
+export { Actor, ActorMeta, ActorObject, ActorRef, HandlerOptions, OperationBrand, OperationDef, OperationDefs, OperationError, OperationOutput, fromRpcs };

package/dist/actor.js

@@ -0,0 +1,127 @@
+import { makeCastReceipt } from "./receipt.js";
+import { ClusterSchema, Entity } from "effect/unstable/cluster";
+import * as DeliverAt from "effect/unstable/cluster/DeliverAt";
+import { Rpc } from "effect/unstable/rpc";
+import { Context, Effect, Layer, PrimaryKey, Schema } from "effect";
+//#region src/actor.ts
+const RESERVED_KEYS = new Set([
+	"_tag",
+	"_meta",
+	"$is",
+	"Context"
+]);
+const compileRpc = (actorName, tag, def) => {
+	const options = {};
+	const payload = def["payload"];
+	const pkFn = def["primaryKey"];
+	const daFn = def["deliverAt"];
+	if (payload) if (Schema.isSchema(payload)) options["payload"] = payload;
+	else {
+		const fields = payload;
+		const Base = Schema.Class(`effect-encore/${actorName}/${tag}/Payload`)(fields);
+		class PayloadClass extends Base {}
+		const proto = PayloadClass.prototype;
+		if (pkFn) proto[PrimaryKey.symbol] = function() {
+			return pkFn(this);
+		};
+		if (daFn) proto[DeliverAt.symbol] = function() {
+			return daFn(this);
+		};
+		options["payload"] = PayloadClass;
+	}
+	if (def["success"]) options["success"] = def["success"];
+	if (def["error"]) options["error"] = def["error"];
+	let rpc = Rpc.make(tag, options);
+	if (def["persisted"]) rpc = rpc.annotate(ClusterSchema.Persisted, true);
+	return rpc;
+};
+const make = (name, definitions) => {
+	for (const tag of Object.keys(definitions)) if (RESERVED_KEYS.has(tag)) throw new Error(`effect-encore: operation "${tag}" collides with reserved property. Reserved: ${[...RESERVED_KEYS].join(", ")}`);
+	const rpcs = Object.entries(definitions).map(([tag, def]) => compileRpc(name, tag, def));
+	const entity = Entity.make(name, rpcs);
+	const constructors = {};
+	for (const tag of Object.keys(definitions)) constructors[tag] = (input) => ({
+		_tag: tag,
+		...input != null && typeof input === "object" ? input : {}
+	});
+	const contextTag = Context.Service(`effect-encore/${name}/Client`);
+	const $is = (tag) => (value) => value != null && typeof value === "object" && "_tag" in value && value["_tag"] === tag;
+	return {
+		_tag: "ActorObject",
+		_meta: {
+			name,
+			definitions,
+			entity
+		},
+		Context: contextTag,
+		$is,
+		...constructors
+	};
+};
+const toLayer = (actor, build, options) => {
+	const transformed = transformHandlers(build);
+	return actor._meta.entity.toLayer(transformed, {
+		spanAttributes: options?.spanAttributes,
+		maxIdleTime: options?.maxIdleTime,
+		concurrency: options?.concurrency,
+		mailboxCapacity: options?.mailboxCapacity
+	});
+};
+const Live = (actor) => Layer.effect(actor.Context, Effect.map(actor._meta.entity.client, (makeClient) => (entityId) => buildActorRef(actor._meta.name, entityId, actor._meta.definitions, makeClient(entityId))));
+const Test = (actor, handlerLayer) => Effect.map(Entity.makeTestClient(actor._meta.entity, handlerLayer), (makeClient) => (entityId) => Effect.map(makeClient(entityId), (rpcClient) => buildActorRef(actor._meta.name, entityId, actor._meta.definitions, rpcClient)));
+const transformHandlers = (build) => {
+	if (build != null && typeof build === "object" && !Effect.isEffect(build)) {
+		const handlers = build;
+		const transformed = {};
+		for (const tag of Object.keys(handlers)) {
+			const handler = handlers[tag];
+			if (!handler) continue;
+			transformed[tag] = (request) => {
+				return handler({
+					operation: {
+						_tag: tag,
+						...request["payload"] ?? {}
+					},
+					request
+				});
+			};
+		}
+		return transformed;
+	}
+	return Effect.map(build, transformHandlers);
+};
+const buildActorRef = (actorName, entityId, definitions, rpcClient) => {
+	const client = rpcClient;
+	return {
+		call: (op) => {
+			const tag = op["_tag"];
+			const fn = client[tag];
+			return definitions[tag]?.["payload"] !== void 0 ? fn?.(op) : fn?.();
+		},
+		cast: (op) => {
+			const tag = op["_tag"];
+			const fn = client[tag];
+			const def = definitions[tag];
+			const discardCall = def?.["payload"] !== void 0 ? fn?.(op, { discard: true }) : fn?.(void 0, { discard: true });
+			return Effect.map(discardCall ?? Effect.void, () => makeCastReceipt({
+				actorType: actorName,
+				entityId,
+				operation: tag,
+				primaryKey: def?.["primaryKey"] ? def["primaryKey"](op) : void 0
+			}));
+		}
+	};
+};
+const Actor = {
+	make,
+	toLayer,
+	Live,
+	Test
+};
+const fromRpcs = (name, rpcs) => ({
+	_tag: "RawActorDefinition",
+	name,
+	entity: Entity.make(name, rpcs)
+});
+//#endregion
+export { Actor, fromRpcs };

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+import { ActorRef, OperationError, OperationOutput } from "./actor.js";
+export { type ActorRef, type OperationError, type OperationOutput };

package/dist/handlers.d.ts

@@ -0,0 +1,2 @@
+import { HandlerOptions } from "./actor.js";
+export { type HandlerOptions };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { CastReceipt, Defect, Failure, Interrupted, PeekResult, Pending, Success, isFailure, isPending, isSuccess, isTerminal, makeCastReceipt } from "./receipt.js";
+import { Actor, ActorMeta, ActorObject, ActorRef, HandlerOptions, OperationBrand, OperationDef, OperationDefs, OperationError, OperationOutput, fromRpcs } from "./actor.js";
+import { NoPrimaryKeyError, peek, watch } from "./peek.js";
+import { observability_d_exports } from "./observability.js";
+import { workflow_d_exports } from "./workflow.js";
+export { Actor, type ActorMeta, type ActorObject, type ActorRef, CastReceipt, Defect, Failure, type HandlerOptions, Interrupted, NoPrimaryKeyError, observability_d_exports as Observability, type OperationBrand, type OperationDef, type OperationDefs, type OperationError, type OperationOutput, type PeekResult, Pending, Success, workflow_d_exports as Workflow, fromRpcs, isFailure, isPending, isSuccess, isTerminal, makeCastReceipt, peek, watch };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { CastReceipt, Defect, Failure, Interrupted, Pending, Success, isFailure, isPending, isSuccess, isTerminal, makeCastReceipt } from "./receipt.js";
+import { Actor, fromRpcs } from "./actor.js";
+import { NoPrimaryKeyError, peek, watch } from "./peek.js";
+import { observability_exports } from "./observability.js";
+import { workflow_exports } from "./workflow.js";
+export { Actor, CastReceipt, Defect, Failure, Interrupted, NoPrimaryKeyError, observability_exports as Observability, Pending, Success, workflow_exports as Workflow, fromRpcs, isFailure, isPending, isSuccess, isTerminal, makeCastReceipt, peek, watch };

package/dist/observability.d.ts

@@ -0,0 +1,9 @@
+import { CurrentAddress } from "effect/unstable/cluster/Entity";
+
+//#region src/observability.d.ts
+declare namespace observability_d_exports {
+  export { CurrentAddress, defaultSpanAttributes };
+}
+declare const defaultSpanAttributes: (actorName: string) => Record<string, string>;
+//#endregion
+export { CurrentAddress, defaultSpanAttributes, observability_d_exports };

package/dist/observability.js

@@ -0,0 +1,13 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { CurrentAddress } from "effect/unstable/cluster/Entity";
+//#region src/observability.ts
+var observability_exports = /* @__PURE__ */ __exportAll({
+	CurrentAddress: () => CurrentAddress,
+	defaultSpanAttributes: () => defaultSpanAttributes
+});
+const defaultSpanAttributes = (actorName) => ({
+	"actor.name": actorName,
+	"actor.library": "effect-encore"
+});
+//#endregion
+export { CurrentAddress, defaultSpanAttributes, observability_exports };

package/dist/peek.d.ts

@@ -0,0 +1,19 @@
+import { CastReceipt, PeekResult } from "./receipt.js";
+import { ActorObject, OperationDefs } from "./actor.js";
+import { MessageStorage, Sharding } from "effect/unstable/cluster";
+import { Duration, Effect, Stream } from "effect";
+import { MalformedMessage, PersistenceError } from "effect/unstable/cluster/ClusterError";
+
+//#region src/peek.d.ts
+declare class NoPrimaryKeyError {
+  readonly receipt: CastReceipt;
+  readonly _tag = "NoPrimaryKeyError";
+  readonly message: string;
+  constructor(receipt: CastReceipt);
+}
+declare const peek: <Name extends string, Defs extends OperationDefs>(actor: ActorObject<Name, Defs>, receipt: CastReceipt) => Effect.Effect<PeekResult, PersistenceError | MalformedMessage | NoPrimaryKeyError, MessageStorage.MessageStorage | Sharding.Sharding>;
+declare const watch: <Name extends string, Defs extends OperationDefs>(actor: ActorObject<Name, Defs>, receipt: CastReceipt, options?: {
+  readonly interval?: Duration.Input;
+}) => Stream.Stream<PeekResult, PersistenceError | MalformedMessage | NoPrimaryKeyError, MessageStorage.MessageStorage | Sharding.Sharding>;
+//#endregion
+export { NoPrimaryKeyError, peek, watch };

package/dist/peek.js

@@ -0,0 +1,61 @@
+import { Defect, Failure, Interrupted, Pending, Success, isTerminal } from "./receipt.js";
+import { EntityAddress, EntityId, EntityType, MessageStorage, Sharding } from "effect/unstable/cluster";
+import { Duration, Effect, Option, Schedule, Stream } from "effect";
+//#region src/peek.ts
+var NoPrimaryKeyError = class {
+	constructor(receipt) {
+		this.receipt = receipt;
+		this._tag = "NoPrimaryKeyError";
+		this.message = `Cannot peek receipt for ${receipt.actorType}.${receipt.operation}: no primaryKey defined on operation`;
+	}
+};
+const peek = (actor, receipt) => {
+	const op = actor._meta.definitions[receipt.operation];
+	if (!op || !op["primaryKey"] || !receipt.primaryKey) return Effect.fail(new NoPrimaryKeyError(receipt));
+	const primaryKey = receipt.primaryKey;
+	return Effect.gen(function* () {
+		const sharding = yield* Sharding.Sharding;
+		const storage = yield* MessageStorage.MessageStorage;
+		const entityId = EntityId.make(receipt.entityId);
+		const group = actor._meta.entity.getShardGroup(entityId);
+		const shardId = sharding.getShardId(entityId, group);
+		const address = EntityAddress.make({
+			entityType: EntityType.make(actor._meta.name),
+			entityId,
+			shardId
+		});
+		const maybeRequestId = yield* storage.requestIdForPrimaryKey({
+			address,
+			tag: receipt.operation,
+			id: primaryKey
+		});
+		if (Option.isNone(maybeRequestId)) return Pending;
+		const replies = yield* storage.repliesForUnfiltered([maybeRequestId.value]);
+		const last = replies[replies.length - 1];
+		if (!last || last._tag !== "WithExit") return Pending;
+		return mapExitToPeekResult(last.exit);
+	});
+};
+const watch = (actor, receipt, options) => {
+	const interval = options?.interval ?? Duration.millis(200);
+	return Stream.fromEffectSchedule(peek(actor, receipt), Schedule.spaced(interval)).pipe(Stream.changesWith(peekResultEquals), Stream.takeUntil(isTerminal));
+};
+const peekResultEquals = (a, b) => {
+	if (a._tag !== b._tag) return false;
+	if (a._tag === "Success" && b._tag === "Success") return a.value === b.value;
+	if (a._tag === "Failure" && b._tag === "Failure") return a.error === b.error;
+	if (a._tag === "Defect" && b._tag === "Defect") return a.cause === b.cause;
+	return true;
+};
+const mapExitToPeekResult = (exit) => {
+	if (exit._tag === "Success") return Success(exit.value);
+	const cause = exit.cause[0];
+	if (!cause) return Pending;
+	switch (cause._tag) {
+		case "Fail": return Failure(cause.error);
+		case "Die": return Defect(cause.defect);
+		case "Interrupt": return Interrupted;
+	}
+};
+//#endregion
+export { NoPrimaryKeyError, peek, watch };

package/dist/receipt.d.ts

@@ -0,0 +1,50 @@
+import { Schema } from "effect";
+
+//#region src/receipt.d.ts
+declare const CastReceipt_base: Schema.Class<CastReceipt, Schema.Struct<{
+  readonly _tag: Schema.Literal<"CastReceipt">;
+  readonly actorType: Schema.String;
+  readonly entityId: Schema.String;
+  readonly operation: Schema.String;
+  readonly primaryKey: Schema.optional<Schema.String>;
+}>, {}>;
+declare class CastReceipt extends CastReceipt_base {}
+declare const makeCastReceipt: (options: {
+  readonly actorType: string;
+  readonly entityId: string;
+  readonly operation: string;
+  readonly primaryKey?: string | undefined;
+}) => CastReceipt;
+type PeekResult<A = unknown, E = unknown> = {
+  readonly _tag: "Pending";
+} | {
+  readonly _tag: "Success";
+  readonly value: A;
+} | {
+  readonly _tag: "Failure";
+  readonly error: E;
+} | {
+  readonly _tag: "Interrupted";
+} | {
+  readonly _tag: "Defect";
+  readonly cause: unknown;
+};
+declare const Pending: PeekResult;
+declare const Success: <A>(value: A) => PeekResult<A, never>;
+declare const Failure: <E>(error: E) => PeekResult<never, E>;
+declare const Interrupted: PeekResult;
+declare const Defect: (cause: unknown) => PeekResult;
+declare const isPending: <A, E>(result: PeekResult<A, E>) => result is {
+  _tag: "Pending";
+};
+declare const isSuccess: <A, E>(result: PeekResult<A, E>) => result is {
+  _tag: "Success";
+  value: A;
+};
+declare const isFailure: <A, E>(result: PeekResult<A, E>) => result is {
+  _tag: "Failure";
+  error: E;
+};
+declare const isTerminal: <A, E>(result: PeekResult<A, E>) => boolean;
+//#endregion
+export { CastReceipt, Defect, Failure, Interrupted, PeekResult, Pending, Success, isFailure, isPending, isSuccess, isTerminal, makeCastReceipt };

package/dist/receipt.js

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+//#region src/receipt.ts
+var CastReceipt = class extends Schema.Class("effect-encore/CastReceipt")({
+	_tag: Schema.Literal("CastReceipt"),
+	actorType: Schema.String,
+	entityId: Schema.String,
+	operation: Schema.String,
+	primaryKey: Schema.optional(Schema.String)
+}) {};
+const makeCastReceipt = (options) => new CastReceipt({
+	_tag: "CastReceipt",
+	actorType: options.actorType,
+	entityId: options.entityId,
+	operation: options.operation,
+	primaryKey: options.primaryKey
+});
+const Pending = { _tag: "Pending" };
+const Success = (value) => ({
+	_tag: "Success",
+	value
+});
+const Failure = (error) => ({
+	_tag: "Failure",
+	error
+});
+const Interrupted = { _tag: "Interrupted" };
+const Defect = (cause) => ({
+	_tag: "Defect",
+	cause
+});
+const isPending = (result) => result._tag === "Pending";
+const isSuccess = (result) => result._tag === "Success";
+const isFailure = (result) => result._tag === "Failure";
+const isTerminal = (result) => result._tag !== "Pending";
+//#endregion
+export { CastReceipt, Defect, Failure, Interrupted, Pending, Success, isFailure, isPending, isSuccess, isTerminal, makeCastReceipt };

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+import { ActorRef } from "./actor.js";
+export { type ActorRef };

package/dist/workflow.d.ts

@@ -0,0 +1,45 @@
+import { Effect, Layer } from "effect";
+import { Activity, DurableDeferred, Workflow } from "effect/unstable/workflow";
+
+//#region src/workflow.d.ts
+declare namespace workflow_d_exports {
+  export { Activity, DurableDeferred, WorkflowDefinition, WorkflowReceipt, WorkflowRef, makeWorkflowReceipt, workflow, workflowClient, workflowHandlers, workflowPoll };
+}
+interface WorkflowDefinition<Name extends string = string> {
+  readonly _tag: "WorkflowDefinition";
+  readonly name: Name;
+  readonly workflow: Workflow.Any;
+}
+interface WorkflowReceipt<Type extends string = string> {
+  readonly _tag: "WorkflowReceipt";
+  readonly workflowName: Type;
+  readonly executionId: string;
+}
+declare const makeWorkflowReceipt: <Type extends string>(workflowName: Type, executionId: string) => WorkflowReceipt<Type>;
+declare const workflow: <const Name extends string>(name: Name, options: {
+  readonly payload: Record<string, unknown>;
+  readonly idempotencyKey: (payload: Record<string, unknown>) => string;
+  readonly success?: unknown;
+  readonly error?: unknown;
+}) => WorkflowDefinition<Name>;
+type WorkflowRef<Name extends string = string> = {
+  readonly call: (payload: unknown) => Effect.Effect<unknown, unknown>;
+  readonly cast: (payload: unknown) => Effect.Effect<WorkflowReceipt<Name>, unknown>;
+  readonly interrupt: () => Effect.Effect<void>;
+  readonly resume: () => Effect.Effect<void>;
+};
+declare const workflowClient: <Name extends string>(def: WorkflowDefinition<Name>) => ((executionId: string) => WorkflowRef<Name>);
+declare const workflowPoll: <Name extends string>(def: WorkflowDefinition<Name>, executionId: string) => Effect.Effect<{
+  _tag: "Pending";
+} | {
+  _tag: "Success";
+  value: unknown;
+} | {
+  _tag: "Failure";
+  error: unknown;
+} | {
+  _tag: "Suspended";
+}, never, never>;
+declare const workflowHandlers: <Name extends string>(def: WorkflowDefinition<Name>, handler: Function) => Layer.Layer<never, never, never>;
+//#endregion
+export { Activity, DurableDeferred, WorkflowDefinition, WorkflowReceipt, WorkflowRef, makeWorkflowReceipt, workflow, workflowClient, workflowHandlers, workflowPoll, workflow_d_exports };