Package Reference

Every package Symmetra ships, every function it exposes, what each parameter does, and what each call returns. All signatures below match the published type definitions exactly.

One important concept before you start: Symmetra packages contain no JavaScript runtime code. They are compile-time type definitions. When you run sym server.ts, the Symmetra engine reads your source, resolves these imports, and generates CUDA C++ for your handlers. Your code never executes in Node.js.

@symmetra/http HTTP server

The GPU-native HTTP server. This is the package every Symmetra application starts with.

import { Router, serve } from '@symmetra/http'

new Router()

Creates a route table. Each route handler you register compiles to a CUDA device function.

const app = new Router()

app.get('/health', ctx => {
  ctx.json({ status: 'ok' })
})

// Grouped routes — everything under /api
const api = app.route('/api')
api.get('/users', ctx => { /* GET /api/users */ })
api.post('/users', ctx => { /* POST /api/users */ })

serve(app, options?)

The entry point. The Symmetra engine intercepts this call at compile time and uses it to configure the GPU server. Returns nothing — the process stays alive serving requests.

Returns: void (the server runs until the process is stopped)

All options are covered in depth with complete examples on the Server Configuration page. Summary:

The ctx object (SymmCtx)

Every handler receives one argument: the request/response context. This is how you read the request and write the response.

Reading the request:

Writing the response:

Utilities on ctx:

app.post('/echo', async ctx => {
  const body = await ctx.json<{ name: string }>()
  ctx.status(200)
     .header('X-Engine', 'symmetra')
  ctx.json({ hello: body.name, device: ctx.gpu.deviceName })
})

@symmetra/core GPU primitives

GPU buffer types, VRAM containers, and compute primitives. Most of these are standard JavaScript shapes (Map, Set, Promise, EventEmitter) that the compiler maps to GPU equivalents — you usually don't import them explicitly.

GpuBuffer<T>

A typed array resident in VRAM. Array operations compile to parallel CUDA kernels — one GPU thread per element instead of a CPU loop.

gpu (GpuApi)

Available as ctx.gpu inside handlers or imported as gpu from @symmetra/http.

GpuMap, GpuSet, GpuRegExp

Standard JavaScript Map, Set, and RegExp literals compile to VRAM-resident equivalents automatically. The interfaces match the standard built-ins — get/set/has/delete/clear/size, iteration, test/exec. RegExp literals compile to a GPU DFA at kernel-compile time, so there is no runtime regex JIT cost. Explicit constructors GpuMapOf(entries?) and GpuSetOf(values?) exist if you want to be explicit.

EventEmitter & Streams

EventEmitter matches the Node.js shape: on / once / off / emit / removeAllListeners / listenerCount. Event dispatch state lives in VRAM.

Streams follow the Node.js model — Readable, Writable, Transform, and pipeline(). Each pipeline stage maps to a VRAM ring buffer; data never leaves GPU memory between stages.

GpuWorker, MessageChannel, Atomics

GpuWorker maps to the Node.js worker_threads API. Each worker gets its own CUDA stream and an isolated VRAM slab.

URL, URLSearchParams, TextEncoder/Decoder, Timers, AbortController

• URL / URLSearchParams — standard WHATWG interfaces. Parsing happens CPU-side (not a hot path); parsed fields upload to the request's VRAM slab.
• TextEncoder.encode(str) returns a GpuBuffer<Uint8Array> in VRAM — one GPU thread per code point. TextDecoder.decode(buf) reverses it.
• setTimeout / setInterval / clearTimeout / clearInterval — standard signatures. A CPU min-heap fires callbacks onto a dedicated GPU timer stream.
• AbortController / AbortSignal — standard shape. The signal compiles to a VRAM flag; abort() sets it instantly with cuMemsetD8. Kernels check the flag at yield points, and @symmetra/net requests accept it.

@symmetra/kv VRAM key-value store

A key-value cache that lives in GPU memory. No Redis process, no DRAM round-trip, no serialization between your handler and the store.

import { KvStore } from '@symmetra/kv'

// Instantiate at module scope — maps to a VRAM allocation
const cache = new KvStore({ maxMb: 256, namespace: 'app' })

Constructor options: maxMb (VRAM budget, default 256) and namespace (key prefix, default empty). The per-request ctx.kv exposes the same API plus keys(pattern?).

Measured behavior (beta, 128 of 6,144 CUDA cores): on our RTX 5070 test rig, a handler doing one KV set + one KV get per request sustained ~3.5K req/s at 6.4ms median — cooperative GPU↔CPU I/O has real cost. Cache-friendly patterns (e.g. memoized Fibonacci) measured ~5.9K req/s at 553µs median.

@symmetra/db Database clients

Typed clients for PostgreSQL, SQLite, and Redis. Database I/O is handled by the CPU side of the runtime (the GPU requests it cooperatively), so treat these as standard async clients.

import { postgres, sqlite, redis } from '@symmetra/db'

postgres(config) → PgClient

Config: host, port, database, user, password, ssl?, maxConnections?, idleTimeoutMs?.

sqlite(options) → SqliteClient — options: path, readOnly?, walMode?. Same query/queryOne/execute shape (SqliteResult adds lastInsertRowid and changes), plus one GPU-specific method:

redis(config?) → RedisClient — standard command set: get, set (with ex/px/nx/xx options), del, exists, expire, ttl, incr, incrBy, hashes (hset/hget/hgetall), sets (sadd/smembers/sismember), lists (lpush/rpush/lrange), and pipeline() for batched commands ending in exec() → Promise<(string|number|null)[]>.

@symmetra/fs Filesystem

import { fs, jsonFs } from '@symmetra/fs'

@symmetra/crypto Cryptography

import { hash, cipher, kdf, random, jwt, password } from '@symmetra/crypto'

@symmetra/env Configuration

import { env, config } from '@symmetra/env'

// Schema-validated, fully typed environment loading
const settings = env.load({
  PORT:         { type: 'port',    default: 8080 },
  DATABASE_URL: { type: 'url',     required: true },
  DEBUG:        { type: 'boolean', default: false },
})
// settings.PORT is number, settings.DATABASE_URL is string, settings.DEBUG is boolean

@symmetra/net Networking

import { http, connect, createUdp, websocket, dns } from '@symmetra/net'

http — outbound HTTP client. All methods return Promise<HttpResponse> where the response has status, ok, headers, and body accessors text(), json<T>(), bytes():

Measured behavior (beta): a handler that performs an outbound fetch back into itself (full GPU → CPU → GPU round trip) measured ~166 req/s at 30ms median on our test rig. Outbound I/O is the most expensive thing a handler can do — cache aggressively.

connect(options) → Promise<TcpSocket> — raw TCP with optional TLS. Socket: write(), read(length?), readLine(), readAll(), close(), plus connected, remoteAddress, remotePort.

createUdp(options?) → Promise<UdpSocket> — send(data, host, port), receive() → { data, remoteAddress, remotePort }, close(). Supports broadcast and multicast groups.

websocket(url, options?) → Promise<WebSocket> — send(), receive() → { type: 'text'|'binary'|'close'|'ping', data }, close(code?, reason?), and a readyState property.

dns — resolve(hostname, type?), lookup(hostname), reverse(ip), records(hostname, type) for A/AAAA/CNAME/MX/TXT/NS records.