@velarscript/node 0.10.1

package/dist/websocket-runtime.js

@@ -0,0 +1,46 @@
+export const VELAR_NODE_WEBSOCKET_RUNTIME = String.raw `
+import __VelarWebSocket, { WebSocketServer as __VelarWebSocketServer } from "ws";
+import { createServer as __velarCreateHttpServer } from "node:http";
+import { readFile as __velarServeReadFile, realpath as __velarServeRealpath, stat as __velarServeStat } from "node:fs/promises";
+import { isAbsolute as __velarServeIsAbsolute, relative as __velarServeRelative, resolve as __velarServeResolve } from "node:path";
+import { ServeRequest as __velarServeRuntime } from "velar/serve";
+
+const __velarWebSocketConnections = new WeakMap();
+const __velarWebSocketServers = new WeakMap();
+const __velarServeNativeOperations = Object.freeze({readFile: __velarServeReadFile, realpath: __velarServeRealpath, stat: __velarServeStat, isAbsolute: __velarServeIsAbsolute, relative: __velarServeRelative, resolve: __velarServeResolve});
+function __velarWsInteger(value, fallback, minimum, maximum, name) { if (value === undefined || value === null) return fallback; if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new RangeError(name + " must be an integer from " + minimum + " through " + maximum); return value; }
+function __velarWsDuration(value, fallback) { if (value === undefined || value === null) return fallback; if (typeof value !== "string") throw new TypeError("WebSocket timeout must be Duration"); const match = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/.exec(value); if (!match) throw new TypeError("WebSocket timeout must be Duration such as 5s"); const result = Number(match[1]) * (match[2] === "s" ? 1000 : 1); if (!Number.isFinite(result) || result < 0 || result > 2147483647) throw new RangeError("WebSocket timeout is outside the supported range"); return result; }
+function __velarWsOptions(options = {}) { if (options === null || typeof options !== "object" || Array.isArray(options)) throw new TypeError("WebSocket options must be a record"); return { maxMessageBytes: __velarWsInteger(options.maxMessageBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxMessageBytes"), maxQueuedMessages: __velarWsInteger(options.maxQueuedMessages, 256, 1, 10000, "maxQueuedMessages"), maxQueuedBytes: __velarWsInteger(options.maxQueuedBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxQueuedBytes"), maxPendingSendBytes: __velarWsInteger(options.maxPendingSendBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxPendingSendBytes") }; }
+function __velarWsBytes(value) { if (value instanceof Uint8Array) { const output = new Uint8Array(value.byteLength); output.set(value); return output; } return null; }
+function __velarWsMessageBytes(value) { if (typeof value === "string") return Buffer.byteLength(value, "utf8"); const bytes = __velarWsBytes(value); if (bytes) return bytes.byteLength; throw new TypeError("WebSocket.send requires text or Bytes"); }
+export class WebSocketBackpressureError extends Error { constructor(message = "WebSocket backpressure limit exceeded") { super(message); this.name = "WebSocketBackpressureError"; } }
+export class WebSocketClosedError extends Error { constructor(message = "WebSocket is closed") { super(message); this.name = "WebSocketClosedError"; } }
+export class WebSocketProtocolError extends Error { constructor(message = "WebSocket protocol error") { super(message); this.name = "WebSocketProtocolError"; } }
+export class WebSocketTimeoutError extends Error { constructor(message = "WebSocket timed out") { super(message); this.name = "WebSocketTimeoutError"; } }
+function __velarWsFinish(state) { if (state.finished) return; state.finished = true; if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(null); } }
+function __velarWsAbort(state) { state.finished = true; state.queue.length = 0; state.queuedBytes = 0; if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(null); } }
+function __velarWsRejectReceive(state, socket, code, reason) { __velarWsAbort(state); socket.close(code, reason); }
+function __velarWsWrap(socket, options) {
+  const value = Object.create(__velarWsConnectionPrototype); const state = { socket, options, queue: [], queuedBytes: 0, waiter: null, pendingSendBytes: 0, finished: false, closePromise: null }; __velarWebSocketConnections.set(value, state);
+  socket.binaryType = "arraybuffer";
+  socket.on("message", (data, binary) => { if (state.finished) return; let message; let size; if (binary) { const source = data instanceof Uint8Array ? data : new Uint8Array(data); size = source.byteLength; if (size > options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 1009, "Message too large"); return; } message = new Uint8Array(size); message.set(source); } else { message = typeof data === "string" ? data : data.toString("utf8"); size = Buffer.byteLength(message, "utf8"); if (size > options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 1009, "Message too large"); return; } } if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(message); } else if (state.queue.length >= options.maxQueuedMessages || state.queuedBytes + size > options.maxQueuedBytes) __velarWsRejectReceive(state, socket, 1009, "Unread message queue full"); else { state.queue.push(message); state.queuedBytes += size; } });
+  socket.on("close", () => __velarWsFinish(state)); socket.on("error", error => { if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.reject(new WebSocketProtocolError(error instanceof Error ? error.message : "WebSocket error")); } __velarWsAbort(state); });
+  return Object.freeze(value);
+}
+const __velarWsConnectionPrototype = Object.freeze({
+  state() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket state requires a connection"); return state.socket.readyState === __VelarWebSocket.CONNECTING ? "connecting" : state.socket.readyState === __VelarWebSocket.OPEN ? "open" : state.socket.readyState === __VelarWebSocket.CLOSING ? "closing" : "closed"; },
+  send(message) { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket.send requires a connection"); if (state.socket.readyState !== __VelarWebSocket.OPEN) return Promise.reject(new WebSocketClosedError()); const size = __velarWsMessageBytes(message); if (size > state.options.maxMessageBytes) return Promise.reject(new RangeError("WebSocket message exceeds maxMessageBytes")); if (state.pendingSendBytes + size > state.options.maxPendingSendBytes) return Promise.reject(new WebSocketBackpressureError()); const bytes = typeof message === "string" ? null : __velarWsBytes(message); state.pendingSendBytes += size; return new Promise((resolve, reject) => state.socket.send(bytes ?? message, { binary: bytes !== null }, error => { state.pendingSendBytes -= size; if (error) reject(new WebSocketClosedError(error.message)); else resolve(null); })); },
+  next() { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket.next requires a connection"); if (state.queue.length) { const message = state.queue.shift(); state.queuedBytes -= __velarWsMessageBytes(message); return Promise.resolve(message); } if (state.finished) return Promise.resolve(null); if (state.waiter) return Promise.reject(new WebSocketBackpressureError("Only one WebSocket.next call may wait at a time")); return new Promise((resolve, reject) => { state.waiter = { resolve, reject }; }); },
+  close(code = 1000, reason = "") { const state = __velarWebSocketConnections.get(this); if (!state) throw new TypeError("WebSocket.close requires a connection"); if (!Number.isSafeInteger(code) || code < 1000 || code > 4999) return Promise.reject(new RangeError("WebSocket close code must be from 1000 through 4999")); if (typeof reason !== "string" || Buffer.byteLength(reason, "utf8") > 123) return Promise.reject(new RangeError("WebSocket close reason cannot exceed 123 UTF-8 bytes")); if (state.finished) return Promise.resolve(null); if (!state.closePromise) { state.closePromise = new Promise(resolve => state.socket.once("close", () => resolve(null))); state.socket.close(code, reason); } return state.closePromise; },
+});
+const __velarWsServerPrototype = Object.freeze({
+  next() { const state = __velarWebSocketServers.get(this); if (!state) throw new TypeError("WebSocketServer.next requires a server"); if (state.queue.length) return Promise.resolve(state.queue.shift()); if (state.stopped) return Promise.resolve(null); if (state.waiter) return Promise.reject(new WebSocketBackpressureError("Only one WebSocketServer.next call may wait at a time")); return new Promise((resolve, reject) => { state.waiter = { resolve, reject }; }); },
+  async stop() { const state = __velarWebSocketServers.get(this); if (!state) throw new TypeError("WebSocketServer.stop requires a server"); if (state.stopped) return null; state.stopped = true; if (state.waiter) { state.waiter.resolve(null); state.waiter = null; } for (const connection of state.connections) await connection.close(1001, "Server stopping"); await new Promise((resolve, reject) => state.server.close(error => error ? reject(error) : resolve(null))); if (state.httpServer) await new Promise((resolve, reject) => state.httpServer.close(error => error ? reject(error) : resolve(null))); return null; },
+});
+const __velarWsConnectionType = Object.freeze({ is(value) { return __velarWebSocketConnections.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match WebSocketConnection"); return value; } });
+const __velarWsServerType = Object.freeze({ is(value) { return __velarWebSocketServers.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match WebSocketServer"); return value; } });
+export const WebSocketConnection = __velarWsConnectionType; export const WebSocketServer = __velarWsServerType;
+export function connect(url, options = {}) { if (typeof url !== "string" || !/^wss?:\/\//u.test(url)) return Promise.reject(new TypeError("WebSocket URL must start with ws:// or wss://")); const limits = __velarWsOptions(options); const timeout = __velarWsDuration(options.timeout, 10000); return new Promise((resolve, reject) => { const socket = new __VelarWebSocket(url, { maxPayload: limits.maxMessageBytes }); const timer = setTimeout(() => { socket.terminate(); reject(new WebSocketTimeoutError("WebSocket connection timed out")); }, timeout); socket.once("open", () => { clearTimeout(timer); resolve(__velarWsWrap(socket, limits)); }); socket.once("error", error => { clearTimeout(timer); reject(new WebSocketProtocolError(error instanceof Error ? error.message : "WebSocket connection failed")); }); }); }
+export function listen(options) { if (options === null || typeof options !== "object" || Array.isArray(options)) return Promise.reject(new TypeError("listen requires an options record")); const limits = __velarWsOptions(options); const port = __velarWsInteger(options.port, 0, 0, 65535, "port"); const maxConnections = __velarWsInteger(options.maxConnections, 1024, 1, 100000, "maxConnections"); const maxPendingConnections = __velarWsInteger(options.maxPendingConnections, 128, 1, 10000, "maxPendingConnections"); if (options.host !== undefined && typeof options.host !== "string") return Promise.reject(new TypeError("WebSocket host must be text")); if (options.path !== undefined && (typeof options.path !== "string" || !options.path.startsWith("/"))) return Promise.reject(new TypeError("WebSocket path must start with '/'")); if (options.http !== undefined && typeof options.http !== "function") return Promise.reject(new TypeError("WebSocket http must be a velar/serve handler")); return new Promise((resolve, reject) => { const httpServer = options.http ? __velarCreateHttpServer((request, response) => { void __velarServeRuntime.__velarHandleNative(options.http, request, response, __velarServeNativeOperations); }) : null; const server = new __VelarWebSocketServer(httpServer ? { server: httpServer, path: options.path, maxPayload: limits.maxMessageBytes, perMessageDeflate: false, clientTracking: true } : { port, host: options.host ?? "127.0.0.1", path: options.path, maxPayload: limits.maxMessageBytes, perMessageDeflate: false, clientTracking: true }); const value = Object.create(__velarWsServerPrototype); const state = { server, httpServer, queue: [], waiter: null, stopped: false, connections: new Set() }; __velarWebSocketServers.set(value, state); server.on("connection", socket => { if (state.connections.size >= maxConnections || (!state.waiter && state.queue.length >= maxPendingConnections)) { socket.close(1013, "Server busy"); return; } const connection = __velarWsWrap(socket, limits); state.connections.add(connection); socket.once("close", () => state.connections.delete(connection)); if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(connection); } else state.queue.push(connection); }); server.once("error", reject); const ready = () => { const address = (httpServer ?? server).address(); Object.defineProperty(value, "port", { value: typeof address === "object" && address ? address.port : port, enumerable: true }); resolve(Object.freeze(value)); }; if (httpServer) { httpServer.once("error", reject); httpServer.listen({port, host: options.host ?? "127.0.0.1"}, ready); } else server.once("listening", ready); }); }
+`.trimStart();
+//# sourceMappingURL=websocket-runtime.js.map

package/dist/websocket-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-runtime.js","sourceRoot":"","sources":["../src/websocket-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,4BAA4B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CrD,CAAC,SAAS,EAAE,CAAC"}

package/dist/worker-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare const VELAR_NODE_WORKER_RUNTIME: string;
+//# sourceMappingURL=worker-runtime.d.ts.map

package/dist/worker-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime.d.ts","sourceRoot":"","sources":["../src/worker-runtime.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,QA8JzB,CAAC"}

package/dist/worker-runtime.js

@@ -0,0 +1,160 @@
+export const VELAR_NODE_WORKER_RUNTIME = String.raw `
+import { Worker as __VelarNodeWorker, isMainThread as __velarWorkerIsMainThread, parentPort as __velarWorkerParentPort } from "node:worker_threads";
+import { workerEntries as __velarWorkerEntries } from "velar/worker-manifest";
+import { Cancellation, CancellationError, TaskTimeoutError } from "velar/task";
+
+const __velarWorkerStates = new WeakMap();
+const __velarWorkerPoolStates = new WeakMap();
+let __velarWorkerServerInstalled = false;
+const __velarWorkerStructuredClone = globalThis.structuredClone;
+function __velarWorkerInteger(value, minimum, maximum, name) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new RangeError(name + " must be an integer from " + minimum + " through " + maximum);
+  return value;
+}
+function __velarWorkerRuntimeType(value, name) {
+  if ((typeof value !== "object" && typeof value !== "function") || value === null || typeof value.parse !== "function" || typeof value.is !== "function") throw new TypeError(name + " must be a runtime Type");
+  return value;
+}
+function __velarWorkerDuration(value) {
+  if (value === null) return 0;
+  if (typeof value !== "string") throw new TypeError("Worker timeout must be Duration or null");
+  const match = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/.exec(value);
+  if (!match) throw new TypeError("Worker timeout must be Duration such as 200ms or 2s");
+  const milliseconds = Number(match[1]) * (match[2] === "s" ? 1000 : 1);
+  if (!Number.isFinite(milliseconds) || milliseconds < 0 || milliseconds > 2147483647) throw new RangeError("Worker timeout is outside the supported range");
+  return milliseconds;
+}
+function __velarWorkerTransfer(value) {
+  const transfers = [];
+  const buffers = new Set();
+  const objects = new Set();
+  const pending = [{ value, depth: 0 }];
+  let visited = 0;
+  let transferBytes = 0;
+  while (pending.length > 0 && visited < 10000 && transfers.length < 1024) {
+    const current = pending.pop();
+    const item = current.value;
+    visited += 1;
+    if (item === null || (typeof item !== "object" && typeof item !== "function")) continue;
+    if (objects.has(item)) continue;
+    objects.add(item);
+    if (ArrayBuffer.isView(item)) {
+      const supported = item instanceof Uint8Array || item instanceof Uint16Array || item instanceof Uint32Array || item instanceof Float32Array;
+      const buffer = item.buffer;
+      if (supported && buffer instanceof ArrayBuffer && item.byteOffset === 0 && item.byteLength === buffer.byteLength
+        && buffer.byteLength > 0 && transferBytes + buffer.byteLength <= 64 * 1024 * 1024 && !buffers.has(buffer)) {
+        buffers.add(buffer);
+        transfers.push(buffer);
+        transferBytes += buffer.byteLength;
+      }
+      continue;
+    }
+    if (current.depth >= 32) continue;
+    const depth = current.depth + 1;
+    if (item instanceof Map) { for (const [key, nested] of item) { pending.push({ value: key, depth }, { value: nested, depth }); } continue; }
+    if (item instanceof Set) { for (const nested of item) pending.push({ value: nested, depth }); continue; }
+    for (const key of Object.keys(item)) pending.push({ value: item[key], depth });
+  }
+  return transfers;
+}
+function __velarWorkerOutbound(value) {
+  const sourceTransfers = __velarWorkerTransfer(value);
+  if (sourceTransfers.length === 0) return { value, transfers: sourceTransfers };
+  if (typeof __velarWorkerStructuredClone !== "function") throw new Error("The structured clone API is unavailable");
+  const snapshot = __velarWorkerStructuredClone(value);
+  return { value: snapshot, transfers: __velarWorkerTransfer(snapshot) };
+}
+function __velarWorkerFailure(error) {
+  return { name: typeof error?.name === "string" ? error.name : "Error", message: typeof error?.message === "string" ? error.message : String(error), stack: typeof error?.stack === "string" ? error.stack : "" };
+}
+export class WorkerBackpressureError extends Error { constructor(message = "Worker queue is full") { super(message); this.name = "WorkerBackpressureError"; } }
+export class WorkerCallError extends Error { constructor(message = "Worker call failed") { super(message); this.name = "WorkerCallError"; } }
+export class WorkerCrashedError extends Error { constructor(message = "Worker crashed") { super(message); this.name = "WorkerCrashedError"; } }
+export class WorkerClosedError extends Error { constructor(message = "Worker is closed") { super(message); this.name = "WorkerClosedError"; } }
+
+function __velarWorkerRejectAll(state, failure) {
+  if (state.closed) return;
+  state.closed = true;
+  for (const pending of state.pending.values()) { if (pending.timer) clearTimeout(pending.timer); pending.unsubscribe(); pending.reject(failure); }
+  state.pending.clear();
+}
+function __velarWorkerClient(name, RequestType, ResponseType, capacity) {
+  if (!__velarWorkerIsMainThread) throw new Error("worker() can only be called outside a worker entry");
+  if (typeof name !== "string" || !Object.hasOwn(__velarWorkerEntries, name)) throw new RangeError("Unknown worker entry '" + String(name) + "'");
+  RequestType = __velarWorkerRuntimeType(RequestType, "Worker request Type"); ResponseType = __velarWorkerRuntimeType(ResponseType, "Worker response Type");
+  capacity = __velarWorkerInteger(capacity, 1, 10000, "Worker capacity");
+  const entry = __velarWorkerEntries[name];
+  const instance = new __VelarNodeWorker(new URL("../../" + entry, import.meta.url), { type: "module" });
+  const value = Object.create(__velarWorkerPrototype);
+  const state = { instance, RequestType, ResponseType, capacity, nextId: 1, pending: new Map(), closed: false };
+  __velarWorkerStates.set(value, state);
+  instance.on("message", message => {
+    if (!message || !Number.isSafeInteger(message.id)) { __velarWorkerRejectAll(state, new WorkerCrashedError("Worker returned an invalid message")); instance.terminate(); return; }
+    const pending = state.pending.get(message.id); if (!pending) return;
+    state.pending.delete(message.id); if (pending.timer) clearTimeout(pending.timer); pending.unsubscribe();
+    if (pending.cancel === "timeout") { pending.reject(new TaskTimeoutError("Worker call timed out after " + pending.timeout)); return; }
+    if (pending.cancel === "cancel") { pending.reject(new CancellationError(pending.reason)); return; }
+    if (!message.ok) { const remote = message.error ?? {}; const failure = new WorkerCallError((remote.name ? remote.name + ": " : "") + (remote.message ?? "Worker call failed")); if (typeof remote.stack === "string" && remote.stack) failure.stack = failure.stack + "\nRemote worker:\n" + remote.stack; pending.reject(failure); return; }
+    try { pending.resolve(state.ResponseType.parse(message.value)); } catch (error) { pending.reject(error); }
+  });
+  instance.on("error", error => __velarWorkerRejectAll(state, new WorkerCrashedError(error instanceof Error ? error.message : "Worker crashed")));
+  instance.on("exit", code => { if (!state.closed) __velarWorkerRejectAll(state, new WorkerCrashedError("Worker exited unexpectedly with code " + code)); });
+  return Object.freeze(value);
+}
+const __velarWorkerPrototype = Object.freeze({
+  call(request, cancellation = null, timeout = null) {
+    const state = __velarWorkerStates.get(this); if (!state) throw new TypeError("Worker.call requires a Worker receiver");
+    if (state.closed) return Promise.reject(new WorkerClosedError());
+    if (state.pending.size >= state.capacity) return Promise.reject(new WorkerBackpressureError("Worker queue capacity " + state.capacity + " is full"));
+    if (cancellation !== null && !Cancellation.is(cancellation)) return Promise.reject(new TypeError("Worker cancellation must be Cancellation or null"));
+    let validated; try { validated = state.RequestType.parse(request); } catch (error) { return Promise.reject(error); }
+    let outbound; try { outbound = __velarWorkerOutbound(validated); } catch (error) { return Promise.reject(error); }
+    const milliseconds = __velarWorkerDuration(timeout); const id = state.nextId++;
+    return new Promise((resolve, reject) => {
+      const pending = { resolve, reject, cancel: null, reason: "Worker call cancelled", timeout, timer: null, unsubscribe: () => null };
+      state.pending.set(id, pending);
+      state.instance.postMessage({ kind: "call", id, value: outbound.value }, outbound.transfers);
+      if (cancellation !== null) pending.unsubscribe = Cancellation.__velarOn(cancellation, reason => { if (!state.pending.has(id) || pending.cancel) return; pending.cancel = "cancel"; pending.reason = reason ?? pending.reason; state.instance.postMessage({ kind: "cancel", id, reason: pending.reason }); });
+      if (milliseconds > 0) pending.timer = setTimeout(() => { if (!state.pending.has(id) || pending.cancel) return; pending.cancel = "timeout"; state.instance.postMessage({ kind: "cancel", id, reason: "Worker call timed out" }); }, milliseconds);
+    });
+  },
+  async close() {
+    const state = __velarWorkerStates.get(this); if (!state) throw new TypeError("Worker.close requires a Worker receiver");
+    if (state.closed) return null;
+    __velarWorkerRejectAll(state, new WorkerClosedError());
+    await state.instance.terminate(); return null;
+  },
+});
+const __velarWorkerPoolPrototype = Object.freeze({
+  call(request, cancellation = null, timeout = null) {
+    const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError("WorkerPool.call requires a WorkerPool receiver");
+    if (state.closed) return Promise.reject(new WorkerClosedError("Worker pool is closed"));
+    let selected = state.workers[0], pending = __velarWorkerStates.get(selected).pending.size;
+    for (let index = 1; index < state.workers.length; index += 1) { const candidate = __velarWorkerStates.get(state.workers[index]).pending.size; if (candidate < pending) { selected = state.workers[index]; pending = candidate; } }
+    if (state.workers.reduce((total, worker) => total + __velarWorkerStates.get(worker).pending.size, 0) >= state.capacity) return Promise.reject(new WorkerBackpressureError("Worker pool queue capacity " + state.capacity + " is full"));
+    return selected.call(request, cancellation, timeout);
+  },
+  async close() { const state = __velarWorkerPoolStates.get(this); if (!state) throw new TypeError("WorkerPool.close requires a WorkerPool receiver"); if (state.closed) return null; state.closed = true; await Promise.all(state.workers.map(worker => worker.close())); return null; },
+});
+const __velarWorkerType = Object.freeze({ is(value) { return __velarWorkerStates.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match Worker"); return value; } });
+const __velarWorkerPoolType = Object.freeze({ is(value) { return __velarWorkerPoolStates.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match WorkerPool"); return value; } });
+export const Worker = Object.freeze({ ...__velarWorkerType, of() { return __velarWorkerType; } });
+export const WorkerPool = Object.freeze({ ...__velarWorkerPoolType, of() { return __velarWorkerPoolType; } });
+export function worker(name, RequestType, ResponseType, capacity = 64) { return __velarWorkerClient(name, RequestType, ResponseType, capacity); }
+export function workerPool(name, RequestType, ResponseType, size, capacity = 256) {
+  size = __velarWorkerInteger(size, 1, 32, "Worker pool size"); capacity = __velarWorkerInteger(capacity, size, 10000, "Worker pool capacity");
+  const workers = Array.from({ length: size }, () => __velarWorkerClient(name, RequestType, ResponseType, Math.ceil(capacity / size)));
+  const value = Object.create(__velarWorkerPoolPrototype); __velarWorkerPoolStates.set(value, { workers, capacity, closed: false }); return Object.freeze(value);
+}
+export function serveWorker(RequestType, ResponseType, handler, capacity = 64) {
+  if (__velarWorkerIsMainThread || !__velarWorkerParentPort) throw new Error("serveWorker() can only run in a declared worker entry");
+  if (__velarWorkerServerInstalled) throw new Error("A worker entry may call serveWorker() only once");
+  RequestType = __velarWorkerRuntimeType(RequestType, "Worker request Type"); ResponseType = __velarWorkerRuntimeType(ResponseType, "Worker response Type");
+  if (typeof handler !== "function") throw new TypeError("serveWorker handler must be an async function"); capacity = __velarWorkerInteger(capacity, 1, 10000, "Worker capacity");
+  __velarWorkerServerInstalled = true; const queue = []; const active = new Map(); let running = false;
+  const drain = async () => { if (running) return; running = true; while (queue.length) { const message = queue.shift(); const cancellation = Cancellation.__velarCreate(); active.set(message.id, cancellation); try { const request = RequestType.parse(message.value); const result = ResponseType.parse(await handler(request, cancellation)); const outbound = __velarWorkerOutbound(result); __velarWorkerParentPort.postMessage({ id: message.id, ok: true, value: outbound.value }, outbound.transfers); } catch (error) { __velarWorkerParentPort.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(error) }); } finally { active.delete(message.id); } } running = false; };
+  __velarWorkerParentPort.on("message", message => { if (!message || !Number.isSafeInteger(message.id)) return; if (message.kind === "cancel") { const cancellation = active.get(message.id); if (cancellation) Cancellation.__velarCancel(cancellation, typeof message.reason === "string" ? message.reason : "Worker call cancelled"); else { const index = queue.findIndex(item => item.id === message.id); if (index >= 0) { queue.splice(index, 1); __velarWorkerParentPort.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(new CancellationError(typeof message.reason === "string" ? message.reason : "Worker call cancelled")) }); } } return; } if (message.kind !== "call") return; if (queue.length + active.size >= capacity) { __velarWorkerParentPort.postMessage({ id: message.id, ok: false, error: __velarWorkerFailure(new WorkerBackpressureError()) }); return; } queue.push(message); drain(); });
+  return null;
+}
+`.trimStart();
+//# sourceMappingURL=worker-runtime.js.map

package/dist/worker-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime.js","sourceRoot":"","sources":["../src/worker-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8JlD,CAAC,SAAS,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@velarscript/node",
+  "version": "0.10.1",
+  "description": "The official VelarScript Node.js module contract and runtime.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "node ../../scripts/clean-package-dist.mjs",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VelarOS-AI/VelarScript.git",
+    "directory": "packages/node"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@velarscript/compiler": "0.10.1",
+    "ws": "^8.21.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./compiler": {
+      "types": "./dist/compiler.d.ts",
+      "default": "./dist/compiler.js"
+    }
+  }
+}