@kodelyth/nextcloud-talk 2026.5.42 → 2026.6.1

package/src/inbound.ts

@@ -1,392 +0,0 @@
-import {
-  channelIngressRoutes,
-  resolveStableChannelMessageIngress,
-} from "klaw/plugin-sdk/channel-ingress-runtime";
-import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "klaw/plugin-sdk/inbound-envelope";
-import {
-  normalizeOptionalString,
-  normalizeStringEntries,
-} from "klaw/plugin-sdk/string-coerce-runtime";
-import {
-  GROUP_POLICY_BLOCKED_LABEL,
-  resolveAllowlistProviderRuntimeGroupPolicy,
-  createChannelPairingController,
-  deliverFormattedTextWithAttachments,
-  logInboundDrop,
-  resolveDefaultGroupPolicy,
-  warnMissingProviderGroupPolicyFallbackOnce,
-  type GroupPolicy,
-  type KlawConfig,
-  type OutboundReplyPayload,
-  type RuntimeEnv,
-} from "../runtime-api.js";
-import type { ResolvedNextcloudTalkAccount } from "./accounts.js";
-import {
-  normalizeNextcloudTalkAllowEntry,
-  normalizeNextcloudTalkAllowlist,
-  resolveNextcloudTalkAllowlistMatch,
-  resolveNextcloudTalkRequireMention,
-  resolveNextcloudTalkRoomMatch,
-} from "./policy.js";
-import { resolveNextcloudTalkRoomKind } from "./room-info.js";
-import { getNextcloudTalkRuntime } from "./runtime.js";
-import { sendMessageNextcloudTalk } from "./send.js";
-import type { CoreConfig, NextcloudTalkInboundMessage, NextcloudTalkRoomConfig } from "./types.js";
-
-const CHANNEL_ID = "nextcloud-talk" as const;
-
-type NextcloudTalkRoomMatch = ReturnType<typeof resolveNextcloudTalkRoomMatch>;
-
-function hasAllowEntries(entries: string[]): boolean {
-  return normalizeNextcloudTalkAllowlist(entries).length > 0;
-}
-
-function roomRoutes(params: {
-  isGroup: boolean;
-  groupPolicy: GroupPolicy;
-  roomMatch: NextcloudTalkRoomMatch;
-  roomConfig?: NextcloudTalkRoomConfig;
-  senderId: string;
-  outerGroupAllowFrom: string[];
-  roomAllowFrom: string[];
-}) {
-  if (!params.isGroup) {
-    return [];
-  }
-  const roomSenderConfigured =
-    params.groupPolicy === "allowlist" && hasAllowEntries(params.roomAllowFrom);
-  return channelIngressRoutes(
-    params.roomMatch.allowlistConfigured && {
-      id: "nextcloud-talk:room",
-      allowed: params.roomMatch.allowed,
-      precedence: 0,
-      matchId: "nextcloud-talk-room",
-      blockReason: "room_not_allowlisted",
-    },
-    params.roomConfig?.enabled === false && {
-      id: "nextcloud-talk:room-enabled",
-      enabled: false,
-      precedence: 10,
-      blockReason: "room_disabled",
-    },
-    roomSenderConfigured && {
-      id: "nextcloud-talk:room-sender",
-      kind: "nestedAllowlist",
-      precedence: 20,
-      blockReason: "room_sender_not_allowlisted",
-      ...(!hasAllowEntries(params.outerGroupAllowFrom)
-        ? {
-            senderPolicy: "replace" as const,
-            senderAllowFrom: params.roomAllowFrom,
-          }
-        : {
-            allowed: resolveNextcloudTalkAllowlistMatch({
-              allowFrom: params.roomAllowFrom,
-              senderId: params.senderId,
-            }).allowed,
-            matchId: "nextcloud-talk-room-sender",
-          }),
-    },
-  );
-}
-
-async function deliverNextcloudTalkReply(params: {
-  cfg: CoreConfig;
-  payload: OutboundReplyPayload;
-  roomToken: string;
-  accountId: string;
-  statusSink?: (patch: { lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { cfg, payload, roomToken, accountId, statusSink } = params;
-  await deliverFormattedTextWithAttachments({
-    payload,
-    send: async ({ text, replyToId }) => {
-      await sendMessageNextcloudTalk(roomToken, text, {
-        cfg,
-        accountId,
-        replyTo: replyToId,
-      });
-      statusSink?.({ lastOutboundAt: Date.now() });
-    },
-  });
-}
-
-export async function handleNextcloudTalkInbound(params: {
-  message: NextcloudTalkInboundMessage;
-  account: ResolvedNextcloudTalkAccount;
-  config: CoreConfig;
-  runtime: RuntimeEnv;
-  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
-}): Promise<void> {
-  const { message, account, config, runtime, statusSink } = params;
-  const core = getNextcloudTalkRuntime();
-  const pairing = createChannelPairingController({
-    core,
-    channel: CHANNEL_ID,
-    accountId: account.accountId,
-  });
-
-  const rawBody = message.text?.trim() ?? "";
-  if (!rawBody) {
-    return;
-  }
-
-  const roomKind = await resolveNextcloudTalkRoomKind({
-    account,
-    roomToken: message.roomToken,
-    runtime,
-  });
-  const isGroup = roomKind === "direct" ? false : roomKind === "group" ? true : message.isGroupChat;
-  const senderId = message.senderId;
-  const senderName = message.senderName;
-  const roomToken = message.roomToken;
-  const roomName = message.roomName;
-
-  statusSink?.({ lastInboundAt: message.timestamp });
-
-  const roomMatch = resolveNextcloudTalkRoomMatch({
-    rooms: account.config.rooms,
-    roomToken,
-  });
-  const roomConfig = roomMatch.roomConfig;
-  const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-    cfg: config as KlawConfig,
-    surface: CHANNEL_ID,
-  });
-  const hasControlCommand = core.channel.text.hasControlCommand(rawBody, config as KlawConfig);
-  const shouldRequireMention = isGroup
-    ? resolveNextcloudTalkRequireMention({
-        roomConfig,
-        wildcardConfig: roomMatch.wildcardConfig,
-      })
-    : false;
-  const { groupPolicy, providerMissingFallbackApplied } =
-    resolveAllowlistProviderRuntimeGroupPolicy({
-      providerConfigPresent:
-        ((config.channels as Record<string, unknown> | undefined)?.[CHANNEL_ID] ?? undefined) !==
-        undefined,
-      groupPolicy: account.config.groupPolicy,
-      defaultGroupPolicy: resolveDefaultGroupPolicy(config as KlawConfig),
-    });
-  const allowFrom = normalizeStringEntries(account.config.allowFrom);
-  const outerGroupAllowFrom = account.config.groupAllowFrom?.length
-    ? normalizeStringEntries(account.config.groupAllowFrom)
-    : allowFrom;
-  const roomAllowFrom = normalizeStringEntries(roomConfig?.allowFrom);
-  const resolveAccess = async (wasMentioned?: boolean) =>
-    await resolveStableChannelMessageIngress({
-      channelId: CHANNEL_ID,
-      accountId: account.accountId,
-      identity: {
-        key: "nextcloud-talk-user-id",
-        normalize: (value) => normalizeNextcloudTalkAllowEntry(value) || null,
-        sensitivity: "pii",
-        entryIdPrefix: "nextcloud-talk-entry",
-      },
-      cfg: config as KlawConfig,
-      readStoreAllowFrom: async () =>
-        await pairing.readStoreForDmPolicy(CHANNEL_ID, account.accountId),
-      subject: { stableId: senderId },
-      conversation: {
-        kind: isGroup ? "group" : "direct",
-        id: isGroup ? roomToken : senderId,
-      },
-      route: roomRoutes({
-        isGroup,
-        groupPolicy,
-        roomMatch,
-        roomConfig,
-        senderId,
-        outerGroupAllowFrom,
-        roomAllowFrom,
-      }),
-      dmPolicy: account.config.dmPolicy ?? "pairing",
-      groupPolicy,
-      policy: {
-        groupAllowFromFallbackToAllowFrom: true,
-        activation: {
-          requireMention: isGroup && shouldRequireMention,
-          allowTextCommands,
-        },
-      },
-      mentionFacts:
-        isGroup && wasMentioned !== undefined
-          ? {
-              canDetectMention: true,
-              wasMentioned,
-              hasAnyMention: wasMentioned,
-            }
-          : undefined,
-      allowFrom,
-      groupAllowFrom: account.config.groupAllowFrom,
-      command: {
-        allowTextCommands,
-        hasControlCommand,
-      },
-    });
-  let access = await resolveAccess();
-  warnMissingProviderGroupPolicyFallbackOnce({
-    providerMissingFallbackApplied,
-    providerKey: "nextcloud-talk",
-    accountId: account.accountId,
-    blockedLabel: GROUP_POLICY_BLOCKED_LABEL.room,
-    log: (message) => runtime.log?.(message),
-  });
-  const commandAuthorized = access.commandAccess.authorized;
-  const accessReason =
-    access.ingress.reasonCode === "route_blocked"
-      ? "route blocked"
-      : access.senderAccess.reasonCode;
-
-  if (isGroup) {
-    if (access.routeAccess.reason === "room_not_allowlisted") {
-      runtime.log?.(`nextcloud-talk: drop room ${roomToken} (not allowlisted)`);
-      return;
-    }
-    if (access.routeAccess.reason === "room_disabled") {
-      runtime.log?.(`nextcloud-talk: drop room ${roomToken} (disabled)`);
-      return;
-    }
-    if (access.routeAccess.reason === "room_sender_not_allowlisted") {
-      runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (policy=${groupPolicy})`);
-      return;
-    }
-    if (access.senderAccess.decision !== "allow") {
-      runtime.log?.(`nextcloud-talk: drop group sender ${senderId} (reason=${accessReason})`);
-      return;
-    }
-  } else {
-    if (access.senderAccess.decision !== "allow") {
-      if (access.senderAccess.decision === "pairing") {
-        await pairing.issueChallenge({
-          senderId,
-          senderIdLine: `Your Nextcloud user id: ${senderId}`,
-          meta: { name: senderName || undefined },
-          sendPairingReply: async (text) => {
-            await sendMessageNextcloudTalk(roomToken, text, {
-              cfg: config,
-              accountId: account.accountId,
-            });
-            statusSink?.({ lastOutboundAt: Date.now() });
-          },
-          onReplyError: (err) => {
-            runtime.error?.(`nextcloud-talk: pairing reply failed for ${senderId}: ${String(err)}`);
-          },
-        });
-      }
-      runtime.log?.(`nextcloud-talk: drop DM sender ${senderId} (reason=${accessReason})`);
-      return;
-    }
-  }
-
-  if (access.commandAccess.shouldBlockControlCommand) {
-    logInboundDrop({
-      log: (message) => runtime.log?.(message),
-      channel: CHANNEL_ID,
-      reason: "control command (unauthorized)",
-      target: senderId,
-    });
-    return;
-  }
-
-  const mentionRegexes = core.channel.mentions.buildMentionRegexes(config as KlawConfig);
-  const wasMentioned = mentionRegexes.length
-    ? core.channel.mentions.matchesMentionPatterns(rawBody, mentionRegexes)
-    : false;
-  if (isGroup) {
-    access = await resolveAccess(wasMentioned);
-  }
-
-  if (isGroup && access.activationAccess.shouldSkip) {
-    runtime.log?.(`nextcloud-talk: drop room ${roomToken} (no mention)`);
-    return;
-  }
-  const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
-    cfg: config as KlawConfig,
-    channel: CHANNEL_ID,
-    accountId: account.accountId,
-    peer: {
-      kind: isGroup ? "group" : "direct",
-      id: isGroup ? roomToken : senderId,
-    },
-    runtime: core.channel,
-    sessionStore: (config.session as Record<string, unknown> | undefined)?.store as
-      | string
-      | undefined,
-  });
-
-  const fromLabel = isGroup ? `room:${roomName || roomToken}` : senderName || `user:${senderId}`;
-  const { storePath, body } = buildEnvelope({
-    channel: "Nextcloud Talk",
-    from: fromLabel,
-    timestamp: message.timestamp,
-    body: rawBody,
-  });
-
-  const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
-
-  const ctxPayload = core.channel.reply.finalizeInboundContext({
-    Body: body,
-    BodyForAgent: rawBody,
-    RawBody: rawBody,
-    CommandBody: rawBody,
-    From: isGroup ? `nextcloud-talk:room:${roomToken}` : `nextcloud-talk:${senderId}`,
-    To: `nextcloud-talk:${roomToken}`,
-    SessionKey: route.sessionKey,
-    AccountId: route.accountId,
-    ChatType: isGroup ? "group" : "direct",
-    ConversationLabel: fromLabel,
-    SenderName: senderName || undefined,
-    SenderId: senderId,
-    GroupSubject: isGroup ? roomName || roomToken : undefined,
-    GroupSystemPrompt: isGroup ? groupSystemPrompt : undefined,
-    Provider: CHANNEL_ID,
-    Surface: CHANNEL_ID,
-    WasMentioned: isGroup ? wasMentioned : undefined,
-    MessageSid: message.messageId,
-    Timestamp: message.timestamp,
-    OriginatingChannel: CHANNEL_ID,
-    OriginatingTo: `nextcloud-talk:${roomToken}`,
-    CommandAuthorized: commandAuthorized,
-  });
-
-  await core.channel.turn.runAssembled({
-    cfg: config as KlawConfig,
-    channel: CHANNEL_ID,
-    accountId: account.accountId,
-    agentId: route.agentId,
-    routeSessionKey: route.sessionKey,
-    storePath,
-    ctxPayload,
-    recordInboundSession: core.channel.session.recordInboundSession,
-    dispatchReplyWithBufferedBlockDispatcher:
-      core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
-    delivery: {
-      deliver: async (payload) => {
-        await deliverNextcloudTalkReply({
-          cfg: config,
-          payload,
-          roomToken,
-          accountId: account.accountId,
-          statusSink,
-        });
-      },
-      onError: (err, info) => {
-        runtime.error?.(`nextcloud-talk ${info.kind} reply failed: ${String(err)}`);
-      },
-    },
-    replyPipeline: {},
-    replyOptions: {
-      skillFilter: roomConfig?.skills,
-      disableBlockStreaming:
-        typeof account.config.blockStreaming === "boolean"
-          ? !account.config.blockStreaming
-          : undefined,
-    },
-    record: {
-      onRecordError: (err) => {
-        runtime.error?.(`nextcloud-talk: failed updating session meta: ${String(err)}`);
-      },
-    },
-  });
-}

package/src/message-actions.test.ts

@@ -1,270 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-types";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { CoreConfig } from "./types.js";
-
-const hoisted = vi.hoisted(() => ({
-  sendReactionNextcloudTalk: vi.fn(),
-  sendMessageNextcloudTalk: vi.fn(),
-  listNextcloudTalkAccountIds: vi.fn(),
-  resolveNextcloudTalkAccount: vi.fn(),
-}));
-
-vi.mock("./send.js", () => ({
-  sendReactionNextcloudTalk: hoisted.sendReactionNextcloudTalk,
-  sendMessageNextcloudTalk: hoisted.sendMessageNextcloudTalk,
-}));
-
-vi.mock("./accounts.js", () => ({
-  listNextcloudTalkAccountIds: hoisted.listNextcloudTalkAccountIds,
-  resolveNextcloudTalkAccount: hoisted.resolveNextcloudTalkAccount,
-}));
-
-const { nextcloudTalkMessageActions } = await import("./message-actions.js");
-
-const configuredAccount = {
-  accountId: "default",
-  enabled: true,
-  baseUrl: "https://nc.example.com",
-  secret: "bot-secret",
-} as const;
-
-const unconfiguredAccount = {
-  accountId: "default",
-  enabled: true,
-  baseUrl: "",
-  secret: null,
-} as const;
-
-const disabledAccount = {
-  accountId: "default",
-  enabled: false,
-  baseUrl: "https://nc.example.com",
-  secret: "bot-secret",
-} as const;
-
-describe("nextcloudTalkMessageActions", () => {
-  beforeEach(() => {
-    hoisted.sendReactionNextcloudTalk.mockReset();
-    hoisted.sendReactionNextcloudTalk.mockResolvedValue({ ok: true });
-    hoisted.sendMessageNextcloudTalk.mockReset();
-    hoisted.listNextcloudTalkAccountIds.mockReset();
-    hoisted.resolveNextcloudTalkAccount.mockReset();
-  });
-
-  describe("describeMessageTool", () => {
-    it("returns null when no accounts are configured", () => {
-      hoisted.listNextcloudTalkAccountIds.mockReturnValue([]);
-
-      const result = nextcloudTalkMessageActions.describeMessageTool?.({
-        cfg: {} as KlawConfig,
-      });
-
-      expect(result).toBeNull();
-    });
-
-    it("returns null when configured account has no secret/baseUrl", () => {
-      hoisted.listNextcloudTalkAccountIds.mockReturnValue([unconfiguredAccount.accountId]);
-      hoisted.resolveNextcloudTalkAccount.mockReturnValue(unconfiguredAccount);
-
-      const result = nextcloudTalkMessageActions.describeMessageTool?.({
-        cfg: {} as KlawConfig,
-      });
-
-      expect(result).toBeNull();
-    });
-
-    it("returns null when the only listed account is disabled", () => {
-      hoisted.listNextcloudTalkAccountIds.mockReturnValue([disabledAccount.accountId]);
-      hoisted.resolveNextcloudTalkAccount.mockReturnValue(disabledAccount);
-
-      const result = nextcloudTalkMessageActions.describeMessageTool?.({
-        cfg: {} as KlawConfig,
-      });
-
-      expect(result).toBeNull();
-    });
-
-    it("advertises send + react when an account is configured", () => {
-      hoisted.listNextcloudTalkAccountIds.mockReturnValue([configuredAccount.accountId]);
-      hoisted.resolveNextcloudTalkAccount.mockReturnValue(configuredAccount);
-
-      const result = nextcloudTalkMessageActions.describeMessageTool?.({
-        cfg: {} as KlawConfig,
-      });
-
-      expect(result?.actions).toEqual(["send", "react"]);
-    });
-
-    it("scopes discovery to a specific accountId when provided", () => {
-      hoisted.resolveNextcloudTalkAccount.mockReturnValue(configuredAccount);
-
-      const result = nextcloudTalkMessageActions.describeMessageTool?.({
-        cfg: {} as KlawConfig,
-        accountId: "work",
-      });
-
-      expect(hoisted.resolveNextcloudTalkAccount).toHaveBeenCalledWith({
-        cfg: {},
-        accountId: "work",
-      });
-      expect(hoisted.listNextcloudTalkAccountIds).not.toHaveBeenCalled();
-      expect(result?.actions).toEqual(["send", "react"]);
-    });
-
-    it("returns null when the targeted account is disabled", () => {
-      hoisted.resolveNextcloudTalkAccount.mockReturnValue(disabledAccount);
-
-      const result = nextcloudTalkMessageActions.describeMessageTool?.({
-        cfg: {} as KlawConfig,
-        accountId: "work",
-      });
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("supportsAction", () => {
-    it("delegates send back to outbound", () => {
-      expect(nextcloudTalkMessageActions.supportsAction?.({ action: "send" })).toBe(false);
-    });
-
-    it("handles react locally", () => {
-      expect(nextcloudTalkMessageActions.supportsAction?.({ action: "react" })).toBe(true);
-    });
-  });
-
-  describe("handleAction", () => {
-    const cfg = {} as CoreConfig;
-
-    it("invokes sendReactionNextcloudTalk with normalized params for the react action", async () => {
-      const result = await nextcloudTalkMessageActions.handleAction?.({
-        channel: "nextcloud-talk",
-        action: "react",
-        params: { to: "room:abc123", messageId: "42", emoji: "👍" },
-        cfg,
-        accountId: "work",
-      });
-
-      expect(hoisted.sendReactionNextcloudTalk).toHaveBeenCalledTimes(1);
-      expect(hoisted.sendReactionNextcloudTalk).toHaveBeenCalledWith("room:abc123", "42", "👍", {
-        accountId: "work",
-        cfg,
-      });
-      expect(result).toMatchObject({
-        details: { ok: true, added: "👍" },
-      });
-    });
-
-    it("uses toolContext.currentMessageId when params.messageId is missing", async () => {
-      await nextcloudTalkMessageActions.handleAction?.({
-        channel: "nextcloud-talk",
-        action: "react",
-        params: { to: "room:abc123", emoji: "✅" },
-        cfg,
-        accountId: null,
-        toolContext: { currentMessageId: 99 },
-      });
-
-      expect(hoisted.sendReactionNextcloudTalk).toHaveBeenCalledWith("room:abc123", "99", "✅", {
-        accountId: undefined,
-        cfg,
-      });
-    });
-
-    it("requires a target room token", async () => {
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "react",
-          params: { messageId: "1", emoji: "👍" },
-          cfg,
-        }),
-      ).rejects.toThrow(/to \(room token\) required/);
-      expect(hoisted.sendReactionNextcloudTalk).not.toHaveBeenCalled();
-    });
-
-    it("requires a messageId (explicit or via toolContext)", async () => {
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "react",
-          params: { to: "room:abc123", emoji: "👍" },
-          cfg,
-        }),
-      ).rejects.toThrow(/messageId required/);
-      expect(hoisted.sendReactionNextcloudTalk).not.toHaveBeenCalled();
-    });
-
-    it("requires an emoji", async () => {
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "react",
-          params: { to: "room:abc123", messageId: "1" },
-          cfg,
-        }),
-      ).rejects.toThrow(/emoji required/);
-      expect(hoisted.sendReactionNextcloudTalk).not.toHaveBeenCalled();
-    });
-
-    it("rejects send through the action handler (outbound owns send)", async () => {
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "send",
-          params: { to: "room:abc123", text: "hi" },
-          cfg,
-        }),
-      ).rejects.toThrow(/handled by outbound/);
-    });
-
-    it("rejects unsupported actions", async () => {
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "delete",
-          params: {},
-          cfg,
-        }),
-      ).rejects.toThrow(/Action delete not supported for nextcloud-talk/);
-    });
-
-    it("rejects reaction removal requests without calling the add-reaction sender", async () => {
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "react",
-          params: { to: "room:abc123", messageId: "1", emoji: "👍", remove: true },
-          cfg,
-        }),
-      ).rejects.toThrow(/removal is not supported/);
-      expect(hoisted.sendReactionNextcloudTalk).not.toHaveBeenCalled();
-    });
-
-    it("still adds the reaction when remove is explicitly false", async () => {
-      await nextcloudTalkMessageActions.handleAction?.({
-        channel: "nextcloud-talk",
-        action: "react",
-        params: { to: "room:abc123", messageId: "1", emoji: "👍", remove: false },
-        cfg,
-      });
-
-      expect(hoisted.sendReactionNextcloudTalk).toHaveBeenCalledTimes(1);
-    });
-
-    it("propagates errors from sendReactionNextcloudTalk", async () => {
-      hoisted.sendReactionNextcloudTalk.mockRejectedValueOnce(
-        new Error("Nextcloud Talk reaction failed: 403 forbidden"),
-      );
-
-      await expect(
-        nextcloudTalkMessageActions.handleAction?.({
-          channel: "nextcloud-talk",
-          action: "react",
-          params: { to: "room:abc123", messageId: "1", emoji: "👍" },
-          cfg,
-        }),
-      ).rejects.toThrow(/403 forbidden/);
-    });
-  });
-});