@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/bridge-outbox-facade.ts

@@ -0,0 +1,182 @@
+import { buildBncrDebugJsonMessage } from '../core/logging.ts';
+import { buildOutboxEnqueueDebugInfo } from '../core/outbox-enqueue.ts';
+import {
+  appendDeadLetter,
+  buildDeadLetterEntry,
+  collectDueOutboxEntries,
+} from '../core/outbox-queue.ts';
+import { formatDisplayScope } from '../core/targets.ts';
+import type { OutboxEntry } from '../core/types.ts';
+import {
+  buildBncrOutboxFailureEntryPatch,
+  buildBncrOutboxPushSuccessEntryPatch,
+} from '../runtime/outbox-transitions.ts';
+import { getErrorMessage } from './error-message.ts';
+
+function isPrePushGuardReason(reason: string) {
+  return reason === 'no-gateway-context' || reason === 'no-active-connection';
+}
+
+export function createBncrBridgeOutboxFacade(runtime: {
+  bridgeId: string;
+  normalizeAccountId: (accountId: string) => string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  backoffMs: (retryCount: number) => number;
+  maxRetry: number;
+  maxDeadLetterEntries: number;
+  outbox: Map<string, OutboxEntry>;
+  getDeadLetter: () => OutboxEntry[];
+  setDeadLetter: (entries: OutboxEntry[]) => void;
+  incrementCounter: (map: Map<string, number>, accountId: string) => void;
+  outboundEnqueueCountByAccount: Map<string, number>;
+  lastOutboundEnqueueAtByAccount: Map<string, number>;
+  prePushGuardSkipCountByAccount: Map<string, number>;
+  lastPrePushGuardSkipAtByAccount: Map<string, number>;
+  lastPrePushGuardSkipReasonByAccount: Map<string, string>;
+  deadLetterSinceStartByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  scheduleSave: () => void;
+  flushPushQueueBestEffort: (args?: {
+    accountId?: string;
+    trigger?: string;
+    reason?: string;
+  }) => void;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  logOutboundSummary: (entry: OutboxEntry) => void;
+  logDeadLetterSummary: (accountId: string, options?: { force?: boolean; source?: string }) => void;
+  resolveMessageAck: (messageId: string, result?: 'acked' | 'timeout') => boolean;
+  markActivity: (accountId: string, at?: number) => void;
+}) {
+  const recordOutboxPrePushFailure = (args: {
+    entry: OutboxEntry;
+    lastError: string;
+    persist?: boolean;
+  }) => {
+    const nextEntry = buildBncrOutboxFailureEntryPatch({
+      entry: args.entry,
+      lastError: args.lastError,
+    });
+    Object.assign(args.entry, nextEntry);
+    runtime.outbox.set(nextEntry.messageId, args.entry);
+    if (args.persist) runtime.scheduleSave();
+  };
+
+  const recordPrePushGuardSkip = (args: { accountId: string; reason: string }) => {
+    if (!isPrePushGuardReason(args.reason)) return;
+    const acc = runtime.normalizeAccountId(args.accountId);
+    runtime.incrementCounter(runtime.prePushGuardSkipCountByAccount, acc);
+    runtime.lastPrePushGuardSkipAtByAccount.set(acc, runtime.now());
+    runtime.lastPrePushGuardSkipReasonByAccount.set(acc, args.reason);
+  };
+
+  const isPrePushGuardDeferral = (entry: OutboxEntry) =>
+    entry.lastError === 'gateway context unavailable' ||
+    entry.lastError === 'no active bncr client';
+
+  const recordOutboxPushFailure = (args: {
+    entry: OutboxEntry;
+    error: unknown;
+    fallbackError: string;
+    persist?: boolean;
+  }) => {
+    const nextEntry = buildBncrOutboxFailureEntryPatch({
+      entry: args.entry,
+      lastError: runtime.asString(getErrorMessage(args.error, args.fallbackError)),
+    });
+    Object.assign(args.entry, nextEntry);
+    runtime.outbox.set(nextEntry.messageId, args.entry);
+    if (args.persist) runtime.scheduleSave();
+  };
+
+  const recordOutboxPushSuccess = (args: {
+    entry: OutboxEntry;
+    connIds: Iterable<string>;
+    ownerConnId?: string;
+    ownerClientId?: string;
+    clearLastError?: boolean;
+  }) => {
+    const pushedAt = runtime.now();
+    const nextEntry = buildBncrOutboxPushSuccessEntryPatch({
+      entry: args.entry,
+      connIds: args.connIds,
+      pushedAt,
+      ownerConnId: args.ownerConnId,
+      ownerClientId: args.ownerClientId,
+      clearLastError: args.clearLastError,
+    });
+    Object.assign(args.entry, nextEntry);
+    runtime.outbox.set(nextEntry.messageId, args.entry);
+    runtime.lastOutboundByAccount.set(nextEntry.accountId, pushedAt);
+    runtime.markActivity(nextEntry.accountId, pushedAt);
+    runtime.scheduleSave();
+  };
+
+  const enqueueOutbound = (entry: OutboxEntry) => {
+    runtime.logInfo(
+      'outbound',
+      buildBncrDebugJsonMessage(
+        'enqueue',
+        buildOutboxEnqueueDebugInfo({
+          bridgeId: runtime.bridgeId,
+          entry,
+          asString: runtime.asString,
+          formatDisplayScope,
+        }),
+      ),
+      { debugOnly: true },
+    );
+    runtime.logOutboundSummary(entry);
+    const accountId = runtime.normalizeAccountId(entry.accountId);
+    runtime.incrementCounter(runtime.outboundEnqueueCountByAccount, accountId);
+    runtime.lastOutboundEnqueueAtByAccount.set(accountId, runtime.now());
+    runtime.outbox.set(entry.messageId, entry);
+    runtime.scheduleSave();
+    runtime.flushPushQueueBestEffort({ accountId: entry.accountId });
+  };
+
+  const moveToDeadLetter = (entry: OutboxEntry, reason: string) => {
+    const dead = buildDeadLetterEntry(entry, reason);
+    runtime.setDeadLetter(
+      appendDeadLetter({
+        deadLetter: runtime.getDeadLetter(),
+        entry: dead,
+        maxEntries: runtime.maxDeadLetterEntries,
+      }),
+    );
+    runtime.incrementCounter(runtime.deadLetterSinceStartByAccount, dead.accountId);
+    runtime.logDeadLetterSummary(dead.accountId, { source: 'move' });
+    runtime.outbox.delete(entry.messageId);
+    runtime.resolveMessageAck(entry.messageId, 'timeout');
+    runtime.scheduleSave();
+  };
+
+  const collectDue = (args: { accountId: string; maxBatch: number }) => {
+    const key = runtime.normalizeAccountId(args.accountId);
+    const result = collectDueOutboxEntries({
+      outbox: runtime.outbox.values(),
+      accountId: key,
+      now: runtime.now(),
+      maxBatch: args.maxBatch,
+      maxRetry: runtime.maxRetry,
+      backoffMs: runtime.backoffMs,
+    });
+
+    for (const entry of result.updatedEntries) runtime.outbox.set(entry.messageId, entry);
+    for (const entry of result.deadLetterEntries)
+      moveToDeadLetter(entry, entry.lastError || 'retry-limit');
+    if (result.duePayloads.length) runtime.scheduleSave();
+    return result.duePayloads;
+  };
+
+  return {
+    recordOutboxPrePushFailure,
+    recordPrePushGuardSkip,
+    isPrePushGuardDeferral,
+    recordOutboxPushFailure,
+    recordOutboxPushSuccess,
+    enqueueOutbound,
+    moveToDeadLetter,
+    collectDue,
+  };
+}

package/src/plugin/bridge-runtime-helpers.ts

@@ -0,0 +1,266 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrExtendedDiagnostics } from '../core/extended-diagnostics.ts';
+import type {
+  BncrAccountRuntimeSnapshot,
+  buildIntegratedDiagnostics as buildIntegratedDiagnosticsFromRuntime,
+} from '../core/status.ts';
+import type { BncrDownlinkHealthSummary, BncrRoute } from '../core/types.ts';
+import { OUTBOUND_FLUSH_REASON, OUTBOUND_FLUSH_TRIGGER } from '../messaging/outbound/reasons.ts';
+import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
+import type { BncrRuntimeFlags } from '../runtime/outbound-flags.ts';
+import type { BncrVerifiedTarget } from './channel-runtime-types.ts';
+import type { ConnectionQueueCounters, LeaseEventPayload } from './connection-handlers.ts';
+import type { BncrActiveConnectionDebugEntry } from './connection-state.ts';
+
+type DiagnosticsRuntimeStatusInput = Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0] & {
+  running: boolean | undefined;
+  channelRoot: string;
+};
+
+type DiagnosticsRuntimeStatusOverrides = {
+  running: boolean;
+  invalidOutboxSessionKeys?: number;
+  legacyAccountResidue?: number;
+};
+
+type ExtendedDiagnosticsOptions = {
+  runtimeStatusInput?: DiagnosticsRuntimeStatusInput;
+  integratedDiagnostics?: ReturnType<typeof buildIntegratedDiagnosticsFromRuntime>;
+};
+
+export function buildBridgeRuntimeStatusInput<T extends object>(args: {
+  runtimeStatusInput: T;
+  running: boolean | undefined;
+  channelRoot: string;
+}): T & { running: boolean | undefined; channelRoot: string } {
+  return {
+    ...args.runtimeStatusInput,
+    running: args.running,
+    channelRoot: args.channelRoot,
+  };
+}
+
+export function buildFlushOnConnectArgs(accountId: string) {
+  return {
+    accountId,
+    trigger: OUTBOUND_FLUSH_TRIGGER.CONNECT,
+    reason: OUTBOUND_FLUSH_REASON.WS_ONLINE,
+  };
+}
+
+export function buildFlushOnActivityArgs(accountId: string) {
+  return {
+    accountId,
+    trigger: OUTBOUND_FLUSH_TRIGGER.ACTIVITY,
+    reason: OUTBOUND_FLUSH_REASON.ACTIVITY_HEARTBEAT,
+  };
+}
+
+export function buildBridgeStatusProjectionRuntime(args: {
+  buildAccountQueueCounters: (accountId: string) => ConnectionQueueCounters;
+  buildExtendedDiagnostics: (
+    accountId: string,
+    options?: ExtendedDiagnosticsOptions,
+  ) => BncrExtendedDiagnostics;
+  buildRuntimeFlags: (accountId?: string) => BncrRuntimeFlags;
+  buildRuntimeStatusInput: (
+    accountId: string,
+    overrides: DiagnosticsRuntimeStatusOverrides,
+  ) => Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0];
+  getAccountRuntimeSnapshot: (
+    accountId: string,
+    runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+  ) => BncrAccountRuntimeSnapshot;
+  buildIntegratedDiagnostics: (
+    accountId: string,
+    runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+  ) => ReturnType<typeof buildIntegratedDiagnosticsFromRuntime>;
+  buildDownlinkHealth: (accountId: string) => BncrDownlinkHealthSummary;
+  resolveChannelRoot: () => string;
+}) {
+  return {
+    buildAccountQueueCounters: (accountId: string) => args.buildAccountQueueCounters(accountId),
+    buildExtendedDiagnostics: (accountId: string, options?: ExtendedDiagnosticsOptions) =>
+      args.buildExtendedDiagnostics(accountId, options),
+    buildRuntimeFlags: (accountId?: string) => args.buildRuntimeFlags(accountId),
+    buildRuntimeStatusInput: (accountId: string, overrides: DiagnosticsRuntimeStatusOverrides) =>
+      buildBridgeRuntimeStatusInput({
+        runtimeStatusInput: args.buildRuntimeStatusInput(accountId, overrides),
+        running: overrides.running,
+        channelRoot: args.resolveChannelRoot(),
+      }),
+    getAccountRuntimeSnapshot: (
+      accountId: string,
+      runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+    ) => args.getAccountRuntimeSnapshot(accountId, runtimeStatusInput),
+    buildIntegratedDiagnostics: (
+      accountId: string,
+      runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+    ) => args.buildIntegratedDiagnostics(accountId, runtimeStatusInput),
+    buildDownlinkHealth: (accountId: string) => args.buildDownlinkHealth(accountId),
+  };
+}
+
+export function buildBridgeDrainTriggers(args: {
+  flushPushQueueBestEffort: (args: { accountId: string; trigger: string; reason: string }) => void;
+}) {
+  return {
+    flushOnConnect: (accountId: string) =>
+      args.flushPushQueueBestEffort(buildFlushOnConnectArgs(accountId)),
+    flushOnActivity: (accountId: string) =>
+      args.flushPushQueueBestEffort(buildFlushOnActivityArgs(accountId)),
+  };
+}
+
+export function buildBridgeLifecycleMarkers(args: {
+  markLastActivityAt: () => void;
+  markLastAckAt: () => void;
+}) {
+  return {
+    markLastActivityAt: () => args.markLastActivityAt(),
+    markLastAckAt: () => args.markLastAckAt(),
+  };
+}
+
+export function buildInboundSurfaceActivityRuntime(args: {
+  markInboundGlobalActivity: () => void;
+  incrementInboundEvents: (accountId: string) => void;
+  setLastInboundByAccount: (accountId: string, at: number) => void;
+  markActivity: (accountId: string, at: number) => void;
+}) {
+  return {
+    markLastInboundAt: (accountId: string) => {
+      args.markInboundGlobalActivity();
+      args.incrementInboundEvents(accountId);
+    },
+    setInboundActivity: (accountId: string, at: number) => {
+      args.setLastInboundByAccount(accountId, at);
+      args.markActivity(accountId, at);
+    },
+  };
+}
+
+export function buildInboundSurfaceConnectionRuntime(args: {
+  shouldIgnoreStaleEvent: (args: {
+    kind:
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort';
+    payload: LeaseEventPayload;
+    accountId: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  observeLease: (
+    kind:
+      | 'connect'
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort',
+    payload: LeaseEventPayload,
+  ) => { stale: boolean };
+  matchesTransferOwner: (args: {
+    ownerConnId?: string;
+    ownerClientId?: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  refreshAcceptedFileTransferLiveState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  refreshLiveConnectionState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady: boolean;
+    preferredForOutbound: boolean;
+    inboundOnly: boolean;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  isOnline: (accountId: string) => boolean;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  getActiveConnectionKey: (accountId: string) => string | null;
+  buildActiveConnectionDebugList: (accountId: string) => BncrActiveConnectionDebugEntry[];
+}) {
+  return {
+    shouldIgnoreStaleEvent: (runtimeArgs: Parameters<typeof args.shouldIgnoreStaleEvent>[0]) =>
+      args.shouldIgnoreStaleEvent(runtimeArgs),
+    observeLease: (
+      kind: Parameters<typeof args.observeLease>[0],
+      payload: Parameters<typeof args.observeLease>[1],
+    ) => args.observeLease(kind, payload),
+    matchesTransferOwner: (runtimeArgs: Parameters<typeof args.matchesTransferOwner>[0]) =>
+      args.matchesTransferOwner(runtimeArgs),
+    refreshAcceptedFileTransferLiveState: (
+      runtimeArgs: Parameters<typeof args.refreshAcceptedFileTransferLiveState>[0],
+    ) => args.refreshAcceptedFileTransferLiveState(runtimeArgs),
+    refreshLiveConnectionState: (
+      runtimeArgs: Parameters<typeof args.refreshLiveConnectionState>[0],
+    ) => args.refreshLiveConnectionState(runtimeArgs),
+    isOnline: (accountId: string) => args.isOnline(accountId),
+    hasRecentInboundReachability: (accountId: string) =>
+      args.hasRecentInboundReachability(accountId),
+    getActiveConnectionKey: (accountId: string) => args.getActiveConnectionKey(accountId),
+    buildActiveConnectionDebugList: (accountId: string) =>
+      args.buildActiveConnectionDebugList(accountId),
+  };
+}
+
+export function buildChannelSendTargetRuntime(args: {
+  resolveVerifiedTarget: (to: string, accountId: string) => BncrVerifiedTarget;
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    payload: ReplyPayloadInput;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
+}) {
+  return {
+    resolveVerifiedTarget: (to: string, accountId: string) =>
+      args.resolveVerifiedTarget(to, accountId),
+    rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) =>
+      args.rememberSessionRoute(sessionKey, accountId, route),
+    enqueueFromReply: (runtimeArgs: Parameters<typeof args.enqueueFromReply>[0]) =>
+      args.enqueueFromReply(runtimeArgs),
+  };
+}
+
+export function buildFlushBestEffortError(args: {
+  accountId?: string;
+  trigger?: string;
+  reason?: string;
+  error: unknown;
+  asString: (value: unknown, fallback?: string) => string;
+  normalizeAccountId: (accountId: string) => string;
+  nextRetryCount: number;
+  retryLimit: number;
+}) {
+  const accountId = args.accountId ? args.normalizeAccountId(args.accountId) : '';
+  const reason = args.asString(args.reason || args.trigger || 'flush-error');
+  const err =
+    args.error && typeof args.error === 'object' && 'message' in args.error
+      ? args.asString((args.error as { message?: unknown }).message || 'flush-error')
+      : args.asString(args.error || 'flush-error');
+  const willRetry = args.nextRetryCount <= args.retryLimit;
+
+  return {
+    accountId,
+    reason,
+    err,
+    willRetry,
+    retryDisplay: willRetry ? args.nextRetryCount : 'false',
+  };
+}

package/src/plugin/bridge-runtime-snapshots.ts

@@ -0,0 +1,104 @@
+import type { RegisterDriftSnapshot, RegisterTraceEntry } from '../core/register-trace.ts';
+import type { BncrConnection } from '../core/types.ts';
+
+export function buildRegisterRuntimeSnapshot(args: {
+  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;
+}) {
+  return {
+    bridgeId: args.bridgeId,
+    gatewayPid: args.gatewayPid,
+    pluginVersion: args.pluginVersion,
+    pluginSource: args.pluginSource,
+    lastApiInstanceId: args.lastApiInstanceId,
+    lastRegistryFingerprint: args.lastRegistryFingerprint,
+    registerCount: args.registerCount,
+    firstRegisterAt: args.firstRegisterAt,
+    lastRegisterAt: args.lastRegisterAt,
+    lastApiRebindAt: args.lastApiRebindAt,
+    apiGeneration: args.apiGeneration,
+    registerTraceRecent: args.registerTraceRecent,
+    lastDriftSnapshot: args.lastDriftSnapshot ?? null,
+  };
+}
+
+export function buildConnectionRuntimeSnapshot(args: {
+  lastGatewayContextAt: number | null;
+  primaryLeaseId: string | null;
+  connectionEpoch: number;
+  acceptedConnections: number;
+  lastConnectAt: number | null;
+  lastDisconnectAt: number | null;
+  lastActivityAtGlobal: number | null;
+  lastInboundAtGlobal: number | null;
+  lastAckAtGlobal: number | null;
+  recentConnections: Map<
+    string,
+    { epoch: number; connectedAt: number; lastActivityAt: number | null; isPrimary: boolean }
+  >;
+}) {
+  return {
+    lastGatewayContextAt: args.lastGatewayContextAt,
+    primaryLeaseId: args.primaryLeaseId,
+    connectionEpoch: args.connectionEpoch,
+    acceptedConnections: args.acceptedConnections,
+    lastConnectAt: args.lastConnectAt,
+    lastDisconnectAt: args.lastDisconnectAt,
+    lastActivityAtGlobal: args.lastActivityAtGlobal,
+    lastInboundAtGlobal: args.lastInboundAtGlobal,
+    lastAckAtGlobal: args.lastAckAtGlobal,
+    recentConnections: args.recentConnections,
+  };
+}
+
+export function buildOutboundRuntimeSnapshot(args: {
+  outboundEnqueueCountByAccount: Map<string, number>;
+  lastOutboundEnqueueAtByAccount: Map<string, number>;
+}) {
+  return {
+    outboundEnqueueCountByAccount: args.outboundEnqueueCountByAccount,
+    lastOutboundEnqueueAtByAccount: args.lastOutboundEnqueueAtByAccount,
+  };
+}
+
+export function buildStatusWorkerLastEventAt(args: {
+  accountId: string;
+  previous: { lastEventAt?: number | null };
+  lastActivityByAccount: ReadonlyMap<string, number>;
+  lastInboundByAccount: ReadonlyMap<string, number>;
+  lastOutboundByAccount: ReadonlyMap<string, number>;
+}) {
+  return (
+    args.lastActivityByAccount.get(args.accountId) ||
+    args.lastInboundByAccount.get(args.accountId) ||
+    args.lastOutboundByAccount.get(args.accountId) ||
+    args.previous?.lastEventAt ||
+    null
+  );
+}
+
+export function buildStatusWorkerActiveConnections(args: {
+  accountId: string;
+  connections: Iterable<BncrConnection>;
+}) {
+  return Array.from(args.connections)
+    .filter((connection) => connection.accountId === args.accountId)
+    .map((connection) => ({
+      connId: connection.connId,
+      clientId: connection.clientId,
+      inboundOnly: connection.inboundOnly === true,
+      outboundReady: connection.outboundReady === true,
+      preferredForOutbound: connection.preferredForOutbound === true,
+    }));
+}

package/src/plugin/bridge-runtime-surface-facade.ts

@@ -0,0 +1,8 @@
+import { buildOpenClawChannelRuntimeSurfaceDiagnostics } from '../openclaw/runtime-surface.ts';
+
+export function createBncrBridgeRuntimeSurfaceFacade(runtime: { getApi: () => unknown }) {
+  return {
+    buildRuntimeSurfaceDiagnostics: () =>
+      buildOpenClawChannelRuntimeSurfaceDiagnostics(runtime.getApi()),
+  };
+}

package/src/plugin/bridge-status-facade.ts

@@ -0,0 +1,76 @@
+import type {
+  BncrAccountRuntimeSnapshot,
+  buildIntegratedDiagnostics as buildIntegratedDiagnosticsFromRuntime,
+} from '../core/status.ts';
+import type { BncrAckObservability } from '../core/types.ts';
+
+type RuntimeStatusInput = Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0];
+type RuntimeStatusMeta = BncrAccountRuntimeSnapshot['meta'];
+
+export function buildBncrStatusProjectionRuntime(runtime: {
+  buildRuntimeStatusInput: (
+    accountId: string,
+    overrides?: Partial<RuntimeStatusInput>,
+  ) => RuntimeStatusInput;
+  buildStatusMeta: (accountId: string) => RuntimeStatusMeta;
+  getAccountRuntimeSnapshot: (
+    accountId: string,
+    runtimeStatusInput: RuntimeStatusInput,
+  ) => BncrAccountRuntimeSnapshot;
+  buildStatusHeadline: (accountId: string) => string;
+  getStatusHeadline: (accountId: string) => string;
+  getChannelSummary: (defaultAccountId: string) => Record<string, unknown>;
+}) {
+  return { ...runtime };
+}
+
+export function buildBncrAckDiagnosticsRuntime(runtime: {
+  buildRuntimeAckObservability: (accountId: string) => BncrAckObservability;
+  buildRuntimeAckStrategy: (ackObservability: BncrAckObservability) => unknown;
+}) {
+  return { ...runtime };
+}
+
+export function createBncrBridgeStatusFacade(runtime: {
+  statusProjection: ReturnType<typeof buildBncrStatusProjectionRuntime>;
+  ackDiagnostics: ReturnType<typeof buildBncrAckDiagnosticsRuntime>;
+}) {
+  const buildRuntimeStatusInput = (
+    accountId: string,
+    overrides: Partial<RuntimeStatusInput> = {},
+  ) => runtime.statusProjection.buildRuntimeStatusInput(accountId, overrides);
+
+  const buildStatusMeta = (accountId: string) =>
+    runtime.statusProjection.buildStatusMeta(accountId);
+
+  const getAccountRuntimeSnapshot = (
+    accountId: string,
+    runtimeStatusInput = buildRuntimeStatusInput(accountId, { running: true }),
+  ) => runtime.statusProjection.getAccountRuntimeSnapshot(accountId, runtimeStatusInput);
+
+  const buildStatusHeadline = (accountId: string) =>
+    runtime.statusProjection.buildStatusHeadline(accountId);
+
+  const getStatusHeadline = (accountId: string) =>
+    runtime.statusProjection.getStatusHeadline(accountId);
+
+  const getChannelSummary = (defaultAccountId: string) =>
+    runtime.statusProjection.getChannelSummary(defaultAccountId);
+
+  const buildRuntimeAckObservability = (accountId: string) =>
+    runtime.ackDiagnostics.buildRuntimeAckObservability(accountId);
+
+  const buildRuntimeAckStrategy = (ackObservability: BncrAckObservability) =>
+    runtime.ackDiagnostics.buildRuntimeAckStrategy(ackObservability);
+
+  return {
+    buildRuntimeStatusInput,
+    buildStatusMeta,
+    getAccountRuntimeSnapshot,
+    buildStatusHeadline,
+    getStatusHeadline,
+    getChannelSummary,
+    buildRuntimeAckObservability,
+    buildRuntimeAckStrategy,
+  };
+}