@gaodefa/daocore 2026.5.100 → 2026.5.101

package/dist/channel-DIxiulzS.d.ts

@@ -0,0 +1,12 @@
+import { t as BaseProbeResult } from "./types.core-Vx171EXS.js";
+import { n as ChannelPlugin } from "./types.public-XxxJRbkm.js";
+import { o as ResolvedZalouserAccount, p as ZcaUserInfo } from "./accounts-BzAN2MM-.js";
+//#region extensions/zalouser/src/probe.d.ts
+type ZalouserProbeResult = BaseProbeResult<string> & {
+  user?: ZcaUserInfo;
+};
+//#endregion
+//#region extensions/zalouser/src/channel.d.ts
+declare const zalouserPlugin: ChannelPlugin<ResolvedZalouserAccount, ZalouserProbeResult>;
+//#endregion
+export { zalouserPlugin as t };

package/dist/channel-DyA_jqoO.d.ts

@@ -0,0 +1,8 @@
+import { n as ChannelPlugin } from "./types.public-XxxJRbkm.js";
+import { s as SignalProbe$1, t as ResolvedSignalAccount } from "./accounts-DvNCYCPg.js";
+
+//#region extensions/signal/src/channel.d.ts
+type SignalProbe = SignalProbe$1;
+declare const signalPlugin: ChannelPlugin<ResolvedSignalAccount, SignalProbe>;
+//#endregion
+export { signalPlugin as t };

package/dist/channel-QmbQSGTv.d.ts

@@ -0,0 +1,8 @@
+import { n as ChannelPlugin } from "./types.public-XxxJRbkm.js";
+import { t as TelegramProbe } from "./probe-BU6uO3l2.js";
+import { t as ResolvedTelegramAccount } from "./accounts-CStJyUzX.js";
+
+//#region extensions/telegram/src/channel.d.ts
+declare const telegramPlugin: ChannelPlugin<ResolvedTelegramAccount, TelegramProbe, unknown>;
+//#endregion
+export { telegramPlugin as t };

package/dist/channel-actions-kaGtvTpB.d.ts

@@ -0,0 +1,5 @@
+import { y as ChannelMessageActionAdapter } from "./types.core-Vx171EXS.js";
+//#region extensions/discord/src/channel-actions.d.ts
+declare const discordMessageActions: ChannelMessageActionAdapter;
+//#endregion
+export { discordMessageActions as t };

package/dist/channel-config-helpers-CT_uHJja.d.ts

@@ -0,0 +1,152 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { N as ChannelSecurityDmPolicy } from "./types.core-Vx171EXS.js";
+import { G as ConfigWriteScopeLike, K as ConfigWriteTargetLike, W as ConfigWriteAuthorizationResultLike, g as ChannelConfigAdapter } from "./types.adapters-M4jFWOBw.js";
+//#region src/plugin-sdk/channel-config-helpers.d.ts
+type ConfigWriteScope = ConfigWriteScopeLike;
+type ConfigWriteTarget = ConfigWriteTargetLike;
+type ConfigWriteAuthorizationResult = ConfigWriteAuthorizationResultLike;
+type ChannelCrudConfigAdapter<ResolvedAccount> = Pick<ChannelConfigAdapter<ResolvedAccount>, "listAccountIds" | "resolveAccount" | "inspectAccount" | "defaultAccountId" | "setAccountEnabled" | "deleteAccount">;
+type ChannelConfigAdapterWithAccessors<ResolvedAccount> = Pick<ChannelConfigAdapter<ResolvedAccount>, "listAccountIds" | "resolveAccount" | "inspectAccount" | "defaultAccountId" | "setAccountEnabled" | "deleteAccount" | "resolveAllowFrom" | "formatAllowFrom" | "resolveDefaultTo">;
+declare function resolveChannelConfigWrites(params: {
+  cfg: DaoCoreConfig;
+  channelId?: string | null;
+  accountId?: string | null;
+}): boolean;
+declare function authorizeConfigWrite(params: {
+  cfg: DaoCoreConfig;
+  origin?: ConfigWriteScope;
+  target?: ConfigWriteTarget;
+  allowBypass?: boolean;
+}): ConfigWriteAuthorizationResult;
+declare function canBypassConfigWritePolicy(params: {
+  channel?: string | null;
+  gatewayClientScopes?: string[] | null;
+}): boolean;
+declare function formatConfigWriteDeniedMessage(params: {
+  result: Exclude<ConfigWriteAuthorizationResult, {
+    allowed: true;
+  }>;
+  fallbackChannelId?: string | null;
+}): string;
+type ChannelConfigAccessorParams<Config extends DaoCoreConfig = DaoCoreConfig> = {
+  cfg: Config;
+  accountId?: string | null;
+};
+type MultiAccountChannelConfigAdapterParams<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig> = {
+  sectionKey: string;
+  listAccountIds: (cfg: Config) => string[];
+  resolveAccount: (cfg: Config, accountId?: string | null) => ResolvedAccount;
+  resolveAccessorAccount?: (params: ChannelConfigAccessorParams<Config>) => AccessorAccount;
+  defaultAccountId: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config, accountId?: string | null) => unknown;
+  clearBaseFields: string[];
+  resolveAllowFrom: (account: AccessorAccount) => Array<string | number> | null | undefined;
+  formatAllowFrom: (allowFrom: Array<string | number>) => string[];
+  resolveDefaultTo?: (account: AccessorAccount) => string | number | null | undefined;
+};
+type NamedAccountChannelConfigBaseParams<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig> = {
+  sectionKey: string;
+  listAccountIds: (cfg: Config) => string[];
+  resolveAccount: (cfg: Config, accountId?: string | null) => ResolvedAccount;
+  defaultAccountId: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config, accountId?: string | null) => unknown;
+  clearBaseFields: string[];
+};
+/** Coerce mixed allowlist config values into plain strings without trimming or deduping. */
+declare function mapAllowFromEntries(allowFrom: Array<string | number> | null | undefined): string[];
+/** Normalize user-facing allowlist entries the same way config and doctor flows expect. */
+declare function formatTrimmedAllowFromEntries(allowFrom: Array<string | number>): string[];
+/** Collapse nullable config scalars into a trimmed optional string. */
+declare function resolveOptionalConfigString(value: string | number | null | undefined): string | undefined;
+/** Adapt `{ cfg, accountId }` accessors to callback sites that pass positional args. */
+declare function adaptScopedAccountAccessor<Result, Config extends DaoCoreConfig = DaoCoreConfig>(accessor: (params: {
+  cfg: Config;
+  accountId?: string | null;
+}) => Result): (cfg: Config, accountId?: string | null) => Result;
+/** Build the shared allowlist/default target adapter surface for account-scoped channel configs. */
+declare function createScopedAccountConfigAccessors<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: {
+  resolveAccount: (params: {
+    cfg: Config;
+    accountId?: string | null;
+  }) => ResolvedAccount;
+  resolveAllowFrom: (account: ResolvedAccount) => Array<string | number> | null | undefined;
+  formatAllowFrom: (allowFrom: Array<string | number>) => string[];
+  resolveDefaultTo?: (account: ResolvedAccount) => string | number | null | undefined;
+}): Pick<ChannelConfigAdapter<ResolvedAccount>, "resolveAllowFrom" | "formatAllowFrom" | "resolveDefaultTo">;
+/** Build the common CRUD/config helpers for channels that store multiple named accounts. */
+declare function createScopedChannelConfigBase<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: NamedAccountChannelConfigBaseParams<ResolvedAccount, Config> & {
+  allowTopLevel?: boolean;
+}): ChannelCrudConfigAdapter<ResolvedAccount>;
+/** Build the full shared config adapter for account-scoped channels with allowlist/default target accessors. */
+declare function createScopedChannelConfigAdapter<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: MultiAccountChannelConfigAdapterParams<ResolvedAccount, AccessorAccount, Config> & {
+  allowTopLevel?: boolean;
+}): ChannelConfigAdapterWithAccessors<ResolvedAccount>;
+/** Build CRUD/config helpers for top-level single-account channels. */
+declare function createTopLevelChannelConfigBase<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: {
+  sectionKey: string;
+  resolveAccount: (cfg: Config) => ResolvedAccount;
+  listAccountIds?: (cfg: Config) => string[];
+  defaultAccountId?: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config) => unknown;
+  deleteMode?: "remove-section" | "clear-fields";
+  clearBaseFields?: string[];
+}): Pick<ChannelConfigAdapter<ResolvedAccount>, "listAccountIds" | "resolveAccount" | "inspectAccount" | "defaultAccountId" | "setAccountEnabled" | "deleteAccount">;
+/** Build the full shared config adapter for top-level single-account channels with allowlist/default target accessors. */
+declare function createTopLevelChannelConfigAdapter<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: {
+  sectionKey: string;
+  resolveAccount: (cfg: Config) => ResolvedAccount;
+  resolveAccessorAccount?: (params: {
+    cfg: Config;
+    accountId?: string | null;
+  }) => AccessorAccount;
+  listAccountIds?: (cfg: Config) => string[];
+  defaultAccountId?: (cfg: Config) => string;
+  inspectAccount?: (cfg: Config) => unknown;
+  deleteMode?: "remove-section" | "clear-fields";
+  clearBaseFields?: string[];
+  resolveAllowFrom: (account: AccessorAccount) => Array<string | number> | null | undefined;
+  formatAllowFrom: (allowFrom: Array<string | number>) => string[];
+  resolveDefaultTo?: (account: AccessorAccount) => string | number | null | undefined;
+}): ChannelConfigAdapterWithAccessors<ResolvedAccount>;
+/** Build CRUD/config helpers for channels where the default account lives at channel root and named accounts live under `accounts`. */
+declare function createHybridChannelConfigBase<ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: NamedAccountChannelConfigBaseParams<ResolvedAccount, Config> & {
+  preserveSectionOnDefaultDelete?: boolean;
+}): ChannelCrudConfigAdapter<ResolvedAccount>;
+/** Build the full shared config adapter for hybrid channels with allowlist/default target accessors. */
+declare function createHybridChannelConfigAdapter<ResolvedAccount, AccessorAccount = ResolvedAccount, Config extends DaoCoreConfig = DaoCoreConfig>(params: MultiAccountChannelConfigAdapterParams<ResolvedAccount, AccessorAccount, Config> & {
+  preserveSectionOnDefaultDelete?: boolean;
+}): ChannelConfigAdapterWithAccessors<ResolvedAccount>;
+/** Convert account-specific DM security fields into the shared runtime policy resolver shape. */
+declare function createScopedDmSecurityResolver<ResolvedAccount extends {
+  accountId?: string | null;
+}>(params: {
+  channelKey: string;
+  resolvePolicy: (account: ResolvedAccount) => string | null | undefined;
+  resolveAllowFrom: (account: ResolvedAccount) => Array<string | number> | null | undefined;
+  resolveAccess?: (params: {
+    cfg: DaoCoreConfig;
+    accountId?: string | null;
+    account: ResolvedAccount;
+  }) => {
+    dmPolicy?: string | null;
+    allowFrom?: Array<string | number> | null;
+  };
+  resolveFallbackAccountId?: (account: ResolvedAccount) => string | null | undefined;
+  defaultPolicy?: string;
+  allowFromPathSuffix?: string;
+  policyPathSuffix?: string;
+  approveChannelId?: string;
+  approveHint?: string;
+  normalizeEntry?: (raw: string) => string;
+  inheritSharedDefaultsFromDefaultAccount?: boolean;
+}): ({
+  cfg,
+  accountId,
+  account
+}: {
+  cfg: DaoCoreConfig;
+  accountId?: string | null;
+  account: ResolvedAccount;
+}) => ChannelSecurityDmPolicy;
+//#endregion
+export { mapAllowFromEntries as _, authorizeConfigWrite as a, createHybridChannelConfigBase as c, createScopedChannelConfigBase as d, createScopedDmSecurityResolver as f, formatTrimmedAllowFromEntries as g, formatConfigWriteDeniedMessage as h, adaptScopedAccountAccessor as i, createScopedAccountConfigAccessors as l, createTopLevelChannelConfigBase as m, ConfigWriteScope as n, canBypassConfigWritePolicy as o, createTopLevelChannelConfigAdapter as p, ConfigWriteTarget as r, createHybridChannelConfigAdapter as s, ConfigWriteAuthorizationResult as t, createScopedChannelConfigAdapter as u, resolveChannelConfigWrites as v, resolveOptionalConfigString as y };

package/dist/channel-core-RyFlNEih.d.ts

@@ -0,0 +1,6 @@
+import { o as createChannelPluginBase$1 } from "./core-DpTiro-3.js";
+
+//#region src/plugin-sdk/channel-core.d.ts
+declare const createChannelPluginBase: typeof createChannelPluginBase$1;
+//#endregion
+export { createChannelPluginBase as t };

package/dist/channel-entry-contract-Clc0XDYR.d.ts

@@ -0,0 +1,112 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { n as ChannelConfigSchema } from "./types.config-CKJTcS4X.js";
+import { n as ChannelOutboundAdapter } from "./outbound.types-gEprXV1y.js";
+import { g as ChannelLegacyStateMigrationPlan } from "./types.core-Vx171EXS.js";
+import { l as DaoCorePluginApi } from "./types-DnrQyzr_2.js";
+import { n as ChannelPlugin } from "./types.public-XxxJRbkm.js";
+import { n as PluginRuntime } from "./types-FUwVViJs.js";
+import { t as PluginModuleLoaderFactory } from "./plugin-module-loader-cache-DOUa0J2M.js";
+
+//#region src/plugin-sdk/channel-entry-contract.d.ts
+type ChannelEntryConfigSchema<TPlugin> = TPlugin extends ChannelPlugin<unknown> ? NonNullable<TPlugin["configSchema"]> : ChannelConfigSchema;
+type BundledEntryModuleRef = {
+  specifier: string;
+  exportName?: string;
+};
+type DefineBundledChannelEntryOptions<TPlugin = ChannelPlugin> = {
+  id: string;
+  name: string;
+  description: string;
+  importMetaUrl: string;
+  plugin: BundledEntryModuleRef;
+  outbound?: BundledEntryModuleRef;
+  secrets?: BundledEntryModuleRef;
+  configSchema?: ChannelEntryConfigSchema<TPlugin> | (() => ChannelEntryConfigSchema<TPlugin>);
+  runtime?: BundledEntryModuleRef;
+  accountInspect?: BundledEntryModuleRef;
+  features?: BundledChannelEntryFeatures;
+  registerCliMetadata?: (api: DaoCorePluginApi) => void;
+  registerFull?: (api: DaoCorePluginApi) => void;
+};
+type DefineBundledChannelSetupEntryOptions = {
+  importMetaUrl: string;
+  plugin: BundledEntryModuleRef;
+  secrets?: BundledEntryModuleRef;
+  runtime?: BundledEntryModuleRef;
+  legacyStateMigrations?: BundledEntryModuleRef;
+  legacySessionSurface?: BundledEntryModuleRef;
+  features?: BundledChannelSetupEntryFeatures;
+};
+type BundledChannelSetupEntryFeatures = {
+  legacyStateMigrations?: boolean;
+  legacySessionSurfaces?: boolean;
+};
+type BundledChannelEntryFeatures = {
+  accountInspect?: boolean;
+};
+type BundledChannelLegacySessionSurface = {
+  isLegacyGroupSessionKey?: (key: string) => boolean;
+  canonicalizeLegacySessionKey?: (params: {
+    key: string;
+    agentId: string;
+  }) => string | null | undefined;
+};
+type BundledChannelLegacyStateMigrationDetector = (params: {
+  cfg: DaoCoreConfig;
+  env: NodeJS.ProcessEnv;
+  stateDir: string;
+  oauthDir: string;
+}) => ChannelLegacyStateMigrationPlan[] | Promise<ChannelLegacyStateMigrationPlan[] | null | undefined> | null | undefined;
+type BundledChannelEntryContract<TPlugin = ChannelPlugin> = {
+  kind: "bundled-channel-entry";
+  id: string;
+  name: string;
+  description: string;
+  configSchema: ChannelEntryConfigSchema<TPlugin>;
+  features?: BundledChannelEntryFeatures;
+  register: (api: DaoCorePluginApi) => void;
+  loadChannelPlugin: (options?: BundledEntryModuleLoadOptions) => TPlugin;
+  loadChannelOutbound?: (options?: BundledEntryModuleLoadOptions) => ChannelOutboundAdapter | undefined;
+  loadChannelSecrets?: (options?: BundledEntryModuleLoadOptions) => ChannelPlugin["secrets"] | undefined;
+  loadChannelAccountInspector?: (options?: BundledEntryModuleLoadOptions) => NonNullable<ChannelPlugin["config"]["inspectAccount"]>;
+  setChannelRuntime?: (runtime: PluginRuntime) => void;
+};
+type BundledChannelSetupEntryContract<TPlugin = ChannelPlugin> = {
+  kind: "bundled-channel-setup-entry";
+  loadSetupPlugin: (options?: BundledEntryModuleLoadOptions) => TPlugin;
+  loadSetupSecrets?: (options?: BundledEntryModuleLoadOptions) => ChannelPlugin["secrets"] | undefined;
+  loadLegacyStateMigrationDetector?: (options?: BundledEntryModuleLoadOptions) => BundledChannelLegacyStateMigrationDetector;
+  loadLegacySessionSurface?: (options?: BundledEntryModuleLoadOptions) => BundledChannelLegacySessionSurface;
+  setChannelRuntime?: (runtime: PluginRuntime) => void;
+  features?: BundledChannelSetupEntryFeatures;
+};
+type BundledEntryModuleLoadOptions = {
+  createLoaderForTest?: PluginModuleLoaderFactory;
+};
+declare function loadBundledEntryExportSync<T>(importMetaUrl: string, reference: BundledEntryModuleRef, options?: BundledEntryModuleLoadOptions): T;
+declare function defineBundledChannelEntry<TPlugin = ChannelPlugin>({
+  id,
+  name,
+  description,
+  importMetaUrl,
+  plugin,
+  outbound,
+  secrets,
+  configSchema,
+  runtime,
+  accountInspect,
+  features,
+  registerCliMetadata,
+  registerFull
+}: DefineBundledChannelEntryOptions<TPlugin>): BundledChannelEntryContract<TPlugin>;
+declare function defineBundledChannelSetupEntry<TPlugin = ChannelPlugin>({
+  importMetaUrl,
+  plugin,
+  secrets,
+  runtime,
+  legacyStateMigrations,
+  legacySessionSurface,
+  features
+}: DefineBundledChannelSetupEntryOptions): BundledChannelSetupEntryContract<TPlugin>;
+//#endregion
+export { BundledChannelSetupEntryContract as a, defineBundledChannelEntry as c, BundledChannelLegacyStateMigrationDetector as i, defineBundledChannelSetupEntry as l, BundledChannelEntryFeatures as n, BundledChannelSetupEntryFeatures as o, BundledChannelLegacySessionSurface as r, BundledEntryModuleLoadOptions as s, BundledChannelEntryContract as t, loadBundledEntryExportSync as u };

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

@@ -0,0 +1,93 @@
+import { r as DaoCoreConfig } from "./types.daocore-z1fablj2.js";
+import { n as InboundEventKind } from "./input-provenance-DgsxhTbk.js";
+import { n as HistoryMediaEntry } from "./history.types-D_WxL2c8.js";
+import { s as CommandNormalizeOptions } from "./commands-registry.types-C5jFrGjh.js";
+import { t as EnvelopeFormatOptions } from "./envelope-CNc8bNcO.js";
+import { n as createInboundDebouncer, t as InboundDebounceCreateParams } from "./inbound-debounce-BFXn-ydt.js";
+import { x as InboundMediaFacts, y as ConversationFacts } from "./types-BnHocVvD.js";
+import { i as filterChannelInboundSupplementalContext, n as BuiltChannelInboundEventContext, t as BuildChannelInboundEventContextParams } from "./context-awibxgXw.js";
+//#region src/channels/inbound-debounce-policy.d.ts
+declare function shouldDebounceTextInbound(params: {
+  text: string | null | undefined;
+  cfg: DaoCoreConfig;
+  hasMedia?: boolean;
+  commandOptions?: CommandNormalizeOptions;
+  allowDebounce?: boolean;
+}): boolean;
+declare function createChannelInboundDebouncer<T>(params: Omit<InboundDebounceCreateParams<T>, "debounceMs"> & {
+  cfg: DaoCoreConfig;
+  channel: string;
+  debounceMsOverride?: number;
+}): {
+  debounceMs: number;
+  debouncer: ReturnType<typeof createInboundDebouncer<T>>;
+};
+//#endregion
+//#region src/channels/session-envelope.d.ts
+declare function resolveInboundSessionEnvelopeContext(params: {
+  cfg: DaoCoreConfig;
+  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: DaoCoreConfig;
+  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
+type BuildChannelTurnContextParams = Omit<BuildChannelInboundEventContextParams, "message"> & {
+  message: BuildChannelInboundEventContextParams["message"] & {
+    inboundTurnKind?: InboundEventKind;
+  };
+};
+type BuiltChannelTurnContext = BuiltChannelInboundEventContext & {
+  InboundTurnKind: InboundEventKind;
+};
+declare function buildChannelTurnContext(params: BuildChannelTurnContextParams): BuiltChannelTurnContext;
+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-lifecycle-BXdiTu_h.d.ts

@@ -0,0 +1,126 @@
+import { n as RuntimeEnv } from "./runtime-Bxifh4bY.js";
+import { i as LivePreviewFinalizerResultKind, n as LivePreviewFinalizerDraft } from "./live-DS2MgTLU.js";
+
+//#region src/channels/draft-preview-finalizer.d.ts
+/**
+ * @deprecated Use `LivePreviewFinalizerDraft` from `daocore/plugin-sdk/channel-message`.
+ */
+type DraftPreviewFinalizerDraft<TId> = LivePreviewFinalizerDraft<TId>;
+/**
+ * @deprecated Use `LivePreviewFinalizerResult` from `daocore/plugin-sdk/channel-message`.
+ */
+type DraftPreviewFinalizerResult = Exclude<LivePreviewFinalizerResultKind, "preview-retained">;
+/**
+ * @deprecated Use `deliverFinalizableLivePreview` from `daocore/plugin-sdk/channel-message`.
+ */
+declare function deliverFinalizableDraftPreview<TPayload, TId, TEdit>(params: {
+  kind: "tool" | "block" | "final";
+  payload: TPayload;
+  draft?: DraftPreviewFinalizerDraft<TId>;
+  buildFinalEdit: (payload: TPayload) => TEdit | undefined;
+  editFinal: (id: TId, edit: TEdit) => Promise<void>;
+  deliverNormally: (payload: TPayload) => Promise<boolean | void>;
+  onPreviewFinalized?: (id: TId) => Promise<void> | void;
+  onNormalDelivered?: () => Promise<void> | void;
+  logPreviewEditFailure?: (error: unknown) => void;
+}): Promise<DraftPreviewFinalizerResult>;
+//#endregion
+//#region src/channels/draft-stream-loop.d.ts
+type DraftStreamLoop = {
+  update: (text: string) => void;
+  flush: () => Promise<void>;
+  stop: () => void;
+  resetPending: () => void;
+  resetThrottleWindow: () => void;
+  waitForInFlight: () => Promise<void>;
+};
+declare function createDraftStreamLoop(params: {
+  throttleMs: number;
+  isStopped: () => boolean;
+  sendOrEditStreamMessage: (text: string) => Promise<void | boolean>;
+  onBackgroundFlushError?: (err: unknown) => void;
+}): DraftStreamLoop;
+//#endregion
+//#region src/channels/draft-stream-controls.d.ts
+type FinalizableDraftStreamState = {
+  stopped: boolean;
+  final: boolean;
+};
+type StopAndClearMessageIdParams<T> = {
+  stopForClear: () => Promise<void>;
+  readMessageId: () => T | undefined;
+  clearMessageId: () => void;
+};
+type ClearFinalizableDraftMessageParams<T> = StopAndClearMessageIdParams<T> & {
+  isValidMessageId: (value: unknown) => value is T;
+  deleteMessage: (messageId: T) => Promise<void>;
+  onDeleteSuccess?: (messageId: T) => void;
+  warn?: (message: string) => void;
+  warnPrefix: string;
+};
+type FinalizableDraftLifecycleParams<T> = Omit<ClearFinalizableDraftMessageParams<T>, "stopForClear"> & {
+  throttleMs: number;
+  state: FinalizableDraftStreamState;
+  sendOrEditStreamMessage: (text: string) => Promise<boolean>;
+};
+declare function createFinalizableDraftStreamControls(params: {
+  throttleMs: number;
+  isStopped: () => boolean;
+  isFinal: () => boolean;
+  markStopped: () => void;
+  markFinal: () => void;
+  sendOrEditStreamMessage: (text: string) => Promise<boolean>;
+}): {
+  loop: DraftStreamLoop;
+  update: (text: string) => void;
+  stop: () => Promise<void>;
+  seal: () => Promise<void>;
+  discardPending: () => Promise<void>;
+  stopForClear: () => Promise<void>;
+};
+declare function createFinalizableDraftStreamControlsForState(params: {
+  throttleMs: number;
+  state: FinalizableDraftStreamState;
+  sendOrEditStreamMessage: (text: string) => Promise<boolean>;
+}): {
+  loop: DraftStreamLoop;
+  update: (text: string) => void;
+  stop: () => Promise<void>;
+  seal: () => Promise<void>;
+  discardPending: () => Promise<void>;
+  stopForClear: () => Promise<void>;
+};
+declare function takeMessageIdAfterStop<T>(params: StopAndClearMessageIdParams<T>): Promise<T | undefined>;
+declare function clearFinalizableDraftMessage<T>(params: ClearFinalizableDraftMessageParams<T>): Promise<void>;
+declare function createFinalizableDraftLifecycle<T>(params: FinalizableDraftLifecycleParams<T>): {
+  clear: () => Promise<void>;
+  loop: DraftStreamLoop;
+  update: (text: string) => void;
+  stop: () => Promise<void>;
+  seal: () => Promise<void>;
+  discardPending: () => Promise<void>;
+  stopForClear: () => Promise<void>;
+};
+//#endregion
+//#region src/channels/transport/stall-watchdog.d.ts
+type StallWatchdogTimeoutMeta = {
+  idleMs: number;
+  timeoutMs: number;
+};
+type ArmableStallWatchdog = {
+  arm: (atMs?: number) => void;
+  touch: (atMs?: number) => void;
+  disarm: () => void;
+  stop: () => void;
+  isArmed: () => boolean;
+};
+declare function createArmableStallWatchdog(params: {
+  label: string;
+  timeoutMs: number;
+  checkIntervalMs?: number;
+  abortSignal?: AbortSignal;
+  runtime?: RuntimeEnv;
+  onTimeout: (meta: StallWatchdogTimeoutMeta) => void;
+}): ArmableStallWatchdog;
+//#endregion
+export { clearFinalizableDraftMessage as a, createFinalizableDraftStreamControlsForState as c, createDraftStreamLoop as d, DraftPreviewFinalizerDraft as f, FinalizableDraftStreamState as i, takeMessageIdAfterStop as l, deliverFinalizableDraftPreview as m, StallWatchdogTimeoutMeta as n, createFinalizableDraftLifecycle as o, DraftPreviewFinalizerResult as p, createArmableStallWatchdog as r, createFinalizableDraftStreamControls as s, ArmableStallWatchdog as t, DraftStreamLoop as u };

package/dist/channel-lifecycle.core-BAA2tO7Y.d.ts

@@ -0,0 +1,79 @@
+import { r as ChannelAccountSnapshot } from "./types.core-Vx171EXS.js";
+
+//#region src/channels/run-state-machine.d.ts
+type RunStateStatusPatch = {
+  busy?: boolean;
+  activeRuns?: number;
+  lastRunActivityAt?: number | null;
+};
+type RunStateStatusSink = (patch: RunStateStatusPatch) => void;
+type RunStateMachineParams = {
+  setStatus?: RunStateStatusSink;
+  abortSignal?: AbortSignal;
+  heartbeatMs?: number;
+  now?: () => number;
+};
+declare function createRunStateMachine(params: RunStateMachineParams): {
+  isActive(): boolean;
+  onRunStart(): void;
+  onRunEnd(): void;
+  deactivate: () => void;
+};
+//#endregion
+//#region src/plugin-sdk/channel-lifecycle.core.d.ts
+type CloseAwareServer = {
+  once: (event: "close", listener: () => void) => unknown;
+};
+type PassiveAccountLifecycleParams<Handle> = {
+  abortSignal?: AbortSignal;
+  start: () => Promise<Handle>;
+  stop?: (handle: Handle) => void | Promise<void>;
+  onStop?: () => void | Promise<void>;
+};
+type ChannelRunQueueTaskContext = {
+  lifecycleSignal?: AbortSignal;
+};
+type ChannelRunQueue = {
+  enqueue: (key: string, task: (context: ChannelRunQueueTaskContext) => Promise<void>) => void;
+  deactivate: () => void;
+};
+type ChannelRunQueueParams = {
+  setStatus?: RunStateStatusSink;
+  abortSignal?: AbortSignal;
+  onError?: (error: unknown) => void;
+};
+/** Bind a fixed account id into a status writer so lifecycle code can emit partial snapshots. */
+declare function createAccountStatusSink(params: {
+  accountId: string;
+  setStatus: (next: ChannelAccountSnapshot) => void;
+}): (patch: Omit<ChannelAccountSnapshot, "accountId">) => void;
+/**
+ * Serialize channel work per key while keeping lifecycle/busy accounting out of
+ * channel-specific message handlers. The queue does not impose run timeouts;
+ * callers should rely on session/tool/runtime lifecycle for long-running work.
+ */
+declare function createChannelRunQueue(params: ChannelRunQueueParams): ChannelRunQueue;
+/**
+ * Return a promise that resolves when the signal is aborted.
+ *
+ * If no signal is provided, the promise stays pending forever. When provided,
+ * `onAbort` runs once before the promise resolves.
+ */
+declare function waitUntilAbort(signal?: AbortSignal, onAbort?: () => void | Promise<void>): Promise<void>;
+/**
+ * Keep a passive account task alive until abort, then run optional cleanup.
+ */
+declare function runPassiveAccountLifecycle<Handle>(params: PassiveAccountLifecycleParams<Handle>): Promise<void>;
+/**
+ * Keep a channel/provider task pending until the HTTP server closes.
+ *
+ * When an abort signal is provided, `onAbort` is invoked once and should
+ * trigger server shutdown. The returned promise resolves only after `close`.
+ */
+declare function keepHttpServerTaskAlive(params: {
+  server: CloseAwareServer;
+  abortSignal?: AbortSignal;
+  onAbort?: () => void | Promise<void>;
+}): Promise<void>;
+//#endregion
+export { createChannelRunQueue as a, waitUntilAbort as c, createAccountStatusSink as i, createRunStateMachine as l, ChannelRunQueueParams as n, keepHttpServerTaskAlive as o, ChannelRunQueueTaskContext as r, runPassiveAccountLifecycle as s, ChannelRunQueue as t };