@effect/cluster 0.0.0-snapshot-d33d8b050b8e3c87dcde9587083e6c1cf733f72b

package/dist/dts/Messenger.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Effect from "effect/Effect";
+import type * as Message from "./Message.js";
+import type * as ShardingException from "./ShardingException.js";
+/**
+ * An interface to communicate with a remote entity.
+ *
+ * @tparam Msg the type of message that can be sent to this entity type
+ * @since 1.0.0
+ * @category models
+ */
+export interface Messenger<Msg extends Message.Message.Any> {
+    /**
+     * Send a message without waiting for a response (fire and forget)
+     *
+     * You can use Effect timeout to get send timeouts. The default behaviour is to send the message indifinetely
+     *
+     * @since 1.0.0
+     */
+    sendDiscard(entityId: string): (message: Msg) => Effect.Effect<void, ShardingException.ShardingException>;
+    /**
+     * Send a message and wait for a response.
+     *
+     * You can use Effect timeout to get send timeouts. The default behaviour is to send the message indifinetely
+     *
+     * @since 1.0.0
+     */
+    send(entityId: string): <A extends Msg>(message: A) => Effect.Effect<Message.Message.Success<A>, ShardingException.ShardingException | Message.Message.Error<A>>;
+}
+//# sourceMappingURL=Messenger.d.ts.map

package/dist/dts/Messenger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messenger.d.ts","sourceRoot":"","sources":["../../src/Messenger.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAEhE;;;;;;GAMG;AACH,MAAM,WAAW,SAAS,CAAC,GAAG,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG;IACxD;;;;;;OAMG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,OAAO,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAA;IAEzG;;;;;;OAMG;IACH,IAAI,CACF,QAAQ,EAAE,MAAM,GACf,CAAC,CAAC,SAAS,GAAG,EACf,OAAO,EAAE,CAAC,KACP,MAAM,CAAC,MAAM,CAChB,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAC1B,iBAAiB,CAAC,iBAAiB,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAC/D,CAAA;CACF"}

package/dist/dts/Pod.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @since 1.0.0
+ */
+import * as Schema from "@effect/schema/Schema";
+import * as PodAddress from "./PodAddress.js";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const PodTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type PodTypeId = typeof PodTypeId;
+declare const Pod_base: Schema.Class<Pod, {
+    [PodTypeId]: Schema.PropertySignature<":", typeof PodTypeId, "@effect/cluster/Pod", ":", "@effect/cluster/Pod", false, never>;
+    address: Schema.Schema<PodAddress.PodAddress, PodAddress.PodAddress.Encoded, never>;
+    version: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    [PodTypeId]: Schema.PropertySignature<":", typeof PodTypeId, "@effect/cluster/Pod", ":", "@effect/cluster/Pod", false, never>;
+    address: Schema.Schema<PodAddress.PodAddress, PodAddress.PodAddress.Encoded, never>;
+    version: typeof Schema.String;
+}>, never, {
+    readonly [PodTypeId]: typeof PodTypeId;
+} & {
+    readonly address: PodAddress.PodAddress;
+} & {
+    readonly version: string;
+}, {}, {}>;
+/**
+ * A pod is an application server that is able to run entities. A pod can run multiple entities,
+ * but a single entity will live on a given pod at a time.
+ * Since this is an application server, it needs to have an unique identifier where it's addressed (PodAddress),
+ * and has a version of the application that's running on it.
+ * Version is used during the rebalance phase to give priority to newer application servers and slowly kill older ones.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare class Pod extends Pod_base {
+    /**
+     * @since 1.0.0
+     */
+    toString(): string;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace Pod {
+    /**
+     * This is the shape that a Pod is represented over the wire.
+     *
+     * @since 1.0.0
+     * @category models
+     */
+    interface Encoded extends Schema.Schema.Encoded<typeof Pod> {
+    }
+}
+/**
+ * Given a value, ensures that it's a valid Pod.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare function isPod(value: unknown): value is Pod;
+/**
+ * Constructs a Pod from it's identifing PodAddress and application server version.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function make(address: PodAddress.PodAddress, version: string): Pod;
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export declare const schema: Schema.Schema<Pod, Pod.Encoded>;
+export {};
+//# sourceMappingURL=Pod.d.ts.map

package/dist/dts/Pod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pod.d.ts","sourceRoot":"","sources":["../../src/Pod.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAE/C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAK7C;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,OAAO,MAAiC,CAAA;AAEhE;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA;;;;;;;;;;;;;;;;AAKxC;;;;;;;;;GASG;AACH,qBAAa,GAAI,SAAQ,QAIvB;IACA;;OAEG;IACH,QAAQ;CAGT;AAED;;;GAGG;AACH,yBAAiB,GAAG,CAAC;IACnB;;;;;OAKG;IACH,UAAiB,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC;KAAG;CACtE;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAOlD;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAEzE;AAED;;;GAGG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,CAChC,GAAG,EACH,GAAG,CAAC,OAAO,CACW,CAAA"}

package/dist/dts/PodAddress.d.ts

@@ -0,0 +1,80 @@
+/**
+ * @since 1.0.0
+ */
+import * as Schema from "@effect/schema/Schema";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const PodAddressTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type PodAddressTypeId = typeof PodAddressTypeId;
+declare const PodAddress_base: Schema.Class<PodAddress, {
+    [PodAddressTypeId]: Schema.PropertySignature<":", typeof PodAddressTypeId, "@effect/cluster/PodAddress", ":", "@effect/cluster/PodAddress", false, never>;
+    host: typeof Schema.String;
+    port: typeof Schema.Number;
+}, Schema.Struct.Encoded<{
+    [PodAddressTypeId]: Schema.PropertySignature<":", typeof PodAddressTypeId, "@effect/cluster/PodAddress", ":", "@effect/cluster/PodAddress", false, never>;
+    host: typeof Schema.String;
+    port: typeof Schema.Number;
+}>, never, {
+    readonly [PodAddressTypeId]: typeof PodAddressTypeId;
+} & {
+    readonly host: string;
+} & {
+    readonly port: number;
+}, {}, {}>;
+/**
+ * A PodAddress is a unique identifier of a Pod (application server).
+ * It is conventially built by using an address and a port, so that messaging implementations may use directly the
+ * PodAddress to know how to connect to the specific Pod.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare class PodAddress extends PodAddress_base {
+    /**
+     * @since 1.0.0
+     */
+    toString(): string;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace PodAddress {
+    /**
+     * This is the shape one PodAddress has over the wire.
+     *
+     * @since 1.0.0
+     * @category models
+     */
+    interface Encoded extends Schema.Schema.Encoded<typeof PodAddress> {
+    }
+}
+/**
+ * Constructs a PodAddress from an host and a port.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function make(host: string, port: number): PodAddress;
+/**
+ * Ensures that the given value is a valid PodAddress.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare function isPodAddress(value: unknown): value is PodAddress;
+/**
+ * This is the schema for a PodAddress.
+ *
+ * @since 1.0.0
+ * @category schema
+ */
+export declare const schema: Schema.Schema<PodAddress, PodAddress.Encoded>;
+export {};
+//# sourceMappingURL=PodAddress.d.ts.map

package/dist/dts/PodAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PodAddress.d.ts","sourceRoot":"","sources":["../../src/PodAddress.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAM/C;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAwC,CAAA;AAK9E;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;;;;;;;;;;;;;;;;AAEtD;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,eAI9B;IACA;;OAEG;IACH,QAAQ;CAGT;AAED;;;GAGG;AACH,yBAAiB,UAAU,CAAC;IAC1B;;;;;OAKG;IACH,UAAiB,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,UAAU,CAAC;KAAG;CAC7E;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAE3D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAOhE;AAED;;;;;GAKG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,CAChC,UAAU,EACV,UAAU,CAAC,OAAO,CACW,CAAA"}

package/dist/dts/Pods.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as HashSet from "effect/HashSet";
+import type * as Layer from "effect/Layer";
+import type * as MessageState from "./MessageState.js";
+import type * as PodAddress from "./PodAddress.js";
+import type * as SerializedEnvelope from "./SerializedEnvelope.js";
+import type * as SerializedMessage from "./SerializedMessage.js";
+import type * as ShardId from "./ShardId.js";
+import type * as ShardingException from "./ShardingException.js";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const PodsTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type PodsTypeId = typeof PodsTypeId;
+/**
+ * An interface to communicate with remote pods.
+ * This is used by the Shard Manager for assigning and unassigning shards.
+ * This is also used by pods for internal communication (forward messages to each other).
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Pods {
+    /**
+     * @since 1.0.0
+     */
+    readonly [PodsTypeId]: PodsTypeId;
+    /**
+     * Notify a pod that it was assigned a list of shards
+     * @since 1.0.0
+     */
+    readonly assignShards: (pod: PodAddress.PodAddress, shards: HashSet.HashSet<ShardId.ShardId>) => Effect.Effect<void, ShardingException.PodUnavailableException>;
+    /**
+     * Notify a pod that it was unassigned a list of shards
+     * @since 1.0.0
+     */
+    readonly unassignShards: (pod: PodAddress.PodAddress, shards: HashSet.HashSet<ShardId.ShardId>) => Effect.Effect<void, ShardingException.PodUnavailableException>;
+    /**
+     * Check that a pod is responsive
+     * @since 1.0.0
+     */
+    readonly ping: (pod: PodAddress.PodAddress) => Effect.Effect<void, ShardingException.PodUnavailableException>;
+    /**
+     * Send a message to a pod and receive its message state
+     * @since 1.0.0
+     */
+    readonly sendAndGetState: (pod: PodAddress.PodAddress, envelope: SerializedEnvelope.SerializedEnvelope) => Effect.Effect<MessageState.MessageState<SerializedMessage.SerializedMessage>, ShardingException.ShardingException>;
+}
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const Pods: Context.Tag<Pods, Pods>;
+/**
+ * Constructs a Pods service from its implementation
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const make: (args: Omit<Pods, typeof PodsTypeId>) => Pods;
+/**
+ * A layer that creates a service that does nothing when called.
+ * Useful for testing ShardManager or when using Sharding.local.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const noop: Layer.Layer<Pods>;
+//# sourceMappingURL=Pods.d.ts.map

package/dist/dts/Pods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pods.d.ts","sourceRoot":"","sources":["../../src/Pods.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAClE,OAAO,KAAK,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,KAAK,OAAO,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAEhE;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,MAA4B,CAAA;AAE5D;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAA;AAE1C;;;;;;;GAOG;AACH,MAAM,WAAW,IAAI;IACnB;;OAEG;IACH,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;IAEjC;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,CACrB,GAAG,EAAE,UAAU,CAAC,UAAU,EAC1B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,iBAAiB,CAAC,uBAAuB,CAAC,CAAA;IAEnE;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,CACvB,GAAG,EAAE,UAAU,CAAC,UAAU,EAC1B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,iBAAiB,CAAC,uBAAuB,CAAC,CAAA;IAEnE;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,iBAAiB,CAAC,uBAAuB,CAAC,CAAA;IAE7G;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,CACxB,GAAG,EAAE,UAAU,CAAC,UAAU,EAC1B,QAAQ,EAAE,kBAAkB,CAAC,kBAAkB,KAC5C,MAAM,CAAC,MAAM,CAChB,YAAY,CAAC,YAAY,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,EAC9D,iBAAiB,CAAC,iBAAiB,CACpC,CAAA;CACF;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAoB,CAAA;AAE7D;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,UAAU,CAAC,KAAK,IAAoB,CAAA;AAEhF;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,IAAI,CAAiB,CAAA"}

package/dist/dts/PodsHealth.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import type * as PodAddress from "./PodAddress.js";
+import type * as Pods from "./Pods.js";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const PodsHealthTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type PodsHealthTypeId = typeof PodsHealthTypeId;
+/**
+ * An interface to check a pod's health.
+ * This is used when a pod is unresponsive, to check if it should be unassigned all its shards or not.
+ * If the pod is alive, shards will not be unassigned because the pods might still be processing messages and might be responsive again.
+ * If the pod is not alive, shards can be safely reassigned somewhere else.
+ * A typical implementation for this is using k8s to check if the pod still exists.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface PodsHealth {
+    /**
+     * @since 1.0.0
+     */
+    readonly [PodsHealthTypeId]: PodsHealthTypeId;
+    /**
+     * Check if a pod is still alive.
+     * @since 1.0.0
+     */
+    readonly isAlive: (podAddress: PodAddress.PodAddress) => Effect.Effect<boolean>;
+}
+/**
+ * Constructs a PodsHealth from its implementation
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: (args: Omit<PodsHealth, typeof PodsHealthTypeId>) => PodsHealth;
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const PodsHealth: Context.Tag<PodsHealth, PodsHealth>;
+/**
+ * A layer that considers pods as always alive.
+ * This is useful for testing only.
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const noop: Layer.Layer<PodsHealth>;
+/**
+ * A layer that pings the pod directly to check if it's alive.
+ * This is useful for developing and testing but not reliable in production.
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const local: Layer.Layer<PodsHealth, never, Pods.Pods>;
+//# sourceMappingURL=PodsHealth.d.ts.map

package/dist/dts/PodsHealth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PodsHealth.d.ts","sourceRoot":"","sources":["../../src/PodsHealth.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAClD,OAAO,KAAK,KAAK,IAAI,MAAM,WAAW,CAAA;AAEtC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAkC,CAAA;AAExE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;AAEtD;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IAE7C;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;CAChF;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,gBAAgB,CAAC,KAAK,UAA0B,CAAA;AAElG;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,UAAU,CAA0B,CAAA;AAErF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAiB,CAAA;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,CAAkB,CAAA"}

package/dist/dts/PoisonPill.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @since 1.0.0
+ */
+import * as Schema from "@effect/schema/Schema";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const PoisonPillTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type PoisonPillTypeId = typeof PoisonPillTypeId;
+/**
+ * @since 1.0.0
+ */
+export declare namespace PoisonPill {
+    /**
+     * This is the shape that a PoisonPill takes over the wire.
+     *
+     * @since 1.0.0
+     * @category models
+     */
+    interface Encoded extends Schema.Schema.Encoded<typeof PoisonPill> {
+    }
+}
+declare const PoisonPill_base: Schema.Class<PoisonPill, {
+    [PoisonPillTypeId]: Schema.PropertySignature<":", typeof PoisonPillTypeId, "@effect/cluster/PoisonPill", ":", "@effect/cluster/PoisonPill", false, never>;
+}, Schema.Struct.Encoded<{
+    [PoisonPillTypeId]: Schema.PropertySignature<":", typeof PoisonPillTypeId, "@effect/cluster/PoisonPill", ":", "@effect/cluster/PoisonPill", false, never>;
+}>, never, {
+    readonly [PoisonPillTypeId]: typeof PoisonPillTypeId;
+}, {}, {}>;
+/**
+ * A PoisonPill is a special value that tells a behaviour entity to shut itself down.
+ * PoisonPill is handled only when you are using a Queue-based RecipientBehaviour.
+ * Other RecipientBehaviour such as fromFunctionEffect would not care about PoisonPill.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare class PoisonPill extends PoisonPill_base {
+}
+/**
+ * Constructs a new PosionPill
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: Effect.Effect<PoisonPill>;
+/**
+ * Checks if the given value is a PoisonPill.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare function isPoisonPill(value: unknown): value is PoisonPill;
+/**
+ * This is the schema for a PoisonPill that is used to encode the value over the wire.
+ * This is useful if you want a behavior that can be shut down from an external message.
+ *
+ * @since 1.0.0
+ * @category schema
+ */
+export declare const schema: Schema.Schema<PoisonPill, PoisonPill.Encoded>;
+/**
+ * Attempts to take a message from the queue in the same way Queue.take does.
+ * If the result is a PoisonPill, it will interrupt the effect.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare function takeOrInterrupt<Req>(dequeue: Queue.Dequeue<Req | PoisonPill>): Effect.Effect<Req>;
+export {};
+//# sourceMappingURL=PoisonPill.d.ts.map

package/dist/dts/PoisonPill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoisonPill.d.ts","sourceRoot":"","sources":["../../src/PoisonPill.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAMrC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAwC,CAAA;AAE9E;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAA;AAKtD;;GAEG;AACH,yBAAiB,UAAU,CAAC;IAC1B;;;;;OAKG;IACH,UAAiB,OAAQ,SAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,UAAU,CAAC;KAAG;CAC7E;;;;;;;;AAED;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,eAE9B;CACD;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAE1C,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAOhE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,CAChC,UAAU,EACV,UAAU,CAAC,OAAO,CACW,CAAA;AAE/B;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EACjC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,GAAG,UAAU,CAAC,GACvC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAKpB"}

package/dist/dts/RecipientAddress.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @since 1.0.0
+ */
+import * as Schema from "@effect/schema/Schema";
+import * as Equal from "effect/Equal";
+import * as Hash from "effect/Hash";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const RecipientAddressTypeId: unique symbol;
+declare const RecipientAddress_base: Schema.Class<RecipientAddress, {
+    [RecipientAddressTypeId]: Schema.PropertySignature<":", typeof RecipientAddressTypeId, "@effect/cluster/RecipientAddress", ":", "@effect/cluster/RecipientAddress", false, never>;
+    recipientTypeName: typeof Schema.String;
+    entityId: typeof Schema.String;
+}, Schema.Struct.Encoded<{
+    [RecipientAddressTypeId]: Schema.PropertySignature<":", typeof RecipientAddressTypeId, "@effect/cluster/RecipientAddress", ":", "@effect/cluster/RecipientAddress", false, never>;
+    recipientTypeName: typeof Schema.String;
+    entityId: typeof Schema.String;
+}>, never, {
+    readonly [RecipientAddressTypeId]: typeof RecipientAddressTypeId;
+} & {
+    readonly recipientTypeName: string;
+} & {
+    readonly entityId: string;
+}, {}, {}>;
+/**
+ * A RecipientAddress uniquely identifies a RecipientType + EntityId instance.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare class RecipientAddress extends RecipientAddress_base {
+    /**
+     * @since 1.0.0
+     */
+    [Hash.symbol](): number;
+    /**
+     * @since 1.0.0
+     */
+    [Equal.symbol](this: RecipientAddress, that: Equal.Equal): boolean;
+}
+/**
+ * Ensure that given value is a RecipientAddress
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function isRecipientAddress(value: unknown): value is RecipientAddress;
+/**
+ * Given a name and a schema for the protocol, constructs an EntityType.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare function makeRecipientAddress(recipientTypeName: string, entityId: string): RecipientAddress;
+export {};
+//# sourceMappingURL=RecipientAddress.d.ts.map

package/dist/dts/RecipientAddress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecipientAddress.d.ts","sourceRoot":"","sources":["../../src/RecipientAddress.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AAKnC;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,OAAO,MAA8C,CAAA;;;;;;;;;;;;;;;;AAK1F;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,qBAMpC;IACA;;OAEG;IACH,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM;IAIvB;;OAEG;IACH,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,GAAG,OAAO;CAMnE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAG5E;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,iBAAiB,EAAE,MAAM,EACzB,QAAQ,EAAE,MAAM,GACf,gBAAgB,CAElB"}

package/dist/dts/RecipientBehaviour.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Message from "@effect/cluster/Message";
+import type * as Duration from "effect/Duration";
+import type * as Effect from "effect/Effect";
+import type * as Option from "effect/Option";
+import type * as Queue from "effect/Queue";
+import type * as Ref from "effect/Ref";
+import type * as Scope from "effect/Scope";
+import type * as MessageState from "./MessageState.js";
+import type * as PoisonPill from "./PoisonPill.js";
+import type * as RecipientBehaviourContext from "./RecipientBehaviourContext.js";
+import type * as ShardingException from "./ShardingException.js";
+/**
+ * A RecipientBehaviour describes how a specific RecipientType should behave.
+ * This is the actual implementation of what an entity should do upon receiving a Msg,
+ * this could require additional context.
+ *
+ * The scope provided in the context is controlled by the cluster EntityManager,
+ * and is used to request the shoutdown of the entity,
+ * so you can safely scope whatever resource you want to use for your behaviour
+ *  and the EntityManager will close the scope for you when the entity is shoutdown.
+ *
+ * The function returned by the RecipientBehaviour effect is what we call "offer" effect.
+ * The offer effect is used by the EntityManager to give messages to the RecipientBehaviour.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface RecipientBehaviour<Msg, R> extends Effect.Effect<(<A extends Msg>(message: A) => Effect.Effect<MessageState.MessageState<Message.Message.Exit<A>>, ShardingException.ExceptionWhileOfferingMessageException>), never, R | RecipientBehaviourContext.RecipientBehaviourContext | Scope.Scope> {
+}
+/**
+ * This are the options for an EntityBehaviour. This controls the entityMaxIdleTime,
+ * check out more on that over the ShardingConfig.
+ * This allows to override the setting for a specific entity.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export type EntityBehaviourOptions = {
+    entityMaxIdleTime?: Option.Option<Duration.Duration>;
+};
+/**
+ * This is the simplest behaviour you can have.
+ * You provide a function that given the entityId and the message, it will immediatly process it.
+ * You are then required to return a MessageState to tell the caller
+ * if the message has just arrived and will be later processed or it has been processed.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const fromFunctionEffect: <Msg extends Message.Message.Any, R>(handler: (entityId: string, message: Msg) => Effect.Effect<MessageState.MessageState<Message.Message.Exit<Msg>>, never, R>) => RecipientBehaviour<Msg, R>;
+/**
+ * This is a stateful version of fromFunctionEffect.
+ * You can provide a function to get the initialState, and then it will be passed as Ref.
+ * Everything here is just stored in memory, so eventual persistence of the state is up to you!
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const fromFunctionEffectStateful: <S, R, Msg extends Message.Message.Any, R2>(initialState: (entityId: string) => Effect.Effect<S, never, R>, handler: (entityId: string, message: Msg, stateRef: Ref.Ref<S>) => Effect.Effect<MessageState.MessageState<Message.Message.Exit<Msg>>, never, R2>) => RecipientBehaviour<Msg, R | R2>;
+/**
+ * This behaviour uses a Queue where the entity will accumulate messages to be processed,
+ * and then you can use the Dequeue to take messages and process them.
+ * A PoisonPill is provided to request interruption of the entity behaviour.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const fromInMemoryQueue: <Msg extends Message.Message.Any, R>(handler: (entityId: string, dequeue: Queue.Dequeue<Msg | PoisonPill.PoisonPill>, processed: <A extends Msg>(message: A, value: Option.Option<Message.Message.Exit<A>>) => Effect.Effect<void, never, never>) => Effect.Effect<void, never, R>) => RecipientBehaviour<Msg, R>;
+//# sourceMappingURL=RecipientBehaviour.d.ts.map

package/dist/dts/RecipientBehaviour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecipientBehaviour.d.ts","sourceRoot":"","sources":["../../src/RecipientBehaviour.ts"],"names":[],"mappings":"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"}

package/dist/dts/RecipientBehaviourContext.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type * as Message from "./Message.js";
+import type * as RecipientAddress from "./RecipientAddress.js";
+import type * as RecipientType from "./RecipientType.js";
+import type * as ShardId from "./ShardId.js";
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const RecipientBehaviourContextTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type RecipientBehaviourContextTypeId = typeof RecipientBehaviourContextTypeId;
+/**
+ * This is the context information that is available to the RecipientBehaviour and has general informations
+ * about this specific entity, like the entityId or the recipientType.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface RecipientBehaviourContext {
+    readonly [RecipientBehaviourContextTypeId]: RecipientBehaviourContextTypeId;
+    readonly recipientAddress: RecipientAddress.RecipientAddress;
+    readonly shardId: ShardId.ShardId;
+    readonly recipientType: RecipientType.RecipientType<Message.Message.Any>;
+    readonly forkShutdown: Effect.Effect<void>;
+}
+/**
+ * A tag to access current RecipientBehaviourContext
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const RecipientBehaviourContext: Context.Tag<RecipientBehaviourContext, RecipientBehaviourContext>;
+/**
+ * Creates a new RecipientBehaviourContext
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: (args: Omit<RecipientBehaviourContext, typeof RecipientBehaviourContextTypeId>) => RecipientBehaviourContext;
+/**
+ * Gets the current entityId
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const entityId: Effect.Effect<string, never, RecipientBehaviourContext>;
+/**
+ * Gets the current entityId
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const recipientAddress: Effect.Effect<RecipientAddress.RecipientAddress, never, RecipientBehaviourContext>;
+/**
+ * Gets the current shardId
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const shardId: Effect.Effect<ShardId.ShardId, never, RecipientBehaviourContext>;
+/**
+ * Gets the current recipientType
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const recipientType: Effect.Effect<RecipientType.RecipientType<Message.Message.Any>, never, RecipientBehaviourContext>;
+/**
+ * Forks the shutdown of the current recipient behaviour as soon as possible.
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const forkShutdown: Effect.Effect<void, never, RecipientBehaviourContext>;
+//# sourceMappingURL=RecipientBehaviourContext.d.ts.map