@velarscript/node 0.11.1 → 0.12.1

package/dist/websocket-runtime.js

@@ -1,46 +1,200 @@
 export const VELAR_NODE_WEBSOCKET_RUNTIME = String.raw `
 import __VelarWebSocket, { WebSocketServer as __VelarWebSocketServer } from "ws";
 import { createServer as __velarCreateHttpServer } from "node:http";
+import { createReadStream as __velarServeCreateReadStream } from "node:fs";
 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";
+import { extname as __velarServeExtname, isAbsolute as __velarServeIsAbsolute, relative as __velarServeRelative, resolve as __velarServeResolve } from "node:path";
+import { brotliCompress as __velarServeBrotliNode, gzip as __velarServeGzipNode } from "node:zlib";
+import { promisify as __velarServePromisify } from "node:util";
+import { ServeRequest as __velarServeRuntime, ServeApp as __velarServeApp } 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});
+const __velarWsPromise = globalThis.Promise;
+const __velarWsPromiseAll = __velarWsPromise.all.bind(__velarWsPromise);
+const __velarWsReflectApply = globalThis.Reflect.apply;
+const __velarWsFinalizationRegistry = globalThis.FinalizationRegistry;
+const __velarWsFinalizerRegister = __velarWsFinalizationRegistry.prototype.register;
+const __velarWsSetTimeout = globalThis.setTimeout;
+const __velarWsClearTimeout = globalThis.clearTimeout;
+const __velarServeGzip = __velarServePromisify(__velarServeGzipNode);
+const __velarServeBrotli = __velarServePromisify(__velarServeBrotliNode);
+const __velarWsAggregateByteLimit = 128 * 1024 * 1024;
+const __velarWsAggregateQueuedMessageLimit = 65536;
+const __velarWsAggregatePendingSendLimit = 8192;
+const __velarWsActiveConnectionLimit = 4096;
+const __velarWsPendingConnectionLimit = 4096;
+let __velarWsAggregateBytes = 0;
+let __velarWsAggregateQueuedMessages = 0;
+let __velarWsAggregatePendingSends = 0;
+let __velarWsActiveConnections = 0;
+let __velarWsPendingConnections = 0;
+let __velarWsActiveHttpSockets = 0;
+const __velarServeNativeOperations = Object.freeze({readFile: __velarServeReadFile, createReadStream: __velarServeCreateReadStream, realpath: __velarServeRealpath, stat: __velarServeStat, extname: __velarServeExtname, isAbsolute: __velarServeIsAbsolute, relative: __velarServeRelative, resolve: __velarServeResolve, compress: (encoding, value) => encoding === "br" ? __velarServeBrotli(value) : __velarServeGzip(value)});
 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"); }
+function __velarWsMessageBytes(value) { if (typeof value === "string") return Buffer.byteLength(value, "utf8"); if (value instanceof Uint8Array) return value.byteLength; throw new TypeError("WebSocket.send requires text or Bytes"); }
+function __velarWsReserve(size) { if (!Number.isSafeInteger(size) || size < 0 || __velarWsAggregateBytes + size > __velarWsAggregateByteLimit) return false; __velarWsAggregateBytes += size; return true; }
+function __velarWsRelease(size) { __velarWsAggregateBytes -= size; if (__velarWsAggregateBytes < 0) __velarWsAggregateBytes = 0; }
+function __velarWsReserveQueue(size) { if (__velarWsAggregateQueuedMessages >= __velarWsAggregateQueuedMessageLimit || !__velarWsReserve(size)) return false; __velarWsAggregateQueuedMessages += 1; return true; }
+function __velarWsReleaseQueue(size, count = 1) { __velarWsRelease(size); __velarWsAggregateQueuedMessages -= count; if (__velarWsAggregateQueuedMessages < 0) __velarWsAggregateQueuedMessages = 0; }
+function __velarWsReserveSend(size) { if (__velarWsAggregatePendingSends >= __velarWsAggregatePendingSendLimit || !__velarWsReserve(size)) return false; __velarWsAggregatePendingSends += 1; return true; }
+function __velarWsReleaseSend(size) { __velarWsRelease(size); __velarWsAggregatePendingSends -= 1; if (__velarWsAggregatePendingSends < 0) __velarWsAggregatePendingSends = 0; }
+function __velarWsReleaseActive(state) { if (!state.active) return; state.active = false; __velarWsActiveConnections -= 1; if (__velarWsActiveConnections < 0) __velarWsActiveConnections = 0; }
+function __velarWsDiscardQueue(state) { if (state.queueReleased) return; state.queueReleased = true; __velarWsReleaseQueue(state.queuedBytes, state.queue.length); state.queue.length = 0; state.queuedBytes = 0; }
 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 __velarWsReleasePendingSends(state) { for (const complete of state.pendingSends) complete(new Error("WebSocket is closed")); state.pendingSends.clear(); }
+const __velarWsFinalizer = new __velarWsFinalizationRegistry(state => { __velarWsAbort(state); try { state.socket.terminate(); } catch {} });
+function __velarWsFinish(state) { if (state.finished) return; state.finished = true; __velarWsReleaseActive(state); if (state.queue.length === 0) __velarWsDiscardQueue(state); __velarWsReleasePendingSends(state); if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(null); } }
+function __velarWsAbort(state) { state.finished = true; __velarWsReleaseActive(state); __velarWsDiscardQueue(state); __velarWsReleasePendingSends(state); 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 __velarWsReceive(state, socket, data, binary) {
+  if (state.finished) return;
+  let source = null; let message = null; let size;
+  if (binary) { source = data instanceof Uint8Array ? data : new Uint8Array(data); size = source.byteLength; }
+  else { message = typeof data === "string" ? data : data.toString("utf8"); size = Buffer.byteLength(message, "utf8"); }
+  if (size > state.options.maxMessageBytes) { __velarWsRejectReceive(state, socket, 1009, "Message too large"); return; }
+  if (state.waiter) { if (source) { message = new Uint8Array(size); message.set(source); } const waiter = state.waiter; state.waiter = null; waiter.resolve(message); return; }
+  if (state.queue.length >= state.options.maxQueuedMessages || state.queuedBytes + size > state.options.maxQueuedBytes || !__velarWsReserveQueue(size)) { __velarWsRejectReceive(state, socket, 1009, "Unread message queue full"); return; }
+  try { if (source) { message = new Uint8Array(size); message.set(source); } state.queue.push(message); state.queuedBytes += size; }
+  catch (error) { __velarWsReleaseQueue(size); throw error; }
+}
 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);
+  __velarWsActiveConnections += 1;
+  const value = Object.create(__velarWsConnectionPrototype); const state = { socket, options, queue: [], queuedBytes: 0, queueReleased: false, waiter: null, pendingSendBytes: 0, pendingSends: new Set(), finished: false, active: true, closePromise: null }; __velarWebSocketConnections.set(value, state);
+  __velarWsReflectApply(__velarWsFinalizerRegister, __velarWsFinalizer, [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("message", (data, binary) => { try { __velarWsReceive(state, socket, data, binary); } catch { __velarWsRejectReceive(state, socket, 1011, "Message handling failed"); } });
   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);
 }
+function __velarWsCloseForStop(connection) {
+  const state = __velarWebSocketConnections.get(connection);
+  if (!state || state.finished) return new __velarWsPromise(resolve => resolve(null));
+  __velarWsAbort(state);
+  return new __velarWsPromise(resolve => {
+    let settled = false; let timer = null;
+    const finish = () => { if (settled) return; settled = true; if (timer !== null) __velarWsClearTimeout(timer); state.socket.off("close", finish); resolve(null); };
+    state.socket.once("close", finish);
+    try { state.socket.close(1001, "Server stopping"); }
+    catch { try { state.socket.terminate(); } catch {} finish(); return; }
+    if (!settled) timer = __velarWsSetTimeout(() => { try { state.socket.terminate(); } catch {} finish(); }, 5000);
+  });
+}
+function __velarWsCompactPendingConnections(state) { if (state.queue.length <= state.pendingConnections.size * 2 + 64) return; const compact = []; for (const connection of state.queue) if (state.pendingConnections.has(connection)) compact.push(connection); state.queue = compact; }
+function __velarWsCloseHttpServer(state, grace = 30000) {
+  return new __velarWsPromise((resolve, reject) => {
+    let settled = false; let forceTimer = null; let finalTimer = null;
+    const finish = action => { if (settled) return; settled = true; if (forceTimer !== null) __velarWsClearTimeout(forceTimer); if (finalTimer !== null) __velarWsClearTimeout(finalTimer); action(); };
+    try { state.httpServer.close(error => error ? finish(() => reject(error)) : finish(() => resolve(null))); }
+    catch (error) { finish(() => reject(error)); return; }
+    try { state.httpServer.closeIdleConnections?.(); } catch {}
+    forceTimer = __velarWsSetTimeout(() => {
+      try { state.httpServer.closeAllConnections?.(); } catch {}
+      for (const socket of state.sockets) try { socket.destroy(); } catch {}
+      finalTimer = __velarWsSetTimeout(() => finish(() => reject(new Error("WebSocket HTTP transport did not stop within its graceful shutdown deadline"))), 1000);
+      finalTimer.unref?.();
+    }, grace);
+    forceTimer.unref?.();
+  });
+}
+function __velarWsStopState(state) {
+  if (state.stopPromise !== null) return state.stopPromise;
+  state.stopped = true;
+  if (state.waiter) { state.waiter.resolve(null); state.waiter = null; }
+  __velarWsPendingConnections -= state.pendingConnections.size;
+  if (__velarWsPendingConnections < 0) __velarWsPendingConnections = 0;
+  state.pendingConnections.clear(); state.queue.length = 0;
+  const applicationClose = state.application ? state.application.close(30000) : new __velarWsPromise(resolve => resolve(null));
+  const httpClose = __velarWsCloseHttpServer(state);
+  const pending = (async () => {
+    try {
+      const closing = [];
+      for (const connection of state.connections) closing.push(__velarWsCloseForStop(connection));
+      await __velarWsPromiseAll(closing);
+      await new __velarWsPromise((resolve, reject) => state.server.close(error => error ? reject(error) : resolve(null)));
+      await __velarWsPromiseAll([httpClose, applicationClose]);
+    } finally { state.connections.clear(); }
+    return null;
+  })();
+  state.stopPromise = pending;
+  return pending;
+}
 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; },
+  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 || !__velarWsReserveSend(size)) return Promise.reject(new WebSocketBackpressureError()); let bytes; try { bytes = typeof message === "string" ? null : __velarWsBytes(message); } catch (error) { __velarWsReleaseSend(size); throw error; } state.pendingSendBytes += size; return new Promise((resolve, reject) => { let completed = false; const complete = error => { if (completed) return; completed = true; state.pendingSends.delete(complete); state.pendingSendBytes -= size; __velarWsReleaseSend(size); if (error) reject(new WebSocketClosedError(error.message)); else resolve(null); }; state.pendingSends.add(complete); try { state.socket.send(bytes ?? message, { binary: bytes !== null }, complete); } catch (error) { complete(error instanceof Error ? error : new Error("WebSocket send failed")); } }); },
+  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(); const size = __velarWsMessageBytes(message); state.queuedBytes -= size; __velarWsReleaseQueue(size); if (state.finished && state.queue.length === 0) __velarWsDiscardQueue(state); 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 => { let settled = false; let timer = null; const finish = () => { if (settled) return; settled = true; if (timer !== null) __velarWsClearTimeout(timer); state.socket.off("close", finish); resolve(null); }; state.socket.once("close", finish); try { state.socket.close(code, reason); } catch { try { state.socket.terminate(); } catch {} finish(); return; } timer = __velarWsSetTimeout(() => { try { state.socket.terminate(); } catch {} finish(); }, 5000); }); } 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; },
+  next() { const state = __velarWebSocketServers.get(this); if (!state) throw new TypeError("WebSocketServer.next requires a server"); while (state.queue.length) { const connection = state.queue.shift(); if (!state.pendingConnections.delete(connection)) continue; __velarWsPendingConnections -= 1; if (__velarWsPendingConnections < 0) __velarWsPendingConnections = 0; return Promise.resolve(connection); } 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 }; }); },
+  stop() { const state = __velarWebSocketServers.get(this); if (!state) throw new TypeError("WebSocketServer.stop requires a server"); return __velarWsStopState(state); },
 });
 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); }); }
+export function connect(url, options = {}) { if (typeof url !== "string" || !/^wss?:\/\//u.test(url)) return __velarWsPromise.reject(new TypeError("WebSocket URL must start with ws:// or wss://")); const limits = __velarWsOptions(options); const timeout = __velarWsDuration(options.timeout, 10000); return new __velarWsPromise((resolve, reject) => { const socket = new __VelarWebSocket(url, { maxPayload: limits.maxMessageBytes }); let settled = false; const finish = (action) => { if (settled) return false; settled = true; __velarWsClearTimeout(timer); socket.off("open", opened); socket.off("error", failed); action(); return true; }; const absorbTerminalError = () => socket.once("error", () => {}); const opened = () => { if (__velarWsActiveConnections >= __velarWsActiveConnectionLimit) { if (finish(() => reject(new WebSocketBackpressureError("WebSocket connection limit exceeded")))) { absorbTerminalError(); socket.close(1013, "Client connection limit reached"); } return; } finish(() => resolve(__velarWsWrap(socket, limits))); }; const failed = error => finish(() => reject(new WebSocketProtocolError(error instanceof Error ? error.message : "WebSocket connection failed"))); const timer = __velarWsSetTimeout(() => { if (finish(() => reject(new WebSocketTimeoutError("WebSocket connection timed out")))) { absorbTerminalError(); socket.terminate(); } }, timeout); socket.once("open", opened); socket.once("error", failed); }); }
+export async function listen(options) {
+  if (options === null || typeof options !== "object" || Array.isArray(options)) throw 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, 4096, "maxConnections");
+  const maxPendingConnections = __velarWsInteger(options.maxPendingConnections, 128, 1, 4096, "maxPendingConnections");
+  if (options.host !== undefined && typeof options.host !== "string") throw new TypeError("WebSocket host must be text");
+  if (options.path !== undefined && (typeof options.path !== "string" || !options.path.startsWith("/"))) throw new TypeError("WebSocket path must start with '/'");
+  const application = __velarServeApp.is(options.http) ? await __velarServeApp.__velarCompilerBridge.nativeApp(options.http) : null;
+  const handler = application ? application.handle : options.http;
+  if (handler !== undefined && typeof handler !== "function") { if (application) await application.close(); throw new TypeError("WebSocket http must be a ServeApp or velar/serve handler"); }
+  try {
+    return await new __velarWsPromise((resolve, reject) => {
+      const httpServer = __velarCreateHttpServer({maxHeaderSize: 64 * 1024, headersTimeout: 10000, requestTimeout: 60000, keepAliveTimeout: 5000, connectionsCheckingInterval: 1000}, (request, response) => {
+        if (handler) void __velarServeRuntime.__velarHandleNative(handler, request, response, __velarServeNativeOperations);
+        else { response.statusCode = 404; response.setHeader("content-type", "text/plain; charset=utf-8"); response.end(request.method === "HEAD" ? undefined : "Not found"); }
+      });
+      httpServer.maxConnections = 2048;
+      httpServer.maxRequestsPerSocket = 1000;
+      const server = new __VelarWebSocketServer({server: httpServer, path: options.path, maxPayload: limits.maxMessageBytes, perMessageDeflate: false, clientTracking: true});
+      const value = Object.create(__velarWsServerPrototype);
+      const state = {server, httpServer, application, queue: [], pendingConnections: new Set(), waiter: null, stopped: false, stopPromise: null, connections: new Set(), sockets: new Set()};
+      __velarWebSocketServers.set(value, state);
+      httpServer.on("connection", socket => {
+        if (state.stopped || state.sockets.size >= 2048 || __velarWsActiveHttpSockets >= 4096) { socket.destroy(); return; }
+        state.sockets.add(socket); __velarWsActiveHttpSockets += 1; socket.setNoDelay(true); socket.setKeepAlive(true, 5000);
+        socket.once("close", () => { if (!state.sockets.delete(socket)) return; __velarWsActiveHttpSockets -= 1; if (__velarWsActiveHttpSockets < 0) __velarWsActiveHttpSockets = 0; });
+      });
+      server.on("connection", socket => {
+        const willQueue = !state.waiter;
+        if (state.stopped || state.connections.size >= maxConnections || __velarWsActiveConnections >= __velarWsActiveConnectionLimit || (willQueue && (state.pendingConnections.size >= maxPendingConnections || __velarWsPendingConnections >= __velarWsPendingConnectionLimit))) { socket.close(1013, "Server busy"); return; }
+        const connection = __velarWsWrap(socket, limits); state.connections.add(connection);
+        socket.once("close", () => { state.connections.delete(connection); if (state.pendingConnections.delete(connection)) { __velarWsPendingConnections -= 1; if (__velarWsPendingConnections < 0) __velarWsPendingConnections = 0; __velarWsCompactPendingConnections(state); } });
+        if (state.waiter) { const waiter = state.waiter; state.waiter = null; waiter.resolve(connection); }
+        else { state.queue.push(connection); state.pendingConnections.add(connection); __velarWsPendingConnections += 1; }
+      });
+      let settled = false;
+      const fail = error => {
+        if (settled) { void __velarWsStopState(state).catch(() => {}); return; }
+        settled = true;
+        try { server.close(); } catch {}
+        try { httpServer.close(); } catch {}
+        reject(error);
+      };
+      server.on("error", fail);
+      httpServer.on("error", fail);
+      httpServer.listen({port, host: options.host ?? "127.0.0.1"}, () => {
+        if (settled) return;
+        const address = httpServer.address();
+        if (!address || typeof address === "string") { fail(new Error("WebSocket server could not determine its bound port")); return; }
+        settled = true;
+        Object.defineProperty(value, "port", {value: address.port, enumerable: true});
+        resolve(Object.freeze(value));
+      });
+    });
+  } catch (error) { if (application) await application.close(); throw error; }
+}
 `.trimStart();
 //# sourceMappingURL=websocket-runtime.js.map

package/dist/websocket-runtime.js.map

@@ -1 +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"}
+{"version":3,"file":"websocket-runtime.js","sourceRoot":"","sources":["../src/websocket-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,4BAA4B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsMrD,CAAC,SAAS,EAAE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velarscript/node",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "description": "The official VelarScript Node.js module contract and runtime.",
   "license": "Apache-2.0",
   "type": "module",
@@ -24,8 +24,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "velar": {
+    "extension": {
+      "kind": "capability",
+      "apiVersion": "0.10",
+      "manifestKey": "node",
+      "extends": {}
+    }
+  },
   "dependencies": {
-    "@velarscript/compiler": "0.11.1",
+    "@velarscript/compiler": "0.12.1",
     "ws": "^8.21.1"
   },
   "exports": {

package/dist/sqlite-runtime.d.ts

@@ -1,3 +0,0 @@
-export declare const VELAR_NODE_SQLITE_WORKER_SOURCE: string;
-export declare const VELAR_NODE_SQLITE_RUNTIME: string;
-//# sourceMappingURL=sqlite-runtime.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sqlite-runtime.d.ts","sourceRoot":"","sources":["../src/sqlite-runtime.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,+BAA+B,QA8C3C,CAAC;AAEF,eAAO,MAAM,yBAAyB,QA2CzB,CAAC"}

package/dist/sqlite-runtime.js

@@ -1,92 +0,0 @@
-export const VELAR_NODE_SQLITE_WORKER_SOURCE = String.raw `
-const { parentPort, workerData } = require("node:worker_threads");
-const { DatabaseSync } = require("node:sqlite");
-const database = new DatabaseSync(workerData.path, { timeout: workerData.busyTimeout });
-const statements = new Map();
-let nextStatement = 1;
-let transaction = 0;
-function params(value) { if (!Array.isArray(value) || value.length > 10000) throw new TypeError("SQLite parameters must be a bounded List"); return value; }
-function sql(value) { if (typeof value !== "string" || value.length === 0 || value.length > 1024 * 1024) throw new TypeError("SQLite SQL must be non-empty text no longer than 1 MiB"); return value; }
-function statement(id) { const value = statements.get(id); if (!value) throw new Error("SQLite statement is closed"); return value; }
-function normalize(value, transfers, seen = new WeakSet()) {
-  if (value === null || typeof value !== "object") return value;
-  if (value instanceof Uint8Array) { const bytes = new Uint8Array(value.byteLength); bytes.set(value); transfers.push(bytes.buffer); return bytes; }
-  if (seen.has(value)) throw new TypeError("SQLite returned cyclic data"); seen.add(value);
-  if (Array.isArray(value)) return value.map(item => normalize(item, transfers, seen));
-  const output = Object.create(null); for (const key of Object.keys(value)) output[key] = normalize(value[key], transfers, seen); return output;
-}
-function resultSize(value, seen = new WeakSet()) { if (value === null) return 4; if (typeof value === "string") return Buffer.byteLength(value, "utf8"); if (typeof value === "number") return 8; if (value instanceof Uint8Array) return value.byteLength; if (typeof value !== "object" || seen.has(value)) return 0; seen.add(value); if (Array.isArray(value)) return value.reduce((sum, item) => sum + resultSize(item, seen), 0); return Object.entries(value).reduce((sum, [key, item]) => sum + Buffer.byteLength(key, "utf8") + resultSize(item, seen), 0); }
-function bounded(value) { if (Array.isArray(value) && value.length > workerData.maxRows) throw new RangeError("SQLite result exceeds maxRows"); if (resultSize(value) > workerData.maxResultBytes) throw new RangeError("SQLite result exceeds maxResultBytes"); return value; }
-function execute(target, values) { const result = target.run(...params(values)); return Number(result.changes); }
-function one(target, values) { return target.get(...params(values)) ?? null; }
-function all(target, values) { return target.all(...params(values)); }
-function transactionId(value) { if (value === 0) { if (transaction !== 0) throw new Error("Use the active Transaction handle while a transaction is open"); return; } if (value !== transaction) throw new Error("SQLite transaction is no longer active"); }
-parentPort.on("message", message => {
-  const transfers = [];
-  try {
-    const tx = Number.isSafeInteger(message.transaction) ? message.transaction : 0;
-    if (message.operation !== "close") transactionId(tx);
-    let value = null;
-    if (message.operation === "execute") value = execute(database.prepare(sql(message.sql)), message.params ?? []);
-    else if (message.operation === "one") value = bounded(one(database.prepare(sql(message.sql)), message.params ?? []));
-    else if (message.operation === "all") value = bounded(all(database.prepare(sql(message.sql)), message.params ?? []));
-    else if (message.operation === "prepare") { const id = nextStatement++; statements.set(id, database.prepare(sql(message.sql))); value = id; }
-    else if (message.operation === "statement.execute") value = execute(statement(message.statement), message.params ?? []);
-    else if (message.operation === "statement.one") value = bounded(one(statement(message.statement), message.params ?? []));
-    else if (message.operation === "statement.all") value = bounded(all(statement(message.statement), message.params ?? []));
-    else if (message.operation === "statement.close") { statements.delete(message.statement); value = null; }
-    else if (message.operation === "transaction") { if (transaction !== 0) throw new Error("SQLite transaction is already active"); database.exec("BEGIN IMMEDIATE"); transaction = message.transactionId; value = transaction; }
-    else if (message.operation === "commit") { database.exec("COMMIT"); transaction = 0; value = null; }
-    else if (message.operation === "rollback") { database.exec("ROLLBACK"); transaction = 0; value = null; }
-    else if (message.operation === "close") { if (transaction !== 0) { database.exec("ROLLBACK"); transaction = 0; } statements.clear(); database.close(); value = null; }
-    else throw new Error("Unknown SQLite operation");
-    const normalized = normalize(value, transfers); parentPort.postMessage({ id: message.id, ok: true, value: normalized }, transfers);
-  } catch (error) { parentPort.postMessage({ id: message.id, ok: false, error: { name: error?.name ?? "Error", message: error?.message ?? String(error), code: error?.code ?? null } }); }
-});
-parentPort.postMessage({ ready: true });
-`;
-export const VELAR_NODE_SQLITE_RUNTIME = String.raw `
-import { Worker as __VelarSqliteWorker } from "node:worker_threads";
-const __velarSqliteDatabases = new WeakMap();
-const __velarSqliteStatements = new WeakMap();
-const __velarSqliteTransactions = new WeakMap();
-export class SqliteError extends Error { constructor(message = "SQLite operation failed", code = null) { super(message); this.name = "SqliteError"; this.code = code; } }
-export class SqliteBackpressureError extends Error { constructor(message = "SQLite queue is full") { super(message); this.name = "SqliteBackpressureError"; } }
-function __velarSqliteInteger(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 __velarSqliteOptions(options = {}) { if (options === null || typeof options !== "object" || Array.isArray(options)) throw new TypeError("SQLite options must be a record"); return { busyTimeout: __velarSqliteInteger(options.busyTimeout, 5000, 0, 2147483647, "busyTimeout"), queueCapacity: __velarSqliteInteger(options.queueCapacity, 256, 1, 10000, "queueCapacity"), maxRows: __velarSqliteInteger(options.maxRows, 10000, 1, 1000000, "maxRows"), maxResultBytes: __velarSqliteInteger(options.maxResultBytes, 16 * 1024 * 1024, 1, 64 * 1024 * 1024, "maxResultBytes") }; }
-function __velarSqliteDatabase(value) { const state = __velarSqliteDatabases.get(value); if (!state) throw new TypeError("SQLite method requires a Database receiver"); return state; }
-function __velarSqliteStatement(value) { const state = __velarSqliteStatements.get(value); if (!state) throw new TypeError("SQLite method requires a Statement receiver"); return state; }
-function __velarSqliteTransaction(value) { const state = __velarSqliteTransactions.get(value); if (!state) throw new TypeError("SQLite method requires a Transaction receiver"); return state; }
-function __velarSqliteParams(value = []) { if (!Array.isArray(value) || value.length > 10000) throw new TypeError("SQLite parameters must be a bounded List"); return value; }
-function __velarSqliteRequest(state, message) { if (state.closed) return Promise.reject(new SqliteError("SQLite database is closed")); if (state.pending.size >= state.options.queueCapacity) return Promise.reject(new SqliteBackpressureError("SQLite queue capacity " + state.options.queueCapacity + " is full")); const id = state.nextId++; return new Promise((resolve, reject) => { state.pending.set(id, { resolve, reject }); state.worker.postMessage({ ...message, id }); }); }
-function __velarSqliteRead(state, operation, sql, params, Type, transaction = 0, statement = 0) { if ((typeof Type !== "object" && typeof Type !== "function") || Type === null || typeof Type.parse !== "function") return Promise.reject(new TypeError("SQLite row validation requires a runtime Type")); return __velarSqliteRequest(state, { operation, sql, params: __velarSqliteParams(params), transaction, statement }).then(value => operation.endsWith("one") ? value === null ? null : Type.parse(value) : value.map(row => Type.parse(row))); }
-const __velarSqliteDatabasePrototype = Object.freeze({
-  execute(sql, params = []) { return __velarSqliteRequest(__velarSqliteDatabase(this), { operation: "execute", sql, params: __velarSqliteParams(params), transaction: 0 }); },
-  one(sql, params, Type) { const state = __velarSqliteDatabase(this); return __velarSqliteRead(state, "one", sql, params, Type); }, all(sql, params, Type) { const state = __velarSqliteDatabase(this); return __velarSqliteRead(state, "all", sql, params, Type); },
-  async prepare(sql) { const state = __velarSqliteDatabase(this); const id = await __velarSqliteRequest(state, { operation: "prepare", sql, transaction: 0 }); return __velarSqliteMakeStatement(state, id, 0); },
-  async transaction() { const state = __velarSqliteDatabase(this); const transaction = state.nextTransaction++; await __velarSqliteRequest(state, { operation: "transaction", transaction: 0, transactionId: transaction }); return __velarSqliteMakeTransaction(state, transaction); },
-  async close() { const state = __velarSqliteDatabase(this); if (state.closed) return null; await __velarSqliteRequest(state, { operation: "close", transaction: 0 }); state.closed = true; await state.worker.terminate(); return null; },
-});
-const __velarSqliteStatementPrototype = Object.freeze({
-  execute(params = []) { const item = __velarSqliteStatement(this); return __velarSqliteRequest(item.database, { operation: "statement.execute", statement: item.id, params: __velarSqliteParams(params), transaction: item.transaction }); },
-  one(params, Type) { const item = __velarSqliteStatement(this); return __velarSqliteRead(item.database, "statement.one", null, params, Type, item.transaction, item.id); }, all(params, Type) { const item = __velarSqliteStatement(this); return __velarSqliteRead(item.database, "statement.all", null, params, Type, item.transaction, item.id); },
-  async close() { const item = __velarSqliteStatement(this); if (item.closed) return null; await __velarSqliteRequest(item.database, { operation: "statement.close", statement: item.id, transaction: item.transaction }); item.closed = true; if (item.owner) item.owner.statements.delete(item); return null; },
-});
-async function __velarSqliteCloseTransactionStatements(item) { for (const statement of [...item.statements]) { if (statement.closed) continue; await __velarSqliteRequest(item.database, { operation: "statement.close", statement: statement.id, transaction: item.id }); statement.closed = true; } item.statements.clear(); }
-const __velarSqliteTransactionPrototype = Object.freeze({
-  execute(sql, params = []) { const item = __velarSqliteTransaction(this); return __velarSqliteRequest(item.database, { operation: "execute", sql, params: __velarSqliteParams(params), transaction: item.id }); },
-  one(sql, params, Type) { const item = __velarSqliteTransaction(this); return __velarSqliteRead(item.database, "one", sql, params, Type, item.id); }, all(sql, params, Type) { const item = __velarSqliteTransaction(this); return __velarSqliteRead(item.database, "all", sql, params, Type, item.id); },
-  async prepare(sql) { const item = __velarSqliteTransaction(this); if (!item.active) throw new SqliteError("SQLite transaction is no longer active"); const id = await __velarSqliteRequest(item.database, { operation: "prepare", sql, transaction: item.id }); return __velarSqliteMakeStatement(item.database, id, item.id, item); },
-  async commit() { const item = __velarSqliteTransaction(this); if (!item.active) throw new SqliteError("SQLite transaction is no longer active"); await __velarSqliteCloseTransactionStatements(item); await __velarSqliteRequest(item.database, { operation: "commit", transaction: item.id }); item.active = false; return null; },
-  async rollback() { const item = __velarSqliteTransaction(this); if (!item.active) return null; await __velarSqliteCloseTransactionStatements(item); await __velarSqliteRequest(item.database, { operation: "rollback", transaction: item.id }); item.active = false; return null; },
-  async close() { return this.rollback(); },
-});
-function __velarSqliteMakeStatement(database, id, transaction, owner = null) { const value = Object.create(__velarSqliteStatementPrototype); const state = { database, id, transaction, owner, closed: false }; __velarSqliteStatements.set(value, state); if (owner) owner.statements.add(state); return Object.freeze(value); }
-function __velarSqliteMakeTransaction(database, id) { const value = Object.create(__velarSqliteTransactionPrototype); __velarSqliteTransactions.set(value, { database, id, active: true, statements: new Set() }); return Object.freeze(value); }
-const __velarSqliteDatabaseType = Object.freeze({ is(value) { return __velarSqliteDatabases.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match Database"); return value; } });
-const __velarSqliteStatementType = Object.freeze({ is(value) { return __velarSqliteStatements.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match Statement"); return value; } });
-const __velarSqliteTransactionType = Object.freeze({ is(value) { return __velarSqliteTransactions.has(value); }, parse(value) { if (!this.is(value)) throw new TypeError("Value does not match Transaction"); return value; } });
-export const Database = __velarSqliteDatabaseType; export const Statement = __velarSqliteStatementType; export const Transaction = __velarSqliteTransactionType;
-export function open(path, options = {}) { if (typeof path !== "string" || path.length === 0 || path.includes("\0")) return Promise.reject(new TypeError("SQLite path must be non-empty text without NUL")); const checked = __velarSqliteOptions(options); return new Promise((resolve, reject) => { const worker = new __VelarSqliteWorker(WORKER_SOURCE, { eval: true, workerData: { path, ...checked } }); const value = Object.create(__velarSqliteDatabasePrototype); const state = { worker, options: checked, pending: new Map(), nextId: 1, nextTransaction: 1, closed: false }; __velarSqliteDatabases.set(value, state); worker.on("message", message => { if (message?.ready) { resolve(Object.freeze(value)); return; } const pending = state.pending.get(message?.id); if (!pending) return; state.pending.delete(message.id); if (message.ok) pending.resolve(message.value); else pending.reject(new SqliteError(message.error?.message ?? "SQLite operation failed", message.error?.code ?? null)); }); worker.on("error", error => { state.closed = true; for (const pending of state.pending.values()) pending.reject(new SqliteError(error.message)); state.pending.clear(); reject(error); }); worker.on("exit", code => { if (!state.closed && code !== 0) { state.closed = true; for (const pending of state.pending.values()) pending.reject(new SqliteError("SQLite worker exited with code " + code)); state.pending.clear(); } }); }); }
-`.trimStart();
-//# sourceMappingURL=sqlite-runtime.js.map

package/dist/sqlite-runtime.js.map

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