@moltzap/client 2026.507.0 → 2026.508.1

package/dist/internal/app-callback-partition-worker.d.ts

@@ -1,160 +0,0 @@
-/**
- * Per-partition worker — bounded queue + forked fiber, owning ordering
- * within one `(taskId, conversationId, hookKind)` tuple.
- *
- * Spec: moltzap#356.
- *
- * Lifecycle is anchored in a per-worker `Scope.CloseableScope` provided
- * by the dispatcher (`app-callback-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 "./app-callback-dispatcher-errors.js";
-import type { PartitionKey, PartitionableRequest } from "./app-callback-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 appCallback 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=app-callback-partition-worker.d.ts.map

package/dist/internal/app-callback-partition-worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-callback-partition-worker.d.ts","sourceRoot":"","sources":["../../src/internal/app-callback-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,qCAAqC,CAAC;AAC9E,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EACrB,MAAM,iCAAiC,CAAC;AACzC,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/app-callback-partition-worker.js

@@ -1,141 +0,0 @@
-/**
- * Per-partition worker — bounded queue + forked fiber, owning ordering
- * within one `(taskId, conversationId, hookKind)` tuple.
- *
- * Spec: moltzap#356.
- *
- * Lifecycle is anchored in a per-worker `Scope.CloseableScope` provided
- * by the dispatcher (`app-callback-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 "./app-callback-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(`appCallback 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(`appCallback 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=app-callback-partition-worker.js.map

package/dist/internal/app-callback-partition-worker.js.map

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

package/dist/internal/app-callback-partitioned-dispatcher.d.ts

@@ -1,180 +0,0 @@
-/**
- * Partitioned appCallback dispatcher.
- *
- * Spec: moltzap#356.
- *
- * Replaces the single `Stream.runForEach(handler)` over `appCallbackInboundQueue`
- * (`packages/client/src/ws-client.ts:658-687@f0df363`) with a
- * partition-router that owns a `Ref<HashMap<PartitionKey,
- * PartitionWorker>>`. For each inbound request:
- *
- *   1. The reader fiber calls `dispatcher.offer(request)`.
- *   2. The dispatcher extracts the partition key (pure, no schema decode).
- *   3. If a worker exists for that key, `worker.offer(request)`.
- *   4. Otherwise, allocate a worker (subject to soft cap) and offer.
- *
- * The dispatcher itself does NOT run a long-lived router fiber: routing
- * is synchronous-up-to-effect on the reader's call thread. The only
- * dispatcher-owned fiber is the **idle reaper**, which periodically
- * walks the partition map and finalizes any worker whose
- * `idleSince._tag === "Idle"` exceeds `idlePartitionTtlMs`.
- *
- * Single-producer guarantee: `dispatcher.offer` is only called from
- * the per-connection reader fiber's `Stream.runForEach` loop in
- * `ws-client.ts:1052-1086`. There is no second producer; concurrent
- * `offer` calls within one dispatcher cannot occur. The actual
- * concurrency property a router would otherwise be defending against
- * is route-vs-drain: the route step (one `Ref.modify` against the
- * partition map + a non-blocking `worker.offer`) is wait-free against
- * every running worker fiber's drain loop. No router fiber means no
- * intermediate buffer between the reader and the per-key worker
- * queue, and no scheduling overhead per route decision.
- *
- * Lifetime: `make` returns `Effect<…, never, Scope.Scope>`. The caller
- * (`ws-client.ts` inside `connectEffect`) calls `Scope.make()` to
- * produce a **dedicated dispatcher Scope** that is NOT bound to the
- * socket Scope, then provides that Scope to `makePartitionedDispatcher`.
- * The dispatcher Scope is held in `ConnState`; teardown from
- * `close()` / `disconnectSync()` is
- * `runtime.runFork(Scope.close(dispatcherScope, Exit.void))`, mirroring
- * today's `runFork(Queue.shutdown(appCallbackInboundQueue))` +
- * `runFork(Fiber.interrupt(appCallbackDispatcherFiber))` pair.
- *
- * Why off-Scope from the socket: `close()` is invoked via `runSync` at
- * `packages/openclaw-channel/src/__tests__/reconnection.integration.test.ts:14`;
- * binding the dispatcher to the socket Scope would make `Scope.close`
- * yield through the runtime (queue.shutdown + fiber.interrupt are
- * non-synchronous), breaking the regression gate at
- * `packages/client/src/ws-client.test.ts:1233-1259`.
- * The `runSync(client.close())` contract is load-bearing — see the
- * test commentary there.
- *
- * Worker scopes are forked children of the dispatcher Scope
- * (`getOrCreatePartitionWorker` calls `Scope.fork(dispatcherScope, …)`
- * for each new worker and provides the child scope to
- * `makePartitionWorker`). Closing the dispatcher Scope cascades to
- * every worker; closing one worker's child scope retires only that
- * worker without leaking finalizers onto the dispatcher scope.
- */
-import { Effect, Scope } from "effect";
-import { type OfferRejected } from "./app-callback-dispatcher-errors.js";
-import { type PartitionKey, type PartitionableRequest } from "./app-callback-partition-key.js";
-import { type PartitionHandler } from "./app-callback-partition-worker.js";
-import type { WsClientLogger } from "../ws-client.js";
-/**
- * Tunable knobs. Defaults named in the design doc; downstream picks
- * exact values at the `MoltZapWsClient` constructor edge.
- */
-export interface PartitionedDispatcherConfig {
-    /**
-     * Soft cap on simultaneously-active partitions per connection.
-     * Default 256. Hit → new partitions fail with `PartitionLimitError`
-     * until the idle reaper retires one.
-     */
-    readonly maxPartitions: number;
-    /**
-     * Bounded queue depth per partition. Default 32. Hit → `offer` fails
-     * with `PartitionQueueFullError` for THIS partition only.
-     */
-    readonly partitionQueueCapacity: number;
-    /**
-     * Idle reaper threshold: a worker whose queue has been continuously
-     * empty for at least this many milliseconds is finalized on the next
-     * reaper tick. Default 60_000.
-     */
-    readonly idlePartitionTtlMs: number;
-    /**
-     * Idle reaper tick period. Default 5_000. Lower = tighter reclamation,
-     * higher CPU cost; higher = looser reclamation, lower overhead.
-     */
-    readonly idleReaperIntervalMs: number;
-}
-/** Defaults. Documented as the named knob values for the implementation. */
-export declare const DEFAULT_PARTITIONED_DISPATCHER_CONFIG: PartitionedDispatcherConfig;
-/**
- * Snapshot of dispatcher state for tests + observability. NOT stable
- * across releases; consumers must treat as best-effort instrumentation.
- */
-export interface DispatcherStats {
-    readonly activePartitions: number;
-    readonly totalOffered: number;
-    readonly totalRejected: {
-        readonly partitionLimit: number;
-        readonly partitionQueueFull: number;
-    };
-    readonly partitions: ReadonlyArray<{
-        readonly key: PartitionKey;
-        readonly queueSize: number;
-        readonly idle: boolean;
-    }>;
-}
-/**
- * Public surface used by `ws-client.ts`. Construction is scoped — the
- * caller's `Scope` owns every partition fiber.
- */
-export interface PartitionedDispatcher {
-    /**
-     * Route one inbound request. Non-blocking. Failure modes are
-     * exhaustive in `OfferRejected`; the reader fiber `Effect.match`es
-     * the tag set to pick a wire-error code.
-     *
-     * Per-tuple ordering: two `offer` calls with the same `PartitionKey`
-     * land on the same `PartitionWorker.offer` (FIFO).
-     * Cross-tuple concurrency: two `offer` calls with different keys
-     * produce no ordering relation.
-     */
-    readonly offer: (request: PartitionableRequest) => Effect.Effect<void, OfferRejected>;
-    /**
-     * Best-effort stats snapshot. Not used in the hot path; called by
-     * tests + the optional `client.stats()` debug surface.
-     */
-    readonly stats: Effect.Effect<DispatcherStats>;
-    /**
-     * Explicit shutdown. Equivalent to `Scope.close(dispatcherScope,
-     * Exit.void)`; exists as a typed handle so callsites that already
-     * hold the dispatcher (not the Scope) can tear it down without
-     * threading the Scope through `ConnState`. Idempotent.
-     *
-     * Callsites that invoke this from a `runSync` context (`close()`,
-     * `disconnectSync()`) MUST wrap with `runtime.runFork`. The Effect
-     * itself yields through the runtime (queue shutdown + fiber
-     * interrupt are non-synchronous); calling `runSync` on it would throw
-     * `AsyncFiberException`. See the regression gate at
-     * `packages/client/src/ws-client.test.ts:1233-1259@f0df363`.
-     */
-    readonly shutdown: Effect.Effect<void>;
-}
-/**
- * Construction params. `handle` is the per-request work — passed in so
- * the dispatcher has no direct dependency on the handler-registry
- * `Ref<HashMap<string, ServerRpcHandler>>` (`appCallbackHandlersRef`); the
- * caller (`ws-client.ts`) closes over the registry and supplies a
- * pre-bound function. This preserves the wire-edge schema-decoding
- * boundary already established in `dispatchInboundServerRequest`.
- *
- * `scope` is the `Scope.CloseableScope` that owns every per-partition
- * worker fiber + the idle reaper. The caller (`ws-client.ts`)
- * allocates it via `Scope.make()` outside the per-connect socket
- * Scope so `runSync(client.close())` can `runFork(Scope.close(scope,
- * Exit.void))` without yielding through the runtime.
- */
-export interface MakePartitionedDispatcherParams {
-    readonly handle: PartitionHandler;
-    readonly scope: Scope.CloseableScope;
-    readonly config?: Partial<PartitionedDispatcherConfig>;
-    readonly logger?: WsClientLogger;
-    /** Monotonic clock for tests. Defaults to `Date.now`. */
-    readonly clock?: () => number;
-}
-/**
- * Construct a partitioned dispatcher. The caller-provided
- * `params.scope` owns every per-partition fiber + the idle-reaper
- * fiber; closing it cascades teardown via `Scope` finalizers.
- *
- * Returns `Effect<…, never>` — neither construction nor partition
- * allocation can fail. The Effect itself does not require a `Scope`
- * because every scoped allocation is provided to `params.scope`
- * explicitly via `Scope.extend`.
- */
-export declare function makePartitionedDispatcher(params: MakePartitionedDispatcherParams): Effect.Effect<PartitionedDispatcher, never>;
-//# sourceMappingURL=app-callback-partitioned-dispatcher.d.ts.map

package/dist/internal/app-callback-partitioned-dispatcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"app-callback-partitioned-dispatcher.d.ts","sourceRoot":"","sources":["../../src/internal/app-callback-partitioned-dispatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,EAGL,MAAM,EAQN,KAAK,EACN,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,oBAAoB,EAC1B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,KAAK,gBAAgB,EAEtB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;;OAIG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC;AAED,4EAA4E;AAC5E,eAAO,MAAM,qCAAqC,EAAE,2BAMjD,CAAC;AAEJ;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE;QACtB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;QAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;KACrC,CAAC;IACF,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;QACjC,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;QAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;KACxB,CAAC,CAAC;CACJ;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,CACd,OAAO,EAAE,oBAAoB,KAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IACxC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;IAC/C;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACvD,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC,yDAAyD;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B;AAoCD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,+BAA+B,GACtC,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAgH7C"}