@toloka-platform/sdk 0.1.0-preview.6 → 0.1.0-preview.7

package/src/cli/program.ts

@@ -1,11 +1,20 @@
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 import { assert } from "es-toolkit";
+import { writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { createClient } from "../client";
 import type { PotatoClient } from "../client";
 import { readTolokaState } from "../state";
 import type { TolokaState } from "../state";
+import {
+  CHECK_RESULT_FILE_ENV,
+  checkProject,
+  watchProjectChecks,
+  runFreshCheck,
+  type CheckProjectOptions,
+  type CheckProjectResult,
+} from "./check";
 import { authStatus, login, logout } from "./auth";
 import type { AuthPrompt } from "./auth";
 import { commandNameFromArgv, createCliAnalytics } from "./analytics";
@@ -83,6 +92,7 @@ export type ProgramContext = {
   readonly environment: TolokaEnvironment;
   readonly io: CliIo;
   readonly injectedClient?: PotatoClient;
+  readonly runChecks?: typeof checkProject;
   readonly analytics?: CliAnalytics;
 };
 
@@ -202,6 +212,29 @@ export type CreatedProgram = {
 export function createProgram(context: ProgramContext): CreatedProgram {
   const program = new Command("toloka");
   const exitCode = { value: 0 };
+  const runChecks = context.runChecks ?? checkProject;
+  const runChecksInterruptibly = async (
+    options: CheckProjectOptions,
+    runner: (options: CheckProjectOptions) => Promise<CheckProjectResult> = runChecks,
+  ): Promise<{ result: CheckProjectResult; interruptedExitCode?: number }> => {
+    const abortController = new AbortController();
+    let interruptedExitCode: number | undefined;
+    const interrupt = (exitCode: number) => {
+      interruptedExitCode = exitCode;
+      abortController.abort();
+    };
+    const interruptSigint = () => interrupt(130);
+    const interruptSigterm = () => interrupt(143);
+    process.on("SIGINT", interruptSigint);
+    process.on("SIGTERM", interruptSigterm);
+    try {
+      const result = await runner({ ...options, signal: abortController.signal });
+      return { result, ...(interruptedExitCode === undefined ? {} : { interruptedExitCode }) };
+    } finally {
+      process.off("SIGINT", interruptSigint);
+      process.off("SIGTERM", interruptSigterm);
+    }
+  };
   let warnedAboutStaleSkills = false;
 
   program
@@ -324,8 +357,9 @@ export function createProgram(context: ProgramContext): CreatedProgram {
     .description("select and manage the current platform project");
   project
     .command("list")
+    .option("--limit <n>", "maximum projects to list", positiveInteger)
     .description("list remote projects this key can see")
-    .action(async () => {
+    .action(async (options: { limit?: number }) => {
       const flags = globals();
       const { client, stored, state } = await resolveContext(flags, context);
       const selected = resolveSelectedProject(flags, context, stored, state);
@@ -333,6 +367,7 @@ export function createProgram(context: ProgramContext): CreatedProgram {
         client,
         io: context.io,
         ...(selected === undefined ? {} : { context: selected }),
+        ...(options.limit === undefined ? {} : { limit: options.limit }),
       });
     });
   project
@@ -440,9 +475,12 @@ export function createProgram(context: ProgramContext): CreatedProgram {
     .action(async () => {
       const flags = globals();
       const sourceRoot = resolveInitRoot(flags);
-      const stored = await readCommandCredentials(flags, context);
       const state = await readTolokaState(sourceRoot);
-      const selected = resolveSelectedProject(flags, context, stored, state);
+      const selected = resolveProjectContext({
+        flags,
+        environment: context.environment,
+        ...(state === undefined ? {} : { state }),
+      });
       const result = await initProject(
         sourceRoot,
         selected === undefined ? {} : { projectId: selected.id },
@@ -500,13 +538,89 @@ export function createProgram(context: ProgramContext): CreatedProgram {
       if (!result.valid) exitCode.value = 1;
     });
 
+  program
+    .command("check")
+    .argument("[pipeline]", "pipeline source directory or name")
+    .option("--node <node>", "check one code or human-work node by name or id")
+    .option("--json", "print the structured check report", false)
+    .option("--watch", "rerun checks when project files change", false)
+    .description("run the complete local source, type, and test gate")
+    .action(
+      async (
+        pipeline: string | undefined,
+        options: { node?: string; json: boolean; watch: boolean },
+      ) => {
+        const sourceRoot = await resolveSourceRoot(globals(), context.io);
+        const checkOptions = {
+          environment: context.environment,
+          sourceRoot,
+          ...(pipeline === undefined ? {} : { pipeline }),
+          ...(options.node === undefined ? {} : { node: options.node }),
+          ...(options.json ? { json: true } : {}),
+        };
+        const writeCheckOutput = async (output: string): Promise<void> => {
+          const resultPath = context.environment[CHECK_RESULT_FILE_ENV];
+          if (resultPath === undefined) context.io.stdout(output);
+          else await writeFile(resultPath, output, "utf8");
+        };
+        const checkRunner =
+          context.runChecks === undefined &&
+          context.environment[CHECK_RESULT_FILE_ENV] === undefined
+            ? runFreshCheck
+            : runChecks;
+        if (options.watch) {
+          const abortController = new AbortController();
+          const stop = () => abortController.abort();
+          process.on("SIGINT", stop);
+          process.on("SIGTERM", stop);
+          try {
+            await watchProjectChecks(
+              checkOptions,
+              async (result) => {
+                await writeCheckOutput(result.output);
+                exitCode.value = result.exitCode;
+              },
+              undefined,
+              abortController.signal,
+            );
+          } finally {
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+          }
+          return;
+        }
+        const { result, interruptedExitCode } = await runChecksInterruptibly(
+          checkOptions,
+          checkRunner,
+        );
+        await writeCheckOutput(result.output);
+        exitCode.value = interruptedExitCode ?? result.exitCode;
+      },
+    );
+
   program
     .command("apply")
-    .description("make the platform match source")
+    .description("check source, then make the platform match it")
     .action(async () => {
-      const { sourceRoot, client, projectId } = await resolveContext(globals(), context);
+      const sourceRoot = await resolveSourceRoot(globals(), context.io);
+      const { result: checked, interruptedExitCode } = await runChecksInterruptibly({
+        sourceRoot,
+        environment: context.environment,
+      });
+      context.io.stdout(checked.output);
+      if (interruptedExitCode !== undefined) {
+        exitCode.value = interruptedExitCode;
+        return;
+      }
+      if (checked.exitCode !== 0) {
+        exitCode.value = checked.exitCode;
+        return;
+      }
+      assert(checked.source, "Passing checks must return project source");
+      const { client, projectId } = await resolveContext(globals(), context);
       const result = await applyProject(client, {
         sourceRoot,
+        source: checked.source,
         ...(projectId === undefined ? {} : { projectId }),
       });
       context.io.stdout(result.output);
@@ -699,11 +813,17 @@ export function createProgram(context: ProgramContext): CreatedProgram {
     .description("operate on a live pipeline in the selected project");
   pipeline
     .command("list")
+    .option("--limit <n>", "maximum pipelines to list", positiveInteger)
     .description("list live pipelines in the selected project")
-    .action(async () => {
+    .action(async (options: { limit?: number }) => {
       const { client, projectId, state } = await resolveContext(globals(), context);
       assert(projectId, MISSING_PROJECT_ID_MESSAGE);
-      const result = await listLivePipelines({ client, projectId, state });
+      const result = await listLivePipelines({
+        client,
+        projectId,
+        state,
+        ...(options.limit === undefined ? {} : { limit: options.limit }),
+      });
       context.io.stdout(result.output);
     });
   pipeline
@@ -1005,27 +1125,35 @@ export async function runTolokaCli(
   environment: TolokaEnvironment = process.env,
   io: CliIo = terminalIo(),
   injectedClient?: PotatoClient,
-  analytics: CliAnalytics = createCliAnalytics({ environment }),
+  analytics?: CliAnalytics,
+  runChecks?: typeof checkProject,
 ): Promise<number> {
+  const activeAnalytics =
+    environment[CHECK_RESULT_FILE_ENV] === undefined
+      ? (analytics ?? createCliAnalytics({ environment }))
+      : undefined;
   const { program, exitCode } = createProgram({
     environment,
     io,
-    analytics,
+    ...(activeAnalytics === undefined ? {} : { analytics: activeAnalytics }),
     ...(injectedClient === undefined ? {} : { injectedClient }),
+    ...(runChecks === undefined ? {} : { runChecks }),
   });
 
   const startedAt = Date.now();
   const result = await runProgram(program, exitCode, argv, io);
-  try {
-    analytics.captureCommand({
-      command: commandNameFromArgv(argv),
-      durationMs: Date.now() - startedAt,
-      exitCode: result.code,
-      outcome: result.outcome,
-      ...(result.error === undefined ? {} : { error: result.error }),
-    });
-    await analytics.shutdown();
-  } catch {}
+  if (activeAnalytics !== undefined) {
+    try {
+      activeAnalytics.captureCommand({
+        command: commandNameFromArgv(argv),
+        durationMs: Date.now() - startedAt,
+        exitCode: result.code,
+        outcome: result.outcome,
+        ...(result.error === undefined ? {} : { error: result.error }),
+      });
+      await activeAnalytics.shutdown();
+    } catch {}
+  }
 
   return result.code;
 }

package/src/cli/project-context.ts

@@ -11,7 +11,10 @@ type ProjectRecord = { readonly id: string; readonly name: string; readonly team
 
 export type ProjectListApi = {
   readonly projects: {
-    readonly listAll: (params?: object) => AsyncIterable<ProjectRecord>;
+    readonly listPage: (params: { readonly limit: number }) => Promise<{
+      readonly projects: readonly ProjectRecord[];
+      readonly pagination: { readonly total: number; readonly hasMore: boolean };
+    }>;
   };
 };
 
@@ -225,15 +228,22 @@ export async function listRemoteProjects(options: {
   readonly client: ProjectListApi;
   readonly context?: ProjectContext;
   readonly io: ProjectIo;
+  readonly limit?: number;
 }): Promise<{ readonly output: string }> {
-  const lines: string[] = [];
-  for await (const project of options.client.projects.listAll()) {
+  const limit = options.limit ?? 20;
+  const page = await options.client.projects.listPage({ limit });
+  const lines = page.projects.map((project) => {
     const mark = options.context?.id === project.id ? "*" : " ";
     const alias =
       options.context?.id === project.id && options.context.alias !== undefined
         ? `\t${options.context.alias}`
         : "";
-    lines.push(`${mark}\t${project.id}\t${project.name}${alias}`);
+    return `${mark}\t${project.id}\t${project.name}${alias}`;
+  });
+  if (page.pagination.hasMore) {
+    lines.push(
+      `Showing ${page.projects.length} of ${page.pagination.total} projects. Raise --limit to see more.`,
+    );
   }
   const output = lines.length === 0 ? "No projects visible." : lines.join("\n");
   options.io.stdout(output);

package/src/cli/runs.ts

@@ -84,21 +84,31 @@ export async function listLivePipelines(options: {
   readonly client: PotatoClient;
   readonly projectId: string;
   readonly state?: TolokaState;
+  readonly limit?: number;
 }): Promise<RunCommandResult> {
-  const live = await collectLivePipelineRefs(options.client, options.projectId, options.state);
+  const limit = options.limit ?? 20;
+  const page = await options.client.pipelines.listPage({ projectId: options.projectId, limit });
+  const sourceDirectoryById = bindingByLiveId(options.projectId, options.state);
+  const live = page.pipelines
+    .map((pipeline) => toRef(pipeline, sourceDirectoryById))
+    .toSorted((left, right) => {
+      const byName = left.name.localeCompare(right.name);
+      return byName === 0 ? left.pipelineId.localeCompare(right.pipelineId) : byName;
+    });
   if (live.length === 0) {
     return { outcome: "reported", output: "This project has no pipelines." };
   }
-  return {
-    outcome: "reported",
-    output: live
-      .map((ref) =>
-        ref.sourceDirectory === undefined
-          ? `${ref.name}\t${ref.pipelineId}`
-          : `${ref.name}\t${ref.pipelineId}\t${ref.sourceDirectory}`,
-      )
-      .join("\n"),
-  };
+  const lines = live.map((ref) =>
+    ref.sourceDirectory === undefined
+      ? `${ref.name}\t${ref.pipelineId}`
+      : `${ref.name}\t${ref.pipelineId}\t${ref.sourceDirectory}`,
+  );
+  if (page.pagination.hasMore) {
+    lines.push(
+      `Showing ${live.length} of ${page.pagination.total} pipelines. Raise --limit to see more.`,
+    );
+  }
+  return { outcome: "reported", output: lines.join("\n") };
 }
 
 const collectLivePipelineRefs = async (

package/src/cli/skill.ts

@@ -191,12 +191,23 @@ export const searchSkills = (
   skills: readonly SkillDescriptor[],
   query: string,
 ): SkillDescriptor[] => {
-  const needle = query.trim().toLowerCase();
-  return skills.filter((skill) =>
-    [skill.id, skill.name, skill.description, ...skill.tags].some((field) =>
-      field.toLowerCase().includes(needle),
-    ),
-  );
+  const needles = query.trim().toLowerCase().split(/\s+/u).filter(Boolean);
+  if (needles.length === 0) return [];
+
+  return skills
+    .map((skill, index) => {
+      const searchable = [skill.id, skill.name, skill.description, ...skill.tags]
+        .join("\n")
+        .toLowerCase();
+      return {
+        skill,
+        index,
+        score: needles.filter((needle) => searchable.includes(needle)).length,
+      };
+    })
+    .filter(({ score }) => score > 0)
+    .toSorted((left, right) => right.score - left.score || left.index - right.index)
+    .map(({ skill }) => skill);
 };
 
 export async function skillStatus(

package/src/testing/code-node.ts

@@ -0,0 +1,160 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AuthoredCodeNode } from "../authoring";
+
+export type RunCodeNodeOptions = {
+  env?: Record<string, string>;
+  pythonExecutable?: string;
+  timeoutMs?: number;
+};
+
+export class CodeNodeExecutionError extends Error {
+  readonly exitCode: number | null;
+  readonly stderr: string;
+
+  constructor(message: string, exitCode: number | null, stderr: string) {
+    super(message);
+    this.name = "CodeNodeExecutionError";
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+}
+
+export class CodeNodeInfrastructureError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "CodeNodeInfrastructureError";
+  }
+}
+
+const collectOutput = async (stream: NodeJS.ReadableStream): Promise<string> => {
+  const chunks: Buffer[] = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+
+const staticEnvironment = (node: AuthoredCodeNode): Record<string, string> =>
+  Object.fromEntries(
+    (node.settings.envVars ?? [])
+      .filter((entry) => entry.type === "static")
+      .map((entry) => [entry.name, entry.value]),
+  );
+
+const decodeCodeNodeOutput = (
+  nodeId: string,
+  serialized: string,
+  exitCode: number | null,
+  stderr: string,
+): Record<string, unknown> => {
+  let output: unknown;
+  try {
+    output = JSON.parse(serialized);
+  } catch (error) {
+    throw new CodeNodeExecutionError(
+      `Code node ${nodeId} returned invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      exitCode,
+      stderr,
+    );
+  }
+  if (output === null || typeof output !== "object" || Array.isArray(output)) {
+    throw new CodeNodeExecutionError(
+      `Code node ${nodeId} returned a non-object value`,
+      exitCode,
+      stderr,
+    );
+  }
+  return output as Record<string, unknown>;
+};
+
+export const runCodeNode = async (
+  node: AuthoredCodeNode,
+  inputs: Record<string, unknown>,
+  { env = {}, pythonExecutable = "python3", timeoutMs = 10_000 }: RunCodeNodeOptions = {},
+): Promise<Record<string, unknown>> => {
+  const directory = await mkdtemp(join(tmpdir(), "toloka-code-node-"));
+  const sourcePath = join(directory, "node.py");
+  const mainTypesPath = join(directory, "main_types.py");
+  const runnerPath = join(directory, "runner.py");
+  const outputPath = join(directory, "output.json");
+
+  try {
+    await Promise.all([
+      writeFile(sourcePath, node.settings.code.code, "utf8"),
+      writeFile(
+        mainTypesPath,
+        "from typing import Any\n\nInputs = dict[str, Any]\nOutputs = dict[str, Any]\n",
+        "utf8",
+      ),
+      writeFile(
+        runnerPath,
+        `import asyncio\nimport json\nimport sys\n\nfrom node import main\n\nasync def run():\n    result = await main(json.load(sys.stdin))\n    with open(sys.argv[1], "w", encoding="utf-8") as output:\n        json.dump(result, output)\n\nasyncio.run(run())\n`,
+        "utf8",
+      ),
+    ]);
+
+    const child = spawn(pythonExecutable, [runnerPath, outputPath], {
+      cwd: directory,
+      env: { ...process.env, ...staticEnvironment(node), ...env },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const {
+      promise: closed,
+      resolve: resolveClose,
+      reject: rejectClose,
+    } = Promise.withResolvers<number | null>();
+    child.once("close", resolveClose);
+    child.once("error", (error) =>
+      rejectClose(
+        new CodeNodeInfrastructureError(
+          `Unable to start Python executable ${JSON.stringify(pythonExecutable)}`,
+          { cause: error },
+        ),
+      ),
+    );
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.stdin.end(JSON.stringify(inputs));
+
+    const [exitCode, , stderr] = await Promise.all([
+      closed,
+      collectOutput(child.stdout),
+      collectOutput(child.stderr),
+    ]).finally(() => clearTimeout(timeout));
+
+    if (timedOut) {
+      throw new CodeNodeExecutionError(
+        `Code node ${node.id} exceeded the ${timeoutMs}ms timeout`,
+        exitCode,
+        stderr,
+      );
+    }
+    if (exitCode !== 0) {
+      throw new CodeNodeExecutionError(
+        `Code node ${node.id} exited with code ${exitCode ?? "unknown"}`,
+        exitCode,
+        stderr,
+      );
+    }
+
+    let serialized: string;
+    try {
+      serialized = await readFile(outputPath, "utf8");
+    } catch (error) {
+      throw new CodeNodeExecutionError(
+        `Code node ${node.id} did not produce an output file: ${error instanceof Error ? error.message : String(error)}`,
+        exitCode,
+        stderr,
+      );
+    }
+    return decodeCodeNodeOutput(node.id, serialized, exitCode, stderr);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+};

package/src/testing/index.ts

@@ -0,0 +1,15 @@
+export { CodeNodeExecutionError, CodeNodeInfrastructureError, runCodeNode } from "./code-node";
+export type { RunCodeNodeOptions } from "./code-node";
+export { expect, test } from "./task-ui";
+export { TaskUiInfrastructureError, TaskUiValidationError } from "./types";
+export type {
+  RenderTaskUiOptions,
+  TaskUiComponentDescription,
+  TaskUiCoverage,
+  TaskUiEntityError,
+  TaskUiFixture,
+  TaskUiFormError,
+  TaskUiNode,
+  TaskUiSession,
+  TypedTestOptions,
+} from "./types";

package/src/testing/task-ui-browser.ts

@@ -0,0 +1,120 @@
+import { assert } from "es-toolkit";
+import { chromium, type Browser, type Page } from "playwright";
+import {
+  TaskUiInfrastructureError,
+  type TaskUiComponentDescription,
+  type TbxBrowserRequest,
+  type TbxTemplate,
+  type TbxWindowApi,
+} from "./types";
+
+export const DEFAULT_TBX_LAUNCHER_URL =
+  "https://tlkfrontprodpublic.blob.core.windows.net/template-builder-production/tb-jsx.agents/index.html?postprocess=true";
+
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "setConfig" }>,
+): Promise<string>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "getComponentTree" }>,
+): Promise<string>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "getComponentState" }>,
+): Promise<Record<string, unknown>>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "getComponentValue" }>,
+): Promise<unknown>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "setComponentValue" }>,
+): Promise<void>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "getValidationErrors" }>,
+): Promise<Array<{ componentId: string; error: string }>>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "getComponentsDescriptions" }>,
+): Promise<TaskUiComponentDescription[]>;
+export function evaluateWithApi(
+  page: Page,
+  request: Extract<TbxBrowserRequest, { operation: "getData" }>,
+): Promise<Record<string, unknown> | undefined>;
+export async function evaluateWithApi(page: Page, request: TbxBrowserRequest): Promise<unknown> {
+  assert(!page.isClosed(), "Task UI browser page is closed");
+
+  return page.evaluate(async (input) => {
+    const api: TbxWindowApi | undefined = Reflect.get(globalThis, "LAUNCHER_EMBED_API");
+    if (api === undefined) throw new Error("Task UI launcher API is unavailable");
+
+    switch (input.operation) {
+      case "setConfig":
+        return api.agents.setConfig(input.config);
+      case "getComponentTree":
+        return api.agents.getComponentTree("xml");
+      case "getComponentState":
+        return api.agents.getComponentState(input.componentId);
+      case "getComponentValue":
+        return api.agents.getComponentValue(input.componentId);
+      case "setComponentValue":
+        return api.agents.setComponentValue(input.componentId, input.value);
+      case "getValidationErrors":
+        return api.agents.getValidationErrors();
+      case "getComponentsDescriptions":
+        return api.agents.getComponentsDescriptions();
+      case "getData":
+        return api.getData();
+    }
+  }, request);
+}
+
+export const selectComponentDocumentation = (
+  descriptions: TaskUiComponentDescription[],
+  names?: string[],
+): Record<string, TaskUiComponentDescription> => {
+  const selected =
+    names === undefined
+      ? descriptions
+      : descriptions.filter((description) => names.includes(description.name));
+  const byName = Object.fromEntries(selected.map((description) => [description.name, description]));
+  if (names !== undefined) {
+    const missing = names.filter((name) => !(name in byName));
+    assert(missing.length === 0, `Unknown Task UI components: ${missing.join(", ")}`);
+  }
+  return byName;
+};
+
+export const readDataPath = (state: Record<string, unknown>): string | undefined => {
+  const path = state.dataPath;
+  return typeof path === "string" ? path : undefined;
+};
+
+export const componentIds = (tree: string): string[] =>
+  [...tree.matchAll(/\bid="([^"]+)"/gu)].map((match) => match[1]!);
+
+export const launchDefaultBrowser = async (): Promise<Browser> => {
+  try {
+    return await chromium.launch({ headless: true });
+  } catch (error) {
+    throw new TaskUiInfrastructureError(
+      "Local Task UI testing requires Playwright and Chromium. Run `bun add --dev playwright vitest` and `bunx playwright install chromium`.",
+      { cause: error },
+    );
+  }
+};
+
+export const waitForTaskUiApi = async (page: Page): Promise<void> => {
+  await page.waitForFunction(
+    () => {
+      const api: TbxWindowApi | undefined = Reflect.get(globalThis, "LAUNCHER_EMBED_API");
+      return api?.agents !== undefined;
+    },
+    undefined,
+    { timeout: 15_000 },
+  );
+};
+
+export type { Browser, Page, TbxTemplate };