effect-encore 0.1.0

package/dist/workflow.js

@@ -0,0 +1,67 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Effect } from "effect";
+import { Activity, DurableDeferred, Workflow } from "effect/unstable/workflow";
+//#region src/workflow.ts
+var workflow_exports = /* @__PURE__ */ __exportAll({
+	Activity: () => Activity,
+	DurableDeferred: () => DurableDeferred,
+	makeWorkflowReceipt: () => makeWorkflowReceipt,
+	workflow: () => workflow,
+	workflowClient: () => workflowClient,
+	workflowHandlers: () => workflowHandlers,
+	workflowPoll: () => workflowPoll
+});
+const makeWorkflowReceipt = (workflowName, executionId) => ({
+	_tag: "WorkflowReceipt",
+	workflowName,
+	executionId
+});
+const workflow = (name, options) => {
+	const wfOptions = {
+		name,
+		payload: options.payload,
+		idempotencyKey: options.idempotencyKey
+	};
+	if (options.success) wfOptions["success"] = options.success;
+	if (options.error) wfOptions["error"] = options.error;
+	return {
+		_tag: "WorkflowDefinition",
+		name,
+		workflow: Workflow.make(wfOptions)
+	};
+};
+const workflowClient = (def) => {
+	const wf = def.workflow;
+	return (_executionId) => ({
+		call: (payload) => wf.execute(payload),
+		cast: (payload) => Effect.map(wf.execute(payload, { discard: true }), (execId) => makeWorkflowReceipt(def.name, execId)),
+		interrupt: () => wf.interrupt(_executionId),
+		resume: () => wf.resume(_executionId)
+	});
+};
+const workflowPoll = (def, executionId) => {
+	const wf = def.workflow;
+	return Effect.map(wf.poll(executionId), (optResult) => {
+		const opt = optResult;
+		if (opt._tag === "None") return { _tag: "Pending" };
+		const result = opt.value;
+		if (result?._tag === "Suspended") return { _tag: "Suspended" };
+		if (result?._tag === "Complete") {
+			const exit = result.exit;
+			if (exit?._tag === "Success") return {
+				_tag: "Success",
+				value: exit.value
+			};
+			return {
+				_tag: "Failure",
+				error: exit?.cause
+			};
+		}
+		return { _tag: "Pending" };
+	});
+};
+const workflowHandlers = (def, handler) => {
+	return def.workflow.toLayer(handler);
+};
+//#endregion
+export { Activity, DurableDeferred, makeWorkflowReceipt, workflow, workflowClient, workflowHandlers, workflowPoll, workflow_exports };

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "effect-encore",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cevr/effect-encore.git"
+  },
+  "files": [
+    "dist",
+    "v3/dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./v3": {
+      "import": {
+        "types": "./v3/dist/index.d.ts",
+        "default": "./v3/dist/index.js"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "typecheck:v3": "tsgo --noEmit -p v3/tsconfig.json",
+    "lint": "concurrently -n ox,effect -c yellow,blue \"oxlint\" \"bun run lint:effect\"",
+    "lint:ox": "oxlint",
+    "lint:effect": "effect-language-service diagnostics --project tsconfig.lsp.json",
+    "lint:fix": "oxlint --fix",
+    "fmt": "oxfmt",
+    "fmt:check": "oxfmt --check",
+    "test": "bun test",
+    "test:v3": "bun test --tsconfig-override=v3/tsconfig.json v3/test/",
+    "test:watch": "bun test --watch",
+    "gate": "concurrently -n type,style,build,test -c blue,yellow,cyan,green \"bun run typecheck\" \"bun run lint && bun run fmt\" \"bun run build\" \"bun run test\"",
+    "build": "tsdown && tsdown --config v3/tsdown.config.ts",
+    "release": "bun run build && changeset publish",
+    "version": "changeset version",
+    "prepare": "lefthook install"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.30.0",
+    "@effect/cluster": "^0.56.2",
+    "@effect/language-service": "^0.85.1",
+    "@effect/rpc": "^0.73.0",
+    "@effect/workflow": "^0.18.0",
+    "@types/bun": "^1.3.11",
+    "@typescript/native-preview": "^7.0.0-dev.20260410.1",
+    "concurrently": "^9.2.1",
+    "effect": "4.0.0-beta.46",
+    "effect-bun-test": "^0.3.0",
+    "effect-v3": "npm:effect@^3.21.0",
+    "lefthook": "^2.1.4",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "tsdown": "^0.21.7",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@effect/cluster": "*",
+    "@effect/rpc": "*",
+    "@effect/workflow": "*",
+    "effect": ">=4.0.0-beta.46"
+  },
+  "peerDependenciesMeta": {
+    "@effect/cluster": {
+      "optional": true
+    },
+    "@effect/rpc": {
+      "optional": true
+    },
+    "@effect/workflow": {
+      "optional": true
+    }
+  }
+}

package/v3/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/v3/dist/actor.d.ts

@@ -0,0 +1,113 @@
+import { CastReceipt } from "./receipt.js";
+import { Entity, Sharding, ShardingConfig } from "@effect/cluster";
+import { Rpc } from "@effect/rpc";
+import { Context, DateTime, Effect, Layer, Schema, Scope } from "effect";
+
+//#region src/actor.d.ts
+interface OperationDef {
+  readonly payload?: Schema.Schema.Any | Schema.Struct.Fields;
+  readonly success?: Schema.Schema.Any;
+  readonly error?: Schema.Schema.Any;
+  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.Schema.Any;
+} ? 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.Schema.Any;
+} ? S : typeof Schema.Void;
+type ErrorOf<C extends OperationDef> = C extends {
+  readonly error: infer E extends Schema.Schema.Any;
+} ? 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.Schema.Any ? F[K] : never> } : C extends {
+  readonly payload: infer P extends Schema.Schema.Any;
+} ? 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.Schema.Any ? F[K] : never> } ? [] : [payload: { readonly [K in keyof F]: Schema.Schema.Type<F[K] extends Schema.Schema.Any ? F[K] : never> }] : C extends {
+  readonly payload: infer _P extends Schema.Schema.Any;
+} ? [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.Tag<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/v3/dist/actor.js

@@ -0,0 +1,127 @@
+import { makeCastReceipt } from "./receipt.js";
+import { ClusterSchema, Entity } from "@effect/cluster";
+import * as DeliverAt from "@effect/cluster/DeliverAt";
+import { Rpc } from "@effect/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.GenericTag(`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/v3/dist/client.d.ts

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

package/v3/dist/handlers.d.ts

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

package/v3/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/v3/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/v3/dist/observability.d.ts

@@ -0,0 +1,9 @@
+import { CurrentAddress } from "@effect/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/v3/dist/observability.js

@@ -0,0 +1,13 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { CurrentAddress } from "@effect/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/v3/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/cluster";
+import { Duration, Effect, Stream } from "effect";
+import { MalformedMessage, PersistenceError } from "@effect/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.DurationInput;
+}) => Stream.Stream<PeekResult, PersistenceError | MalformedMessage | NoPrimaryKeyError, MessageStorage.MessageStorage | Sharding.Sharding>;
+//#endregion
+export { NoPrimaryKeyError, peek, watch };

package/v3/dist/peek.js

@@ -0,0 +1,72 @@
+import { Defect, Failure, Interrupted, Pending, Success, isTerminal } from "./receipt.js";
+import { EntityAddress, EntityId, MessageStorage, Sharding } from "@effect/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: 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 mapCauseEncodedToPeekResult(last.exit);
+	});
+};
+const watch = (actor, receipt, options) => {
+	const interval = options?.interval ?? Duration.millis(200);
+	return Stream.repeatEffectWithSchedule(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 mapCauseEncodedToPeekResult = (exit) => {
+	if (exit._tag === "Success") return Success(exit.value);
+	const first = findFirstCause(exit.cause);
+	if (!first) return Pending;
+	switch (first._tag) {
+		case "Fail": return Failure(first.error);
+		case "Die": return Defect(first.defect);
+		case "Interrupt": return Interrupted;
+		default: return Pending;
+	}
+};
+const findFirstCause = (cause) => {
+	switch (cause._tag) {
+		case "Fail":
+		case "Die":
+		case "Interrupt": return cause;
+		case "Empty": return null;
+		case "Sequential":
+		case "Parallel": return findFirstCause(cause.left) ?? findFirstCause(cause.right);
+	}
+};
+//#endregion
+export { NoPrimaryKeyError, peek, watch };

package/v3/dist/receipt.d.ts

@@ -0,0 +1,66 @@
+import { Schema } from "effect";
+
+//#region src/receipt.d.ts
+declare const CastReceipt_base: Schema.Class<CastReceipt, {
+  _tag: Schema.Literal<["CastReceipt"]>;
+  actorType: typeof Schema.String;
+  entityId: typeof Schema.String;
+  operation: typeof Schema.String;
+  primaryKey: Schema.optional<typeof Schema.String>;
+}, Schema.Struct.Encoded<{
+  _tag: Schema.Literal<["CastReceipt"]>;
+  actorType: typeof Schema.String;
+  entityId: typeof Schema.String;
+  operation: typeof Schema.String;
+  primaryKey: Schema.optional<typeof Schema.String>;
+}>, never, {
+  readonly _tag: "CastReceipt";
+} & {
+  readonly actorType: string;
+} & {
+  readonly entityId: string;
+} & {
+  readonly operation: string;
+} & {
+  readonly primaryKey?: 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/v3/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/v3/dist/testing.d.ts

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