actor-ts 0.9.0

package/dist/cluster/sharding/ClusterSharding.js

@@ -0,0 +1,133 @@
+import { PersistenceExtensionId } from '../../persistence/PersistenceExtension.js';
+import { Props } from '../../Props.js';
+import { HashAllocationStrategy } from './AllocationStrategy.js';
+import { JournalRememberEntitiesStore, } from './RememberEntitiesStore.js';
+import { ShardRegion, coordinatorPath, } from './ShardRegion.js';
+import { ShardCoordinator } from './ShardCoordinator.js';
+import { isShardingMessage } from './ShardingProtocol.js';
+/**
+ * User-facing entry point.  Attaches to an ActorSystem + Cluster pair and
+ * lets you start a sharded region for each entity type.  A `ShardCoordinator`
+ * is spawned lazily on every node; only the one hosted by the current
+ * cluster leader is active — the rest act as warm standbys.
+ */
+export class ClusterSharding {
+    system;
+    cluster;
+    regionsByPath = new Map();
+    coordinators = new Map();
+    constructor(system, cluster) {
+        this.system = system;
+        this.cluster = cluster;
+        cluster._setEnvelopeHandler((env) => this.dispatchEnvelope(env));
+    }
+    static instances = new WeakMap();
+    static get(system, cluster) {
+        const existing = ClusterSharding.instances.get(system);
+        if (existing)
+            return existing;
+        const created = new ClusterSharding(system, cluster);
+        ClusterSharding.instances.set(system, created);
+        return created;
+    }
+    start(arg1, arg2, arg3) {
+        const settings = typeof arg1 === 'string'
+            ? this.buildSettingsFromShorthand(arg1, arg2, arg3 ?? {})
+            : arg1;
+        this.ensureCoordinator(settings);
+        const existing = this.findRegionByType(settings.typeName);
+        if (existing)
+            return existing;
+        const cfg = ShardRegion.settingsToConfig(settings, this.cluster, (path) => this.regionsByPath.get(path) ?? null);
+        const ref = this.system.spawn(
+        // ShardRegion internally handles extra envelope types; cast to Actor<TMsg>
+        // so the returned ref presents the user-facing signature.
+        Props.create(() => new ShardRegion(cfg)), `sharding-${settings.typeName}`);
+        this.regionsByPath.set(ref.path.toString(), ref);
+        return ref;
+    }
+    /** @internal — wrap the shorthand entity arg into a Props + assemble full settings. */
+    buildSettingsFromShorthand(typeName, entity, opts) {
+        // Classes have a `.prototype` whose `constructor` === the class itself.
+        // Arrow functions don't have `prototype`; regular non-class functions do
+        // (with `.prototype.constructor === fn`), so we treat anything that's
+        // `new`-able the same way classes are.  The closure form (arrow `() =>
+        // new X()`) falls into the factory branch.
+        const isClass = typeof entity === 'function' &&
+            typeof entity.prototype === 'object' &&
+            entity.prototype?.constructor === entity;
+        const factory = isClass
+            ? () => new entity()
+            : entity;
+        return { ...opts, typeName, entityProps: Props.create(factory) };
+    }
+    /** Start a proxy region — routes to the cluster but never hosts entities. */
+    startProxy(settings) {
+        return this.start({ ...settings, proxy: true });
+    }
+    /* ------------------------------- Internal -------------------------------- */
+    ensureCoordinator(settings) {
+        if (this.coordinators.has(settings.typeName))
+            return;
+        const coordinatorSettings = {
+            typeName: settings.typeName,
+            cluster: this.cluster,
+            allocationStrategy: settings.allocationStrategy ?? new HashAllocationStrategy(),
+            role: settings.role,
+            rebalanceIntervalMs: settings.rebalanceIntervalMs,
+            handOffTimeoutMs: settings.handOffTimeoutMs,
+            rememberEntities: settings.rememberEntities,
+            rememberEntitiesStore: this.resolveRememberEntitiesStore(settings),
+            coordinatorStateStore: settings.coordinatorStateStore,
+            lease: settings.lease,
+            acquireRetryIntervalMs: settings.acquireRetryIntervalMs,
+            localResolver: (path) => this.regionsByPath.get(path) ?? this.coordinators.get(this.typeNameFromCoordinatorPath(path) ?? '') ?? null,
+        };
+        const ref = this.system.spawn(Props.create(() => new ShardCoordinator(coordinatorSettings)), `sharding-coordinator-${settings.typeName}`);
+        this.coordinators.set(settings.typeName, ref);
+        this.regionsByPath.set(coordinatorPath(this.system.name, settings.typeName), ref);
+    }
+    /**
+     * Resolve the `rememberEntitiesStore` for a sharded type:
+     *
+     *   - User passed `null`           → keep registry in-memory only.
+     *   - User passed an instance      → use it as-is.
+     *   - rememberEntities=false       → no persistence regardless.
+     *   - rememberEntities=true (default path) → auto-instantiate
+     *     `JournalRememberEntitiesStore` from the system's persistence
+     *     extension so the registry survives cluster cold-starts
+     *     without the user wiring anything up.
+     */
+    resolveRememberEntitiesStore(settings) {
+        if (!settings.rememberEntities)
+            return undefined;
+        if (settings.rememberEntitiesStore === null)
+            return undefined;
+        if (settings.rememberEntitiesStore)
+            return settings.rememberEntitiesStore;
+        const journal = this.system.extension(PersistenceExtensionId).journal;
+        return new JournalRememberEntitiesStore(journal);
+    }
+    typeNameFromCoordinatorPath(path) {
+        const m = path.match(/\/sharding-coordinator-([^/]+)$/);
+        return m ? m[1] : null;
+    }
+    findRegionByType(typeName) {
+        const suffix = `/user/sharding-${typeName}`;
+        for (const [path, ref] of this.regionsByPath) {
+            if (path.endsWith(suffix))
+                return ref;
+        }
+        return null;
+    }
+    dispatchEnvelope(env) {
+        const ref = this.regionsByPath.get(env.to);
+        if (!ref) {
+            this.system.log.warn(`[sharding] no region/coordinator registered for ${env.to}`);
+            return;
+        }
+        ref.tell(env.body);
+    }
+}
+export { isShardingMessage };
+//# sourceMappingURL=ClusterSharding.js.map

package/dist/cluster/sharding/ClusterSharding.js.map

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

package/dist/cluster/sharding/CoordinatorState.d.ts

@@ -0,0 +1,83 @@
+import type { DistributedDataHandle } from '../../crdt/DistributedData.js';
+import type { NodeAddressData } from '../NodeAddress.js';
+/**
+ * Wire shape for `ShardCoordinator` state — what's persisted to
+ * `CoordinatorStateStore` so a new leader can skip the full
+ * rebuild-from-Register-gossip path on `LeaderChanged`.
+ *
+ * `pending` and `rebalanceInProgress` are deliberately **not**
+ * persisted: they're transient by nature (in-flight queries +
+ * mid-flight handoffs).  A fresh leader rebuilds them as new
+ * messages arrive.
+ *
+ * `entitiesPerShard` is persisted separately via
+ * `RememberEntitiesStore` (#49) — those two stores have different
+ * cadences (state changes here are bursty during rebalance; entity
+ * lifecycle is steady).  Keeping them apart lets each tune
+ * independently.
+ */
+export interface CoordinatorStateData {
+    /** Replica that wrote this snapshot.  Informational + LWW tiebreak. */
+    readonly leader: string;
+    /** Wall-clock millis at write time.  LWW tiebreak. */
+    readonly takenAt: number;
+    /** Region table — keyed by the same `regionKey` the coordinator uses. */
+    readonly regions: ReadonlyArray<RegionInfoData>;
+    /** Allocation map.  `[shardId, regionKey][]` — Map's wire shape. */
+    readonly shardHome: ReadonlyArray<readonly [number, string]>;
+}
+/** JSON-friendly mirror of the in-memory `RegionInfo`. */
+export interface RegionInfoData {
+    /** Same key as `regionKey(node, path)`. */
+    readonly key: string;
+    readonly node: NodeAddressData;
+    readonly path: string;
+    readonly proxy: boolean;
+    readonly shards: ReadonlyArray<number>;
+}
+/**
+ * Pluggable persistence for the coordinator's allocation state.
+ * Symmetric to `RememberEntitiesStore` from #49: load / save / clear.
+ *
+ * The default impl is `DistributedDataCoordinatorStateStore` —
+ * gossip-replicated within the cluster, so when leadership flips
+ * the new leader sees a recent snapshot from the previous leader.
+ * Custom impls could front a SQLite table or any other backend.
+ */
+export interface CoordinatorStateStore {
+    /** Load the most recent snapshot, or `null` if none stored. */
+    load(typeName: string): Promise<CoordinatorStateData | null>;
+    /** Persist a fresh snapshot.  Overwrites any prior. */
+    save(typeName: string, state: CoordinatorStateData): Promise<void>;
+}
+/**
+ * `CoordinatorStateStore` backed by `DistributedData`.  Each
+ * coordinator's state lives in a single LWW register keyed by
+ * `sharding-coordinator-state|{typeName}`.  Cluster-wide gossip
+ * propagates the writes; on leadership flip the new leader's local
+ * DD view typically holds the previous leader's last snapshot
+ * (modulo the gossip interval — a few hundred ms behind in the
+ * worst case).
+ *
+ * **CRDT shape**: a single `LWWRegister<CoordinatorStateData>`.
+ * Tiebreak via `(timestamp, replicaId)` is exactly what we want —
+ * the most recent writer (=most recent leader) wins.
+ *
+ * **Latency**: DD's default gossip is push-to-one-random-peer per
+ * tick.  In a 3-node cluster, the previous leader's last write
+ * reaches the new leader within ~2 gossip rounds in expectation.
+ * For sub-second failover the user can tighten
+ * `DistributedDataSettings.gossipIntervalMs`.
+ */
+export declare class DistributedDataCoordinatorStateStore implements CoordinatorStateStore {
+    private readonly dd;
+    /** This replica's id — used as the LWWRegister writer. */
+    private readonly replicaId;
+    constructor(dd: DistributedDataHandle, 
+    /** This replica's id — used as the LWWRegister writer. */
+    replicaId: string);
+    private keyFor;
+    load(typeName: string): Promise<CoordinatorStateData | null>;
+    save(typeName: string, state: CoordinatorStateData): Promise<void>;
+}
+//# sourceMappingURL=CoordinatorState.d.ts.map

package/dist/cluster/sharding/CoordinatorState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoordinatorState.d.ts","sourceRoot":"","sources":["../../../src/cluster/sharding/CoordinatorState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,oBAAoB;IACnC,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAChD,oEAAoE;IACpE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC9D;AAED,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC,+DAA+D;IAC/D,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;IAE7D,uDAAuD;IACvD,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpE;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,oCAAqC,YAAW,qBAAqB;IAE9E,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAFT,EAAE,EAAE,qBAAqB;IAC1C,0DAA0D;IACzC,SAAS,EAAE,MAAM;IAGpC,OAAO,CAAC,MAAM;IAIR,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAK5D,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;CAWzE"}

package/dist/cluster/sharding/CoordinatorState.js

@@ -0,0 +1,46 @@
+import { LWWRegister } from '../../crdt/LWWRegister.js';
+/* ============== DistributedData-backed default impl =================== */
+/**
+ * `CoordinatorStateStore` backed by `DistributedData`.  Each
+ * coordinator's state lives in a single LWW register keyed by
+ * `sharding-coordinator-state|{typeName}`.  Cluster-wide gossip
+ * propagates the writes; on leadership flip the new leader's local
+ * DD view typically holds the previous leader's last snapshot
+ * (modulo the gossip interval — a few hundred ms behind in the
+ * worst case).
+ *
+ * **CRDT shape**: a single `LWWRegister<CoordinatorStateData>`.
+ * Tiebreak via `(timestamp, replicaId)` is exactly what we want —
+ * the most recent writer (=most recent leader) wins.
+ *
+ * **Latency**: DD's default gossip is push-to-one-random-peer per
+ * tick.  In a 3-node cluster, the previous leader's last write
+ * reaches the new leader within ~2 gossip rounds in expectation.
+ * For sub-second failover the user can tighten
+ * `DistributedDataSettings.gossipIntervalMs`.
+ */
+export class DistributedDataCoordinatorStateStore {
+    dd;
+    replicaId;
+    constructor(dd, 
+    /** This replica's id — used as the LWWRegister writer. */
+    replicaId) {
+        this.dd = dd;
+        this.replicaId = replicaId;
+    }
+    keyFor(typeName) {
+        return `sharding-coordinator-state|${typeName}`;
+    }
+    async load(typeName) {
+        const reg = this.dd.get(this.keyFor(typeName));
+        return reg?.value() ?? null;
+    }
+    async save(typeName, state) {
+        this.dd.update(this.keyFor(typeName), () => LWWRegister.empty(), (reg) => reg.assign(this.replicaId, state, state.takenAt));
+        // The update is fire-and-forget (DD serialises through its
+        // mailbox) — we don't await write-to-disk.  That's fine: load
+        // reads the local view, which always reflects our own writes
+        // synchronously.
+    }
+}
+//# sourceMappingURL=CoordinatorState.js.map

package/dist/cluster/sharding/CoordinatorState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoordinatorState.js","sourceRoot":"","sources":["../../../src/cluster/sharding/CoordinatorState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AA0DxD,4EAA4E;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,oCAAoC;IAE5B;IAEA;IAHnB,YACmB,EAAyB;IAC1C,0DAA0D;IACzC,SAAiB;QAFjB,OAAE,GAAF,EAAE,CAAuB;QAEzB,cAAS,GAAT,SAAS,CAAQ;IACjC,CAAC;IAEI,MAAM,CAAC,QAAgB;QAC7B,OAAO,8BAA8B,QAAQ,EAAE,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAgB;QACzB,MAAM,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAoC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QAClF,OAAO,GAAG,EAAE,KAAK,EAAE,IAAI,IAAI,CAAC;IAC9B,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAgB,EAAE,KAA2B;QACtD,IAAI,CAAC,EAAE,CAAC,MAAM,CACZ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EACrB,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,EAAwB,EAC/C,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAC1D,CAAC;QACF,2DAA2D;QAC3D,8DAA8D;QAC9D,6DAA6D;QAC7D,iBAAiB;IACnB,CAAC;CACF"}

package/dist/cluster/sharding/Passivate.d.ts

@@ -0,0 +1,23 @@
+import type { ActorRef } from '../../ActorRef.js';
+/**
+ * An entity actor sends `Passivate(stopMessage)` to its parent (the shard
+ * region) to request a graceful shutdown.  The region then forwards
+ * `stopMessage` to the entity and buffers any further traffic for the
+ * entity until it has fully stopped; the next inbound message recreates
+ * the entity and flushes the buffer.
+ *
+ * Two call shapes are accepted:
+ *   // Explicit (recommended) — entity attaches its own ref so the region
+ *   // can find it regardless of how `tell` was invoked:
+ *   this.context.parent?.tell(new Passivate(Stop, this.self));
+ *
+ *   // Implicit — works when the enclosing `tell` also passed `self` as
+ *   // the sender:
+ *   this.context.parent?.tell(new Passivate(Stop), this.self);
+ */
+export declare class Passivate {
+    readonly stopMessage: unknown;
+    readonly entity?: ActorRef | undefined;
+    constructor(stopMessage: unknown, entity?: ActorRef | undefined);
+}
+//# sourceMappingURL=Passivate.d.ts.map

package/dist/cluster/sharding/Passivate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Passivate.d.ts","sourceRoot":"","sources":["../../../src/cluster/sharding/Passivate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,SAAS;aAEF,WAAW,EAAE,OAAO;aACpB,MAAM,CAAC,EAAE,QAAQ;gBADjB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE,QAAQ,YAAA;CAEpC"}

package/dist/cluster/sharding/Passivate.js

@@ -0,0 +1,25 @@
+/**
+ * An entity actor sends `Passivate(stopMessage)` to its parent (the shard
+ * region) to request a graceful shutdown.  The region then forwards
+ * `stopMessage` to the entity and buffers any further traffic for the
+ * entity until it has fully stopped; the next inbound message recreates
+ * the entity and flushes the buffer.
+ *
+ * Two call shapes are accepted:
+ *   // Explicit (recommended) — entity attaches its own ref so the region
+ *   // can find it regardless of how `tell` was invoked:
+ *   this.context.parent?.tell(new Passivate(Stop, this.self));
+ *
+ *   // Implicit — works when the enclosing `tell` also passed `self` as
+ *   // the sender:
+ *   this.context.parent?.tell(new Passivate(Stop), this.self);
+ */
+export class Passivate {
+    stopMessage;
+    entity;
+    constructor(stopMessage, entity) {
+        this.stopMessage = stopMessage;
+        this.entity = entity;
+    }
+}
+//# sourceMappingURL=Passivate.js.map

package/dist/cluster/sharding/Passivate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Passivate.js","sourceRoot":"","sources":["../../../src/cluster/sharding/Passivate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,SAAS;IAEF;IACA;IAFlB,YACkB,WAAoB,EACpB,MAAiB;QADjB,gBAAW,GAAX,WAAW,CAAS;QACpB,WAAM,GAAN,MAAM,CAAW;IAChC,CAAC;CACL"}

package/dist/cluster/sharding/RememberEntitiesStore.d.ts

@@ -0,0 +1,60 @@
+import type { Journal } from '../../persistence/Journal.js';
+/**
+ * Append-only event recording an entity's lifecycle on the
+ * coordinator side.  The coordinator emits one of these every time
+ * `handleEntityStarted` or `handleEntityStopped` runs (when
+ * `rememberEntities: true`); replaying the full event log on
+ * coordinator restart rebuilds the in-memory `entitiesPerShard` map.
+ */
+export type RememberEvent = {
+    readonly kind: 'started';
+    readonly shardId: number;
+    readonly entityId: string;
+} | {
+    readonly kind: 'stopped';
+    readonly shardId: number;
+    readonly entityId: string;
+};
+/**
+ * Pluggable persistence backend for the sharded-entity registry.  The
+ * default `JournalRememberEntitiesStore` reuses the system's `Journal`
+ * — same plumbing that backs `PersistentActor`, so any Journal
+ * implementation (in-memory, SQLite, Cassandra, …) works out of the
+ * box.  Custom impls can hit a different store entirely (e.g. a
+ * standalone SQLite DB for the registry, separate from the event
+ * journal).
+ *
+ * **Concurrency**: `append` is called serially by the coordinator
+ * (it chains writes via a promise-of-the-last-write), so impls don't
+ * need to handle concurrent appends to the same `typeName`.
+ */
+export interface RememberEntitiesStore {
+    /** Persist a single entity-lifecycle event. */
+    append(typeName: string, event: RememberEvent): Promise<void>;
+    /**
+     * Replay every event ever recorded for `typeName`, in append order.
+     * Returns an empty array if nothing's been written.  Called once
+     * per coordinator preStart.
+     */
+    load(typeName: string): Promise<RememberEvent[]>;
+    /** Forget every event for `typeName`.  Used by tests + reset tooling. */
+    clear(typeName: string): Promise<void>;
+}
+/**
+ * Default `RememberEntitiesStore` impl backed by any `Journal`.
+ * Stores events under `persistenceId = "sharding-coordinator-{typeName}"`
+ * so a custom journal layout doesn't collide with regular event-
+ * sourced actors (which use the user-defined `persistenceId`).
+ *
+ * Tagged with `'sharding-remember'` so users can spot the registry
+ * in tag-based projections / queries if they want to audit it.
+ */
+export declare class JournalRememberEntitiesStore implements RememberEntitiesStore {
+    private readonly journal;
+    constructor(journal: Journal);
+    private pidFor;
+    append(typeName: string, event: RememberEvent): Promise<void>;
+    load(typeName: string): Promise<RememberEvent[]>;
+    clear(typeName: string): Promise<void>;
+}
+//# sourceMappingURL=RememberEntitiesStore.d.ts.map

package/dist/cluster/sharding/RememberEntitiesStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RememberEntitiesStore.d.ts","sourceRoot":"","sources":["../../../src/cluster/sharding/RememberEntitiesStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACjF;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtF;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACpC,+CAA+C;IAC/C,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9D;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAEjD,yEAAyE;IACzE,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,qBAAa,4BAA6B,YAAW,qBAAqB;IAC5D,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO;IAE7C,OAAO,CAAC,MAAM;IAIR,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAM7D,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAMhD,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAK7C"}

package/dist/cluster/sharding/RememberEntitiesStore.js

@@ -0,0 +1,35 @@
+/**
+ * Default `RememberEntitiesStore` impl backed by any `Journal`.
+ * Stores events under `persistenceId = "sharding-coordinator-{typeName}"`
+ * so a custom journal layout doesn't collide with regular event-
+ * sourced actors (which use the user-defined `persistenceId`).
+ *
+ * Tagged with `'sharding-remember'` so users can spot the registry
+ * in tag-based projections / queries if they want to audit it.
+ */
+export class JournalRememberEntitiesStore {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    pidFor(typeName) {
+        return `sharding-coordinator-${typeName}`;
+    }
+    async append(typeName, event) {
+        const pid = this.pidFor(typeName);
+        const head = await this.journal.highestSeq(pid);
+        await this.journal.append(pid, [event], head, ['sharding-remember']);
+    }
+    async load(typeName) {
+        const pid = this.pidFor(typeName);
+        const events = await this.journal.read(pid, 1);
+        return events.map((pe) => pe.event);
+    }
+    async clear(typeName) {
+        const pid = this.pidFor(typeName);
+        const head = await this.journal.highestSeq(pid);
+        if (head > 0)
+            await this.journal.delete(pid, head);
+    }
+}
+//# sourceMappingURL=RememberEntitiesStore.js.map

package/dist/cluster/sharding/RememberEntitiesStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RememberEntitiesStore.js","sourceRoot":"","sources":["../../../src/cluster/sharding/RememberEntitiesStore.ts"],"names":[],"mappings":"AAyCA;;;;;;;;GAQG;AACH,MAAM,OAAO,4BAA4B;IACV;IAA7B,YAA6B,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;IAAG,CAAC;IAEzC,MAAM,CAAC,QAAgB;QAC7B,OAAO,wBAAwB,QAAQ,EAAE,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,QAAgB,EAAE,KAAoB;QACjD,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAChD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACvE,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAgB;QACzB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAgB,GAAG,EAAE,CAAC,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,QAAgB;QAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAClC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,IAAI,GAAG,CAAC;YAAE,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACrD,CAAC;CACF"}

package/dist/cluster/sharding/ShardAllocator.d.ts

@@ -0,0 +1,23 @@
+import { NodeAddress } from '../NodeAddress.js';
+/** Strategy: given a shard id and the active member addresses, return the owner. */
+export type ShardAllocator = (shardId: number, members: ReadonlyArray<NodeAddress>) => NodeAddress;
+/**
+ * Simple modulo allocator: sort addresses and pick shardId % n.  Every node
+ * computes the same assignment deterministically.  Works well when the
+ * member set is stable; moves a lot of shards when it changes.
+ */
+export declare const moduloAllocator: ShardAllocator;
+/**
+ * Stable ring-hash allocator: for each shard, hash together (shardId, address)
+ * and pick the address with the highest hash (highest-random-weight / rendezvous
+ * hashing).  When one node leaves, only its shards relocate — the rest stay
+ * put.  Better rebalance behaviour than modulo at the cost of a bit more
+ * computation.
+ */
+export declare const rendezvousAllocator: ShardAllocator;
+/**
+ * Helper used by the default ShardRegion to map an entityId to a shard.
+ * Uses a stable string hash; callers may supply their own extractShardId.
+ */
+export declare function hashShardId(entityId: string, numShards: number): number;
+//# sourceMappingURL=ShardAllocator.d.ts.map

package/dist/cluster/sharding/ShardAllocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShardAllocator.d.ts","sourceRoot":"","sources":["../../../src/cluster/sharding/ShardAllocator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,KAChC,WAAW,CAAC;AAEjB;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAI7B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,cASjC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvE"}

package/dist/cluster/sharding/ShardAllocator.js

@@ -0,0 +1,54 @@
+/**
+ * Simple modulo allocator: sort addresses and pick shardId % n.  Every node
+ * computes the same assignment deterministically.  Works well when the
+ * member set is stable; moves a lot of shards when it changes.
+ */
+export const moduloAllocator = (shardId, members) => {
+    if (members.length === 0)
+        throw new Error('No members available to allocate shard');
+    const sorted = [...members].sort((a, b) => a.compareTo(b));
+    return sorted[shardId % sorted.length];
+};
+/**
+ * Stable ring-hash allocator: for each shard, hash together (shardId, address)
+ * and pick the address with the highest hash (highest-random-weight / rendezvous
+ * hashing).  When one node leaves, only its shards relocate — the rest stay
+ * put.  Better rebalance behaviour than modulo at the cost of a bit more
+ * computation.
+ */
+export const rendezvousAllocator = (shardId, members) => {
+    if (members.length === 0)
+        throw new Error('No members available to allocate shard');
+    let bestHash = -1;
+    let best = members[0];
+    for (const addr of members) {
+        const h = hashCombine(shardId, addr.toString());
+        if (h > bestHash) {
+            bestHash = h;
+            best = addr;
+        }
+    }
+    return best;
+};
+/**
+ * Helper used by the default ShardRegion to map an entityId to a shard.
+ * Uses a stable string hash; callers may supply their own extractShardId.
+ */
+export function hashShardId(entityId, numShards) {
+    return Math.abs(stringHash(entityId)) % numShards;
+}
+function stringHash(s) {
+    let h = 2166136261; // FNV-1a 32-bit basis
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h;
+}
+function hashCombine(a, b) {
+    let h = stringHash(b) ^ (a * 2654435761);
+    h ^= h >>> 13;
+    h = Math.imul(h, 1540483477);
+    return h >>> 0;
+}
+//# sourceMappingURL=ShardAllocator.js.map

package/dist/cluster/sharding/ShardAllocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShardAllocator.js","sourceRoot":"","sources":["../../../src/cluster/sharding/ShardAllocator.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;IAClE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IACpF,MAAM,MAAM,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3D,OAAO,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAE,CAAC;AAC1C,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE;IACtE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;IACpF,IAAI,QAAQ,GAAG,CAAC,CAAC,CAAC;IAClB,IAAI,IAAI,GAAgB,OAAO,CAAC,CAAC,CAAE,CAAC;IACpC,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAC;YAAC,QAAQ,GAAG,CAAC,CAAC;YAAC,IAAI,GAAG,IAAI,CAAC;QAAC,CAAC;IAClD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,QAAgB,EAAE,SAAiB;IAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC;AACpD,CAAC;AAED,SAAS,UAAU,CAAC,CAAS;IAC3B,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,sBAAsB;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,SAAS,WAAW,CAAC,CAAS,EAAE,CAAS;IACvC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC;IACzC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;IACd,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC"}