it("rejects empty or missing names", () => {

expect(isValidProfileName("")).toBe(false);

// @ts-expect-error testing invalid input

expect(isValidProfileName(null)).toBe(false);

// @ts-expect-error testing invalid input

expect(isValidProfileName(undefined)).toBe(false);

expect(isValidProfileName(null as unknown as string)).toBe(false);

expect(isValidProfileName(undefined as unknown as string)).toBe(false);

});

it("rejects names that are too long", () => {

import { Routes } from "discord-api-types/v10";

import { describe, expect, it, vi } from "vitest";

import { RequestClient } from "../internal/discord.js";

import { sendTyping } from "./typing.js";

describe("sendTyping", () => {

it("uses the direct Discord typing REST endpoint", async () => {

const rest = {

post: vi.fn(async () => {}),

};

const rest = new RequestClient("test-token");

const post = vi.spyOn(rest, "post").mockResolvedValue(undefined);

await sendTyping({

// @ts-expect-error test stub only needs rest.post

rest,

channelId: "12345",

});

expect(rest.post).toHaveBeenCalledTimes(1);

expect(rest.post).toHaveBeenCalledWith(Routes.channelTyping("12345"));

expect(post).toHaveBeenCalledTimes(1);

expect(post).toHaveBeenCalledWith(Routes.channelTyping("12345"));

});

it("times out when the typing endpoint hangs", async () => {

vi.useFakeTimers();

try {

const rest = {

post: vi.fn(() => new Promise(() => {})),

};

const rest = new RequestClient("test-token");

vi.spyOn(rest, "post").mockReturnValue(new Promise(() => {}));

const promise = sendTyping({

// @ts-expect-error test stub only needs rest.post

rest,

channelId: "12345",

});

let activeController: AbortController | undefined;

function post(message: TelegramIngressWorkerMessage): void {

// oxlint-disable-next-line unicorn/require-post-message-target-origin -- Node worker_threads ports do not accept a targetOrigin argument.

parentPort?.postMessage(message);

if (parentPort) {

Reflect.apply(Reflect.get(parentPort, "postMessage") as (value: unknown) => void, parentPort, [

message,

]);

}

}

function sleep(ms: number): Promise<void> {

};

},

async stop() {

// oxlint-disable-next-line unicorn/require-post-message-target-origin -- Node worker_threads workers do not accept a targetOrigin argument.

worker.postMessage({ type: "stop" });

Reflect.apply(Reflect.get(worker, "postMessage") as (value: unknown) => void, worker, [

{ type: "stop" },

]);

const timeout = setTimeout(() => {

void worker.terminate();

}, 15_000);

it("handles empty/null inputs safely", () => {

expect(isBotMentioned("", botShip)).toBe(false);

expect(isBotMentioned("test", "")).toBe(false);

// @ts-expect-error testing null input

expect(isBotMentioned(null, botShip)).toBe(false);

expect(isBotMentioned(null as unknown as string, botShip)).toBe(false);

});

it("requires word boundary for nickname", () => {

}

}

// oxlint-disable-next-line unicorn/require-post-message-target-origin -- Node worker_threads MessagePort, not window.postMessage.

parentPort?.postMessage(await main());

if (parentPort) {

Reflect.apply(Reflect.get(parentPort, "postMessage") as (message: unknown) => void, parentPort, [

await main(),

]);

}

import { t } from "../../i18n/index.ts";

import { icons } from "../icons.ts";

const ESCAPE = String.fromCharCode(0x1b);

const OSC8_LINK_RE = new RegExp(

`${ESCAPE}\\]8;;.*?${ESCAPE}\\\\|${ESCAPE}\\]8;;${ESCAPE}\\\\`,

"g",

);

const SGR_RE = new RegExp(`${ESCAPE}\\[[0-9;]*m`, "g");

/** Strip ANSI escape codes (SGR, OSC-8) for readable log display. */

function stripAnsi(text: string): string {

/* eslint-disable no-control-regex -- stripping ANSI escape sequences requires matching ESC */

return text.replace(/\x1b\]8;;.*?\x1b\\|\x1b\]8;;\x1b\\/g, "").replace(/\x1b\[[0-9;]*m/g, "");

return text.replace(OSC8_LINK_RE, "").replace(SGR_RE, "");

}

export type OverviewLogTailProps = {