Add server and its client utility

.gitignore

@@ -133,3 +133,6 @@ dist
 bench/.bench-cache
 bench-node/.bench-cache
 bench-web/.transformers-cache
+
+# Benchmark result files
+bench/benchmark-results.jsonl

bench/package-lock.json

@@ -8,7 +8,9 @@
       "name": "bench",
       "version": "0.0.2",
       "dependencies": {
-        "@huggingface/transformers": "^3.7.4"
+        "@hono/node-server": "^1.19.5",
+        "@huggingface/transformers": "^3.7.4",
+        "hono": "^4.9.10"
       },
       "devDependencies": {
         "@playwright/test": "^1.55.1",
@@ -470,6 +472,18 @@
         "node": ">=18"
       }
     },
+    "node_modules/@hono/node-server": {
+      "version": "1.19.5",
+      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.5.tgz",
+      "integrity": "sha512-iBuhh+uaaggeAuf+TftcjZyWh2GEgZcVGXkNtskLVoWaXhnJtC5HLHrU8W1KHDoucqO1MswwglmkWLFyiDn4WQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.14.1"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
     "node_modules/@huggingface/jinja": {
       "version": "0.5.1",
       "resolved": "https://registry.npmjs.org/@huggingface/jinja/-/jinja-0.5.1.tgz",
@@ -1592,6 +1606,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/hono": {
+      "version": "4.9.10",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.9.10.tgz",
+      "integrity": "sha512-AlI15ijFyKTXR7eHo7QK7OR4RoKIedZvBuRjO8iy4zrxvlY5oFCdiRG/V/lFJHCNXJ0k72ATgnyzx8Yqa5arug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
     "node_modules/json-stringify-safe": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",

bench/package.json

@@ -7,13 +7,17 @@
     "bench": "tsx src/index.ts",
     "bench:node": "tsx src/node/index.ts",
     "bench:web": "tsx src/web/cli.ts",
+    "bench:install": "playwright install",
+    "server": "tsx src/server/index.ts",
+    "server:dev": "tsx watch src/server/index.ts",
     "dev": "vite",
     "build": "tsc -p tsconfig.json",
-    "preview": "vite preview",
-    "bench:install": "playwright install"
+    "preview": "vite preview"
   },
   "dependencies": {
-    "@huggingface/transformers": "^3.7.4"
+    "@hono/node-server": "^1.19.5",
+    "@huggingface/transformers": "^3.7.4",
+    "hono": "^4.9.10"
   },
   "devDependencies": {
     "@playwright/test": "^1.55.1",

bench/src/server/index.ts

@@ -0,0 +1,241 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { BenchmarkQueue, BenchmarkRequest } from "./queue.js";
+import { BenchmarkStorage } from "./storage.js";
+import { randomUUID } from "crypto";
+
+const app = new Hono();
+const queue = new BenchmarkQueue();
+const storage = new BenchmarkStorage();
+
+// Enable CORS for development
+app.use("/*", cors());
+
+// Store completed benchmarks to file
+queue.on("completed", async (benchmark) => {
+  try {
+    await storage.appendResult(benchmark);
+    console.log(`✓ Benchmark ${benchmark.id} saved to file`);
+  } catch (error) {
+    console.error(`✗ Failed to save benchmark ${benchmark.id}:`, error);
+  }
+});
+
+queue.on("failed", async (benchmark) => {
+  try {
+    await storage.appendResult(benchmark);
+    console.log(`✗ Failed benchmark ${benchmark.id} saved to file`);
+  } catch (error) {
+    console.error(`✗ Failed to save failed benchmark ${benchmark.id}:`, error);
+  }
+});
+
+// Log queue events
+queue.on("added", (benchmark) => {
+  console.log(`📥 Added to queue: ${benchmark.id} (${benchmark.platform}/${benchmark.modelId})`);
+});
+
+queue.on("started", (benchmark) => {
+  console.log(`🚀 Started: ${benchmark.id}`);
+});
+
+queue.on("completed", (benchmark) => {
+  console.log(`✅ Completed: ${benchmark.id} in ${(benchmark.completedAt! - benchmark.startedAt!) / 1000}s`);
+});
+
+queue.on("failed", (benchmark) => {
+  console.log(`❌ Failed: ${benchmark.id} - ${benchmark.error}`);
+});
+
+// API Endpoints
+
+/**
+ * POST /api/benchmark
+ * Submit a new benchmark request
+ */
+app.post("/api/benchmark", async (c) => {
+  const body = await c.req.json();
+  const {
+    platform = "node",
+    modelId,
+    task,
+    mode = "warm",
+    repeats = 3,
+    dtype,
+    batchSize = 1,
+    device = "webgpu",
+    browser = "chromium",
+    headed = false,
+  } = body;
+
+  if (!modelId || !task) {
+    return c.json({ error: "modelId and task are required" }, 400);
+  }
+
+  const request: BenchmarkRequest = {
+    id: randomUUID(),
+    platform,
+    modelId,
+    task,
+    mode,
+    repeats,
+    dtype,
+    batchSize,
+    device,
+    browser,
+    headed,
+    timestamp: Date.now(),
+  };
+
+  queue.addBenchmark(request);
+
+  return c.json({
+    id: request.id,
+    message: "Benchmark queued",
+    position: queue.getQueueStatus().pending,
+  });
+});
+
+/**
+ * GET /api/benchmark/:id
+ * Get benchmark status/result by ID
+ */
+app.get("/api/benchmark/:id", async (c) => {
+  const id = c.req.param("id");
+
+  // Check queue first (for pending/running benchmarks)
+  const queued = queue.getBenchmark(id);
+  if (queued) {
+    return c.json(queued);
+  }
+
+  // Check storage (for completed benchmarks)
+  const stored = await storage.getResultById(id);
+  if (stored) {
+    return c.json(stored);
+  }
+
+  return c.json({ error: "Benchmark not found" }, 404);
+});
+
+/**
+ * GET /api/benchmarks
+ * Get all benchmark results from storage
+ */
+app.get("/api/benchmarks", async (c) => {
+  const results = await storage.getAllResults();
+  return c.json({
+    total: results.length,
+    results,
+  });
+});
+
+/**
+ * GET /api/queue
+ * Get current queue status
+ */
+app.get("/api/queue", (c) => {
+  const status = queue.getQueueStatus();
+  const allBenchmarks = queue.getAllBenchmarks();
+
+  return c.json({
+    status,
+    queue: allBenchmarks,
+  });
+});
+
+/**
+ * DELETE /api/benchmarks
+ * Clear all stored results
+ */
+app.delete("/api/benchmarks", async (c) => {
+  await storage.clearResults();
+  return c.json({ message: "All results cleared" });
+});
+
+/**
+ * GET /
+ * Simple status page
+ */
+app.get("/", (c) => {
+  const status = queue.getQueueStatus();
+  return c.html(`
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <title>Benchmark Server</title>
+      <style>
+        body { font-family: system-ui; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
+        h1 { color: #333; }
+        .status { background: #f5f5f5; padding: 1rem; border-radius: 4px; margin: 1rem 0; }
+        .endpoint { background: #fff; border: 1px solid #ddd; padding: 0.5rem; margin: 0.5rem 0; border-radius: 4px; }
+        .method { display: inline-block; width: 60px; font-weight: bold; color: #0066cc; }
+        code { background: #f0f0f0; padding: 2px 6px; border-radius: 3px; }
+      </style>
+    </head>
+    <body>
+      <h1>🚀 Transformers.js Benchmark Server</h1>
+
+      <div class="status">
+        <h2>Queue Status</h2>
+        <p>Pending: ${status.pending} | Running: ${status.running} | Completed: ${status.completed} | Failed: ${status.failed}</p>
+      </div>
+
+      <h2>API Endpoints</h2>
+
+      <div class="endpoint">
+        <span class="method">POST</span> <code>/api/benchmark</code> - Submit benchmark request
+      </div>
+
+      <div class="endpoint">
+        <span class="method">GET</span> <code>/api/benchmark/:id</code> - Get benchmark status/result
+      </div>
+
+      <div class="endpoint">
+        <span class="method">GET</span> <code>/api/benchmarks</code> - Get all stored results
+      </div>
+
+      <div class="endpoint">
+        <span class="method">GET</span> <code>/api/queue</code> - Get queue status
+      </div>
+
+      <div class="endpoint">
+        <span class="method">DELETE</span> <code>/api/benchmarks</code> - Clear all results
+      </div>
+
+      <h2>Example Request</h2>
+      <pre style="background: #f5f5f5; padding: 1rem; border-radius: 4px; overflow-x: auto;">
+curl -X POST http://localhost:3000/api/benchmark \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "platform": "node",
+    "modelId": "Xenova/all-MiniLM-L6-v2",
+    "task": "feature-extraction",
+    "mode": "warm",
+    "repeats": 3,
+    "batchSize": 1
+  }'
+      </pre>
+    </body>
+    </html>
+  `);
+});
+
+const PORT = Number(process.env.PORT) || 3000;
+
+serve({
+  fetch: app.fetch,
+  port: PORT,
+}, (info) => {
+  console.log(`
+🚀 Benchmark Server running on http://localhost:${info.port}
+
+API Endpoints:
+  POST   /api/benchmark      - Submit benchmark
+  GET    /api/benchmark/:id  - Get result
+  GET    /api/benchmarks     - List all results
+  GET    /api/queue          - Queue status
+  DELETE /api/benchmarks     - Clear results
+  `);
+});

bench/src/server/queue.ts

@@ -0,0 +1,207 @@
+import { EventEmitter } from "events";
+import { BenchmarkResult } from "../core/types.js";
+
+export interface BenchmarkRequest {
+  id: string;
+  platform: "node" | "web";
+  modelId: string;
+  task: string;
+  mode: "warm" | "cold";
+  repeats: number;
+  dtype?: string;
+  batchSize: number;
+  device?: string;
+  browser?: string;
+  headed?: boolean;
+  timestamp: number;
+}
+
+export interface QueuedBenchmark extends BenchmarkRequest {
+  status: "pending" | "running" | "completed" | "failed";
+  result?: BenchmarkResult;
+  error?: string;
+  startedAt?: number;
+  completedAt?: number;
+}
+
+export class BenchmarkQueue extends EventEmitter {
+  private queue: QueuedBenchmark[] = [];
+  private isProcessing = false;
+
+  addBenchmark(request: BenchmarkRequest): void {
+    const queued: QueuedBenchmark = {
+      ...request,
+      status: "pending",
+    };
+    this.queue.push(queued);
+    this.emit("added", queued);
+    this.processQueue();
+  }
+
+  getBenchmark(id: string): QueuedBenchmark | undefined {
+    return this.queue.find((b) => b.id === id);
+  }
+
+  getAllBenchmarks(): QueuedBenchmark[] {
+    return [...this.queue];
+  }
+
+  getQueueStatus() {
+    return {
+      total: this.queue.length,
+      pending: this.queue.filter((b) => b.status === "pending").length,
+      running: this.queue.filter((b) => b.status === "running").length,
+      completed: this.queue.filter((b) => b.status === "completed").length,
+      failed: this.queue.filter((b) => b.status === "failed").length,
+    };
+  }
+
+  private async processQueue() {
+    if (this.isProcessing) return;
+
+    const pending = this.queue.find((b) => b.status === "pending");
+    if (!pending) return;
+
+    this.isProcessing = true;
+    pending.status = "running";
+    pending.startedAt = Date.now();
+
+    this.emit("started", pending);
+
+    try {
+      const result = await this.runBenchmark(pending);
+      pending.status = "completed";
+      pending.result = result;
+      pending.completedAt = Date.now();
+      this.emit("completed", pending);
+    } catch (error) {
+      pending.status = "failed";
+      // Capture detailed error information
+      if (error instanceof Error) {
+        pending.error = error.message;
+        // Log full error details to console
+        console.error(`\n❌ Benchmark ${pending.id} failed:`);
+        console.error(`   Message: ${error.message}`);
+        if (error.stack) {
+          console.error(`   Stack trace:\n${error.stack}`);
+        }
+      } else {
+        pending.error = String(error);
+        console.error(`\n❌ Benchmark ${pending.id} failed: ${pending.error}`);
+      }
+      pending.completedAt = Date.now();
+      this.emit("failed", pending);
+    }
+
+    this.isProcessing = false;
+    // Process next item
+    setImmediate(() => this.processQueue());
+  }
+
+  private async runBenchmark(request: BenchmarkRequest): Promise<BenchmarkResult> {
+    if (request.platform === "node") {
+      // Use spawn instead of dynamic import to avoid import.meta.url issues
+      const { spawn } = await import("child_process");
+
+      // Build command args
+      const args = [
+        "src/node/index.ts",
+        request.modelId,
+        request.task,
+        `--mode=${request.mode}`,
+        `--repeats=${request.repeats}`,
+        `--batch-size=${request.batchSize}`,
+      ];
+      if (request.dtype) args.push(`--dtype=${request.dtype}`);
+
+      console.log(`\n[Queue] Dispatching node benchmark with command: tsx ${args.join(' ')}`);
+
+      return new Promise((resolve, reject) => {
+        const proc = spawn("tsx", args, { cwd: process.cwd() });
+        let stdout = "";
+        let stderr = "";
+
+        proc.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+
+        proc.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+
+        proc.on("close", (code) => {
+          if (code !== 0) {
+            reject(new Error(`Benchmark failed with code ${code}: ${stderr}`));
+            return;
+          }
+
+          // Extract JSON from stdout (last JSON object)
+          const jsonMatch = stdout.match(/\{[\s\S]*"platform"[\s\S]*\}/);
+          if (jsonMatch) {
+            try {
+              const result = JSON.parse(jsonMatch[0]);
+              resolve(result);
+            } catch (e) {
+              reject(new Error(`Failed to parse benchmark result: ${e}`));
+            }
+          } else {
+            reject(new Error("No benchmark result found in output"));
+          }
+        });
+      });
+    } else {
+      // For web benchmarks, we'll use the CLI approach with Playwright
+      const { spawn } = await import("child_process");
+
+      // Build command args
+      const args = [
+        "src/web/cli.ts",
+        request.modelId,
+        request.task,
+        `--mode=${request.mode}`,
+        `--repeats=${request.repeats}`,
+        `--device=${request.device || "webgpu"}`,
+        `--batch-size=${request.batchSize}`,
+      ];
+      if (request.dtype) args.push(`--dtype=${request.dtype}`);
+      if (request.browser) args.push(`--browser=${request.browser}`);
+      if (request.headed) args.push(`--headed=true`);
+
+      console.log(`\n[Queue] Dispatching web benchmark with command: tsx ${args.join(' ')}`);
+
+      return new Promise((resolve, reject) => {
+        const proc = spawn("tsx", args, { cwd: process.cwd() });
+        let stdout = "";
+        let stderr = "";
+
+        proc.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+
+        proc.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+
+        proc.on("close", (code) => {
+          if (code !== 0) {
+            reject(new Error(`Benchmark failed with code ${code}: ${stderr}`));
+            return;
+          }
+
+          // Extract JSON from stdout (last JSON object)
+          const jsonMatch = stdout.match(/\{[\s\S]*"platform"[\s\S]*\}/);
+          if (jsonMatch) {
+            try {
+              const result = JSON.parse(jsonMatch[0]);
+              resolve(result);
+            } catch (e) {
+              reject(new Error(`Failed to parse benchmark result: ${e}`));
+            }
+          } else {
+            reject(new Error("No benchmark result found in output"));
+          }
+        });
+      });
+    }
+  }
+}

bench/src/server/storage.ts

@@ -0,0 +1,44 @@
+import fs from "fs/promises";
+import path from "path";
+import { QueuedBenchmark } from "./queue.js";
+
+export class BenchmarkStorage {
+  private filePath: string;
+
+  constructor(filePath: string = "./benchmark-results.jsonl") {
+    this.filePath = path.resolve(filePath);
+  }
+
+  async appendResult(benchmark: QueuedBenchmark): Promise<void> {
+    const line = JSON.stringify(benchmark) + "\n";
+    await fs.appendFile(this.filePath, line, "utf-8");
+  }
+
+  async getAllResults(): Promise<QueuedBenchmark[]> {
+    try {
+      const content = await fs.readFile(this.filePath, "utf-8");
+      const lines = content.trim().split("\n").filter(line => line.length > 0);
+      return lines.map(line => JSON.parse(line));
+    } catch (error: any) {
+      if (error.code === "ENOENT") {
+        return []; // File doesn't exist yet
+      }
+      throw error;
+    }
+  }
+
+  async getResultById(id: string): Promise<QueuedBenchmark | undefined> {
+    const results = await this.getAllResults();
+    return results.find(r => r.id === id);
+  }
+
+  async clearResults(): Promise<void> {
+    try {
+      await fs.unlink(this.filePath);
+    } catch (error: any) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+}

client/README.md

@@ -0,0 +1,81 @@
+# Benchmark Client
+
+CLI client for interacting with the Transformers.js benchmark server.
+
+## Installation
+
+```bash
+npm install
+```
+
+## Usage
+
+The client provides commands to submit benchmarks, check their status, and view results.
+
+From the client directory:
+```bash
+npm run cli -- <command> [options]
+```
+
+Or from the root directory:
+```bash
+npm run cli --prefix client -- <command> [options]
+```
+
+### Submit a Benchmark
+
+```bash
+npm run cli -- submit <modelId> <task> [options]
+```
+
+**Options:**
+- `--platform <node|web>` - Platform to run on (default: node)
+- `--mode <warm|cold>` - Cache mode (default: warm)
+- `--repeats <n>` - Number of times to repeat (default: 3)
+- `--batch-size <n>` - Batch size for inference (default: 1)
+- `--dtype <type>` - Data type (fp32, fp16, q8, etc.)
+- `--device <device>` - Device for web platform (default: webgpu)
+- `--browser <chromium|firefox|webkit>` - Browser for web (default: chromium)
+- `--headed` - Run browser in headed mode
+- `--wait` - Wait for completion
+
+**Examples:**
+
+```bash
+# Submit a Node.js benchmark
+npm run cli -- submit Xenova/all-MiniLM-L6-v2 feature-extraction --platform node --repeats 5 --wait
+
+# Submit a web benchmark with WebGPU
+npm run cli -- submit Xenova/distilbert-base-uncased fill-mask --platform web --device webgpu --headed
+
+# Submit with specific dtype
+npm run cli -- submit Xenova/all-MiniLM-L6-v2 feature-extraction --dtype fp16 --batch-size 4
+```
+
+### Get Benchmark Result
+
+```bash
+npm run cli -- get <benchmark-id>
+```
+
+### List All Benchmarks
+
+```bash
+npm run cli -- list
+```
+
+### Check Queue Status
+
+```bash
+npm run cli -- queue
+```
+
+## Configuration
+
+Set the server URL via environment variable:
+
+```bash
+export BENCH_SERVER_URL=http://localhost:3000
+```
+
+Default: `http://localhost:3000`

client/package-lock.json

@@ -0,0 +1,770 @@
+{
+  "name": "client",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "client",
+      "version": "0.0.1",
+      "dependencies": {
+        "yargs": "^17.7.2"
+      },
+      "devDependencies": {
+        "@types/yargs": "^17.0.33",
+        "tsx": "^4.20.6",
+        "typescript": "^5.9.3"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.10.tgz",
+      "integrity": "sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.10.tgz",
+      "integrity": "sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.10.tgz",
+      "integrity": "sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.10.tgz",
+      "integrity": "sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.10.tgz",
+      "integrity": "sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.10.tgz",
+      "integrity": "sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.10.tgz",
+      "integrity": "sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.10.tgz",
+      "integrity": "sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.10.tgz",
+      "integrity": "sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.10.tgz",
+      "integrity": "sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.10.tgz",
+      "integrity": "sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.10.tgz",
+      "integrity": "sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.10.tgz",
+      "integrity": "sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.10.tgz",
+      "integrity": "sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.10.tgz",
+      "integrity": "sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.10.tgz",
+      "integrity": "sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.10.tgz",
+      "integrity": "sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.10.tgz",
+      "integrity": "sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.10.tgz",
+      "integrity": "sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.10.tgz",
+      "integrity": "sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.10.tgz",
+      "integrity": "sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.10.tgz",
+      "integrity": "sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.10.tgz",
+      "integrity": "sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.10.tgz",
+      "integrity": "sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.10.tgz",
+      "integrity": "sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.10.tgz",
+      "integrity": "sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@types/yargs": {
+      "version": "17.0.33",
+      "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz",
+      "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/yargs-parser": "*"
+      }
+    },
+    "node_modules/@types/yargs-parser": {
+      "version": "21.0.3",
+      "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz",
+      "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.10",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.10.tgz",
+      "integrity": "sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.10",
+        "@esbuild/android-arm": "0.25.10",
+        "@esbuild/android-arm64": "0.25.10",
+        "@esbuild/android-x64": "0.25.10",
+        "@esbuild/darwin-arm64": "0.25.10",
+        "@esbuild/darwin-x64": "0.25.10",
+        "@esbuild/freebsd-arm64": "0.25.10",
+        "@esbuild/freebsd-x64": "0.25.10",
+        "@esbuild/linux-arm": "0.25.10",
+        "@esbuild/linux-arm64": "0.25.10",
+        "@esbuild/linux-ia32": "0.25.10",
+        "@esbuild/linux-loong64": "0.25.10",
+        "@esbuild/linux-mips64el": "0.25.10",
+        "@esbuild/linux-ppc64": "0.25.10",
+        "@esbuild/linux-riscv64": "0.25.10",
+        "@esbuild/linux-s390x": "0.25.10",
+        "@esbuild/linux-x64": "0.25.10",
+        "@esbuild/netbsd-arm64": "0.25.10",
+        "@esbuild/netbsd-x64": "0.25.10",
+        "@esbuild/openbsd-arm64": "0.25.10",
+        "@esbuild/openbsd-x64": "0.25.10",
+        "@esbuild/openharmony-arm64": "0.25.10",
+        "@esbuild/sunos-x64": "0.25.10",
+        "@esbuild/win32-arm64": "0.25.10",
+        "@esbuild/win32-ia32": "0.25.10",
+        "@esbuild/win32-x64": "0.25.10"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.10.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz",
+      "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "4.20.6",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.20.6.tgz",
+      "integrity": "sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.25.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    }
+  }
+}

client/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "client",
+  "private": true,
+  "type": "module",
+  "version": "0.0.1",
+  "scripts": {
+    "cli": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/yargs": "^17.0.33",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}

client/src/index.ts

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+const SERVER_URL = process.env.BENCH_SERVER_URL || "http://localhost:3000";
+
+interface SubmitOptions {
+  platform?: "node" | "web";
+  modelId: string;
+  task: string;
+  mode?: "warm" | "cold";
+  repeats?: number;
+  dtype?: string;
+  batchSize?: number;
+  device?: string;
+  browser?: string;
+  headed?: boolean;
+}
+
+async function submitBenchmark(options: SubmitOptions) {
+  const response = await fetch(`${SERVER_URL}/api/benchmark`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(options),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to submit benchmark: ${response.statusText}`);
+  }
+
+  return await response.json();
+}
+
+async function getBenchmark(id: string) {
+  const response = await fetch(`${SERVER_URL}/api/benchmark/${id}`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to get benchmark: ${response.statusText}`);
+  }
+
+  return await response.json();
+}
+
+async function listBenchmarks() {
+  const response = await fetch(`${SERVER_URL}/api/benchmarks`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to list benchmarks: ${response.statusText}`);
+  }
+
+  return await response.json();
+}
+
+async function getQueueStatus() {
+  const response = await fetch(`${SERVER_URL}/api/queue`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to get queue status: ${response.statusText}`);
+  }
+
+  return await response.json();
+}
+
+async function pollBenchmark(id: string, interval = 2000): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const check = async () => {
+      try {
+        const result = await getBenchmark(id);
+
+        if (result.status === "completed") {
+          resolve(result);
+        } else if (result.status === "failed") {
+          reject(new Error(result.error));
+        } else {
+          console.log(`Status: ${result.status}...`);
+          setTimeout(check, interval);
+        }
+      } catch (error) {
+        reject(error);
+      }
+    };
+    check();
+  });
+}
+
+yargs(hideBin(process.argv))
+  .command(
+    "submit <modelId> <task>",
+    "Submit a new benchmark request",
+    (yargs) => {
+      return yargs
+        .positional("modelId", {
+          describe: "Model ID to benchmark",
+          type: "string",
+          demandOption: true,
+        })
+        .positional("task", {
+          describe: "Task to perform (e.g., feature-extraction, fill-mask)",
+          type: "string",
+          demandOption: true,
+        })
+        .option("platform", {
+          describe: "Platform to run on",
+          choices: ["node", "web"] as const,
+          default: "node" as const,
+        })
+        .option("mode", {
+          describe: "Cache mode",
+          choices: ["warm", "cold"] as const,
+          default: "warm" as const,
+        })
+        .option("repeats", {
+          describe: "Number of times to repeat the benchmark",
+          type: "number",
+          default: 3,
+        })
+        .option("batch-size", {
+          describe: "Batch size for inference",
+          type: "number",
+          default: 1,
+        })
+        .option("dtype", {
+          describe: "Data type (fp32, fp16, q8, etc.)",
+          type: "string",
+        })
+        .option("device", {
+          describe: "Device for web platform",
+          type: "string",
+          default: "webgpu",
+        })
+        .option("browser", {
+          describe: "Browser for web platform",
+          choices: ["chromium", "firefox", "webkit"] as const,
+          default: "chromium" as const,
+        })
+        .option("headed", {
+          describe: "Run browser in headed mode",
+          type: "boolean",
+          default: false,
+        })
+        .option("wait", {
+          describe: "Wait for benchmark completion",
+          type: "boolean",
+          default: false,
+        });
+    },
+    async (argv) => {
+      const options: SubmitOptions = {
+        modelId: argv.modelId,
+        task: argv.task,
+        platform: argv.platform,
+        mode: argv.mode,
+        repeats: argv.repeats,
+        batchSize: argv.batchSize,
+        device: argv.device,
+        browser: argv.browser,
+        headed: argv.headed,
+      };
+
+      if (argv.dtype) {
+        options.dtype = argv.dtype;
+      }
+
+      console.log("Submitting benchmark...");
+      const result = await submitBenchmark(options);
+      console.log(`✓ Benchmark queued: ${result.id}`);
+      console.log(`  Position in queue: ${result.position}`);
+
+      if (argv.wait) {
+        console.log("\nWaiting for completion...");
+        const completed = await pollBenchmark(result.id);
+        console.log("\n✅ Benchmark completed!");
+        console.log(JSON.stringify(completed.result, null, 2));
+      } else {
+        console.log(`\nCheck status with: bench-client get ${result.id}`);
+      }
+    }
+  )
+  .command(
+    "get <id>",
+    "Get benchmark result by ID",
+    (yargs) => {
+      return yargs.positional("id", {
+        describe: "Benchmark ID",
+        type: "string",
+        demandOption: true,
+      });
+    },
+    async (argv) => {
+      const result = await getBenchmark(argv.id);
+      console.log(JSON.stringify(result, null, 2));
+    }
+  )
+  .command(
+    "list",
+    "List all benchmark results",
+    () => {},
+    async () => {
+      const result = await listBenchmarks();
+      console.log(`Total benchmarks: ${result.total}\n`);
+      result.results.forEach((b: any) => {
+        console.log(`${b.id} - ${b.status} - ${b.platform}/${b.modelId}/${b.task}`);
+      });
+    }
+  )
+  .command(
+    "queue",
+    "Show queue status",
+    () => {},
+    async () => {
+      const result = await getQueueStatus();
+      console.log("Queue Status:");
+      console.log(`  Pending: ${result.status.pending}`);
+      console.log(`  Running: ${result.status.running}`);
+      console.log(`  Completed: ${result.status.completed}`);
+      console.log(`  Failed: ${result.status.failed}`);
+
+      if (result.queue.length > 0) {
+        console.log("\nCurrent Queue:");
+        result.queue.forEach((b: any) => {
+          console.log(`  [${b.status}] ${b.id} - ${b.platform}/${b.modelId}`);
+        });
+      }
+    }
+  )
+  .demandCommand(1, "You need to specify a command")
+  .help()
+  .alias("h", "help")
+  .strict()
+  .parse();
+
+export { submitBenchmark, getBenchmark, listBenchmarks, getQueueStatus, pollBenchmark };

client/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*"]
+}