@xmoxmo/bncr 0.5.6 → 0.5.7

package/src/plugin/channel-send.ts

@@ -3,13 +3,38 @@ import { normalizeAccountId } from '../core/accounts.ts';
 import { buildBncrDebugJsonMessage } from '../core/logging.ts';
 import type { BncrRoute, OutboxEntry } from '../core/types.ts';
 import { buildBncrDurableQueuedResult } from '../messaging/outbound/durable-queue-adapter.ts';
-import { extractConsumptionFields, parseBncrMarker } from '../messaging/outbound/marker-parser.ts';
+
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
-import { sendBncrMedia, sendBncrText } from '../messaging/outbound/send.ts';
 import type { BncrChannelSendContext, BncrVerifiedTarget } from './channel-runtime-types.ts';
 
-function normalizeReplyKind(value: unknown): ReplyPayloadInput['kind'] {
-  return value === 'tool' || value === 'block' || value === 'final' ? value : undefined;
+/**
+ * Resolve downloadMedia with cascade: override (host/user) > ctx > scene.
+ * Marker-level downloadMedia is extracted downstream by the orchestrator's
+ * normalisation and has highest priority (overrides whatever we pass).
+ */
+
+/** Override fields shared by sendDispatch and messageSendDispatch. */
+type ChannelSendOverrideFields = {
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: unknown;
+  asVoice?: boolean;
+  audioAsVoice?: boolean;
+  downloadMedia?: boolean;
+  type?: string;
+  kind?: string;
+  replyToId?: string;
+};
+
+function resolveDownloadMedia(
+  to: string,
+  overrideValue: boolean | undefined,
+  ctxValue: boolean | undefined,
+  runtime: BncrChannelSendRuntime,
+): boolean | undefined {
+  if (overrideValue !== undefined) return overrideValue;
+  if (ctxValue !== undefined) return ctxValue;
+  return runtime.resolveSceneDownloadMedia?.(to);
 }
 
 export type BncrChannelSendRuntime = {
@@ -27,106 +52,15 @@ export type BncrChannelSendRuntime = {
     mediaLocalRoots?: readonly string[];
   }) => Promise<void>;
   listOutboxEntries: () => OutboxEntry[];
+  /** Resolve downloadMedia from scene config: marker > scene > global > default(false). */
+  resolveSceneDownloadMedia?: (to: string) => boolean | undefined;
 };
 
-/**
- * Merge all extra sources (ctx.extra, marker params, host-level fields)
- * into a single extra bag. Strips consumption fields and returns them
- * as independent params, remaining extra passes through the pipeline.
- */
-function resolveUnifiedOutboundExtra(ctx: BncrChannelSendContext): {
-  cleanText: string;
-  extra: Record<string, unknown>;
-  consumed: {
-    asVoice?: boolean;
-    audioAsVoice?: boolean;
-    downloadMedia?: boolean;
-    type?: string;
-    kind?: string;
-    replyToId?: string;
-  };
-} {
-  // 1. Parse marker from text
-  const { cleanText, params: markerParams } = parseBncrMarker(
-    typeof ctx.text === 'string' ? ctx.text : '',
-  );
-
-  // 2. Merge all sources: extra from ctx + marker params + host-level fields
-  const merged: Record<string, unknown> = {
-    ...(typeof ctx.extra === 'object' && ctx.extra !== null ? ctx.extra : {}),
-    ...markerParams,
-  };
-  if (ctx.forceDocument === true) merged.forceDocument = true;
-  if (ctx.gifPlayback === true) merged.gifPlayback = true;
-  if (ctx.silent === true) merged.silent = true;
-
-  // 3. Strip consumption fields
-  const { consumed, remaining } = extractConsumptionFields(merged);
-
-  return {
-    cleanText,
-    extra: remaining,
-    consumed,
-  };
-}
-
-function resolveChannelSendReplyToId(
-  asString: BncrChannelSendRuntime['asString'],
-  ctx: BncrChannelSendContext,
-) {
-  return asString(ctx?.replyToId || ctx?.replyToMessageId || '').trim() || undefined;
-}
-
-function logChannelSendEntry(
-  runtime: BncrChannelSendRuntime,
-  args: {
-    kind: 'text' | 'media';
-    accountId: string;
-    to: string;
-    ctx: BncrChannelSendContext;
-    payload: {
-      text: string;
-      mediaUrl: string;
-      mediaUrls?: string[];
-      asVoice?: boolean;
-      audioAsVoice?: boolean;
-      downloadMedia?: boolean;
-    };
-  },
-) {
-  runtime.logInfo(
-    'outbound',
-    buildBncrDebugJsonMessage(`send-entry:${args.kind}`, {
-      accountId: args.accountId,
-      to: args.to,
-      text: args.payload.text,
-      mediaUrl: args.payload.mediaUrl,
-      mediaUrls: args.payload.mediaUrls,
-      asVoice: args.payload.asVoice,
-      audioAsVoice: args.payload.audioAsVoice,
-      downloadMedia: args.payload.downloadMedia,
-      sessionKey: runtime.asString(args.ctx?.sessionKey || ''),
-      mirrorSessionKey: runtime.asString(args.ctx?.mirror?.sessionKey || ''),
-      rawCtx: {
-        to: args.ctx?.to,
-        accountId: args.ctx?.accountId,
-        threadId: args.ctx?.threadId,
-        replyToId: args.ctx?.replyToId,
-      },
-    }),
-    { debugOnly: true },
-  );
-}
-
 async function enqueueChannelMessageHandoff(
   runtime: BncrChannelSendRuntime,
   ctx: BncrChannelSendContext,
   payload: ReplyPayloadInput,
-  extra?: Record<string, unknown>,
 ) {
-  if (extra && Object.keys(extra).length > 0) {
-    payload = { ...payload, extra: { ...extra } };
-  }
   const accountId = normalizeAccountId(ctx.accountId);
   const to = runtime.asString(ctx.to || '').trim();
   const verified = runtime.resolveVerifiedTarget(to, accountId);
@@ -146,180 +80,230 @@ async function enqueueChannelMessageHandoff(
   return entries[entries.length - 1];
 }
 
+/**
+ * Resolve downloadMedia from scene config when not already set by marker/host.
+ * Scene cascade: marker > scene config > global > default(false).
+ */
+
 export function createBncrChannelSendRuntime(runtime: BncrChannelSendRuntime) {
-  /**
-   * Single dispatch: resolves unified extra (marker + ctx + host fields),
-   * determines text vs media route, and calls the appropriate send function.
-   */
-  async function sendDispatch(ctx: BncrChannelSendContext) {
-    await runtime.syncDebugFlag();
-    const accountId = normalizeAccountId(ctx.accountId);
+  /** Extract media-related override fields from a channel send context. */
+  function mediaOverrides(ctx: BncrChannelSendContext) {
+    return {
+      mediaUrl: runtime.asString(ctx.mediaUrl || ''),
+      mediaUrls: ctx.mediaUrls,
+      asVoice: ctx.asVoice === true,
+      audioAsVoice: ctx.audioAsVoice === true,
+      type: runtime.asString(ctx.type || '').trim() || undefined,
+    };
+  }
+
+  function extractSendFields(
+    ctx: BncrChannelSendContext,
+    overrides?: ChannelSendOverrideFields,
+  ): {
+    accountId: string;
+    to: string;
+    text: string;
+    mediaUrl: string;
+    mediaUrls: unknown;
+    asVoice: boolean;
+    audioAsVoice: boolean;
+    type: string | undefined;
+    kind: unknown;
+    replyToId: string | undefined;
+    extra: Record<string, unknown> | undefined;
+    downloadMedia: boolean | undefined;
+  } {
     const to = runtime.asString(ctx.to || '').trim();
-    const { cleanText, extra, consumed } = resolveUnifiedOutboundExtra(ctx);
-    const replyToId = resolveChannelSendReplyToId(runtime.asString, ctx);
 
-    // Resolve effective media params: ctx.mediaUrl is the source of truth.
-    // extra.path/mediaUrl from marker only triggers media when:
-    //   - it is a local file path (starts with / or ./), OR
-    //   - consumed.type is a known media type (file/image/video/audio)
-    // Otherwise they are treated as metadata (e.g. appmsg thumbnail URL).
-    const ctxMediaUrl = runtime.asString(ctx.mediaUrl || '').trim();
-    const markerPath = runtime
-      .asString((extra.path as string) || (extra.mediaUrl as string) || '')
-      .trim();
-    const isLocalPath =
-      markerPath.startsWith('/') || markerPath.startsWith('./') || markerPath.startsWith('../');
-    const isMediaType = ['file', 'image', 'video', 'audio'].includes(consumed.type || '');
-    const effectiveMediaUrl = ctxMediaUrl || (isLocalPath || isMediaType ? markerPath : '');
-    const effectiveMediaUrls = Array.isArray(ctx?.mediaUrls) ? ctx.mediaUrls : undefined;
-    const asVoice = consumed.asVoice ?? ctx?.asVoice === true;
-    const audioAsVoice = consumed.audioAsVoice ?? ctx?.audioAsVoice === true;
-    const downloadMedia = consumed.downloadMedia ?? ctx?.downloadMedia ?? false;
-    const type = consumed.type ?? (runtime.asString(ctx?.type || '').trim() || undefined);
-    const hasMedia = !!(effectiveMediaUrl || effectiveMediaUrls?.length);
-    console.log(
-      '[bncr] send-dispatch cleanText=' +
-        JSON.stringify(cleanText) +
-        '|downloadMedia=' +
-        JSON.stringify(consumed.downloadMedia) +
-        '|hasMedia=' +
-        hasMedia +
-        '|mediaUrl=' +
-        JSON.stringify(effectiveMediaUrl),
+    // Extract fields from context / overrides WITHOUT normalising markers.
+    // Raw text (with markers) is passed downstream; the orchestrator handles
+    // all normalisation including marker parsing, pre-send, and media routing.
+    const text = overrides?.text !== undefined ? overrides.text : runtime.asString(ctx.text || '');
+    const mediaUrl =
+      overrides?.mediaUrl !== undefined ? overrides.mediaUrl : runtime.asString(ctx.mediaUrl || '');
+    const mediaUrls = overrides?.mediaUrls !== undefined ? overrides.mediaUrls : ctx.mediaUrls;
+    const asVoice = overrides?.asVoice ?? ctx.asVoice === true;
+    const audioAsVoice = overrides?.audioAsVoice ?? ctx.audioAsVoice === true;
+    const type =
+      overrides?.type !== undefined
+        ? overrides.type
+        : runtime.asString(ctx.type || '').trim() || undefined;
+    const kind = overrides?.kind ?? ctx.kind;
+    const replyToId =
+      (overrides?.replyToId ??
+        runtime.asString(ctx.replyToId || ctx.replyToMessageId || '').trim()) ||
+      undefined;
+    const extra =
+      typeof ctx.extra === 'object' && ctx.extra !== null ? { ...ctx.extra } : undefined;
+    const downloadMedia = resolveDownloadMedia(
+      to,
+      overrides?.downloadMedia,
+      ctx.downloadMedia,
+      runtime,
     );
 
-    const kind: 'text' | 'media' = hasMedia ? 'media' : 'text';
-    logChannelSendEntry(runtime, {
+    return {
+      accountId: normalizeAccountId(ctx.accountId),
+      to,
+      text: text,
+      mediaUrl: mediaUrl,
+      mediaUrls,
+      asVoice,
+      audioAsVoice,
+      type,
       kind,
+      replyToId,
+      extra,
+      downloadMedia,
+    };
+  }
+
+  /**
+   * Single dispatch path for channelSendText / channelSendMedia.
+   * Both normalize first then branch media vs text via hasMedia.
+   * channelSendMedia passes mediaOverrides(ctx) to ensure media routing,
+   * channelSendText passes no overrides and relies on ctx content alone.
+   */
+  async function sendDispatch(
+    ctx: BncrChannelSendContext,
+    overrides?: {
+      text?: string;
+      mediaUrl?: string;
+      mediaUrls?: unknown;
+      asVoice?: boolean;
+      audioAsVoice?: boolean;
+      downloadMedia?: boolean;
+      type?: string;
+      kind?: string;
+      replyToId?: string;
+    },
+  ) {
+    await runtime.syncDebugFlag();
+    const {
       accountId,
       to,
-      ctx,
-      payload: {
-        text: cleanText,
-        mediaUrl: effectiveMediaUrl,
-        mediaUrls: effectiveMediaUrls,
-        asVoice,
-        audioAsVoice,
-      },
-    });
+      text,
+      mediaUrl,
+      mediaUrls,
+      asVoice,
+      audioAsVoice,
+      type,
+      kind,
+      replyToId,
+      extra,
+      downloadMedia,
+    } = extractSendFields(ctx, overrides);
 
-    if (hasMedia) {
-      return sendBncrMedia({
-        channelId: runtime.channelId,
+    runtime.logInfo(
+      'outbound',
+      buildBncrDebugJsonMessage('send-raw', {
         accountId,
         to,
-        text: cleanText,
-        mediaUrl: effectiveMediaUrl,
-        mediaUrls: effectiveMediaUrls,
-        asVoice,
-        audioAsVoice,
+        textLen: text.length,
+        hasMedia: Boolean(mediaUrl || (Array.isArray(mediaUrls) && mediaUrls.length)),
         downloadMedia,
-        type,
-        extra: Object.keys(extra).length > 0 ? extra : undefined,
-        kind: normalizeReplyKind(ctx?.kind),
-        replyToId,
-        mediaLocalRoots: ctx.mediaLocalRoots,
-        resolveVerifiedTarget: (...a) => runtime.resolveVerifiedTarget(...a),
-        rememberSessionRoute: (...a) => runtime.rememberSessionRoute(...a),
-        enqueueFromReply: (a) => runtime.enqueueFromReply(a),
-        createMessageId: () => randomUUID(),
-      });
-    }
+      }),
+      { debugOnly: true },
+    );
+
+    const verified = runtime.resolveVerifiedTarget(to, accountId);
+    runtime.rememberSessionRoute(verified.sessionKey, accountId, verified.route);
 
-    return sendBncrText({
-      channelId: runtime.channelId,
+    await runtime.enqueueFromReply({
       accountId,
-      to,
-      text: cleanText,
-      kind: normalizeReplyKind(ctx?.kind),
-      replyToId,
-      extra: Object.keys(extra).length > 0 ? extra : undefined,
+      sessionKey: verified.sessionKey,
+      route: verified.route,
+      payload: {
+        text: text,
+        mediaUrl: mediaUrl || undefined,
+        mediaUrls: Array.isArray(mediaUrls) && mediaUrls.length ? mediaUrls : undefined,
+        asVoice: asVoice || undefined,
+        audioAsVoice: audioAsVoice || undefined,
+        downloadMedia,
+        type,
+        extra,
+        kind: kind as 'tool' | 'block' | 'final' | undefined,
+        replyToId,
+      },
       mediaLocalRoots: ctx.mediaLocalRoots,
-      resolveVerifiedTarget: (...a) => runtime.resolveVerifiedTarget(...a),
-      rememberSessionRoute: (...a) => runtime.rememberSessionRoute(...a),
-      enqueueFromReply: (a) => runtime.enqueueFromReply(a),
-      createMessageId: () => randomUUID(),
     });
+
+    return {
+      channel: runtime.channelId,
+      messageId: randomUUID(),
+      chatId: verified.sessionKey,
+    };
   }
 
   /**
-   * Durable dispatch: same logic but enqueues via channel message handoff.
+   * Durable channel.message path: same normalize, then enqueue handoff.
    */
   async function messageSendDispatch(
     ctx: BncrChannelSendContext,
-    inputOverrides?: {
+    overrides?: {
       text?: string;
       mediaUrl?: string;
-      mediaUrls?: string[];
+      mediaUrls?: unknown;
       asVoice?: boolean;
       audioAsVoice?: boolean;
       downloadMedia?: boolean;
       type?: string;
-      kind?: ReplyPayloadInput['kind'];
+      kind?: string;
       replyToId?: string;
     },
   ) {
-    // Merge inputOverrides text into ctx so marker parsing sees the effective text
-    const effectiveCtx =
-      inputOverrides?.text !== undefined ? { ...ctx, text: inputOverrides.text } : ctx;
-    const { cleanText, extra, consumed } = resolveUnifiedOutboundExtra(effectiveCtx);
-    const replyToId = resolveChannelSendReplyToId(runtime.asString, ctx);
-
-    console.log(
-      '[bncr] msg-dispatch cleanText=' +
-        JSON.stringify(cleanText) +
-        '|downloadMedia=' +
-        JSON.stringify(consumed.downloadMedia) +
-        '|mediaUrl=' +
-        JSON.stringify(inputOverrides?.mediaUrl),
-    );
+    const {
+      text,
+      mediaUrl,
+      mediaUrls,
+      asVoice,
+      audioAsVoice,
+      type,
+      kind,
+      replyToId,
+      extra,
+      downloadMedia,
+    } = extractSendFields(ctx, overrides);
 
-    const payload: ReplyPayloadInput = {
-      text: cleanText,
-      mediaUrl: inputOverrides?.mediaUrl || '',
-      mediaUrls: inputOverrides?.mediaUrls,
-      asVoice: consumed.asVoice ?? inputOverrides?.asVoice ?? false,
-      audioAsVoice: consumed.audioAsVoice ?? inputOverrides?.audioAsVoice ?? false,
-      downloadMedia: consumed.downloadMedia ?? inputOverrides?.downloadMedia ?? false,
-      type: consumed.type ?? inputOverrides?.type,
-      kind: normalizeReplyKind(consumed.kind) ?? inputOverrides?.kind,
-      replyToId: inputOverrides?.replyToId || replyToId,
-      ...(Object.keys(extra).length > 0 ? { extra: { ...extra } } : {}),
-    };
-    const entry = await enqueueChannelMessageHandoff(runtime, ctx, payload, extra);
+    const entry = await enqueueChannelMessageHandoff(runtime, ctx, {
+      text: text,
+      mediaUrl: mediaUrl || '',
+      mediaUrls: Array.isArray(mediaUrls) && mediaUrls.length ? mediaUrls : undefined,
+      asVoice,
+      audioAsVoice,
+      downloadMedia,
+      type,
+      extra,
+      kind: kind as 'tool' | 'block' | 'final' | undefined,
+      replyToId,
+    });
     return buildBncrDurableQueuedResult({ entry });
   }
 
   return {
-    channelSendText: sendDispatch,
-    channelSendMedia: sendDispatch,
+    channelSendText: (ctx: BncrChannelSendContext) => sendDispatch(ctx),
+    channelSendMedia: (ctx: BncrChannelSendContext) => sendDispatch(ctx, mediaOverrides(ctx)),
 
-    channelMessageSendText: async (ctx: BncrChannelSendContext) =>
-      messageSendDispatch(ctx, { kind: normalizeReplyKind(ctx?.kind) }),
+    channelMessageSendText: async (ctx: BncrChannelSendContext) => messageSendDispatch(ctx),
 
     channelMessageSendMedia: async (ctx: BncrChannelSendContext) =>
-      messageSendDispatch(ctx, {
-        mediaUrl: runtime.asString(ctx.mediaUrl || ''),
-        mediaUrls: Array.isArray(ctx?.mediaUrls) ? ctx.mediaUrls : undefined,
-        asVoice: ctx?.asVoice === true,
-        audioAsVoice: ctx?.audioAsVoice === true,
-        type: runtime.asString(ctx.type || '').trim() || undefined,
-        kind: normalizeReplyKind(ctx?.kind),
-      }),
+      messageSendDispatch(ctx, mediaOverrides(ctx)),
 
     channelMessageSendPayload: async (ctx: BncrChannelSendContext) => {
       const p = ctx?.payload || {};
-      if (!p || typeof p !== 'object')
+      if (!p || typeof p !== 'object') {
         throw new Error('bncr channel.message payload must be an object');
+      }
       return messageSendDispatch(ctx, {
         text: runtime.asString(p.text || p.message || p.caption || ''),
         mediaUrl: runtime.asString(p.mediaUrl || ''),
         mediaUrls: Array.isArray(p.mediaUrls) ? p.mediaUrls : undefined,
         asVoice: p.asVoice === true,
         audioAsVoice: p.audioAsVoice === true,
-        downloadMedia: p.downloadMedia === true,
+        downloadMedia: p.downloadMedia as boolean | undefined,
         type: runtime.asString(p.type || '').trim() || undefined,
-        kind: normalizeReplyKind(p.kind) ?? normalizeReplyKind(ctx?.kind),
+        kind: typeof p.kind === 'string' ? p.kind : ctx.kind,
         replyToId:
           runtime.asString(p.replyToId || ctx?.replyToId || ctx?.replyToMessageId || '').trim() ||
           undefined,

package/src/plugin/channel-utils.ts

@@ -1,40 +1,19 @@
 import path from 'node:path';
+import {
+  asString,
+  clampFiniteNumber,
+  finiteNumberOr,
+  isPlainObject,
+  now,
+} from '../core/value-sanitize.ts';
 
-export function now() {
-  return Date.now();
-}
-
-export function asString(v: unknown, fallback = ''): string {
-  if (typeof v === 'string') return v;
-  if (v == null) return fallback;
-  return String(v);
-}
-
-export function finiteNumberOr(value: unknown, fallback: number): number {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
+export { asString, clampFiniteNumber, finiteNumberOr, isPlainObject, now };
 
 export function finiteNonNegativeNumberOrNull(value: unknown): number | null {
   const n = Number(value);
   return Number.isFinite(n) && n >= 0 ? n : null;
 }
 
-export function clampFiniteNumber(
-  value: unknown,
-  fallback: number,
-  min: number,
-  max: number,
-): number {
-  const n = Number(value);
-  const finite = Number.isFinite(n) ? n : fallback;
-  return Math.max(min, Math.min(finite, max));
-}
-
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 export function backoffMs(retryCount: number): number {
   return Math.max(1_000, 1_000 * 2 ** Math.max(0, retryCount - 1));
 }

package/src/plugin/connection-handlers-helpers.ts

@@ -203,21 +203,6 @@ export function hasTerminalFileAckState(state: FileAckState | undefined): state
   return state?.status === 'completed' || state?.status === 'aborted';
 }
 
-export function matchesTransferOwner(args: {
-  transfer: FileAckState | undefined;
-  connId: string;
-  clientId?: string;
-}) {
-  const { transfer, connId, clientId } = args;
-  const sameConn = !!transfer?.ownerConnId && transfer.ownerConnId === connId;
-  const sameClient =
-    !transfer?.ownerConnId &&
-    !!transfer?.ownerClientId &&
-    !!clientId &&
-    transfer.ownerClientId === clientId;
-  return { sameConn, sameClient };
-}
-
 export function applyFileAckState(args: {
   transfer: FileSendTransferState;
   stage: BncrFileAckStage;

package/src/plugin/connection-handlers.ts

@@ -1,5 +1,6 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 import { CHANNEL_ID } from '../core/accounts.ts';
+import { matchesTransferOwner } from '../core/lease-state.ts';
 import type { FileSendTransferState } from '../core/types.ts';
 import {
   applyFileAckState,
@@ -16,7 +17,6 @@ import {
   hasTerminalFileAckState,
   isBncrFileAckStage,
   type LeaseEventPayload,
-  matchesTransferOwner,
   type PreparedAckHandling,
   resolveFileAckLeaseEventKind,
 } from './connection-handlers-helpers.ts';
@@ -363,20 +363,21 @@ export function createBncrConnectionHandlers(runtime: BncrConnectionHandlersRunt
       let resolvedState = activeTransfer?.status ?? 'late';
 
       if (staleObserved.stale) {
-        const { sameConn, sameClient } = matchesTransferOwner({
-          transfer: activeTransfer,
+        const sameOwner = matchesTransferOwner({
+          ownerConnId: transferOwnerConnId,
+          ownerClientId: transferOwnerClientId,
           connId,
           clientId,
         });
         const adopted =
-          !(sameConn || sameClient) &&
+          !sameOwner &&
           runtime.tryAdoptTransferOwner({
             accountId,
             transfer: activeTransfer,
             connId,
             clientId,
           });
-        if (!(sameConn || sameClient || adopted)) {
+        if (!sameOwner && !adopted) {
           runtime.logWarn(
             'stale',
             `ignore kind=file.ack accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId} stage=${stage} reason=owner-mismatch ownerConnId=${transferOwnerConnId || '-'} ownerClientId=${transferOwnerClientId || '-'}`,

package/src/plugin/file-inbound-abort.ts

@@ -59,6 +59,11 @@ export function createBncrFileInboundAbortHandler(runtime: BncrFileInboundRuntim
     }
 
     const staleObserved = runtime.observeLease('file.abort', params ?? {});
+    // #not-merged Intentionally duplicated across complete/chunk/abort.
+    // Each handler emits a distinct logWarn message with its own event-kind
+    // in the format string, and the surrounding logic diverges in more than
+    // just the event name.  Merging would add parameter-gluing boilerplate
+    // with no reduction in total LOC.  See also the sibling files.
     if (staleObserved.stale) {
       if (
         !runtime.matchesTransferOwner({

package/src/plugin/file-inbound-chunk.ts

@@ -78,6 +78,11 @@ export function createBncrFileInboundChunkHandler(runtime: BncrFileInboundRuntim
     }
 
     const staleObserved = runtime.observeLease('file.chunk', params ?? {});
+    // #not-merged Intentionally duplicated across complete/chunk/abort.
+    // Each handler emits a distinct logWarn message with its own event-kind
+    // in the format string, and the surrounding logic diverges in more than
+    // just the event name.  Merging would add parameter-gluing boilerplate
+    // with no reduction in total LOC.  See also the sibling files.
     if (staleObserved.stale) {
       if (
         !runtime.matchesTransferOwner({

package/src/plugin/file-inbound-complete.ts

@@ -63,6 +63,11 @@ export function createBncrFileInboundCompleteHandler(runtime: BncrFileInboundRun
     }
 
     const staleObserved = runtime.observeLease('file.complete', params ?? {});
+    // #not-merged Intentionally duplicated across complete/chunk/abort.
+    // Each handler emits a distinct logWarn message with its own event-kind
+    // in the format string, and the surrounding logic diverges in more than
+    // just the event name.  Merging would add parameter-gluing boilerplate
+    // with no reduction in total LOC.  See also the sibling files.
     if (staleObserved.stale) {
       if (
         !runtime.matchesTransferOwner({