@newbase-clawchat/openclaw-clawchat 2026.4.21 → 2026.4.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newbase-clawchat/openclaw-clawchat",
-  "version": "2026.4.21",
+  "version": "2026.4.23",
   "description": "OpenClaw ClawChat channel plugin",
   "files": [
     "index.ts",
@@ -12,8 +12,7 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run typecheck",
-    "release": "npm run prepublishOnly && npm publish",
-    "test-ui": "node ./tools/standalone-webchat-server.mjs"
+    "release": "npm run prepublishOnly && npm publish"
   },
   "dependencies": {
     "@newbase-clawchat/sdk": "^0.1.0",
@@ -46,11 +45,10 @@
       "docsPath": "/channels/openclaw-clawchat",
       "docsLabel": "openclaw-clawchat",
       "blurb":  "OpenClaw ClawChat channel plugin",
-      "order": 110
+      "order": 70
     },
     "install": {
       "npmSpec": "@newbase-clawchat/openclaw-clawchat",
-      "localPath": "extensions/openclaw-clawchat",
       "defaultChoice": "npm",
       "minHostVersion": ">=2026.3.23"
     }

package/src/api-client.test.ts

@@ -96,6 +96,25 @@ describe("openclaw-clawchat api-client", () => {
     expect((init.headers as Record<string, string>)["content-type"]).toBe("application/json");
   });
 
+  it("updateMyProfile forwards bio in the JSON body", async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      jsonResponse({
+        code: 0,
+        message: "ok",
+        data: { user_id: "u1", bio: "hello there" },
+      }),
+    );
+    const client = createOpenclawClawlingApiClient({
+      baseUrl: "https://api.example.com",
+      token: "tk",
+      userId: "agent-1",
+      fetchImpl,
+    });
+    await client.updateMyProfile({ bio: "hello there" });
+    const init = fetchImpl.mock.calls[0]![1] as RequestInit;
+    expect(JSON.parse(init.body as string)).toEqual({ bio: "hello there" });
+  });
+
   it("updateMyProfile throws validation error when userId is not configured", async () => {
     const fetchImpl = vi.fn();
     const client = createOpenclawClawlingApiClient({

package/src/api-client.ts

@@ -24,7 +24,7 @@ export interface OpenclawClawlingApiClient {
   getMyProfile(): Promise<Profile>;
   getUserInfo(userId: string): Promise<Profile>;
   listFriends(params: { page?: number; pageSize?: number }): Promise<FriendList>;
-  updateMyProfile(patch: { nick_name?: string; avatar?: string }): Promise<Profile>;
+  updateMyProfile(patch: { nick_name?: string; avatar_url?: string; bio?: string }): Promise<Profile>;
   uploadMedia(params: { buffer: Buffer; filename: string; mime?: string }): Promise<UploadResult>;
   /**
    * Exchange an invite code for an agent token.
@@ -172,7 +172,7 @@ export function createOpenclawClawlingApiClient(opts: ApiClientOptions): Opencla
       }
       return await call<Profile>(
         "PATCH",
-        `/v1/agents/${encodeURIComponent(opts.userId.trim())}`,
+        `/v1/users/me`,
         {
           body: JSON.stringify(patch),
           headers: { "content-type": "application/json" },

package/src/api-types.ts

@@ -7,9 +7,9 @@
  */
 
 export interface Profile {
-  user_id: string;
-  nick_name: string;
-  avatar?: string;
+  id: string;
+  nickname?: string;
+  avatar_url?: string;
   bio?: string;
 }
 

package/src/channel.outbound.test.ts

@@ -0,0 +1,203 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const getClientMock = vi.hoisted(() => vi.fn());
+const getRuntimeMock = vi.hoisted(() => vi.fn());
+const waitForClientMock = vi.hoisted(() => vi.fn());
+const uploadOutboundMediaMock = vi.hoisted(() => vi.fn());
+const createApiClientMock = vi.hoisted(() => vi.fn());
+const sendTextMock = vi.hoisted(() => vi.fn());
+const sendMediaMock = vi.hoisted(() => vi.fn());
+
+vi.mock("./runtime.ts", () => ({
+  getOpenclawClawlingClient: getClientMock,
+  getOpenclawClawlingRuntime: getRuntimeMock,
+  waitForOpenclawClawlingClient: waitForClientMock,
+  startOpenclawClawlingGateway: vi.fn(),
+}));
+
+vi.mock("./media-runtime.ts", () => ({
+  uploadOutboundMedia: uploadOutboundMediaMock,
+}));
+
+vi.mock("./api-client.ts", () => ({
+  createOpenclawClawlingApiClient: createApiClientMock,
+}));
+
+vi.mock("./outbound.ts", () => ({
+  sendOpenclawClawlingText: sendTextMock,
+  sendOpenclawClawlingMedia: sendMediaMock,
+}));
+
+describe("openclaw-clawchat channel outbound", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    getClientMock.mockReset();
+    getRuntimeMock.mockReset();
+    waitForClientMock.mockReset();
+    uploadOutboundMediaMock.mockReset();
+    createApiClientMock.mockReset();
+    sendTextMock.mockReset();
+    sendMediaMock.mockReset();
+  });
+
+  it("sendText waits for client activation when no active client exists yet", async () => {
+    const client = { sendMessage: vi.fn() };
+    getClientMock.mockReturnValue(undefined);
+    waitForClientMock.mockResolvedValue(client);
+    sendTextMock.mockResolvedValue({ messageId: "m-2", acceptedAt: 456 });
+
+    const { openclawClawlingOutbound } = await import("./outbound.ts");
+    const result = await openclawClawlingOutbound.sendText!({
+      cfg: {
+        channels: {
+          "openclaw-clawchat": {
+            enabled: true,
+            websocketUrl: "ws://t",
+            baseUrl: "https://api.example.com",
+            token: "tk",
+            userId: "agent-1",
+          },
+        },
+      } as never,
+      to: "cc:user-1",
+      text: "hello",
+    });
+
+    expect(waitForClientMock).toHaveBeenCalledWith("default");
+    expect(sendTextMock).toHaveBeenCalledWith({
+      client,
+      account: expect.objectContaining({ userId: "agent-1" }),
+      to: { chatId: "user-1", chatType: "direct" },
+      text: "hello",
+    });
+    expect(result).toEqual({
+      channel: "openclaw-clawchat",
+      to: "cc:user-1",
+      messageId: "m-2",
+    });
+  });
+
+  it("sendMedia uploads mediaUrl and sends resulting fragments", async () => {
+    const client = { sendMessage: vi.fn() };
+    const runtime = { media: { loadWebMedia: vi.fn() } };
+    const apiClient = { uploadMedia: vi.fn() };
+    getClientMock.mockReturnValue(client);
+    getRuntimeMock.mockReturnValue(runtime);
+    createApiClientMock.mockReturnValue(apiClient);
+    uploadOutboundMediaMock.mockResolvedValue([
+      { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
+    ]);
+    sendMediaMock.mockResolvedValue({ messageId: "m-1", acceptedAt: 123 });
+
+    const { openclawClawlingOutbound } = await import("./outbound.ts");
+    const result = await openclawClawlingOutbound.sendMedia!({
+      cfg: {
+        channels: {
+          "openclaw-clawchat": {
+            enabled: true,
+            websocketUrl: "ws://t",
+            baseUrl: "https://api.example.com",
+            token: "tk",
+            userId: "agent-1",
+          },
+        },
+      } as never,
+      to: "cc:group:room-1",
+      text: "caption",
+      mediaUrl: "/tmp/photo.png",
+      mediaLocalRoots: ["/tmp"],
+    });
+
+    expect(createApiClientMock).toHaveBeenCalledWith({
+      baseUrl: "https://api.example.com",
+      token: "tk",
+      userId: "agent-1",
+    });
+    expect(uploadOutboundMediaMock).toHaveBeenCalledWith(["/tmp/photo.png"], {
+      apiClient,
+      runtime,
+      mediaLocalRoots: ["/tmp"],
+    });
+    expect(sendMediaMock).toHaveBeenCalledWith({
+      client,
+      account: expect.objectContaining({ userId: "agent-1", baseUrl: "https://api.example.com" }),
+      to: { chatId: "room-1", chatType: "group" },
+      text: "caption",
+      mediaFragments: [{ kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" }],
+    });
+    expect(result).toEqual({
+      channel: "openclaw-clawchat",
+      to: "cc:group:room-1",
+      messageId: "m-1",
+    });
+  });
+
+  it("sendMedia rejects missing mediaUrl", async () => {
+    getClientMock.mockReturnValue({ sendMessage: vi.fn() });
+    const { openclawClawlingOutbound } = await import("./outbound.ts");
+    await expect(
+      openclawClawlingOutbound.sendMedia!({
+        cfg: {
+          channels: {
+            "openclaw-clawchat": {
+              enabled: true,
+              websocketUrl: "ws://t",
+              baseUrl: "https://api.example.com",
+              token: "tk",
+              userId: "agent-1",
+            },
+          },
+        } as never,
+        to: "cc:user-1",
+        text: "caption",
+      }),
+    ).rejects.toThrow(/requires mediaUrl/);
+  });
+
+  it("sendMedia waits for client activation when no active client exists yet", async () => {
+    const client = { sendMessage: vi.fn() };
+    const runtime = { media: { loadWebMedia: vi.fn() } };
+    const apiClient = { uploadMedia: vi.fn() };
+    getClientMock.mockReturnValue(undefined);
+    waitForClientMock.mockResolvedValue(client);
+    getRuntimeMock.mockReturnValue(runtime);
+    createApiClientMock.mockReturnValue(apiClient);
+    uploadOutboundMediaMock.mockResolvedValue([
+      { kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" },
+    ]);
+    sendMediaMock.mockResolvedValue({ messageId: "m-3", acceptedAt: 789 });
+
+    const { openclawClawlingOutbound } = await import("./outbound.ts");
+    const result = await openclawClawlingOutbound.sendMedia!({
+      cfg: {
+        channels: {
+          "openclaw-clawchat": {
+            enabled: true,
+            websocketUrl: "ws://t",
+            baseUrl: "https://api.example.com",
+            token: "tk",
+            userId: "agent-1",
+          },
+        },
+      } as never,
+      to: "cc:group:room-1",
+      text: "caption",
+      mediaUrl: "/tmp/photo.png",
+      mediaLocalRoots: ["/tmp"],
+    });
+
+    expect(waitForClientMock).toHaveBeenCalledWith("default");
+    expect(sendMediaMock).toHaveBeenCalledWith({
+      client,
+      account: expect.objectContaining({ userId: "agent-1", baseUrl: "https://api.example.com" }),
+      to: { chatId: "room-1", chatType: "group" },
+      text: "caption",
+      mediaFragments: [{ kind: "image", url: "https://cdn/uploaded.png", mime: "image/png" }],
+    });
+    expect(result).toEqual({
+      channel: "openclaw-clawchat",
+      to: "cc:group:room-1",
+      messageId: "m-3",
+    });
+  });
+});

package/src/channel.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { openclawClawlingPlugin } from "./channel.ts";
+import { parseOpenclawRecipient } from "./outbound.ts";
 
 describe("openclaw-clawchat plugin", () => {
   it("publishes openclaw-clawchat channel metadata", () => {
@@ -68,5 +69,23 @@ describe("openclaw-clawchat plugin", () => {
     });
     expect(Array.isArray(hints) && hints.length).toBeGreaterThan(0);
     expect(hints!.some((h) => /ClawChat/.test(h))).toBe(true);
+    expect(hints!.some((h) => /update.*profile|profile.*bio/i.test(h))).toBe(true);
+    expect(hints!.some((h) => /update.*avatar|profile picture|clawchat_upload_avatar/i.test(h))).toBe(
+      true,
+    );
+  });
+
+  it("normalizes openclaw-clawchat targets for host resolution", () => {
+    const normalized = openclawClawlingPlugin.messaging?.normalizeTarget?.(
+      "openclaw-clawchat:usr_01KPN6SQFQEGM9HR11CHRHPMMT",
+    );
+    expect(normalized).toBe("usr_01KPN6SQFQEGM9HR11CHRHPMMT");
+  });
+
+  it("parses openclaw-clawchat target prefix as a direct recipient", () => {
+    expect(parseOpenclawRecipient("openclaw-clawchat:usr_01KPN6SQFQEGM9HR11CHRHPMMT")).toEqual({
+      chatId: "usr_01KPN6SQFQEGM9HR11CHRHPMMT",
+      chatType: "direct",
+    });
   });
 });

package/src/channel.ts

@@ -6,7 +6,6 @@ import {
   type OpenClawConfig,
 } from "openclaw/plugin-sdk/core";
 import { createEmptyChannelDirectoryAdapter } from "openclaw/plugin-sdk/directory-runtime";
-import { chunkMarkdownText } from "openclaw/plugin-sdk/reply-runtime";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
 import {
   createComputedAccountStatusAdapter,
@@ -19,53 +18,8 @@ import {
   resolveOpenclawClawlingAccount,
   type ResolvedOpenclawClawlingAccount,
 } from "./config.ts";
-import type { ChatType } from "./client.ts";
-import { sendOpenclawClawlingText } from "./outbound.ts";
-import { startOpenclawClawlingGateway, getOpenclawClawlingClient } from "./runtime.ts";
-
-/**
- * Parse an agent-initiated outbound recipient string into the new-protocol
- * `chat_id` + `chat_type` pair.
- *
- * Accepted forms (case-insensitive prefix):
- *   - `cc:{chat_id}`                  → direct
- *   - `clawchat:{chat_id}`            → direct
- *   - `cc:direct:{chat_id}`           → direct
- *   - `cc:group:{chat_id}`            → group
- *   - `clawchat:direct:{chat_id}`     → direct
- *   - `clawchat:group:{chat_id}`      → group
- *   - bare `{chat_id}`                → direct (backward compat)
- */
-export function parseOpenclawRecipient(to: string): { chatId: string; chatType: ChatType } {
-  const raw = (to ?? "").trim();
-  if (!raw) throw new Error("openclaw-clawchat: outbound `to` is empty");
-
-  // Split on the first ":" to detect the scheme. If no scheme, treat as a
-  // bare chat_id defaulting to direct.
-  const firstColon = raw.indexOf(":");
-  if (firstColon < 0) return { chatId: raw, chatType: "direct" };
-
-  const scheme = raw.slice(0, firstColon).toLowerCase();
-  const rest = raw.slice(firstColon + 1);
-  if (scheme !== "cc" && scheme !== "clawchat") {
-    // Unknown scheme — treat the whole string as the chat_id for robustness.
-    return { chatId: raw, chatType: "direct" };
-  }
-
-  // After the scheme we optionally accept `direct:` / `group:` type prefix.
-  const secondColon = rest.indexOf(":");
-  if (secondColon >= 0) {
-    const typeToken = rest.slice(0, secondColon).toLowerCase();
-    const chatId = rest.slice(secondColon + 1).trim();
-    if ((typeToken === "direct" || typeToken === "group") && chatId) {
-      return { chatId, chatType: typeToken };
-    }
-  }
-  // No explicit type token → default to direct, chat_id is `rest`.
-  const chatId = rest.trim();
-  if (!chatId) throw new Error(`openclaw-clawchat: missing chat_id in \"${to}\"`);
-  return { chatId, chatType: "direct" };
-}
+import { openclawClawlingOutbound } from "./outbound.ts";
+import { startOpenclawClawlingGateway } from "./runtime.ts";
 
 const configAdapter = createTopLevelChannelConfigAdapter<ResolvedOpenclawClawlingAccount>({
   sectionKey: CHANNEL_ID,
@@ -244,35 +198,25 @@ export const openclawClawlingPlugin: ChannelPlugin<ResolvedOpenclawClawlingAccou
         messageToolHints: () => [
           "To send an image or file to the current user, use the message tool with action='send' and set 'media' to a local file path or a remote URL. You do not need to specify 'to' — the current conversation recipient is used automatically.",
           "When the user asks you to find an image from the web, use a web search or browser tool to find a suitable image URL, then send it using the message tool with 'media' set to that HTTPS image URL — do NOT download the image first.",
+          "When the user asks you to update your profile, nickname, bio, self-introduction, or personal introduction, use `clawchat_update_my_profile` with the relevant fields (`nickname`, `bio`, and/or `avatar_url`).",
+          "When the user asks you to change or update your avatar/profile picture using a local image, first use `clawchat_upload_avatar` to get the avatar URL, then call `clawchat_update_my_profile` with `avatar_url`.",
           "- ClawChat targeting: omit `target` to reply to the current chat (auto-inferred). To send to a specific chat, use `cc:{chat_id}` (direct, default) or `cc:group:{chat_id}` (group). `clawchat:` is accepted as a synonym of `cc:`.",
           "- ClawChat supports media fragments (image / file / audio / video) alongside text in the same message.",
           "- ClawChat stream mode emits `message.created` → progressive `message.add` deltas → `message.done`, followed by a consolidated `message.reply` with the merged text.",
         ],
       },
-    },
-    outbound: {
-      deliveryMode: "direct",
-      chunker: (text, limit) => chunkMarkdownText(text, limit),
-      chunkerMode: "markdown",
-      textChunkLimit: 4000,
-      sendText: async ({ cfg, to, text }) => {
-        const account = resolveOpenclawClawlingAccount(cfg);
-        const client = getOpenclawClawlingClient(account.accountId);
-        if (!client) {
-          throw new Error(`openclaw-clawchat client not running for account ${account.accountId}`);
-        }
-        const recipient = parseOpenclawRecipient(to);
-        const result = await sendOpenclawClawlingText({
-          client,
-          account,
-          to: recipient,
-          text,
-        });
-        return {
-          channel: CHANNEL_ID,
-          to,
-          messageId: result?.messageId ?? `${account.userId}-${Date.now()}`,
-        };
+      messaging: {
+        normalizeTarget: (target) =>
+          target
+            .trim()
+            .replace(/^openclaw-clawchat:/i, "")
+            .replace(/^clawchat:/i, "")
+            .replace(/^cc:/i, ""),
+        targetResolver: {
+          looksLikeId: (raw, normalized) => Boolean((normalized ?? raw).trim()),
+          hint: "active-session",
+        },
       },
     },
+    outbound: openclawClawlingOutbound,
   });

package/src/inbound.test.ts

@@ -230,6 +230,23 @@ describe("openclaw-clawchat inbound", () => {
     ]);
   });
 
+  it("dispatches image-only messages", async () => {
+    const ingest = vi.fn().mockResolvedValue(undefined);
+    const env = buildSendEnvelope({ text: "   " });
+    env.payload.message.body.fragments = [{ kind: "image", url: "https://cdn/x.png" }];
+    await dispatchOpenclawClawlingInbound({
+      envelope: env,
+      cfg: {} as never,
+      runtime: {} as never,
+      account: baseAccount(),
+      ingest,
+    });
+    expect(ingest).toHaveBeenCalledTimes(1);
+    const call = ingest.mock.calls[0]![0];
+    expect(call.rawBody).toBe("![image](https://cdn/x.png)");
+    expect(call.mediaItems).toEqual([{ kind: "image", url: "https://cdn/x.png" }]);
+  });
+
   it("dispatches when sender is only on envelope.sender (real wire, no message.sender)", async () => {
     const ingest = vi.fn().mockResolvedValue(undefined);
     const env = buildSendEnvelope({ text: "hello" });

package/src/inbound.ts

@@ -131,7 +131,9 @@ export async function dispatchOpenclawClawlingInbound(
     return;
   }
   if (!hasRenderableText(message)) {
-    log?.info?.(`[${account.accountId}] openclaw-clawchat skip empty msg=${payload.message_id}`);
+    log?.info?.(
+      `[${account.accountId}] openclaw-clawchat skip empty msg=${payload.message_id}`,
+    );
     return;
   }
   if (rememberAndCheck(payload.message_id)) {

package/src/media-runtime.test.ts

@@ -6,13 +6,6 @@ import {
   type MediaItem,
 } from "./media-runtime.ts";
 
-// loadWebMedia is imported directly in media-runtime.ts (not via runtime.channel.media)
-// because the channel runtime only exposes fetchRemoteMedia/saveMediaBuffer.
-const loadWebMediaMock = vi.hoisted(() => vi.fn());
-vi.mock("openclaw/plugin-sdk/web-media", () => ({
-  loadWebMedia: loadWebMediaMock,
-}));
-
 describe("inferMediaKindFromMime", () => {
   it("maps image/* to image", () => {
     expect(inferMediaKindFromMime("image/png")).toBe("image");
@@ -99,20 +92,21 @@ describe("uploadOutboundMedia", () => {
     } as unknown as ReturnType<typeof import("./api-client.ts").createOpenclawClawlingApiClient>;
   }
 
-  function setupLoadWebMedia() {
-    loadWebMediaMock.mockResolvedValue({
+  function buildRuntime() {
+    const loadWebMedia = vi.fn().mockResolvedValue({
       buffer: Buffer.from("loaded-bytes"),
       contentType: "image/png",
       fileName: "img.png",
     });
-    return loadWebMediaMock;
+    const runtime = {
+      media: { loadWebMedia },
+    } as unknown as import("openclaw/plugin-sdk/core").PluginRuntime;
+    return { runtime, loadWebMedia };
   }
 
   it("loads each url and uploads", async () => {
-    const loadWebMedia = setupLoadWebMedia();
+    const { runtime, loadWebMedia } = buildRuntime();
     const apiClient = buildApiClient();
-    // runtime is unused for uploadOutboundMedia (loadWebMedia is a direct import)
-    const runtime = {} as unknown as import("openclaw/plugin-sdk/core").PluginRuntime;
     const fragments = await uploadOutboundMedia(["https://cdn/in.png", "https://cdn/in2.png"], {
       apiClient,
       runtime,
@@ -137,11 +131,10 @@ describe("uploadOutboundMedia", () => {
   });
 
   it("drops a single failed upload, returns the rest", async () => {
-    setupLoadWebMedia();
+    const { runtime } = buildRuntime();
     const apiClient = buildApiClient();
     (apiClient.uploadMedia as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error("boom"));
     const log = { info: vi.fn(), error: vi.fn() };
-    const runtime = {} as unknown as import("openclaw/plugin-sdk/core").PluginRuntime;
     const fragments = await uploadOutboundMedia(["https://cdn/a.png", "https://cdn/b.png"], {
       apiClient,
       runtime,
@@ -153,7 +146,7 @@ describe("uploadOutboundMedia", () => {
 
   it("returns empty array for empty input", async () => {
     const apiClient = buildApiClient();
-    const runtime = {} as unknown as import("openclaw/plugin-sdk/core").PluginRuntime;
+    const { runtime } = buildRuntime();
     expect(await uploadOutboundMedia([], { apiClient, runtime })).toEqual([]);
   });
 });

package/src/media-runtime.ts

@@ -1,5 +1,4 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk/core";
-import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
 import type { OpenclawClawlingApiClient } from "./api-client.ts";
 
 /**
@@ -98,8 +97,9 @@ export async function fetchInboundMedia(
  * Upload each URL (remote or local path) to /media/upload via the api
  * client and return a fragment ready to splice into `body.fragments`.
  *
- * Uses `loadWebMedia` from `openclaw/plugin-sdk/web-media` (not the channel
- * runtime media helpers, which only expose fetchRemoteMedia/saveMediaBuffer).
+ * Uses the host runtime's `runtime.media.loadWebMedia`, so local-root
+ * enforcement and media-loading policy stay aligned with the current
+ * OpenClaw runtime instead of a directly imported helper.
  *
  * Single-upload failures log at error and are dropped; the remaining
  * fragments still come back so a partially-failing batch still sends the
@@ -114,7 +114,7 @@ export async function uploadOutboundMedia(
   const out: ClawlingMediaFragment[] = [];
   for (const url of urls) {
     try {
-      const loaded = await loadWebMedia(url, {
+      const loaded = await ctx.runtime.media.loadWebMedia(url, {
         maxBytes,
         ...(ctx.mediaLocalRoots && ctx.mediaLocalRoots.length > 0
           ? { localRoots: ctx.mediaLocalRoots }