@moltzap/client 2026.501.0 → 2026.501.2

package/dist/internal/s2c-dispatcher-errors.d.ts

@@ -0,0 +1,66 @@
+declare const MalformedPartitionKeyError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "MalformedPartitionKeyError";
+} & Readonly<A>;
+/**
+ * The decoded server-request frame did not carry a usable partition key.
+ * Examples: required `params.sessionId` missing or not a UUID; method
+ * name absent from the s2c registry.
+ *
+ * Failure mode is structural — the request cannot be routed. The reader
+ * synthesizes a `-32602 Invalid params` error response.
+ */
+export declare class MalformedPartitionKeyError extends MalformedPartitionKeyError_base<{
+    readonly method: string;
+    readonly reason: "missing-session-id" | "missing-conversation-id" | "unknown-method" | "params-shape";
+    readonly requestId: string;
+}> {
+}
+declare const PartitionLimitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PartitionLimitError";
+} & Readonly<A>;
+/**
+ * The active-partition count has reached `maxPartitions` (soft cap, default
+ * 256). New partitions cannot be allocated until an existing partition is
+ * reaped by the idle reaper or the connection scope closes. Per-tenant DoS
+ * guard.
+ *
+ * Failure mode is liveness — the request is rejected without contention
+ * with existing partitions. Reader synthesizes a `-32000 Server busy`
+ * error response so the server retries / falls through.
+ */
+export declare class PartitionLimitError extends PartitionLimitError_base<{
+    readonly key: string;
+    readonly activePartitions: number;
+    readonly maxPartitions: number;
+    readonly requestId: string;
+}> {
+}
+declare const PartitionQueueFullError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PartitionQueueFullError";
+} & Readonly<A>;
+/**
+ * The target partition's bounded queue is at capacity (default 32). Slow
+ * handler is backpressuring its own partition. Other partitions are
+ * unaffected.
+ *
+ * Failure mode is per-partition liveness — the queue is full ONLY for this
+ * tuple. Reader synthesizes a `-32000 Partition busy` error response;
+ * server may retry or surface the failure to the originator (AppHost
+ * fail-CLOSED verdict for hooks).
+ */
+export declare class PartitionQueueFullError extends PartitionQueueFullError_base<{
+    readonly key: string;
+    readonly capacity: number;
+    readonly requestId: string;
+}> {
+}
+/**
+ * Discriminated union over every reason `PartitionedDispatcher.offer` can
+ * reject an inbound request. Exhaustive: adding a new branch fails every
+ * `match` site at compile time. Branch handlers in the reader's
+ * frame-routing path discriminate on `_tag` to pick the right wire-error
+ * code.
+ */
+export type OfferRejected = MalformedPartitionKeyError | PartitionLimitError | PartitionQueueFullError;
+export {};
+//# sourceMappingURL=s2c-dispatcher-errors.d.ts.map

package/dist/internal/s2c-dispatcher-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s2c-dispatcher-errors.d.ts","sourceRoot":"","sources":["../../src/internal/s2c-dispatcher-errors.ts"],"names":[],"mappings":";;;AAYA;;;;;;;GAOG;AACH,qBAAa,0BAA2B,SAAQ,gCAE9C;IACA,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EACX,oBAAoB,GACpB,yBAAyB,GACzB,gBAAgB,GAChB,cAAc,CAAC;IACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;CAAG;;;;AAEL;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,SAAQ,yBAEvC;IACA,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;CAAG;;;;AAEL;;;;;;;;;GASG;AACH,qBAAa,uBAAwB,SAAQ,6BAE3C;IACA,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;CAAG;AAEL;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,0BAA0B,GAC1B,mBAAmB,GACnB,uBAAuB,CAAC"}

package/dist/internal/s2c-dispatcher-errors.js

@@ -0,0 +1,46 @@
+/**
+ * Tagged error types for the partitioned s2c dispatcher.
+ *
+ * Spec: moltzap#356 — partitioned dispatch keyed on
+ * `(sessionId, conversationId, hookKind)`.
+ *
+ * All errors are surfaced on `PartitionedDispatcher.offer`'s typed channel.
+ * The reader fiber translates each tag into an immediate s2c error response
+ * so the server's `Deferred.await` resolves deterministically (no hangs).
+ */
+import { Data } from "effect";
+/**
+ * The decoded server-request frame did not carry a usable partition key.
+ * Examples: required `params.sessionId` missing or not a UUID; method
+ * name absent from the s2c registry.
+ *
+ * Failure mode is structural — the request cannot be routed. The reader
+ * synthesizes a `-32602 Invalid params` error response.
+ */
+export class MalformedPartitionKeyError extends Data.TaggedError("MalformedPartitionKeyError") {
+}
+/**
+ * The active-partition count has reached `maxPartitions` (soft cap, default
+ * 256). New partitions cannot be allocated until an existing partition is
+ * reaped by the idle reaper or the connection scope closes. Per-tenant DoS
+ * guard.
+ *
+ * Failure mode is liveness — the request is rejected without contention
+ * with existing partitions. Reader synthesizes a `-32000 Server busy`
+ * error response so the server retries / falls through.
+ */
+export class PartitionLimitError extends Data.TaggedError("PartitionLimitError") {
+}
+/**
+ * The target partition's bounded queue is at capacity (default 32). Slow
+ * handler is backpressuring its own partition. Other partitions are
+ * unaffected.
+ *
+ * Failure mode is per-partition liveness — the queue is full ONLY for this
+ * tuple. Reader synthesizes a `-32000 Partition busy` error response;
+ * server may retry or surface the failure to the originator (AppHost
+ * fail-CLOSED verdict for hooks).
+ */
+export class PartitionQueueFullError extends Data.TaggedError("PartitionQueueFullError") {
+}
+//# sourceMappingURL=s2c-dispatcher-errors.js.map

package/dist/internal/s2c-dispatcher-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"s2c-dispatcher-errors.js","sourceRoot":"","sources":["../../src/internal/s2c-dispatcher-errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B;;;;;;;GAOG;AACH,MAAM,OAAO,0BAA2B,SAAQ,IAAI,CAAC,WAAW,CAC9D,4BAA4B,CAS5B;CAAG;AAEL;;;;;;;;;GASG;AACH,MAAM,OAAO,mBAAoB,SAAQ,IAAI,CAAC,WAAW,CACvD,qBAAqB,CAMrB;CAAG;AAEL;;;;;;;;;GASG;AACH,MAAM,OAAO,uBAAwB,SAAQ,IAAI,CAAC,WAAW,CAC3D,yBAAyB,CAKzB;CAAG"}

package/dist/internal/s2c-partition-key.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Pure partition-key extractor for the partitioned s2c dispatcher.
+ *
+ * Spec: moltzap#356.
+ *
+ * Decode rules — `decodeFrames` validates the **frame envelope only**
+ * (`packages/client/src/runtime/frame.ts:29-34@f0df363`); the inbound
+ * `params` field arrives as `unknown`. Per-method param-shape decode
+ * (`S2cRpcMap[method]['params']`) is the AppHost layer's job
+ * (`packages/app-sdk/src/app.ts:489-491@f0df363`) and is unchanged
+ * by this refactor.
+ *
+ * This module performs **narrow validation of routing fields only**:
+ * confirm `params` is an object, then extract three fields with
+ * the same tolerance as the AppHost cast:
+ *
+ *   - `sessionId` (always required for every entry in `s2cRpcMethods`)
+ *   - `conversationId` (present on `apps/onBeforeDispatch` and
+ *     `apps/onBeforeMessageDelivery`; absent on lifecycle methods —
+ *     synthesized as the literal sentinel `*lifecycle*`)
+ *   - `method` — the wire method name doubles as `hookKind`.
+ *
+ * The result is a branded string `PartitionKey`. Branding prevents
+ * accidental reuse of raw `string` keys in the worker map.
+ */
+import { Either } from "effect";
+import { MalformedPartitionKeyError } from "./s2c-dispatcher-errors.js";
+/**
+ * Branded partition-key string. Constructed only by `extractPartitionKey`.
+ * Format is opaque to consumers; equality is value equality.
+ */
+export type PartitionKey = string & {
+    readonly __brand: "PartitionKey";
+};
+/**
+ * Sentinel placeholder for s2c methods that carry no `conversationId`
+ * (lifecycle: `apps/onJoin`, `apps/onClose`, `apps/onSessionActive`).
+ * All lifecycle calls for the same `(sessionId, method)` share one
+ * partition; cross-method lifecycle ordering is preserved by the server,
+ * not the client.
+ */
+export declare const LIFECYCLE_CONVERSATION_SENTINEL: "*lifecycle*";
+/**
+ * Shape the dispatcher hands the extractor. Mirrors `DecodedServerRequest`
+ * in `ws-client.ts` but stays import-cycle-free for the internal modules.
+ */
+export interface PartitionableRequest {
+    readonly id: string;
+    readonly method: string;
+    readonly params: unknown;
+}
+/**
+ * Decode a partition key from an inbound s2c request. Does NOT mutate the
+ * request. On any structural failure, returns
+ * `MalformedPartitionKeyError` with a typed `reason` tag the reader fiber
+ * uses to pick an error response code.
+ */
+export declare function extractPartitionKey(request: PartitionableRequest): Either.Either<PartitionKey, MalformedPartitionKeyError>;
+/**
+ * Inverse projection for tests + observability. Pure deconstruction of a
+ * `PartitionKey` back into its three components. Returning a structured
+ * record (rather than a tuple) lets callers discriminate on
+ * `conversationId === LIFECYCLE_CONVERSATION_SENTINEL`.
+ */
+export declare function describePartitionKey(key: PartitionKey): {
+    readonly sessionId: string;
+    readonly conversationId: string;
+    readonly method: string;
+};
+//# sourceMappingURL=s2c-partition-key.d.ts.map

package/dist/internal/s2c-partition-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s2c-partition-key.d.ts","sourceRoot":"","sources":["../../src/internal/s2c-partition-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AAExE;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;CAAE,CAAC;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,EAAG,aAAsB,CAAC;AA4BtE;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAMD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,0BAA0B,CAAC,CA0DzD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,GAAG;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,CAmBA"}

package/dist/internal/s2c-partition-key.js

@@ -0,0 +1,140 @@
+/**
+ * Pure partition-key extractor for the partitioned s2c dispatcher.
+ *
+ * Spec: moltzap#356.
+ *
+ * Decode rules — `decodeFrames` validates the **frame envelope only**
+ * (`packages/client/src/runtime/frame.ts:29-34@f0df363`); the inbound
+ * `params` field arrives as `unknown`. Per-method param-shape decode
+ * (`S2cRpcMap[method]['params']`) is the AppHost layer's job
+ * (`packages/app-sdk/src/app.ts:489-491@f0df363`) and is unchanged
+ * by this refactor.
+ *
+ * This module performs **narrow validation of routing fields only**:
+ * confirm `params` is an object, then extract three fields with
+ * the same tolerance as the AppHost cast:
+ *
+ *   - `sessionId` (always required for every entry in `s2cRpcMethods`)
+ *   - `conversationId` (present on `apps/onBeforeDispatch` and
+ *     `apps/onBeforeMessageDelivery`; absent on lifecycle methods —
+ *     synthesized as the literal sentinel `*lifecycle*`)
+ *   - `method` — the wire method name doubles as `hookKind`.
+ *
+ * The result is a branded string `PartitionKey`. Branding prevents
+ * accidental reuse of raw `string` keys in the worker map.
+ */
+import { Either } from "effect";
+import { MalformedPartitionKeyError } from "./s2c-dispatcher-errors.js";
+/**
+ * Sentinel placeholder for s2c methods that carry no `conversationId`
+ * (lifecycle: `apps/onJoin`, `apps/onClose`, `apps/onSessionActive`).
+ * All lifecycle calls for the same `(sessionId, method)` share one
+ * partition; cross-method lifecycle ordering is preserved by the server,
+ * not the client.
+ */
+export const LIFECYCLE_CONVERSATION_SENTINEL = "*lifecycle*";
+/**
+ * Methods that carry `conversationId` on `params`. Disjoint from the
+ * lifecycle methods, which fall back to `LIFECYCLE_CONVERSATION_SENTINEL`.
+ *
+ * Kept as a literal `Set` (not derived from `s2cRpcMethods`) so this
+ * module has no schema-package import beyond the error type — keeping
+ * the routing layer pure and import-cycle-free per architect §3.2.
+ */
+const CONVERSATION_BEARING_METHODS = new Set([
+    "apps/onBeforeDispatch",
+    "apps/onBeforeMessageDelivery",
+]);
+const LIFECYCLE_METHODS = new Set([
+    "apps/onJoin",
+    "apps/onClose",
+    "apps/onSessionActive",
+]);
+/**
+ * Field separator inside a `PartitionKey`. ASCII vertical bar; not legal
+ * in a UUID and not legal in any of our `appId` values, so the encoded
+ * key parses unambiguously.
+ */
+const KEY_SEP = "|";
+function isPlainObject(x) {
+    return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+/**
+ * Decode a partition key from an inbound s2c request. Does NOT mutate the
+ * request. On any structural failure, returns
+ * `MalformedPartitionKeyError` with a typed `reason` tag the reader fiber
+ * uses to pick an error response code.
+ */
+export function extractPartitionKey(request) {
+    const { id: requestId, method, params } = request;
+    const isLifecycle = LIFECYCLE_METHODS.has(method);
+    const isConversationBearing = CONVERSATION_BEARING_METHODS.has(method);
+    if (!isLifecycle && !isConversationBearing) {
+        return Either.left(new MalformedPartitionKeyError({
+            method,
+            reason: "unknown-method",
+            requestId,
+        }));
+    }
+    if (!isPlainObject(params)) {
+        return Either.left(new MalformedPartitionKeyError({
+            method,
+            reason: "params-shape",
+            requestId,
+        }));
+    }
+    const sessionIdRaw = params["sessionId"];
+    if (typeof sessionIdRaw !== "string" || sessionIdRaw.length === 0) {
+        return Either.left(new MalformedPartitionKeyError({
+            method,
+            reason: "missing-session-id",
+            requestId,
+        }));
+    }
+    let conversationId;
+    if (isConversationBearing) {
+        const convRaw = params["conversationId"];
+        if (typeof convRaw !== "string" || convRaw.length === 0) {
+            return Either.left(new MalformedPartitionKeyError({
+                method,
+                reason: "missing-conversation-id",
+                requestId,
+            }));
+        }
+        conversationId = convRaw;
+    }
+    else {
+        // Lifecycle: synthesize sentinel. (S, "*lifecycle*", method) keeps
+        // distinct lifecycle methods on distinct keys per OQ-1 default.
+        conversationId = LIFECYCLE_CONVERSATION_SENTINEL;
+    }
+    const encoded = `${sessionIdRaw}${KEY_SEP}${conversationId}${KEY_SEP}${method}`;
+    return Either.right(encoded);
+}
+/**
+ * Inverse projection for tests + observability. Pure deconstruction of a
+ * `PartitionKey` back into its three components. Returning a structured
+ * record (rather than a tuple) lets callers discriminate on
+ * `conversationId === LIFECYCLE_CONVERSATION_SENTINEL`.
+ */
+export function describePartitionKey(key) {
+    // Method is the only field that can contain a slash; sessionId is a
+    // UUID and conversationId is a UUID or the lifecycle sentinel. Split
+    // on the first two `KEY_SEP` occurrences only so a hypothetical
+    // future method name with `KEY_SEP` (impossible today; ASCII `|`)
+    // would still round-trip cleanly.
+    const first = key.indexOf(KEY_SEP);
+    const second = first === -1 ? -1 : key.indexOf(KEY_SEP, first + 1);
+    if (first === -1 || second === -1) {
+        // `extractPartitionKey` is the only constructor; an unparsable key
+        // means a caller bypassed branding. This is a programmer error,
+        // not a runtime user-input failure — fail loudly.
+        throw new Error(`describePartitionKey: malformed PartitionKey: ${key}`);
+    }
+    return {
+        sessionId: key.slice(0, first),
+        conversationId: key.slice(first + 1, second),
+        method: key.slice(second + 1),
+    };
+}
+//# sourceMappingURL=s2c-partition-key.js.map

package/dist/internal/s2c-partition-key.js.map

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

package/dist/internal/s2c-partition-worker.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Per-partition worker — bounded queue + forked fiber, owning ordering
+ * within one `(sessionId, conversationId, hookKind)` tuple.
+ *
+ * Spec: moltzap#356.
+ *
+ * Lifecycle is anchored in a per-worker `Scope.CloseableScope` provided
+ * by the dispatcher (`s2c-partitioned-dispatcher.ts`'s
+ * `getOrCreatePartitionWorker` calls `Scope.fork(dispatcherScope, …)`
+ * for each new worker and hands the child scope in via the config).
+ * Closing the worker's scope shuts the queue, runs registered
+ * finalizers, and interrupts the drain fiber — cascading finalization
+ * with no orphan references on the dispatcher scope. Closing the
+ * dispatcher scope still cascades to every worker via the parent-child
+ * scope link from `Scope.fork`.
+ *
+ * Backpressure: the queue is `Queue.bounded(capacity)`. `offer` is
+ * **non-blocking** — if the queue is full it fails with
+ * `PartitionQueueFullError` rather than suspending the caller. The
+ * reader fiber must NOT block; per-partition fullness is surfaced as
+ * a typed error and translated to a wire-level error response.
+ *
+ * Single-producer guarantee: only the dispatcher's reader-fiber path
+ * calls `offer` for any given partition. That makes the
+ * `Queue.size + offer` pre-check race-free for "full" detection: if
+ * size < capacity at the check, the subsequent `offer` cannot suspend
+ * because no other producer can fill the queue between check and
+ * offer. The drain fiber only consumes; it cannot push us past
+ * capacity.
+ *
+ * Why `idleSince` is a `MutableRef` (synchronous cell) rather than a
+ * `Ref`: the dispatcher's reaper inspects `idleSince._tag === "Idle"`
+ * inside a `Ref.modify` lambda over the partition map (synchronous
+ * lambda body — no `yield`). A `Ref.get` would require an Effect step
+ * we cannot take inside the lambda; `MutableRef.get` is synchronous.
+ * Producer (offer) and drain-loop sites use `MutableRef.set`. JS's
+ * single-threaded execution model makes the `Idle ↔ Busy` transitions
+ * race-free between fibers, and the dispatcher's atomic
+ * `Ref.modify(partitionsRef)` is the synchronization point that
+ * ensures snapshot+remove on idle partitions runs without an offer
+ * landing in between.
+ */
+import { Effect, Fiber, MutableRef, Scope } from "effect";
+import { PartitionQueueFullError } from "./s2c-dispatcher-errors.js";
+import type { PartitionKey, PartitionableRequest } from "./s2c-partition-key.js";
+import type { WsClientLogger } from "../ws-client.js";
+/**
+ * The handler the worker drains its queue against. Mirrors the existing
+ * `dispatchInboundServerRequest` signature in `ws-client.ts:912-965` —
+ * the dispatcher passes an already-bound function so the worker has no
+ * direct knowledge of the registered s2c handler registry.
+ *
+ * Defects inside `handle` are caught and logged by the worker; they
+ * never escape into the per-connection scope's failure channel.
+ */
+export type PartitionHandler = (request: PartitionableRequest) => Effect.Effect<void, never>;
+/**
+ * Idle / busy / retiring sum-type tracked per worker. See
+ * `PartitionWorker.idleSince`.
+ *
+ * - `Idle` — drain queue empty, last handler returned at `sinceMs`.
+ *   Eligible for reap once `sinceMs` ages past `idlePartitionTtlMs`.
+ * - `Busy` — handler running OR producer has reserved this worker
+ *   for a pending `Queue.offer`. Reaper skips Busy workers.
+ * - `Retiring` — reaper has claimed this worker for teardown
+ *   (transition done atomically inside the reaper's `Ref.modify`
+ *   lambda over the partition map). Producer's `worker.offer` MUST
+ *   refuse to enqueue when it observes `Retiring`; otherwise the
+ *   reaper's `Scope.close` would silently drop the just-enqueued
+ *   request, leaving the server-side `Deferred.await` to time out.
+ */
+export type IdleSince = {
+    readonly _tag: "Idle";
+    readonly sinceMs: number;
+} | {
+    readonly _tag: "Busy";
+} | {
+    readonly _tag: "Retiring";
+};
+/**
+ * One partition's runtime state. Constructed by `makePartitionWorker`;
+ * owned by the dispatcher's partition map.
+ */
+export interface PartitionWorker {
+    /** Identity. Read-only after construction. */
+    readonly key: PartitionKey;
+    /**
+     * Non-blocking offer. Fails with `PartitionQueueFullError` if the
+     * bounded queue is at capacity; never suspends. Idempotent under
+     * shutdown — post-shutdown offers fail with the same tag (queue is
+     * shut down, equivalent to "no capacity").
+     */
+    readonly offer: (request: PartitionableRequest) => Effect.Effect<void, PartitionQueueFullError>;
+    /**
+     * Worker fiber draining the queue via `Stream.runForEach(handle)`.
+     * Surfaced for observability + tests; the worker's `Scope.close` is
+     * the canonical teardown path (it triggers the queue.shutdown
+     * finalizer and interrupts the fiber via the scope cascade).
+     */
+    readonly fiber: Fiber.RuntimeFiber<void, never>;
+    /**
+     * Idle-since tracker. `Busy` while the worker has a request queued
+     * or a handler running; `Idle{sinceMs}` once the queue drains and
+     * the handler returns. Stored in a `MutableRef` so the dispatcher's
+     * reaper can read it synchronously inside its `Ref.modify` lambda
+     * over the partition map (the atomic check that prevents a reaped
+     * worker from receiving a concurrent offer between snapshot and
+     * removal).
+     */
+    readonly idleSince: MutableRef.MutableRef<IdleSince>;
+    /**
+     * Live queue size for `DispatcherStats`. Reaper does not consult
+     * this — it gates strictly on `idleSince._tag === "Idle"` to avoid
+     * races where the queue snapshot misses an in-flight item.
+     */
+    readonly queueSize: Effect.Effect<number>;
+    /**
+     * The closeable scope owning this worker's finalizers (queue
+     * shutdown, drain fiber). Forked from the dispatcher's scope by
+     * `getOrCreatePartitionWorker`; closing it cleanly retires the
+     * worker without orphaning finalizers on the parent dispatcher
+     * scope.
+     */
+    readonly scope: Scope.CloseableScope;
+}
+/**
+ * Construction parameters for one worker. Capacity and the handler are
+ * dispatcher-level config; `scope` is the per-worker closeable scope
+ * the dispatcher allocated via `Scope.fork`; logger is optional and
+ * matches the existing `WsClientLogger` shape used elsewhere in the
+ * client package.
+ */
+export interface PartitionWorkerConfig {
+    readonly key: PartitionKey;
+    readonly capacity: number;
+    readonly handle: PartitionHandler;
+    /**
+     * Per-worker scope owning every finalizer this worker registers
+     * (queue shutdown + drain fiber). The dispatcher's reaper closes
+     * this scope to retire the worker. Closing the parent dispatcher
+     * scope cascades through it via `Scope.fork`.
+     */
+    readonly scope: Scope.CloseableScope;
+    readonly logger?: WsClientLogger;
+    /** Monotonic clock for tests; defaults to `Date.now`. */
+    readonly clock?: () => number;
+}
+/**
+ * Build one worker. Allocates a bounded queue, forks a draining fiber
+ * via `Stream.fromQueue` + `Stream.runForEach`, and registers the
+ * scope finalizer that shuts the queue. Defects in `handle` are
+ * caught + logged; the fiber never fails.
+ *
+ * Returns `Effect<PartitionWorker, never>` — no `Scope.Scope`
+ * requirement. All scoped allocations (queue finalizer, forked drain
+ * fiber) are bound to the caller-provided `config.scope` via
+ * `Scope.extend`.
+ */
+export declare function makePartitionWorker(config: PartitionWorkerConfig): Effect.Effect<PartitionWorker, never>;
+//# sourceMappingURL=s2c-partition-worker.d.ts.map

package/dist/internal/s2c-partition-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s2c-partition-worker.d.ts","sourceRoot":"","sources":["../../src/internal/s2c-partition-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,EAAS,MAAM,EAAE,KAAK,EAAE,UAAU,EAAS,KAAK,EAAU,MAAM,QAAQ,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,OAAO,EAAE,oBAAoB,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAEhC;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC;AAElC;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,8CAA8C;IAC9C,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,OAAO,EAAE,oBAAoB,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAChD;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1C;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC;CACtC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC,yDAAyD;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,qBAAqB,GAC5B,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,KAAK,CAAC,CAmIvC"}

package/dist/internal/s2c-partition-worker.js

@@ -0,0 +1,141 @@
+/**
+ * Per-partition worker — bounded queue + forked fiber, owning ordering
+ * within one `(sessionId, conversationId, hookKind)` tuple.
+ *
+ * Spec: moltzap#356.
+ *
+ * Lifecycle is anchored in a per-worker `Scope.CloseableScope` provided
+ * by the dispatcher (`s2c-partitioned-dispatcher.ts`'s
+ * `getOrCreatePartitionWorker` calls `Scope.fork(dispatcherScope, …)`
+ * for each new worker and hands the child scope in via the config).
+ * Closing the worker's scope shuts the queue, runs registered
+ * finalizers, and interrupts the drain fiber — cascading finalization
+ * with no orphan references on the dispatcher scope. Closing the
+ * dispatcher scope still cascades to every worker via the parent-child
+ * scope link from `Scope.fork`.
+ *
+ * Backpressure: the queue is `Queue.bounded(capacity)`. `offer` is
+ * **non-blocking** — if the queue is full it fails with
+ * `PartitionQueueFullError` rather than suspending the caller. The
+ * reader fiber must NOT block; per-partition fullness is surfaced as
+ * a typed error and translated to a wire-level error response.
+ *
+ * Single-producer guarantee: only the dispatcher's reader-fiber path
+ * calls `offer` for any given partition. That makes the
+ * `Queue.size + offer` pre-check race-free for "full" detection: if
+ * size < capacity at the check, the subsequent `offer` cannot suspend
+ * because no other producer can fill the queue between check and
+ * offer. The drain fiber only consumes; it cannot push us past
+ * capacity.
+ *
+ * Why `idleSince` is a `MutableRef` (synchronous cell) rather than a
+ * `Ref`: the dispatcher's reaper inspects `idleSince._tag === "Idle"`
+ * inside a `Ref.modify` lambda over the partition map (synchronous
+ * lambda body — no `yield`). A `Ref.get` would require an Effect step
+ * we cannot take inside the lambda; `MutableRef.get` is synchronous.
+ * Producer (offer) and drain-loop sites use `MutableRef.set`. JS's
+ * single-threaded execution model makes the `Idle ↔ Busy` transitions
+ * race-free between fibers, and the dispatcher's atomic
+ * `Ref.modify(partitionsRef)` is the synchronization point that
+ * ensures snapshot+remove on idle partitions runs without an offer
+ * landing in between.
+ */
+import { Cause, Effect, Fiber, MutableRef, Queue, Scope, Stream } from "effect";
+import { PartitionQueueFullError } from "./s2c-dispatcher-errors.js";
+/**
+ * Build one worker. Allocates a bounded queue, forks a draining fiber
+ * via `Stream.fromQueue` + `Stream.runForEach`, and registers the
+ * scope finalizer that shuts the queue. Defects in `handle` are
+ * caught + logged; the fiber never fails.
+ *
+ * Returns `Effect<PartitionWorker, never>` — no `Scope.Scope`
+ * requirement. All scoped allocations (queue finalizer, forked drain
+ * fiber) are bound to the caller-provided `config.scope` via
+ * `Scope.extend`.
+ */
+export function makePartitionWorker(config) {
+    const clock = config.clock ?? Date.now;
+    return Scope.extend(Effect.gen(function* () {
+        const queue = yield* Queue.bounded(config.capacity);
+        const idleSince = MutableRef.make({
+            _tag: "Idle",
+            sinceMs: clock(),
+        });
+        // Drain loop: take → mark Busy → run handler (catching defects)
+        // → mark Idle if queue is now empty. `Stream.fromQueue` ends
+        // naturally when the queue is shut down (Scope finalizer below),
+        // so the fiber returns cleanly without an explicit interrupt for
+        // the happy path.
+        const drainEffect = Stream.fromQueue(queue).pipe(Stream.runForEach((request) => Effect.gen(function* () {
+            MutableRef.set(idleSince, { _tag: "Busy" });
+            yield* config.handle(request).pipe(Effect.catchAllCause((cause) => Effect.sync(() => {
+                config.logger?.warn(`s2c partition worker handler defected (key=${config.key})`, Cause.pretty(cause));
+            })));
+            const remaining = yield* Queue.size(queue).pipe(Effect.catchAllCause(() => Effect.succeed(0)));
+            if (remaining === 0) {
+                MutableRef.set(idleSince, {
+                    _tag: "Idle",
+                    sinceMs: clock(),
+                });
+            }
+        })), Effect.catchAllCause((cause) => Effect.sync(() => {
+            config.logger?.warn(`s2c partition worker fiber exited (key=${config.key})`, Cause.pretty(cause));
+        })), Effect.asVoid);
+        const fiber = yield* Effect.forkScoped(drainEffect);
+        // Shut the queue when the worker scope closes. `Effect.forkScoped`
+        // already covers fiber interruption; queue.shutdown is the
+        // belt-and-braces guarantee that the running stream observes the
+        // shutdown and returns even if the fiber is mid-handler.
+        yield* Effect.addFinalizer(() => Queue.shutdown(queue).pipe(Effect.catchAllCause(() => Effect.void)));
+        const offer = (request) => Effect.gen(function* () {
+            const size = yield* Queue.size(queue).pipe(
+            // `Queue.size` on a shut-down queue surfaces interrupt; treat
+            // every failure as "queue unavailable" → full-error tag.
+            Effect.catchAllCause(() => Effect.succeed(config.capacity)));
+            if (size >= config.capacity) {
+                return yield* Effect.fail(new PartitionQueueFullError({
+                    key: config.key,
+                    capacity: config.capacity,
+                    requestId: request.id,
+                }));
+            }
+            // Atomic CAS: transition Idle/Busy → Busy, but refuse if the
+            // dispatcher's reaper has already claimed this worker for
+            // teardown (`Retiring`). The reaper sets `Retiring`
+            // synchronously inside its `Ref.modify(partitionsRef, …)`
+            // lambda, so once we observe `Retiring` here, the worker has
+            // already been removed from the partition map and its scope
+            // is being closed. Failing without enqueueing is the correct
+            // and only safe move — a queued item would be silently
+            // dropped when `Scope.close` fires `Queue.shutdown`.
+            const claim = MutableRef.updateAndGet(idleSince, (current) => current._tag === "Retiring" ? current : { _tag: "Busy" });
+            if (claim._tag === "Retiring") {
+                return yield* Effect.fail(new PartitionQueueFullError({
+                    key: config.key,
+                    capacity: config.capacity,
+                    requestId: request.id,
+                }));
+            }
+            const accepted = yield* Queue.offer(queue, request).pipe(Effect.catchAllCause(() => Effect.succeed(false)));
+            if (!accepted) {
+                // Queue shut down between size-check and offer — surface as
+                // `PartitionQueueFullError` so the reader's tag-discrimination
+                // path treats it identically to "queue full".
+                return yield* Effect.fail(new PartitionQueueFullError({
+                    key: config.key,
+                    capacity: config.capacity,
+                    requestId: request.id,
+                }));
+            }
+        });
+        return {
+            key: config.key,
+            offer,
+            fiber,
+            idleSince,
+            queueSize: Queue.size(queue).pipe(Effect.catchAllCause(() => Effect.succeed(0))),
+            scope: config.scope,
+        };
+    }), config.scope);
+}
+//# sourceMappingURL=s2c-partition-worker.js.map

package/dist/internal/s2c-partition-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"s2c-partition-worker.js","sourceRoot":"","sources":["../../src/internal/s2c-partition-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAgHrE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAA6B;IAE7B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC;IACvC,OAAO,KAAK,CAAC,MAAM,CACjB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,OAAO,CAAuB,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC1E,MAAM,SAAS,GAAG,UAAU,CAAC,IAAI,CAAY;YAC3C,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,KAAK,EAAE;SACjB,CAAC,CAAC;QAEH,gEAAgE;QAChE,6DAA6D;QAC7D,iEAAiE;QACjE,iEAAiE;QACjE,kBAAkB;QAClB,MAAM,WAAW,GAA+B,MAAM,CAAC,SAAS,CAC9D,KAAK,CACN,CAAC,IAAI,CACJ,MAAM,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;YAClB,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAW,CAAC,CAAC;YACrD,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAChC,MAAM,CAAC,aAAa,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;gBACf,MAAM,CAAC,MAAM,EAAE,IAAI,CACjB,8CAA8C,MAAM,CAAC,GAAG,GAAG,EAC3D,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CACpB,CAAC;YACJ,CAAC,CAAC,CACH,CACF,CAAC;YACF,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAC7C,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAC9C,CAAC;YACF,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;gBACpB,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE;oBACxB,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,KAAK,EAAE;iBACR,CAAC,CAAC;YACd,CAAC;QACH,CAAC,CAAC,CACH,EACD,MAAM,CAAC,aAAa,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE;YACf,MAAM,CAAC,MAAM,EAAE,IAAI,CACjB,0CAA0C,MAAM,CAAC,GAAG,GAAG,EACvD,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CACpB,CAAC;QACJ,CAAC,CAAC,CACH,EACD,MAAM,CAAC,MAAM,CACd,CAAC;QACF,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;QAEpD,mEAAmE;QACnE,2DAA2D;QAC3D,iEAAiE;QACjE,yDAAyD;QACzD,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAC9B,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CACpE,CAAC;QAEF,MAAM,KAAK,GAAG,CACZ,OAA6B,EACiB,EAAE,CAChD,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;YAClB,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI;YACxC,8DAA8D;YAC9D,yDAAyD;YACzD,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAC5D,CAAC;YACF,IAAI,IAAI,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAC5B,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,uBAAuB,CAAC;oBAC1B,GAAG,EAAE,MAAM,CAAC,GAAG;oBACf,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,SAAS,EAAE,OAAO,CAAC,EAAE;iBACtB,CAAC,CACH,CAAC;YACJ,CAAC;YACD,6DAA6D;YAC7D,0DAA0D;YAC1D,oDAAoD;YACpD,0DAA0D;YAC1D,6DAA6D;YAC7D,4DAA4D;YAC5D,6DAA6D;YAC7D,uDAAuD;YACvD,qDAAqD;YACrD,MAAM,KAAK,GAAG,UAAU,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAC3D,OAAO,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAE,EAAE,IAAI,EAAE,MAAM,EAAY,CACpE,CAAC;YACF,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC9B,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,uBAAuB,CAAC;oBAC1B,GAAG,EAAE,MAAM,CAAC,GAAG;oBACf,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,SAAS,EAAE,OAAO,CAAC,EAAE;iBACtB,CAAC,CACH,CAAC;YACJ,CAAC;YACD,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CACtD,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAClD,CAAC;YACF,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,4DAA4D;gBAC5D,+DAA+D;gBAC/D,8CAA8C;gBAC9C,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,uBAAuB,CAAC;oBAC1B,GAAG,EAAE,MAAM,CAAC,GAAG;oBACf,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,SAAS,EAAE,OAAO,CAAC,EAAE;iBACtB,CAAC,CACH,CAAC;YACJ,CAAC;QACH,CAAC,CAAC,CAAC;QAEL,OAAO;YACL,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,KAAK;YACL,KAAK;YACL,SAAS;YACT,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAC/B,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAC9C;YACD,KAAK,EAAE,MAAM,CAAC,KAAK;SACM,CAAC;IAC9B,CAAC,CAAC,EACF,MAAM,CAAC,KAAK,CACb,CAAC;AACJ,CAAC"}