@gestaltrun/dsh-im-runtime 0.0.0-stage → 0.1.5

package/lib/types/delivery-schema.d.ts

@@ -0,0 +1,176 @@
+import { z, type ZodType } from 'zod';
+import type { ImAdmissionId, ImAdmissionAnnotation, ImAdmissionAnnotationId, ImAdmissionAnnotatorId, ImAgentTaskView, ImInboundOperationResult, ImDeliveryScope, ImInboundMessageInput, ImInboundMessageView, ImMessageId, ImOutboundView, ImScopeId, ImProviderCursorCommitResult, ImProviderCursorId, ImProviderCursorOwner, ImTriggerReason } from './delivery-types.ts';
+import type { ImUploadTarget, ImUploadObservation } from './upload-types.ts';
+/** Captured platform identities; legacy observations omit the whole value. */
+export declare const imUploadIdentitySchema: z.ZodObject<{
+    senderAccountId: z.ZodNullable<z.ZodString>;
+    senderDisplayName: z.ZodNullable<z.ZodString>;
+    senderDomain: z.ZodNullable<z.ZodString>;
+    assignedAccountId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const imDeliveryScopeSchema: ZodType<ImDeliveryScope>;
+/** Parser for provider and JSONL inbound records. */
+export declare const imInboundMessageInputSchema: ZodType<ImInboundMessageInput>;
+/** Server V2 control-result fields shared by the journal and queue parsers. */
+export declare const imUploadConversationEventSchema: z.ZodObject<{
+    eventId: z.ZodString;
+    conversationKey: z.ZodString;
+    accountId: z.ZodString;
+    kind: z.ZodEnum<{
+        ai_to_human: "ai_to_human";
+        hosting_disabled: "hosting_disabled";
+        hosting_resumed: "hosting_resumed";
+    }>;
+    occurredAt: z.ZodISODateTime;
+    controlRevision: z.ZodString;
+    relatedMessageIds: z.ZodArray<z.ZodString>;
+    sourceOperationId: z.ZodString;
+    sourceKind: z.ZodLiteral<"dsh-control-result">;
+    payloadHash: z.ZodString;
+}, z.core.$strip>;
+export declare const imUploadObservationSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./upload-types.ts").ImUploadObservationId, string>>;
+    target: z.ZodObject<{
+        serverOrigin: z.ZodURL;
+        tenantId: z.ZodPipe<z.ZodString, z.ZodTransform<import("@deepseek-ai/dsh-brand").Branded<"MerchantTenantId">, string>>;
+        shopAccountId: z.ZodString;
+        traffic: z.ZodEnum<{
+            formal: "formal";
+            test: "test";
+            simulation: "simulation";
+        }>;
+        testRunId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    scope: z.ZodType<ImDeliveryScope, unknown, z.core.$ZodTypeInternals<ImDeliveryScope, unknown>>;
+    observedAt: z.ZodISODateTime;
+    identity: z.ZodOptional<z.ZodObject<{
+        senderAccountId: z.ZodNullable<z.ZodString>;
+        senderDisplayName: z.ZodNullable<z.ZodString>;
+        senderDomain: z.ZodNullable<z.ZodString>;
+        assignedAccountId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    message: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"inbound">;
+        value: z.ZodType<ImInboundMessageView, unknown, z.core.$ZodTypeInternals<ImInboundMessageView, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"outbound">;
+        value: z.ZodType<ImOutboundView, unknown, z.core.$ZodTypeInternals<ImOutboundView, unknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"conversation-event">;
+        value: z.ZodObject<{
+            eventId: z.ZodString;
+            conversationKey: z.ZodString;
+            accountId: z.ZodString;
+            kind: z.ZodEnum<{
+                ai_to_human: "ai_to_human";
+                hosting_disabled: "hosting_disabled";
+                hosting_resumed: "hosting_resumed";
+            }>;
+            occurredAt: z.ZodISODateTime;
+            controlRevision: z.ZodString;
+            relatedMessageIds: z.ZodArray<z.ZodString>;
+            sourceOperationId: z.ZodString;
+            sourceKind: z.ZodLiteral<"dsh-control-result">;
+            payloadHash: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+interface StoredDeliveryOperation {
+    readonly fingerprint: string;
+    readonly result: ImInboundOperationResult;
+}
+/** One durable record per complete conversation scope. */
+export interface ImDeliveryAggregate {
+    readonly uploadIdentities?: Readonly<Record<string, import('./upload-types.ts').ImUploadIdentity>>;
+    readonly scope: ImDeliveryScope;
+    readonly scopeId: ImScopeId;
+    readonly uploadTargets?: Readonly<Record<string, ImUploadTarget>>;
+    readonly uploadPending?: readonly ImUploadObservation[];
+    readonly uploadObservedAt?: string;
+    readonly nextMessageSequenceNumber: number;
+    readonly nextOutboundSequenceNumber: number;
+    readonly cursor: import('./delivery-types.ts').ImConversationCursor;
+    readonly presentation?: import('./delivery-types.ts').ImConversationPresentation;
+    /** Latest platform-provided direct peer identity. Older records omit it. */
+    readonly directRecipient?: import('./types.ts').ImDirectRecipient;
+    readonly messages: Readonly<Record<string, ImInboundMessageView>>;
+    readonly messageIdsByExternalId: Readonly<Record<string, ImMessageId>>;
+    readonly operations: Readonly<Record<string, StoredDeliveryOperation>>;
+    readonly outbounds: Readonly<Record<string, ImOutboundView>>;
+}
+export declare const imDeliveryAggregateSchema: ZodType<ImDeliveryAggregate>;
+/** One provider feed cursor plus queryable CAS receipts. */
+export interface ImProviderCursorAggregate {
+    readonly id: ImProviderCursorId;
+    readonly owner: ImProviderCursorOwner;
+    readonly cursor: string | null;
+    readonly updatedAt: string;
+    readonly operations: Readonly<Record<string, {
+        readonly fingerprint: string;
+        readonly result: ImProviderCursorCommitResult;
+    }>>;
+}
+/** Parser for one provider-owned feed cursor plus its CAS receipts. */
+export declare const imProviderCursorAggregateSchema: ZodType<ImProviderCursorAggregate>;
+/** Batch frozen before Agent creation or steering begins. */
+export interface ImPendingAdmission {
+    /** Analysis frozen for append/recovery; absence means it has not been attempted. */
+    readonly annotations?: readonly ImAdmissionAnnotation[];
+    /** Customer pause generation frozen before asynchronous admission work. */
+    readonly handlingEpoch?: number;
+    readonly admissionId: ImAdmissionId;
+    readonly messageIds: readonly ImMessageId[];
+    readonly triggerReasons: readonly ImTriggerReason[];
+    readonly createdAt: string;
+}
+/** Durable execution assignment for one conversation scope. */
+export interface ImExecutionAggregate extends ImAgentTaskView {
+    readonly pendingAdmission?: ImPendingAdmission;
+}
+/** Frozen analysis parse path, shared by JSON records and compatibility fixtures. */
+export declare const imAdmissionAnnotationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotationId, string>>;
+    annotatorId: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotatorId, string>>;
+    version: z.ZodString;
+    status: z.ZodLiteral<"success">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotationId, string>>;
+    annotatorId: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotatorId, string>>;
+    version: z.ZodString;
+    status: z.ZodEnum<{
+        timeout: "timeout";
+        failed: "failed";
+    }>;
+}, z.core.$strip>], "status">;
+/** Parser for the frozen batch retained until its exact Session append commits. */
+export declare const imPendingAdmissionSchema: z.ZodObject<{
+    annotations: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotationId, string>>;
+        annotatorId: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotatorId, string>>;
+        version: z.ZodString;
+        status: z.ZodLiteral<"success">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotationId, string>>;
+        annotatorId: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionAnnotatorId, string>>;
+        version: z.ZodString;
+        status: z.ZodEnum<{
+            timeout: "timeout";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>], "status">>>;
+    handlingEpoch: z.ZodOptional<z.ZodNumber>;
+    admissionId: z.ZodPipe<z.ZodString, z.ZodTransform<ImAdmissionId, string>>;
+    messageIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ImMessageId, string>>>;
+    triggerReasons: z.ZodArray<z.ZodEnum<{
+        direct: "direct";
+        mention: "mention";
+        "every-n": "every-n";
+        "fixed-interval": "fixed-interval";
+    }>>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strip>;
+/** Parser for one route-bound Agent task generation. */
+export declare const imExecutionAggregateSchema: ZodType<ImExecutionAggregate>;
+export {};

package/lib/types/delivery-sqlite.d.ts

@@ -0,0 +1,387 @@
+/** Host-owned sqlite records for IM delivery. Opens one file and reads by key. */
+import { type SqliteConnectionConfig } from './sqlite-connection.ts';
+import type { NasHostLease, SqliteJournalMode } from './nas-host-lease.ts';
+import type { ImUploadControlResult } from './upload-types.ts';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { type ImDeliveryAggregate, type ImExecutionAggregate, type ImProviderCursorAggregate } from './delivery-schema.ts';
+import type { ImAgentTaskId, ImCustomerSessionListRequest, ImCustomerSessionPage, ImCustomerListPage, ImCustomerListRequest, ImCustomerReadAckRequest, ImDeliveryScope, ImHandlingControl, ImOutboundRequestId, ImOutboundView, ImProviderCursorId, ImScopeId, ImSetHandlingControlRequest } from './delivery-types.ts';
+import type { ImAccountId, ImPlatform } from './types.ts';
+import type { ImInboundContentQuery } from './transport.ts';
+import type { ImDeliveryAccountSlice } from './placement-slice.ts';
+export declare const IM_DELIVERY_UNIT = "gestaltrun_im_delivery";
+export declare const IM_DELIVERY_UNIT_VERSION = 1;
+/** Monotonic physical layout version stored in `PRAGMA user_version`. */
+export declare const IM_DELIVERY_SCHEMA_VERSION = 4;
+/** 语句遇锁等待时长；node:sqlite 缺省为 0，任何持锁者都会让语句立即失败。NAS 交接窗口内旧实例的短暂事务通常在 2 秒内提交。 */
+export declare const DEFAULT_DELIVERY_BUSY_TIMEOUT_MS = 2000;
+/** 迁移单步遇锁重试的时间预算；超限抛 `IM_DELIVERY_SQLITE_BUSY`，由 supervisor 重启后再试，而不是无限期卡住启动。 */
+export declare const DEFAULT_DELIVERY_MIGRATION_RETRY_BUDGET_MS = 30000;
+/** Values one consumer derives from scope documents; created by `ImDeliverySqlite.projectScopes`. */
+export interface ImScopeProjection<T> {
+    /**
+     * @param id - complete conversation identity.
+     * @returns the value derived from the stored document, or absence when none is stored; parses the document only when this projection has not derived it yet.
+     */
+    get(id: ImScopeId): T | undefined;
+    /** Stop deriving and release the values. Idempotent; `get` throws afterwards. */
+    dispose(): void;
+}
+/**
+ * Durable delivery records with key lookups and small parsed-document caches.
+ * Scope descriptors and correlation identifiers derived from parsed or written documents stay in memory without a
+ * size bound, so account-wide listings and SDK matching do not re-read documents. Like the document caches, they
+ * require this connection to be the only writer.
+ * Physical unit tables stay compatible with the sqlite KV layout already on disk.
+ */
+export declare class ImDeliverySqlite {
+    private readonly lease?;
+    private readonly releaseReservation?;
+    /** Test-only: throw after this many scopes have been committed during 1→2 backfill. */
+    static injectBackfillCrashAfter: number | undefined;
+    /** Test-only: override the committed backfill batch size. */
+    static backfillBatchSize: number | undefined;
+    /** Test-only: fail the next customer-index write so putScope can prove rollback. */
+    static failNextCustomerIndexWrite: boolean;
+    /** Test-only: fail the next cursor-account index write so putCursor can prove rollback. */
+    static failNextCursorIndexWrite: boolean;
+    private readonly db;
+    private readonly scopeSelect;
+    private readonly scopeUpsert;
+    private readonly cursorSelect;
+    private readonly cursorUpsert;
+    private readonly executionSelect;
+    private readonly executionUpsert;
+    private customerUnreadRevision;
+    private readonly customerUnreads;
+    private readonly scopeCache;
+    /**
+     * Descriptor of each stored scope seen since open or the last bulk removal. A scope id hashes its
+     * descriptor (`encodeImScopeId`), so an entry stays exact while that scope is stored.
+     */
+    private readonly scopeDescriptors;
+    /** `correlationIdentifiers` of each parsed or written scope document, grouped by account; every write refreshes its entry. */
+    private readonly correlationByAccount;
+    /** Accounts whose every stored scope has a `correlationByAccount` entry; writes keep them complete until a bulk removal. */
+    private readonly correlationComplete;
+    private readonly projections;
+    private readonly executionCache;
+    private closed;
+    private readonly releaseFence;
+    private constructor();
+    /**
+     * Open or create the delivery database and ensure unit tables plus lookup indexes.
+     * @param path - sqlite file path, or `:memory:`.
+     * @param options - 日志、连接锁和页缓存设置、锁等待与重试预算及可选云端租约；所有访问检查本地期限。
+     * @returns the opened record store.
+     */
+    static open(path: string, options?: SqliteConnectionConfig & {
+        readonly journalMode?: SqliteJournalMode;
+        readonly lease?: NasHostLease;
+        readonly busyTimeoutMs?: number;
+        readonly migrationRetryBudgetMs?: number;
+    }): Promise<ImDeliverySqlite>;
+    /** @param requestId - outbox intent owning private staged bytes and SDK metadata. @returns stored JSON; the media owner validates before use. */
+    mediaPreparation(requestId: ImOutboundRequestId): unknown;
+    /** @param requestId - owning intent. @param value - media-owner validated private JSON, never included in history or Remote snapshots. */
+    saveMediaPreparation(requestId: ImOutboundRequestId, value: object): void;
+    /** @returns file intents whose external preparation started without committed metadata. */
+    unfinishedFilePreparationIds(): readonly ImOutboundRequestId[];
+    /** @param requestId - predecessor intent under retry consideration. @returns whether its external file preparation remains unconfirmed. */
+    hasUnfinishedFilePreparation(requestId: ImOutboundRequestId): boolean;
+    /**
+     * Read one conversation aggregate by scope id.
+     * @param id - complete conversation identity.
+     * @returns the stored aggregate, or absence.
+     */
+    getScope(id: ImScopeId): ImDeliveryAggregate | undefined;
+    /**
+     * Persist one conversation aggregate and refresh its lookup indexes.
+     * @param id - complete conversation identity.
+     * @param value - stored aggregate.
+     */
+    putScope(id: ImScopeId, value: ImDeliveryAggregate): Promise<void>;
+    /**
+     * Read one provider cursor by id.
+     * @param id - provider feed identity.
+     * @returns the stored cursor, or absence.
+     */
+    getCursor(id: ImProviderCursorId): ImProviderCursorAggregate | undefined;
+    /**
+     * Opaque provider cursors for one account.
+     * Stored operations stay in sqlite and are not returned.
+     * Cursor ids come from the derived account index and are ordered by id.
+     * @param accountId - cursor owner.
+     */
+    checkpointCursors(accountId: ImAccountId): readonly {
+        readonly streamId: string;
+        readonly cursor: string;
+    }[];
+    /**
+     * Durable unsubmitted input, unsettled-send and unknown-send counts for one real account.
+     * Message rows are not copied out. Reads the derived per-scope counts maintained with each scope write.
+     * @param accountId - conversation owner.
+     */
+    checkpointCounts(accountId: ImAccountId): {
+        readonly pendingCount: number;
+        readonly unknownSendCount: number;
+    };
+    /**
+     * Persist one provider cursor.
+     * @param id - provider feed identity.
+     * @param value - stored cursor.
+     */
+    putCursor(id: ImProviderCursorId, value: ImProviderCursorAggregate): Promise<void>;
+    /**
+     * Read one Agent task generation by id.
+     * @param id - durable task identity.
+     * @returns the stored generation, or absence.
+     */
+    getExecution(id: ImAgentTaskId): ImExecutionAggregate | undefined;
+    /**
+     * Persist one Agent task generation and refresh its lookup indexes.
+     * @param id - durable task identity.
+     * @param value - stored generation.
+     */
+    putExecution(id: ImAgentTaskId, value: ImExecutionAggregate): Promise<void>;
+    /**
+     * Apply one transform to a stored execution.
+     * @param id - durable task identity.
+     * @param fn - synchronous transform of the current record.
+     * @returns the stored next record.
+     */
+    updateExecution(id: ImAgentTaskId, fn: (current: ImExecutionAggregate) => ImExecutionAggregate): Promise<ImExecutionAggregate>;
+    /**
+     * List conversations that currently have pending live inbound.
+     * @returns scopes whose pendingCount is greater than zero.
+     */
+    pendingScopes(): ImDeliveryScope[];
+    /**
+     * List conversations with an interrupted platform send.
+     * @returns scope ids that currently have a dispatching outbound.
+     */
+    dispatchingScopeIds(): readonly ImScopeId[];
+    /**
+     * List conversations owned by one configured account.
+     * Membership comes from the account index; descriptors come from memory or the conversation summaries, not documents.
+     * @param accountId - durable IM account.
+     * @returns stored scopes for that account, in scope-id order.
+     */
+    scopesForAccount(accountId: ImAccountId): ImDeliveryScope[];
+    /**
+     * Read one conversation's descriptor without parsing its document.
+     * @param id - complete conversation identity.
+     * @returns the stored scope, or absence when no document is stored under `id`.
+     */
+    scopeDescriptor(id: ImScopeId): ImDeliveryScope | undefined;
+    /**
+     * Report whether one conversation holds received live inbound above its suppression watermark.
+     * Reads the pending index written with each document, which holds a scope exactly when its `cursor.pendingCount` is positive.
+     * @param id - complete conversation identity.
+     * @returns false for a scope without pending input or without a document.
+     */
+    hasPendingInbound(id: ImScopeId): boolean;
+    /** @param accountId - account owning the conversations. @param platform - admitted platform. @param uid - unqualified buyer UID. @returns matching real direct scopes using summary rows; older empty conversations use their saved direct recipient. The lookup does not populate the aggregate cache. */
+    directScopesForPeer(accountId: ImAccountId, platform: ImPlatform, uid: string): ImDeliveryScope[];
+    /** @param accountId - listener account. @param platform - admitted platform. @param request - platform message identity and optional conversation restriction. @returns matching real scopes from message rows and summaries, without parsing aggregates. */
+    inboundScopes(accountId: ImAccountId, platform: ImPlatform, request: ImInboundContentQuery): ImDeliveryScope[];
+    /**
+     * Conversations of one account whose document holds one of `identifiers` as the external message id of a live
+     * external inbound, or as the request or external message id of a sent outbound.
+     * The first call for an account parses the documents not yet parsed since open or the last bulk removal; later calls read no rows.
+     * @param accountId - durable IM account.
+     * @param identifiers - exact provider message ids or outbound request ids.
+     * @returns matching stored scopes, in scope-id order.
+     */
+    scopesWithCorrelationIdentifier(accountId: ImAccountId, identifiers: ReadonlySet<string>): ImDeliveryScope[];
+    /**
+     * Derive one value from every scope document parsed or written from now on. Each committed write refreshes the
+     * value and bulk removals clear it. A derivation failure during a write leaves that scope underived, and the next
+     * `get` derives it again and throws the failure to its caller; the committed write is unaffected.
+     * @param derive - pure function of one document; it must not keep the document.
+     * @returns accessor of the derived values.
+     */
+    projectScopes<T extends object>(derive: (value: ImDeliveryAggregate) => T): ImScopeProjection<T>;
+    /** @returns scopes with durable observations not yet transferred to the external queue. Reads the derived upload-pending index. */
+    uploadScopeIds(): readonly ImScopeId[];
+    /**
+     * Resolve the newest execution bound to one Agent Session.
+     * @param sessionId - IM Agent Session.
+     * @returns that Session's newest task, or absence.
+     */
+    executionForSession(sessionId: SessionId): ImExecutionAggregate | undefined;
+    /**
+     * Resolve the newest execution for one conversation.
+     * @param scopeId - complete conversation identity.
+     * @returns the highest-generation task, or absence.
+     */
+    latestExecutionForScope(scopeId: ImScopeId): ImExecutionAggregate | undefined;
+    /**
+     * List task generations for one conversation in generation order.
+     * @param scopeId - complete conversation identity.
+     * @returns stored generations for that scope.
+     */
+    executionsForScope(scopeId: ImScopeId): ImExecutionAggregate[];
+    /**
+     * Newest execution per conversation, resolved with one indexed join per chunk of scope ids.
+     * Ties on generation resolve to the highest task id, the same row the per-scope
+     * `ORDER BY generation DESC LIMIT 1` query returns.
+     * @param scopeIds - complete conversation identities.
+     * @returns the highest-generation task of each scope that has one.
+     */
+    latestExecutionsForScopes(scopeIds: readonly ImScopeId[]): Map<ImScopeId, ImExecutionAggregate>;
+    /**
+     * @param accountId - durable IM account.
+     * @returns ids the account index lists and the scope table stores, in scope-id order.
+     */
+    private accountScopeIds;
+    /**
+     * Fill `scopeDescriptors` for stored ids from the conversation summaries written in the same transaction as each
+     * document, one statement per chunk. Ids whose summary is absent or invalid fall back to their documents.
+     * @param ids - ids whose documents are stored.
+     */
+    private loadScopeDescriptors;
+    /** @param ids - scope ids. @returns known descriptors in the order of `ids`; unknown ids are absent. */
+    private descriptorsOf;
+    /**
+     * Stored scope documents for explicit ids, fetched with one join per chunk.
+     * Ids without a stored document are absent from the result.
+     * @param ids - complete conversation identities.
+     * @returns parsed aggregates keyed by scope id.
+     */
+    private scopeDocuments;
+    /**
+     * Generations of every listed conversation in generation order, resolved with one
+     * indexed join per chunk. Scopes never overlap chunk boundaries, so per-scope order matches `executionsForScope`.
+     * @param scopeIds - complete conversation identities.
+     * @returns per-scope stored generations keyed by scope id.
+     */
+    private executionsForScopes;
+    /**
+     * Export all durable real-conversation facts for one account, excluding simulations and derived indexes.
+     * Documents, generations, read positions and handling controls resolve in a fixed number of
+     * batched queries, not per scope.
+     * @param accountId - source account; the caller drains writers before taking a final snapshot.
+     * @returns independent account slice; it contains buyer data and must not be logged.
+     */
+    exportAccountSlice(accountId: ImAccountId): ImDeliveryAccountSlice;
+    /**
+     * Read positions of one reader batch across scopes, grouped per scope.
+     * Reader order inside each group matches the per-scope point query (reader-id order).
+     * @param scopeIds - complete conversation identities.
+     * @returns acknowledged live-inbound positions keyed by scope id.
+     */
+    private readPositionsForScopes;
+    /**
+     * Handling controls batch across scopes.
+     * @param scopeIds - complete conversation identities.
+     * @returns stored controls keyed by scope id; scopes without a control are absent.
+     */
+    private handlingControlsForScopes;
+    /**
+     * Replace one account's real facts in one transaction, preserving other accounts, simulations and maximum reader positions.
+     * @param slice - wire-validated slice authorized for the target epoch; caller owns stopped listeners, drained queues and exclusive activation. Epoch receipts belong to the handoff journal.
+     * @throws ImPlacementSliceError for identities already owned by another account; transaction failures leave the prior slice intact unless the NAS fence closes the database, in which case the caller must remain stopped and reconcile.
+     */
+    replaceAccountSlice(slice: ImDeliveryAccountSlice): void;
+    /**
+     * Record a provider actor id that belongs to one configured account.
+     * @param accountId - durable IM account.
+     * @param actorId - provider actor observed on a native-client or echo frame.
+     */
+    rememberNativeActor(accountId: ImAccountId, actorId: string): void;
+    /**
+     * Report whether one provider actor belongs to a configured account.
+     * @param accountId - durable IM account.
+     * @param actorId - provider actor id.
+     * @returns true when that actor was stored for the account.
+     */
+    isNativeActor(accountId: ImAccountId, actorId: string): boolean;
+    /**
+     * Locate the conversation that owns one outbound request.
+     * @param requestId - outbound identity.
+     * @returns that request's scope and stored outbound, or absence.
+     */
+    outboundOwner(requestId: ImOutboundRequestId): {
+        readonly scope: ImDeliveryScope;
+        readonly outbound: ImOutboundView;
+    } | undefined;
+    /**
+     * Report whether the delivery unit currently has no records.
+     * @returns true when scopes, cursors, and executions are empty.
+     */
+    empty(): boolean;
+    /**
+     * Delete every delivery record and lookup index.
+     */
+    deleteAll(): Promise<void>;
+    /** Release the sqlite connection. Idempotent. */
+    close(): void;
+    private backfillIndexes;
+    private backfillNativeActors;
+    private markLookupReady;
+    private markNativeReady;
+    private insertScopeIndexes;
+    private clearScopeIndexes;
+    private insertNativeActors;
+    private insertExecutionIndexes;
+    private clearExecutionIndexes;
+    private rememberScope;
+    /** Drop parsed scope documents and every projection derived from them after documents were removed or replaced in bulk. */
+    private forgetScopes;
+    private rememberExecution;
+    /**
+     * List customer rows for one account and source, grouped by customer key.
+     * @param request - account, real/simulation filter, optional substring, and reader.
+     */
+    listCustomers(request: ImCustomerListRequest): ImCustomerListPage;
+    /**
+     * Read customer Session references without loading unread or handling state.
+     * @param request - account, source, search and keyset cursor.
+     * @returns Session references in the same order as the full customer list.
+     */
+    listCustomerSessions(request: ImCustomerSessionListRequest): ImCustomerSessionPage;
+    private customerGroups;
+    /**
+     * Advance one reader's inbound watermark with max semantics.
+     * @param request - reader, scope, and observed arrival sequence.
+     */
+    ackCustomerRead(request: ImCustomerReadAckRequest): void;
+    /**
+     * Persist one scope's automatic-handling pause fact.
+     * @param request - scope and pause fields.
+     * @param upload - successful product operation to journal atomically; absent for safety-only pauses.
+     * @returns committed control revision. Storage failure rolls back both control and observation.
+     */
+    setHandlingControl(request: ImSetHandlingControlRequest, upload?: ImUploadControlResult): ImHandlingControl;
+    /**
+     * Read one scope's automatic-handling pause fact.
+     * @param scopeId - complete conversation identity.
+     */
+    getHandlingControl(scopeId: ImScopeId): ImHandlingControl | undefined;
+    private requireHandlingControl;
+    private customerMatches;
+    private likeMatch;
+    /**
+     * One customer's acknowledged live-inbound watermarks, batched across scopes.
+     * @param readerId - reading customer-service reader.
+     * @param scopeIds - complete conversation identities of one page.
+     * @returns acknowledged sequence per scope; scopes without an ack read as 0.
+     */
+    private readWatermarksForScopes;
+    /** Reuse per-reader counts for this delivery revision; acknowledgements invalidate their reader. */
+    private customerUnreadCounts;
+    /**
+     * Unread live-inbound counts for scopes with their per-scope watermark, one range count per
+     * scope through a values join over the message index. Scopes without unread messages are absent.
+     * @param scopeIds - every scope the counts must cover; scopes missing from `watermarks` read from 0.
+     * @param watermarks - acknowledged sequence per scope id.
+     * @returns unread count per scope id.
+     */
+    private unreadCountsForScopes;
+    private customerRow;
+    private latestExecutionRow;
+    private updateSummaryExecution;
+    private changeWatermark;
+    private assertIndexReady;
+    private assertOpen;
+}