@gaodefa/daocore 2026.5.68 → 2026.5.69

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

@@ -0,0 +1,283 @@
+import { s as ReplyPayload } from "./get-reply-options.types-BXrapyJ-.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-DOdQc8vl.js";
+import { b as OutboundDeliveryResult } from "./outbound.types-CQJou9Fo.js";
+import { n as CreateChannelReplyPipelineParams, t as ChannelReplyPipeline } from "./reply-pipeline-B9DSMJAR.js";
+import { i as OutboundDeliveryIntent, t as DeliverOutboundPayloadsParams } from "./deliver-CBROHc15.js";
+import { n as kernel_d_exports, u as deliverInboundReplyWithMessageSendContext$1 } from "./kernel-C1dSnZtC.js";
+import { a as hasVisibleChannelTurnDispatch, i as hasFinalChannelTurnDispatch, o as resolveChannelTurnDispatchCounts } from "./dispatch-result-CP3niup-.js";
+import { c as inbound_reply_dispatch_d_exports } from "./inbound-reply-dispatch-BVqoxwfH.js";
+//#region src/channels/message/capabilities.d.ts
+declare function deriveDurableFinalDeliveryRequirements(params: DeriveDurableFinalDeliveryRequirementsParams): DurableFinalDeliveryRequirementMap;
+//#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/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/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 = "cancelled_by_message_sending_hook" | "empty_after_message_sending_hook" | "no_visible_payload" | "adapter_returned_no_identity" | "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/plugin-sdk/channel-message.d.ts
+type ChannelTurnKernelModule = typeof kernel_d_exports;
+type InboundReplyDispatchModule = typeof inbound_reply_dispatch_d_exports;
+/** @deprecated Use `createChannelMessageReplyPipeline(...)` for compatibility dispatchers. */
+declare function createChannelTurnReplyPipeline(params: CreateChannelReplyPipelineParams): ChannelReplyPipeline;
+/** @deprecated Compatibility helper for legacy reply dispatch results. */
+declare const hasFinalChannelMessageReplyDispatch: typeof hasFinalChannelTurnDispatch;
+/** @deprecated Compatibility helper for legacy reply dispatch results. */
+declare const hasVisibleChannelMessageReplyDispatch: typeof hasVisibleChannelTurnDispatch;
+/** @deprecated Compatibility helper for legacy reply dispatch results. */
+declare const resolveChannelMessageReplyDispatchCounts: typeof resolveChannelTurnDispatchCounts;
+/** @deprecated Compatibility helper for legacy reply dispatch bridges. */
+declare const buildChannelMessageReplyDispatchBase: InboundReplyDispatchModule["buildChannelMessageReplyDispatchBase"];
+/**
+ * @deprecated Compatibility reply-dispatch bridge. New channel plugins should
+ * expose a `message` adapter and route sends through
+ * `deliverInboundReplyWithMessageSendContext(...)` or
+ * `sendDurableMessageBatch(...)`.
+ */
+declare const dispatchChannelMessageReplyWithBase: InboundReplyDispatchModule["dispatchChannelMessageReplyWithBase"];
+/**
+ * @deprecated Compatibility reply-dispatch bridge. New channel plugins should
+ * expose a `message` adapter and route sends through
+ * `deliverInboundReplyWithMessageSendContext(...)` or
+ * `sendDurableMessageBatch(...)`.
+ */
+declare const recordChannelMessageReplyDispatch: InboundReplyDispatchModule["recordChannelMessageReplyDispatch"];
+declare const deliverInboundReplyWithMessageSendContext: ChannelTurnKernelModule["deliverInboundReplyWithMessageSendContext"];
+/** @deprecated Use `deliverInboundReplyWithMessageSendContext`. */
+declare const deliverDurableInboundReplyPayload: typeof deliverInboundReplyWithMessageSendContext$1;
+declare function sendDurableMessageBatch(params: DurableMessageBatchSendParams): Promise<DurableMessageBatchSendResult>;
+declare function withDurableMessageSendContext<T>(params: DurableMessageSendContextParams, run: (ctx: DurableMessageSendContext) => Promise<T>): Promise<T>;
+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
+export { verifyLivePreviewFinalizerCapabilityProofs as $, ChannelMessageLiveCapabilityProof as A, LivePreviewFinalizerCapabilityProofMap as B, MessageAckState as C, createMessageReceiptFromOutboundResults as D, shouldAckMessageAfterStage as E, ChannelMessageReceiveAckPolicyProofResult as F, listDeclaredReceiveAckPolicies as G, listDeclaredChannelMessageLiveCapabilities as H, DurableFinalCapabilityProof as I, verifyChannelMessageLiveCapabilityProofs as J, verifyChannelMessageAdapterCapabilityProofs as K, DurableFinalCapabilityProofMap as L, ChannelMessageLiveCapabilityProofResult as M, ChannelMessageReceiveAckPolicyProof as N, listMessageReceiptPlatformIds as O, ChannelMessageReceiveAckPolicyProofMap as P, verifyDurableFinalCapabilityProofs as Q, DurableFinalCapabilityProofResult as R, MessageAckStage as S, createMessageReceiveContext as T, listDeclaredDurableFinalCapabilities as U, LivePreviewFinalizerCapabilityProofResult as V, listDeclaredLivePreviewFinalizerCapabilities as W, verifyChannelMessageReceiveAckPolicyAdapterProofs as X, verifyChannelMessageLiveFinalizerProofs as Y, verifyChannelMessageReceiveAckPolicyProofs as Z, DurableMessageSendState as _, deliverInboundReplyWithMessageSendContext as a, createDurableMessageStateRecord as b, hasVisibleChannelMessageReplyDispatch as c, sendDurableMessageBatch as d, ChannelMessageOutboundBridgeAdapter as et, withDurableMessageSendContext as f, DurableMessageSendContextParams as g, DurableMessageSendContext as h, deliverDurableInboundReplyPayload as i, deriveDurableFinalDeliveryRequirements as it, ChannelMessageLiveCapabilityProofMap as j, resolveMessageReceiptPrimaryId as k, recordChannelMessageReplyDispatch as l, DurableMessageBatchSendResult as m, createChannelTurnReplyPipeline as n, CreateChannelMessageAdapterFromOutboundParams as nt, dispatchChannelMessageReplyWithBase as o, DurableMessageBatchSendParams as p, verifyChannelMessageLiveCapabilityAdapterProofs as q, defineChannelMessageAdapter as r, createChannelMessageAdapterFromOutbound as rt, hasFinalChannelMessageReplyDispatch as s, buildChannelMessageReplyDispatchBase as t, ChannelMessageOutboundBridgeResult as tt, resolveChannelMessageReplyDispatchCounts as u, DurableMessageStateRecord as v, MessageReceiveContext as w, MessageAckPolicy as x, classifyDurableSendRecoveryState as y, LivePreviewFinalizerCapabilityProof as z };

package/dist/channel-pairing-4bXm_DJq.d.ts

@@ -0,0 +1,58 @@
+import { t as ChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { t as ChannelPairingAdapter } from "./pairing.types-DuI1v4kY.js";
+import { n as PluginRuntime } from "./types-Ch3J-pzD.js";
+import { n as issuePairingChallenge } from "./pairing-challenge-Bm6EgPDI.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 };

package/dist/channel-plugin-common-CDVtJ7Z-.d.ts

@@ -0,0 +1,9 @@
+import { n as ChatChannelId } from "./channel-id.types-ClK6B_QE.js";
+import { E as ChannelMeta } from "./types.core-C_KSj9hF.js";
+//#region src/channels/chat-meta-shared.d.ts
+type ChatChannelMeta = ChannelMeta;
+//#endregion
+//#region src/channels/chat-meta.d.ts
+declare function getChatChannelMeta(id: ChatChannelId): ChatChannelMeta;
+//#endregion
+export { getChatChannelMeta as t };

package/dist/channel-plugin-runtime-DTUNtOkE.d.ts

@@ -0,0 +1,7 @@
+import { n as ChannelPlugin } from "./types.public-GxxOTOdk.js";
+import { t as ResolvedMattermostAccount } from "./accounts-Deymhmce.js";
+
+//#region extensions/mattermost/src/channel.d.ts
+declare const mattermostPlugin: ChannelPlugin<ResolvedMattermostAccount>;
+//#endregion
+export { mattermostPlugin as t };

package/dist/channel-policy-FlcdLkud.d.ts

@@ -0,0 +1,198 @@
+import { r as DaoCoreConfig } from "./types.daocore-FLA7MxtO.js";
+import { _ as GroupPolicy } from "./types.base-tQh4FMBR.js";
+import { V as ChannelSecurityAdapter } from "./types.adapters-CrvmoR6f.js";
+//#region src/channels/plugins/group-policy-warnings.d.ts
+type GroupPolicyWarningCollector = (groupPolicy: GroupPolicy) => string[];
+type AccountGroupPolicyWarningCollector<ResolvedAccount> = (params: {
+  account: ResolvedAccount;
+  cfg: DaoCoreConfig;
+}) => string[];
+type ConfigGroupPolicyWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}> = (params: Params) => string[];
+type WarningCollector<Params> = (params: Params) => string[];
+declare function composeWarningCollectors<Params>(...collectors: Array<WarningCollector<Params> | null | undefined>): WarningCollector<Params>;
+declare function projectWarningCollector<Params, Projected>(project: (params: Params) => Projected, collector: WarningCollector<Projected>): WarningCollector<Params>;
+declare function projectConfigWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}>(collector: WarningCollector<{
+  cfg: DaoCoreConfig;
+}>): WarningCollector<Params>;
+declare function projectConfigAccountIdWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}>(collector: WarningCollector<{
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+}>): WarningCollector<Params>;
+declare function projectAccountWarningCollector<ResolvedAccount, Params extends {
+  account: ResolvedAccount;
+}>(collector: WarningCollector<ResolvedAccount>): WarningCollector<Params>;
+declare function projectAccountConfigWarningCollector<ResolvedAccount, ProjectedCfg, Params extends {
+  account: ResolvedAccount;
+  cfg: DaoCoreConfig;
+}>(projectCfg: (cfg: DaoCoreConfig) => ProjectedCfg, collector: WarningCollector<{
+  account: ResolvedAccount;
+  cfg: ProjectedCfg;
+}>): WarningCollector<Params>;
+declare function createConditionalWarningCollector<Params>(...collectors: Array<(params: Params) => string | string[] | null | undefined | false>): WarningCollector<Params>;
+declare function composeAccountWarningCollectors<ResolvedAccount, Params extends {
+  account: ResolvedAccount;
+}>(baseCollector: WarningCollector<Params>, ...collectors: Array<(account: ResolvedAccount) => string | string[] | null | undefined | false>): WarningCollector<Params>;
+declare function buildOpenGroupPolicyWarning(params: {
+  surface: string;
+  openBehavior: string;
+  remediation: string;
+}): string;
+declare function buildOpenGroupPolicyRestrictSendersWarning(params: {
+  surface: string;
+  openScope: string;
+  groupPolicyPath: string;
+  groupAllowFromPath: string;
+  mentionGated?: boolean;
+}): string;
+declare function buildOpenGroupPolicyNoRouteAllowlistWarning(params: {
+  surface: string;
+  routeAllowlistPath: string;
+  routeScope: string;
+  groupPolicyPath: string;
+  groupAllowFromPath: string;
+  mentionGated?: boolean;
+}): string;
+declare function buildOpenGroupPolicyConfigureRouteAllowlistWarning(params: {
+  surface: string;
+  openScope: string;
+  groupPolicyPath: string;
+  routeAllowlistPath: string;
+  mentionGated?: boolean;
+}): string;
+declare function collectOpenGroupPolicyRestrictSendersWarnings(params: Parameters<typeof buildOpenGroupPolicyRestrictSendersWarning>[0] & {
+  groupPolicy: "open" | "allowlist" | "disabled";
+}): string[];
+declare function collectAllowlistProviderRestrictSendersWarnings(params: {
+  cfg: DaoCoreConfig;
+  providerConfigPresent: boolean;
+  configuredGroupPolicy?: GroupPolicy | null;
+} & Omit<Parameters<typeof collectOpenGroupPolicyRestrictSendersWarnings>[0], "groupPolicy">): string[];
+/** Build an account-aware allowlist-provider warning collector for sender-restricted groups. */
+declare function createAllowlistProviderRestrictSendersWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+} & Omit<Parameters<typeof collectAllowlistProviderRestrictSendersWarnings>[0], "cfg" | "providerConfigPresent" | "configuredGroupPolicy">): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+/** Build a direct account-aware warning collector when the policy already lives on the account. */
+declare function createOpenGroupPolicyRestrictSendersWarningCollector<ResolvedAccount>(params: {
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  defaultGroupPolicy?: GroupPolicy;
+} & Omit<Parameters<typeof collectOpenGroupPolicyRestrictSendersWarnings>[0], "groupPolicy">): (account: ResolvedAccount) => string[];
+declare function collectAllowlistProviderGroupPolicyWarnings(params: {
+  cfg: DaoCoreConfig;
+  providerConfigPresent: boolean;
+  configuredGroupPolicy?: GroupPolicy | null;
+  collect: GroupPolicyWarningCollector;
+}): string[];
+/** Build a config-aware allowlist-provider warning collector from an arbitrary policy resolver. */
+declare function createAllowlistProviderGroupPolicyWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (params: Params) => GroupPolicy | null | undefined;
+  collect: (params: Params & {
+    groupPolicy: GroupPolicy;
+  }) => string[];
+}): ConfigGroupPolicyWarningCollector<Params>;
+declare function collectOpenProviderGroupPolicyWarnings(params: {
+  cfg: DaoCoreConfig;
+  providerConfigPresent: boolean;
+  configuredGroupPolicy?: GroupPolicy | null;
+  collect: GroupPolicyWarningCollector;
+}): string[];
+/** Build a config-aware open-provider warning collector from an arbitrary policy resolver. */
+declare function createOpenProviderGroupPolicyWarningCollector<Params extends {
+  cfg: DaoCoreConfig;
+}>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (params: Params) => GroupPolicy | null | undefined;
+  collect: (params: Params & {
+    groupPolicy: GroupPolicy;
+  }) => string[];
+}): ConfigGroupPolicyWarningCollector<Params>;
+/** Build an account-aware allowlist-provider warning collector for simple open-policy warnings. */
+declare function createAllowlistProviderOpenWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  buildOpenWarning: Parameters<typeof buildOpenGroupPolicyWarning>[0];
+}): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+declare function collectOpenGroupPolicyRouteAllowlistWarnings(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  routeAllowlistConfigured: boolean;
+  restrictSenders: Parameters<typeof buildOpenGroupPolicyRestrictSendersWarning>[0];
+  noRouteAllowlist: Parameters<typeof buildOpenGroupPolicyNoRouteAllowlistWarning>[0];
+}): string[];
+/** Build an account-aware allowlist-provider warning collector for route-allowlisted groups. */
+declare function createAllowlistProviderRouteAllowlistWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  resolveRouteAllowlistConfigured: (account: ResolvedAccount) => boolean;
+  restrictSenders: Parameters<typeof buildOpenGroupPolicyRestrictSendersWarning>[0];
+  noRouteAllowlist: Parameters<typeof buildOpenGroupPolicyNoRouteAllowlistWarning>[0];
+}): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+declare function collectOpenGroupPolicyConfiguredRouteWarnings(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  routeAllowlistConfigured: boolean;
+  configureRouteAllowlist: Parameters<typeof buildOpenGroupPolicyConfigureRouteAllowlistWarning>[0];
+  missingRouteAllowlist: Parameters<typeof buildOpenGroupPolicyWarning>[0];
+}): string[];
+/** Build an account-aware open-provider warning collector for configured-route channels. */
+declare function createOpenProviderConfiguredRouteWarningCollector<ResolvedAccount>(params: {
+  providerConfigPresent: (cfg: DaoCoreConfig) => boolean;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  resolveRouteAllowlistConfigured: (account: ResolvedAccount) => boolean;
+  configureRouteAllowlist: Parameters<typeof buildOpenGroupPolicyConfigureRouteAllowlistWarning>[0];
+  missingRouteAllowlist: Parameters<typeof buildOpenGroupPolicyWarning>[0];
+}): AccountGroupPolicyWarningCollector<ResolvedAccount>;
+//#endregion
+//#region src/plugin-sdk/channel-policy.d.ts
+declare function normalizeAllowFromList(list: Array<string | number> | undefined | null): string[];
+declare function coerceNativeSetting(value: unknown): boolean | "auto" | undefined;
+type ChannelMutableAllowlistCandidate = {
+  pathLabel: string;
+  list: unknown;
+};
+declare function createDangerousNameMatchingMutableAllowlistWarningCollector(params: {
+  channel: string;
+  detector: (entry: string) => boolean;
+  collectLists: (scope: {
+    prefix: string;
+    account: Record<string, unknown>;
+    dangerousFlagPath: string;
+  }) => ChannelMutableAllowlistCandidate[];
+}): ({
+  cfg
+}: {
+  cfg: DaoCoreConfig;
+}) => string[];
+/** Compose the common DM policy resolver with restrict-senders group warnings. */
+declare function createRestrictSendersChannelSecurity<ResolvedAccount extends {
+  accountId?: string | null;
+}>(params: {
+  channelKey: string;
+  resolveDmPolicy: (account: ResolvedAccount) => string | null | undefined;
+  resolveDmAllowFrom: (account: ResolvedAccount) => Array<string | number> | null | undefined;
+  resolveGroupPolicy: (account: ResolvedAccount) => GroupPolicy | null | undefined;
+  surface: string;
+  openScope: string;
+  groupPolicyPath: string;
+  groupAllowFromPath: string;
+  mentionGated?: boolean;
+  providerConfigPresent?: (cfg: DaoCoreConfig) => boolean;
+  resolveFallbackAccountId?: (account: ResolvedAccount) => string | null | undefined;
+  defaultDmPolicy?: string;
+  allowFromPathSuffix?: string;
+  policyPathSuffix?: string;
+  approveChannelId?: string;
+  approveHint?: string;
+  normalizeDmEntry?: (raw: string) => string;
+  inheritSharedDefaultsFromDefaultAccount?: boolean;
+}): ChannelSecurityAdapter<ResolvedAccount>;
+//#endregion
+export { createOpenProviderConfiguredRouteWarningCollector as C, projectConfigAccountIdWarningCollector as D, projectAccountWarningCollector as E, projectConfigWarningCollector as O, createOpenGroupPolicyRestrictSendersWarningCollector as S, projectAccountConfigWarningCollector as T, createAllowlistProviderGroupPolicyWarningCollector as _, normalizeAllowFromList as a, createAllowlistProviderRouteAllowlistWarningCollector as b, buildOpenGroupPolicyWarning as c, collectOpenGroupPolicyConfiguredRouteWarnings as d, collectOpenGroupPolicyRestrictSendersWarnings as f, composeWarningCollectors as g, composeAccountWarningCollectors as h, createRestrictSendersChannelSecurity as i, projectWarningCollector as k, collectAllowlistProviderGroupPolicyWarnings as l, collectOpenProviderGroupPolicyWarnings as m, coerceNativeSetting as n, buildOpenGroupPolicyConfigureRouteAllowlistWarning as o, collectOpenGroupPolicyRouteAllowlistWarnings as p, createDangerousNameMatchingMutableAllowlistWarningCollector as r, buildOpenGroupPolicyRestrictSendersWarning as s, ChannelMutableAllowlistCandidate as t, collectAllowlistProviderRestrictSendersWarnings as u, createAllowlistProviderOpenWarningCollector as v, createOpenProviderGroupPolicyWarningCollector as w, createConditionalWarningCollector as x, createAllowlistProviderRestrictSendersWarningCollector as y };

package/dist/channel-secret-basic-runtime-coCwEL7F.d.ts

@@ -0,0 +1,65 @@
+import { r as SecretDefaults, t as ResolverContext } from "./runtime-shared-B-k1pA1i.js";
+
+//#region src/secrets/channel-secret-basic-runtime.d.ts
+type ChannelAccountEntry = {
+  accountId: string;
+  account: Record<string, unknown>;
+  enabled: boolean;
+};
+type ChannelAccountSurface = {
+  hasExplicitAccounts: boolean;
+  channelEnabled: boolean;
+  accounts: ChannelAccountEntry[];
+};
+type ChannelAccountPredicate = (entry: ChannelAccountEntry) => boolean;
+declare function getChannelRecord(config: {
+  channels?: Record<string, unknown>;
+}, channelKey: string): Record<string, unknown> | undefined;
+declare function getChannelSurface(config: {
+  channels?: Record<string, unknown>;
+}, channelKey: string): {
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+} | null;
+declare function resolveChannelAccountSurface(channel: Record<string, unknown>): ChannelAccountSurface;
+declare function isBaseFieldActiveForChannelSurface(surface: ChannelAccountSurface, rootKey: string): boolean;
+declare function normalizeSecretStringValue(value: unknown): string;
+declare function hasConfiguredSecretInputValue(value: unknown, defaults: SecretDefaults | undefined): boolean;
+declare function collectSimpleChannelFieldAssignments(params: {
+  channelKey: string;
+  field: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topInactiveReason: string;
+  accountInactiveReason: string;
+}): void;
+declare function collectConditionalChannelFieldAssignments(params: {
+  channelKey: string;
+  field: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topLevelActiveWithoutAccounts: boolean;
+  topLevelInheritedAccountActive: ChannelAccountPredicate;
+  accountActive: ChannelAccountPredicate;
+  topInactiveReason: string;
+  accountInactiveReason: string | ((entry: ChannelAccountEntry) => string);
+}): void;
+declare function collectNestedChannelFieldAssignments(params: {
+  channelKey: string;
+  nestedKey: string;
+  field: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topLevelActive: boolean;
+  topInactiveReason: string;
+  accountActive: ChannelAccountPredicate;
+  accountInactiveReason: string | ((entry: ChannelAccountEntry) => string);
+}): void;
+//#endregion
+export { collectNestedChannelFieldAssignments as a, getChannelSurface as c, normalizeSecretStringValue as d, resolveChannelAccountSurface as f, collectConditionalChannelFieldAssignments as i, hasConfiguredSecretInputValue as l, ChannelAccountPredicate as n, collectSimpleChannelFieldAssignments as o, ChannelAccountSurface as r, getChannelRecord as s, ChannelAccountEntry as t, isBaseFieldActiveForChannelSurface as u };

package/dist/channel-secret-tts-runtime-feiaACJK.d.ts

@@ -0,0 +1,22 @@
+import { r as SecretDefaults, t as ResolverContext } from "./runtime-shared-B-k1pA1i.js";
+import { n as ChannelAccountPredicate, r as ChannelAccountSurface } from "./channel-secret-basic-runtime-coCwEL7F.js";
+
+//#region src/secrets/channel-secret-tts-runtime.d.ts
+declare function collectNestedChannelTtsAssignments(params: {
+  channelKey: string;
+  nestedKey: string;
+  channel: Record<string, unknown>;
+  surface: ChannelAccountSurface;
+  defaults: SecretDefaults | undefined;
+  context: ResolverContext;
+  topLevelActive: boolean;
+  topInactiveReason: string;
+  accountActive: ChannelAccountPredicate;
+  accountInactiveReason: string | ((entry: {
+    accountId: string;
+    account: Record<string, unknown>;
+    enabled: boolean;
+  }) => string);
+}): void;
+//#endregion
+export { collectNestedChannelTtsAssignments as t };