@xmoxmo/bncr 0.5.7 → 0.5.9

package/src/core/outbox-entry-builders.ts

@@ -12,27 +12,67 @@ function sanitizeExtraSpread(extra: Record<string, unknown>): Record<string, unk
   return out;
 }
 
-export function buildFileTransferOutboxEntry(args: {
+export type BuildOutboxEntryParams = {
   createMessageId: () => string;
   now: () => number;
   normalizeAccountId: (accountId?: string | null) => string;
   accountId: string;
   sessionKey: string;
   route: BncrRoute;
-  mediaUrl: string;
-  mediaLocalRoots?: readonly string[];
-  text: string;
-  asVoice?: boolean;
-  audioAsVoice?: boolean;
+  /** For text sends this is 'text'; for media it may be undefined (inferred downstream). */
   type?: string;
-  extra?: Record<string, unknown>;
+  /** Message body (text content for text sends, caption for media sends). */
+  msg: string;
   kind?: 'tool' | 'block' | 'final';
   replyToId?: string;
   replyTargetPolicy?: OutboundReplyTargetPolicy;
+  extra?: Record<string, unknown>;
+  /** Media-only fields. When transferMode === 'media' these shape the frame. */
+  transferMode?: 'text' | 'media';
+  mediaUrl?: string;
+  mediaLocalRoots?: readonly string[];
+  asVoice?: boolean;
+  audioAsVoice?: boolean;
   downloadMedia?: boolean;
-}): OutboxEntry {
+};
+
+/**
+ * Unified outbox entry builder.
+ *
+ * Text and media sends share the same outbox lifecycle (queue, drain, retry).
+ * The only structural difference is that media entries carry extra media fields
+ * and set `transferMode: 'media'` so the push layer knows to process media.
+ *
+ * - **Text**: `{ type: 'text', transferMode: undefined, no media fields }`
+ * - **Media**: `{ type: args.type || undefined, transferMode: 'media', ...media fields }`
+ */
+export function buildOutboxEntry(args: BuildOutboxEntryParams): OutboxEntry {
   const messageId = args.createMessageId();
   const createdAt = args.now();
+  const isMedia = args.transferMode === 'media';
+
+  const message: Record<string, unknown> = {
+    platform: args.route.platform,
+    groupId: args.route.groupId,
+    userId: args.route.userId,
+    type: isMedia ? args.type : 'text',
+    kind: args.kind,
+    msg: args.msg,
+    path: '',
+    base64: '',
+    fileName: '',
+    ...(args.extra ? sanitizeExtraSpread(args.extra) : {}),
+  };
+
+  if (isMedia) {
+    message.mediaUrl = args.mediaUrl || '';
+    if (args.mediaLocalRoots) message.mediaLocalRoots = Array.from(args.mediaLocalRoots);
+    message.asVoice = args.asVoice === true;
+    message.audioAsVoice = args.audioAsVoice === true;
+    message.downloadMedia = args.downloadMedia;
+    message.transferMode = 'media';
+  }
+
   return {
     messageId,
     accountId: args.normalizeAccountId(args.accountId),
@@ -49,84 +89,22 @@ export function buildFileTransferOutboxEntry(args: {
           replyToId: args.replyToId,
           replyTargetPolicy: args.replyTargetPolicy,
         }) || undefined,
-      message: {
-        platform: args.route.platform,
-        groupId: args.route.groupId,
-        userId: args.route.userId,
-        type: args.type,
-        // No fallback: when type is not provided the downstream adapter
-        // (tgBot / GewePlus) infers from mediaUrl extension.
-        kind: args.kind,
-        msg: args.text,
-        mediaUrl: args.mediaUrl,
-        mediaLocalRoots: args.mediaLocalRoots ? Array.from(args.mediaLocalRoots) : undefined,
-        asVoice: args.asVoice === true,
-        audioAsVoice: args.audioAsVoice === true,
-        downloadMedia: args.downloadMedia,
-        transferMode: 'media',
-        path: '',
-        base64: '',
-        fileName: '',
-        ...(args.extra ? sanitizeExtraSpread(args.extra) : {}),
+      message: message as {
+        platform: string;
+        groupId: string;
+        userId: string;
+        type?: string;
+        kind?: 'tool' | 'block' | 'final';
+        msg: string;
+        path: string;
+        base64: string;
+        fileName: string;
+        [key: string]: unknown;
       },
+      ts: createdAt,
     },
     createdAt,
     retryCount: 0,
     nextAttemptAt: createdAt,
   };
 }
-
-export function buildTextOutboxEntry(args: {
-  createMessageId: () => string;
-  now: () => number;
-  normalizeAccountId: (accountId?: string | null) => string;
-  accountId: string;
-  extra?: Record<string, unknown>;
-  sessionKey: string;
-  route: BncrRoute;
-  text: string;
-  kind?: 'tool' | 'block' | 'final';
-  replyToId?: string;
-  replyTargetPolicy?: OutboundReplyTargetPolicy;
-}): OutboxEntry {
-  const messageId = args.createMessageId();
-  const createdAt = args.now();
-  const frame = {
-    type: 'message.outbound',
-    messageId,
-    idempotencyKey: messageId,
-    sessionKey: args.sessionKey,
-    replyToId:
-      normalizeOutboundReplyToId({
-        kind: args.kind,
-        replyToId: args.replyToId,
-        replyTargetPolicy: args.replyTargetPolicy,
-      }) || undefined,
-    message: {
-      platform: args.route.platform,
-      groupId: args.route.groupId,
-      userId: args.route.userId,
-      type: 'text',
-      kind: args.kind,
-      msg: args.text,
-      path: '',
-      base64: '',
-      fileName: '',
-      // Extra fields from marker/pipeline spread for adapter-specific data
-      // (e.g. type="appmsg", msg="<appmsg>..." from [BncrParam:...])
-      ...(args.extra ? sanitizeExtraSpread(args.extra) : {}),
-    },
-    ts: createdAt,
-  };
-
-  return {
-    messageId,
-    accountId: args.normalizeAccountId(args.accountId),
-    sessionKey: args.sessionKey,
-    route: args.route,
-    payload: frame,
-    createdAt,
-    retryCount: 0,
-    nextAttemptAt: createdAt,
-  };
-}

package/src/core/outbox-summary.ts

@@ -1,26 +1,6 @@
 import type { OutboxEntry } from './types.ts';
 
-type OutboxSummaryMessage = {
-  type?: unknown;
-  msg?: unknown;
-  mediaUrl?: unknown;
-  audioAsVoice?: boolean;
-  asVoice?: boolean;
-};
-
-type OutboxSummaryPayload = {
-  type?: unknown;
-  message?: OutboxSummaryMessage;
-};
-
-function inferMediaTypeFromUrl(raw: string): 'image' | 'video' | 'audio' | 'file' {
-  const clean = String(raw || '').split(/[?#]/, 1)[0] || '';
-  const ext = clean.includes('.') ? clean.slice(clean.lastIndexOf('.') + 1).toLowerCase() : '';
-  if (['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'heic', 'heif'].includes(ext)) return 'image';
-  if (['mp4', 'mov', 'mkv', 'webm', 'avi', 'm4v'].includes(ext)) return 'video';
-  if (['mp3', 'wav', 'ogg', 'oga', 'opus', 'm4a', 'aac', 'flac'].includes(ext)) return 'audio';
-  return 'file';
-}
+type OutboxSummaryMessage = { type?: unknown; msg?: unknown; mediaUrl?: unknown };
 
 function filenameFromUrl(raw: string): string {
   const clean = String(raw || '').split(/[?#]/, 1)[0] || '';
@@ -33,27 +13,13 @@ function filenameFromUrl(raw: string): string {
   }
 }
 
-function summarizeOutboxType(
-  payload: OutboxSummaryPayload,
-  msg: OutboxSummaryMessage,
-  asString: (value: unknown) => string,
-) {
-  const directType = asString(msg.type || '');
-  if (directType) return directType;
-  // Infer type from mediaUrl when no direct type is set
-  const mediaUrl = asString(msg.mediaUrl || '');
-  if (mediaUrl) {
-    if (msg.audioAsVoice === true || msg.asVoice === true) return 'voice';
-    const inferred = inferMediaTypeFromUrl(mediaUrl);
-    if (inferred) return inferred;
-  }
-  return asString(payload?.type || 'unknown');
+function summarizeOutboxType(msg: OutboxSummaryMessage, asString: (value: unknown) => string) {
+  return asString(msg.type || '') || 'unknown';
 }
 
 function summarizeOutboxText(msg: OutboxSummaryMessage, asString: (value: unknown) => string) {
   const text = asString(msg.msg || '').trim();
   if (text) return text;
-  // Fall back to filename from mediaUrl when no caption is set
   const mediaUrl = asString(msg.mediaUrl || '');
   if (mediaUrl) return filenameFromUrl(mediaUrl);
   return '';
@@ -65,9 +31,9 @@ export function summarizeOutboxEntry(args: {
   formatDisplayScope: (route: OutboxEntry['route']) => string;
   summarizeTextPreview: (raw: string, limit?: number) => string;
 }) {
-  const payload = args.entry.payload as OutboxSummaryPayload;
+  const payload = args.entry.payload as { message?: OutboxSummaryMessage } | undefined;
   const msg = payload?.message || {};
-  const type = summarizeOutboxType(payload, msg, args.asString);
+  const type = summarizeOutboxType(msg, args.asString);
   const text = summarizeOutboxText(msg, args.asString);
   const preview = args.summarizeTextPreview(text);
   return [type, args.formatDisplayScope(args.entry.route), preview].join('|');

package/src/core/permissions.ts

@@ -10,7 +10,7 @@ type BncrElevatedConfigRoot = {
     };
   };
 };
-export function getBncrElevatedConfig(rootCfg: BncrElevatedConfigRoot | null | undefined) {
+function getBncrElevatedConfig(rootCfg: BncrElevatedConfigRoot | null | undefined) {
   const elevated = rootCfg?.tools?.elevated || {};
   const allowFrom = elevated?.allowFrom || {};
   const bncrRules = Array.isArray(allowFrom?.bncr)

package/src/core/register-trace.ts

@@ -43,7 +43,7 @@ export type RegisterDriftSnapshot = {
   traceRecent: Array<Record<string, unknown>>;
 };
 
-export function classifyRegisterTrace(stack: string) {
+function classifyRegisterTrace(stack: string) {
   if (
     stack.includes('prepareSecretsRuntimeSnapshot') ||
     stack.includes('resolveRuntimeWebTools') ||
@@ -66,7 +66,7 @@ export function classifyRegisterTrace(stack: string) {
   return 'other';
 }
 
-export function dominantRegisterBucket(sourceBuckets: Record<string, number>) {
+function dominantRegisterBucket(sourceBuckets: Record<string, number>) {
   let winner: string | null = null;
   let winnerCount = -1;
   for (const [bucket, count] of Object.entries(sourceBuckets)) {

package/src/messaging/inbound/parse.ts

@@ -58,7 +58,7 @@ function asInboundMediaItems(params: BncrInboundParamsInput): BncrInboundMediaIt
   }));
 }
 
-export function inboundDedupKey(params: {
+function inboundDedupKey(params: {
   accountId: string;
   platform: string;
   groupId: string;

package/src/messaging/outbound/diagnostics-debug-builders.ts

@@ -348,18 +348,3 @@ export function buildPushFailureDebugInfo(args: {
       (typeof args.lastError === 'string' && args.lastError) || OUTBOUND_TERMINAL_REASON.PUSH_RETRY,
   };
 }
-
-export function buildReplyMediaFallbackDebugInfo(args: {
-  sessionKey: string;
-  mediaUrl: string;
-  replyToId: string;
-  fallback: { text: string; reason: string };
-}) {
-  return {
-    sessionKey: args.sessionKey,
-    mediaUrl: args.mediaUrl,
-    replyToId: args.replyToId || undefined,
-    fallbackText: args.fallback.text,
-    reason: args.fallback.reason,
-  };
-}

package/src/messaging/outbound/diagnostics.ts

@@ -17,7 +17,6 @@ export {
   buildOutboxRouteSelectDebugInfo,
   buildOutboxScheduleDebugInfo,
   buildPushFailureDebugInfo,
-  buildReplyMediaFallbackDebugInfo,
   buildRetryRerouteDebugInfo,
 } from './diagnostics-debug-builders.ts';
 

package/src/messaging/outbound/marker-parser.ts

@@ -12,8 +12,13 @@
  * - Incomplete marker (no closing ]) → left in text, does NOT block later
  *   complete markers.
  * - Multiple valid markers → all stripped, params merge (later same-key wins).
+ * - When path/paths/mediaUrl/mediaUrls are present, probe for reachability.
+ *   Unreachable single paths keep the marker visible in the output text.
+ *   Unreachable entries in path arrays are dropped with warnings logged.
  */
 
+import fs from 'node:fs';
+
 const PREFIX = '[BncrParam:';
 
 /**
@@ -186,3 +191,232 @@ export function extractConsumptionFields(extra: Record<string, unknown> | undefi
     remaining,
   };
 }
+
+// ---------------------------------------------------------------------------
+// Media path probing
+// ---------------------------------------------------------------------------
+
+const PROBE_TIMEOUT_MS = 5_000;
+const MEDIA_PATH_KEYS = new Set(['path', 'paths', 'mediaUrl', 'mediaUrls']);
+
+function hasMediaPathParams(params: Record<string, unknown>): boolean {
+  for (const key of MEDIA_PATH_KEYS) {
+    if (key in params) return true;
+  }
+  return false;
+}
+
+/**
+ * Check whether a single media path (HTTP URL or local file) is reachable.
+ *
+ * - HTTP/HTTPS URLs → HEAD request with short timeout (5 s), follows redirects.
+ * - Local files → fs.existsSync.
+ *
+ * Returns `{ ok, reason }` where `reason` describes the failure when `ok` is false.
+ */
+async function probeMediaPath(raw: string): Promise<{
+  ok: boolean;
+  reason?: string;
+}> {
+  const path = String(raw || '').trim();
+  if (!path) return { ok: false, reason: 'empty path' };
+
+  // HTTP(S) URL — HEAD probe
+  if (path.startsWith('http://') || path.startsWith('https://')) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+      const response = await fetch(path, {
+        method: 'HEAD',
+        signal: controller.signal,
+        redirect: 'follow',
+      });
+      clearTimeout(timer);
+      if (response.ok || response.status === 206) return { ok: true };
+      // HEAD failed — try Range GET (first 4 bytes) as fallback.
+      // Some CDNs / object stores reject HEAD but serve GET with Range.
+      const probeReason = `HEAD ${response.status}`;
+      try {
+        const controller2 = new AbortController();
+        const timer2 = setTimeout(() => controller2.abort(), PROBE_TIMEOUT_MS);
+        const rangeResp = await fetch(path, {
+          method: 'GET',
+          headers: { Range: 'bytes=0-3' },
+          signal: controller2.signal,
+          redirect: 'follow',
+        });
+        clearTimeout(timer2);
+        if (rangeResp.status === 206 || rangeResp.ok) return { ok: true }; // 206=Range ok, other 2xx=server reachable
+        return { ok: false, reason: `${probeReason}, Range GET ${rangeResp.status}` };
+      } catch (err2: unknown) {
+        const reason2 = err2 instanceof Error ? err2.message : String(err2);
+        return { ok: false, reason: `${probeReason}, Range GET error: ${reason2}` };
+      }
+    } catch (err: unknown) {
+      const reason = err instanceof Error ? err.message : String(err);
+      // fetch-level error (DNS / timeout) — don't attempt fallback
+      return { ok: false, reason };
+    }
+  }
+
+  // Local file
+  try {
+    if (fs.existsSync(path)) return { ok: true };
+    return { ok: false, reason: 'file not found' };
+  } catch {
+    return { ok: false, reason: 'unreadable path' };
+  }
+}
+
+/**
+ * After JSON marker parsing, probe any media paths found in the params.
+ *
+ * - Single path (`path` / `mediaUrl`): if unreachable, keeps the marker in text
+ *   (returns allValid=false, warnings populated).
+ * - Path arrays (`paths` / `mediaUrls`): unreachable entries are removed; if at
+ *   least one entry is valid the marker is still stripped.  If ALL entries are
+ *   invalid the marker is kept.
+ *
+ * Returns `{ params, warnings, allValid }`:
+ * - `params` — (potentially filtered) params with invalid array entries removed.
+ * - `warnings` — human-readable warning strings for each unreachable path.
+ * - `allValid` — false when a single path or all array entries are unreachable.
+ */
+async function probeAndResolveMarkerPaths(params: Record<string, unknown>): Promise<{
+  params: Record<string, unknown>;
+  warnings: string[];
+  allValid: boolean;
+}> {
+  const warnings: string[] = [];
+  if (!hasMediaPathParams(params)) return { params, warnings, allValid: true };
+
+  // Single path / mediaUrl
+  const singlePath = String(params.path ?? params.mediaUrl ?? '').trim();
+  if (singlePath) {
+    const result = await probeMediaPath(singlePath);
+    if (!result.ok) {
+      warnings.push(`path ${singlePath} unreachable: ${result.reason}`);
+      return { params, warnings, allValid: false };
+    }
+    // Path confirmed reachable — signal downstream that media is validated
+    // Only set ismedia:true when user hasn't explicitly opted out.
+    if (!('ismedia' in params && params.ismedia === false)) {
+      params = { ...params, ismedia: true };
+    }
+    return { params, warnings, allValid: true };
+  }
+
+  // Path arrays — paths / mediaUrls
+  const arraySource = (params.paths ?? params.mediaUrls) as unknown;
+  if (Array.isArray(arraySource) && arraySource.length > 0) {
+    const entries = arraySource.filter(
+      (v): v is string => typeof v === 'string' && v.trim().length > 0,
+    );
+    if (entries.length === 0) return { params, warnings, allValid: true };
+
+    const results = await Promise.all(entries.map((p) => probeMediaPath(p)));
+    const valid: string[] = [];
+    for (let i = 0; i < entries.length; i++) {
+      if (results[i].ok) {
+        valid.push(entries[i]);
+      } else {
+        warnings.push(`path ${entries[i]} unreachable: ${results[i].reason}`);
+      }
+    }
+
+    if (valid.length === 0) {
+      // All invalid → keep marker
+      return { params, warnings, allValid: false };
+    }
+    // At least one valid → strip marker, replace with filtered entries.
+    // Only set ismedia=true when user hasn't explicitly opted out.
+    const setMedia = !('ismedia' in params && params.ismedia === false);
+    params = { ...params, ...(setMedia ? { ismedia: true } : {}), paths: valid, mediaUrls: valid };
+  }
+
+  return { params, warnings, allValid: true };
+}
+
+/**
+ * Parse text markers AND probe media paths in one async step.
+ *
+/**
+ * Unified marker strip decision: the single place that decides whether to strip
+ * a [BncrParam:...] marker from the text or leave it in place.
+ *
+ * - Markers that JSON parse successfully AND whose media paths (if any) are
+ *   reachable → stripped from text, params extracted and merged.
+ * - Markers whose paths are unreachable (single path OR all array entries) →
+ *   kept in text, NOT stripped, NOT extracted.
+ * - Markers without path fields → stripped as normal (existing behavior).
+ * - Markers that fail JSON parse → kept in text (existing behavior).
+ * - Multiple markers → each evaluated independently, later markers' params
+ *   overwrite earlier ones when the same key appears.
+ *
+ * This function IS the single decision point.  Downstream consumers of the
+ * returned text never re-parse markers — they trust the decision made here.
+ */
+export async function resolveMarkerStripDecision(text: string): Promise<{
+  cleanText: string;
+  params: Record<string, unknown>;
+  warnings: string[];
+}> {
+  const params: Record<string, unknown> = {};
+  const warnings: string[] = [];
+  let result = text;
+  let searchFrom = 0;
+  const hadMarkers = text.includes(PREFIX);
+
+  if (!hadMarkers) return { cleanText: text, params, warnings };
+
+  while (true) {
+    const idx = result.indexOf(PREFIX, searchFrom);
+    if (idx === -1) break;
+
+    const end = findMarkerEnd(result, idx);
+    if (end === -1) {
+      searchFrom = idx + PREFIX.length;
+      continue;
+    }
+
+    const rawJson = result.slice(idx + PREFIX.length, end);
+    let parsed: Record<string, unknown> | null = null;
+    try {
+      const obj = JSON.parse(rawJson);
+      if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        parsed = obj as Record<string, unknown>;
+      }
+    } catch {
+      // JSON parse failed → keep marker in text, continue scanning after it
+      searchFrom = end + 1;
+      continue;
+    }
+
+    // JSON parsed but is not a plain object → keep marker in text
+    if (!parsed) {
+      searchFrom = end + 1;
+      continue;
+    }
+
+    // Marker has path fields → probe before deciding to strip
+    if (hasMediaPathParams(parsed)) {
+      const probeResult = await probeAndResolveMarkerPaths(parsed);
+      if (probeResult.warnings.length > 0) warnings.push(...probeResult.warnings);
+      if (!probeResult.allValid) {
+        // Path(s) unreachable → keep marker in text, do NOT extract any params
+        searchFrom = end + 1;
+        continue;
+      }
+      // Paths valid → strip, merge params (probeResult.params includes ismedia:true + filtered arrays)
+      Object.assign(params, probeResult.params);
+    } else {
+      // No path fields → strip marker and merge params unconditionally
+      Object.assign(params, parsed);
+    }
+    result = result.slice(0, idx) + result.slice(end + 1);
+    searchFrom = idx;
+  }
+
+  const cleanText = result !== text ? result.replace(/ {2,}/g, ' ').trim() : result;
+  return { cleanText, params, warnings };
+}

package/src/messaging/outbound/media-dedupe.ts

@@ -15,10 +15,7 @@ export function normalizeMessageText(value: unknown): string {
   return asString(value || '').trim();
 }
 
-export function shouldTreatReplyToAsSame(
-  currentReplyToId: string,
-  previousReplyToId: string,
-): boolean {
+function shouldTreatReplyToAsSame(currentReplyToId: string, previousReplyToId: string): boolean {
   if (!currentReplyToId || !previousReplyToId) return true;
   return currentReplyToId === previousReplyToId;
 }

package/src/messaging/outbound/normalize-outbound-send.ts

@@ -12,7 +12,7 @@
  */
 
 import { asString, isPlainObject } from '../../core/value-sanitize.ts';
-import { extractConsumptionFields, parseBncrMarker } from './marker-parser.ts';
+import { extractConsumptionFields, resolveMarkerStripDecision } from './marker-parser.ts';
 
 const MEDIA_SOURCE_EXTRA_KEYS = ['path', 'paths', 'mediaUrl', 'mediaUrls'] as const;
 
@@ -104,13 +104,13 @@ function buildBranchExtra(args: {
  * Parse markers from one or more text fields and merge extras.
  * Marker params always override host/params extra and host control flags.
  */
-export function mergeMarkerAndHostFields(args: {
+export async function mergeMarkerAndHostFields(args: {
   texts: string[];
   hostExtra?: Record<string, unknown>;
   forceDocument?: boolean;
   gifPlayback?: boolean;
   silent?: boolean;
-}): {
+}): Promise<{
   cleanTexts: string[];
   markerParams: Record<string, unknown>;
   consumed: Partial<{
@@ -124,12 +124,12 @@ export function mergeMarkerAndHostFields(args: {
   }>;
   remaining: Record<string, unknown>;
   markerHasMsg: boolean;
-} {
+}> {
   const markerParams: Record<string, unknown> = {};
   const cleanTexts: string[] = [];
 
   for (const raw of args.texts) {
-    const { cleanText, params } = parseBncrMarker(raw);
+    const { cleanText, params } = await resolveMarkerStripDecision(raw);
     cleanTexts.push(cleanText);
     Object.assign(markerParams, params);
   }
@@ -222,13 +222,15 @@ function resolveDispatchMediaSources(args: {
  * Normalize any outbound send input into a single dispatch shape.
  * Callers only need to branch on `hasMedia` after this.
  */
-export function normalizeOutboundSend(input: UnifiedOutboundSendInput): NormalizedOutboundSend {
+export async function normalizeOutboundSend(
+  input: UnifiedOutboundSendInput,
+): Promise<NormalizedOutboundSend> {
   const rawText = asString(input.text ?? input.message ?? '', '');
   const rawCaption = asString(input.caption ?? '', '');
   // Prefer text/message; also parse caption so marker in either field works.
   const textsToParse = rawCaption && rawCaption !== rawText ? [rawText, rawCaption] : [rawText];
 
-  const { cleanTexts, consumed, remaining, markerHasMsg } = mergeMarkerAndHostFields({
+  const { cleanTexts, consumed, remaining, markerHasMsg } = await mergeMarkerAndHostFields({
     texts: textsToParse,
     hostExtra: isPlainObject(input.extra) ? input.extra : undefined,
     forceDocument: input.forceDocument,