@parall/agent-core 1.44.0 → 1.46.0

package/dist/gateway-lane-flow.d.ts

@@ -13,8 +13,15 @@ import type { ParallEvent } from './types.js';
 export interface LaneFlowHost {
     laneLedger?: LaneLedger;
     ledgerDisabled: boolean;
+    /**
+     * Sticky: the server answered a by-id complete with 400 (predates the
+     * form, v1.44). Typed resolution falls back to the legacy ack for the
+     * rest of the process; claims stay on the ledger (that face is older).
+     */
+    typedByIdCompleteUnsupported: boolean;
     shuttingDown: boolean;
     dispatchedMessages: Set<string>;
+    dispatchedTasks: Set<string>;
     /**
      * Per-WorkItem failure backoff for typed dispatch consumption. A consume
      * that ends without an ack re-arms the entry; the next attempt for the
@@ -60,14 +67,77 @@ export declare function dispatchLaneGroup(host: LaneFlowHost, opts: {
     captureText?: string[];
     hasMoreLocal: () => boolean;
 }): Promise<'dispatched' | 'foreign' | 'shutdown' | 'failed'>;
+/**
+ * The WorkItem ids of a typed event group whose lifecycle the ledger owns
+ * (claimed into dsp lanes by consumeTypedDispatch), or null when the group
+ * must stay on the legacy received/ack surface — ledger unavailable, an id
+ * missing, or a member that rides a message lane. Non-null means: skip
+ * legacy received+ack, resolve via the by-id complete, and fold the
+ * turn-error signal into the outcome.
+ */
+export declare function typedLedgerEventIds(host: LaneFlowHost, events: ParallEvent[]): string[] | null;
+/** Outcome of a by-id complete attempt. */
+export type TypedResolveOutcome = 'ok' | 'stale' | 'unsupported' | 'failed';
+/**
+ * By-id complete (turn_outcome ok): terminal resolution of ONE WorkItem —
+ * exact where the source pair is ambiguous across task siblings. `lane`
+ * fences the call while the row is claim-owned (a dethroned caller gets
+ * 'stale' and must leave the row to its successor); omit it for the
+ * wrapper-less pending close (buffered drain, administrative drops).
+ */
+export declare function resolveDispatchByID(host: LaneFlowHost, dispatchEventId: string, lane?: string): Promise<TypedResolveOutcome>;
+/**
+ * Free a typed event's in-memory hot-path dedupe claim by its source pair —
+ * the ParallEvent-keyed mirror of the gateway's clearTypedDispatchDedupe
+ * (which keys on the wire DispatchNewData). Used when a buffered typed
+ * dispatch ran but its resolution failed: the member re-drives, and a stale
+ * local claim would make this pod reject the retry forever.
+ *
+ * PARITY: the switch below and clearTypedDispatchDedupe's must handle the
+ * same typed source families — when adding a new typed event type, extend
+ * BOTH (they key the same dedupe entries from different event shapes).
+ */
+export declare function clearTypedDedupeForEvent(host: LaneFlowHost, event: ParallEvent): void;
+/**
+ * Settle a drained typed group — the one wrapper-less dispatch path: these
+ * events buffered behind a busy main (fork-less adapter), their consume
+ * guards returned false and released the claims, so the drain site owns the
+ * terminal resolution. Rows are pending — the by-id close resolves them
+ * without a fence; a row a successor lane meanwhile claimed answers stale and
+ * is that owner's to finish. `turnErrored` (consumed at the call site before
+ * the drain can start another turn) leaves the rows for the renotify pacing
+ * instead. Either way a row left live gets its local dedupe claim freed, or
+ * this pod would reject the retry forever.
+ */
+export declare function settleDrainedTypedGroup(host: LaneFlowHost, events: ParallEvent[], ids: string[], turnErrored: boolean): Promise<void>;
+/** Consumption hooks for one typed dispatch. */
+export interface TypedConsumeHooks {
+    /**
+     * Legacy administrative ack — invoked ONLY on the ledger-disabled fallback
+     * path (old server). On the ledger path the WorkItem resolves through the
+     * sources-form complete instead; this callback never fires there.
+     */
+    legacyAck: (dispatchEventId?: string) => boolean | void | Promise<boolean | void>;
+    /**
+     * Free the item's in-memory hot-path dedupe claim. Invoked when the handler
+     * ran but the resolution could not commit (sources-form complete failed) —
+     * the member is released for re-drive, and a stale local claim would make
+     * this pod reject its own retry forever.
+     */
+    clearDedupe?: () => void;
+}
 /**
  * Consume one typed dispatch (task/comment/schedule/trigger/approval) under
  * its typed-lane occupancy guard: claim the dsp:<id> lane (skip when another
- * pod holds it or the WorkItem is already resolved), run the handler, ack on
- * success (the doc's option (b): notification delivered, tracked elsewhere),
- * then release the lane. Legacy run+ack flow when the ledger is unavailable.
+ * pod holds it or the WorkItem is already resolved), run the handler, then
+ * settle. A successful run resolves the WorkItem terminally via the
+ * sources-form complete (turn_outcome ok — the server sweeps it, or lets a
+ * typed Effect committed during the turn stand, and drops the vacated lane);
+ * a failed / errored / unresolved run releases the member back to pending on
+ * the redrive budget via the lane complete. Legacy run+ack flow when the
+ * ledger is unavailable.
  *
- * Repeated failures back off: a consume that ends un-acked re-arms the
+ * Repeated failures back off: a consume that ends unresolved re-arms the
  * WorkItem's backoff entry, and the next attempt sleeps out the remaining
  * window before claiming. Without this, complete's release re-drives the
  * item instantly and a persistently-failing consume (e.g. buffered behind a
@@ -78,7 +148,7 @@ export declare function consumeTypedDispatch(host: LaneFlowHost, ref: {
     dispatchEventId?: string;
     sourceType?: string;
     sourceId?: string;
-}, run: (dispatchEventId?: string) => Promise<boolean>, ack: (dispatchEventId?: string) => boolean | void | Promise<boolean | void>): Promise<void>;
+}, run: (dispatchEventId?: string) => Promise<boolean>, hooks: TypedConsumeHooks): Promise<void>;
 /**
  * Shared consumption of a message WorkItem referenced by id — the ONE
  * protocol for dispatch catch-up pages and post-complete re-drive hints

package/dist/gateway-lane-flow.d.ts.map

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

package/dist/gateway-lane-flow.js

@@ -1,3 +1,4 @@
+import { ApiError } from '@parall/sdk';
 import { LedgerUnsupportedError } from './lane-ledger.js';
 /**
  * Dispatch one group of same-lane message events under the ledger contract:
@@ -101,6 +102,161 @@ export async function dispatchLaneGroup(host, opts) {
     await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
     return 'dispatched';
 }
+/**
+ * The WorkItem ids of a typed event group whose lifecycle the ledger owns
+ * (claimed into dsp lanes by consumeTypedDispatch), or null when the group
+ * must stay on the legacy received/ack surface — ledger unavailable, an id
+ * missing, or a member that rides a message lane. Non-null means: skip
+ * legacy received+ack, resolve via the by-id complete, and fold the
+ * turn-error signal into the outcome.
+ */
+export function typedLedgerEventIds(host, events) {
+    if (!host.laneLedger || host.ledgerDisabled)
+        return null;
+    const ids = [];
+    for (const ev of events) {
+        if (!ev.dispatchEventId || host.usesLaneLedger(ev))
+            return null;
+        ids.push(ev.dispatchEventId);
+    }
+    return ids.length > 0 ? ids : null;
+}
+/**
+ * A pre-by-id server (v1.44) routes a by-id body into its lane-form
+ * validation and answers 400 INVALID_REQUEST. Any 400 here means the server
+ * did not understand the form — a well-formed by-id call never 400s on a
+ * current server — so the caller falls back to the legacy typed ack for the
+ * rest of the process (sticky; the bridge restarts on the next update).
+ */
+function isByIDCompleteUnsupported(err) {
+    return err instanceof ApiError && err.status === 400;
+}
+/**
+ * By-id complete (turn_outcome ok): terminal resolution of ONE WorkItem —
+ * exact where the source pair is ambiguous across task siblings. `lane`
+ * fences the call while the row is claim-owned (a dethroned caller gets
+ * 'stale' and must leave the row to its successor); omit it for the
+ * wrapper-less pending close (buffered drain, administrative drops).
+ */
+export async function resolveDispatchByID(host, dispatchEventId, lane) {
+    try {
+        await host.opts.client.completeDispatch(host.opts.config.org_id, {
+            dispatch_event_id: dispatchEventId,
+            ...(lane ? { lane } : {}),
+            turn_outcome: 'ok',
+        });
+        return 'ok';
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 409)
+            return 'stale';
+        if (isByIDCompleteUnsupported(err))
+            return 'unsupported';
+        host.opts.log?.warn(`by-id complete failed for ${dispatchEventId} — leaving for re-drive: ${String(err)}`);
+        return 'failed';
+    }
+}
+/**
+ * Free a typed event's in-memory hot-path dedupe claim by its source pair —
+ * the ParallEvent-keyed mirror of the gateway's clearTypedDispatchDedupe
+ * (which keys on the wire DispatchNewData). Used when a buffered typed
+ * dispatch ran but its resolution failed: the member re-drives, and a stale
+ * local claim would make this pod reject the retry forever.
+ *
+ * PARITY: the switch below and clearTypedDispatchDedupe's must handle the
+ * same typed source families — when adding a new typed event type, extend
+ * BOTH (they key the same dedupe entries from different event shapes).
+ */
+export function clearTypedDedupeForEvent(host, event) {
+    const sourceId = event.ackSourceId;
+    if (!sourceId)
+        return;
+    switch (event.ackSourceType) {
+        case 'task_activity': {
+            // Task dedupe keys are `${task_id}:${updated_at}`; the task id is the
+            // event target. Prefix-clear mirrors clearTypedDispatchDedupe.
+            const prefix = `${event.targetId}:`;
+            for (const key of host.dispatchedTasks) {
+                if (key.startsWith(prefix))
+                    host.dispatchedTasks.delete(key);
+            }
+            break;
+        }
+        case 'comment':
+            host.dispatchedTasks.delete(`comment:${sourceId}`);
+            break;
+        case 'schedule_run':
+            host.dispatchedTasks.delete(`schedule_run:${sourceId}`);
+            break;
+        case 'external_trigger_run':
+            host.dispatchedTasks.delete(`external_trigger_run:${sourceId}`);
+            break;
+        case 'channel_message':
+            host.dispatchedMessages.delete(`channel_message:${sourceId}`);
+            break;
+        case 'approval':
+            host.dispatchedTasks.delete(`approval:${sourceId}`);
+            break;
+    }
+}
+/**
+ * Settle a drained typed group — the one wrapper-less dispatch path: these
+ * events buffered behind a busy main (fork-less adapter), their consume
+ * guards returned false and released the claims, so the drain site owns the
+ * terminal resolution. Rows are pending — the by-id close resolves them
+ * without a fence; a row a successor lane meanwhile claimed answers stale and
+ * is that owner's to finish. `turnErrored` (consumed at the call site before
+ * the drain can start another turn) leaves the rows for the renotify pacing
+ * instead. Either way a row left live gets its local dedupe claim freed, or
+ * this pod would reject the retry forever.
+ */
+export async function settleDrainedTypedGroup(host, events, ids, turnErrored) {
+    if (turnErrored) {
+        host.opts.log?.info(`buffered typed turn for ${events[events.length - 1]?.messageId} surfaced a runtime error — leaving for re-drive`);
+        for (const event of events)
+            clearTypedDedupeForEvent(host, event);
+        return;
+    }
+    // The legacy ack BY ID, never by source — task siblings share a source
+    // pair, and a by-source ack would sweep the undispatched one. Awaited, and
+    // the dedupe claim is freed on EVERY outcome: a claim's lifetime is the
+    // buffer stay (#1149). On failure the row is still pending and its retry
+    // must not be self-rejected; on success the row is terminal — but a
+    // shared-key sibling WorkItem (task assign+update fetch the same
+    // `task:updated_at` pair) must not be rejected by a leftover claim either.
+    const legacyAckFrom = async (start) => {
+        for (const [j, id] of ids.slice(start).entries()) {
+            try {
+                await host.opts.client.ackDispatchByID(host.opts.config.org_id, id);
+            }
+            catch {
+                // Transient ack failure: the row stays live server-side and its
+                // re-drive re-converges — keep settling the REST of the group (a
+                // propagated error would strand every later id's retained claim).
+            }
+            finally {
+                clearTypedDedupeForEvent(host, events[start + j]);
+            }
+        }
+    };
+    if (host.typedByIdCompleteUnsupported) {
+        // Sticky: the server already answered one by-id probe with 400 — go
+        // straight to the legacy acks instead of re-probing per group.
+        await legacyAckFrom(0);
+        return;
+    }
+    for (const [i, id] of ids.entries()) {
+        const outcome = await resolveDispatchByID(host, id);
+        if (outcome === 'unsupported') {
+            host.typedByIdCompleteUnsupported = true;
+            host.opts.log?.warn('server predates the by-id dispatch complete — falling back to legacy typed acks');
+            await legacyAckFrom(i);
+            return;
+        }
+        // Freed on every outcome — see legacyAckFrom's contract note.
+        clearTypedDedupeForEvent(host, events[i]);
+    }
+}
 /** Failure backoff pacing for typed dispatch retries (base 2s, cap 5min). */
 const TYPED_BACKOFF_BASE_MS = 2_000;
 const TYPED_BACKOFF_CAP_MS = 5 * 60_000;
@@ -108,18 +264,22 @@ const TYPED_BACKOFF_MAP_CAP = 512;
 /**
  * Consume one typed dispatch (task/comment/schedule/trigger/approval) under
  * its typed-lane occupancy guard: claim the dsp:<id> lane (skip when another
- * pod holds it or the WorkItem is already resolved), run the handler, ack on
- * success (the doc's option (b): notification delivered, tracked elsewhere),
- * then release the lane. Legacy run+ack flow when the ledger is unavailable.
+ * pod holds it or the WorkItem is already resolved), run the handler, then
+ * settle. A successful run resolves the WorkItem terminally via the
+ * sources-form complete (turn_outcome ok — the server sweeps it, or lets a
+ * typed Effect committed during the turn stand, and drops the vacated lane);
+ * a failed / errored / unresolved run releases the member back to pending on
+ * the redrive budget via the lane complete. Legacy run+ack flow when the
+ * ledger is unavailable.
  *
- * Repeated failures back off: a consume that ends un-acked re-arms the
+ * Repeated failures back off: a consume that ends unresolved re-arms the
  * WorkItem's backoff entry, and the next attempt sleeps out the remaining
  * window before claiming. Without this, complete's release re-drives the
  * item instantly and a persistently-failing consume (e.g. buffered behind a
  * saturated fork pool) spins at wire speed — the client half of the
  * 2026-07-11 poison loop (the server half is the redrive budget).
  */
-export async function consumeTypedDispatch(host, ref, run, ack) {
+export async function consumeTypedDispatch(host, ref, run, hooks) {
     const backoffKey = ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`;
     const armed = host.typedRedriveBackoff.get(backoffKey);
     if (armed) {
@@ -142,8 +302,8 @@ export async function consumeTypedDispatch(host, ref, run, ack) {
     // consume — clearing backoff there would let an ack outage re-create the
     // wire-speed release/re-drive loop against a pre-budget server.
     const settleAck = (ackResult) => ackResult !== false;
-    const settle = (acked) => {
-        if (acked) {
+    const settle = (resolved) => {
+        if (resolved) {
             host.typedRedriveBackoff.delete(backoffKey);
             return;
         }
@@ -168,7 +328,7 @@ export async function consumeTypedDispatch(host, ref, run, ack) {
         let acked = false;
         try {
             if (await run(ref.dispatchEventId)) {
-                acked = settleAck(await ack(ref.dispatchEventId));
+                acked = settleAck(await hooks.legacyAck(ref.dispatchEventId));
             }
         }
         finally {
@@ -197,21 +357,68 @@ export async function consumeTypedDispatch(host, ref, run, ack) {
         host.opts.log?.info(`typed dispatch ${ref.dispatchEventId ?? `${ref.sourceType}:${ref.sourceId}`} not claimable (held elsewhere or already resolved) — skipping`);
         return;
     }
-    let acked = false;
+    let resolved = false;
+    let viaLegacyAck = false;
     try {
-        // Ack must settle before Complete. A fire-and-forget ack races the lane
-        // release: Complete can return the still-received typed item to pending
-        // and publish a re-drive while its successful ack is still in flight.
+        // A successful run resolves the member terminally through the by-id
+        // complete — one fenced call that sweeps exactly this WorkItem (a typed
+        // Effect committed during the turn already made it terminal — idempotent
+        // no-op) AND drops the vacated lane. Resolution must settle inside this
+        // guard: a fire-and-forget resolve would race the finally's release and
+        // spuriously re-drive handled work.
         if (await run(lane.typedDispatchEventId)) {
-            acked = settleAck(await ack(lane.typedDispatchEventId));
+            if (host.typedByIdCompleteUnsupported || !lane.typedDispatchEventId) {
+                // Pre-by-id server (or a defensive claim shape without the id):
+                // the legacy administrative ack is still live there.
+                viaLegacyAck = true;
+                resolved = settleAck(await hooks.legacyAck(lane.typedDispatchEventId));
+            }
+            else {
+                const outcome = await resolveDispatchByID(host, lane.typedDispatchEventId, lane.lane);
+                if (outcome === 'unsupported') {
+                    host.typedByIdCompleteUnsupported = true;
+                    host.opts.log?.warn('server predates the by-id dispatch complete — falling back to the legacy typed ack');
+                    viaLegacyAck = true;
+                    resolved = settleAck(await hooks.legacyAck(lane.typedDispatchEventId));
+                }
+                else if (outcome === 'stale') {
+                    // A successor lane owns the row — its turn resolves it. Nothing to
+                    // spin on locally; our claim record is already dethroned. Free the
+                    // local dedupe claim though: if the successor later FAILS and
+                    // releases the row, the re-drive may land back on this pod, and a
+                    // stale local claim would self-reject the retry into the budget.
+                    hooks.clearDedupe?.();
+                    resolved = true;
+                }
+                else {
+                    resolved = outcome === 'ok';
+                    if (!resolved) {
+                        // The member is about to be released for re-drive — free its
+                        // hot-path dedupe claim first, or this pod rejects its own retry
+                        // forever (same contract as the legacy ack-failure path).
+                        hooks.clearDedupe?.();
+                    }
+                }
+            }
         }
     }
     finally {
-        settle(acked);
-        // Release the occupancy row. A buffered dispatch may outlive this guard
-        // (lane TTL) — acceptable at-least-once; the ledger's resolution paths
-        // still dedupe the persistent side effects.
-        await host.laneLedger.completeIfIdle(lane.laneKey, false).catch(() => { });
+        settle(resolved);
+        if (resolved && !viaLegacyAck) {
+            // The by-id complete already dropped (or a takeover already owns) the
+            // server-side lane row; only the local record and context file remain.
+            host.laneLedger.dropLocal(lane.laneKey);
+        }
+        else {
+            // Two jobs, one call: an unresolved turn (unconsumed / failed /
+            // errored / resolution-failed) releases the member back to pending on
+            // the redrive budget; a legacy-acked turn still needs its server-side
+            // lane row dropped (the ack resolves the row but not the occupancy).
+            // A buffered dispatch may outlive this guard (lane TTL) — acceptable
+            // at-least-once; the ledger's resolution paths still dedupe the
+            // persistent side effects.
+            await host.laneLedger.completeIfIdle(lane.laneKey, false).catch(() => { });
+        }
     }
 }
 /**
@@ -227,7 +434,22 @@ export async function consumeMessageWorkItem(host, item) {
         return;
     if (!host.tryClaimMessage(item.source_id))
         return;
+    // Administrative drop (deleted source / self-sender / skip decision): on
+    // the ledger path the by-id complete closes the pending row terminally and
+    // refuses (409) a row a live lane owns — the owner's turn resolves it. The
+    // legacy ack remains the ledger-disabled / pre-by-id fallback.
+    // Fire-and-forget either way: a failed drop leaves the row live and the
+    // next re-drive converges on the same drop.
     const ackItem = () => {
+        if (host.laneLedger && !host.ledgerDisabled && !host.typedByIdCompleteUnsupported) {
+            void resolveDispatchByID(host, item.id).then((outcome) => {
+                if (outcome === 'unsupported') {
+                    host.typedByIdCompleteUnsupported = true;
+                    host.opts.client.ackDispatchByID(host.opts.config.org_id, item.id).catch(() => { });
+                }
+            });
+            return;
+        }
         host.opts.client.ackDispatchByID(host.opts.config.org_id, item.id).catch(() => { });
     };
     let msg = null;

package/dist/http-keepalive.d.ts

@@ -0,0 +1,4 @@
+export declare function configureHttpKeepAlive(opts?: {
+    keepAliveTimeoutMs?: number;
+}): void;
+//# sourceMappingURL=http-keepalive.d.ts.map

package/dist/http-keepalive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-keepalive.d.ts","sourceRoot":"","sources":["../src/http-keepalive.ts"],"names":[],"mappings":"AAsBA,wBAAgB,sBAAsB,CAAC,IAAI,CAAC,EAAE;IAAE,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAanF"}

package/dist/http-keepalive.js

@@ -0,0 +1,33 @@
+import { Agent, setGlobalDispatcher } from 'undici';
+/**
+ * Keep bridge→api HTTP connections long-lived.
+ *
+ * Node's built-in fetch closes idle pooled connections after ~4s when the
+ * server sends no Keep-Alive hint (our NLB+Envoy edge sends none), so any two
+ * bridge API calls spaced more than a few seconds apart pay a fresh TCP+TLS
+ * handshake. On a degraded long-haul link that handshake is exactly what
+ * fails — established connections (the WS, the runtime's own model stream)
+ * ride through such windows while every bridge call times out (2026-07-10:
+ * step creation losses). A 2-minute idle timeout keeps one warm connection
+ * across an active turn's step cadence, comfortably below the NLB's 350s
+ * idle cutoff.
+ *
+ * Uses undici's global-dispatcher registry, which Node's built-in fetch
+ * shares (verified on Node 22 / undici 7) — so this covers every fetch in
+ * the process: ParallClient, lane-ledger heartbeats, OTLP export.
+ * Node-only; call once from a bridge/daemon entrypoint before any fetch.
+ */
+let installed = false;
+export function configureHttpKeepAlive(opts) {
+    // Idempotent: a second call (e.g. a process hosting several bridge
+    // entrypoints) must not replace — and leak — the already-installed Agent.
+    if (installed)
+        return;
+    installed = true;
+    const keepAliveTimeout = opts?.keepAliveTimeoutMs ?? 120_000;
+    setGlobalDispatcher(new Agent({
+        keepAliveTimeout,
+        // Also cap the server-hinted value: never idle past the edge's cutoff.
+        keepAliveMaxTimeout: keepAliveTimeout,
+    }));
+}

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export * from './provider-config.js';
 export * from './types.js';
 export * from './lane-key.js';
 export type { LaneFlowHost } from './gateway-lane-flow.js';
-export { consumeTypedDispatch } from './gateway-lane-flow.js';
+export { consumeTypedDispatch, settleDrainedTypedGroup } from './gateway-lane-flow.js';
 export * from './session-state.js';
 export * from './routing.js';
 export * from './event-format.js';
@@ -11,6 +11,7 @@ export * from './bridge-workspace.js';
 export * from './dispatch-adapter.js';
 export { createLogger, childLogger } from './logger.js';
 export * from './gateway-base.js';
+export { configureHttpKeepAlive } from './http-keepalive.js';
 export * from './platform-config.js';
 export * from './channel-capability.js';
 export * from './channel-token.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACxD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACvF,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACxD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAM7D,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,7 +1,7 @@
 export * from './provider-config.js';
 export * from './types.js';
 export * from './lane-key.js';
-export { consumeTypedDispatch } from './gateway-lane-flow.js';
+export { consumeTypedDispatch, settleDrainedTypedGroup } from './gateway-lane-flow.js';
 export * from './session-state.js';
 export * from './routing.js';
 export * from './event-format.js';
@@ -10,6 +10,12 @@ export * from './bridge-workspace.js';
 export * from './dispatch-adapter.js';
 export { createLogger, childLogger } from './logger.js';
 export * from './gateway-base.js';
+export { configureHttpKeepAlive } from './http-keepalive.js';
+// StepPersister / StepRetryQueue / SessionLifecycleCoordinator /
+// ForkSessionFinalizer are internal gateway collaborators — deliberately NOT
+// re-exported from the package root (no external consumer; a root export
+// would become an accidental long-term compat promise). Tests import their
+// built modules directly (e.g. `../dist/step-retry-queue.js`).
 export * from './platform-config.js';
 export * from './channel-capability.js';
 export * from './channel-token.js';

package/dist/lane-ledger.d.ts

@@ -123,6 +123,14 @@ export declare class LaneLedger {
         sourceType?: string;
         sourceId?: string;
     }): Promise<ActiveLane | null>;
+    /**
+     * Drop a lane's local record without any server call — for a typed lane
+     * whose member the by-id complete just resolved (the server dropped the
+     * vacated lane row in the same transaction). Calling completeIfIdle
+     * instead would fire a lane-form Complete at a lane that no longer exists
+     * and burn an RPC on the guaranteed STALE_LANE answer.
+     */
+    dropLocal(laneKey: string): void;
     /**
      * Remove the per-lane context file (and its CLI sidecar) when the lane
      * ends. A leftover file would make a later cross-context send to the same

package/dist/lane-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lane-ledger.d.ts","sourceRoot":"","sources":["../src/lane-ledger.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,sDAAsD;AACtD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;CAAG;AAEpD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,CAAC;AAqBrD;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;gBAGpC,IAAI,EAAE;QACrB,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,aAAa,CAAC;KACrB;IAGH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,+FAA+F;IAC/F,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAIpC,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IAOtC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS;IAIvD,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAIzC;;;;;;OAMG;IACG,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAsFnE;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BrD;;;;;OAKG;IACH;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK9B,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B3E;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC;;;;;;;OAOG;IACH,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IA6BlC;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,yEAAyE;IACzE,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;OAKG;IACG,UAAU,CAAC,GAAG,EAAE;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA8B9B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;CAW1B"}
+{"version":3,"file":"lane-ledger.d.ts","sourceRoot":"","sources":["../src/lane-ledger.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,sDAAsD;AACtD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;CAAG;AAEpD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,CAAC;AAqBrD;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;gBAGpC,IAAI,EAAE;QACrB,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,aAAa,CAAC;KACrB;IAGH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,+FAA+F;IAC/F,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAIpC,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IAOtC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS;IAIvD,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAIzC;;;;;;OAMG;IACG,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAsFnE;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BrD;;;;;OAKG;IACH;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK9B,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B3E;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC;;;;;;;OAOG;IACH,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IA6BlC;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,yEAAyE;IACzE,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;OAKG;IACG,UAAU,CAAC,GAAG,EAAE;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA8B9B;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;CAW1B"}

package/dist/lane-ledger.js

@@ -347,6 +347,20 @@ export class LaneLedger {
         this.lanes.set(lane.laneKey, lane);
         return lane;
     }
+    /**
+     * Drop a lane's local record without any server call — for a typed lane
+     * whose member the by-id complete just resolved (the server dropped the
+     * vacated lane row in the same transaction). Calling completeIfIdle
+     * instead would fire a lane-form Complete at a lane that no longer exists
+     * and burn an RPC on the guaranteed STALE_LANE answer.
+     */
+    dropLocal(laneKey) {
+        const lane = this.lanes.get(laneKey);
+        if (!lane)
+            return;
+        this.lanes.delete(laneKey);
+        this.removeLaneContext(lane);
+    }
     /**
      * Remove the per-lane context file (and its CLI sidecar) when the lane
      * ends. A leftover file would make a later cross-context send to the same