vectrojs 0.0.1 → 0.1.1

package/bin/vectro.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// vectro serve --root ~/data [--port 8787] [--pg 5433] ...
+//   Serves the CSV, TSV, JSON-lines, Arrow and .vectro files in the folder as
+//   SQL tables over HTTP and / or the PostgreSQL protocol (src/serve/).
+import { serve, servePg, serveFlight, openTables } from '../src/serve/index.mjs';
+
+const [command, ...rest] = process.argv.slice(2);
+const HELP = `usage: vectro serve --root <folder> [options]
+
+  Every CSV, TSV, JSON-lines, Arrow / Feather and .vectro file in the folder
+  becomes a table named after its file.
+
+  HTTP (Excel, Power BI Web, Google Sheets, pandas):
+    --port 8787            the HTTP port (--no-http: none)
+    --token <secret>       requests need "Authorization: Bearer <secret>"
+    --cors                 allow pages from other sites
+  PostgreSQL (Power BI, Tableau, Metabase, Grafana, psql):
+    --pg 5433              also speak the PostgreSQL protocol on this port
+    --user <name> --password <secret>   (or VECTRO_PG_PASSWORD; needed with --host)
+    --auth scram|md5|password           how the password is checked (scram)
+    --tls-cert <file> --tls-key <file>  encrypted connections
+    --database <name>      the database name reported (vectro)
+    --log-queries          print every statement clients send
+  Arrow Flight SQL (pandas, Polars, DuckDB through ADBC):
+    --flight 31337         also serve Flight SQL on this port (grpc://host:31337)
+                           (--user / --password and --tls-cert / --tls-key as above)
+  All:
+    --host 127.0.0.1       the address to listen on (0.0.0.0: every network)
+    --quiet
+
+  curl 'http://127.0.0.1:8787/sql?q=SELECT region, COUNT(*) FROM orders GROUP BY 1&format=csv'
+  psql -h 127.0.0.1 -p 5433 -U vectro vectro`;
+
+function option(name, fallback) {
+  const i = rest.indexOf(`--${name}`);
+  if (i < 0) return fallback;
+  const v = rest[i + 1];
+  if (v === undefined || v.startsWith('--')) { console.error(`vectro: --${name} needs a value\n\n${HELP}`); process.exit(2); }
+  return v;
+}
+
+if (command !== 'serve') {
+  console.log(HELP);
+  process.exit(command === undefined || command === 'help' || command === '--help' ? 0 : 2);
+}
+const quiet = rest.includes('--quiet');
+const log = quiet ? () => {} : (msg) => process.stderr.write(`[vectro] ${msg}\n`);
+try {
+  const host = option('host', '127.0.0.1');
+  const catalog = await openTables({ root: option('root', process.cwd()), log });
+  const running = [];
+  if (!rest.includes('--no-http')) {
+    const s = await serve({ catalog, port: Number(option('port', process.env.PORT ?? 8787)), host, token: option('token', process.env.VECTRO_TOKEN ?? null), cors: rest.includes('--cors'), log });
+    running.push(s);
+    log(`HTTP at ${s.url}: try ${s.url}/sql?q=${encodeURIComponent(`SELECT * FROM ${[...catalog.entries.keys()][0] ?? 'mytable'} LIMIT 5`)}`);
+  }
+  const pgPort = option('pg', null);
+  if (pgPort !== null) {
+    const certFile = option('tls-cert', null), keyFile = option('tls-key', null);
+    const p = await servePg({
+      catalog, port: Number(pgPort), host, user: option('user', null), password: option('password', process.env.VECTRO_PG_PASSWORD ?? null),
+      auth: option('auth', 'scram'), tls: certFile && keyFile ? { certFile, keyFile } : null, database: option('database', 'vectro'),
+      log, logQueries: rest.includes('--log-queries'),
+    });
+    running.push(p);
+    log(`PostgreSQL at ${p.host}:${p.port} (database ${option('database', 'vectro')}${certFile ? ', TLS' : ''}): psql -h ${p.host} -p ${p.port} -U ${option('user', 'vectro')} ${option('database', 'vectro')}`);
+  }
+  const flightPort = option('flight', null);
+  if (flightPort !== null) {
+    const certFile = option('tls-cert', null), keyFile = option('tls-key', null);
+    const f = await serveFlight({ catalog, port: Number(flightPort), host, user: option('user', null), password: option('password', process.env.VECTRO_PG_PASSWORD ?? null), tls: certFile && keyFile ? { certFile, keyFile } : null, database: option('database', 'vectro'), log, logQueries: rest.includes('--log-queries') });
+    running.push(f);
+    log(`Flight SQL at ${f.url}`);
+  }
+  log(`${catalog.entries.size} table(s): ${[...catalog.entries].map(([n, e]) => `${n} (${e.table.length.toLocaleString()} rows)`).join(', ') || 'none'}`);
+  const stop = () => Promise.all(running.map((s) => s.close())).then(() => catalog.close()).then(() => process.exit(0));
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+} catch (err) {
+  console.error(`vectro: ${err.message.replace(/^vectro:\s*/, '')}`);
+  process.exit(1);
+}

package/mcp/server.mjs

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+// Vectro MCP server: lets an AI assistant (Claude, ChatGPT, any MCP client)
+// load data files and ask analytics questions, answered by Vectro on all
+// cores. Speaks the Model Context Protocol over stdio (JSON-RPC 2.0, one
+// message per line), with no dependencies.
+//
+//   node mcp/server.mjs --root ~/data     (files outside --root are refused)
+//
+// Safety: the assistant only reads files under --root, and its expressions
+// are Vectro's small math language (no code runs, no eval).
+import { realpathSync } from 'node:fs';
+import { resolve, extname, basename } from 'node:path';
+import { createInterface } from 'node:readline';
+import { Engine, sql } from '../src/node.mjs';
+import { LoadError, safePath as safePathIn, loadFile, columnsOf, kindOf } from '../src/serve/catalog.mjs';
+
+const VERSION = '0.1.1';
+const PROTOCOLS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+const MAX_ROWS = 500, DEFAULT_ROWS = 50;
+
+const args = process.argv.slice(2);
+const rootArg = args.includes('--root') ? args[args.indexOf('--root') + 1] : process.cwd();
+const ROOT = realpathSync(resolve(rootArg));
+const engine = new Engine();
+const tables = new Map(); // name -> { table, source, chain: tables to free when dropped (add_column builds on the previous one) }
+const log = (...a) => process.stderr.write(`[vectro-mcp] ${a.join(' ')}\n`);
+
+// ---- tools --------------------------------------------------------------------
+const TOOLS = [
+  {
+    name: 'load_file',
+    description: 'Load a CSV, TSV, JSON-lines (one flat JSON object per line) or Arrow file (.arrow, .feather, .ipc) from the data folder into a named table, or open a Vectro dataset (.vectro: a table on disk, any size; queries read it in chunks). Returns its columns, their kinds and a few sample rows. Text columns become categories (filterable, groupable).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'File path, relative to the data folder' },
+        name: { type: 'string', description: 'Table name to use in later calls (default: the file name without extension)' },
+        types: { type: 'object', description: 'Optional column kinds: { column: "number" | "category" | "string" } (string = free text, returned but not filtered)', additionalProperties: { type: 'string' } },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'list_tables',
+    description: 'List the loaded tables with their row counts and columns.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'describe_table',
+    description: 'Column statistics: for numbers min, max, mean and missing count; for categories the number of distinct labels and the most common ones.',
+    inputSchema: { type: 'object', properties: { table: { type: 'string' } }, required: ['table'] },
+  },
+  {
+    name: 'query',
+    description: [
+      'Answer a question about a table. All parts are optional except table.',
+      'Expressions use column names, numbers, + - * /, comparisons (== != < <= > >=), && || !, cond ? a : b, and abs sqrt floor ceil min max. Text is compared with quotes: region == \'EU\'. Category text functions: startsWith(col, \'x\'), endsWith(col, \'x\'), contains(col, \'x\'), in(col, \'a\', \'b\'), like(col, \'EU-%\') (% any run, _ one character). Date columns compare with ISO text (ts >= \'2024-03-01\') and have year(ts), month(ts), day(ts), hour(ts), weekday(ts) (1 = Monday), dayStart(ts), weekStart(ts), monthStart(ts). Missing values: isMissing(x), coalesce(x, 0); sum, mean, min, max and count(x) skip them.',
+      'filter: which rows, e.g. "region == \'EU\' && price > 100".',
+      'aggregates: { name: "sum(expr)" | "mean(expr)" | "min(expr)" | "max(expr)" | "count()" | "count(condition)" | "countDistinct(expr)" }.',
+      'group_by: a column (any text or number column) or a list of columns, to aggregate per group.',
+      'sort: a column, aggregate name or expression ("-" first for largest first), or a list of them.',
+      'limit: rows to return (default 50, at most 500).',
+      'Without aggregates it returns matching rows; with aggregates and no group_by, one row of totals.',
+    ].join(' '),
+    inputSchema: {
+      type: 'object',
+      properties: {
+        table: { type: 'string' },
+        filter: { type: 'string' },
+        group_by: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+        aggregates: { type: 'object', additionalProperties: { type: 'string' } },
+        sort: { oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+        limit: { type: 'integer', minimum: 1, maximum: MAX_ROWS },
+      },
+      required: ['table'],
+    },
+  },
+  {
+    name: 'sql',
+    description: [
+      'Run one SQL SELECT over the loaded tables (by their names).',
+      'SELECT [DISTINCT] ... FROM t [[LEFT | RIGHT | FULL] JOIN u ON t.x = u.y | USING (x)] WHERE ... GROUP BY ... HAVING ... ORDER BY ... [ASC|DESC] LIMIT n [OFFSET m]; WITH (CTEs), subqueries (IN, EXISTS, correlated), UNION / INTERSECT / EXCEPT, window functions (ROW_NUMBER, RANK, SUM(...) OVER (...)), MEDIAN and PERCENTILE_CONT.',
+      'Aggregates: COUNT(*), COUNT(x), COUNT(DISTINCT x), SUM, AVG, MIN, MAX, APPROX_COUNT_DISTINCT. Also BETWEEN, IN, LIKE, IS NULL, CASE WHEN, COALESCE, ROUND, LEAST, GREATEST, CAST, DATE \'2024-01-01\', INTERVAL \'7 days\', EXTRACT(YEAR FROM ts), DATE_TRUNC(\'month\', ts), YEAR(ts), MONTH(ts).',
+      'Text: compare, LIKE / ILIKE, IN, ||, UPPER, LOWER, TRIM, SUBSTRING, REPLACE, LENGTH, SPLIT_PART, STRFTIME and more. Missing values are NULL (missing text is \'\').',
+      'At most 500 rows come back (add LIMIT); the answer says how many rows the query has.',
+    ].join(' '),
+    inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+  },
+  {
+    name: 'search_similar',
+    description: 'For tables loaded from JSON lines that have an embedding field (an array of numbers): the k rows whose embeddings are most similar (cosine) to a given row\'s, or to a given vector. Optional filter on the other columns.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        table: { type: 'string' },
+        like: { type: 'object', description: 'The row to compare with, found by a column value, e.g. { "column": "id", "value": 42 }', properties: { column: { type: 'string' }, value: {} }, required: ['column', 'value'] },
+        vector: { type: 'array', items: { type: 'number' }, description: 'Or an embedding to compare with (same length as the stored ones)' },
+        k: { type: 'integer', minimum: 1, maximum: MAX_ROWS },
+        filter: { type: 'string', description: 'Which rows may be returned, e.g. "year >= 2020"' },
+      },
+      required: ['table'],
+    },
+  },
+  {
+    name: 'add_column',
+    description: 'Add a computed column to a table, e.g. name "revenue", expression "price * qty * (1 - discount)".',
+    inputSchema: { type: 'object', properties: { table: { type: 'string' }, name: { type: 'string' }, expression: { type: 'string' } }, required: ['table', 'name', 'expression'] },
+  },
+  {
+    name: 'drop_table',
+    description: 'Unload a table and free its memory.',
+    inputSchema: { type: 'object', properties: { table: { type: 'string' } }, required: ['table'] },
+  },
+];
+
+class ToolError extends Error {}
+
+function release(name) {
+  const entry = tables.get(name);
+  if (!entry) return;
+  for (const t of entry.chain.reverse()) { if (t.isDataset) t.close(); else t.dispose(); }
+  entry.index?.dispose();
+  tables.delete(name);
+}
+
+const safePath = (path) => safePathIn(ROOT, path);
+
+function getTable(name) {
+  const entry = tables.get(name);
+  if (!entry) throw new ToolError(`no table "${name}" (loaded: ${[...tables.keys()].join(', ') || 'none'}; use load_file)`);
+  return entry;
+}
+
+const clean = (rows) => rows.map((r) => Object.fromEntries(Object.entries(r).map(([k, v]) => [k, v instanceof Date ? v.toISOString() : typeof v === 'number' && !Number.isFinite(v) ? null : v])));
+const handlers = {
+  sql({ query }) {
+    const all = Object.fromEntries([...tables].map(([n, e]) => [n, e.table]));
+    const t = sql(query, all).collect();
+    try {
+      const rows = clean(t.toRows(MAX_ROWS));
+      return { rows_in_answer: t.length, returned: rows.length, rows };
+    } finally { t.dispose(); }
+  },
+  async load_file({ path, name, types }) {
+    const real = safePath(path);
+    const tname = name || basename(real, extname(real)).replace(/[^A-Za-z0-9_]/g, '_');
+    const { table, skipped = 0, index = null, embedding = null, onDisk } = await loadFile(engine, real, { types });
+    release(tname);
+    tables.set(tname, { table, source: path, chain: [table], index });
+    if (onDisk) return { table: tname, rows: table.length, on_disk: true, columns: columnsOf(table), sample: clean(table.toRows(5)) };
+    return { table: tname, rows: table.length, columns: columnsOf(table), sample: clean(table.toRows(5)), ...(embedding ? { embedding } : {}), ...(skipped ? { skipped_lines: skipped } : {}) };
+  },
+  list_tables() {
+    return [...tables].map(([name, { table, source }]) => ({ table: name, source, rows: table.length, columns: columnsOf(table) }));
+  },
+  describe_table({ table: name }) {
+    const { table } = getTable(name);
+    const out = {};
+    for (const [col, c] of table.cols) {
+      if (c.strings) { out[col] = { kind: 'text' }; continue; }
+      if (c.dict) {
+        const grouped = table.groupBy(col).agg({ rows: 'count()' });
+        const g = table.isDataset ? grouped.collect() : grouped;
+        const top = clean(g.top(10, ['-rows', col]).toRows());
+        out[col] = { kind: 'category', distinct: g.length, most_common: top };
+        g.dispose();
+        continue;
+      }
+      const a = table.filter(`${col} == ${col}`).agg({ n: 'count()', min: `min(${col})`, max: `max(${col})`, mean: `mean(${col})` });
+      if (c.date) { // ISO text; filter with ts >= '2024-01-01', year(ts), month(ts)...
+        const iso = (v) => (Number.isFinite(v) ? new Date(v).toISOString() : null);
+        out[col] = { kind: 'date', min: iso(a.min), max: iso(a.max), missing: table.length - a.n };
+        continue;
+      }
+      out[col] = { kind: 'number', ...clean([a])[0], missing: table.length - a.n };
+    }
+    return { table: name, rows: table.length, columns: out };
+  },
+  query({ table: name, filter, group_by: groupBy, aggregates, sort, limit = DEFAULT_ROWS }) {
+    const entry = getTable(name);
+    const lim = Math.max(1, Math.min(MAX_ROWS, Math.floor(limit)));
+    const ds = entry.table.isDataset; // (a dataset: a lazy query, read in chunks)
+    const view = ds ? (filter ? entry.table.filter(filter) : entry.table.lazy()) : filter ? entry.table.filter(filter) : entry.table;
+    const hasAgg = aggregates && Object.keys(aggregates).length;
+    if (groupBy) {
+      if (!hasAgg) throw new ToolError('group_by needs aggregates, e.g. { "orders": "count()" }');
+      const grouped = view.groupBy(groupBy).agg(aggregates);
+      const g = ds ? grouped.collect() : grouped;
+      try {
+        const groups = g.length;
+        const t = sort ? g.top(lim, sort) : null;
+        const rows = clean((t ?? g).toRows(lim));
+        t?.dispose();
+        return { groups, returned: rows.length, rows };
+      } finally { g.dispose(); }
+    }
+    if (hasAgg) return { rows: clean([view.agg(aggregates)]) };
+    if (ds) return (() => { const rows = clean((sort ? view.top(lim, sort) : view.limit(lim)).toRows()); return { matching_rows: filter ? view.count() : entry.table.length, returned: rows.length, rows }; })();
+    const matching = filter ? view.count() : view.length;
+    const t = sort ? view.top(lim, sort) : null;
+    const rows = clean((t ?? view).toRows(lim));
+    t?.dispose();
+    return { matching_rows: matching, returned: rows.length, rows };
+  },
+  async search_similar({ table: name, like, vector, k = 10, filter }) {
+    const entry = getTable(name);
+    if (!entry.index) throw new ToolError(`table "${name}" has no embeddings (load a JSON-lines file with an array-of-numbers field)`);
+    let q = vector;
+    if (!q) {
+      if (!like?.column) throw new ToolError('give like: { column, value } or vector');
+      const value = typeof like.value === 'string' ? `'${like.value.replaceAll("'", '')}'` : Number(like.value);
+      const dims = Array.from({ length: entry.index.dim }, (_, j) => `v${j}`);
+      const [row] = entry.index.table.filter(`${like.column} == ${value}`).select(...dims).toRows(1);
+      if (!row) throw new ToolError(`no row where ${like.column} is ${JSON.stringify(like.value)}`);
+      q = dims.map((d) => row[d]);
+    }
+    const hits = await entry.index.searchAsync(q, { k: Math.max(1, Math.min(MAX_ROWS, Math.floor(k))), filter });
+    return { returned: hits.length, rows: clean(hits) };
+  },
+  add_column({ table: name, name: col, expression }) {
+    const entry = getTable(name);
+    if (entry.table.isDataset) throw new ToolError(`"${name}" is a dataset on disk; use the expression directly in query or sql instead of adding a column`);
+    const derived = entry.table.derive(col, expression); // shares the old columns
+    entry.table = derived;
+    entry.chain.push(derived);
+    return { table: name, columns: columnsOf(derived), sample: clean(derived.toRows(3)) };
+  },
+  drop_table({ table: name }) {
+    getTable(name);
+    release(name);
+    return { dropped: name };
+  },
+};
+
+// ---- JSON-RPC over stdio ----------------------------------------------------------
+const send = (msg) => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...msg })}\n`);
+
+async function handle(msg) {
+  const { id, method, params } = msg;
+  const reply = (result) => id !== undefined && send({ id, result });
+  const error = (code, message) => id !== undefined && send({ id, error: { code, message } });
+  switch (method) {
+    case 'initialize': {
+      const asked = params?.protocolVersion;
+      return reply({
+        protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: { name: 'vectro', title: 'Vectro analytics', version: VERSION },
+        instructions: `Load CSV, JSON-lines, Arrow or .vectro files from ${ROOT} with load_file, then answer questions with sql (or query: filter, group_by, aggregates, sort, limit). Use describe_table to see columns and common values first.`,
+      });
+    }
+    case 'notifications/initialized':
+    case 'notifications/cancelled':
+      return undefined;
+    case 'ping':
+      return reply({});
+    case 'tools/list':
+      return reply({ tools: TOOLS });
+    case 'tools/call': {
+      const fn = handlers[params?.name];
+      if (!fn) return error(-32602, `unknown tool: ${params?.name}`);
+      try {
+        const t0 = performance.now();
+        const result = await fn(params.arguments ?? {});
+        const ms = Math.round((performance.now() - t0) * 100) / 100;
+        const body = Array.isArray(result) ? { tables: result, ms } : { ...result, ms };
+        return reply({ content: [{ type: 'text', text: JSON.stringify(body) }], structuredContent: body, isError: false });
+      } catch (err) {
+        // tool errors go back to the model, so it can fix its call
+        return reply({ content: [{ type: 'text', text: err instanceof ToolError || err instanceof LoadError || /^vectro:/.test(err.message) ? err.message : `error: ${err.message}` }], isError: true });
+      }
+    }
+    default:
+      if (method?.startsWith('notifications/')) return undefined;
+      return error(-32601, `method not found: ${method}`);
+  }
+}
+
+let queue = Promise.resolve();
+const rl = createInterface({ input: process.stdin });
+rl.on('line', (line) => {
+  if (!line.trim()) return;
+  let msg;
+  try { msg = JSON.parse(line); } catch { return send({ id: null, error: { code: -32700, message: 'parse error' } }); }
+  for (const m of Array.isArray(msg) ? msg : [msg]) queue = queue.then(() => handle(m)); // one call at a time, in order
+});
+rl.on('close', () => queue.then(() => engine.close()).then(() => process.exit(0)));
+log(`ready; data folder ${ROOT}`);

package/package.json

@@ -1,15 +1,93 @@
 {
   "name": "vectrojs",
-  "version": "0.0.1",
-  "description": "Multi-core analytics engine for JavaScript (Node, browsers, edge). Coming soon.",
+  "version": "0.1.1",
+  "description": "Multi-core analytics engine for JavaScript: columnar tables, SQL and fused SIMD WebAssembly kernels for Node, browsers and edge runtimes, with no native code. Serves tables to Power BI, Tableau, Metabase, Grafana, pandas and Polars.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Hamza Masood",
+  "homepage": "https://vectrojs.dev",
+  "bugs": {
+    "url": "https://github.com/vectrojs/vectro/issues",
+    "email": "support@vectrojs.dev"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vectrojs/vectro.git"
   },
-  "homepage": "https://github.com/vectrojs",
-  "license": "MIT",
+  "keywords": [
+    "analytics",
+    "query-engine",
+    "embedded-database",
+    "javascript",
+    "nodejs",
+    "sql",
+    "dataframe",
+    "columnar",
+    "olap",
+    "webassembly",
+    "wasm",
+    "simd",
+    "multithreading",
+    "worker-threads",
+    "csv",
+    "arrow",
+    "flight-sql",
+    "postgres-wire-protocol",
+    "odata",
+    "power-bi",
+    "tableau",
+    "duckdb-alternative",
+    "browser"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "src/node.mjs",
+  "exports": {
+    ".": "./src/node.mjs",
+    "./portable": "./src/portable.mjs",
+    "./browser": "./src/browser.mjs",
+    "./serve": "./src/serve/index.mjs",
+    "./dist/vectro.wasm": "./dist/vectro.wasm"
+  },
   "files": [
+    "src",
+    "bin",
+    "dist",
+    "mcp",
     "README.md",
-    "LICENSE"
-  ]
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build-wasm.mjs",
+    "prepublishOnly": "npm run build && npm test",
+    "test": "node test/test-ops.mjs && node test/test-fusion.mjs && node test/test-tables.mjs && node test/test-csv.mjs && node test/test-async.mjs && node test/test-split.mjs && node test/test-balance.mjs && node test/test-stream.mjs && node test/test-ndjson.mjs && node test/test-window.mjs && node test/test-websocket.mjs && node test/test-frames.mjs && node test/test-emitter.mjs && node test/test-arrow.mjs && node test/test-groupby.mjs && node test/test-partition.mjs && node test/test-join.mjs && node test/test-distinct.mjs && node test/test-distinct-wide.mjs && node test/test-types.mjs && node test/test-plan.mjs && node test/test-sql.mjs && node test/test-missing.mjs && node test/test-fast-paths.mjs && node test/test-pack.mjs && node test/test-dataset.mjs && node test/test-topk-dataset.mjs && node test/test-lookup-join.mjs && node test/test-sort.mjs && node test/test-zones.mjs && node test/test-textfns.mjs && node test/test-vectors.mjs && node test/test-mcp.mjs && node test/test-serve.mjs && node test/test-pg.mjs && node test/test-odata.mjs && node test/test-flight.mjs && node test/test-connectors.mjs && node test/test-check-cases.mjs",
+    "test:single": "VECTRO_MODE=single sh -c 'node test/test-ops.mjs && node test/test-fusion.mjs && node test/test-tables.mjs && node test/test-csv.mjs'",
+    "test:interp": "VECTRO_MODE=interp sh -c 'node test/test-ops.mjs && node test/test-fusion.mjs && node test/test-tables.mjs && node test/test-csv.mjs'",
+    "test:edge": "npm run build && VECTRO_MODE=edge sh -c 'node --disallow-code-generation-from-strings test/test-ops.mjs && node --disallow-code-generation-from-strings test/test-fusion.mjs && node --disallow-code-generation-from-strings test/test-tables.mjs && node --disallow-code-generation-from-strings test/test-csv.mjs'",
+    "test:browser-sim": "VECTRO_MODE=browser-sim sh -c 'node test/test-ops.mjs && node test/test-fusion.mjs && node test/test-tables.mjs && node test/test-csv.mjs && node test/test-async.mjs'",
+    "test:all": "npm test && npm run test:single && npm run test:interp && npm run test:edge && npm run test:browser-sim && npm run test:compressed && npm run test:poison",
+    "test:compressed": "VECTRO_COMPRESS=1 npm test",
+    "test:poison": "VECTRO_POISON=1 VECTRO_COMPRESS=1 npm test",
+    "check:expected": "node scripts/make-check-expected.mjs",
+    "bench": "node --max-old-space-size=8192 bench/bench.mjs",
+    "bench:async": "node --max-old-space-size=8192 bench/bench-async.mjs",
+    "bench:skew": "node --max-old-space-size=8192 bench/bench-skew.mjs",
+    "bench:split-csv": "node --max-old-space-size=8192 bench/bench-split-csv.mjs",
+    "serve:browser": "node examples/browser-threads/serve.mjs 8766",
+    "serve:split": "node examples/browser-threads/serve.mjs 8767 --no-isolation",
+    "serve:phone": "node examples/browser-threads/serve.mjs 8772 --no-isolation --lan",
+    "bench:stream": "node bench/bench-stream.mjs",
+    "bench:sort": "node --max-old-space-size=8192 bench/bench-sort.mjs",
+    "bench:vectors": "node --max-old-space-size=8192 bench/bench-vectors.mjs",
+    "mcp": "node mcp/server.mjs",
+    "bench:pack": "node --max-old-space-size=8192 bench/bench-pack.mjs",
+    "bench:plan": "node --max-old-space-size=8192 bench/bench-plan.mjs",
+    "bench:zones": "node --max-old-space-size=8192 bench/bench-zones.mjs"
+  },
+  "bin": {
+    "vectro": "bin/vectro.mjs",
+    "vectro-mcp": "mcp/server.mjs"
+  }
 }