fengming 0.3.7 → 0.3.9

package/dist/channel-inbound-iGiqx6CS.d.ts

@@ -0,0 +1,97 @@
+import { r as FengMingConfig } from "./types.fengming-NdBrgqd4.js";
+import { s as CommandNormalizeOptions } from "./commands-registry.types-BmK44BYW.js";
+import { d as InboundEventKind } from "./templating-suu09Bb-.js";
+import { n as HistoryMediaEntry } from "./history.types-D_WxL2c8.js";
+import { t as EnvelopeFormatOptions } from "./envelope-DO9ebYIy.js";
+import { n as createInboundDebouncer, t as InboundDebounceCreateParams } from "./inbound-debounce-CvRGrO4q.js";
+import { x as InboundMediaFacts, y as ConversationFacts } from "./types-DltHmoCX.js";
+import { S as filterChannelInboundSupplementalContext, h as BuiltChannelInboundEventContext, m as BuildChannelInboundEventContextParams } from "./kernel-BHnBXnm2.js";
+//#region src/channels/inbound-debounce-policy.d.ts
+declare function shouldDebounceTextInbound(params: {
+  text: string | null | undefined;
+  cfg: FengMingConfig;
+  hasMedia?: boolean;
+  commandOptions?: CommandNormalizeOptions;
+  allowDebounce?: boolean;
+}): boolean;
+declare function createChannelInboundDebouncer<T>(params: Omit<InboundDebounceCreateParams<T>, "debounceMs"> & {
+  cfg: FengMingConfig;
+  channel: string;
+  debounceMsOverride?: number;
+}): {
+  debounceMs: number;
+  debouncer: ReturnType<typeof createInboundDebouncer<T>>;
+};
+//#endregion
+//#region src/channels/session-envelope.d.ts
+declare function resolveInboundSessionEnvelopeContext(params: {
+  cfg: FengMingConfig;
+  agentId: string;
+  sessionKey: string;
+}): {
+  storePath: string;
+  envelopeOptions: EnvelopeFormatOptions;
+  previousTimestamp: number | undefined;
+};
+//#endregion
+//#region src/channels/inbound-event/classification.d.ts
+type ClassifyChannelInboundEventParams = {
+  conversation: Pick<ConversationFacts, "kind">;
+  unmentionedGroupPolicy?: InboundEventKind;
+  wasMentioned?: boolean;
+  hasControlCommand?: boolean;
+  hasAbortRequest?: boolean;
+  commandSource?: "native" | "text";
+};
+declare function classifyChannelInboundEvent(params: ClassifyChannelInboundEventParams): InboundEventKind;
+declare function resolveUnmentionedGroupInboundPolicy(params: {
+  cfg: FengMingConfig;
+  agentId?: string;
+}): InboundEventKind;
+//#endregion
+//#region src/channels/inbound-event/media.d.ts
+type ChannelInboundMediaInput = {
+  path?: string | null;
+  url?: string | null;
+  contentType?: string | null;
+  kind?: InboundMediaFacts["kind"] | null;
+  transcribed?: boolean | null;
+  messageId?: string | null;
+};
+type ChannelInboundMediaPayload = {
+  MediaPath?: string;
+  MediaUrl?: string;
+  MediaType?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+  MediaTranscribedIndexes?: number[];
+};
+declare function toInboundMediaFacts(media: readonly ChannelInboundMediaInput[] | null | undefined, defaults?: {
+  kind?: InboundMediaFacts["kind"];
+  messageId?: string;
+  transcribed?: (media: ChannelInboundMediaInput, index: number) => boolean;
+}): InboundMediaFacts[];
+declare function toHistoryMediaEntries(media: readonly ChannelInboundMediaInput[] | null | undefined, defaults?: {
+  kind?: InboundMediaFacts["kind"];
+  messageId?: string;
+}): HistoryMediaEntry[];
+declare function buildChannelInboundMediaPayload(media: readonly InboundMediaFacts[] | null | undefined): ChannelInboundMediaPayload;
+//#endregion
+//#region src/plugin-sdk/channel-inbound.d.ts
+/** @deprecated Use `BuildChannelInboundEventContextParams`. */
+type BuildChannelTurnContextParams = Omit<BuildChannelInboundEventContextParams, "message"> & {
+  message: BuildChannelInboundEventContextParams["message"] & {
+    inboundTurnKind?: InboundEventKind;
+  };
+};
+/** @deprecated Use `BuiltChannelInboundEventContext`. */
+type BuiltChannelTurnContext = BuiltChannelInboundEventContext & {
+  InboundTurnKind: InboundEventKind;
+};
+/** @deprecated Use `buildChannelInboundEventContext`. */
+declare function buildChannelTurnContext(params: BuildChannelTurnContextParams): BuiltChannelTurnContext;
+/** @deprecated Use `filterChannelInboundSupplementalContext`. */
+declare const filterChannelTurnSupplementalContext: typeof filterChannelInboundSupplementalContext;
+//#endregion
+export { ChannelInboundMediaInput as a, toHistoryMediaEntries as c, classifyChannelInboundEvent as d, resolveUnmentionedGroupInboundPolicy as f, shouldDebounceTextInbound as h, filterChannelTurnSupplementalContext as i, toInboundMediaFacts as l, createChannelInboundDebouncer as m, BuiltChannelTurnContext as n, ChannelInboundMediaPayload as o, resolveInboundSessionEnvelopeContext as p, buildChannelTurnContext as r, buildChannelInboundMediaPayload as s, BuildChannelTurnContextParams as t, ClassifyChannelInboundEventParams as u };

package/dist/channel-message-C3QPaDUk.js

@@ -0,0 +1,12 @@
+import { t as createChannelReplyPipeline } from "./reply-pipeline-4jiTFHlm.js";
+import "./inbound-reply-dispatch-vwW5Hl-_.js";
+import { t as deliverInboundReplyWithMessageSendContext } from "./channel-outbound-Bt45s9Ss.js";
+//#region src/plugin-sdk/channel-message.ts
+/** @deprecated Use `createChannelMessageReplyPipeline(...)` from `fengming/plugin-sdk/channel-outbound`. */
+function createChannelTurnReplyPipeline(params) {
+	return createChannelReplyPipeline(params);
+}
+/** @deprecated Use `deliverInboundReplyWithMessageSendContext(...)` from `fengming/plugin-sdk/channel-outbound`. */
+const deliverDurableInboundReplyPayload = deliverInboundReplyWithMessageSendContext;
+//#endregion
+export { deliverDurableInboundReplyPayload as n, createChannelTurnReplyPipeline as t };

package/dist/channel-message-CXDjxb2U.d.ts

@@ -0,0 +1,9 @@
+import { n as CreateChannelReplyPipelineParams, t as ChannelReplyPipeline } from "./reply-pipeline-DYMNI1Tf.js";
+import { f as deliverInboundReplyWithMessageSendContext } from "./kernel-BHnBXnm2.js";
+//#region src/plugin-sdk/channel-message.d.ts
+/** @deprecated Use `createChannelMessageReplyPipeline(...)` from `fengming/plugin-sdk/channel-outbound`. */
+declare function createChannelTurnReplyPipeline(params: CreateChannelReplyPipelineParams): ChannelReplyPipeline;
+/** @deprecated Use `deliverInboundReplyWithMessageSendContext(...)` from `fengming/plugin-sdk/channel-outbound`. */
+declare const deliverDurableInboundReplyPayload: typeof deliverInboundReplyWithMessageSendContext;
+//#endregion
+export { deliverDurableInboundReplyPayload as n, createChannelTurnReplyPipeline as t };

package/dist/channel-outbound-ofvvmMSK.d.ts

@@ -0,0 +1,325 @@
+import { T as ReplyToMode } from "./types.base-BqSq2llv.js";
+import { s as ReplyPayload } from "./types-CrmoEuWv.js";
+import { r as PluginStateKeyedStore } from "./plugin-state-store.types-BaJtc5SJ.js";
+import { A as LiveMessageState, C as DeriveDurableFinalDeliveryRequirementsParams, E as DurableFinalDeliveryRequirementMap, I as MessageReceiptPartKind, L as MessageReceiptSourceResult, M as LivePreviewFinalizerCapabilityMap, N as MessageDurabilityPolicy, O as DurableMessageSendIntent, P as MessageReceipt, R as MessageSendContext, _ as ChannelMessageSendPollContext, a as ChannelMessageLiveCapability, b as ChannelMessageSendTextContext, c as ChannelMessageReceiveAdapterShape, g as ChannelMessageSendPayloadContext, h as ChannelMessageSendMediaContext, i as ChannelMessageLiveAdapterShape, j as LivePreviewFinalizerCapability, n as ChannelMessageAdapterShape, s as ChannelMessageReceiveAckPolicy, t as ChannelMessageAdapter, w as DurableFinalDeliveryCapability, z as RenderedMessageBatch } from "./types-C4HgagiY.js";
+import { S as OutboundPayloadDeliverySuppressionReason, b as OutboundDeliveryResult } from "./outbound.types-DVkbsxo8.js";
+import { i as OutboundDeliveryIntent, t as DeliverOutboundPayloadsParams } from "./deliver-BnVp3VbL.js";
+import { n as kernel_d_exports } from "./kernel-BHnBXnm2.js";
+//#region src/channels/message/send.d.ts
+type DurableMessageBatchSendParams = Omit<DeliverOutboundPayloadsParams, "abortSignal" | "onDeliveryIntent" | "payloads" | "queuePolicy"> & {
+  payloads: ReplyPayload[];
+  attempt?: number;
+  signal?: AbortSignal; /** @deprecated Use `signal`. */
+  abortSignal?: AbortSignal;
+  previousReceipt?: MessageReceipt;
+};
+type DurableMessageSuppressionReason = OutboundPayloadDeliverySuppressionReason | "no_visible_result";
+type DurableMessageFailureStage = "platform_send" | "queue" | "unknown";
+type DurableMessagePayloadDeliveryOutcome = {
+  index: number;
+  status: "sent";
+  results: OutboundDeliveryResult[];
+} | {
+  index: number;
+  status: "suppressed";
+  reason: DurableMessageSuppressionReason;
+  hookEffect?: {
+    cancelReason?: string;
+    metadata?: Record<string, unknown>;
+  };
+} | {
+  index: number;
+  status: "failed";
+  error: unknown;
+  sentBeforeError: boolean;
+  stage: DurableMessageFailureStage;
+};
+type DurableMessageBatchSendResult = {
+  status: "sent";
+  results: OutboundDeliveryResult[];
+  receipt: MessageReceipt;
+  deliveryIntent?: OutboundDeliveryIntent;
+  payloadOutcomes?: DurableMessagePayloadDeliveryOutcome[];
+} | {
+  status: "suppressed";
+  results: [];
+  receipt: MessageReceipt;
+  deliveryIntent?: OutboundDeliveryIntent;
+  reason: DurableMessageSuppressionReason;
+  payloadOutcomes?: DurableMessagePayloadDeliveryOutcome[];
+} | {
+  status: "partial_failed";
+  results: OutboundDeliveryResult[];
+  receipt: MessageReceipt;
+  error: unknown;
+  sentBeforeError: true;
+  deliveryIntent?: OutboundDeliveryIntent;
+  payloadOutcomes?: DurableMessagePayloadDeliveryOutcome[];
+} | {
+  status: "failed";
+  error: unknown;
+  stage?: DurableMessageFailureStage;
+  payloadOutcomes?: DurableMessagePayloadDeliveryOutcome[];
+};
+type DurableMessageSendContextParams = DurableMessageBatchSendParams & {
+  durability?: Exclude<MessageDurabilityPolicy, "disabled">;
+  preview?: LiveMessageState<ReplyPayload>;
+  onPreviewUpdate?: (rendered: RenderedMessageBatch<ReplyPayload>, state: LiveMessageState<ReplyPayload>) => Promise<LiveMessageState<ReplyPayload>> | LiveMessageState<ReplyPayload>;
+  onEditReceipt?: (receipt: MessageReceipt, rendered: RenderedMessageBatch<ReplyPayload>) => Promise<MessageReceipt> | MessageReceipt;
+  onDeleteReceipt?: (receipt: MessageReceipt) => Promise<void> | void;
+  onCommitReceipt?: (receipt: MessageReceipt) => Promise<void> | void;
+  onSendFailure?: (error: unknown) => Promise<void> | void;
+};
+type DurableMessageSendContext = MessageSendContext<ReplyPayload, DurableMessageBatchSendResult>;
+//#endregion
+//#region src/channels/message/capabilities.d.ts
+declare function deriveDurableFinalDeliveryRequirements(params: DeriveDurableFinalDeliveryRequirementsParams): DurableFinalDeliveryRequirementMap;
+//#endregion
+//#region src/channels/message/adapter.d.ts
+declare const defaultManualReceiveAdapter: {
+  readonly defaultAckPolicy: "manual";
+  readonly supportedAckPolicies: readonly ["manual"];
+};
+type ChannelMessageAdapterWithDefaultReceive<TAdapter extends ChannelMessageAdapterShape> = TAdapter & {
+  receive: TAdapter["receive"] extends undefined ? typeof defaultManualReceiveAdapter : NonNullable<TAdapter["receive"]>;
+};
+declare function defineChannelMessageAdapter<const TAdapter extends ChannelMessageAdapterShape>(adapter: TAdapter): ChannelMessageAdapter<ChannelMessageAdapterWithDefaultReceive<TAdapter>>;
+//#endregion
+//#region src/channels/message/outbound-bridge.d.ts
+type ChannelMessageOutboundBridgeResult = MessageReceiptSourceResult & {
+  receipt?: MessageReceipt;
+  messageId?: string;
+};
+type ChannelMessageOutboundBridgeAdapter<TConfig = unknown> = {
+  deliveryCapabilities?: {
+    durableFinal?: DurableFinalDeliveryRequirementMap;
+  };
+  sendText?: (ctx: ChannelMessageSendTextContext<TConfig>) => Promise<ChannelMessageOutboundBridgeResult>;
+  sendMedia?: (ctx: ChannelMessageSendMediaContext<TConfig>) => Promise<ChannelMessageOutboundBridgeResult>;
+  sendPayload?: (ctx: ChannelMessageSendPayloadContext<TConfig>) => Promise<ChannelMessageOutboundBridgeResult>;
+  sendPoll?: (ctx: ChannelMessageSendPollContext<TConfig>) => Promise<ChannelMessageOutboundBridgeResult>;
+};
+type CreateChannelMessageAdapterFromOutboundParams<TConfig = unknown> = {
+  id?: string;
+  outbound: ChannelMessageOutboundBridgeAdapter<TConfig>;
+  capabilities?: DurableFinalDeliveryRequirementMap;
+  live?: ChannelMessageLiveAdapterShape;
+  receive?: ChannelMessageReceiveAdapterShape;
+};
+declare function createChannelMessageAdapterFromOutbound<TConfig = unknown>(params: CreateChannelMessageAdapterFromOutboundParams<TConfig>): ChannelMessageAdapterShape<TConfig>;
+//#endregion
+//#region src/channels/message/durable-receive.d.ts
+type DurableInboundReceivePendingRecord<TPayload, TMetadata = unknown> = {
+  id: string;
+  payload: TPayload;
+  metadata?: TMetadata;
+  receivedAt: number;
+  updatedAt: number;
+  attempts: number;
+  lastAttemptAt?: number;
+  lastError?: string;
+};
+type DurableInboundReceiveCompletedRecord<TMetadata = unknown> = {
+  id: string;
+  completedAt: number;
+  metadata?: TMetadata;
+};
+type DurableInboundReceiveAcceptResult<TPayload, TMetadata, TCompletedMetadata> = {
+  kind: "accepted";
+  duplicate: false;
+  record: DurableInboundReceivePendingRecord<TPayload, TMetadata>;
+} | {
+  kind: "pending";
+  duplicate: true;
+  record: DurableInboundReceivePendingRecord<TPayload, TMetadata>;
+} | {
+  kind: "completed";
+  duplicate: true;
+  record: DurableInboundReceiveCompletedRecord<TCompletedMetadata>;
+};
+type DurableInboundReceiveJournalOptions<TPayload, TMetadata, TCompletedMetadata> = {
+  pendingStore: PluginStateKeyedStore<DurableInboundReceivePendingRecord<TPayload, TMetadata>>;
+  completedStore: PluginStateKeyedStore<DurableInboundReceiveCompletedRecord<TCompletedMetadata>>;
+  now?: () => number;
+  pendingTtlMs?: number;
+  completedTtlMs?: number;
+};
+type DurableInboundReceiveAcceptOptions<TMetadata> = {
+  metadata?: TMetadata;
+  receivedAt?: number;
+};
+type DurableInboundReceiveCompleteOptions<TCompletedMetadata> = {
+  metadata?: TCompletedMetadata;
+  completedAt?: number;
+};
+type DurableInboundReceiveReleaseOptions = {
+  lastError?: string;
+  releasedAt?: number;
+};
+type DurableInboundReceiveJournal<TPayload, TMetadata, TCompletedMetadata> = {
+  accept(id: string, payload: TPayload, options?: DurableInboundReceiveAcceptOptions<TMetadata>): Promise<DurableInboundReceiveAcceptResult<TPayload, TMetadata, TCompletedMetadata>>;
+  pending(): Promise<Array<DurableInboundReceivePendingRecord<TPayload, TMetadata>>>;
+  complete(id: string, options?: DurableInboundReceiveCompleteOptions<TCompletedMetadata>): Promise<void>;
+  release(id: string, options?: DurableInboundReceiveReleaseOptions): Promise<boolean>;
+  deletePending(id: string): Promise<boolean>;
+};
+declare function createDurableInboundReceiveJournal<TPayload, TMetadata = unknown, TCompletedMetadata = unknown>(options: DurableInboundReceiveJournalOptions<TPayload, TMetadata, TCompletedMetadata>): DurableInboundReceiveJournal<TPayload, TMetadata, TCompletedMetadata>;
+//#endregion
+//#region src/channels/message/contracts.d.ts
+type DurableFinalCapabilityProof = () => Promise<void> | void;
+type DurableFinalCapabilityProofMap = Partial<Record<DurableFinalDeliveryCapability, DurableFinalCapabilityProof>>;
+type DurableFinalCapabilityProofResult = {
+  capability: DurableFinalDeliveryCapability;
+  status: "verified" | "not_declared";
+};
+type LivePreviewFinalizerCapabilityProof = () => Promise<void> | void;
+type ChannelMessageLiveCapabilityProof = () => Promise<void> | void;
+type ChannelMessageReceiveAckPolicyProof = () => Promise<void> | void;
+type LivePreviewFinalizerCapabilityProofMap = Partial<Record<LivePreviewFinalizerCapability, LivePreviewFinalizerCapabilityProof>>;
+type ChannelMessageLiveCapabilityProofMap = Partial<Record<ChannelMessageLiveCapability, ChannelMessageLiveCapabilityProof>>;
+type ChannelMessageReceiveAckPolicyProofMap = Partial<Record<ChannelMessageReceiveAckPolicy, ChannelMessageReceiveAckPolicyProof>>;
+type LivePreviewFinalizerCapabilityProofResult = {
+  capability: LivePreviewFinalizerCapability;
+  status: "verified" | "not_declared";
+};
+type ChannelMessageLiveCapabilityProofResult = {
+  capability: ChannelMessageLiveCapability;
+  status: "verified" | "not_declared";
+};
+type ChannelMessageReceiveAckPolicyProofResult = {
+  policy: ChannelMessageReceiveAckPolicy;
+  status: "verified" | "not_declared";
+};
+declare function listDeclaredDurableFinalCapabilities(capabilities: DurableFinalDeliveryRequirementMap | undefined): DurableFinalDeliveryCapability[];
+declare function listDeclaredLivePreviewFinalizerCapabilities(capabilities: LivePreviewFinalizerCapabilityMap | undefined): LivePreviewFinalizerCapability[];
+declare function listDeclaredChannelMessageLiveCapabilities(capabilities: Partial<Record<ChannelMessageLiveCapability, boolean>> | undefined): ChannelMessageLiveCapability[];
+declare function listDeclaredReceiveAckPolicies(receive: ChannelMessageAdapterShape["receive"] | undefined): ChannelMessageReceiveAckPolicy[];
+declare function verifyDurableFinalCapabilityProofs(params: {
+  adapterName: string;
+  capabilities?: DurableFinalDeliveryRequirementMap;
+  proofs: DurableFinalCapabilityProofMap;
+}): Promise<DurableFinalCapabilityProofResult[]>;
+declare function verifyLivePreviewFinalizerCapabilityProofs(params: {
+  adapterName: string;
+  capabilities?: LivePreviewFinalizerCapabilityMap;
+  proofs: LivePreviewFinalizerCapabilityProofMap;
+}): Promise<LivePreviewFinalizerCapabilityProofResult[]>;
+declare function verifyChannelMessageLiveCapabilityProofs(params: {
+  adapterName: string;
+  capabilities?: Partial<Record<ChannelMessageLiveCapability, boolean>>;
+  proofs: ChannelMessageLiveCapabilityProofMap;
+}): Promise<ChannelMessageLiveCapabilityProofResult[]>;
+declare function verifyChannelMessageReceiveAckPolicyProofs(params: {
+  adapterName: string;
+  receive?: ChannelMessageAdapterShape["receive"];
+  proofs: ChannelMessageReceiveAckPolicyProofMap;
+}): Promise<ChannelMessageReceiveAckPolicyProofResult[]>;
+declare function verifyChannelMessageAdapterCapabilityProofs(params: {
+  adapterName: string;
+  adapter: Pick<ChannelMessageAdapterShape, "durableFinal">;
+  proofs: DurableFinalCapabilityProofMap;
+}): Promise<DurableFinalCapabilityProofResult[]>;
+declare function verifyChannelMessageReceiveAckPolicyAdapterProofs(params: {
+  adapterName: string;
+  adapter: Pick<ChannelMessageAdapterShape, "receive">;
+  proofs: ChannelMessageReceiveAckPolicyProofMap;
+}): Promise<ChannelMessageReceiveAckPolicyProofResult[]>;
+declare function verifyChannelMessageLiveFinalizerProofs(params: {
+  adapterName: string;
+  adapter: Pick<ChannelMessageAdapterShape, "live">;
+  proofs: LivePreviewFinalizerCapabilityProofMap;
+}): Promise<LivePreviewFinalizerCapabilityProofResult[]>;
+declare function verifyChannelMessageLiveCapabilityAdapterProofs(params: {
+  adapterName: string;
+  adapter: Pick<ChannelMessageAdapterShape, "live">;
+  proofs: ChannelMessageLiveCapabilityProofMap;
+}): Promise<ChannelMessageLiveCapabilityProofResult[]>;
+//#endregion
+//#region src/channels/message/receipt.d.ts
+type MessageReceiptInputResult = MessageReceiptSourceResult & {
+  receipt?: MessageReceipt;
+};
+declare function createMessageReceiptFromOutboundResults(params: {
+  results: readonly MessageReceiptInputResult[];
+  kind?: MessageReceiptPartKind;
+  threadId?: string;
+  replyToId?: string;
+  sentAt?: number;
+}): MessageReceipt;
+declare function listMessageReceiptPlatformIds(receipt: MessageReceipt): string[];
+declare function resolveMessageReceiptPrimaryId(receipt: MessageReceipt): string | undefined;
+//#endregion
+//#region src/channels/message/receive.d.ts
+type MessageAckPolicy = ChannelMessageReceiveAckPolicy;
+type MessageAckStage = "receive_record" | "agent_dispatch" | "durable_send" | "manual";
+type MessageAckState = "pending" | "acked" | "nacked";
+type MessageReceiveContext<TMessage = unknown> = {
+  id: string;
+  channel: string;
+  accountId?: string;
+  message: TMessage;
+  ackPolicy: MessageAckPolicy;
+  ackState: MessageAckState;
+  ackedAt?: number;
+  nackErrorMessage?: string;
+  receivedAt: number;
+  signal: AbortSignal;
+  shouldAckAfter(stage: MessageAckStage): boolean;
+  ack(): Promise<void>;
+  nack(error: unknown): Promise<void>;
+};
+declare function shouldAckMessageAfterStage(policy: MessageAckPolicy, stage: MessageAckStage): boolean;
+declare function createMessageReceiveContext<TMessage>(params: {
+  id: string;
+  channel: string;
+  accountId?: string;
+  message: TMessage;
+  ackPolicy?: MessageAckPolicy;
+  receivedAt?: number;
+  signal?: AbortSignal;
+  onAck?: () => Promise<void> | void;
+  onNack?: (error: unknown) => Promise<void> | void;
+}): MessageReceiveContext<TMessage>;
+//#endregion
+//#region src/channels/message/state.d.ts
+type DurableMessageSendState = "pending" | "sent" | "suppressed" | "failed" | "unknown_after_send";
+type DurableMessageStateRecord = {
+  intent: DurableMessageSendIntent;
+  state: DurableMessageSendState;
+  receipt?: MessageReceipt;
+  updatedAt: number;
+  errorMessage?: string;
+};
+declare function createDurableMessageStateRecord(params: {
+  intent: DurableMessageSendIntent;
+  state?: DurableMessageSendState;
+  receipt?: MessageReceipt;
+  updatedAt?: number;
+  error?: unknown;
+}): DurableMessageStateRecord;
+declare function classifyDurableSendRecoveryState(params: {
+  hasIntent: boolean;
+  hasReceipt: boolean;
+  platformSendMayHaveStarted: boolean;
+  failed?: boolean;
+  suppressed?: boolean;
+}): DurableMessageSendState;
+//#endregion
+//#region src/infra/outbound/reply-policy.d.ts
+type ReplyToResolution = {
+  replyToId?: string;
+  source?: "explicit" | "implicit";
+};
+declare function createReplyToFanout(params: {
+  replyToId?: string | null;
+  replyToMode?: ReplyToMode;
+  replyToIdSource?: ReplyToResolution["source"];
+}): () => string | undefined;
+//#endregion
+//#region src/plugin-sdk/channel-outbound.d.ts
+type ChannelInboundKernelModule = typeof kernel_d_exports;
+declare const deliverInboundReplyWithMessageSendContext: ChannelInboundKernelModule["deliverInboundReplyWithMessageSendContext"];
+declare function sendDurableMessageBatch(params: DurableMessageSendContextParams): Promise<DurableMessageBatchSendResult>;
+declare function withDurableMessageSendContext<T>(params: DurableMessageSendContextParams, run: (ctx: DurableMessageSendContext) => Promise<T>): Promise<T>;
+//#endregion
+export { ChannelMessageOutboundBridgeResult as $, LivePreviewFinalizerCapabilityProofResult as A, verifyChannelMessageReceiveAckPolicyProofs as B, ChannelMessageReceiveAckPolicyProofMap as C, DurableFinalCapabilityProofResult as D, DurableFinalCapabilityProofMap as E, verifyChannelMessageAdapterCapabilityProofs as F, DurableInboundReceiveCompleteOptions as G, verifyLivePreviewFinalizerCapabilityProofs as H, verifyChannelMessageLiveCapabilityAdapterProofs as I, DurableInboundReceiveJournalOptions as J, DurableInboundReceiveCompletedRecord as K, verifyChannelMessageLiveCapabilityProofs as L, listDeclaredDurableFinalCapabilities as M, listDeclaredLivePreviewFinalizerCapabilities as N, LivePreviewFinalizerCapabilityProof as O, listDeclaredReceiveAckPolicies as P, ChannelMessageOutboundBridgeAdapter as Q, verifyChannelMessageLiveFinalizerProofs as R, ChannelMessageReceiveAckPolicyProof as S, DurableFinalCapabilityProof as T, DurableInboundReceiveAcceptOptions as U, verifyDurableFinalCapabilityProofs as V, DurableInboundReceiveAcceptResult as W, DurableInboundReceiveReleaseOptions as X, DurableInboundReceivePendingRecord as Y, createDurableInboundReceiveJournal as Z, listMessageReceiptPlatformIds as _, createReplyToFanout as a, DurableMessageBatchSendResult as at, ChannelMessageLiveCapabilityProofMap as b, classifyDurableSendRecoveryState as c, MessageAckStage as d, CreateChannelMessageAdapterFromOutboundParams as et, MessageAckState as f, createMessageReceiptFromOutboundResults as g, shouldAckMessageAfterStage as h, ReplyToResolution as i, DurableMessageBatchSendParams as it, listDeclaredChannelMessageLiveCapabilities as j, LivePreviewFinalizerCapabilityProofMap as k, createDurableMessageStateRecord as l, createMessageReceiveContext as m, sendDurableMessageBatch as n, defineChannelMessageAdapter as nt, DurableMessageSendState as o, DurableMessageSendContext as ot, MessageReceiveContext as p, DurableInboundReceiveJournal as q, withDurableMessageSendContext as r, deriveDurableFinalDeliveryRequirements as rt, DurableMessageStateRecord as s, DurableMessageSendContextParams as st, deliverInboundReplyWithMessageSendContext as t, createChannelMessageAdapterFromOutbound as tt, MessageAckPolicy as u, resolveMessageReceiptPrimaryId as v, ChannelMessageReceiveAckPolicyProofResult as w, ChannelMessageLiveCapabilityProofResult as x, ChannelMessageLiveCapabilityProof as y, verifyChannelMessageReceiveAckPolicyAdapterProofs as z };

package/dist/channel-pairing-DKscOV1K.d.ts

@@ -0,0 +1,58 @@
+import { Qn as PluginRuntime } from "./types-BQw1qXGl.js";
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-B0SQgllo.js";
+import { n as issuePairingChallenge } from "./pairing-challenge-BNbdSItF.js";
+
+//#region src/channels/plugins/pairing-adapters.d.ts
+type PairingNotifyParams = Parameters<NonNullable<ChannelPairingAdapter["notifyApproval"]>>[0];
+declare function createPairingPrefixStripper(prefixRe: RegExp, map?: (entry: string) => string): NonNullable<ChannelPairingAdapter["normalizeAllowEntry"]>;
+declare function createLoggedPairingApprovalNotifier(format: string | ((params: PairingNotifyParams) => string), log?: (message: string) => void): NonNullable<ChannelPairingAdapter["notifyApproval"]>;
+declare function createTextPairingAdapter(params: {
+  idLabel: string;
+  message: string;
+  normalizeAllowEntry?: ChannelPairingAdapter["normalizeAllowEntry"];
+  notify: (params: PairingNotifyParams & {
+    message: string;
+  }) => Promise<void> | void;
+}): ChannelPairingAdapter;
+//#endregion
+//#region src/plugin-sdk/pairing-access.d.ts
+type PairingApi = PluginRuntime["channel"]["pairing"];
+type ScopedUpsertInput = Omit<Parameters<PairingApi["upsertPairingRequest"]>[0], "channel" | "accountId">;
+/** Scope pairing store operations to one channel/account pair for plugin-facing helpers. */
+declare function createScopedPairingAccess(params: {
+  core: PluginRuntime;
+  channel: ChannelId;
+  accountId: string;
+}): {
+  accountId: string;
+  readAllowFromStore: () => Promise<string[]>;
+  readStoreForDmPolicy: (provider: ChannelId, accountId: string) => Promise<string[]>;
+  upsertPairingRequest: (input: ScopedUpsertInput) => Promise<{
+    code: string;
+    created: boolean;
+  }>;
+};
+//#endregion
+//#region src/plugin-sdk/channel-pairing.d.ts
+type ScopedPairingAccess = ReturnType<typeof createScopedPairingAccess>;
+/** Pairing helpers scoped to one channel account. */
+type ChannelPairingController = ScopedPairingAccess & {
+  issueChallenge: (params: Omit<Parameters<typeof issuePairingChallenge>[0], "channel" | "upsertPairingRequest">) => ReturnType<typeof issuePairingChallenge>;
+};
+/** Pre-bind the channel id and storage sink for pairing challenges. */
+declare function createChannelPairingChallengeIssuer(params: {
+  channel: ChannelId;
+  upsertPairingRequest: Parameters<typeof issuePairingChallenge>[0]["upsertPairingRequest"];
+}): (challenge: Omit<Parameters<typeof issuePairingChallenge>[0], "channel" | "upsertPairingRequest">) => Promise<{
+  created: boolean;
+  code?: string;
+}>;
+/** Build the full scoped pairing controller used by channel runtime code. */
+declare function createChannelPairingController(params: {
+  core: PluginRuntime;
+  channel: ChannelId;
+  accountId: string;
+}): ChannelPairingController;
+//#endregion
+export { createPairingPrefixStripper as a, createLoggedPairingApprovalNotifier as i, createChannelPairingChallengeIssuer as n, createTextPairingAdapter as o, createChannelPairingController as r, ChannelPairingController as t };