@xmoxmo/bncr 0.5.7 → 0.5.8

package/src/plugin/file-transfer-orchestrator.ts

@@ -193,7 +193,38 @@ export function createBncrFileTransferOrchestrator(runtime: BncrFileTransferOrch
   };
   const HTTP_URL_RE = /^https?:\/\//i;
 
-  /** Try HEAD for Content-Type; fall back to Range+sniff for magic bytes when unclear. */
+  const EXT_TO_MIME: Record<string, string> = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    bmp: 'image/bmp',
+    heic: 'image/heic',
+    heif: 'image/heif',
+    mp4: 'video/mp4',
+    mov: 'video/quicktime',
+    mkv: 'video/x-matroska',
+    webm: 'video/webm',
+    avi: 'video/x-msvideo',
+    m4v: 'video/x-m4v',
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    ogg: 'audio/ogg',
+    oga: 'audio/ogg',
+    opus: 'audio/opus',
+    m4a: 'audio/mp4',
+    aac: 'audio/aac',
+    flac: 'audio/flac',
+  };
+
+  function mimeFromUrlExt(url: string): string | undefined {
+    const clean = url.split(/[?#]/, 1)[0] || '';
+    const ext = clean.includes('.') ? clean.slice(clean.lastIndexOf('.') + 1).toLowerCase() : '';
+    return EXT_TO_MIME[ext];
+  }
+
+  /** Try HEAD for Content-Type; fall back to Range+sniff for magic bytes; then URL extension. */
   async function resolveRemoteMediaType(url: string): Promise<{ mimeType?: string }> {
     // 1) HEAD -> Content-Type
     let headerType = '';
@@ -229,8 +260,14 @@ export function createBncrFileTransferOrchestrator(runtime: BncrFileTransferOrch
       if (!sniffed) return {};
       return { mimeType: sniffed };
     } catch {
-      return {};
+      /* Range sniff failed, fall through to extension inference */
     }
+
+    // 3) URL extension -> mime type (fallback when HEAD and Range both fail)
+    const extMime = mimeFromUrlExt(url);
+    if (extMime) return { mimeType: extMime };
+
+    return {};
   }
 
   /** Minimal magic-byte MIME sniffer for the first ~512 bytes. */

package/src/plugin/media-orchestrators-runtime-group.ts

@@ -1,21 +1,13 @@
 import type { BncrRoute, FileSendTransferState, OutboxEntry } from '../core/types.ts';
-import { normalizeMessageText } from '../messaging/outbound/media-dedupe.ts';
 import type {
   NormalizedReplyPayload,
   OutboundReplyTargetPolicy,
-  ReplyMediaEntriesParams,
   ReplyPayloadInput,
 } from '../messaging/outbound/reply-enqueue.ts';
 import {
   enqueueNormalizedReplyPayload,
-  enqueueReplyTextEntry,
   normalizeReplyPayload,
 } from '../messaging/outbound/reply-enqueue.ts';
-import {
-  enqueueReplyMediaFallbackTextEntry,
-  enqueueReplyMediaFileTransferEntry,
-  enqueueSingleReplyMediaEntry,
-} from '../messaging/outbound/reply-enqueue-media.ts';
 import type { createBncrFileAckRuntime } from './file-ack-runtime.ts';
 import { createBncrFileTransferOrchestrator } from './file-transfer-orchestrator.ts';
 import type { createBncrFileTransferSetup } from './file-transfer-setup.ts';
@@ -27,92 +19,12 @@ type FileAckPayload = Awaited<
   ReturnType<ReturnType<typeof createBncrFileAckRuntime>['waitForFileAck']>
 >;
 
-function buildReplyMediaEntryHelpers(runtime: {
-  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
-  enqueueOutbound: (entry: OutboxEntry) => void;
-  buildTextOutboxEntry: (args: {
-    accountId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    text: string;
-    kind?: 'tool' | 'block' | 'final';
-    replyToId?: string;
-    replyTargetPolicy?: OutboundReplyTargetPolicy;
-  }) => OutboxEntry;
-  buildFileTransferOutboxEntry: (args: {
-    accountId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    mediaUrl: string;
-    mediaLocalRoots?: readonly string[];
-    text: string;
-    asVoice: boolean;
-    audioAsVoice: boolean;
-    type?: string;
-    extra?: Record<string, unknown>;
-    kind?: 'tool' | 'block' | 'final';
-    replyToId?: string;
-    replyTargetPolicy?: OutboundReplyTargetPolicy;
-    downloadMedia?: boolean;
-  }) => OutboxEntry;
-  rememberRecentMediaSend: (args: {
-    sessionKey: string;
-    mediaUrl: string;
-    text: string;
-    replyToId: string;
-    createdAt: number;
-  }) => void;
-}) {
-  return {
-    enqueueReplyMediaFallbackTextEntry: (
-      params: Parameters<typeof enqueueReplyMediaFallbackTextEntry>[0],
-    ) =>
-      enqueueReplyMediaFallbackTextEntry(params, {
-        logInfo: runtime.logInfo,
-        enqueueOutbound: runtime.enqueueOutbound,
-        buildTextOutboxEntry: runtime.buildTextOutboxEntry,
-      }),
-    enqueueReplyMediaFileTransferEntry: (
-      params: Parameters<typeof enqueueReplyMediaFileTransferEntry>[0],
-    ) =>
-      enqueueReplyMediaFileTransferEntry(params, {
-        enqueueOutbound: runtime.enqueueOutbound,
-        buildFileTransferOutboxEntry: runtime.buildFileTransferOutboxEntry,
-        rememberRecentMediaSend: runtime.rememberRecentMediaSend,
-      }),
-  };
-}
-
-function buildReplyTextEntryHelper(runtime: {
-  enqueueOutbound: (entry: OutboxEntry) => void;
-  buildTextOutboxEntry: (args: {
-    accountId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    text: string;
-    kind?: 'tool' | 'block' | 'final';
-    replyToId?: string;
-    replyTargetPolicy?: OutboundReplyTargetPolicy;
-  }) => OutboxEntry;
-}) {
-  return (params: {
-    accountId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    payload: NormalizedReplyPayload;
-  }) =>
-    enqueueReplyTextEntry(params, {
-      enqueueOutbound: runtime.enqueueOutbound,
-      buildTextOutboxEntry: runtime.buildTextOutboxEntry,
-    });
-}
-
-function normalizeReplyOrchestratorPayload(args: {
+async function normalizeReplyOrchestratorPayload(args: {
   payload: ReplyPayloadInput;
   asString: (value: unknown, fallback?: string) => string;
   replyTargetPolicy?: OutboundReplyTargetPolicy;
 }) {
-  return normalizeReplyPayload(
+  return await normalizeReplyPayload(
     args.payload,
     { asString: args.asString },
     {
@@ -186,29 +98,21 @@ export function createBncrMediaOrchestratorsRuntimeGroup(runtime: {
     payload: NormalizedReplyPayload;
   }) => void;
   enqueueOutbound: (entry: OutboxEntry) => void;
-  buildTextOutboxEntry: (args: {
+  buildOutboxEntry: (args: {
     accountId: string;
     sessionKey: string;
     route: BncrRoute;
-    text: string;
-    kind?: 'tool' | 'block' | 'final';
-    replyToId?: string;
-    replyTargetPolicy?: OutboundReplyTargetPolicy;
-  }) => OutboxEntry;
-  buildFileTransferOutboxEntry: (args: {
-    accountId: string;
-    sessionKey: string;
-    route: BncrRoute;
-    mediaUrl: string;
-    mediaLocalRoots?: readonly string[];
-    text: string;
-    asVoice: boolean;
-    audioAsVoice: boolean;
     type?: string;
-    extra?: Record<string, unknown>;
+    msg: string;
     kind?: 'tool' | 'block' | 'final';
     replyToId?: string;
     replyTargetPolicy?: OutboundReplyTargetPolicy;
+    extra?: Record<string, unknown>;
+    transferMode?: 'text' | 'media';
+    mediaUrl?: string;
+    mediaLocalRoots?: readonly string[];
+    asVoice?: boolean;
+    audioAsVoice?: boolean;
     downloadMedia?: boolean;
   }) => OutboxEntry;
   rememberRecentMediaSend: (args: {
@@ -244,40 +148,7 @@ export function createBncrMediaOrchestratorsRuntimeGroup(runtime: {
     logFileTransferCompleteAck: runtime.logFileTransferCompleteAck,
   });
 
-  const replyMediaEntryHelpers = buildReplyMediaEntryHelpers(runtime);
-  const replyTextEntryHelper = buildReplyTextEntryHelper(runtime);
-
-  const enqueueReplyMediaEntries = (params: ReplyMediaEntriesParams) => {
-    let first = true;
-    const currentTime = runtime.now();
-
-    for (const mediaUrl of params.payload.mediaList) {
-      const normalizedText = normalizeMessageText(first ? params.payload.text : '');
-      const fallback = runtime.tryBuildMediaDedupeFallback({
-        sessionKey: params.sessionKey,
-        mediaUrl,
-        text: normalizedText,
-        replyToId: params.payload.replyToId,
-        currentTime,
-      });
-
-      enqueueSingleReplyMediaEntry(
-        {
-          params,
-          mediaUrl,
-          normalizedText,
-          text: first ? params.payload.text : '',
-          fallback,
-          currentTime,
-        },
-        replyMediaEntryHelpers,
-      );
-
-      first = false;
-    }
-  };
-
-  const enqueueFromReply = (params: {
+  const enqueueFromReply = async (params: {
     accountId: string;
     sessionKey: string;
     route: BncrRoute;
@@ -286,7 +157,7 @@ export function createBncrMediaOrchestratorsRuntimeGroup(runtime: {
     replyTargetPolicy?: OutboundReplyTargetPolicy;
   }) => {
     const { accountId, sessionKey, route, payload, mediaLocalRoots, replyTargetPolicy } = params;
-    const normalized = normalizeReplyOrchestratorPayload({
+    const normalized = await normalizeReplyOrchestratorPayload({
       payload,
       asString: runtime.asString,
       replyTargetPolicy,
@@ -302,19 +173,19 @@ export function createBncrMediaOrchestratorsRuntimeGroup(runtime: {
       },
       {
         logEnqueueFromReply: runtime.logEnqueueFromReply,
-        enqueueReplyMediaEntries,
-        enqueueReplyTextEntry: replyTextEntryHelper,
+        enqueueOutbound: runtime.enqueueOutbound,
+        buildOutboxEntry: runtime.buildOutboxEntry,
+        tryBuildMediaDedupeFallback: runtime.tryBuildMediaDedupeFallback,
+        rememberRecentMediaSend: runtime.rememberRecentMediaSend,
+        logInfo: runtime.logInfo,
       },
     );
   };
 
-  const replyMediaOrchestrator = {
-    enqueueFromReply,
-    enqueueReplyMediaEntries,
-  };
-
   return {
     fileTransferOrchestrator,
-    replyMediaOrchestrator,
+    replyMediaOrchestrator: {
+      enqueueFromReply,
+    },
   };
 }

package/src/plugin/messaging.ts

@@ -67,12 +67,12 @@ function isDisplayTarget(
   return Boolean(value && typeof value === 'object');
 }
 
-export function normalizeBncrMessagingTarget(raw: string) {
+function normalizeBncrMessagingTarget(raw: string) {
   const input = asSanitizedString(raw).trim();
   return input || undefined;
 }
 
-export function formatBncrMessagingTargetDisplay({ target }: BncrMessagingTargetDisplayInput) {
+function formatBncrMessagingTargetDisplay({ target }: BncrMessagingTargetDisplayInput) {
   if (typeof target === 'string') {
     const parsed = parseExplicitTarget(asSanitizedString(target).trim());
     return parsed?.route ? formatBncrHumanDisplay(parsed.route) : asSanitizedString(target).trim();
@@ -183,7 +183,7 @@ export function createBncrMessagingSurface(getBridge: () => BncrMessagingRuntime
   };
 }
 
-export function createBncrMessagingTargetResolver(getBridge: () => BncrMessagingRuntimeBridge) {
+function createBncrMessagingTargetResolver(getBridge: () => BncrMessagingRuntimeBridge) {
   return {
     looksLikeId: (raw: string, normalized?: string) => {
       return looksLikeBncrExplicitTarget(asSanitizedString(normalized || raw).trim());

package/src/plugin/outbox-push.ts

@@ -3,12 +3,7 @@ import {
   resolveFileTransferFailureState,
 } from '../core/outbox-file-transfer-failure.ts';
 import { buildTextPushFailureArgs } from '../core/outbox-text-push-failure.ts';
-import {
-  buildTextPushBroadcastPayload,
-  buildTextPushOkArgs,
-  buildTextPushRouteSelectArgs,
-  buildTextPushSuccessArgs,
-} from '../core/outbox-text-push-success.ts';
+
 import type { BncrConnection, OutboxEntry } from '../core/types.ts';
 import {
   buildOutboxPushOkDebugInfo,
@@ -137,51 +132,6 @@ export function createBncrOutboxPush(runtime: BncrOutboxPushRuntime) {
     );
   };
 
-  const pushTextSuccessPath = (args: {
-    entry: OutboxEntry;
-    owner: BncrConnection | null;
-    connIds: Iterable<string>;
-    recentInboundReachable: boolean;
-    routeReason: string;
-    ownerConnId?: string;
-  }) => {
-    runtime.gatewayBroadcastToConnIds(
-      runtime.pushEvent,
-      buildTextPushBroadcastPayload({
-        payload: args.entry.payload,
-        messageId: args.entry.messageId,
-      }),
-      new Set(args.connIds),
-    );
-    logOutboxRouteSelect(
-      buildTextPushRouteSelectArgs({
-        entry: args.entry,
-        connIds: args.connIds,
-        routeReason: args.routeReason,
-        recentInboundReachable: args.recentInboundReachable,
-        owner: args.owner,
-        event: runtime.pushEvent,
-      }),
-    );
-    runtime.recordOutboxPushSuccess(
-      buildTextPushSuccessArgs({
-        entry: args.entry,
-        connIds: args.connIds,
-        ownerConnId: args.ownerConnId,
-        ownerClientId: args.ownerConnId ? args.owner?.clientId : undefined,
-      }),
-    );
-    logOutboxPushOkSummary(args.entry.messageId);
-    logOutboxPushOk(
-      buildTextPushOkArgs({
-        entry: args.entry,
-        connIds: args.connIds,
-        recentInboundReachable: args.recentInboundReachable,
-        event: runtime.pushEvent,
-      }),
-    );
-  };
-
   const handleTextPushFailure = (args: { entry: OutboxEntry; error: unknown }) => {
     runtime.recordOutboxPushFailure({
       entry: args.entry,
@@ -253,7 +203,6 @@ export function createBncrOutboxPush(runtime: BncrOutboxPushRuntime) {
   };
 
   return {
-    pushTextSuccessPath,
     handleTextPushFailure,
     handleFileTransferPushFailure,
     handleFileTransferPushGuardFailure,

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;