@kuralle-agents/messaging 0.9.0 → 0.11.0

package/README.md

@@ -16,7 +16,7 @@ Provides the `PlatformClient` interface that every messaging vendor package impl
 - **`PlatformClient`** — interface that normalizes sending, receiving, media, webhooks, and format conversion across vendors. Implement this to add any messaging platform.
 - **`SessionResolver`** — maps inbound messages to Kuralle session IDs. Default: `{platform}:{threadId}`. Swap in `ThreadIdResolver`, `PhoneLookupResolver`, or a custom `SessionResolverChain`.
 - **`StreamMapper`** — consumes `AsyncIterable<HarnessStreamPart>`, sends typing indicators during streaming, delegates final output to a `ResponseMapper`.
-- **`MessageDeduplicator`** — LRU cache that prevents duplicate webhook processing.
+- **`InboundLedger`** — async claim/append/complete ledger for tenant-scoped inbound idempotency and ordering.
 - **`WindowTracker`** / **`WindowStore`** — tracks 24-hour messaging windows per thread; used by `createMessagingRouter` to detect expired windows.
 - **`OutboundPipeline`** + **`windowGuard`** — window-safe outbound path (see below).
 - **`createInputCoalescer`** + **`inboundCoalescing`** — optional per-thread burst coalescing before `runtime.run` (WhatsApp text-ins). Default **off**; see [Inbound coalescing](#inbound-coalescing).

package/dist/adapter/createMessagingRouter.d.ts

@@ -1,36 +1,3 @@
 import { Hono } from 'hono';
 import type { MessagingRouterConfig } from '../types.js';
-/**
- * Create a Hono router that bridges messaging platform webhooks with the Kuralle runtime.
- *
- * For each platform in the config, this function:
- * 1. Registers message, status, and reaction handlers on the platform client
- * 2. Mounts GET and POST webhook routes at `/{platformName}/webhook`
- *
- * When a message arrives:
- * 1. The platform client verifies the webhook signature, parses the payload,
- *    and dispatches to the registered message handler
- * 2. The handler deduplicates the message, tracks the conversation window,
- *    resolves the session, and streams the runtime response
- * 3. The stream mapper sends the response back through the outbound pipeline
- *
- * @param config - Router configuration with runtime, platforms, and optional customizations.
- * @returns A Hono app with webhook routes mounted for each platform.
- *
- * @example
- * ```typescript
- * import { createMessagingRouter } from '@kuralle-agents/messaging';
- *
- * const router = createMessagingRouter({
- *   runtime,
- *   platforms: {
- *     whatsapp: whatsappClient,
- *     messenger: messengerClient,
- *   },
- * });
- *
- * // Mount into your main Hono app
- * app.route('/messaging', router);
- * ```
- */
 export declare function createMessagingRouter(config: MessagingRouterConfig): Hono;

package/dist/adapter/createMessagingRouter.js

@@ -1,14 +1,14 @@
 import { Hono } from 'hono';
-import { mergeUserInputContents } from '@kuralle-agents/core';
-import { MessageDeduplicator } from '../shared/deduplicator.js';
 import { InMemoryWindowStore } from './window-store.js';
 import { defaultSessionResolver } from './session-resolver.js';
 import { InboundResolverChain, defaultInboundChain, } from './input-resolver-chain.js';
-import { attachInboundMedia } from './inbound-media.js';
 import { createInputCoalescer } from './input-coalescer.js';
 import { StreamMapper } from './stream-mapper.js';
 import { OutboundPipeline } from './outbound-pipeline.js';
 import { windowGuard } from './middleware/window-guard.js';
+import { InMemoryInboundLedger, conversationKeyToString, } from '../inbound/ledger.js';
+import { claimAndAppend, coalesceMessages, consentStop, createInboundPipeline, ownershipGate, recordWindow, resolveAndAttachMedia, runTurn, statusReactionErrorPhase, } from '../inbound/pipeline.js';
+import { noopCoalesceScheduler, PlatformMediaResolver, systemClock } from '../inbound/ports.js';
 function buildOutboundChain(extra) {
     return [...(extra ?? []), windowGuard];
 }
@@ -45,42 +45,9 @@ async function recordInboundToHistory(config, sessionId, message, userId) {
     session.updatedAt = new Date();
     await store.save(session);
 }
-/**
- * Create a Hono router that bridges messaging platform webhooks with the Kuralle runtime.
- *
- * For each platform in the config, this function:
- * 1. Registers message, status, and reaction handlers on the platform client
- * 2. Mounts GET and POST webhook routes at `/{platformName}/webhook`
- *
- * When a message arrives:
- * 1. The platform client verifies the webhook signature, parses the payload,
- *    and dispatches to the registered message handler
- * 2. The handler deduplicates the message, tracks the conversation window,
- *    resolves the session, and streams the runtime response
- * 3. The stream mapper sends the response back through the outbound pipeline
- *
- * @param config - Router configuration with runtime, platforms, and optional customizations.
- * @returns A Hono app with webhook routes mounted for each platform.
- *
- * @example
- * ```typescript
- * import { createMessagingRouter } from '@kuralle-agents/messaging';
- *
- * const router = createMessagingRouter({
- *   runtime,
- *   platforms: {
- *     whatsapp: whatsappClient,
- *     messenger: messengerClient,
- *   },
- * });
- *
- * // Mount into your main Hono app
- * app.route('/messaging', router);
- * ```
- */
 export function createMessagingRouter(config) {
     const app = new Hono();
-    const deduplicator = new MessageDeduplicator();
+    const ledger = config.ledger ?? new InMemoryInboundLedger();
     const windowStore = config.windowStore ?? new InMemoryWindowStore();
     const sessionResolver = config.sessionResolver ?? defaultSessionResolver;
     const inboundChain = config.inputResolver
@@ -100,87 +67,56 @@ export function createMessagingRouter(config) {
         : undefined;
     for (const [name, platform] of Object.entries(config.platforms)) {
         const pipeline = new OutboundPipeline(buildOutboundChain(config.outbound), platform);
+        const outboundSender = new PipelineOutboundSender(streamMapper, platform, pipeline, windowStore, config.responseMapper);
+        const inboundRuntime = {
+            ledger,
+            window: windowStore,
+            consent: config.consent,
+            ownership: config.ownership,
+            media: new PlatformMediaResolver(platform),
+            sender: outboundSender,
+            runtime: new RuntimeTurnRunner(config.runtime),
+            scheduler: config.scheduler ?? noopCoalesceScheduler,
+            clock: config.clock ?? systemClock,
+        };
+        const inboundPipeline = createInboundPipeline([
+            claimAndAppend(),
+            statusReactionErrorPhase({
+                onStatus: async (event) => {
+                    await config.onStatus?.(event.data);
+                },
+            }),
+            recordWindow(),
+            consentStop(),
+            ownershipGate({
+                resolveSession: (message) => sessionResolver.resolve(message),
+                recordHumanOwned: (message, sessionId, userId) => recordInboundToHistory(config, sessionId, message, userId),
+            }),
+            resolveAndAttachMedia(inboundChain),
+            coalesceMessages(coalescer),
+            runTurn(),
+        ]);
         platform.onMessage(async (message) => {
-            if (deduplicator.isDuplicate(message.id))
-                return;
-            await windowStore.recordInbound(message.threadId, message.timestamp);
-            if (config.consent && message.text?.trim().toUpperCase() === 'STOP') {
-                await config.consent.optOut(message.customerId);
-                return;
+            try {
+                await inboundPipeline.ingest(conversationKeyFromMessage(name, message), messageEvent(message), inboundRuntime);
             }
-            const { sessionId, userId } = await sessionResolver.resolve(message);
-            if (config.ownership && (await config.ownership.owner(message.threadId)) === 'human') {
-                await recordInboundToHistory(config, sessionId, message, userId);
-                return;
-            }
-            const { input: resolvedInput, selection } = await inboundChain.resolve(message);
-            // Multimodal intake: download any inbound media and attach it as AI SDK file
-            // parts so photos / voice notes / documents reach the model (REQ multimodal).
-            const input = await attachInboundMedia(message, resolvedInput, platform);
-            const runInbound = async (items) => {
-                const mergedInput = mergeUserInputContents(items.map((i) => i.input)) ?? '';
-                const last = items[items.length - 1];
-                const { sessionId, userId } = last;
-                try {
-                    const handle = config.runtime.run({
-                        input: mergedInput,
-                        sessionId,
-                        userId,
-                        selection: last.selection,
-                    });
-                    const parts = await streamMapper.mapStream(handle.events, platform, message.threadId, {
-                        responseMapper: config.responseMapper,
-                        pipeline,
-                        windowStore,
-                        sessionId,
-                        userId,
-                    });
-                    if (config.ownership &&
-                        parts.some((p) => p.type === 'handoff' && p.targetAgent === 'human')) {
-                        await config.ownership.claim(message.threadId, 'human');
-                    }
-                }
-                catch (error) {
-                    try {
-                        const window = await windowStore.get(message.threadId);
-                        await pipeline.send({
-                            threadId: message.threadId,
-                            platform: name,
-                            payload: { kind: 'text', text: fallbackMessage },
-                            meta: { window, parts: [], sessionId, userId },
-                        });
-                    }
-                    catch {
-                        // Cannot even send fallback — nothing more we can do
-                    }
-                    const errorContext = {
-                        message: last.message,
-                        platform: name,
-                        error: error,
-                    };
-                    config.onError?.(error, errorContext);
-                }
-            };
-            const item = {
-                input,
-                selection,
-                sessionId,
-                userId,
-                message,
-                platform: name,
-            };
-            if (coalescer) {
-                coalescer.push(message.threadId, item, runInbound);
-            }
-            else {
-                await runInbound([item]);
+            catch (error) {
+                await sendFallback({
+                    error: error,
+                    fallbackMessage,
+                    message,
+                    platformName: name,
+                    pipeline,
+                    windowStore,
+                    config,
+                });
             }
         });
         platform.onStatus(async (status) => {
-            if (status.conversation?.expirationTimestamp && status.threadId) {
-                await windowStore.recordExpiry(status.threadId, status.conversation.expirationTimestamp);
-            }
-            config.onStatus?.(status);
+            await inboundPipeline.ingest(conversationKeyFromStatus(name, status), statusEvent(status), inboundRuntime);
+        });
+        platform.onReaction(async (reaction) => {
+            await inboundPipeline.ingest(conversationKeyFromReaction(name, reaction), reactionEvent(reaction, inboundRuntime.clock.now()), inboundRuntime);
         });
         app.get(`/${name}/webhook`, async (c) => {
             return platform.handleWebhook(c.req.raw);
@@ -213,3 +149,147 @@ export function createMessagingRouter(config) {
     }
     return app;
 }
+class RuntimeTurnRunner {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async runTurn(args) {
+        const handle = this.runtime.run({
+            input: args.input,
+            sessionId: args.sessionId,
+            userId: args.userId,
+            selection: args.selection,
+            abortSignal: args.signal,
+        });
+        const parts = await collectParts(handle.events);
+        return turnResult(parts);
+    }
+    async deliverSignal(args) {
+        const handle = this.runtime.run({
+            sessionId: args.sessionId,
+            signalDelivery: args.signal,
+            abortSignal: args.signal2,
+        });
+        const parts = await collectParts(handle.events);
+        return turnResult(parts);
+    }
+}
+class PipelineOutboundSender {
+    streamMapper;
+    platform;
+    pipeline;
+    windowStore;
+    responseMapper;
+    constructor(streamMapper, platform, pipeline, windowStore, responseMapper) {
+        this.streamMapper = streamMapper;
+        this.platform = platform;
+        this.pipeline = pipeline;
+        this.windowStore = windowStore;
+        this.responseMapper = responseMapper;
+    }
+    async send(ctx, result) {
+        const threadId = threadIdForContext(ctx);
+        await this.streamMapper.mapParts(result.parts, this.platform, threadId, {
+            responseMapper: this.responseMapper,
+            pipeline: this.pipeline,
+            windowStore: this.windowStore,
+            sessionId: ctx.sessionId ?? conversationKeyToString(ctx.key),
+            userId: ctx.userId,
+        });
+    }
+}
+async function collectParts(stream) {
+    const parts = [];
+    for await (const part of stream) {
+        parts.push(part);
+    }
+    return parts;
+}
+function turnResult(parts) {
+    return {
+        parts,
+        suspended: suspendedPart(parts),
+        handoffToHuman: parts.some((part) => part.type === 'handoff' && part.targetAgent === 'human'),
+    };
+}
+function suspendedPart(parts) {
+    const paused = parts.find((part) => part.type === 'paused');
+    return paused ? { signalId: paused.waitingFor } : undefined;
+}
+async function sendFallback(args) {
+    const resolved = await (args.config.sessionResolver ?? defaultSessionResolver).resolve(args.message);
+    try {
+        const window = await args.windowStore.get(args.message.threadId);
+        await args.pipeline.send({
+            threadId: args.message.threadId,
+            platform: args.platformName,
+            payload: { kind: 'text', text: args.fallbackMessage },
+            meta: { window, parts: [], sessionId: resolved.sessionId, userId: resolved.userId },
+        });
+    }
+    catch {
+        // Preserve previous behavior: fallback send failure is swallowed, original error is reported.
+    }
+    const errorContext = {
+        message: args.message,
+        platform: args.platformName,
+        error: args.error,
+    };
+    args.config.onError?.(args.error, errorContext);
+}
+function messageEvent(message) {
+    return {
+        kind: 'message',
+        id: message.id,
+        ts: message.timestamp.getTime(),
+        data: message,
+    };
+}
+function statusEvent(status) {
+    return {
+        kind: 'status',
+        id: `status:${status.messageId}:${status.status}:${status.timestamp.getTime()}`,
+        ts: status.timestamp.getTime(),
+        data: status,
+    };
+}
+function reactionEvent(reaction, now) {
+    return {
+        kind: 'reaction',
+        id: `reaction:${reaction.messageId}:${reaction.userId}:${reaction.emoji}:${reaction.action}`,
+        ts: now,
+        data: reaction,
+    };
+}
+function conversationKeyFromMessage(platformName, message) {
+    return conversationKeyFromThread(message.platform || platformName, message.threadId);
+}
+function conversationKeyFromStatus(platformName, status) {
+    return conversationKeyFromThread(platformName, status.threadId ?? status.recipientId);
+}
+function conversationKeyFromReaction(platformName, reaction) {
+    return conversationKeyFromThread(platformName, reaction.userId);
+}
+function conversationKeyFromThread(platform, threadId) {
+    const parts = threadId.split(':');
+    if (parts.length >= 3 && parts[0] === platform) {
+        return {
+            platform,
+            businessId: parts[1],
+            threadId: parts.slice(2).join(':'),
+        };
+    }
+    return {
+        platform,
+        businessId: 'default',
+        threadId,
+    };
+}
+function threadIdForContext(ctx) {
+    if (ctx.event.kind === 'message')
+        return ctx.event.data.threadId;
+    if (ctx.event.kind === 'status' && ctx.event.data.threadId)
+        return ctx.event.data.threadId;
+    return conversationKeyToString(ctx.key);
+}

package/dist/adapter/stream-mapper.d.ts

@@ -2,6 +2,7 @@ import type { HarnessStreamPart } from '@kuralle-agents/core';
 import type { PlatformClient, StreamMapperOptions } from '../types.js';
 export declare class StreamMapper {
     mapStream(stream: AsyncIterable<HarnessStreamPart>, platform: PlatformClient, threadId: string, options: StreamMapperOptions): Promise<HarnessStreamPart[]>;
+    mapParts(parts: HarnessStreamPart[], platform: PlatformClient, threadId: string, options: StreamMapperOptions, textOverride?: string): Promise<void>;
     private buildMeta;
     private sendFreeform;
     private defaultMapResponse;

package/dist/adapter/stream-mapper.js

@@ -38,19 +38,7 @@ export class StreamMapper {
             }
             typingActive = false;
             clearInterval(typingInterval);
-            const meta = await this.buildMeta(options.windowStore, threadId, parts, options.sessionId, options.userId);
-            if (options.responseMapper) {
-                await options.responseMapper.mapResponse(parts, {
-                    threadId,
-                    platform: platform.platform,
-                    sendText: (text) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'text', text }, meta),
-                    sendInteractive: (msg) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'interactive', interactive: msg }, meta),
-                    sendMedia: (media) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'media', media }, meta),
-                });
-            }
-            else {
-                await this.defaultMapResponse(options.pipeline, platform, threadId, textBuffer, meta, parts);
-            }
+            await this.mapParts(parts, platform, threadId, options, textBuffer);
         }
         finally {
             typingActive = false;
@@ -58,6 +46,25 @@ export class StreamMapper {
         }
         return parts;
     }
+    async mapParts(parts, platform, threadId, options, textOverride) {
+        const text = textOverride ??
+            parts
+                .filter((part) => part.type === 'text-delta')
+                .map((part) => part.delta)
+                .join('');
+        const meta = await this.buildMeta(options.windowStore, threadId, parts, options.sessionId, options.userId);
+        if (options.responseMapper) {
+            await options.responseMapper.mapResponse(parts, {
+                threadId,
+                platform: platform.platform,
+                sendText: (message) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'text', text: message }, meta),
+                sendInteractive: (msg) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'interactive', interactive: msg }, meta),
+                sendMedia: (media) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'media', media }, meta),
+            });
+            return;
+        }
+        await this.defaultMapResponse(options.pipeline, platform, threadId, text, meta, parts);
+    }
     async buildMeta(windowStore, threadId, parts, sessionId, userId) {
         const window = await windowStore.get(threadId);
         return { window, parts, sessionId, userId };

package/dist/inbound/ledger.d.ts

@@ -0,0 +1,37 @@
+import type { InboundEvent } from './types.js';
+export type ClaimResult = 'claimed' | 'duplicate' | 'in_progress';
+export interface ConversationKey {
+    platform: string;
+    businessId: string;
+    threadId: string;
+}
+export type ConvKeyStr = string;
+export interface InboundLedger {
+    claim(key: ConversationKey, eventId: string): Promise<ClaimResult>;
+    complete(key: ConversationKey, eventId: string): Promise<void>;
+    append(key: ConversationKey, event: InboundEvent): Promise<{
+        seq: number;
+    }>;
+    readUnprocessed(key: ConversationKey): Promise<InboundEvent[]>;
+    commitCursor(key: ConversationKey, throughSeq: number, expect: number): Promise<boolean>;
+    prune(key: ConversationKey, ttlMs: number): Promise<number>;
+}
+export declare const ledgerSeq: unique symbol;
+export type SequencedInboundEvent = InboundEvent & {
+    [ledgerSeq]?: number;
+};
+export declare function conversationKeyToString(key: ConversationKey): ConvKeyStr;
+export declare function eventSeq(event: InboundEvent): number | undefined;
+export declare class InMemoryInboundLedger implements InboundLedger {
+    private readonly states;
+    claim(key: ConversationKey, eventId: string): Promise<ClaimResult>;
+    complete(key: ConversationKey, eventId: string): Promise<void>;
+    append(key: ConversationKey, event: InboundEvent): Promise<{
+        seq: number;
+    }>;
+    readUnprocessed(key: ConversationKey): Promise<InboundEvent[]>;
+    commitCursor(key: ConversationKey, throughSeq: number, expect: number): Promise<boolean>;
+    prune(key: ConversationKey, ttlMs: number): Promise<number>;
+    cursor(key: ConversationKey): number;
+    private state;
+}

package/dist/inbound/ledger.js

@@ -0,0 +1,72 @@
+export const ledgerSeq = Symbol.for('@kuralle-agents/messaging/inbound-seq');
+export function conversationKeyToString(key) {
+    return `${key.platform}:${key.businessId}:${key.threadId}`;
+}
+export function eventSeq(event) {
+    return event[ledgerSeq];
+}
+export class InMemoryInboundLedger {
+    states = new Map();
+    async claim(key, eventId) {
+        const state = this.state(key);
+        const existing = state.claims.get(eventId);
+        if (existing === 'complete')
+            return 'duplicate';
+        if (existing === 'in_progress')
+            return 'in_progress';
+        state.claims.set(eventId, 'in_progress');
+        return 'claimed';
+    }
+    async complete(key, eventId) {
+        this.state(key).claims.set(eventId, 'complete');
+    }
+    async append(key, event) {
+        const state = this.state(key);
+        if (state.events.some((stored) => stored.event.id === event.id)) {
+            const stored = state.events.find((item) => item.event.id === event.id);
+            return { seq: stored.seq };
+        }
+        const seq = state.nextSeq++;
+        const sequenced = Object.assign({}, event);
+        Object.defineProperty(sequenced, ledgerSeq, {
+            value: seq,
+            enumerable: false,
+        });
+        state.events.push({ event: sequenced, seq, appendedAt: Date.now() });
+        state.events.sort((a, b) => a.event.ts - b.event.ts || a.seq - b.seq);
+        return { seq };
+    }
+    async readUnprocessed(key) {
+        const state = this.state(key);
+        return state.events
+            .filter((stored) => stored.seq > state.cursor)
+            .sort((a, b) => a.event.ts - b.event.ts || a.seq - b.seq)
+            .map((stored) => stored.event);
+    }
+    async commitCursor(key, throughSeq, expect) {
+        const state = this.state(key);
+        if (state.cursor !== expect)
+            return false;
+        state.cursor = Math.max(state.cursor, throughSeq);
+        return true;
+    }
+    async prune(key, ttlMs) {
+        const state = this.state(key);
+        const cutoff = Date.now() - ttlMs;
+        const before = state.events.length;
+        state.events = state.events.filter((stored) => stored.seq > state.cursor || stored.appendedAt >= cutoff);
+        return before - state.events.length;
+    }
+    cursor(key) {
+        return this.state(key).cursor;
+    }
+    state(key) {
+        const str = conversationKeyToString(key);
+        let state = this.states.get(str);
+        if (!state) {
+            state = { nextSeq: 1, cursor: 0, claims: new Map(), events: [] };
+            this.states.set(str, state);
+        }
+        return state;
+    }
+}

package/dist/inbound/pipeline.d.ts

@@ -0,0 +1,40 @@
+import type { CoalescedInboundItem } from '../types/adapter.js';
+import type { InboundMessage } from '../types/messages.js';
+import type { InputCoalescer } from '../adapter/input-coalescer.js';
+import type { InboundResolverChain } from '../adapter/input-resolver-chain.js';
+import { type ConversationKey } from './ledger.js';
+import type { InboundContext, InboundEvent, InboundMiddleware, InboundOutcome, InboundRuntime } from './types.js';
+export type CoalescedPipelineItem = CoalescedInboundItem & {
+    key: ConversationKey;
+    eventId: string;
+    seq: number;
+    ctx: InboundContext;
+};
+export declare function createInboundPipeline(mw: InboundMiddleware[]): {
+    ingest(key: ConversationKey, event: InboundEvent, rt: InboundRuntime): Promise<InboundOutcome>;
+    flush(key: ConversationKey, rt: InboundRuntime): Promise<InboundOutcome>;
+};
+export declare function claimAndAppend(): InboundMiddleware;
+export declare function statusReactionErrorPhase(options?: {
+    onStatus?: (status: InboundEvent & {
+        kind: 'status';
+    }) => Promise<void>;
+    onReaction?: (reaction: InboundEvent & {
+        kind: 'reaction';
+    }) => Promise<void>;
+    onErrorEvent?: (event: InboundEvent & {
+        kind: 'error';
+    }) => Promise<void>;
+}): InboundMiddleware;
+export declare function recordWindow(): InboundMiddleware;
+export declare function consentStop(): InboundMiddleware;
+export declare function ownershipGate(options: {
+    resolveSession(message: InboundMessage): Promise<{
+        sessionId: string;
+        userId?: string;
+    }>;
+    recordHumanOwned(message: InboundMessage, sessionId: string, userId?: string): Promise<void>;
+}): InboundMiddleware;
+export declare function resolveAndAttachMedia(inboundChain: InboundResolverChain): InboundMiddleware;
+export declare function coalesceMessages(coalescer: InputCoalescer<CoalescedPipelineItem> | undefined): InboundMiddleware;
+export declare function runTurn(): InboundMiddleware;

package/dist/inbound/pipeline.js

@@ -0,0 +1,239 @@
+import { mergeUserInputContents } from '@kuralle-agents/core';
+import { eventSeq, } from './ledger.js';
+export function createInboundPipeline(mw) {
+    async function run(ctx) {
+        const dispatch = (i) => {
+            const middleware = mw[i];
+            if (!middleware)
+                return Promise.resolve({ kind: 'short', by: 'pipeline', reason: 'no-input' });
+            const next = () => dispatch(i + 1);
+            return middleware.handle(ctx, next);
+        };
+        const outcome = await dispatch(0);
+        await finalizeIfTerminal(ctx, outcome);
+        return outcome;
+    }
+    return {
+        ingest(key, event, rt) {
+            return run({ key, event, rt, locals: {} });
+        },
+        async flush(key, rt) {
+            const events = await rt.ledger.readUnprocessed(key);
+            let last = { kind: 'short', by: 'pipeline', reason: 'no-input' };
+            for (const event of events) {
+                last = await run({ key, event, rt, locals: { replay: true } });
+            }
+            return last;
+        },
+    };
+}
+async function finalizeIfTerminal(ctx, outcome) {
+    if (ctx.locals.claimResult !== 'claimed' || outcome.kind === 'buffered')
+        return;
+    await completeAndCommit(ctx, ctx.event.id);
+}
+async function completeAndCommit(ctx, eventId) {
+    await ctx.rt.ledger.complete(ctx.key, eventId);
+    const seq = typeof ctx.locals.seq === 'number' ? ctx.locals.seq : eventSeq(ctx.event);
+    const cursor = typeof ctx.locals.cursor === 'number' ? ctx.locals.cursor : 0;
+    if (seq !== undefined) {
+        const committed = await ctx.rt.ledger.commitCursor(ctx.key, seq, cursor);
+        if (!committed) {
+            await ctx.rt.ledger.commitCursor(ctx.key, seq, seq - 1);
+        }
+    }
+}
+export function claimAndAppend() {
+    return {
+        name: 'claim',
+        async handle(ctx, next) {
+            const claim = await ctx.rt.ledger.claim(ctx.key, ctx.event.id);
+            ctx.locals.claimResult = claim;
+            if (claim === 'duplicate') {
+                return { kind: 'short', by: 'claim', reason: 'duplicate' };
+            }
+            if (claim === 'in_progress') {
+                return { kind: 'short', by: 'claim', reason: 'in-progress' };
+            }
+            const cursorBefore = await currentCursor(ctx);
+            const { seq } = await ctx.rt.ledger.append(ctx.key, ctx.event);
+            ctx.locals.seq = seq;
+            ctx.locals.cursor = cursorBefore;
+            return next();
+        },
+    };
+}
+async function currentCursor(ctx) {
+    const events = await ctx.rt.ledger.readUnprocessed(ctx.key);
+    const seqs = events.map((event) => eventSeq(event)).filter((seq) => seq !== undefined);
+    const minSeq = Math.min(...seqs, Number.POSITIVE_INFINITY);
+    return minSeq === Number.POSITIVE_INFINITY ? 0 : minSeq - 1;
+}
+export function statusReactionErrorPhase(options) {
+    return {
+        name: 'phase-handler',
+        async handle(ctx, next) {
+            if (ctx.event.kind === 'status') {
+                const status = ctx.event.data;
+                if (status.conversation?.expirationTimestamp && status.threadId) {
+                    await ctx.rt.window.recordExpiry(status.threadId, status.conversation.expirationTimestamp);
+                }
+                await options?.onStatus?.(ctx.event);
+                return { kind: 'short', by: 'phase-handler', reason: 'status' };
+            }
+            if (ctx.event.kind === 'reaction') {
+                await options?.onReaction?.(ctx.event);
+                return { kind: 'short', by: 'phase-handler', reason: 'reaction' };
+            }
+            if (ctx.event.kind === 'error') {
+                await options?.onErrorEvent?.(ctx.event);
+                return { kind: 'short', by: 'phase-handler', reason: 'error' };
+            }
+            return next();
+        },
+    };
+}
+export function recordWindow() {
+    return {
+        name: 'record-window',
+        async handle(ctx, next) {
+            if (ctx.event.kind === 'message') {
+                await ctx.rt.window.recordInbound(ctx.event.data.threadId, ctx.event.data.timestamp);
+            }
+            return next();
+        },
+    };
+}
+export function consentStop() {
+    return {
+        name: 'consent-stop',
+        async handle(ctx, next) {
+            if (ctx.event.kind === 'message' &&
+                ctx.rt.consent &&
+                ctx.event.data.text?.trim().toUpperCase() === 'STOP') {
+                await ctx.rt.consent.optOut(ctx.event.data.customerId);
+                return { kind: 'short', by: 'consent-stop', reason: 'opted-out' };
+            }
+            return next();
+        },
+    };
+}
+export function ownershipGate(options) {
+    return {
+        name: 'ownership',
+        async handle(ctx, next) {
+            if (ctx.event.kind !== 'message')
+                return next();
+            const resolved = await options.resolveSession(ctx.event.data);
+            ctx.sessionId = resolved.sessionId;
+            ctx.userId = resolved.userId;
+            if (ctx.rt.ownership && (await ctx.rt.ownership.owner(ctx.event.data.threadId)) === 'human') {
+                await options.recordHumanOwned(ctx.event.data, resolved.sessionId, resolved.userId);
+                return { kind: 'short', by: 'ownership', reason: 'human-owned' };
+            }
+            return next();
+        },
+    };
+}
+export function resolveAndAttachMedia(inboundChain) {
+    return {
+        name: 'resolve-media',
+        async handle(ctx, next) {
+            if (ctx.event.kind !== 'message')
+                return next();
+            const { input: resolvedInput, selection } = await inboundChain.resolve(ctx.event.data);
+            ctx.input = await ctx.rt.media.resolve(ctx.event.data, resolvedInput);
+            ctx.selection = selection;
+            return next();
+        },
+    };
+}
+export function coalesceMessages(coalescer) {
+    return {
+        name: 'coalesce',
+        async handle(ctx, next) {
+            if (!coalescer || ctx.event.kind !== 'message')
+                return next();
+            if (ctx.input === undefined)
+                return { kind: 'short', by: 'coalesce', reason: 'no-input' };
+            const seq = typeof ctx.locals.seq === 'number' ? ctx.locals.seq : eventSeq(ctx.event);
+            if (seq === undefined)
+                return next();
+            coalescer.push(ctx.event.data.threadId, {
+                key: ctx.key,
+                eventId: ctx.event.id,
+                seq,
+                input: ctx.input,
+                selection: ctx.selection,
+                sessionId: ctx.sessionId ?? `${ctx.key.platform}:${ctx.key.businessId}:${ctx.key.threadId}`,
+                userId: ctx.userId,
+                message: ctx.event.data,
+                platform: ctx.key.platform,
+                ctx,
+            }, async (items) => {
+                await runCoalesced(items);
+            });
+            return { kind: 'buffered' };
+        },
+    };
+}
+async function runCoalesced(items) {
+    if (items.length === 0)
+        return;
+    const last = items[items.length - 1];
+    const input = mergeUserInputContents(items.map((item) => item.input)) ?? '';
+    const result = await last.ctx.rt.runtime.runTurn({
+        key: last.key,
+        input,
+        selection: last.selection,
+        sessionId: last.sessionId,
+        userId: last.userId,
+    });
+    await last.ctx.rt.sender.send(last.ctx, result);
+    if (result.handoffToHuman && last.ctx.rt.ownership && last.ctx.event.kind === 'message') {
+        await last.ctx.rt.ownership.claim(last.ctx.event.data.threadId, 'human');
+    }
+    for (const item of items) {
+        await item.ctx.rt.ledger.complete(item.key, item.eventId);
+    }
+    const throughSeq = Math.max(...items.map((item) => item.seq));
+    await last.ctx.rt.ledger.commitCursor(last.key, throughSeq, throughSeq - items.length);
+}
+export function runTurn() {
+    return {
+        name: 'run-turn',
+        async handle(ctx) {
+            let result;
+            if (ctx.event.kind === 'signal') {
+                result = await ctx.rt.runtime.deliverSignal({
+                    key: ctx.key,
+                    sessionId: ctx.sessionId ?? `${ctx.key.platform}:${ctx.key.businessId}:${ctx.key.threadId}`,
+                    signal: {
+                        signalId: ctx.event.data.signalId,
+                        name: ctx.event.data.name,
+                        payload: ctx.event.data.payload,
+                    },
+                });
+            }
+            else if (ctx.event.kind === 'message' && ctx.input !== undefined) {
+                result = await ctx.rt.runtime.runTurn({
+                    key: ctx.key,
+                    input: ctx.input,
+                    selection: ctx.selection,
+                    sessionId: ctx.sessionId,
+                    userId: ctx.userId,
+                });
+            }
+            else {
+                return { kind: 'short', by: 'run-turn', reason: 'no-input' };
+            }
+            await ctx.rt.sender.send(ctx, result);
+            if (result.handoffToHuman && ctx.rt.ownership && ctx.event.kind === 'message') {
+                await ctx.rt.ownership.claim(ctx.event.data.threadId, 'human');
+            }
+            if (result.suspended)
+                return { kind: 'suspended', signalId: result.suspended.signalId };
+            return { kind: 'ran', parts: result.parts };
+        },
+    };
+}

package/dist/inbound/ports.d.ts

@@ -0,0 +1,18 @@
+import type { UserInputContent } from '@kuralle-agents/core';
+import type { InboundMessage } from '../types/messages.js';
+import type { PlatformClient } from '../types/client.js';
+export interface MediaResolver {
+    resolve(message: InboundMessage, input: UserInputContent): Promise<UserInputContent>;
+}
+export declare class PlatformMediaResolver implements MediaResolver {
+    private readonly client;
+    constructor(client: Pick<PlatformClient, 'downloadMedia'>);
+    resolve(message: InboundMessage, input: UserInputContent): Promise<UserInputContent>;
+}
+export declare const systemClock: {
+    now: () => number;
+};
+export declare const noopCoalesceScheduler: {
+    arm: () => Promise<void>;
+    cancel: () => Promise<void>;
+};

package/dist/inbound/ports.js

@@ -0,0 +1,17 @@
+export class PlatformMediaResolver {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async resolve(message, input) {
+        const { attachInboundMedia } = await import('../adapter/inbound-media.js');
+        return attachInboundMedia(message, input, this.client);
+    }
+}
+export const systemClock = {
+    now: () => Date.now(),
+};
+export const noopCoalesceScheduler = {
+    arm: async () => { },
+    cancel: async () => { },
+};

package/dist/inbound/types.d.ts

@@ -0,0 +1,116 @@
+import type { HarnessStreamPart, ResolvedSelection, SignalDelivery, UserInputContent } from '@kuralle-agents/core';
+import type { ConsentStore } from '../adapter/consent-store.js';
+import type { MediaResolver } from './ports.js';
+import type { OwnershipStore } from '../adapter/ownership-store.js';
+import type { ReactionData, StatusUpdate, InboundMessage } from '../types/messages.js';
+import type { WindowStore } from '../adapter/window-store.js';
+import type { ConversationKey, InboundLedger } from './ledger.js';
+export type NormalizedWebhookError = {
+    code?: string | number;
+    title?: string;
+    message?: string;
+    phoneNumberId?: string;
+    raw?: unknown;
+};
+export type InboundEvent = {
+    kind: 'message';
+    id: string;
+    ts: number;
+    data: InboundMessage;
+} | {
+    kind: 'status';
+    id: string;
+    ts: number;
+    data: StatusUpdate;
+} | {
+    kind: 'reaction';
+    id: string;
+    ts: number;
+    data: ReactionData;
+} | {
+    kind: 'error';
+    id: string;
+    ts: number;
+    data: NormalizedWebhookError;
+} | {
+    kind: 'signal';
+    id: string;
+    ts: number;
+    data: {
+        name: string;
+        signalId: string;
+        payload?: unknown;
+    };
+};
+export interface TurnResult {
+    parts: HarnessStreamPart[];
+    suspended?: {
+        signalId: string;
+    };
+    handoffToHuman?: boolean;
+}
+export interface TurnRunner {
+    runTurn(a: {
+        key: ConversationKey;
+        input: UserInputContent;
+        selection?: ResolvedSelection;
+        userId?: string;
+        sessionId?: string;
+        signal?: AbortSignal;
+    }): Promise<TurnResult>;
+    deliverSignal(a: {
+        key: ConversationKey;
+        signal: SignalDelivery;
+        sessionId?: string;
+        signal2?: AbortSignal;
+    }): Promise<TurnResult>;
+}
+export interface CoalesceScheduler {
+    arm(key: ConversationKey, atMs: number): Promise<void>;
+    cancel(key: ConversationKey): Promise<void>;
+}
+export interface Clock {
+    now(): number;
+}
+export interface OutboundSender {
+    send(ctx: InboundContext, result: TurnResult): Promise<void>;
+}
+export interface InboundRuntime {
+    ledger: InboundLedger;
+    window: WindowStore;
+    consent?: ConsentStore;
+    ownership?: OwnershipStore;
+    media: MediaResolver;
+    sender: OutboundSender;
+    runtime: TurnRunner;
+    scheduler: CoalesceScheduler;
+    clock: Clock;
+}
+export type InboundOutcome = {
+    kind: 'ran';
+    parts: HarnessStreamPart[];
+} | {
+    kind: 'suspended';
+    signalId: string;
+} | {
+    kind: 'buffered';
+} | {
+    kind: 'short';
+    by: string;
+    reason: 'duplicate' | 'opted-out' | 'human-owned' | 'window-closed' | 'no-input' | 'in-progress' | string;
+};
+export interface InboundContext {
+    key: ConversationKey;
+    event: InboundEvent;
+    rt: InboundRuntime;
+    input?: UserInputContent;
+    selection?: ResolvedSelection;
+    sessionId?: string;
+    userId?: string;
+    locals: Record<string, unknown>;
+}
+export type InboundNext = () => Promise<InboundOutcome>;
+export interface InboundMiddleware {
+    readonly name: string;
+    handle(ctx: InboundContext, next: InboundNext): Promise<InboundOutcome>;
+}

package/dist/inbound/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { PlatformClient, InboundMessage, StatusUpdate, SendResult, MediaPayload, MediaHandle, MediaDownload, MediaUploadOptions, MediaReference, InteractiveMessage, InteractiveAction, InteractiveReply, ContactInfo, LocationData, ReactionData, MessageContext, ConversationInfo, PricingInfo, StatusError, FormatConverter, MessageHandler, StatusHandler, ReactionHandler, MessagingRouterConfig, InboundCoalescingConfig, CoalescedInboundItem, SessionResolver, ResponseMapper, ResponseContext, ErrorContext, StreamMapperOptions, HealthCheckResult, } from './types.js';
+export type { PlatformClient, InboundMessage, StatusUpdate, SendResult, MediaPayload, MediaHandle, MediaDownload, MediaUploadOptions, MediaReference, InteractiveMessage, InteractiveAction, InteractiveReply, ContactInfo, LocationData, ReactionData, MessageContext, ConversationInfo, PricingInfo, StatusError, FormatConverter, MessageHandler, StatusHandler, ReactionHandler, MessagingRouterConfig, InboundCoalescingConfig, CoalescedInboundItem, SessionResolver, ResponseMapper, ResponseContext, ErrorContext, StreamMapperOptions, HealthCheckResult, InboundEvent, InboundRuntime, InboundOutcome, InboundMiddleware, InboundContext, TurnRunner, TurnResult, OutboundSender, CoalesceScheduler, Clock, } from './types.js';
 export { MessagingError, RateLimitError, WindowClosedError, AuthenticationError, PermissionError, RecipientError, TemplateError, MediaError, WebhookVerificationError, } from './errors.js';
 export { createMessagingRouter } from './adapter/createMessagingRouter.js';
 export { createInputCoalescer } from './adapter/input-coalescer.js';
@@ -18,7 +18,12 @@ export { redisSetSucceeded } from './adapter/redis-client.js';
 export { createRedisWindowStore } from './adapter/redis-window-store.js';
 export type { OwnershipStore, ConversationOwner } from './adapter/ownership-store.js';
 export type { ConsentStore } from './adapter/consent-store.js';
-export { MessageDeduplicator } from './shared/deduplicator.js';
+export { InMemoryInboundLedger, conversationKeyToString, eventSeq, } from './inbound/ledger.js';
+export type { ClaimResult, ConversationKey, ConvKeyStr, InboundLedger, SequencedInboundEvent, } from './inbound/ledger.js';
+export { createInboundPipeline, claimAndAppend, statusReactionErrorPhase, recordWindow, consentStop, ownershipGate, resolveAndAttachMedia, coalesceMessages, runTurn, } from './inbound/pipeline.js';
+export type { CoalescedPipelineItem } from './inbound/pipeline.js';
+export { PlatformMediaResolver, noopCoalesceScheduler, systemClock, } from './inbound/ports.js';
+export type { MediaResolver } from './inbound/ports.js';
 export { passthroughFormatter } from './shared/format-base.js';
 export type { MessageFormatter } from './shared/format-base.js';
 export { MediaCache } from './shared/media-cache.js';

package/dist/index.js

@@ -16,10 +16,12 @@ export { WindowTracker } from './adapter/window-tracker.js';
 export { InMemoryWindowStore } from './adapter/window-store.js';
 export { redisSetSucceeded } from './adapter/redis-client.js';
 export { createRedisWindowStore } from './adapter/redis-window-store.js';
+export { InMemoryInboundLedger, conversationKeyToString, eventSeq, } from './inbound/ledger.js';
+export { createInboundPipeline, claimAndAppend, statusReactionErrorPhase, recordWindow, consentStop, ownershipGate, resolveAndAttachMedia, coalesceMessages, runTurn, } from './inbound/pipeline.js';
+export { PlatformMediaResolver, noopCoalesceScheduler, systemClock, } from './inbound/ports.js';
 // ====================================
 // Shared
 // ====================================
-export { MessageDeduplicator } from './shared/deduplicator.js';
 export { passthroughFormatter } from './shared/format-base.js';
 export { MediaCache } from './shared/media-cache.js';
 export { HttpUrlStrategy, UploadStrategy, FileHashDedupStrategy, } from './shared/media-strategy.js';

package/dist/types/adapter.d.ts

@@ -14,6 +14,8 @@ import type { OutboundMiddleware } from './outbound.js';
 import type { InboundMessage, InteractiveMessage, MediaPayload } from './messages.js';
 import type { SendResult } from './responses.js';
 import type { PlatformClient, StatusHandler } from './client.js';
+import type { Clock, CoalesceScheduler } from '../inbound/types.js';
+import type { InboundLedger } from '../inbound/ledger.js';
 /**
  * Resolves an inbound message to a session identifier for the Kuralle runtime.
  */
@@ -61,6 +63,12 @@ export interface MessagingRouterConfig {
     outbound?: OutboundMiddleware[];
     /** Pluggable window store; defaults to in-memory (fail-closed on miss). */
     windowStore?: WindowStore;
+    /** Pluggable inbound ledger; defaults to in-memory (single-process/dev). */
+    ledger?: InboundLedger;
+    /** Host scheduler port; Node defaults to an in-process no-op for M-01. */
+    scheduler?: CoalesceScheduler;
+    /** Injectable clock for deterministic pipeline tests. */
+    clock?: Clock;
     /** When set, human-owned threads skip `runtime.run` on inbound (REQ-21). */
     ownership?: OwnershipStore;
     /** When set, STOP inbound opts the customer out; outbound uses `consentGate` (REQ-11). */

package/dist/types.d.ts

@@ -8,3 +8,5 @@ export type { ContactInfo, LocationData, MediaPayload, MediaReference, MediaHand
 export type { SendResult, FormatConverter } from './types/responses.js';
 export type { MessageHandler, StatusHandler, ReactionHandler, PlatformClient, HealthCheckResult, } from './types/client.js';
 export type { SessionResolver, ResponseContext, ResponseMapper, ErrorContext, MessagingRouterConfig, InboundCoalescingConfig, CoalescedInboundItem, StreamMapperOptions, } from './types/adapter.js';
+export type { InboundEvent, NormalizedWebhookError, InboundRuntime, TurnRunner, TurnResult, CoalesceScheduler, Clock, OutboundSender, InboundOutcome, InboundContext, InboundNext, InboundMiddleware, } from './inbound/types.js';
+export type { ClaimResult, ConversationKey, ConvKeyStr, InboundLedger, SequencedInboundEvent, } from './inbound/ledger.js';

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/kuralle/kuralle-agents.git",
     "directory": "packages/kuralle-messaging"
   },
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Core interfaces and Kuralle adapter for messaging platforms",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
   ],
   "dependencies": {
     "hono": "^4.7.4",
-    "@kuralle-agents/core": "0.9.0"
+    "@kuralle-agents/core": "0.11.0"
   },
   "devDependencies": {
     "typescript": "^5.8.2",

package/dist/shared/deduplicator.d.ts

@@ -1,35 +0,0 @@
-/**
- * LRU-based message deduplication to prevent processing the same
- * webhook event twice. Uses a Map (which preserves insertion order)
- * as the underlying data structure with TTL-based expiration.
- */
-export declare class MessageDeduplicator {
-    private readonly cache;
-    private readonly maxSize;
-    private readonly ttlMs;
-    /**
-     * Create a new deduplicator.
-     * @param maxSize - Maximum number of message IDs to track. Default: 10000.
-     * @param ttlMs - Time-to-live for entries in milliseconds. Default: 300000 (5 minutes).
-     */
-    constructor(maxSize?: number, ttlMs?: number);
-    /**
-     * Check if a message ID has been seen recently.
-     *
-     * If the message ID is new, it is recorded and `false` is returned.
-     * If it has been seen within the TTL window, `true` is returned.
-     * Expired entries are treated as new.
-     *
-     * @param messageId - The platform-specific message identifier.
-     * @returns `true` if this message was already processed (duplicate), `false` if new.
-     */
-    isDuplicate(messageId: string): boolean;
-    /**
-     * Remove expired entries, then evict oldest if still at capacity.
-     */
-    private evict;
-    /** Return the current number of tracked message IDs. */
-    get size(): number;
-    /** Clear all tracked message IDs. */
-    clear(): void;
-}

package/dist/shared/deduplicator.js

@@ -1,79 +0,0 @@
-/**
- * LRU-based message deduplication to prevent processing the same
- * webhook event twice. Uses a Map (which preserves insertion order)
- * as the underlying data structure with TTL-based expiration.
- */
-export class MessageDeduplicator {
-    cache;
-    maxSize;
-    ttlMs;
-    /**
-     * Create a new deduplicator.
-     * @param maxSize - Maximum number of message IDs to track. Default: 10000.
-     * @param ttlMs - Time-to-live for entries in milliseconds. Default: 300000 (5 minutes).
-     */
-    constructor(maxSize = 10_000, ttlMs = 300_000) {
-        this.cache = new Map();
-        this.maxSize = maxSize;
-        this.ttlMs = ttlMs;
-    }
-    /**
-     * Check if a message ID has been seen recently.
-     *
-     * If the message ID is new, it is recorded and `false` is returned.
-     * If it has been seen within the TTL window, `true` is returned.
-     * Expired entries are treated as new.
-     *
-     * @param messageId - The platform-specific message identifier.
-     * @returns `true` if this message was already processed (duplicate), `false` if new.
-     */
-    isDuplicate(messageId) {
-        const now = Date.now();
-        const existing = this.cache.get(messageId);
-        if (existing !== undefined) {
-            // Check if the entry has expired
-            if (now - existing < this.ttlMs) {
-                return true;
-            }
-            // Expired — delete so we can re-insert at the end
-            this.cache.delete(messageId);
-        }
-        // Evict oldest entries if at capacity
-        if (this.cache.size >= this.maxSize) {
-            this.evict(now);
-        }
-        // Record this message
-        this.cache.set(messageId, now);
-        return false;
-    }
-    /**
-     * Remove expired entries, then evict oldest if still at capacity.
-     */
-    evict(now) {
-        // First pass: remove all expired entries
-        for (const [key, timestamp] of this.cache) {
-            if (now - timestamp >= this.ttlMs) {
-                this.cache.delete(key);
-            }
-        }
-        // If still at capacity, remove oldest entries (Map iterates in insertion order)
-        if (this.cache.size >= this.maxSize) {
-            const toRemove = this.cache.size - this.maxSize + 1;
-            let removed = 0;
-            for (const key of this.cache.keys()) {
-                if (removed >= toRemove)
-                    break;
-                this.cache.delete(key);
-                removed++;
-            }
-        }
-    }
-    /** Return the current number of tracked message IDs. */
-    get size() {
-        return this.cache.size;
-    }
-    /** Clear all tracked message IDs. */
-    clear() {
-        this.cache.clear();
-    }
-}