@gaodefa/daocore 2026.5.99 → 2026.5.100

package/dist/interactive-dispatch-Bp20mNVW.d.ts

@@ -0,0 +1,56 @@
+import { L as ChannelStructuredComponents } from "./types.core-tk4nkbSB.js";
+import { mt as PluginInteractiveRegistration } from "./types-DEEPn4W72.js";
+import { Jt as PluginConversationBindingRequestResult, Kt as PluginConversationBinding, qt as PluginConversationBindingRequestParams } from "./hook-types-D_9P6xki.js";
+//#region extensions/discord/src/interactive-dispatch.d.ts
+type DiscordInteractiveHandlerContext = {
+  channel: "discord";
+  accountId: string;
+  interactionId: string;
+  conversationId: string;
+  parentConversationId?: string;
+  guildId?: string;
+  senderId?: string;
+  senderUsername?: string;
+  auth: {
+    isAuthorizedSender: boolean;
+  };
+  interaction: {
+    kind: "button" | "select" | "modal";
+    data: string;
+    namespace: string;
+    payload: string;
+    messageId?: string;
+    values?: string[];
+    fields?: Array<{
+      id: string;
+      name: string;
+      values: string[];
+    }>;
+  };
+  respond: {
+    acknowledge: () => Promise<void>;
+    reply: (params: {
+      text: string;
+      ephemeral?: boolean;
+    }) => Promise<void>;
+    followUp: (params: {
+      text: string;
+      ephemeral?: boolean;
+    }) => Promise<void>;
+    editMessage: (params: {
+      text?: string;
+      components?: ChannelStructuredComponents;
+    }) => Promise<void>;
+    clearComponents: (params?: {
+      text?: string;
+    }) => Promise<void>;
+  };
+  requestConversationBinding: (params?: PluginConversationBindingRequestParams) => Promise<PluginConversationBindingRequestResult>;
+  detachConversationBinding: () => Promise<{
+    removed: boolean;
+  }>;
+  getCurrentConversationBinding: () => Promise<PluginConversationBinding | null>;
+};
+type DiscordInteractiveHandlerRegistration = PluginInteractiveRegistration<DiscordInteractiveHandlerContext, "discord">;
+//#endregion
+export { DiscordInteractiveHandlerRegistration as n, DiscordInteractiveHandlerContext as t };

package/dist/interactive-dispatch-D-tu-AnD.d.ts

@@ -0,0 +1,143 @@
+import { r as ReplyPayload } from "./reply-payload-BJ364q4f.js";
+import { mt as PluginInteractiveRegistration } from "./types-DEEPn4W72.js";
+import { Jt as PluginConversationBindingRequestResult, Kt as PluginConversationBinding, qt as PluginConversationBindingRequestParams } from "./hook-types-D_9P6xki.js";
+//#region extensions/telegram/src/model-buttons.d.ts
+type ButtonRow = Array<{
+  text: string;
+  callback_data: string;
+}>;
+type ParsedModelCallback = {
+  type: "providers";
+} | {
+  type: "list";
+  provider: string;
+  page: number;
+} | {
+  type: "select";
+  provider?: string;
+  model: string;
+} | {
+  type: "back";
+};
+type ProviderInfo = {
+  id: string;
+  count: number;
+};
+type ResolveModelSelectionResult = {
+  kind: "resolved";
+  provider: string;
+  model: string;
+} | {
+  kind: "ambiguous";
+  model: string;
+  matchingProviders: string[];
+};
+type ModelsKeyboardParams = {
+  provider: string;
+  models: readonly string[];
+  currentModel?: string;
+  currentPage: number;
+  totalPages: number;
+  pageSize?: number;
+  /** Optional map from provider/model to display name. When provided, the
+   *  display name is shown on the button instead of the raw model ID. */
+  modelNames?: ReadonlyMap<string, string>;
+};
+/**
+ * Parse a model callback_data string into a structured object.
+ * Returns null if the data doesn't match a known pattern.
+ */
+declare function parseModelCallbackData(data: string): ParsedModelCallback | null;
+declare function buildModelSelectionCallbackData(params: {
+  provider: string;
+  model: string;
+}): string | null;
+declare function resolveModelSelection(params: {
+  callback: Extract<ParsedModelCallback, {
+    type: "select";
+  }>;
+  providers: readonly string[];
+  byProvider: ReadonlyMap<string, ReadonlySet<string>>;
+}): ResolveModelSelectionResult;
+/**
+ * Build provider selection keyboard with 2 providers per row.
+ */
+declare function buildProviderKeyboard(providers: ProviderInfo[]): ButtonRow[];
+/**
+ * Build model list keyboard with pagination and back button.
+ */
+declare function buildModelsKeyboard(params: ModelsKeyboardParams): ButtonRow[];
+/**
+ * Build "Browse providers" button for /model summary.
+ */
+declare function buildBrowseProvidersButton(): ButtonRow[];
+/**
+ * Get page size for model list pagination.
+ */
+declare function getModelsPageSize(): number;
+/**
+ * Calculate total pages for a model list.
+ */
+declare function calculateTotalPages(totalModels: number, pageSize?: number): number;
+//#endregion
+//#region extensions/telegram/src/command-ui.d.ts
+declare function buildCommandsPaginationKeyboard(currentPage: number, totalPages: number, agentId?: string): Array<Array<{
+  text: string;
+  callback_data: string;
+}>>;
+declare function buildTelegramModelsProviderChannelData(params: {
+  providers: ProviderInfo[];
+}): ReplyPayload["channelData"] | null;
+//#endregion
+//#region extensions/telegram/src/interactive-dispatch.d.ts
+type TelegramInteractiveButtons = Array<Array<{
+  text: string;
+  callback_data: string;
+  style?: "danger" | "success" | "primary";
+}>>;
+type TelegramInteractiveHandlerContext = {
+  channel: "telegram";
+  accountId: string;
+  callbackId: string;
+  conversationId: string;
+  parentConversationId?: string;
+  senderId?: string;
+  senderUsername?: string;
+  threadId?: number;
+  isGroup: boolean;
+  isForum: boolean;
+  auth: {
+    isAuthorizedSender: boolean;
+  };
+  callback: {
+    data: string;
+    namespace: string;
+    payload: string;
+    messageId: number;
+    chatId: string;
+    messageText?: string;
+  };
+  respond: {
+    reply: (params: {
+      text: string;
+      buttons?: TelegramInteractiveButtons;
+    }) => Promise<void>;
+    editMessage: (params: {
+      text: string;
+      buttons?: TelegramInteractiveButtons;
+    }) => Promise<void>;
+    editButtons: (params: {
+      buttons: TelegramInteractiveButtons;
+    }) => Promise<void>;
+    clearButtons: () => Promise<void>;
+    deleteMessage: () => Promise<void>;
+  };
+  requestConversationBinding: (params?: PluginConversationBindingRequestParams) => Promise<PluginConversationBindingRequestResult>;
+  detachConversationBinding: () => Promise<{
+    removed: boolean;
+  }>;
+  getCurrentConversationBinding: () => Promise<PluginConversationBinding | null>;
+};
+type TelegramInteractiveHandlerRegistration = PluginInteractiveRegistration<TelegramInteractiveHandlerContext, "telegram">;
+//#endregion
+export { resolveModelSelection as _, ButtonRow as a, ProviderInfo as c, buildModelSelectionCallbackData as d, buildModelsKeyboard as f, parseModelCallbackData as g, getModelsPageSize as h, buildTelegramModelsProviderChannelData as i, ResolveModelSelectionResult as l, calculateTotalPages as m, TelegramInteractiveHandlerRegistration as n, ModelsKeyboardParams as o, buildProviderKeyboard as p, buildCommandsPaginationKeyboard as r, ParsedModelCallback as s, TelegramInteractiveHandlerContext as t, buildBrowseProvidersButton as u };

package/dist/interactive-nWPgHLZj.d.ts

@@ -0,0 +1,26 @@
+import { S as MessagePresentationButton, b as MessagePresentation, h as InteractiveReplyBlock, m as InteractiveReply } from "./get-reply-options.types-BXrapyJ-.js";
+import { l as ChannelPresentationCapabilities } from "./outbound.types-BgOkffIj.js";
+
+//#region src/channels/plugins/outbound/presentation-limits.d.ts
+/**
+ * Adapt a portable presentation to the target channel's advertised capabilities.
+ *
+ * Unsupported controls are downgraded to text/context fallback blocks where possible, and
+ * labels, values, rows, options, styles, disabled state, and text are clipped to channel limits.
+ */
+declare function adaptMessagePresentationForChannel(params: {
+  presentation: MessagePresentation;
+  capabilities?: ChannelPresentationCapabilities;
+}): MessagePresentation;
+/** Return the subset of buttons that can still be rendered under action limits. */
+declare function applyPresentationActionLimits(buttons: readonly MessagePresentationButton[], capabilities?: ChannelPresentationCapabilities): MessagePresentationButton[];
+/** Resolve an action page size that leaves room for reserved actions on the target channel. */
+declare function presentationPageSize(capabilities?: ChannelPresentationCapabilities, reservedActions?: number, maxPageSize?: number): number;
+//#endregion
+//#region src/channels/plugins/outbound/interactive.d.ts
+/**
+ * @deprecated Use MessagePresentation helpers for new rendering paths.
+ */
+declare function reduceInteractiveReply<TState>(interactive: InteractiveReply | undefined, initialState: TState, reduce: (state: TState, block: InteractiveReplyBlock, index: number) => TState): TState;
+//#endregion
+export { presentationPageSize as i, adaptMessagePresentationForChannel as n, applyPresentationActionLimits as r, reduceInteractiveReply as t };

package/dist/internal-hooks-C2lkjHOk.d.ts

@@ -0,0 +1,176 @@
+import { r as DaoCoreConfig } from "./types.daocore-CNMq809i.js";
+import { o as SessionEntry } from "./types-DyE5xc5O.js";
+import { t as WorkspaceBootstrapFile } from "./workspace-DY9Fuin-.js";
+import { Zt as SessionsPatchParams } from "./types-zV1f4lTR.js";
+import { t as CliDeps } from "./deps.types-C8BV1CgG.js";
+import { n as InternalHookEventType, r as InternalHookHandler, t as InternalHookEvent } from "./internal-hook-types-BwvTZGLB.js";
+
+//#region src/hooks/internal-hooks.d.ts
+type AgentBootstrapHookContext = {
+  workspaceDir: string;
+  bootstrapFiles: WorkspaceBootstrapFile[];
+  cfg?: DaoCoreConfig;
+  sessionKey?: string;
+  sessionId?: string;
+  agentId?: string;
+};
+type AgentBootstrapHookEvent = InternalHookEvent & {
+  type: "agent";
+  action: "bootstrap";
+  context: AgentBootstrapHookContext;
+};
+type GatewayStartupHookContext = {
+  cfg?: DaoCoreConfig;
+  deps?: CliDeps;
+  workspaceDir?: string;
+};
+type GatewayStartupHookEvent = InternalHookEvent & {
+  type: "gateway";
+  action: "startup";
+  context: GatewayStartupHookContext;
+};
+type MessageReceivedHookContext = {
+  /** Sender identifier (e.g., phone number, user ID) */from: string; /** Message content */
+  content: string; /** Unix timestamp when the message was received */
+  timestamp?: number; /** Channel identifier (for example "chat" or "support-chat") */
+  channelId: string; /** Provider account ID for multi-account setups */
+  accountId?: string; /** Conversation/chat ID */
+  conversationId?: string; /** Message ID from the provider */
+  messageId?: string; /** Additional provider-specific metadata */
+  metadata?: Record<string, unknown>;
+};
+type MessageReceivedHookEvent = InternalHookEvent & {
+  type: "message";
+  action: "received";
+  context: MessageReceivedHookContext;
+};
+type MessageSentHookContext = {
+  /** Recipient identifier */to: string; /** Message content */
+  content: string; /** Whether the message was sent successfully */
+  success: boolean; /** Error message if sending failed */
+  error?: string; /** Channel identifier (for example "chat" or "support-chat") */
+  channelId: string; /** Provider account ID for multi-account setups */
+  accountId?: string; /** Conversation/chat ID */
+  conversationId?: string; /** Message ID returned by the provider */
+  messageId?: string; /** Whether this message was sent in a group/channel context */
+  isGroup?: boolean; /** Group or channel identifier, if applicable */
+  groupId?: string;
+};
+type MessageSentHookEvent = InternalHookEvent & {
+  type: "message";
+  action: "sent";
+  context: MessageSentHookContext;
+};
+type MessageEnrichedBodyHookContext = {
+  /** Sender identifier (e.g., phone number, user ID) */from?: string; /** Recipient identifier */
+  to?: string; /** Original raw message body (e.g., "🎤 [Audio]") */
+  body?: string; /** Enriched body shown to the agent, including transcript */
+  bodyForAgent?: string; /** Unix timestamp when the message was received */
+  timestamp?: number; /** Channel identifier (for example "chat" or "support-chat") */
+  channelId: string; /** Conversation/chat ID */
+  conversationId?: string; /** Message ID from the provider */
+  messageId?: string; /** Sender user ID */
+  senderId?: string; /** Sender display name */
+  senderName?: string; /** Sender username */
+  senderUsername?: string; /** Provider name */
+  provider?: string; /** Surface name */
+  surface?: string; /** Path to the media file that was transcribed */
+  mediaPath?: string; /** MIME type of the media */
+  mediaType?: string;
+};
+type MessageTranscribedHookContext = MessageEnrichedBodyHookContext & {
+  /** The transcribed text from audio */transcript: string;
+};
+type MessageTranscribedHookEvent = InternalHookEvent & {
+  type: "message";
+  action: "transcribed";
+  context: MessageTranscribedHookContext;
+};
+type MessagePreprocessedHookContext = MessageEnrichedBodyHookContext & {
+  /** Transcribed audio text, if the message contained audio */transcript?: string; /** Whether this message was sent in a group/channel context */
+  isGroup?: boolean; /** Group or channel identifier, if applicable */
+  groupId?: string;
+};
+type MessagePreprocessedHookEvent = InternalHookEvent & {
+  type: "message";
+  action: "preprocessed";
+  context: MessagePreprocessedHookContext;
+};
+type SessionPatchHookContext = {
+  sessionEntry: SessionEntry;
+  patch: SessionsPatchParams;
+  cfg: DaoCoreConfig;
+};
+type SessionPatchHookEvent = InternalHookEvent & {
+  type: "session";
+  action: "patch";
+  context: SessionPatchHookContext;
+};
+/**
+ * Register a hook handler for a specific event type or event:action combination
+ *
+ * @param eventKey - Event type (e.g., 'command') or specific action (e.g., 'command:new')
+ * @param handler - Function to call when the event is triggered
+ *
+ * @example
+ * ```ts
+ * // Listen to all command events
+ * registerInternalHook('command', async (event) => {
+ *   console.log('Command:', event.action);
+ * });
+ *
+ * // Listen only to /new commands
+ * registerInternalHook('command:new', async (event) => {
+ *   await saveSessionToMemory(event);
+ * });
+ * ```
+ */
+declare function registerInternalHook(eventKey: string, handler: InternalHookHandler): void;
+/**
+ * Unregister a specific hook handler
+ *
+ * @param eventKey - Event key the handler was registered for
+ * @param handler - The handler function to remove
+ */
+declare function unregisterInternalHook(eventKey: string, handler: InternalHookHandler): void;
+/**
+ * Clear all registered hooks (useful for testing)
+ */
+declare function clearInternalHooks(): void;
+declare function setInternalHooksEnabled(enabled: boolean): void;
+/**
+ * Get all registered event keys (useful for debugging)
+ */
+declare function getRegisteredEventKeys(): string[];
+declare function hasInternalHookListeners(type: InternalHookEventType, action: string): boolean;
+/**
+ * Trigger a hook event
+ *
+ * Calls all handlers registered for:
+ * 1. The general event type (e.g., 'command')
+ * 2. The specific event:action combination (e.g., 'command:new')
+ *
+ * Handlers are called in registration order. Errors are caught and logged
+ * but don't prevent other handlers from running.
+ *
+ * @param event - The event to trigger
+ */
+declare function triggerInternalHook(event: InternalHookEvent): Promise<void>;
+/**
+ * Create a hook event with common fields filled in
+ *
+ * @param type - The event type
+ * @param action - The action within that type
+ * @param sessionKey - The session key
+ * @param context - Additional context
+ */
+declare function createInternalHookEvent(type: InternalHookEventType, action: string, sessionKey: string, context?: Record<string, unknown>): InternalHookEvent;
+declare function isAgentBootstrapEvent(event: InternalHookEvent): event is AgentBootstrapHookEvent;
+declare function isGatewayStartupEvent(event: InternalHookEvent): event is GatewayStartupHookEvent;
+declare function isMessageReceivedEvent(event: InternalHookEvent): event is MessageReceivedHookEvent;
+declare function isMessageSentEvent(event: InternalHookEvent): event is MessageSentHookEvent;
+declare function isMessageTranscribedEvent(event: InternalHookEvent): event is MessageTranscribedHookEvent;
+declare function isMessagePreprocessedEvent(event: InternalHookEvent): event is MessagePreprocessedHookEvent;
+declare function isSessionPatchEvent(event: InternalHookEvent): event is SessionPatchHookEvent;
+//#endregion
+export { isMessageSentEvent as C, setInternalHooksEnabled as D, registerInternalHook as E, triggerInternalHook as O, isMessageReceivedEvent as S, isSessionPatchEvent as T, getRegisteredEventKeys as _, MessagePreprocessedHookContext as a, isGatewayStartupEvent as b, MessageReceivedHookEvent as c, MessageTranscribedHookContext as d, MessageTranscribedHookEvent as f, createInternalHookEvent as g, clearInternalHooks as h, GatewayStartupHookEvent as i, unregisterInternalHook as k, MessageSentHookContext as l, SessionPatchHookEvent as m, AgentBootstrapHookEvent as n, MessagePreprocessedHookEvent as o, SessionPatchHookContext as p, GatewayStartupHookContext as r, MessageReceivedHookContext as s, AgentBootstrapHookContext as t, MessageSentHookEvent as u, hasInternalHookListeners as v, isMessageTranscribedEvent as w, isMessagePreprocessedEvent as x, isAgentBootstrapEvent as y };

package/dist/io-CeNW52s1.d.ts

@@ -0,0 +1,186 @@
+import { r as DaoCoreConfig, t as ConfigFileSnapshot } from "./types.daocore-CNMq809i.js";
+import { n as PluginMetadataSnapshot } from "./plugin-metadata-snapshot.types-CFcWzFfQ.js";
+import { a as RuntimeConfigWriteNotification, i as RuntimeConfigSnapshotRefreshOptions, t as ConfigWriteAfterWrite } from "./runtime-snapshot-D6bsH3Pg.js";
+import fs from "node:fs";
+import JSON5 from "json5";
+
+//#region src/config/io.d.ts
+type ParseConfigJson5Result = {
+  ok: true;
+  parsed: unknown;
+} | {
+  ok: false;
+  error: string;
+};
+type ConfigWriteResult = {
+  persistedHash: string;
+  persistedConfig: DaoCoreConfig;
+};
+type ConfigWriteOptions = {
+  /**
+   * Read-time env snapshot used to validate `${VAR}` restoration decisions.
+   * If omitted, write falls back to current process env.
+   */
+  envSnapshotForRestore?: Record<string, string | undefined>;
+  /**
+   * Optional safety check: only use envSnapshotForRestore when writing the
+   * same config file path that produced the snapshot.
+   */
+  expectedConfigPath?: string;
+  /**
+   * Paths that must be explicitly removed from the persisted file payload,
+   * even if schema/default normalization reintroduces them.
+   */
+  unsetPaths?: string[][];
+  /**
+   * Paths that were explicitly set by the caller. Values at these paths are
+   * persisted even when they equal runtime-injected defaults.
+   */
+  explicitSetPaths?: readonly (readonly string[])[];
+  /**
+   * Internal companion for explicitSetPaths after a wrapper has projected a
+   * runtime-shaped config back onto the authored source shape.
+   */
+  explicitSetValueSource?: DaoCoreConfig;
+  /**
+   * Internal fast path for callers that already hold a fresh config snapshot.
+   * Avoids rereading the full config just to prepare an immediate write.
+   */
+  baseSnapshot?: ConfigFileSnapshot;
+  /**
+   * Internal one-shot CLI fast path. When no runtime snapshot is active, skip
+   * the post-write runtime snapshot refresh/reload tail entirely.
+   */
+  skipRuntimeSnapshotRefresh?: boolean;
+  /**
+   * Optional controls for the active runtime snapshot refresh after this write.
+   */
+  runtimeRefresh?: RuntimeConfigSnapshotRefreshOptions;
+  /**
+   * Allow intentionally destructive config writes, such as explicit reset flows.
+   * Normal writers must keep this false so clobbers are rejected before disk commit.
+   */
+  allowDestructiveWrite?: boolean;
+  /**
+   * Allow an intentional large config size drop while keeping other destructive
+   * guards active. Used by repair flows that remove stale or legacy config.
+   */
+  allowConfigSizeDrop?: boolean;
+  /**
+   * Suppress human-readable output logs (overwrite/anomaly messages).
+   * Useful when the caller wants machine-readable output only (--json mode).
+   */
+  skipOutputLogs?: boolean;
+  /**
+   * Runtime reload intent for observers that react to committed config writes.
+   * Omitted means the observer should use its normal reload plan.
+   */
+  afterWrite?: ConfigWriteAfterWrite;
+  /**
+   * Legacy root keys to preserve on disk while excluding them from write validation.
+   * This is for doctor repair of historical config metadata that should not become
+   * part of the public schema contract again.
+   */
+  preservedLegacyRootKeys?: readonly string[];
+  /**
+   * Skip plugin-aware validation before writing. Use only for safe partial
+   * migrations (e.g. legacy key removal) where the base schema is valid but
+   * an unrelated plugin rule prevents the full write from succeeding.
+   */
+  skipPluginValidation?: boolean;
+  /**
+   * Preserve an older writer version for update handoff writes that must be
+   * readable by the parent process after a candidate doctor repair.
+   */
+  lastTouchedVersionOverride?: string;
+};
+type ReadConfigFileSnapshotForWriteResult = {
+  snapshot: ConfigFileSnapshot;
+  writeOptions: ConfigWriteOptions;
+};
+type ConfigWriteNotification = RuntimeConfigWriteNotification;
+type ConfigSnapshotReadMeasure = <T>(name: string, run: () => T | Promise<T>) => Promise<T>;
+declare class ConfigRuntimeRefreshError extends Error {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+declare function resolveConfigSnapshotHash(snapshot: {
+  hash?: string;
+  raw?: string | null;
+}): string | null;
+type ConfigIoDeps = {
+  fs?: typeof fs;
+  json5?: typeof JSON5;
+  env?: NodeJS.ProcessEnv;
+  homedir?: () => string;
+  configPath?: string;
+  logger?: Pick<typeof console, "error" | "warn">;
+  measure?: ConfigSnapshotReadMeasure;
+  suppressFutureVersionWarning?: boolean;
+  observe?: boolean;
+};
+type ConfigSnapshotReadOptions = {
+  measure?: ConfigSnapshotReadMeasure;
+  observe?: boolean;
+  skipPluginValidation?: boolean;
+  preservedLegacyRootKeys?: readonly string[];
+};
+declare function parseConfigJson5(raw: string, json5?: {
+  parse: (value: string) => unknown;
+}): ParseConfigJson5Result;
+type ReadConfigFileSnapshotWithPluginMetadataResult = {
+  snapshot: ConfigFileSnapshot;
+  pluginMetadataSnapshot?: PluginMetadataSnapshot;
+};
+declare function createConfigIO(overrides?: ConfigIoDeps & {
+  pluginValidation?: "full" | "skip";
+  preservedLegacyRootKeys?: readonly string[];
+}): {
+  configPath: string;
+  loadConfig: () => DaoCoreConfig;
+  readBestEffortConfig: () => Promise<DaoCoreConfig>;
+  readSourceConfigBestEffort: () => Promise<DaoCoreConfig>;
+  readConfigFileSnapshot: () => Promise<ConfigFileSnapshot>;
+  readConfigFileSnapshotWithPluginMetadata: () => Promise<ReadConfigFileSnapshotWithPluginMetadataResult>;
+  readConfigFileSnapshotForWrite: () => Promise<ReadConfigFileSnapshotForWriteResult>;
+  promoteConfigSnapshotToLastKnownGood: (snapshot: ConfigFileSnapshot) => Promise<boolean>;
+  recoverConfigFromLastKnownGood: (params: {
+    snapshot: ConfigFileSnapshot;
+    reason: string;
+  }) => Promise<boolean>;
+  recoverConfigFromJsonRootSuffix: (snapshot: ConfigFileSnapshot) => Promise<boolean>;
+  writeConfigFile: (cfg: DaoCoreConfig, options?: ConfigWriteOptions) => Promise<{
+    persistedHash: string;
+    persistedConfig: DaoCoreConfig;
+  }>;
+};
+declare function clearConfigCache(): void;
+declare function registerConfigWriteListener(listener: (event: ConfigWriteNotification) => void): () => void;
+declare function projectConfigOntoRuntimeSourceSnapshot(config: DaoCoreConfig): DaoCoreConfig;
+declare function loadConfig(options?: {
+  skipPluginValidation?: boolean;
+}): DaoCoreConfig;
+declare function getRuntimeConfig(options?: {
+  skipPluginValidation?: boolean;
+}): DaoCoreConfig;
+declare function readBestEffortConfig(): Promise<DaoCoreConfig>;
+declare function readSourceConfigBestEffort(): Promise<DaoCoreConfig>;
+declare function readConfigFileSnapshot(options?: ConfigSnapshotReadOptions): Promise<ConfigFileSnapshot>;
+declare function readConfigFileSnapshotWithPluginMetadata(options?: {
+  measure?: ConfigSnapshotReadMeasure;
+}): Promise<ReadConfigFileSnapshotWithPluginMetadataResult>;
+declare function promoteConfigSnapshotToLastKnownGood(snapshot: ConfigFileSnapshot): Promise<boolean>;
+declare function recoverConfigFromLastKnownGood(params: {
+  snapshot: ConfigFileSnapshot;
+  reason: string;
+}): Promise<boolean>;
+declare function recoverConfigFromJsonRootSuffix(snapshot: ConfigFileSnapshot): Promise<boolean>;
+declare function readSourceConfigSnapshot(): Promise<ConfigFileSnapshot>;
+declare function readConfigFileSnapshotForWrite(options?: {
+  skipPluginValidation?: boolean;
+}): Promise<ReadConfigFileSnapshotForWriteResult>;
+declare function readSourceConfigSnapshotForWrite(): Promise<ReadConfigFileSnapshotForWriteResult>;
+declare function writeConfigFile(cfg: DaoCoreConfig, options?: ConfigWriteOptions): Promise<ConfigWriteResult>;
+//#endregion
+export { registerConfigWriteListener as C, recoverConfigFromLastKnownGood as S, writeConfigFile as T, readConfigFileSnapshotWithPluginMetadata as _, ConfigWriteResult as a, readSourceConfigSnapshotForWrite as b, createConfigIO as c, parseConfigJson5 as d, projectConfigOntoRuntimeSourceSnapshot as f, readConfigFileSnapshotForWrite as g, readConfigFileSnapshot as h, ConfigWriteOptions as i, getRuntimeConfig as l, readBestEffortConfig as m, ConfigSnapshotReadOptions as n, ReadConfigFileSnapshotWithPluginMetadataResult as o, promoteConfigSnapshotToLastKnownGood as p, ConfigWriteNotification as r, clearConfigCache as s, ConfigRuntimeRefreshError as t, loadConfig as u, readSourceConfigBestEffort as v, resolveConfigSnapshotHash as w, recoverConfigFromJsonRootSuffix as x, readSourceConfigSnapshot as y };