@parall/parel-channel 1.40.0 → 1.42.0

package/dist/session.js

@@ -35,7 +35,54 @@ export function reportingEnabled(ctx) {
  * simply never read again.)
  */
 export const TURN_ENVELOPE_KEY = `turnEnvelope:${MAIN_SESSION_KEY}`;
-const SESSION_CACHE_KEY = `session:${MAIN_SESSION_KEY}`;
+export const SESSION_CACHE_KEY = `session:${MAIN_SESSION_KEY}`;
+const childSessionCacheKey = (childRef) => `sessionChild:${childRef}`;
+/**
+ * Conversation key for envelope subjects and fork routing. Thread-aware:
+ * parel's turn grouping (F2) and mid-turn injection (F3) key on the envelope
+ * subject, and a turn carries ONE reply route — grouping two threads of the
+ * same chat under one subject would absorb thread B into thread A's turn and
+ * deliver its reply to the wrong thread (agent-core's lane keys draw the
+ * same thread/channel line). `~` is outside both nanoid and ULID alphabets,
+ * so the composite never collides with a plain id.
+ */
+export function conversationKey(chatId, threadRootId) {
+    return threadRootId ? `${chatId}~${threadRootId}` : chatId;
+}
+/**
+ * The addressable entity id inside a (possibly thread-composite) subject.
+ * Splits ONLY the `cht_…~msg_…` composite conversationKey produces — typed
+ * wiki subjects are scheme-stripped paths where `~` is a legal character
+ * (e.g. `wik_1/docs/~draft.md`) and must pass through untouched.
+ */
+export function subjectEntityId(subject) {
+    const sep = subject.indexOf('~');
+    if (sep === -1)
+        return subject;
+    const head = subject.slice(0, sep);
+    const tail = subject.slice(sep + 1);
+    return head.startsWith('cht_') && tail.startsWith('msg_') ? head : subject;
+}
+/**
+ * Step broadcast routing by subject shape: chat ids and channel conversations
+ * have live subscribers; task/schedule/trigger/wiki subjects are stored-only
+ * targets (the server publishes step WS events for chat/task targets and
+ * simply persists the rest). Mirrors agent-core's resolveStepTarget so both
+ * runtimes' session panels read identically.
+ */
+export function stepTargetTypeFor(subject) {
+    if (subject.startsWith('chv_'))
+        return 'channel_conversation';
+    if (subject.startsWith('tsk_'))
+        return 'task';
+    if (subject.startsWith('sch_'))
+        return 'schedule';
+    if (subject.startsWith('xtr_'))
+        return 'external_trigger';
+    if (subject.startsWith('wcs_') || subject.startsWith('wik_'))
+        return 'wiki';
+    return 'chat';
+}
 function resultForStatus(status) {
     return status === 404 || status === 409 || status === 410 ? 'stale' : 'failed';
 }
@@ -87,6 +134,87 @@ export async function ensureSession(ctx, opts = {}) {
         return null;
     }
 }
+/**
+ * Resolve the CURRENT main ase_ from the server, bypassing the cache — the
+ * onOpen generation check needs the authoritative id to compare against the
+ * cached one (New Session rotates it). Updates the cache on success; returns
+ * null on failure WITHOUT touching the cache (the caller must not lose its
+ * only generation token to a transient error).
+ */
+export async function fetchMainSessionFresh(ctx) {
+    if (!reportingEnabled(ctx))
+        return null;
+    try {
+        const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({ runtime_type: 'parel', runtime_session_id: MAIN_SESSION_KEY }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json().catch(() => null));
+        const id = body?.id;
+        if (!id)
+            return null;
+        await ctx.store?.set(SESSION_CACHE_KEY, id).catch(() => { });
+        return id;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get-or-create the parall AgentSession mirroring one fork child session
+ * (ase_ with parent_session_id → the main ase_, runtime_session_id = the
+ * opaque childRef — the connector never sees parel's internal session id).
+ * Same caching/degradation posture as ensureSession; the parent resolve
+ * reuses the main-session cache so the extra cost is one store read.
+ */
+export async function ensureChildSession(ctx, childRef, opts = {}) {
+    if (!reportingEnabled(ctx))
+        return null;
+    const cacheKey = childSessionCacheKey(childRef);
+    const cached = await ctx.store?.get(cacheKey).catch(() => null);
+    if (typeof cached === 'string' && cached)
+        return cached;
+    const parentId = await ensureSession(ctx, opts);
+    try {
+        const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({
+                runtime_type: 'parel',
+                runtime_session_id: childRef,
+                // Forks sit outside the main-lane uniqueness (parent set), mirroring
+                // the standard runtimes' fork ase_ semantics.
+                runtime_lane_key: `agent:fork:parel:${childRef}`,
+                ...(parentId ? { parent_session_id: parentId } : {}),
+            }),
+            signal: AbortSignal.timeout(opts.timeoutMs ?? REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok) {
+            console.error(`[parel-channel] child session get-or-create failed (${res.status})`);
+            return null;
+        }
+        const body = (await res.json().catch(() => null));
+        const id = body?.id;
+        if (!id)
+            return null;
+        await ctx.store?.set(cacheKey, id).catch(() => { });
+        return id;
+    }
+    catch (err) {
+        console.error('[parel-channel] child session get-or-create failed', err);
+        return null;
+    }
+}
+/** Drop one child session's cache row (its ase_ was closed under us). */
+export async function invalidateChildSession(ctx, childRef) {
+    await ctx.store?.delete(childSessionCacheKey(childRef)).catch(() => { });
+}
 /** PATCH the session (status / trigger_message_id). Never throws. */
 export async function patchSession(ctx, sessionId, body) {
     try {
@@ -194,6 +322,44 @@ export async function createChannelInputStep(ctx, sessionId, args) {
         return 'failed';
     }
 }
+/**
+ * Input step for a typed (non-message) dispatch — task/schedule/trigger/
+ * wiki-comment/approval events. Same processing-ring/panel role as the chat
+ * input step; the target routes the record to the source entity instead of a
+ * chat (typed dispatches have no message-level indicator, so the step is the
+ * panel timeline entry, not an indicator driver).
+ */
+export async function createTypedInputStep(ctx, sessionId, args) {
+    try {
+        const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions/${sessionId}/steps`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({
+                step_type: 'input',
+                ...(args.target ? { target_type: args.target.type, target_id: args.target.id } : {}),
+                // Session-scoped dedup — a failed ack leaves the dispatch replayable
+                // by the catch-up sweep, same rationale as the chat input step.
+                idempotency_key: `input:${args.dispatchId || args.sourceId}`,
+                content: {
+                    trigger_type: args.triggerType,
+                    trigger_ref: { source_id: args.sourceId },
+                    ...(args.senderId ? { sender_id: args.senderId } : {}),
+                    summary: args.summary.slice(0, 200),
+                },
+            }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (res.ok)
+            return 'ok';
+        console.error(`[parel-channel] typed input step failed (${res.status})`);
+        return resultForStatus(res.status);
+    }
+    catch (err) {
+        console.error('[parel-channel] typed input step failed', err);
+        return 'failed';
+    }
+}
 const ERROR_TEXT_MAX = 500;
 /**
  * Credential redaction for runtime error strings that become user-visible
@@ -239,16 +405,18 @@ export async function createErrorStep(ctx, sessionId, args) {
     const text = `Turn failed: ${redactSecrets(args.error, knownSecrets)}`.slice(0, ERROR_TEXT_MAX);
     try {
         const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions/${sessionId}/steps`;
-        // Same subject-prefix line createTraceStep draws: chv_ turns must not
-        // target 'chat' or the broadcast lands on a channel no client watches.
-        const targetType = args.subject.startsWith('chv_') ? 'channel_conversation' : 'chat';
+        // Same subject-shape line createTraceStep draws: non-chat subjects must
+        // not target 'chat' or the broadcast lands on a channel no client
+        // watches. Thread-composite subjects address the chat itself.
+        const targetId = subjectEntityId(args.subject);
+        const targetType = stepTargetTypeFor(targetId);
         const res = await fetch(url, {
             method: 'POST',
             headers: jsonHeaders(ctx),
             body: JSON.stringify({
                 step_type: 'text',
                 target_type: targetType,
-                target_id: args.subject,
+                target_id: targetId,
                 // At-most-once today (agent-event pushes are not replayed), but the
                 // turnId key makes a future retry path free of duplicate error rows.
                 idempotency_key: `error:${args.turnId}`,
@@ -331,15 +499,17 @@ export async function createTraceStep(ctx, sessionId, subject, event) {
     }
     try {
         const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions/${sessionId}/steps`;
-        // The subject prefix tells chat turns from external IM turns — channel
-        // steps must not target 'chat' or the server would broadcast them onto
-        // a messages:{chv_} channel no client subscribes to (agent-core's
-        // resolveStepTarget draws the same line).
-        const targetType = subject.startsWith('chv_') ? 'channel_conversation' : 'chat';
+        // The subject shape tells chat turns from external IM / typed-entity
+        // turns — non-chat steps must not target 'chat' or the server would
+        // broadcast them onto a messages:{…} channel no client subscribes to
+        // (agent-core's resolveStepTarget draws the same line). Thread-composite
+        // subjects address the chat itself.
+        const targetId = subjectEntityId(subject);
+        const targetType = stepTargetTypeFor(targetId);
         const res = await fetch(url, {
             method: 'POST',
             headers: jsonHeaders(ctx),
-            body: JSON.stringify({ ...body, target_type: targetType, target_id: subject }),
+            body: JSON.stringify({ ...body, target_type: targetType, target_id: targetId }),
             signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
         });
         if (res.ok)
@@ -352,6 +522,50 @@ export async function createTraceStep(ctx, sessionId, subject, event) {
         return 'failed';
     }
 }
+/**
+ * Ack a dispatch by source so it leaves the pending queue (idempotent).
+ * Typed as the fetch effect so it can ride BOTH hook channels (onMessage's
+ * ConnectorEffect[] and onAgentEvent's AgentEventEffect[] — the fork spawn
+ * ack fires from a child agent event).
+ */
+export function ackEffect(ctx, sourceType, sourceId) {
+    return {
+        type: 'fetch',
+        request: {
+            url: `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/dispatch/ack`,
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${requireAgk(ctx)}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ source_type: sourceType, source_id: sourceId }),
+        },
+        idempotencyKey: `ack:${sourceType}:${sourceId}`,
+    };
+}
+/**
+ * Ack ONE dispatch WorkItem by its id. Typed dispatches must use this form:
+ * sibling WorkItems (e.g. a task mutation's task_assign + task_update rows)
+ * share (source_type, source_id), so the by-source ack would terminally
+ * resolve work that was never emitted. Message dispatches keep the by-source
+ * form (one WorkItem per message; the source ack is the established legacy
+ * contract).
+ */
+export function ackByIdEffect(ctx, dispatchId) {
+    return {
+        type: 'fetch',
+        request: {
+            url: `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/dispatch/${dispatchId}/ack`,
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${requireAgk(ctx)}`,
+                'Content-Type': 'application/json',
+            },
+            body: '{}',
+        },
+        idempotencyKey: `ackid:${dispatchId}`,
+    };
+}
 /**
  * Lights the pending ring (server broadcasts dispatch.received). Must COMPLETE
  * before the ack effect is returned: MarkReceived only transitions rows still
@@ -359,8 +573,10 @@ export async function createTraceStep(ctx, sessionId, subject, event) {
  * means the ring never appears.
  */
 export async function markDispatchReceived(ctx, sourceType, sourceId) {
-    if (!reportingEnabled(ctx))
-        return;
+    // Deliberately NOT gated on reportingEnabled: this is ledger surface, not
+    // session reporting — the URL needs no agent id, and with ack-on-emit gone
+    // the received transition is what keeps the reconnect sweep's TTL window
+    // (and the indicator lifecycle) working even for agent-id-less old configs.
     try {
         const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/dispatch/received`;
         const res = await fetch(url, {
@@ -376,3 +592,165 @@ export async function markDispatchReceived(ctx, sourceType, sourceId) {
         console.error('[parel-channel] mark received failed', err);
     }
 }
+// ── By-source ledger surface ────────────────────────────
+//
+// The connector consumes dispatches without claiming lanes (parel's own
+// queue serializes turns), so its ledger writes address WorkItems by source
+// pointer, and its liveness bookkeeping is a per-source attempt fence in the
+// durable store. Design: parel-reply-contract-alignment.md §5.3.
+/**
+ * How long an emitted source may stay unresolved before the reconnect sweep
+ * re-emits it (crash / lost turn_completed self-heal — the successor of the
+ * retired turnwatch timer). Must comfortably exceed any legitimate turn.
+ */
+export const EMIT_TTL_MS = 30 * 60 * 1000;
+function activeEmitKey(sourceType, sourceId) {
+    return `active:${sourceType}:${sourceId}`;
+}
+/**
+ * Per-source attempt fence. Written before emit, cleared by the matching
+ * turn event's complete: a turn event only closes a source whose stored id
+ * EXACTLY matches one of its envelopeIds — a late turn_completed from a
+ * superseded attempt (the source was re-emitted after the TTL) must not
+ * close the in-flight retry's work (codex P2 attempt fence).
+ */
+export async function readActiveEmit(ctx, sourceType, sourceId) {
+    const raw = await ctx.store?.get(activeEmitKey(sourceType, sourceId)).catch(() => null);
+    if (raw &&
+        typeof raw === 'object' &&
+        typeof raw.id === 'string' &&
+        typeof raw.at === 'number') {
+        return raw;
+    }
+    return null;
+}
+export async function writeActiveEmit(ctx, sourceType, sourceId, envelopeId) {
+    await ctx.store
+        ?.set(activeEmitKey(sourceType, sourceId), { id: envelopeId, at: ctx.now() })
+        .catch(() => { });
+}
+export async function clearActiveEmit(ctx, sourceType, sourceId) {
+    await ctx.store?.delete(activeEmitKey(sourceType, sourceId)).catch(() => { });
+}
+/**
+ * Deterministic envelope id for a source: `{sourceType}:{sourceId}` on the
+ * first attempt, `…#r{n}` on re-emits. Attempt-suffixed ids are unique per
+ * attempt, so a re-emit is a NEW envelope to parel regardless of any dedupe
+ * behavior — the retry always produces a fresh turn.
+ */
+export function nextEnvelopeId(sourceType, sourceId, prior) {
+    const base = `${sourceType}:${sourceId}`;
+    if (!prior)
+        return base;
+    const m = prior.id.match(/#r(\d+)$/);
+    const attempt = m ? Number(m[1]) + 1 : 1;
+    return `${base}#r${attempt}`;
+}
+/** envelope id → source pointer (strips the attempt suffix). */
+export function sourceFromEnvelopeId(envelopeId) {
+    const bare = envelopeId.replace(/#r\d+$/, '');
+    const i = bare.indexOf(':');
+    if (i <= 0 || i === bare.length - 1)
+        return null;
+    return { sourceType: bare.slice(0, i), sourceId: bare.slice(i + 1) };
+}
+/**
+ * Fence-checked turn-end ledger close for a set of envelope ids — the shared
+ * core of BOTH turn-end hooks: onAgentEvent (turn_completed/turn_failed, the
+ * primary) and deliver (the no-observe npm-fallback path, where turn events
+ * never arrive and this is the ONLY terminal ledger hook — without it a
+ * received row would re-emit on every TTL sweep forever). Only sources whose
+ * `active:{source}` store row matches the envelope id EXACTLY are completed
+ * (attempt fence); the fence rows clear on success. Both hooks running is
+ * harmless: whichever completes first consumes the fence, the other skips.
+ */
+export async function completeFencedEnvelopes(ctx, envelopeIds) {
+    const fenced = [];
+    for (const envId of envelopeIds) {
+        const src = sourceFromEnvelopeId(envId);
+        if (!src)
+            continue; // pre-alignment envelope id (dsp_*) — old rows were acked on emit
+        const active = await readActiveEmit(ctx, src.sourceType, src.sourceId);
+        if (active?.id === envId) {
+            fenced.push({ source_type: src.sourceType, source_id: src.sourceId });
+        }
+    }
+    if (fenced.length > 0 && (await completeSources(ctx, fenced))) {
+        for (const src of fenced) {
+            await clearActiveEmit(ctx, src.source_type, src.source_id);
+        }
+    }
+}
+/**
+ * Turn-end ledger close: resolves the turn's folded sources on the server —
+ * broad-cover to the turn's reply Effect when one exists, no_action sweep
+ * otherwise (the server decides; POST /dispatch/complete-sources, idempotent).
+ * One immediate retry on failure; a still-failed call leaves the rows
+ * received and the catch-up TTL re-emit self-heals.
+ */
+export async function completeSources(ctx, sources) {
+    // Ledger surface — not gated on reportingEnabled (see markDispatchReceived).
+    if (sources.length === 0)
+        return true;
+    const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/dispatch/complete-sources`;
+    const attempt = async () => {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({ sources }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            console.error(`[parel-channel] complete-sources failed (${res.status})`);
+        return res.ok;
+    };
+    try {
+        if (await attempt())
+            return true;
+    }
+    catch {
+        // fall through to the single immediate retry
+    }
+    try {
+        return await attempt();
+    }
+    catch (err) {
+        console.error('[parel-channel] complete-sources failed', err);
+        return false;
+    }
+}
+/**
+ * Turn-end plain text as a suppressed audit step — the runtime-standard
+ * Layer 0 posture (agent-dm-loop-prevention.md): recorded on the session,
+ * never delivered to the chat. No `projection` field, so the server's
+ * projection gate keeps it panel-only; `suppressed: true` is the content
+ * marker the standard bridges write for undelivered text.
+ */
+export async function createSuppressedTextStep(ctx, sessionId, args) {
+    try {
+        const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions/${sessionId}/steps`;
+        // Same subject-prefix line the other step writers draw: chv_ turns must
+        // not target 'chat' or the broadcast lands on a channel no client watches.
+        const targetType = args.subject.startsWith('chv_') ? 'channel_conversation' : 'chat';
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({
+                step_type: 'text',
+                target_type: targetType,
+                target_id: args.subject,
+                idempotency_key: `text:${args.deliveryId}`,
+                content: { text: args.text, suppressed: true },
+            }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (res.ok)
+            return 'ok';
+        console.error(`[parel-channel] suppressed text step failed (${res.status})`);
+        return resultForStatus(res.status);
+    }
+    catch (err) {
+        console.error('[parel-channel] suppressed text step failed', err);
+        return 'failed';
+    }
+}

package/dist/typed-dispatch.d.ts

@@ -0,0 +1,82 @@
+import type { ConnectorContext } from '@parel/plugin-sdk';
+/**
+ * Typed (non-message) dispatches → agent events.
+ *
+ * Mirrors the standard runtimes' coverage (agent-core gateway dispatch.new
+ * switch; hermes adapter's inline port): task_assign / task_update /
+ * task_comment / wiki_comment / schedule.fire / external_trigger /
+ * approval_decided. Each handler pulls the source entity, renders the same
+ * event-body line format agent-core's buildEventBody produces (so an agent
+ * moved between runtimes reads identical events), and returns a plan the
+ * inbound pipeline turns into envelope + progress reporting + ack.
+ *
+ * Semantics carried over from the standard runtimes:
+ * - Permanently-unusable sources (404/403, deleted comments, no_reply hints,
+ *   stale task assignment) resolve to `stale` — the caller acks and drops.
+ * - Transient fetch failures resolve to `pending` — the dispatch stays
+ *   pending and the reconnect catch-up sweep retries it.
+ * - schedule.fire tolerates 404 by contract (post-fire PATCH on target_ids /
+ *   attached_to_uri legitimately revokes access to a delivered run snapshot;
+ *   docs/primitives/schedule.md § Snapshot 不变性) — warn + ack + drop.
+ *
+ * Reply semantics are uniform with the rest of the connector: NOTHING
+ * auto-delivers (the CLI-only reply contract,
+ * parel-reply-contract-alignment.md). A typed turn's turn-end text is never
+ * posted anywhere; the agent acts through its sandbox CLI — identical to
+ * the standard runtimes, where typed events are answered with CLI actions.
+ * approval_decided differs only in ROUTING metadata: it lives in a chat, so
+ * its plan carries the chatId — that anchors the suppressed turn-end audit
+ * step and tells the agent where to `parall messages send`; the reply
+ * itself is still an explicit CLI send.
+ */
+export interface TypedDispatchData {
+    id?: unknown;
+    event_type?: unknown;
+    source_type?: unknown;
+    source_id?: unknown;
+    chat_id?: unknown;
+    task_id?: unknown;
+    actor_id?: unknown;
+    delivery_reason?: unknown;
+}
+/** Dispatch event types this module consumes (everything but the message pair). */
+export declare const TYPED_EVENT_TYPES: readonly ["task_assign", "task_update", "task_comment", "wiki_comment", "schedule.fire", "external_trigger", "approval_decided"];
+export declare function isTypedEventType(eventType: string): boolean;
+/** What the inbound pipeline needs to emit + report one typed event. */
+export interface TypedEventPlan {
+    outcome: 'emit';
+    /** F2 grouping key + agent-event correlation anchor (task/schedule/… id). */
+    subject: string;
+    /** Framed event body (the envelope's data.text). */
+    body: string;
+    /** Input-step routing; null skips the step (no meaningful target). */
+    stepTarget: {
+        type: string;
+        id: string;
+    } | null;
+    /** Input-step content bits. */
+    triggerType: string;
+    summary: string;
+    /**
+     * Set only for approval_decided: anchors the suppressed turn-end audit
+     * step and tells the agent where to `parall messages send` — replies are
+     * CLI-only, nothing auto-delivers.
+     */
+    chatId?: string;
+}
+export type TypedDispatchResult = TypedEventPlan
+/** Permanently unusable — ack and drop. */
+ | {
+    outcome: 'stale';
+}
+/** Transient failure — leave pending for the catch-up sweep. */
+ | {
+    outcome: 'pending';
+};
+/**
+ * Build the plan for one typed dispatch. Never throws: any unexpected error
+ * degrades to `pending` (same posture as the message path — the sweep
+ * retries, and a poisoned row eventually surfaces as a stuck pending count).
+ */
+export declare function planTypedDispatch(data: TypedDispatchData, ctx: ConnectorContext): Promise<TypedDispatchResult>;
+//# sourceMappingURL=typed-dispatch.d.ts.map

package/dist/typed-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-dispatch.d.ts","sourceRoot":"","sources":["../src/typed-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAI1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,kIAQpB,CAAC;AAEX,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAChD,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,mBAAmB,GAC3B,cAAc;AAChB,2CAA2C;GACzC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE;AACtB,gEAAgE;GAC9D;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC;AAY3B;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,mBAAmB,CAAC,CAwC9B"}