@xmoxmo/bncr 0.5.7 → 0.5.9

package/src/plugin/outbox-unified-push-flow.ts

@@ -0,0 +1,307 @@
+import {
+  buildFileTransferPushOkArgs,
+  buildFileTransferPushSuccessArgs,
+} from '../core/outbox-file-transfer-bookkeeping.ts';
+import { resolveFileTransferGuard } from '../core/outbox-file-transfer-guards.ts';
+import {
+  prepareRouteSelection,
+  prepareRouteSelection as prepareTextPushRouteSelection,
+} from '../core/outbox-file-transfer-prep.ts';
+import {
+  buildFileTransferBroadcastPayload,
+  buildFileTransferRouteSelectArgs,
+} from '../core/outbox-file-transfer-success.ts';
+import { resolveTextPushGuard } from '../core/outbox-text-push-guards.ts';
+import {
+  buildTextPushBroadcastPayload,
+  buildTextPushOkArgs,
+  buildTextPushRouteSelectArgs,
+  buildTextPushSuccessArgs,
+} from '../core/outbox-text-push-success.ts';
+import type { BncrConnection, BncrRoute, OutboxEntry } from '../core/types.ts';
+import { isPlainObject } from '../core/value-sanitize.ts';
+import {
+  selectOutboxFileTransferRouteCandidates,
+  selectOutboxRouteCandidates,
+} from '../messaging/outbound/queue-selectors.ts';
+
+type FileTransferGuardFailure = {
+  reason: 'media-url-missing' | 'no-gateway-context' | 'no-active-connection';
+  lastError: string;
+  recentInboundReachable?: boolean;
+};
+
+export type RunBncrOutboxPushArgs = {
+  entry: OutboxEntry;
+  gatewayContext: unknown;
+  owner: BncrConnection | null;
+  resolvePushConnIds: (accountId: string) => Set<string>;
+  resolveRecentInboundConnIds: (accountId: string) => Set<string>;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  isRevalidatedAttemptedConn: (connId: string) => boolean;
+  // Route + guard failure
+  recordOutboxPrePushFailure: (args: {
+    entry: OutboxEntry;
+    lastError: string;
+    persist?: boolean;
+  }) => void;
+  logOutboxPushSkip: (args: {
+    messageId: string;
+    accountId: string;
+    reason: string;
+    recentInboundReachable?: boolean;
+    routeReason?: string;
+    connIds?: Iterable<string>;
+    ownerConnId?: string;
+    ownerClientId?: string;
+  }) => void;
+  handleFileTransferPushGuardFailure: (args: {
+    entry: OutboxEntry;
+    guard: FileTransferGuardFailure & { ok: false };
+  }) => void;
+  // Broadcast + bookkeeping (unified)
+  pushEvent: string;
+  gatewayBroadcastToConnIds: (
+    event: string,
+    payload: unknown,
+    connIds: ReadonlySet<string>,
+  ) => void;
+  recordOutboxPushSuccess: (args: {
+    entry: OutboxEntry;
+    connIds: Iterable<string>;
+    ownerConnId?: string;
+    ownerClientId?: string;
+  }) => void;
+  logOutboxRouteSelect: (args: {
+    messageId: string;
+    accountId: string;
+    kind?: 'file-transfer';
+    routeReason: string;
+    connIds: Iterable<string>;
+    ownerConnId: string;
+    ownerClientId: string;
+    recentInboundReachable: boolean;
+    event: string;
+  }) => void;
+  logOutboxPushOkSummary: (messageId: string) => void;
+  logOutboundSummary: (entry: OutboxEntry) => void;
+  logOutboxPushOk: (args: {
+    messageId: string;
+    accountId: string;
+    kind?: 'file-transfer';
+    connIds: Iterable<string>;
+    ownerConnId: string;
+    ownerClientId: string;
+    recentInboundReachable: boolean;
+    event: string;
+  }) => void;
+  // Failure handlers
+  handleTextPushFailure: (args: { entry: OutboxEntry; error: unknown }) => void;
+  handleFileTransferPushFailure: (args: { entry: OutboxEntry; error: unknown }) => void;
+  // Media-specific (optional)
+  transferMediaToBncrClient?: (params: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    mediaUrl: string;
+    mediaLocalRoots?: readonly string[];
+    downloadMedia?: boolean;
+  }) => Promise<{
+    mode: 'base64' | 'chunk';
+    mimeType?: string;
+    fileName?: string;
+    base64?: string;
+    path?: string;
+  }>;
+  buildFileTransferOutboundFrame?: (params: {
+    entry: OutboxEntry;
+    msg: Record<string, unknown>;
+    media: { fileName?: string; mimeType?: string; path?: string; base64?: string; type?: string };
+    mediaUrl: string;
+  }) => Record<string, unknown>;
+};
+
+export async function runBncrOutboxPush(args: RunBncrOutboxPushArgs): Promise<boolean> {
+  const entry = args.entry;
+  const msg =
+    isPlainObject(entry.payload) &&
+    isPlainObject((entry.payload as Record<string, unknown>).message)
+      ? ((entry.payload as Record<string, unknown>).message as Record<string, unknown>)
+      : null;
+  const transferMode = msg?.transferMode === 'media' ? 'media' : 'text';
+
+  // Route selection
+  const selection =
+    transferMode === 'media'
+      ? prepareRouteSelection({
+          entry,
+          owner: args.owner,
+          resolvePushConnIds: args.resolvePushConnIds,
+          resolveRecentInboundConnIds: args.resolveRecentInboundConnIds,
+          hasRecentInboundReachability: args.hasRecentInboundReachability,
+          isRevalidatedAttemptedConn: args.isRevalidatedAttemptedConn,
+          selectRouteCandidates: selectOutboxFileTransferRouteCandidates,
+        })
+      : prepareTextPushRouteSelection({
+          entry,
+          owner: args.owner,
+          resolvePushConnIds: args.resolvePushConnIds,
+          resolveRecentInboundConnIds: args.resolveRecentInboundConnIds,
+          hasRecentInboundReachability: args.hasRecentInboundReachability,
+          isRevalidatedAttemptedConn: args.isRevalidatedAttemptedConn,
+          selectRouteCandidates: selectOutboxRouteCandidates,
+        });
+
+  // Guard + dispatch
+  if (transferMode === 'media') {
+    const guard = resolveFileTransferGuard({
+      gatewayContext: args.gatewayContext,
+      entry,
+      owner: args.owner,
+      routeSelection: selection,
+      mediaUrl: String(msg!.mediaUrl || '').trim(),
+    });
+    if (!guard.ok) {
+      args.handleFileTransferPushGuardFailure({
+        entry,
+        guard: guard as FileTransferGuardFailure & { ok: false },
+      });
+      return false;
+    }
+
+    // ── Media success path (inline) ──
+    try {
+      const media = await args.transferMediaToBncrClient!({
+        accountId: entry.accountId,
+        sessionKey: entry.sessionKey,
+        route: entry.route,
+        mediaUrl: guard.mediaUrl,
+        mediaLocalRoots: Array.isArray(msg!.mediaLocalRoots)
+          ? (msg!.mediaLocalRoots as readonly string[])
+          : undefined,
+        downloadMedia: msg!.downloadMedia as boolean | undefined,
+      });
+      const frame = args.buildFileTransferOutboundFrame!({
+        entry,
+        msg: msg!,
+        media,
+        mediaUrl: guard.mediaUrl,
+      });
+
+      args.gatewayBroadcastToConnIds(
+        args.pushEvent,
+        buildFileTransferBroadcastPayload({ frame, messageId: entry.messageId }),
+        new Set(guard.connIds),
+      );
+      args.logOutboxRouteSelect(
+        buildFileTransferRouteSelectArgs({
+          entry,
+          connIds: guard.connIds,
+          routeReason: guard.routeReason,
+          recentInboundReachable: guard.recentInboundReachable,
+          owner: args.owner,
+          event: args.pushEvent,
+        }),
+      );
+      args.recordOutboxPushSuccess(
+        buildFileTransferPushSuccessArgs({
+          entry,
+          connIds: guard.connIds,
+          owner: args.owner,
+        }),
+      );
+      args.logOutboxPushOkSummary(entry.messageId);
+      // Sync entry type from the resolved frame
+      const frameMsg = frame?.message as Record<string, unknown> | undefined;
+      if (frameMsg?.type !== undefined) {
+        (msg! as Record<string, unknown>).type = frameMsg.type;
+      }
+      args.logOutboundSummary(entry);
+      args.logOutboxPushOk(
+        buildFileTransferPushOkArgs({
+          entry,
+          connIds: guard.connIds,
+          recentInboundReachable: guard.recentInboundReachable,
+          event: args.pushEvent,
+        }),
+      );
+      return true;
+    } catch (error) {
+      args.handleFileTransferPushFailure({ entry, error });
+      return false;
+    }
+  }
+
+  // ── Text ──
+  const textGuard = resolveTextPushGuard({
+    gatewayContext: args.gatewayContext,
+    entry,
+    routeSelection: selection,
+  });
+  if (!textGuard.ok) {
+    args.recordOutboxPrePushFailure({
+      entry,
+      lastError:
+        textGuard.reason === 'no-gateway-context'
+          ? 'gateway context unavailable'
+          : 'no active bncr client',
+      persist: true,
+    });
+    args.logOutboxPushSkip({
+      messageId: entry.messageId,
+      accountId: entry.accountId,
+      reason: textGuard.reason,
+      recentInboundReachable:
+        textGuard.reason === 'no-active-connection' ? textGuard.recentInboundReachable : undefined,
+      routeReason: selection.routeReason,
+      connIds: selection.connIds,
+      ownerConnId: selection.ownerConnId,
+      ownerClientId: args.owner?.clientId,
+    });
+    return false;
+  }
+
+  // ── Text success path (inline) ──
+  try {
+    args.gatewayBroadcastToConnIds(
+      args.pushEvent,
+      buildTextPushBroadcastPayload({
+        payload: entry.payload,
+        messageId: entry.messageId,
+      }),
+      new Set(textGuard.connIds),
+    );
+    args.logOutboxRouteSelect(
+      buildTextPushRouteSelectArgs({
+        entry,
+        connIds: textGuard.connIds,
+        routeReason: textGuard.routeReason,
+        recentInboundReachable: textGuard.recentInboundReachable,
+        owner: args.owner,
+        event: args.pushEvent,
+      }),
+    );
+    args.recordOutboxPushSuccess(
+      buildTextPushSuccessArgs({
+        entry,
+        connIds: textGuard.connIds,
+        ownerConnId: textGuard.ownerConnId,
+        ownerClientId: textGuard.ownerConnId ? args.owner?.clientId : undefined,
+      }),
+    );
+    args.logOutboxPushOkSummary(entry.messageId);
+    args.logOutboundSummary(entry);
+    args.logOutboxPushOk(
+      buildTextPushOkArgs({
+        entry,
+        connIds: textGuard.connIds,
+        recentInboundReachable: textGuard.recentInboundReachable,
+        event: args.pushEvent,
+      }),
+    );
+    return true;
+  } catch (error) {
+    args.handleTextPushFailure({ entry, error });
+    return false;
+  }
+}

package/src/plugin/scene-registry.ts

@@ -36,7 +36,7 @@ export function buildSceneKey(parsed: ParsedInbound): string {
     : `${parsed.platform}:${parsed.userId}`;
 }
 
-export function buildSceneRecord(args: {
+function buildSceneRecord(args: {
   parsed: ParsedInbound;
   sceneKey: string;
   kind: BncrSceneKind;

package/src/runtime/log-dedupe.ts

@@ -5,10 +5,10 @@ export type LogDedupeStateEntry = {
 
 export type LogDedupeState = Map<string, LogDedupeStateEntry>;
 
-export const LOG_DEDUPE_STATE_TTL_MS = 10 * 60 * 1000;
-export const LOG_DEDUPE_STATE_MAX_ENTRIES = 1_000;
+const LOG_DEDUPE_STATE_TTL_MS = 10 * 60 * 1000;
+const LOG_DEDUPE_STATE_MAX_ENTRIES = 1_000;
 
-export function pruneLogDedupeState(
+function pruneLogDedupeState(
   state: LogDedupeState,
   currentTime: number,
   options?: {

package/src/runtime/outbound-ack-timeout.ts

@@ -42,9 +42,7 @@ function isAdaptiveAckRecovered(args: {
   );
 }
 
-export function computeBncrRecommendedAckTimeoutReason(
-  args: ComputeBncrRecommendedAckTimeoutReasonArgs,
-) {
+function computeBncrRecommendedAckTimeoutReason(args: ComputeBncrRecommendedAckTimeoutReasonArgs) {
   if (args.recentAckTimeoutCount <= 0) return 'no-timeout-evidence';
   if (args.lateAckOkCount <= 0) return 'no-late-ack-evidence';
   if (typeof args.lastLateAckPushLatencyMs !== 'number') return 'missing-latency';
@@ -54,7 +52,7 @@ export function computeBncrRecommendedAckTimeoutReason(
   return 'late-ack-observed';
 }
 
-export function computeBncrRecommendedAckTimeoutMs(args: ComputeBncrRecommendedAckTimeoutArgs) {
+function computeBncrRecommendedAckTimeoutMs(args: ComputeBncrRecommendedAckTimeoutArgs) {
   if (
     args.lateAckOkCount <= 0 ||
     args.recentAckTimeoutCount <= 0 ||

package/src/runtime/status-snapshots.ts

@@ -34,7 +34,7 @@ function getCounter(map: Map<string, number>, accountId: string): number {
   return map.get(normalizeAccountId(accountId)) || 0;
 }
 
-export function buildRuntimeQueueSnapshot(args: {
+function buildRuntimeQueueSnapshot(args: {
   accountId: string;
   outboxEntries: Iterable<OutboxEntry>;
   deadLetterEntries: Iterable<OutboxEntry>;
@@ -59,7 +59,7 @@ export function buildRuntimeQueueSnapshot(args: {
   };
 }
 
-export function buildRuntimeEventCounters(args: {
+function buildRuntimeEventCounters(args: {
   accountId: string;
   connectEventsByAccount: Map<string, number>;
   inboundEventsByAccount: Map<string, number>;

package/src/runtime/status-worker.ts

@@ -49,7 +49,7 @@ export type ChannelAccountWorkerHandle = {
   healthLogState?: HealthStatusLogState;
 };
 
-export const HEALTH_STATUS_STABLE_WINDOW_MS = 10_000;
+const HEALTH_STATUS_STABLE_WINDOW_MS = 10_000;
 
 export type HealthStatusLogState = {
   emittedSig: string | null;
@@ -112,11 +112,7 @@ type StatusWorkerRuntime = {
   hooks: StatusWorkerHooks;
 };
 
-export function clearBncrStatusWorker(
-  runtime: StatusWorkerRuntime,
-  accountId: string,
-  reason: string,
-) {
+function clearBncrStatusWorker(runtime: StatusWorkerRuntime, accountId: string, reason: string) {
   const worker = runtime.workers.get(accountId);
   if (!worker) return false;
   worker.finish(reason);

package/src/core/outbox-text-push-prep.ts

@@ -1 +0,0 @@
-export { prepareRouteSelection as prepareTextPushRouteSelection } from './outbox-file-transfer-prep.ts';

package/src/plugin/bridge-file-transfer-push-facade.ts

@@ -1,142 +0,0 @@
-import {
-  buildFileTransferPushOkArgs,
-  buildFileTransferPushSuccessArgs,
-} from '../core/outbox-file-transfer-bookkeeping.ts';
-import {
-  buildFileTransferBroadcastPayload,
-  buildFileTransferRouteSelectArgs,
-} from '../core/outbox-file-transfer-success.ts';
-import type { BncrConnection, BncrRoute, OutboxEntry } from '../core/types.ts';
-
-export function createBncrBridgeFileTransferPushFacade(runtime: {
-  pushEvent: string;
-  getGatewayContext: () => {
-    broadcastToConnIds: (event: string, payload: unknown, connIds: ReadonlySet<string>) => void;
-  } | null;
-  transferMediaToBncrClient: (params: {
-    accountId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    mediaUrl: string;
-    mediaLocalRoots?: readonly string[];
-    downloadMedia?: boolean;
-  }) => Promise<{
-    mode: 'base64' | 'chunk';
-    mimeType?: string;
-    fileName?: string;
-    base64?: string;
-    path?: string;
-  }>;
-  buildFileTransferOutboundFrame: (params: {
-    entry: OutboxEntry;
-    msg: Record<string, unknown>;
-    media: { fileName?: string; mimeType?: string; path?: string; base64?: string; type?: string };
-    mediaUrl: string;
-  }) => Record<string, unknown>;
-  logOutboxRouteSelect: (args: {
-    messageId: string;
-    accountId: string;
-    kind?: 'file-transfer';
-    routeReason: string;
-    connIds: Iterable<string>;
-    ownerConnId: string;
-    ownerClientId: string;
-    recentInboundReachable: boolean;
-    event: string;
-  }) => void;
-  recordOutboxPushSuccess: (args: {
-    entry: OutboxEntry;
-    connIds: Iterable<string>;
-    ownerConnId?: string;
-    ownerClientId?: string;
-    clearLastError?: boolean;
-  }) => void;
-  logOutboxPushOkSummary: (messageId: string) => void;
-  logOutboxPushOk: (args: {
-    messageId: string;
-    accountId: string;
-    kind?: 'file-transfer';
-    connIds: Iterable<string>;
-    ownerConnId: string;
-    ownerClientId: string;
-    recentInboundReachable: boolean;
-    event: string;
-  }) => void;
-  handleFileTransferPushFailure: (args: { entry: OutboxEntry; error: unknown }) => void;
-  handleFileTransferPushGuardFailure: (args: {
-    entry: OutboxEntry;
-    guard: {
-      reason: 'media-url-missing' | 'no-gateway-context' | 'no-active-connection';
-      lastError: string;
-      recentInboundReachable?: boolean;
-    };
-  }) => void;
-}) {
-  const pushFileTransferSuccessPath = async (args: {
-    entry: OutboxEntry;
-    msg: Record<string, unknown>;
-    owner: BncrConnection | null;
-    connIds: Iterable<string>;
-    recentInboundReachable: boolean;
-    routeReason: string;
-    mediaUrl: string;
-  }): Promise<void> => {
-    const media = await runtime.transferMediaToBncrClient({
-      accountId: args.entry.accountId,
-      sessionKey: args.entry.sessionKey,
-      route: args.entry.route,
-      mediaUrl: args.mediaUrl,
-      mediaLocalRoots: Array.isArray(args.msg.mediaLocalRoots)
-        ? args.msg.mediaLocalRoots.filter((v): v is string => typeof v === 'string')
-        : undefined,
-      downloadMedia: args.msg.downloadMedia as boolean | undefined,
-    });
-    const frame = runtime.buildFileTransferOutboundFrame({
-      entry: args.entry,
-      msg: args.msg,
-      media,
-      mediaUrl: args.mediaUrl,
-    });
-
-    runtime.getGatewayContext()!.broadcastToConnIds(
-      runtime.pushEvent,
-      buildFileTransferBroadcastPayload({
-        frame,
-        messageId: args.entry.messageId,
-      }),
-      new Set(args.connIds),
-    );
-    runtime.logOutboxRouteSelect(
-      buildFileTransferRouteSelectArgs({
-        entry: args.entry,
-        connIds: args.connIds,
-        routeReason: args.routeReason,
-        recentInboundReachable: args.recentInboundReachable,
-        owner: args.owner,
-        event: runtime.pushEvent,
-      }),
-    );
-    runtime.recordOutboxPushSuccess(
-      buildFileTransferPushSuccessArgs({
-        entry: args.entry,
-        connIds: args.connIds,
-        owner: args.owner,
-      }),
-    );
-    runtime.logOutboxPushOkSummary(args.entry.messageId);
-    runtime.logOutboxPushOk(
-      buildFileTransferPushOkArgs({
-        entry: args.entry,
-        connIds: args.connIds,
-        recentInboundReachable: args.recentInboundReachable,
-        event: runtime.pushEvent,
-      }),
-    );
-  };
-
-  return {
-    pushFileTransferSuccessPath,
-    handleFileTransferPushFailure: runtime.handleFileTransferPushFailure,
-    handleFileTransferPushGuardFailure: runtime.handleFileTransferPushGuardFailure,
-  };
-}

package/src/plugin/outbox-file-push-flow.ts

@@ -1,69 +0,0 @@
-import { resolveFileTransferGuard } from '../core/outbox-file-transfer-guards.ts';
-import { prepareRouteSelection } from '../core/outbox-file-transfer-prep.ts';
-import type { BncrConnection, OutboxEntry } from '../core/types.ts';
-import { selectOutboxFileTransferRouteCandidates } from '../messaging/outbound/queue-selectors.ts';
-
-export async function runBncrFileTransferOutboxPush(args: {
-  entry: OutboxEntry;
-  msg: Record<string, unknown>;
-  gatewayContext: unknown;
-  owner: BncrConnection | null;
-  resolvePushConnIds: (accountId: string) => Set<string>;
-  resolveRecentInboundConnIds: (accountId: string) => Set<string>;
-  hasRecentInboundReachability: (accountId: string) => boolean;
-  isRevalidatedAttemptedConn: (connId: string) => boolean;
-  handleFileTransferPushGuardFailure: (args: {
-    entry: OutboxEntry;
-    guard: Exclude<ReturnType<typeof resolveFileTransferGuard>, { ok: true }>;
-  }) => void;
-  pushFileTransferSuccessPath: (args: {
-    entry: OutboxEntry;
-    msg: Record<string, unknown>;
-    owner: BncrConnection | null;
-    connIds: Iterable<string>;
-    recentInboundReachable: boolean;
-    routeReason: string;
-    mediaUrl: string;
-  }) => Promise<void>;
-  handleFileTransferPushFailure: (args: { entry: OutboxEntry; error: unknown }) => void;
-}) {
-  const selection = prepareRouteSelection({
-    entry: args.entry,
-    owner: args.owner,
-    resolvePushConnIds: args.resolvePushConnIds,
-    resolveRecentInboundConnIds: args.resolveRecentInboundConnIds,
-    hasRecentInboundReachability: args.hasRecentInboundReachability,
-    isRevalidatedAttemptedConn: args.isRevalidatedAttemptedConn,
-    selectRouteCandidates: selectOutboxFileTransferRouteCandidates,
-  });
-  const guard = resolveFileTransferGuard({
-    gatewayContext: args.gatewayContext,
-    entry: args.entry,
-    owner: args.owner,
-    routeSelection: selection,
-    mediaUrl: String(args.msg.mediaUrl || '').trim(),
-  });
-  if (!guard.ok) {
-    args.handleFileTransferPushGuardFailure({
-      entry: args.entry,
-      guard,
-    });
-    return false;
-  }
-
-  try {
-    await args.pushFileTransferSuccessPath({
-      entry: args.entry,
-      msg: args.msg,
-      owner: args.owner,
-      connIds: guard.connIds,
-      recentInboundReachable: guard.recentInboundReachable,
-      routeReason: guard.routeReason,
-      mediaUrl: guard.mediaUrl,
-    });
-    return true;
-  } catch (error) {
-    args.handleFileTransferPushFailure({ entry: args.entry, error });
-    return false;
-  }
-}

package/src/plugin/outbox-text-push-flow.ts

@@ -1,90 +0,0 @@
-import { resolveTextPushGuard } from '../core/outbox-text-push-guards.ts';
-import { prepareTextPushRouteSelection } from '../core/outbox-text-push-prep.ts';
-import type { BncrConnection, OutboxEntry } from '../core/types.ts';
-import { selectOutboxRouteCandidates } from '../messaging/outbound/queue-selectors.ts';
-
-export async function runBncrTextOutboxPush(args: {
-  entry: OutboxEntry;
-  gatewayContext: unknown;
-  owner: BncrConnection | null;
-  resolvePushConnIds: (accountId: string) => Set<string>;
-  resolveRecentInboundConnIds: (accountId: string) => Set<string>;
-  hasRecentInboundReachability: (accountId: string) => boolean;
-  isRevalidatedAttemptedConn: (connId: string) => boolean;
-  recordOutboxPrePushFailure: (args: {
-    entry: OutboxEntry;
-    lastError: string;
-    persist?: boolean;
-  }) => void;
-  logOutboxPushSkip: (args: {
-    messageId: string;
-    accountId: string;
-    reason: string;
-    recentInboundReachable?: boolean;
-    routeReason?: string;
-    connIds?: Iterable<string>;
-    ownerConnId?: string;
-    ownerClientId?: string;
-  }) => void;
-  pushTextSuccessPath: (args: {
-    entry: OutboxEntry;
-    owner: BncrConnection | null;
-    connIds: Iterable<string>;
-    recentInboundReachable: boolean;
-    routeReason: string;
-    ownerConnId?: string;
-  }) => void;
-  handleTextPushFailure: (args: { entry: OutboxEntry; error: unknown }) => void;
-}) {
-  const selection = prepareTextPushRouteSelection({
-    entry: args.entry,
-    owner: args.owner,
-    resolvePushConnIds: args.resolvePushConnIds,
-    resolveRecentInboundConnIds: args.resolveRecentInboundConnIds,
-    hasRecentInboundReachability: args.hasRecentInboundReachability,
-    isRevalidatedAttemptedConn: args.isRevalidatedAttemptedConn,
-    selectRouteCandidates: selectOutboxRouteCandidates,
-  });
-  const guard = resolveTextPushGuard({
-    gatewayContext: args.gatewayContext,
-    entry: args.entry,
-    routeSelection: selection,
-  });
-  if (!guard.ok) {
-    args.recordOutboxPrePushFailure({
-      entry: args.entry,
-      lastError:
-        guard.reason === 'no-gateway-context'
-          ? 'gateway context unavailable'
-          : 'no active bncr client',
-      persist: true,
-    });
-    args.logOutboxPushSkip({
-      messageId: args.entry.messageId,
-      accountId: args.entry.accountId,
-      reason: guard.reason,
-      recentInboundReachable:
-        guard.reason === 'no-active-connection' ? guard.recentInboundReachable : undefined,
-      routeReason: selection.routeReason,
-      connIds: selection.connIds,
-      ownerConnId: selection.ownerConnId,
-      ownerClientId: args.owner?.clientId,
-    });
-    return false;
-  }
-
-  try {
-    args.pushTextSuccessPath({
-      entry: args.entry,
-      owner: args.owner,
-      connIds: guard.connIds,
-      recentInboundReachable: guard.recentInboundReachable,
-      routeReason: guard.routeReason,
-      ownerConnId: guard.ownerConnId,
-    });
-    return true;
-  } catch (error) {
-    args.handleTextPushFailure({ entry: args.entry, error });
-    return false;
-  }
-}