veryfront 0.1.519 → 0.1.521

package/src/src/agent/testing/live-evals/formatting.ts

@@ -0,0 +1,106 @@
+import { Buffer } from "node:buffer";
+import type { AgUiSseProgressSnapshot as EvalProgressSnapshot } from "../../index.js";
+
+function escapePdfText(input: string): string {
+  return input.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(
+    ")",
+    "\\)",
+  );
+}
+
+export function createPlainTextPdf(lines: string[]): Buffer {
+  const contentLines = [
+    "BT",
+    "/F1 18 Tf",
+    "72 720 Td",
+    `(${escapePdfText(lines[0] ?? "Untitled")}) Tj`,
+    "/F1 12 Tf",
+    ...lines.slice(1).flatMap((
+      line,
+    ) => ["0 -20 Td", `(${escapePdfText(line)}) Tj`]),
+    "ET",
+  ];
+  const contentStream = contentLines.join("\n");
+
+  const objects = [
+    "<< /Type /Catalog /Pages 2 0 R >>",
+    "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+    "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>",
+    `<< /Length ${
+      Buffer.byteLength(contentStream, "utf8")
+    } >>\nstream\n${contentStream}\nendstream`,
+    "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+  ];
+
+  let pdf = "%PDF-1.4\n";
+  const offsets = [0];
+
+  objects.forEach((objectBody, index) => {
+    offsets.push(Buffer.byteLength(pdf, "utf8"));
+    pdf += `${index + 1} 0 obj\n${objectBody}\nendobj\n`;
+  });
+
+  const xrefOffset = Buffer.byteLength(pdf, "utf8");
+  pdf += `xref\n0 ${objects.length + 1}\n`;
+  pdf += "0000000000 65535 f \n";
+
+  offsets.slice(1).forEach((offset) => {
+    pdf += `${offset.toString().padStart(10, "0")} 00000 n \n`;
+  });
+
+  pdf += `trailer\n<< /Root 1 0 R /Size ${
+    objects.length + 1
+  } >>\nstartxref\n${xrefOffset}\n%%EOF\n`;
+  return Buffer.from(pdf, "utf8");
+}
+
+export function buildProgressLine(input: {
+  caseId: string;
+  startedAt: number;
+  progress: EvalProgressSnapshot;
+}): string {
+  const elapsedSeconds = Math.max(
+    1,
+    Math.round((Date.now() - input.startedAt) / 1000),
+  );
+  const lastEvent = input.progress.lastEventType ?? "none";
+  const lastTool = input.progress.lastToolCallName
+    ? ` tool=${input.progress.lastToolCallName}`
+    : "";
+  const toolSummary = input.progress.toolStarts.length > 0
+    ? ` tools=${input.progress.toolStarts.join(",")}`
+    : "";
+  const textSummary = input.progress.textLength > 0 ? ` text=${input.progress.textLength}ch` : "";
+  return `[progress] ${input.caseId} ${elapsedSeconds}s events=${input.progress.eventCount} last=${lastEvent}${lastTool}${toolSummary}${textSummary}`;
+}
+
+export function buildFailureSuffix(progress: EvalProgressSnapshot): string {
+  const details = [
+    `events=${progress.eventCount}`,
+    `last=${progress.lastEventType ?? "none"}`,
+    progress.lastToolCallName ? `tool=${progress.lastToolCallName}` : null,
+    progress.toolStarts.length > 0 ? `tools=${progress.toolStarts.join(",")}` : null,
+    progress.textLength > 0 ? `text=${progress.textLength}ch` : null,
+  ].filter((value) => value !== null);
+
+  return details.length > 0 ? ` Progress: ${details.join(" ")}` : "";
+}
+
+export function containsOrderedSubsequence(
+  haystack: string[],
+  needle: string[],
+): boolean {
+  let cursor = 0;
+
+  for (const value of haystack) {
+    if (value === needle[cursor]) {
+      cursor += 1;
+    }
+
+    if (cursor === needle.length) {
+      return true;
+    }
+  }
+
+  return cursor === needle.length;
+}

package/src/src/agent/testing/live-evals/index.ts

@@ -0,0 +1,30 @@
+export {
+  buildFailureSuffix,
+  buildProgressLine,
+  containsOrderedSubsequence,
+  createPlainTextPdf,
+} from "./formatting.js";
+export {
+  buildRuntimePerformanceSummary,
+  type LiveEvalResultForPerformance,
+  type LiveEvalRuntime,
+  type RuntimePerformanceSummary,
+} from "./performance.js";
+export { buildLiveEvalRequestBody, type BuildLiveEvalRequestBodyInput } from "./request.js";
+export {
+  buildLiveEvalCaseTagSummary,
+  buildLiveEvalRuntimeSummary,
+  buildLiveEvalStatusSummary,
+  hasEveryLiveEvalTag,
+  type LiveEvalCaseMetadata,
+  type LiveEvalCaseSelectionInput,
+  type LiveEvalResultForReport,
+  resolveLiveEvalRequestedCaseIds,
+  selectLiveEvalCases,
+} from "./report.js";
+export {
+  createFailedEvalResult,
+  createPassedEvalResult,
+  createSkippedEvalResult,
+  type LiveEvalResultRecord,
+} from "./result.js";

package/src/src/agent/testing/live-evals/performance.ts

@@ -0,0 +1,52 @@
+export type LiveEvalRuntime = "framework";
+
+export interface LiveEvalResultForPerformance {
+  runtime: LiveEvalRuntime;
+  durationMs: number;
+}
+
+export interface RuntimePerformanceSummary {
+  count: number;
+  avgDurationMs: number;
+  p50DurationMs: number;
+  p95DurationMs: number;
+  minDurationMs: number;
+  maxDurationMs: number;
+}
+
+function calculateDurationPercentile(
+  sortedDurations: number[],
+  percentile: number,
+): number {
+  if (sortedDurations.length === 0) {
+    return 0;
+  }
+
+  const index = Math.min(
+    sortedDurations.length - 1,
+    Math.max(0, Math.ceil((percentile / 100) * sortedDurations.length) - 1),
+  );
+
+  return sortedDurations[index] ?? 0;
+}
+
+export function buildRuntimePerformanceSummary(
+  results: LiveEvalResultForPerformance[],
+): Record<LiveEvalRuntime, RuntimePerformanceSummary> {
+  const durations = results.map((result) => result.durationMs).sort((
+    left,
+    right,
+  ) => left - right);
+  const totalDuration = durations.reduce((sum, value) => sum + value, 0);
+
+  return {
+    framework: {
+      count: durations.length,
+      avgDurationMs: durations.length > 0 ? Math.round(totalDuration / durations.length) : 0,
+      p50DurationMs: calculateDurationPercentile(durations, 50),
+      p95DurationMs: calculateDurationPercentile(durations, 95),
+      minDurationMs: durations[0] ?? 0,
+      maxDurationMs: durations.at(-1) ?? 0,
+    },
+  };
+}

package/src/src/agent/testing/live-evals/report.ts

@@ -0,0 +1,155 @@
+import type { LiveEvalRuntime } from "./performance.js";
+
+export interface LiveEvalCaseMetadata {
+  tags: readonly string[];
+}
+
+export interface LiveEvalResultForReport {
+  runtime: LiveEvalRuntime;
+  status: "pass" | "fail" | "skip";
+}
+
+export interface LiveEvalCaseSelectionInput<TCase extends { id: string }> {
+  allCases: TCase[];
+  readOnlyCases: TCase[];
+  writeCases: TCase[];
+  experimentalWriteCases: TCase[];
+  requestedCaseIds: Set<string>;
+  requestedCaseTags?: Set<string>;
+  runWriteEvals: boolean;
+  runExperimentalWriteEvals: boolean;
+}
+
+export function hasEveryLiveEvalTag(
+  tags: readonly string[],
+  requestedTags: Set<string>,
+): boolean {
+  for (const requestedTag of requestedTags) {
+    if (!tags.includes(requestedTag)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function buildLiveEvalCaseTagSummary(
+  cases: readonly {
+    metadata?: LiveEvalCaseMetadata;
+  }[],
+): Record<string, number> {
+  const counts = new Map<string, number>();
+
+  for (const testCase of cases) {
+    const caseTags = testCase.metadata?.tags ?? [];
+    for (const tag of caseTags) {
+      counts.set(tag, (counts.get(tag) ?? 0) + 1);
+    }
+  }
+
+  return Object.fromEntries(
+    [...counts.entries()].sort(([left], [right]) => left.localeCompare(right)),
+  );
+}
+
+export function selectLiveEvalCases<
+  TCase extends { id: string; metadata?: LiveEvalCaseMetadata },
+>(
+  input: LiveEvalCaseSelectionInput<TCase>,
+): TCase[] {
+  const configuredCases = input.runWriteEvals
+    ? [
+      ...input.readOnlyCases,
+      ...input.writeCases,
+      ...(input.runExperimentalWriteEvals ? input.experimentalWriteCases : []),
+    ]
+    : input.readOnlyCases;
+
+  const selectedCases = input.requestedCaseIds.size > 0
+    ? input.allCases.filter((testCase) => input.requestedCaseIds.has(testCase.id))
+    : configuredCases;
+
+  const requestedCaseTags = input.requestedCaseTags ?? new Set<string>();
+
+  return requestedCaseTags.size > 0
+    ? selectedCases.filter((testCase) =>
+      hasEveryLiveEvalTag(testCase.metadata?.tags ?? [], requestedCaseTags)
+    )
+    : selectedCases;
+}
+
+export function resolveLiveEvalRequestedCaseIds(input: {
+  caseSets: Record<string, readonly string[]>;
+  requestedCaseIds: Set<string>;
+  requestedCaseSetId?: string | null;
+}): Set<string> {
+  const resolved = new Set(input.requestedCaseIds);
+  const requestedCaseSetId = input.requestedCaseSetId?.trim();
+
+  if (!requestedCaseSetId) {
+    return resolved;
+  }
+
+  const caseIds = input.caseSets[requestedCaseSetId];
+  if (!caseIds) {
+    throw new Error(
+      `Unknown AG_UI_EVAL_CASE_SET "${requestedCaseSetId}". Known sets: ${
+        Object.keys(input.caseSets).join(", ")
+      }`,
+    );
+  }
+
+  for (const caseId of caseIds) {
+    resolved.add(caseId);
+  }
+
+  return resolved;
+}
+
+interface LiveEvalRuntimeCounts {
+  passed: number;
+  failed: number;
+  skipped: number;
+}
+
+function buildRuntimeCounts(
+  results: LiveEvalResultForReport[],
+  runtime: LiveEvalRuntime,
+): LiveEvalRuntimeCounts {
+  return {
+    passed:
+      results.filter((result) => result.runtime === runtime && result.status === "pass").length,
+    failed:
+      results.filter((result) => result.runtime === runtime && result.status === "fail").length,
+    skipped:
+      results.filter((result) => result.runtime === runtime && result.status === "skip").length,
+  };
+}
+
+export function buildLiveEvalRuntimeSummary(
+  runtimes: readonly LiveEvalRuntime[],
+  results: LiveEvalResultForReport[],
+): Record<LiveEvalRuntime, LiveEvalRuntimeCounts> {
+  const empty: LiveEvalRuntimeCounts = { passed: 0, failed: 0, skipped: 0 };
+  const summary: Record<LiveEvalRuntime, LiveEvalRuntimeCounts> = {
+    framework: empty,
+  };
+  for (const runtime of runtimes) {
+    summary[runtime] = buildRuntimeCounts(results, runtime);
+  }
+  return summary;
+}
+
+export function buildLiveEvalStatusSummary(
+  results: LiveEvalResultForReport[],
+): {
+  passed: number;
+  failed: number;
+  skipped: number;
+} {
+  return {
+    passed: results.filter((result) => result.status === "pass").length,
+    failed: results.filter((result) => result.status === "fail").length,
+    skipped: results.filter((result) => result.status === "skip").length,
+  };
+}

package/src/src/agent/testing/live-evals/request.ts

@@ -0,0 +1,60 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+export interface BuildLiveEvalRequestBodyInput {
+  testCaseId: string;
+  prompt: string;
+  metadata?: Record<string, string>;
+  projectId: string | null;
+  branchId?: string;
+  model?: string;
+  conversationId?: string | null;
+  allowedTools?: string[];
+  forceRuntimeOverrides?: boolean;
+  maxSteps?: number;
+}
+
+export function buildLiveEvalRequestBody(input: BuildLiveEvalRequestBodyInput) {
+  const veryfront: Record<string, unknown> = {};
+  if (input.projectId) {
+    veryfront.projectId = input.projectId;
+  }
+  if (input.conversationId) {
+    veryfront.conversationId = input.conversationId;
+  }
+  if (input.branchId) {
+    veryfront.branchId = input.branchId;
+  }
+  if (input.model) {
+    veryfront.model = input.model;
+  }
+  if (input.allowedTools || input.forceRuntimeOverrides) {
+    veryfront.runtimeOverrides = {
+      allowedTools: input.allowedTools ?? [],
+      ...(input.maxSteps ? { maxSteps: input.maxSteps } : {}),
+    };
+  }
+
+  return {
+    threadId: dntShim.crypto.randomUUID(),
+    runId: `eval-run-${dntShim.crypto.randomUUID()}`,
+    state: {
+      evalCase: input.testCaseId,
+      ...(input.metadata ?? {}),
+    },
+    tools: [],
+    context: [],
+    ...(Object.keys(veryfront).length > 0
+      ? {
+        forwardedProps: {
+          veryfront,
+        },
+      }
+      : {}),
+    messages: [
+      {
+        id: dntShim.crypto.randomUUID(),
+        role: "user" as const,
+        content: input.prompt,
+      },
+    ],
+  };
+}

package/src/src/agent/testing/live-evals/result.ts

@@ -0,0 +1,96 @@
+import type { LiveEvalRuntime } from "./performance.js";
+
+export interface LiveEvalResultRecord {
+  id: string;
+  label: string;
+  runtime: LiveEvalRuntime;
+  status: "pass" | "fail" | "skip";
+  details: string;
+  durationMs: number;
+  conversationId?: string;
+  runId?: string;
+  artifactPaths?: string[];
+  traceSignature?: string;
+  toolStarts?: string[];
+  toolArgsPreview?: string;
+  textPreview?: string;
+}
+
+export function createSkippedEvalResult(input: {
+  id: string;
+  label: string;
+  runtime: LiveEvalRuntime;
+  details: string;
+  startedAt: number;
+}): LiveEvalResultRecord {
+  return {
+    id: input.id,
+    label: input.label,
+    runtime: input.runtime,
+    status: "skip",
+    details: input.details,
+    durationMs: Date.now() - input.startedAt,
+  };
+}
+
+export function createFailedEvalResult(input: {
+  id: string;
+  label: string;
+  runtime: LiveEvalRuntime;
+  details: string;
+  startedAt: number;
+  conversationId?: string;
+  runId?: string;
+  artifactPaths?: string[];
+  traceSignature?: string;
+  toolStarts?: string[];
+  toolArgsPreview?: string;
+  textPreview?: string;
+}): LiveEvalResultRecord {
+  return {
+    id: input.id,
+    label: input.label,
+    runtime: input.runtime,
+    status: "fail",
+    details: input.details,
+    durationMs: Date.now() - input.startedAt,
+    ...(input.conversationId ? { conversationId: input.conversationId } : {}),
+    ...(input.runId ? { runId: input.runId } : {}),
+    ...(input.artifactPaths?.length ? { artifactPaths: input.artifactPaths } : {}),
+    ...(input.traceSignature ? { traceSignature: input.traceSignature } : {}),
+    ...(input.toolStarts ? { toolStarts: input.toolStarts } : {}),
+    ...(input.toolArgsPreview ? { toolArgsPreview: input.toolArgsPreview } : {}),
+    ...(input.textPreview ? { textPreview: input.textPreview } : {}),
+  };
+}
+
+export function createPassedEvalResult(input: {
+  id: string;
+  label: string;
+  runtime: LiveEvalRuntime;
+  details: string;
+  startedAt: number;
+  conversationId?: string;
+  runId?: string;
+  artifactPaths?: string[];
+  traceSignature?: string;
+  toolStarts?: string[];
+  toolArgsPreview?: string;
+  textPreview?: string;
+}): LiveEvalResultRecord {
+  return {
+    id: input.id,
+    label: input.label,
+    runtime: input.runtime,
+    status: "pass",
+    details: input.details,
+    durationMs: Date.now() - input.startedAt,
+    ...(input.conversationId ? { conversationId: input.conversationId } : {}),
+    ...(input.runId ? { runId: input.runId } : {}),
+    ...(input.artifactPaths?.length ? { artifactPaths: input.artifactPaths } : {}),
+    ...(input.traceSignature ? { traceSignature: input.traceSignature } : {}),
+    ...(input.toolStarts ? { toolStarts: input.toolStarts } : {}),
+    ...(input.toolArgsPreview ? { toolArgsPreview: input.toolArgsPreview } : {}),
+    ...(input.textPreview ? { textPreview: input.textPreview } : {}),
+  };
+}

package/src/src/agent/veryfront-cloud-agent-service.ts

@@ -2,9 +2,20 @@ import * as dntShim from "../../_dnt.shims.js";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { z } from "zod";
 import type { AgentServiceSandboxToolsOptions } from "../sandbox/index.js";
 import { createAgentServiceSandboxTools } from "../sandbox/index.js";
+import { register, tryResolve } from "../extensions/contracts.js";
+import { MISSING_EXTENSION_ERROR } from "../extensions/errors.js";
+import type { AuthProvider } from "../extensions/auth/index.js";
+import type { SchemaValidator } from "../extensions/schema/index.js";
+import {
+  type NodeTelemetryProvider,
+  NodeTelemetryProviderName,
+} from "../extensions/tracing/index.js";
+import {
+  type SandboxShellToolsProvider,
+  SandboxShellToolsProviderName,
+} from "../extensions/sandbox/index.js";
 import {
   createRemoteMCPToolSource,
   createToolsFromRemoteDefinitions,
@@ -211,10 +222,6 @@ const PROJECT_CONFIG_FILES = [
   "veryfront.config.ts",
   "veryfront.config.mjs",
 ];
-const ProjectManifestNameSchema = z.object({
-  name: z.string().trim().min(1).optional(),
-}).passthrough();
-
 function pathOptionToPath(pathOption: AgentServicePathOption): string {
   return pathOption instanceof URL ? fileURLToPath(pathOption) : pathOption;
 }
@@ -275,12 +282,12 @@ function readProjectManifestName(projectDir: string): string | null {
     }
 
     try {
-      const parsed = ProjectManifestNameSchema.parse(
-        JSON.parse(readFileSync(filePath, "utf8")),
-      );
-      if (parsed.name) {
-        return parsed.name;
-      }
+      const parsed = JSON.parse(readFileSync(filePath, "utf8")) as unknown;
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+      const name = (parsed as { name?: unknown }).name;
+      if (typeof name !== "string") continue;
+      const trimmedName = name.trim();
+      if (trimmedName) return trimmedName;
     } catch {
       continue;
     }
@@ -324,13 +331,32 @@ function resolveMcpServers(
 async function loadDefaultCreateBashTool(): Promise<
   AgentServiceSandboxToolsOptions["createBashTool"]
 > {
-  const { createBashTool } = await import("bash-tool");
-  return createBashTool;
+  const provider = tryResolve<SandboxShellToolsProvider>(SandboxShellToolsProviderName);
+  if (provider) return provider;
+
+  try {
+    const { createBashSandboxShellToolsProvider } = await import(
+      "../../extensions/ext-sandbox-shell-tools/src/index.js"
+    );
+    return createBashSandboxShellToolsProvider;
+  } catch (error) {
+    throw MISSING_EXTENSION_ERROR.create({
+      message:
+        'Missing extension for contract "SandboxShellToolsProvider". Enable ext-sandbox-shell-tools or pass createBashTool explicitly.',
+      detail:
+        `Veryfront cloud agent sandbox shell tools require a SandboxShellToolsProvider implementation: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+    });
+  }
 }
 
 async function resolveNodeVeryfrontCloudAgentServiceOptions(
   options: NodeVeryfrontCloudAgentServiceOptions,
 ): Promise<ResolvedNodeVeryfrontCloudAgentServiceOptions> {
+  await ensureDefaultSchemaValidator();
+  await ensureDefaultAuthProvider();
+  await ensureDefaultNodeTelemetryProvider();
   return {
     ...options,
     serviceName: resolveServiceName(options),
@@ -338,6 +364,29 @@ async function resolveNodeVeryfrontCloudAgentServiceOptions(
   };
 }
 
+async function ensureDefaultSchemaValidator(): Promise<void> {
+  if (tryResolve<SchemaValidator>("SchemaValidator")) return;
+  const { createZodAdapter } = await import("../../extensions/ext-schema-zod/src/adapter.js");
+  register<SchemaValidator>("SchemaValidator", createZodAdapter());
+}
+
+async function ensureDefaultAuthProvider(): Promise<void> {
+  if (tryResolve<AuthProvider>("AuthProvider")) return;
+  const { createAuthProvider } = await import("../../extensions/ext-auth-jwt/src/index.js");
+  register<AuthProvider>("AuthProvider", createAuthProvider({}));
+}
+
+async function ensureDefaultNodeTelemetryProvider(): Promise<void> {
+  if (tryResolve<NodeTelemetryProvider>(NodeTelemetryProviderName)) return;
+  const { OpenTelemetryNodeTelemetryProvider } = await import(
+    "../../extensions/ext-tracing-opentelemetry/src/index.js"
+  );
+  register<NodeTelemetryProvider>(
+    NodeTelemetryProviderName,
+    new OpenTelemetryNodeTelemetryProvider(),
+  );
+}
+
 function resolveEnvironment(
   options: Pick<NodeVeryfrontCloudAgentServiceOptions, "env" | "processTarget">,
 ): CreateNodeAgentServiceRuntimeInfrastructureOptions["env"] {

package/src/src/build/compiler/mdx-compiler/frontmatter-parser.ts

@@ -40,7 +40,7 @@ async function parseManually(content: string): Promise<ParsedContent | null> {
   }
 
   try {
-    const { parse } = await import("std/yaml/parse.ts");
+    const { parse } = await import("../../../../deps/jsr.io/@std/yaml/1.1.0/parse.js");
     const parsed = parse(frontmatterText);
     const frontmatter = (parsed && typeof parsed === "object" ? parsed : {}) as MDXFrontmatter;
 

package/src/src/build/compiler/mdx-compiler/mdx-processor.ts

@@ -1,33 +1,22 @@
-import { compile as compileMdx, type CompileOptions as MDXCompileOptions } from "@mdx-js/mdx";
-import { getRehypePlugins, getRemarkPlugins } from "../../../transforms/plugins/plugin-loader.js";
+import { resolve as resolveContract } from "../../../extensions/contracts.js";
+import type { ContentProcessor } from "../../../extensions/content/index.js";
 import type { CompileOptions } from "./types.js";
 
-type MDXPluggable = NonNullable<MDXCompileOptions["remarkPlugins"]>[number];
-
 interface ProcessedMDX {
   code: string;
   imports: string[];
 }
 
 export async function compileMDX(content: string, options: CompileOptions): Promise<ProcessedMDX> {
-  const [remarkPlugins, rehypePlugins] = await Promise.all([
-    getRemarkPlugins(),
-    getRehypePlugins(),
-  ]);
-
-  const compiled = await compileMdx(content, {
-    outputFormat: "program",
-    jsx: true,
-    jsxRuntime: "automatic",
-    jsxImportSource: "react",
-    development: options.mode === "development",
-    remarkPlugins: remarkPlugins as MDXPluggable[],
-    rehypePlugins: rehypePlugins as MDXPluggable[],
+  const processor = resolveContract<ContentProcessor>("ContentProcessor");
+  const compiled = await processor.compileMdx({
+    projectDir: options.projectDir,
+    content,
+    mode: options.mode,
+    target: "server",
   });
 
-  const code = String(compiled.value);
-
-  return { code, imports: extractImports(code) };
+  return { code: compiled.compiledCode, imports: extractImports(compiled.compiledCode) };
 }
 
 function extractImports(code: string): string[] {