@moltzap/client 2026.812.0 → 2026.902.0

package/dist/channel-core.d.ts

@@ -1,306 +0,0 @@
-/**
- * Channel core: serialized inbound turn delivery over a MoltZapService.
- * Owns the inbound queue, same-conversation coalescing, the interceptor
- * gate, the per-turn timeout, and channel teardown. Enriched adapter delivery
- * uses channel-core-enrichment.ts; raw daemon delivery receives the coalesced
- * Message batch without reading or committing presentation context.
- */
-import { Effect } from "effect";
-import type { ConversationId } from "@moltzap/protocol/conversation";
-import type { Message } from "@moltzap/protocol/message";
-import type { CrossConversationEntry, CrossConvMessage, ServiceRpcError } from "./service.js";
-/** Projects MCP-reconstructed context through the channel-owned presentation. */
-export { projectHarnessTurn } from "./channel-core-enrichment.js";
-/** Describes enriched sender. */
-interface EnrichedSender {
-    id: string;
-    name: string;
-}
-/** Describes enriched conversation meta. */
-export interface EnrichedConversationMeta {
-    type: "dm" | "group";
-    name?: string;
-    /** "type:id" strings (e.g. "agent:uuid"). */
-    participants: string[];
-}
-/** Describes context blocks. */
-export interface ContextBlocks {
-    groupMetadata?: EnrichedConversationMeta;
-    crossConversation?: CrossConversationEntry[];
-    crossConversationMessages?: CrossConvMessage[];
-}
-/** Describes enriched inbound message. */
-export interface EnrichedInboundMessage {
-    id: string;
-    conversationId: ConversationId;
-    sender: EnrichedSender;
-    /** Text parts joined with newlines. Non-text parts dropped. */
-    text: string;
-    isFromMe: boolean;
-    createdAt: string;
-    conversationMeta?: EnrichedConversationMeta;
-    contextBlocks: ContextBlocks;
-    /**
-     * Present when multiple queued messages from the same conversation were
-     * coalesced into this single turn. Includes the primary message first.
-     */
-    coalescedMessages?: ReadonlyArray<{
-        id: string;
-        sender: EnrichedSender;
-        text: string;
-        createdAt: string;
-    }>;
-}
-/** The subset of MoltZapService that MoltZapChannelCore needs. */
-export interface ChannelService {
-    readonly ownAgentId?: string;
-    on(event: "message", handler: (payload: {
-        message: Message;
-    }) => void): void;
-    on(event: "disconnect", handler: () => void): void;
-    connect(): Effect.Effect<unknown, ServiceRpcError>;
-    /**
-     * Effectful teardown for scoped process owners, which need the service's
-     * transports closed before the scope's release completes. Services that
-     * only offer the fire-and-forget {@link ChannelService.close} omit it.
-     */
-    shutdown?(): Effect.Effect<void>;
-    close(): void;
-    send(conversationId: ConversationId, text: string): Effect.Effect<void, ServiceRpcError>;
-    getConversation(convId: string): {
-        type: string;
-        name?: string;
-        participants: string[];
-    } | undefined;
-    getAgentName(agentId: string): string | undefined;
-    resolveAgentName(agentId: string): Effect.Effect<string>;
-    peekContextEntries(currentConvId: string, opts?: {
-        maxConversations?: number;
-        maxMessagesPerConv?: number;
-    }): {
-        entries: CrossConversationEntry[];
-        commit: () => void;
-    };
-    peekFullMessages(currentConvId: string): {
-        messages: CrossConvMessage[];
-        commit: () => void;
-    };
-}
-/** Configures channel core. */
-export interface ChannelCoreOptions {
-    service: ChannelService;
-    /**
-     * Wall-clock bound on one handler invocation. On expiry the turn is
-     * abandoned and the consumer keeps draining.
-     *
-     * Unset means unbounded, which is the safe default for runtimes whose
-     * turns legitimately run for minutes: nothing else can interrupt the
-     * handler, so a bound that is too tight silently drops real work. The
-     * cost of leaving it unset is that a hung handler stalls the serial
-     * drain forever — set it for runtimes that can wedge.
-     *
-     * The bound covers the handler only. Enrichment and
-     * {@link ChannelCoreOptions.inboundInterceptor} run outside it.
-     */
-    turnTimeoutMs?: number;
-    /**
-     * Endpoint-side gate consulted once per coalesced turn before the selected
-     * handler. The enriched path performs enrichment before the gate; the raw
-     * path deliberately does not enrich. Unset is passthrough.
-     */
-    inboundInterceptor?: InboundInterceptor;
-}
-/**
- * Handler invoked for every enriched inbound message. Returns an Effect so the
- * error channel is part of the type — callers fail with a tagged error and the
- * consumer fiber logs it instead of dropping it on the floor like a Promise
- * rejection would.
- */
-export type InboundHandler<E = unknown> = (msg: EnrichedInboundMessage) => Effect.Effect<void, E>;
-/**
- * Handler for one coalesced raw inbound turn. The existing Message values are
- * delivered in arrival order after the inbound interceptor admits the batch.
- * Raw delivery does not enrich messages or read and commit presentation
- * context.
- */
-export type RawInboundHandler<E = unknown> = (messages: readonly Message[]) => Effect.Effect<void, E>;
-/**
- * Verdict an {@link InboundInterceptor} returns for one coalesced turn.
- *
- * The union is closed at deliver and drop on purpose: there is no hold or
- * delay verdict. An interceptor is an Effect, so pacing is expressed by
- * suspending inside it — an ambient Clock sleep, a semaphore, a gate the
- * embedder opens later — and the verdict says only whether the turn runs. A
- * hold verdict would ask the core to park this turn and start the next one,
- * which is the multi-turn concurrency the single consumer fiber exists to
- * prevent.
- */
-export type InboundInterceptDecision = {
-    readonly _tag: "deliver";
-} | {
-    readonly _tag: "drop";
-    readonly reason?: string;
-};
-/**
- * Gate the embedder installs between coalescing and the selected handler. The
- * enriched handler path performs enrichment before consulting the gate; the
- * raw handler path does not enrich. The gate receives the newest message of
- * the coalesced batch — a gate deciding whether a turn is still worth running
- * cares about the latest thing said — and its verdict governs the whole batch.
- *
- * It runs on the single consumer fiber, so suspending inside it delays this
- * turn and every message queued behind it, and `turnTimeoutMs` does not bound
- * that suspension. An interceptor that never resumes stalls the drain
- * permanently.
- *
- * A defect, a failure, or a synchronous throw delivers. An embedder bug in a
- * gate must not silently black-hole a production channel: a channel that
- * over-delivers announces itself, one that has gone quiet looks like a network
- * problem for hours.
- */
-export type InboundInterceptor = (message: Message) => Effect.Effect<InboundInterceptDecision>;
-/**
- * Wraps a `MoltZapService` with one-turn-at-a-time inbound delivery and a send
- * helper. Adapter handlers receive enriched messages. A daemon handler may
- * instead receive the admitted coalesced raw Message batch. One core per
- * service — `getContextEntries()` is side-effectful (advances
- * per-conversation markers), so a second core would consume entries the first
- * expected.
- *
- * Turn-taking is entirely endpoint-local: the server delivers every message
- * it accepts, and this core decides when the runtime sees them.
- *
- * Inbound path from wire bytes to user handler:.
- *
- * ```mermaid
- * sequenceDiagram
- *   participant server
- *   participant ws as MoltZapAgentClient
- *   participant svc as MoltZapService
- *   participant core as MoltZapChannelCore
- *   participant raw as RawInboundHandler
- *   participant enriched as InboundHandler
- *
- *   server->>ws: agent/message/received notification
- *   ws->>svc: subscribers.dispatch — fanout(message)
- *   svc->>core: message listener
- *   Note over core: dedup via recordMessageIdIfNew, drop when stopped or no handler is installed, then Queue.unsafeOffer(inboundQueue, message)
- *   Note over core: consumer fiber — Queue.take
- *   Note over core: takeCoalescedConversationMessages drains same-conv backlog into one turn
- *   alt raw daemon handler
- *     Note over core: inboundInterceptor — deliver or drop this batch
- *     core->>raw: rawInboundHandler(messages)
- *     raw-->>core: Effect.void
- *   else enriched adapter handler
- *     Note over core: enrichMessage — sender name, conversation, context entries
- *     Note over core: inboundInterceptor — deliver or drop this turn
- *     core->>enriched: inboundHandler(enriched)
- *     enriched-->>core: Effect.void
- *     Note over core: completed handler commits presentation context
- *   end
- *   Note over core: handler exceeds turnTimeoutMs — turn abandoned, drain continues
- * ```
- *
- * The single consumer fiber awaits the handler inline, so at most one turn
- * runs at a time and messages that arrive mid-turn wait in the queue.
- */
-export declare class MoltZapChannelCore {
-    private readonly service;
-    private readonly turnTimeoutMs?;
-    private readonly inboundInterceptor?;
-    private connected;
-    private stopped;
-    private inboundHandler;
-    /**
-     * Inbound messages with an installed handler enqueue synchronously; a single
-     * forked consumer fiber serialises delivery so handlers execute
-     * one-at-a-time in arrival order.
-     */
-    private readonly inboundQueue;
-    private readonly consumerFiber;
-    private readonly disconnectHandlers;
-    constructor(opts: ChannelCoreOptions);
-    private registerMessageListener;
-    private startConsumerFiber;
-    private logInboundFailure;
-    private registerConnectionListeners;
-    /**
-     * Replaces any previous handler.
-     * @param handler Handler invoked for matching requests.
-     */
-    onInbound<E>(handler: InboundHandler<E>): void;
-    /**
-     * Replaces any previous handler with a raw coalesced-turn handler. The
-     * admitted batch passes the interceptor and reaches the handler without
-     * enrichment or presentation-context commits.
-     * @param handler Handler invoked for each admitted raw batch.
-     */
-    onRawInbound<E>(handler: RawInboundHandler<E>): void;
-    onDisconnect(handler: () => void): void;
-    private fanout;
-    connect(): Effect.Effect<void, ServiceRpcError>;
-    /**
-     * Tear the channel down, resolving only once the service's own transports
-     * are closed. A scoped owner releases this before its process exits, so
-     * fire-and-forget teardown would leave sockets open past the scope.
-     *
-     * Service shutdown runs concurrently with interrupting the consumer fiber
-     * because an in-flight turn's finalizer can take arbitrarily long. Awaiting
-     * the interrupt first would hold the transports open for exactly as long as
-     * that finalizer runs.
-     * @returns Completion of the channel-owned teardown.
-     */
-    disconnect(): Effect.Effect<void>;
-    isConnected(): boolean;
-    /**
-     * Reply into a conversation.
-     * @param conversationId Value supplied to the operation.
-     * @param text Text to process.
-     * @returns The send result.
-     */
-    sendReply(conversationId: ConversationId, text: string): Effect.Effect<void, ServiceRpcError>;
-    private runInboundTurn;
-    /**
-     * Consult the interceptor for this turn, if one is installed.
-     * @param messages The coalesced batch, primary first.
-     * @returns Whether the handler runs for this batch.
-     */
-    private interceptTurn;
-    /**
-     * Apply a verdict, logging the drops at debug so a quiet channel can be
-     * traced back to its gate.
-     * @param newest Message the interceptor judged.
-     * @param decision Verdict for the whole coalesced batch.
-     * @returns Whether the handler runs.
-     */
-    private applyInterceptDecision;
-    private logInterceptorFailure;
-    /**
-     * Await the user handler, bounded by `turnTimeoutMs` when it is set.
-     * @param handler Installed inbound handler.
-     * @param input Value delivered to the selected handler.
-     * @param primary Message that opened this turn.
-     * @returns Whether the handler ran to completion.
-     */
-    private awaitHandlerTurn;
-    /**
-     * Drain every queued message for the primary's conversation into one turn,
-     * leaving other conversations queued in arrival order. Coalescing keeps a
-     * burst in one conversation from costing one turn per message.
-     * @param primary Message that opened this turn.
-     * @returns The messages belonging to this turn, primary first.
-     */
-    private takeCoalescedConversationMessages;
-    /**
-     * Stateless enrichment helper. Falls back to `sender.id` if
-     * `resolveAgentName` throws (e.g. Service not yet connected).
-     * @param service Value supplied to the operation.
-     * @param messageOrMessages Value supplied to the operation.
-     * @returns The enriched message and its context-commit callback.
-     */
-    static enrichMessage(service: ChannelService, messageOrMessages: Message | readonly Message[]): Effect.Effect<{
-        enriched: EnrichedInboundMessage;
-        commitContext?: () => void;
-    }>;
-}
-//# sourceMappingURL=channel-core.d.ts.map

package/dist/channel-core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel-core.d.ts","sourceRoot":"","sources":["../src/channel-core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAA0B,MAAM,EAAwB,MAAM,QAAQ,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EAChB,MAAM,cAAc,CAAC;AAEtB,iFAAiF;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAElE,iCAAiC;AACjC,UAAU,cAAc;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,4CAA4C;AAC5C,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,gCAAgC;AAChC,MAAM,WAAW,aAAa;IAC5B,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,iBAAiB,CAAC,EAAE,sBAAsB,EAAE,CAAC;IAC7C,yBAAyB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChD;AAED,0CAA0C;AAC1C,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,cAAc,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAC5C,aAAa,EAAE,aAAa,CAAC;IAE7B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,aAAa,CAAC;QAChC,EAAE,EAAE,MAAM,CAAC;QACX,MAAM,EAAE,cAAc,CAAC;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;CACJ;AAED,kEAAkE;AAClE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,EAAE,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAC7E,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACnD,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,CACF,cAAc,EAAE,cAAc,EAC9B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IACxC,eAAe,CACb,MAAM,EAAE,MAAM,GACb;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,SAAS,CAAC;IACvE,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAClD,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACzD,kBAAkB,CAChB,aAAa,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAE,GAChE;QAAE,OAAO,EAAE,sBAAsB,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;IAC7D,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG;QACvC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;QAC7B,MAAM,EAAE,MAAM,IAAI,CAAC;KACpB,CAAC;CACH;AAED,+BAA+B;AAC/B,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,cAAc,CAAC;IAExB;;;;;;;;;;;;OAYG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,CACxC,GAAG,EAAE,sBAAsB,KACxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAE5B;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,CAC3C,QAAQ,EAAE,SAAS,OAAO,EAAE,KACzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAM5B;;;;;;;;;;GAUG;AACH,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;AAwC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAqB;IACzD,OAAO,CAAC,SAAS,CAAS;IAO1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAyC;IAE/D;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAE3B;IACF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA2B;IACzD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAyB;IAE5D,YAAY,IAAI,EAAE,kBAAkB,EAYnC;IAED,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,2BAA2B;IAOnC;;;OAGG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI,CAE7C;IAED;;;;;OAKG;IACH,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI,CAEnD;IAED,YAAY,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAEtC;IAED,OAAO,CAAC,MAAM;IAed,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAkB9C;IAED;;;;;;;;;;OAUG;IACH,UAAU,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAoBhC;IAED,WAAW,IAAI,OAAO,CAErB;IAED;;;;;OAKG;IACH,SAAS,CACP,cAAc,EAAE,cAAc,EAC9B,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAEtC;IAED,OAAO,CAAC,cAAc;IAkCtB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IA4BrB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAiB9B,OAAO,CAAC,qBAAqB;IAe7B;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IA+BxB;;;;;;OAMG;IACH,OAAO,CAAC,iCAAiC;IAuBzC;;;;;;OAMG;IACH,MAAM,CAAC,aAAa,CAClB,OAAO,EAAE,cAAc,EACvB,iBAAiB,EAAE,OAAO,GAAG,SAAS,OAAO,EAAE,GAC9C,MAAM,CAAC,MAAM,CAAC;QACf,QAAQ,EAAE,sBAAsB,CAAC;QACjC,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;KAC5B,CAAC,CAED;CACF"}

package/dist/channel-core.js

@@ -1,365 +0,0 @@
-/**
- * Channel core: serialized inbound turn delivery over a MoltZapService.
- * Owns the inbound queue, same-conversation coalescing, the interceptor
- * gate, the per-turn timeout, and channel teardown. Enriched adapter delivery
- * uses channel-core-enrichment.ts; raw daemon delivery receives the coalesced
- * Message batch without reading or committing presentation context.
- */
-import { Cause, Chunk, Duration, Effect, Fiber, Option, Queue } from "effect";
-import { enrichChannelMessage } from "./channel-core-enrichment.js";
-/** Projects MCP-reconstructed context through the channel-owned presentation. */
-export { projectHarnessTurn } from "./channel-core-enrichment.js";
-function errorSummary(err) {
-    if (err instanceof Error) {
-        return {
-            errorName: err.name,
-            errorMessage: err.message,
-            errorStack: err.stack,
-        };
-    }
-    return {
-        errorValue: String(err),
-    };
-}
-function effectLogDebug(message, annotations) {
-    return Effect.logDebug(message).pipe(Effect.annotateLogs(annotations));
-}
-function effectLogWarning(message, annotations) {
-    return Effect.logWarning(message).pipe(Effect.annotateLogs(annotations));
-}
-function effectLogError(message, annotations) {
-    return Effect.logError(message).pipe(Effect.annotateLogs(annotations));
-}
-function runBackgroundLog(effect) {
-    Effect.runFork(effect);
-}
-/**
- * Wraps a `MoltZapService` with one-turn-at-a-time inbound delivery and a send
- * helper. Adapter handlers receive enriched messages. A daemon handler may
- * instead receive the admitted coalesced raw Message batch. One core per
- * service — `getContextEntries()` is side-effectful (advances
- * per-conversation markers), so a second core would consume entries the first
- * expected.
- *
- * Turn-taking is entirely endpoint-local: the server delivers every message
- * it accepts, and this core decides when the runtime sees them.
- *
- * Inbound path from wire bytes to user handler:.
- *
- * ```mermaid
- * sequenceDiagram
- *   participant server
- *   participant ws as MoltZapAgentClient
- *   participant svc as MoltZapService
- *   participant core as MoltZapChannelCore
- *   participant raw as RawInboundHandler
- *   participant enriched as InboundHandler
- *
- *   server->>ws: agent/message/received notification
- *   ws->>svc: subscribers.dispatch — fanout(message)
- *   svc->>core: message listener
- *   Note over core: dedup via recordMessageIdIfNew, drop when stopped or no handler is installed, then Queue.unsafeOffer(inboundQueue, message)
- *   Note over core: consumer fiber — Queue.take
- *   Note over core: takeCoalescedConversationMessages drains same-conv backlog into one turn
- *   alt raw daemon handler
- *     Note over core: inboundInterceptor — deliver or drop this batch
- *     core->>raw: rawInboundHandler(messages)
- *     raw-->>core: Effect.void
- *   else enriched adapter handler
- *     Note over core: enrichMessage — sender name, conversation, context entries
- *     Note over core: inboundInterceptor — deliver or drop this turn
- *     core->>enriched: inboundHandler(enriched)
- *     enriched-->>core: Effect.void
- *     Note over core: completed handler commits presentation context
- *   end
- *   Note over core: handler exceeds turnTimeoutMs — turn abandoned, drain continues
- * ```
- *
- * The single consumer fiber awaits the handler inline, so at most one turn
- * runs at a time and messages that arrive mid-turn wait in the queue.
- */
-export class MoltZapChannelCore {
-    service;
-    turnTimeoutMs;
-    inboundInterceptor;
-    connected = false;
-    // Terminal stop: disconnect() interrupts the sole consumer fiber and it is
-    // never restarted, while the service deliberately keeps message listeners
-    // registered across close()/connect() cycles. Without this flag a
-    // reconnected service would keep offering inbound messages into a queue
-    // nothing drains — unbounded growth and silent non-delivery. Stopped means
-    // stopped: inbound observed after disconnect() is dropped at the listener.
-    stopped = false;
-    inboundHandler = null;
-    /**
-     * Inbound messages with an installed handler enqueue synchronously; a single
-     * forked consumer fiber serialises delivery so handlers execute
-     * one-at-a-time in arrival order.
-     */
-    inboundQueue = Effect.runSync(Queue.unbounded());
-    consumerFiber;
-    disconnectHandlers = [];
-    constructor(opts) {
-        this.service = opts.service;
-        if (opts.turnTimeoutMs !== undefined) {
-            this.turnTimeoutMs = opts.turnTimeoutMs;
-        }
-        if (opts.inboundInterceptor !== undefined) {
-            this.inboundInterceptor = opts.inboundInterceptor;
-        }
-        this.registerMessageListener();
-        this.consumerFiber = this.startConsumerFiber();
-        this.registerConnectionListeners();
-    }
-    registerMessageListener() {
-        this.service.on("message", ({ message }) => {
-            // A core with no handler — a daemon that owns the connection without
-            // running a turn loop — observes messages it will never deliver.
-            // Dropping here keeps the queue from holding work nothing consumes, and
-            // makes the pre-registration window a definite drop rather than a race
-            // between the consumer fiber and the embedder's onInbound call.
-            if (this.stopped || this.inboundHandler === null) {
-                return;
-            }
-            Queue.unsafeOffer(this.inboundQueue, message);
-        });
-    }
-    startConsumerFiber() {
-        const consumer = Effect.forever(Queue.take(this.inboundQueue).pipe(Effect.flatMap((message) => this.runInboundTurn(message).pipe(Effect.catchAllCause((cause) => this.logInboundFailure(message, cause))))));
-        return Effect.runFork(consumer);
-    }
-    logInboundFailure(message, cause) {
-        return effectLogError("MoltZapChannelCore: inbound handler failed", {
-            messageId: message.id,
-            conversationId: message.conversationId,
-            causePretty: Cause.pretty(cause),
-            ...errorSummary(Cause.squash(cause)),
-        });
-    }
-    registerConnectionListeners() {
-        this.service.on("disconnect", () => {
-            this.connected = false;
-            this.fanout(this.disconnectHandlers, "disconnect");
-        });
-    }
-    /**
-     * Replaces any previous handler.
-     * @param handler Handler invoked for matching requests.
-     */
-    onInbound(handler) {
-        this.inboundHandler = { _tag: "enriched", handler };
-    }
-    /**
-     * Replaces any previous handler with a raw coalesced-turn handler. The
-     * admitted batch passes the interceptor and reaches the handler without
-     * enrichment or presentation-context commits.
-     * @param handler Handler invoked for each admitted raw batch.
-     */
-    onRawInbound(handler) {
-        this.inboundHandler = { _tag: "raw", handler };
-    }
-    onDisconnect(handler) {
-        this.disconnectHandlers.push(handler);
-    }
-    fanout(handlers, label) {
-        for (const h of handlers) {
-            try {
-                h();
-            }
-            catch (err) {
-                runBackgroundLog(effectLogError(`MoltZapChannelCore: ${label} handler threw`, {
-                    err,
-                    label,
-                }));
-            }
-        }
-    }
-    connect() {
-        // A stopped core has no consumer fiber and its listener drops every
-        // inbound message; reporting a successful connect here would hand the
-        // embedder a healthy-looking channel that is permanently deaf. Stopped
-        // is terminal — reconnecting means constructing a new core.
-        if (this.stopped) {
-            return Effect.dieMessage("MoltZapChannelCore.connect called after disconnect; a stopped core cannot be reconnected — construct a new core");
-        }
-        return this.service.connect().pipe(Effect.tap(() => Effect.sync(() => {
-            this.connected = true;
-        })), Effect.asVoid);
-    }
-    /**
-     * Tear the channel down, resolving only once the service's own transports
-     * are closed. A scoped owner releases this before its process exits, so
-     * fire-and-forget teardown would leave sockets open past the scope.
-     *
-     * Service shutdown runs concurrently with interrupting the consumer fiber
-     * because an in-flight turn's finalizer can take arbitrarily long. Awaiting
-     * the interrupt first would hold the transports open for exactly as long as
-     * that finalizer runs.
-     * @returns Completion of the channel-owned teardown.
-     */
-    disconnect() {
-        return Effect.gen(function* () {
-            this.connected = false;
-            this.stopped = true;
-            // Interrupt the consumer fiber so any queued inbound messages are
-            // dropped rather than delivered after the channel is torn down.
-            const stopConsumer = Fiber.interrupt(this.consumerFiber);
-            const shutdown = this.service.shutdown?.();
-            if (shutdown === undefined) {
-                this.service.close();
-                yield* stopConsumer;
-                return;
-            }
-            yield* Effect.all([stopConsumer, shutdown], {
-                concurrency: 2,
-                discard: true,
-            });
-        }.bind(this));
-    }
-    isConnected() {
-        return this.connected;
-    }
-    /**
-     * Reply into a conversation.
-     * @param conversationId Value supplied to the operation.
-     * @param text Text to process.
-     * @returns The send result.
-     */
-    sendReply(conversationId, text) {
-        return this.service.send(conversationId, text);
-    }
-    runInboundTurn(primary) {
-        return Effect.gen(function* () {
-            const messages = yield* this.takeCoalescedConversationMessages(primary);
-            const registered = this.inboundHandler;
-            if (registered === null) {
-                return;
-            }
-            if (registered._tag === "raw") {
-                if (!(yield* this.interceptTurn(messages))) {
-                    return;
-                }
-                yield* this.awaitHandlerTurn(registered.handler, messages, primary);
-                return;
-            }
-            const { enriched, commitContext } = yield* MoltZapChannelCore.enrichMessage(this.service, messages);
-            if (!(yield* this.interceptTurn(messages))) {
-                return;
-            }
-            const completed = yield* this.awaitHandlerTurn(registered.handler, enriched, primary);
-            // Context markers advance only for a turn the handler finished. A
-            // dropped or abandoned one leaves its entries for the next turn.
-            if (completed && commitContext) {
-                commitContext();
-            }
-        }.bind(this));
-    }
-    /**
-     * Consult the interceptor for this turn, if one is installed.
-     * @param messages The coalesced batch, primary first.
-     * @returns Whether the handler runs for this batch.
-     */
-    interceptTurn(messages) {
-        const interceptor = this.inboundInterceptor;
-        if (interceptor === undefined) {
-            return Effect.succeed(true);
-        }
-        const newest = 
-        /* Safe because a coalesced batch always holds at least its primary. */ messages[messages.length - 1];
-        // Suspended so an interceptor that throws before returning its Effect
-        // becomes a defect this pipeline can fail open on, not one the consumer
-        // fiber catches after the turn is already lost.
-        return Effect.suspend(() => interceptor(newest)).pipe(Effect.flatMap((decision) => this.applyInterceptDecision(newest, decision)), Effect.catchAllCause((cause) => 
-        // Interruption is teardown, not an interceptor bug: re-raise it so a
-        // disconnected channel stops draining instead of delivering the turn.
-        Cause.isInterruptedOnly(cause)
-            ? Effect.failCause(cause)
-            : this.logInterceptorFailure(newest, cause).pipe(Effect.as(true))));
-    }
-    /**
-     * Apply a verdict, logging the drops at debug so a quiet channel can be
-     * traced back to its gate.
-     * @param newest Message the interceptor judged.
-     * @param decision Verdict for the whole coalesced batch.
-     * @returns Whether the handler runs.
-     */
-    applyInterceptDecision(newest, decision) {
-        if (decision._tag === "deliver") {
-            return Effect.succeed(true);
-        }
-        return effectLogDebug("MoltZapChannelCore: inbound turn dropped by interceptor", {
-            messageId: newest.id,
-            conversationId: newest.conversationId,
-            ...(decision.reason !== undefined ? { reason: decision.reason } : {}),
-        }).pipe(Effect.as(false));
-    }
-    logInterceptorFailure(newest, cause) {
-        return effectLogWarning("MoltZapChannelCore: inbound interceptor failed, delivering anyway", {
-            messageId: newest.id,
-            conversationId: newest.conversationId,
-            causePretty: Cause.pretty(cause),
-            ...errorSummary(Cause.squash(cause)),
-        });
-    }
-    /**
-     * Await the user handler, bounded by `turnTimeoutMs` when it is set.
-     * @param handler Installed inbound handler.
-     * @param input Value delivered to the selected handler.
-     * @param primary Message that opened this turn.
-     * @returns Whether the handler ran to completion.
-     */
-    awaitHandlerTurn(handler, input, primary) {
-        // The handler is user code returning an Effect — yield it directly so its
-        // typed error channel propagates to the consumer fiber, which logs and
-        // continues. Awaiting it inline preserves arrival-order delivery.
-        const turn = handler(input);
-        const timeoutMs = this.turnTimeoutMs;
-        if (timeoutMs === undefined) {
-            return turn.pipe(Effect.as(true));
-        }
-        return turn.pipe(Effect.timeoutOption(Duration.millis(timeoutMs)), Effect.tap((finished) => Option.isNone(finished)
-            ? effectLogWarning("MoltZapChannelCore: inbound turn abandoned after timeout", {
-                messageId: primary.id,
-                conversationId: primary.conversationId,
-                timeoutMs,
-            })
-            : Effect.void), Effect.map(Option.isSome));
-    }
-    /**
-     * Drain every queued message for the primary's conversation into one turn,
-     * leaving other conversations queued in arrival order. Coalescing keeps a
-     * burst in one conversation from costing one turn per message.
-     * @param primary Message that opened this turn.
-     * @returns The messages belonging to this turn, primary first.
-     */
-    takeCoalescedConversationMessages(primary) {
-        return Effect.sync(() => {
-            const queued = Chunk.toReadonlyArray(Effect.runSync(Queue.takeAll(this.inboundQueue)));
-            const sameConversation = [primary];
-            const remaining = [];
-            for (const queuedMessage of queued) {
-                if (queuedMessage.conversationId === primary.conversationId) {
-                    sameConversation.push(queuedMessage);
-                }
-                else {
-                    remaining.push(queuedMessage);
-                }
-            }
-            for (const remainingMessage of remaining) {
-                Queue.unsafeOffer(this.inboundQueue, remainingMessage);
-            }
-            return sameConversation;
-        });
-    }
-    /**
-     * Stateless enrichment helper. Falls back to `sender.id` if
-     * `resolveAgentName` throws (e.g. Service not yet connected).
-     * @param service Value supplied to the operation.
-     * @param messageOrMessages Value supplied to the operation.
-     * @returns The enriched message and its context-commit callback.
-     */
-    static enrichMessage(service, messageOrMessages) {
-        return enrichChannelMessage(service, messageOrMessages);
-    }
-}
-//# sourceMappingURL=channel-core.js.map