@qwen-code/qwen-code 0.21.6-preview.0 → 0.21.7-nightly.20260807.fca8f3c1f

package/chunks/{chunk-4T6QMNX2.js → chunk-7HMDOAIC.js}

@@ -6,7 +6,7 @@ import {
   EventBus,
   logEventSizingFailed,
   serializedBridgeEventByteLength
-} from "./chunk-GLWP3FDB.js";
+} from "./chunk-MZSJ43WV.js";
 import {
   normalizeCompactedReplayMaxBytes,
   normalizeMaxJournalBytes,
@@ -17,7 +17,7 @@ import {
 } from "./chunk-OCPBI7J5.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-2U7GPHA6.js";
+} from "./chunk-E33LOKRA.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -26,11 +26,12 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-WIRAPZ62.js";
+} from "./chunk-NLREQJFK.js";
 import {
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
   DAEMON_CHANNEL_DELIVERY_META_KEY,
+  DAEMON_MODEL_PROMPT_META_KEY,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_HIDE_INHERITED_META_KEY,
   LOAD_REPLAY_META_KEY,
@@ -42,8 +43,9 @@ import {
   REQUESTED_SESSION_ID_META_KEY,
   TODO_STOP_GUARD_CONTINUATION_CLAIM_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
-  WORKTREE_MCP_DEFER_META_KEY
-} from "./chunk-UKZEXS6K.js";
+  WORKTREE_MCP_DEFER_META_KEY,
+  isValidTrustedModelPrompt
+} from "./chunk-R574ATRM.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -71,9 +73,12 @@ import {
 } from "./chunk-6PLDPT2C.js";
 import {
   CHANNEL_DELIVERY_ERROR_CODES,
+  LIVE_TASK_TOOL_NAMES,
+  MAX_LIVE_SCREEN_CONTEXT_TEXT_CHARS,
+  MAX_LIVE_SPEAK_TO_USER_MESSAGE_CHARS,
   MAX_SUB_SESSION_NAME_CHARS,
   MAX_SUB_SESSION_PROMPT_CHARS
-} from "./chunk-BK2UNYWD.js";
+} from "./chunk-HIBNSEJE.js";
 import {
   EXTERNAL_TOOL_GUARD_READY_META_KEY,
   EXTERNAL_TOOL_GUARD_REQUIRED_VALUE,
@@ -95,16 +100,16 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-DOA7MCDY.js";
+} from "./chunk-I3LJQR5I.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-MGSSJT27.js";
+} from "./chunk-L4N6TIP7.js";
 import {
   INVOCATION_CONTEXT_META_KEY,
   PRIVATE_ACP_CAPABILITY_ENV,
   PRIVATE_PARENT_CAPABILITY_META_KEY
-} from "./chunk-O656RSMC.js";
+} from "./chunk-FTJUO7R2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -1835,7 +1840,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false, externalToolGuard) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent, onWorkspaceGenerationEvent, onChannelDelivery, hasSessionSpawnInFlight = () => false, getLiveScreenContextCaptureHandler = () => void 0, getLiveTaskToolRequestHandler = () => void 0, getLiveSpeakToUserHandler = () => void 0, externalToolGuard) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1852,6 +1857,9 @@ var BridgeClient = class {
     this.onWorkspaceGenerationEvent = onWorkspaceGenerationEvent;
     this.onChannelDelivery = onChannelDelivery;
     this.hasSessionSpawnInFlight = hasSessionSpawnInFlight;
+    this.getLiveScreenContextCaptureHandler = getLiveScreenContextCaptureHandler;
+    this.getLiveTaskToolRequestHandler = getLiveTaskToolRequestHandler;
+    this.getLiveSpeakToUserHandler = getLiveSpeakToUserHandler;
     this.externalToolGuard = externalToolGuard;
   }
   static {
@@ -2130,6 +2138,15 @@ var BridgeClient = class {
     if (method === SERVE_CONTROL_EXT_METHODS.createSubSession) {
       return this.handleCreateSubSession(params);
     }
+    if (method === SERVE_CONTROL_EXT_METHODS.liveCaptureScreenContext) {
+      return this.handleLiveScreenContextCapture(params);
+    }
+    if (method === SERVE_CONTROL_EXT_METHODS.liveTaskTool) {
+      return this.handleLiveTaskTool(params);
+    }
+    if (method === SERVE_CONTROL_EXT_METHODS.liveSpeakToUser) {
+      return this.handleLiveSpeakToUser(params);
+    }
     if (method === SERVE_CONTROL_EXT_METHODS.channelDelivery) {
       return this.handleChannelDelivery(params);
     }
@@ -2484,6 +2501,71 @@ var BridgeClient = class {
       ...result.parentSessionPersisted !== void 0 ? { parentSessionPersisted: result.parentSessionPersisted } : {}
     };
   }
+  async handleLiveScreenContextCapture(params) {
+    const handler = this.getLiveScreenContextCaptureHandler();
+    if (!handler) {
+      throw RequestError.methodNotFound(
+        SERVE_CONTROL_EXT_METHODS.liveCaptureScreenContext
+      );
+    }
+    const callerSessionId = params["callerSessionId"];
+    if (typeof callerSessionId !== "string" || callerSessionId.length === 0 || !this.ownsSession(callerSessionId)) {
+      throw RequestError.invalidParams(
+        void 0,
+        "`callerSessionId` is required and must name a session owned by this connection"
+      );
+    }
+    const result = await handler({ callerSessionId });
+    if (result.appName.length === 0 || result.appName.length > 512 || result.windowTitle !== void 0 && result.windowTitle.length > 2048 || result.accessibilityText.length > MAX_LIVE_SCREEN_CONTEXT_TEXT_CHARS || result.screenshotPath.length === 0 || result.screenshotPath.length > 4096) {
+      throw RequestError.internalError(void 0, "Invalid Appshot result.");
+    }
+    return {
+      appName: result.appName,
+      ...result.windowTitle ? { windowTitle: result.windowTitle } : {},
+      accessibilityText: result.accessibilityText,
+      screenshotPath: result.screenshotPath
+    };
+  }
+  async handleLiveTaskTool(params) {
+    const handler = this.getLiveTaskToolRequestHandler();
+    if (!handler) {
+      throw RequestError.methodNotFound(SERVE_CONTROL_EXT_METHODS.liveTaskTool);
+    }
+    const callerSessionId = params["callerSessionId"];
+    const name = params["name"];
+    const args = params["arguments"];
+    if (typeof callerSessionId !== "string" || callerSessionId.length === 0 || !this.ownsSession(callerSessionId) || typeof name !== "string" || !LIVE_TASK_TOOL_NAMES.includes(
+      name
+    ) || typeof args !== "object" || args === null || Array.isArray(args)) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invalid Live task-tool request."
+      );
+    }
+    return handler({
+      callerSessionId,
+      name,
+      arguments: args
+    });
+  }
+  async handleLiveSpeakToUser(params) {
+    const handler = this.getLiveSpeakToUserHandler();
+    if (!handler) {
+      throw RequestError.methodNotFound(
+        SERVE_CONTROL_EXT_METHODS.liveSpeakToUser
+      );
+    }
+    const callerSessionId = params["callerSessionId"];
+    const message = params["message"];
+    if (typeof callerSessionId !== "string" || callerSessionId.length === 0 || !this.ownsSession(callerSessionId) || typeof message !== "string" || message.trim().length === 0 || message.length > MAX_LIVE_SPEAK_TO_USER_MESSAGE_CHARS) {
+      throw RequestError.invalidParams(
+        void 0,
+        "Invalid Live speak-to-user request."
+      );
+    }
+    await handler({ callerSessionId, message });
+    return { accepted: true };
+  }
   /**
    * Handle child->bridge ACP `extNotification` calls. Recognized methods are
    * `qwen/notify/session/model-update`,
@@ -2493,11 +2575,26 @@ var BridgeClient = class {
    * `qwen/notify/session/prompt-suggestion` (followup assist),
    * `qwen/notify/session/artifact-event` (hook artifacts),
    * `qwen/notify/session/terminal-sequence`, and
+   * `_qwencode/end_turn` (background-notification turns), and
    * `qwen/notify/session/mcp-budget-event` — each translated into a
    * session-scoped SSE frame. Unknown methods are dropped silently for
    * forward-compat.
    */
   async extNotification(method, params) {
+    if (method === "_qwencode/end_turn") {
+      const sessionId2 = params["sessionId"];
+      const reason = params["reason"];
+      if (typeof sessionId2 !== "string" || sessionId2.length === 0 || typeof reason !== "string" || reason.length === 0 || reason.length > 128 || params["source"] !== "background_notification") {
+        return;
+      }
+      const entry = this.resolveEntry(sessionId2);
+      if (!entry || !this.ownsSession(sessionId2)) return;
+      entry.events.publish({
+        type: "background_notification_turn_complete",
+        data: { sessionId: sessionId2, reason }
+      });
+      return;
+    }
     if (method === "qwen/notify/session/generation/event") {
       const sessionId2 = params["sessionId"];
       const requestId = params["requestId"];
@@ -5993,6 +6090,9 @@ var DEFAULT_MAX_PENDING_PER_SESSION = 64;
 var DEFAULT_SESSION_REAP_INTERVAL_MS = 6e4;
 var DEFAULT_SESSION_IDLE_TIMEOUT_MS = 30 * 6e4;
 function createAcpSessionBridge(opts) {
+  let liveScreenContextCaptureHandler;
+  let liveTaskToolRequestHandler;
+  let liveSpeakToUserHandler;
   const defaultSessionScope = opts.sessionScope ?? "single";
   let maxSessions;
   if (opts.maxSessions === void 0) {
@@ -6560,6 +6660,9 @@ function createAcpSessionBridge(opts) {
           },
           opts.onChannelDelivery,
           () => channelInfo?.sessionIds === sessionIds && channelInfo.sessionSpawnsInFlight > 0,
+          () => liveScreenContextCaptureHandler,
+          () => liveTaskToolRequestHandler,
+          () => liveSpeakToUserHandler,
           opts.externalToolGuard
         );
         connection = new ClientSideConnection(() => client, channel.stream);
@@ -7750,9 +7853,15 @@ function createAcpSessionBridge(opts) {
       };
     }
     if (action === "load") {
+      const liveJournal = snapshot.liveJournal.map((event) => {
+        if (!entry.activePromptId || event.type !== "history_truncated" || !event.data || typeof event.data !== "object" || event.data.scope !== "live_journal") {
+          return event;
+        }
+        return { ...event, promptId: entry.activePromptId };
+      });
       return {
         compactedReplay: snapshot.compactedTurns,
-        liveJournal: snapshot.liveJournal,
+        liveJournal,
         lastEventId: snapshot.lastEventId,
         eventEpoch,
         ...replayStatus,
@@ -7923,6 +8032,7 @@ function createAcpSessionBridge(opts) {
       return {
         sessionId: existing.sessionId,
         workspaceCwd: existing.workspaceCwd,
+        ...existing.effectiveCwd !== existing.workspaceCwd ? { currentCwd: existing.effectiveCwd } : {},
         attached: true,
         clientId,
         createdAt: existing.createdAt,
@@ -8120,6 +8230,7 @@ function createAcpSessionBridge(opts) {
         return {
           sessionId: racedEntry.sessionId,
           workspaceCwd: racedEntry.workspaceCwd,
+          ...racedEntry.effectiveCwd !== racedEntry.workspaceCwd ? { currentCwd: racedEntry.effectiveCwd } : {},
           attached: true,
           clientId: clientId2,
           createdAt: racedEntry.createdAt,
@@ -8355,6 +8466,15 @@ function createAcpSessionBridge(opts) {
   __name(closeSessionImpl, "closeSessionImpl");
   startSessionReaper();
   const bridgeApi = {
+    setLiveScreenContextCaptureHandler(handler) {
+      liveScreenContextCaptureHandler = handler;
+    },
+    setLiveTaskToolRequestHandler(handler) {
+      liveTaskToolRequestHandler = handler;
+    },
+    setLiveSpeakToUserHandler(handler) {
+      liveSpeakToUserHandler = handler;
+    },
     getDaemonStatusSnapshot() {
       return {
         limits: {
@@ -8478,6 +8598,7 @@ function createAcpSessionBridge(opts) {
           return {
             sessionId: existing.sessionId,
             workspaceCwd: existing.workspaceCwd,
+            ...existing.effectiveCwd !== existing.workspaceCwd ? { currentCwd: existing.effectiveCwd } : {},
             attached: true,
             clientId,
             createdAt: existing.createdAt,
@@ -8581,6 +8702,12 @@ function createAcpSessionBridge(opts) {
         entry,
         context?.clientId
       );
+      const modelPrompt = context?.modelPrompt;
+      if (modelPrompt !== void 0 && !isValidTrustedModelPrompt(modelPrompt)) {
+        throw new TypeError(
+          "Bridge modelPrompt must be a non-empty bounded string."
+        );
+      }
       if (signal?.aborted) {
         throw new DOMException("Prompt aborted", "AbortError");
       }
@@ -8627,6 +8754,14 @@ function createAcpSessionBridge(opts) {
         state: isQueued ? "queued" : "running"
       };
       entry.pendingPromptList.push(pendingEntry);
+      try {
+        context?.onPromptAdmitted?.();
+      } catch (error) {
+        opts.onDiagnosticLine?.(
+          `qwen serve: prompt admission observer failed for session=${sessionId}: ${error instanceof Error ? error.message : String(error)}`,
+          "warn"
+        );
+      }
       const deadlineMs = context?.deadlineMs;
       const hasDeadline = typeof deadlineMs === "number" && Number.isFinite(deadlineMs) && deadlineMs > 0;
       let deadlineReject;
@@ -8755,6 +8890,7 @@ function createAcpSessionBridge(opts) {
                   delete meta[PRIVATE_PARENT_CAPABILITY_META_KEY];
                   delete meta[DAEMON_CONTINUE_META_KEY];
                   delete meta[DAEMON_CHANNEL_DELIVERY_META_KEY];
+                  delete meta[DAEMON_MODEL_PROMPT_META_KEY];
                   if (isRetry) {
                     meta[DAEMON_RETRY_META_KEY] = true;
                   }
@@ -8764,6 +8900,9 @@ function createAcpSessionBridge(opts) {
                   if (context?.channelDelivery) {
                     meta[DAEMON_CHANNEL_DELIVERY_META_KEY] = context.channelDelivery;
                   }
+                  if (modelPrompt !== void 0) {
+                    meta[DAEMON_MODEL_PROMPT_META_KEY] = modelPrompt;
+                  }
                   meta[INVOCATION_CONTEXT_META_KEY] = invocationContext;
                   if (Object.keys(meta).length > 0) {
                     copy._meta = meta;
@@ -9292,7 +9431,8 @@ function createAcpSessionBridge(opts) {
           {
             sessionId,
             path: req.path,
-            ...req.allowedRoots ? { allowedRoots: req.allowedRoots } : {}
+            ...req.allowedRoots ? { allowedRoots: req.allowedRoots } : {},
+            ...req.managedRelocation ? { managedRelocation: req.managedRelocation } : {}
           }
         );
         const extResult = raw;
@@ -10030,6 +10170,20 @@ function createAcpSessionBridge(opts) {
         refreshed: result.refreshed ?? false
       };
     },
+    async setSessionLiveConversationActive(sessionId, active) {
+      await requestSessionStatus(
+        sessionId,
+        SERVE_CONTROL_EXT_METHODS.sessionLiveConversation,
+        { active }
+      );
+    },
+    async appendSessionLiveTranscript(sessionId, entries, model) {
+      await requestSessionStatus(
+        sessionId,
+        SERVE_CONTROL_EXT_METHODS.sessionLiveTranscript,
+        { entries, model }
+      );
+    },
     async setSessionApprovalMode(sessionId, mode, opts2, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -10237,6 +10391,24 @@ function createAcpSessionBridge(opts) {
       entry.midTurnMessageQueue.splice(index, 1);
       return { removed: true };
     },
+    async enqueueBackgroundNotification(sessionId, notification) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const info = channelInfoForEntry(entry);
+      if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+      const response = await Promise.race([
+        withTimeout(
+          entry.connection.extMethod(
+            SERVE_CONTROL_EXT_METHODS.sessionBackgroundNotification,
+            { sessionId, ...notification }
+          ),
+          initTimeoutMs,
+          SERVE_CONTROL_EXT_METHODS.sessionBackgroundNotification
+        ),
+        getTransportClosedReject(entry)
+      ]);
+      return { sessionId, accepted: response["accepted"] === true };
+    },
     async generateSessionBtw(sessionId, question, signal, _context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -11119,6 +11291,7 @@ export {
   SessionArtifactAuthorizationError,
   SESSION_SOURCE_META_KEY,
   parseSessionSource,
+  isA2uiToolMeta,
   extractErrorMessage,
   extractErrorCode,
   classifyTurnErrorKind,

package/chunks/{chunk-33FNCQSY.js → chunk-7MH4J33A.js}

@@ -10,11 +10,11 @@ import {
 } from "./chunk-CPBF7KYF.js";
 import {
   atomicWriteJSON
-} from "./chunk-UH7Z7Y45.js";
+} from "./chunk-FOGU3LJX.js";
 import {
   Storage,
   isNodeError
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-2AGOQ7QO.js → chunk-7UFKAV7Y.js}

@@ -1,8 +1,11 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  MAX_INLINE_IMAGE_ENCODED_LENGTH
+} from "./chunk-2VSTGY6M.js";
 import {
   MAX_TERMINAL_IMAGE_BYTES
-} from "./chunk-D7D7RXIJ.js";
+} from "./chunk-IC4Z6LX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -847,11 +850,15 @@ var MAX_PREVIEW_ROWS = 24;
 var ESTIMATED_CELL_WIDTH_PX = 8;
 var ESTIMATED_CELL_HEIGHT_PX = 16;
 var MAX_REASON_CHARS = 200;
+var MAX_INLINE_IMAGE_DIMENSION = 1e6;
+var MAX_INLINE_IMAGE_PIXELS = 64e6;
 var CMD_SHELL_METACHARACTERS = /[&|<>^%"!()\n\r]/;
 var RENDER_CACHE_LIMIT = 40;
 var RENDER_CACHE_BYTE_LIMIT = 32 * 1024 * 1024;
 var renderCache = /* @__PURE__ */ new Map();
 var renderCacheBytes = 0;
+var INLINE_DECODE_CACHE_LIMIT = 4;
+var inlineDecodeCache = /* @__PURE__ */ new Map();
 var TRANSMITTED_KEY_LIMIT = 256;
 var transmittedKeys = /* @__PURE__ */ new Set();
 function wasKittyImageWritten(key) {
@@ -896,6 +903,44 @@ function containsCmdShellMetacharacters(filePath) {
   return CMD_SHELL_METACHARACTERS.test(filePath);
 }
 __name(containsCmdShellMetacharacters, "containsCmdShellMetacharacters");
+function prepareInlineTerminalImage({
+  data,
+  mimeType,
+  contentWidth,
+  availableTerminalHeight,
+  env = process.env,
+  stdoutIsTTY = process.stdout.isTTY,
+  disabled = false
+}) {
+  const format = getImageFormat(mimeType);
+  const emptyFallback = format ? `[image: ${format}]` : "[image]";
+  if (format !== "png") {
+    return { fallbackText: emptyFallback, result: null };
+  }
+  const decoded = getDecodedInlinePng(data);
+  if (!decoded) {
+    return { fallbackText: emptyFallback, result: null };
+  }
+  const { png, size } = decoded;
+  const fallbackText = `[image: ${size.width}x${size.height} png]`;
+  if (disabled) {
+    return { fallbackText, result: null };
+  }
+  const shape = fitImageToTerminal2(size, contentWidth, availableTerminalHeight);
+  const useKitty = supportsKittyImageProtocol(env, stdoutIsTTY);
+  const chafaPath = useKitty ? null : findExecutable("chafa", env);
+  const cacheKey = createInlineRenderCacheKey(png, shape, useKitty, chafaPath);
+  const cached = getCachedRenderResult(cacheKey);
+  if (cached) {
+    return { fallbackText, result: cached };
+  }
+  const result = useKitty ? { ...renderKitty(png, shape), key: cacheKey } : renderWithChafa({ data: png }, shape, env, chafaPath);
+  if (result.kind !== "unavailable") {
+    rememberRenderResult(cacheKey, result);
+  }
+  return { fallbackText, result };
+}
+__name(prepareInlineTerminalImage, "prepareInlineTerminalImage");
 function renderTerminalImage({
   display,
   contentWidth,
@@ -959,7 +1004,7 @@ function renderTerminalImage({
       reason: `Image exceeds the ${MAX_TERMINAL_IMAGE_BYTES} byte display limit.`
     };
   }
-  const result = useKitty ? { ...renderKitty(png, shape), key: cacheKey } : renderWithChafa(display.filePath, shape, env, chafaPath);
+  const result = useKitty ? { ...renderKitty(png, shape), key: cacheKey } : renderWithChafa({ filePath: display.filePath }, shape, env, chafaPath);
   if (result.kind !== "unavailable") {
     rememberRenderResult(cacheKey, result);
   }
@@ -996,6 +1041,70 @@ function createRenderCacheKey(filePath, stat, shape, useKitty, chafaPath) {
   ].join("\0");
 }
 __name(createRenderCacheKey, "createRenderCacheKey");
+function createInlineRenderCacheKey(png, shape, useKitty, chafaPath) {
+  return [
+    "inline",
+    crypto2.createHash("sha256").update(png).digest("hex"),
+    shape.widthCells,
+    shape.rows,
+    useKitty ? "kitty" : chafaPath ?? "none"
+  ].join("\0");
+}
+__name(createInlineRenderCacheKey, "createInlineRenderCacheKey");
+function getImageFormat(mimeType) {
+  const match = /^image\/([a-z0-9][a-z0-9.+-]*)$/.exec(
+    mimeType.trim().toLowerCase()
+  );
+  return match?.[1] ?? null;
+}
+__name(getImageFormat, "getImageFormat");
+function decodeInlineImage(data) {
+  if (data.length === 0 || data.length > MAX_INLINE_IMAGE_ENCODED_LENGTH) {
+    return null;
+  }
+  const normalized = data.replace(/\s/g, "");
+  if (normalized.length === 0 || normalized.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    return null;
+  }
+  const decoded = Buffer.from(normalized, "base64");
+  if (decoded.length === 0 || decoded.length > MAX_TERMINAL_IMAGE_BYTES || decoded.toString("base64").replace(/=+$/, "") !== normalized.replace(/=+$/, "")) {
+    return null;
+  }
+  return decoded;
+}
+__name(decodeInlineImage, "decodeInlineImage");
+function getDecodedInlinePng(data) {
+  const cached = inlineDecodeCache.get(data);
+  if (cached) {
+    inlineDecodeCache.delete(data);
+    inlineDecodeCache.set(data, cached);
+    return cached;
+  }
+  const png = decodeInlineImage(data);
+  if (!png) return null;
+  const size = readValidatedInlinePngSize(png);
+  if (!size) return null;
+  const decoded = { png, size };
+  inlineDecodeCache.set(data, decoded);
+  while (inlineDecodeCache.size > INLINE_DECODE_CACHE_LIMIT) {
+    const oldest = inlineDecodeCache.keys().next().value;
+    if (oldest === void 0) break;
+    inlineDecodeCache.delete(oldest);
+  }
+  return decoded;
+}
+__name(getDecodedInlinePng, "getDecodedInlinePng");
+function readValidatedInlinePngSize(png) {
+  if (png.length < 24 || png.readUInt32BE(8) !== 13 || png.subarray(12, 16).toString("ascii") !== "IHDR") {
+    return null;
+  }
+  const size = readPngSize(png);
+  if (!size || !Number.isInteger(size.width) || !Number.isInteger(size.height) || size.width <= 0 || size.height <= 0 || size.width > MAX_INLINE_IMAGE_DIMENSION || size.height > MAX_INLINE_IMAGE_DIMENSION || size.width * size.height > MAX_INLINE_IMAGE_PIXELS) {
+    return null;
+  }
+  return size;
+}
+__name(readValidatedInlinePngSize, "readValidatedInlinePngSize");
 function getCachedRenderResult(key) {
   const cached = renderCache.get(key);
   if (cached) {
@@ -1097,7 +1206,7 @@ function renderKitty(png, shape) {
   };
 }
 __name(renderKitty, "renderKitty");
-function renderWithChafa(filePath, shape, env, chafaPath) {
+function renderWithChafa(source, shape, env, chafaPath) {
   if (!chafaPath) {
     return {
       kind: "unavailable",
@@ -1105,7 +1214,7 @@ function renderWithChafa(filePath, shape, env, chafaPath) {
     };
   }
   const useShell = shouldRunThroughShell(chafaPath);
-  if (useShell && containsCmdShellMetacharacters(filePath)) {
+  if (useShell && "filePath" in source && containsCmdShellMetacharacters(source.filePath)) {
     return {
       kind: "unavailable",
       reason: "Image path contains characters that cannot be safely passed to the renderer on this platform."
@@ -1120,14 +1229,15 @@ function renderWithChafa(filePath, shape, env, chafaPath) {
         "--format=symbols",
         "--symbols=block",
         `--size=${shape.widthCells}x${shape.rows}`,
-        filePath
+        "filePath" in source ? source.filePath : "-"
       ],
       {
         encoding: "utf8",
         env: createRendererChildEnv(env),
         shell: useShell,
         maxBuffer: CHAFA_MAX_OUTPUT_BYTES,
-        timeout: CHAFA_TIMEOUT_MS
+        timeout: CHAFA_TIMEOUT_MS,
+        ..."data" in source ? { input: source.data } : {}
       }
     );
     const lines = stdout.split(/\r?\n/).filter((line) => line.length > 0);
@@ -1150,12 +1260,14 @@ __name(firstLineBounded, "firstLineBounded");
 
 export {
   renderMermaidImageAsync,
+  MAX_INLINE_IMAGE_PIXELS,
   TRANSMITTED_KEY_LIMIT,
   wasKittyImageWritten,
   markKittyImageWritten,
   supportsKittyImageProtocol,
   getTerminalImageRenderSupport,
   containsCmdShellMetacharacters,
+  prepareInlineTerminalImage,
   renderTerminalImage
 };
 /**

package/chunks/{chunk-JELIWHXD.js → chunk-AOHJKPKL.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";