@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/channel-runtime-builders-status.ts

@@ -0,0 +1,331 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrExtendedDiagnostics } from '../core/extended-diagnostics.ts';
+import type { RegisterTraceSummary } from '../core/register-trace.ts';
+import type {
+  BncrAccountRuntimeSnapshot,
+  buildIntegratedDiagnostics as buildIntegratedDiagnosticsFromRuntime,
+} from '../core/status.ts';
+import type {
+  BncrAckObservability,
+  BncrConnection,
+  BncrDeadLetterDiagnosticsSummary,
+  BncrDiagnosticsSummary,
+  BncrDownlinkHealthSummary,
+  BncrOutboxQueueDiagnostics,
+  BncrRoute,
+  FileSendTransferState,
+  OutboxEntry,
+} from '../core/types.ts';
+import type { BncrRuntimeFlags } from '../runtime/outbound-flags.ts';
+import type { createBncrBridgeDiagnosticsHandlersComponent } from './channel-components.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import type {
+  ConnectionQueueCounters,
+  FileAckPayload,
+  LeaseEventPayload,
+  PreparedAckHandling,
+} from './connection-handlers.ts';
+
+type DiagnosticsRuntimeStatusInput = Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0] & {
+  running: boolean | undefined;
+  channelRoot: string;
+};
+
+type DiagnosticsRuntimeStatusOverrides = {
+  running: boolean;
+  invalidOutboxSessionKeys?: number;
+  legacyAccountResidue?: number;
+};
+
+type StoredRouteRecord = { accountId: string; route: BncrRoute; updatedAt: number };
+type StoredLastSessionRecord = { sessionKey: string; scope: string; updatedAt: number };
+
+// Status/diagnostics-side wiring catalog.
+//
+// Order is intentional:
+// 1) gateway-adjacent diagnostics host surfaces
+// 2) persistence/status read-model slices
+// 3) diagnostics assembly slices
+
+export function buildBncrBridgeSurfaceHandlersRuntime(deps: {
+  bridgeId: string;
+  gatewayPid: number;
+  pushEvent: string;
+  bridgeVersion: number;
+  getApi: Parameters<typeof createBncrBridgeDiagnosticsHandlersComponent>[0]['getApi'];
+  channelId: string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  finiteNonNegativeNumberOrNull: (value: unknown) => number | null;
+  syncDebugFlag: () => Promise<void>;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  normalizeAccountId: (value: string) => string;
+  pluginRoot: string;
+  buildAccountQueueCounters: (accountId: string) => ConnectionQueueCounters;
+  buildExtendedDiagnostics: (
+    accountId: string,
+    args?: Record<string, unknown>,
+  ) => BncrExtendedDiagnostics;
+  buildRuntimeFlags: (accountId: string) => BncrRuntimeFlags;
+  buildRuntimeStatusInput: (
+    accountId: string,
+    overrides: DiagnosticsRuntimeStatusOverrides,
+  ) => DiagnosticsRuntimeStatusInput;
+  getAccountRuntimeSnapshot: (
+    accountId: string,
+    runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+  ) => BncrAccountRuntimeSnapshot;
+  buildIntegratedDiagnostics: (
+    accountId: string,
+    runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+  ) => ReturnType<typeof buildIntegratedDiagnosticsFromRuntime>;
+  buildDownlinkHealth: (accountId: string) => BncrDownlinkHealthSummary;
+  isPrimaryConnection: (accountId: string, clientId?: string) => boolean;
+  acceptConnection: () => { leaseId: string; connectionEpoch: number; acceptedAt: number };
+  refreshLiveConnectionState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady: boolean;
+    preferredForOutbound: boolean;
+    inboundOnly: boolean;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  flushOnConnect: (accountId: string) => void;
+  flushOnActivity: (accountId: string) => void;
+  shouldIgnoreStaleEvent: (args: {
+    kind:
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort'
+      | 'inbound';
+    payload: LeaseEventPayload;
+    accountId: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  incrementConnectEvents: (accountId: string) => void;
+  incrementActivityEvents: (accountId: string) => void;
+  incrementAckEvents: (accountId: string) => void;
+  markLastActivityAt: () => void;
+  markLastAckAt: () => void;
+  messageAckWaiterCount: () => number;
+  fileAckWaiterCount: () => number;
+  prepareAckHandling: (args: {
+    params: GatewayRequestHandlerOptions['params'];
+    respond: GatewayRequestHandlerOptions['respond'];
+    client: GatewayRequestHandlerOptions['client'];
+    context: GatewayRequestHandlerOptions['context'];
+  }) => PreparedAckHandling | null;
+  handleAckOutcome: (
+    args: {
+      params: GatewayRequestHandlerOptions['params'];
+      respond: GatewayRequestHandlerOptions['respond'];
+    } & PreparedAckHandling,
+  ) => void;
+  fileSendTransfers: Map<string, FileSendTransferState>;
+  hasFileAckWaiter: (key: string) => boolean;
+  fileAckKey: (transferId: string, stage: string, chunkIndex?: number) => string;
+  observeLease: (
+    kind:
+      | 'connect'
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort',
+    payload: LeaseEventPayload,
+  ) => { stale: boolean };
+  tryAdoptTransferOwner: (args: {
+    accountId: string;
+    transfer: FileSendTransferState | undefined;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  refreshAcceptedFileTransferLiveState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  resolveFileAck: (args: {
+    transferId: string;
+    stage: string;
+    chunkIndex?: number;
+    payload: FileAckPayload;
+    ok: boolean;
+  }) => void;
+  countInvalidOutboxSessionKeys: (accountId: string) => number;
+  countLegacyAccountResidue: (accountId: string) => number;
+  activeConnectionCount: (accountId: string) => number;
+  getMessageAckWaiterCount: () => number;
+  getFileAckWaiterCount: () => number;
+  filterDeadLetterEntries: (args: {
+    accountId: string;
+    reason?: string | null;
+    olderThan?: number | null;
+  }) => OutboxEntry[];
+  listDeadLetterEntries: () => OutboxEntry[];
+  buildDeadLetterDiagnostics: (accountId: string) => BncrDeadLetterDiagnosticsSummary;
+  replaceDeadLetterEntries: (nextEntries: OutboxEntry[]) => void;
+  scheduleSave: () => void;
+  logDeadLetterSummary: (accountId: string, args: { force: boolean; source: string }) => void;
+}) {
+  return { ...deps };
+}
+
+export function buildBncrTargetStatusRuntime(deps: {
+  api: unknown;
+  channelId: string;
+  canonicalAgentId: string | null;
+  getPluginRoot: () => string | null;
+  startedAt: number;
+  debugVerbose: boolean;
+  adaptiveAckTimeoutEnabled: boolean;
+  defaultMessageAckTimeoutMs: number;
+  fileAckTimeoutMs: number;
+  maxAckTimeoutMs: number;
+  now: () => number;
+  normalizeAccountId: (accountId: string) => string;
+  sessionRoutes: Map<string, StoredRouteRecord>;
+  routeAliases: Map<string, StoredRouteRecord>;
+  lastSessionByAccount: Map<string, StoredLastSessionRecord>;
+  markActivity: (accountId: string, at?: number) => void;
+  scheduleSave: () => void;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  ensureCanonicalAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer?: unknown;
+    channelId?: string;
+  }) => string;
+  recentMediaDedupeBySession: Map<string, Map<string, unknown>>;
+  resolveMessageAckTimeoutMs: (accountId?: string) => number;
+  isOnline: (accountId: string) => boolean;
+  outboxValues: () => Iterable<OutboxEntry>;
+  deadLetterEntries: () => OutboxEntry[];
+  sessionRouteValues: () => Iterable<{ accountId: string }>;
+  countInvalidOutboxSessionKeys: (accountId: string) => number;
+  countLegacyAccountResidue: (accountId: string) => number;
+  connectEventsByAccount: Map<string, number>;
+  inboundEventsByAccount: Map<string, number>;
+  activityEventsByAccount: Map<string, number>;
+  ackEventsByAccount: Map<string, number>;
+  activeConnectionCount: (accountId: string) => number;
+  lastActivityByAccount: Map<string, number>;
+  lastInboundByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  buildRuntimeAckObservability: (accountId: string) => BncrAckObservability;
+  buildRuntimeAckStrategy: (ackObservability: BncrAckObservability) => {
+    timeoutMs: number;
+    reason:
+      | 'static-default'
+      | 'adaptive-disabled'
+      | 'invalid-observability'
+      | 'late-ack-observed'
+      | 'capped-max';
+  };
+  lastAckOkByAccount: Map<string, number>;
+  lastAckTimeoutByAccount: Map<string, number>;
+  getAckTimeoutCount: (accountId: string) => number;
+  getAccountPendingOutboxEntries: (accountId: string) => OutboxEntry[];
+  getAccountDeadLetterEntries: (accountId: string) => OutboxEntry[];
+  connectionsValues: () => Iterable<{ lastSeenAt: number }>;
+  connectTtlMs: number;
+}) {
+  return { ...deps };
+}
+
+export function buildBncrDiagnosticsSelectionRuntime(deps: {
+  normalizeAccountId: (accountId: string) => string;
+  outboxValues: () => Iterable<OutboxEntry>;
+  getDeadLetterEntries: () => OutboxEntry[];
+  connectionsValues: () => Iterable<BncrConnection>;
+}) {
+  return { ...deps };
+}
+
+export function buildBncrOutboxDiagnosticsRuntime(deps: {
+  normalizeAccountId: (accountId: string) => string;
+  outboxValues: () => Iterable<OutboxEntry>;
+  pendingAllAccounts: () => number;
+  resolvePushConnIds: (accountId: string) => Set<string>;
+}) {
+  return { ...deps };
+}
+
+export function buildBncrRuntimeAckObservabilityRuntime(deps: {
+  normalizeAccountId: (accountId: string) => string;
+  getCounter: (map: Map<string, number>, accountId: string) => number;
+  ackTimeoutCountByAccount: Map<string, number>;
+  lateAckOkCountByAccount: Map<string, number>;
+  lastLateAckPushLatencyMsByAccount: Map<string, number>;
+  lastLateAckOkByAccount: Map<string, number>;
+  adaptiveAckRecoveryOkCountByAccount: Map<string, number>;
+  lastAckOkByAccount: Map<string, number>;
+  lastAckTimeoutByAccount: Map<string, number>;
+  lastAckQueueLatencyMsByAccount: Map<string, number>;
+  lastAckPushLatencyMsByAccount: Map<string, number>;
+  lastLateAckQueueLatencyMsByAccount: Map<string, number>;
+  adaptiveAckTimeoutEnabled: boolean;
+  defaultAckTimeoutMs: number;
+  resolveMessageAckTimeoutMs: (accountId: string) => number;
+  minAckTimeoutMs: number;
+  maxAckTimeoutMs: number;
+  lateAckObservationTtlMs: number;
+  recoveryOkThreshold: number;
+  now: () => number;
+}) {
+  return { ...deps };
+}
+
+export function buildBncrDeadLetterDiagnosticsRuntime(deps: {
+  normalizeAccountId: (accountId: string) => string;
+  getDeadLetterEntries: () => OutboxEntry[];
+  maxDeadLetterEntries: number;
+  getCounter: (map: Map<string, number>, accountId: string) => number;
+  deadLetterSinceStartByAccount: Map<string, number>;
+  getAccountDeadLetterEntries: (accountId: string) => OutboxEntry[];
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logInfoDedup: (
+    scope: string,
+    message: string,
+    options: { key: string; sig: string; windowMs?: number },
+  ) => void;
+}) {
+  return { ...deps };
+}
+
+export function buildBncrExtendedDiagnosticsAssemblerRuntime(deps: {
+  normalizeAccountId: (accountId: string) => string;
+  buildIntegratedDiagnostics: (
+    accountId: string,
+    runtimeStatusInput?: Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0],
+  ) => BncrDiagnosticsSummary;
+  buildOutboxDiagnostics: (accountId: string) => BncrOutboxQueueDiagnostics;
+  buildRuntimeAckObservability: (accountId: string) => BncrAckObservability;
+  getCounter: (map: Map<string, number>, accountId: string) => number;
+  prePushGuardSkipCountByAccount: Map<string, number>;
+  lastPrePushGuardSkipAtByAccount: Map<string, number>;
+  lastPrePushGuardSkipReasonByAccount: Map<string, string>;
+  hasGatewayContext: () => boolean;
+  buildRuntimeSurfaceDiagnostics: () => Record<string, unknown>;
+  getRegisterRuntime: () => Record<string, unknown>;
+  buildRegisterTraceSummary: () => RegisterTraceSummary;
+  activeConnectionCount: (accountId: string) => number;
+  getConnectionRuntime: () => Record<string, unknown>;
+  getOutboundRuntime: () => Record<string, unknown>;
+  buildDeadLetterDiagnostics: (accountId: string) => BncrDeadLetterDiagnosticsSummary;
+  bridgeVersion: number;
+  staleCounters: Record<string, number>;
+  now: () => number;
+}) {
+  return { ...deps };
+}

package/src/plugin/channel-runtime-builders.ts

@@ -0,0 +1,25 @@
+// Aggregated runtime wiring entrypoint.
+//
+// Delivery and status/diagnostics slices now live in dedicated files so the
+// bridge wiring catalog stays readable without changing import sites.
+
+export {
+  buildBncrAckOutboxRuntime,
+  buildBncrChannelSendRuntime,
+  buildBncrConnectionStateRuntime,
+  buildBncrFileTransferRuntime,
+  buildBncrInboundSurfaceRuntime,
+  buildBncrMediaOrchestratorsRuntime,
+  buildBncrOutboxPushRouteRuntime,
+  buildBncrStateTransientRuntime,
+} from './channel-runtime-builders-delivery.ts';
+
+export {
+  buildBncrBridgeSurfaceHandlersRuntime,
+  buildBncrDeadLetterDiagnosticsRuntime,
+  buildBncrDiagnosticsSelectionRuntime,
+  buildBncrExtendedDiagnosticsAssemblerRuntime,
+  buildBncrOutboxDiagnosticsRuntime,
+  buildBncrRuntimeAckObservabilityRuntime,
+  buildBncrTargetStatusRuntime,
+} from './channel-runtime-builders-status.ts';

package/src/plugin/channel-runtime-constants.ts

@@ -0,0 +1,40 @@
+export const BRIDGE_VERSION = 2;
+export const BNCR_PUSH_EVENT = 'plugin.bncr.push';
+export const BNCR_FILE_INIT_EVENT = 'plugin.bncr.file.init';
+export const BNCR_FILE_CHUNK_EVENT = 'plugin.bncr.file.chunk';
+export const BNCR_FILE_COMPLETE_EVENT = 'plugin.bncr.file.complete';
+export const BNCR_FILE_ABORT_EVENT = 'plugin.bncr.file.abort';
+export const CONNECT_TTL_MS = 120_000;
+export const RECENT_INBOUND_SEND_WINDOW_MS = 60_000;
+export const MAX_RETRY = 10;
+export const MAX_DEAD_LETTER_ENTRIES = 1000;
+export const MAX_SESSION_ROUTE_ENTRIES = 1000;
+export const MAX_ACCOUNT_ACTIVITY_ENTRIES = 1000;
+export const PUSH_DRAIN_INTERVAL_MS = 500;
+export const PUSH_DRAIN_ACCOUNT_BUDGET = 5;
+export const PUSH_DRAIN_ACCOUNT_TIME_BUDGET_MS = 2_000;
+export const PUSH_DRAIN_EXCEPTION_RETRY_LIMIT = 3;
+export const PUSH_DRAIN_EXCEPTION_RETRY_DELAY_MS = 1_000;
+export const PUSH_DRAIN_STUCK_WARN_MS = 30_000;
+export const PRE_PUSH_GUARD_RETRY_DELAY_MS = 1_000;
+export const PUSH_ACK_TIMEOUT_MS = 30_000;
+export const ADAPTIVE_ACK_TIMEOUT_DEFAULT_ENABLED = true;
+export const RECOMMENDED_ACK_TIMEOUT_MIN_MS = PUSH_ACK_TIMEOUT_MS;
+export const RECOMMENDED_ACK_TIMEOUT_MAX_MS = 90_000;
+export const ADAPTIVE_ACK_TIMEOUT_OBSERVATION_TTL_MS = 60 * 60 * 1000;
+export const ADAPTIVE_ACK_TIMEOUT_RECOVERY_OK_THRESHOLD = 3;
+export const ADAPTIVE_ACK_TIMEOUT_LOG_THROTTLE_MS = 5 * 60 * 1000;
+export const OUTBOUND_READY_TTL_MS = 30_000;
+export const PREFERRED_OUTBOUND_TTL_MS = 12_000;
+export const FILE_FORCE_CHUNK = true;
+export const FILE_INLINE_THRESHOLD = 5 * 1024 * 1024;
+export const FILE_CHUNK_SIZE = 256 * 1024;
+export const INBOUND_FILE_TRANSFER_MAX_BYTES = 50 * 1024 * 1024;
+export const INBOUND_FILE_TRANSFER_MAX_CHUNKS =
+  Math.ceil(INBOUND_FILE_TRANSFER_MAX_BYTES / FILE_CHUNK_SIZE) + 1;
+export const FILE_ACK_TIMEOUT_MS = 30_000;
+export const FILE_TRANSFER_ACK_TTL_MS = 30_000;
+export const MAX_EARLY_FILE_ACKS = 1000;
+export const FILE_TRANSFER_KEEP_MS = 6 * 60 * 60 * 1000;
+export const FILE_TRANSFER_TERMINAL_KEEP_MS = 10 * 60 * 1000;
+export const REGISTER_WARMUP_WINDOW_MS = 30_000;

package/src/plugin/channel-runtime-types.ts

@@ -0,0 +1,146 @@
+import type { RegisterDriftSnapshot, RegisterTraceEntry } from '../core/register-trace.ts';
+import type { BncrDiagnosticsSummary, BncrRoute, OutboxEntry } from '../core/types.ts';
+import type { OpenClawChannelToolSend, openClawJsonResult } from '../openclaw/sdk-helpers.ts';
+
+type OpenClawJsonResultPayload = ReturnType<typeof openClawJsonResult>;
+
+export type BncrChannelConfigRoot = {
+  channels?: Record<string, BncrChannelConfigSection | undefined>;
+};
+
+export type BncrChannelConfigSection = {
+  enabled?: boolean;
+  name?: string;
+  debug?: {
+    verbose?: boolean;
+  };
+  accounts?: Record<string, BncrAccountConfig | undefined>;
+  outboundRequireAck?: boolean;
+  [key: string]: unknown;
+};
+
+export type BncrAccountConfig = {
+  enabled?: boolean;
+  name?: string;
+  [key: string]: unknown;
+};
+
+export type BncrPersistedSessionRoute = {
+  sessionKey: string;
+  accountId: string;
+  route: BncrRoute;
+  updatedAt: number;
+};
+
+export type BncrPersistedAccountTimestamp = {
+  accountId: string;
+  updatedAt: number;
+};
+
+export type BncrPersistedLastSession = {
+  accountId: string;
+  sessionKey: string;
+  scope: string;
+  updatedAt: number;
+};
+
+export type BncrStatusRuntimeSnapshot = {
+  connected?: boolean;
+  running?: boolean;
+  mode?: string;
+  pending?: number | null;
+  deadLetter?: number | null;
+  lastEventAt?: number | null;
+  lastError?: string | null;
+  lastSessionKey?: string | null;
+  lastSessionScope?: string | null;
+  lastSessionAt?: number | null;
+  lastActivityAt?: number | null;
+  lastInboundAt?: number | null;
+  lastOutboundAt?: number | null;
+  lastSessionAgo?: string | null;
+  lastActivityAgo?: string | null;
+  lastInboundAgo?: string | null;
+  lastOutboundAgo?: string | null;
+  diagnostics?: BncrDiagnosticsSummary | Record<string, unknown> | null;
+  meta?: Record<string, unknown> | null;
+  [key: string]: unknown;
+};
+
+export type BncrVerifiedTarget = {
+  sessionKey: string;
+  route: BncrRoute;
+  displayScope: string;
+};
+
+export type BncrChannelSendContext = {
+  accountId?: string | null;
+  to?: string;
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  type?: string;
+  kind?: string;
+  replyToId?: string | null;
+  replyToMessageId?: string | null;
+  asVoice?: boolean;
+  audioAsVoice?: boolean;
+  mediaLocalRoots?: readonly string[];
+  payload?: Record<string, unknown>;
+  sessionKey?: string;
+  mirror?: { sessionKey?: string };
+  threadId?: string;
+};
+
+export type BncrRegisterRuntimeSnapshot = {
+  bridgeId: string;
+  gatewayPid: number;
+  pluginVersion: string | null;
+  pluginSource: string | null;
+  lastApiInstanceId: string | null;
+  lastRegistryFingerprint: string | null;
+  registerCount: number;
+  firstRegisterAt: number | null;
+  lastRegisterAt: number | null;
+  lastApiRebindAt: number | null;
+  apiGeneration: number;
+  registerTraceRecent: RegisterTraceEntry[];
+  lastDriftSnapshot: RegisterDriftSnapshot | null;
+};
+
+export type FileAckPayloadState = {
+  payload: Record<string, unknown>;
+  ok: boolean;
+  at: number;
+};
+
+export type ChannelMessageActionAdapter = {
+  describeMessageTool: (ctx: { cfg: BncrChannelConfigRoot }) => {
+    actions: readonly ['send'];
+    capabilities: readonly [];
+  } | null;
+  supportsAction: (ctx: { action: string }) => boolean;
+  extractToolSend: (ctx: { args: unknown }) => OpenClawChannelToolSend | null;
+  handleAction: (ctx: {
+    action: string;
+    params: unknown;
+    accountId?: string | null;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<OpenClawJsonResultPayload>;
+};
+
+export type PersistedState = {
+  outbox: OutboxEntry[];
+  deadLetter: OutboxEntry[];
+  sessionRoutes: BncrPersistedSessionRoute[];
+  lastSessionByAccount?: BncrPersistedLastSession[];
+  lastActivityByAccount?: BncrPersistedAccountTimestamp[];
+  lastInboundByAccount?: BncrPersistedAccountTimestamp[];
+  lastOutboundByAccount?: BncrPersistedAccountTimestamp[];
+  lastDriftSnapshot?: RegisterDriftSnapshot | null;
+};
+
+export type BncrBridgeRuntimePaths = {
+  pluginRoot?: string | null;
+  pluginFile?: string | null;
+};

package/src/plugin/channel-send-runtime-group.ts

@@ -0,0 +1,37 @@
+import type { BncrRoute } from '../core/types.ts';
+import { createBncrChannelSendRuntimeComponent } from './channel-components.ts';
+
+export function createBncrChannelSendRuntimeGroup(runtime: {
+  channelId: string;
+  asString: (value: unknown, fallback?: string) => string;
+  syncDebugFlag: () => Promise<void>;
+  logInfo: (scope: string, message: string, options?: Record<string, unknown>) => void;
+  resolveVerifiedTarget: (
+    to: string,
+    accountId: string,
+  ) => {
+    sessionKey: string;
+    route: BncrRoute;
+    displayScope: string;
+  };
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) => void;
+  enqueueFromReply: Parameters<typeof createBncrChannelSendRuntimeComponent>[0]['enqueueFromReply'];
+  listOutboxEntries: Parameters<
+    typeof createBncrChannelSendRuntimeComponent
+  >[0]['listOutboxEntries'];
+}) {
+  const channelSendRuntime = createBncrChannelSendRuntimeComponent({
+    channelId: runtime.channelId,
+    asString: runtime.asString,
+    syncDebugFlag: runtime.syncDebugFlag,
+    logInfo: runtime.logInfo,
+    resolveVerifiedTarget: runtime.resolveVerifiedTarget,
+    rememberSessionRoute: runtime.rememberSessionRoute,
+    enqueueFromReply: runtime.enqueueFromReply,
+    listOutboxEntries: runtime.listOutboxEntries,
+  });
+
+  return {
+    channelSendRuntime,
+  };
+}