@velarscript/node 0.10.1

package/dist/terminal-runtime.js

@@ -0,0 +1,290 @@
+// Application-facing proxy for the isolated terminal host. It captures all
+// validation, MessagePort and Worker operations before application code runs;
+// stdin ownership, decoding, and fd writes live in terminal-worker-runtime.ts.
+export const VELAR_NODE_TERMINAL_RUNTIME = String.raw `
+import { EventEmitter as __VelarTerminalEventEmitter } from "node:events";
+import { MessageChannel as __VelarTerminalMessageChannel, MessagePort as __VelarTerminalMessagePort, Worker as __VelarTerminalWorker } from "node:worker_threads";
+
+const __velarTerminalNativeArray = globalThis.Array;
+const __velarTerminalNativeError = globalThis.Error;
+const __velarTerminalNativeNumber = globalThis.Number;
+const __velarTerminalNativeObject = globalThis.Object;
+const __velarTerminalNativePromise = globalThis.Promise;
+const __velarTerminalNativeRangeError = globalThis.RangeError;
+const __velarTerminalNativeReflect = globalThis.Reflect;
+const __velarTerminalNativeString = globalThis.String;
+const __velarTerminalNativeTypeError = globalThis.TypeError;
+const __velarTerminalOwnDescriptor = __velarTerminalNativeObject.getOwnPropertyDescriptor;
+const __velarTerminalApply = __velarTerminalNativeReflect.apply;
+function __velarTerminalDataOperation(target, name) {
+  const descriptor = __velarTerminalOwnDescriptor(target, name);
+  if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "function") {
+    throw new __velarTerminalNativeError("VelarScript terminal host operation '" + name + "' is unavailable");
+  }
+  return descriptor.value;
+}
+const __velarTerminalArrayPush = __velarTerminalDataOperation(__velarTerminalNativeArray.prototype, "push");
+const __velarTerminalArraySlice = __velarTerminalDataOperation(__velarTerminalNativeArray.prototype, "slice");
+const __velarTerminalArrayIsArray = __velarTerminalDataOperation(__velarTerminalNativeArray, "isArray");
+const __velarTerminalNumberIsSafeInteger = __velarTerminalDataOperation(__velarTerminalNativeNumber, "isSafeInteger");
+const __velarTerminalObjectCreate = __velarTerminalDataOperation(__velarTerminalNativeObject, "create");
+const __velarTerminalObjectFreeze = __velarTerminalDataOperation(__velarTerminalNativeObject, "freeze");
+const __velarTerminalOwnKeys = __velarTerminalDataOperation(__velarTerminalNativeReflect, "ownKeys");
+const __velarTerminalPromiseThen = __velarTerminalDataOperation(__velarTerminalNativePromise.prototype, "then");
+const __velarTerminalStringIncludes = __velarTerminalDataOperation(__velarTerminalNativeString.prototype, "includes");
+const __velarTerminalMessagePortPost = __velarTerminalDataOperation(__VelarTerminalMessagePort.prototype, "postMessage");
+const __velarTerminalMessagePortStart = __velarTerminalDataOperation(__VelarTerminalMessagePort.prototype, "start");
+const __velarTerminalMessagePortRef = __velarTerminalDataOperation(__VelarTerminalMessagePort.prototype, "ref");
+const __velarTerminalMessagePortUnref = __velarTerminalDataOperation(__VelarTerminalMessagePort.prototype, "unref");
+const __velarTerminalMessagePortClose = __velarTerminalDataOperation(__VelarTerminalMessagePort.prototype, "close");
+const __velarTerminalWorkerUnref = __velarTerminalDataOperation(__VelarTerminalWorker.prototype, "unref");
+const __velarTerminalWorkerTerminate = __velarTerminalDataOperation(__VelarTerminalWorker.prototype, "terminate");
+const __velarTerminalEventOn = __velarTerminalDataOperation(__VelarTerminalEventEmitter.prototype, "on");
+const __velarTerminalMessageData = __velarTerminalOwnDescriptor(globalThis.MessageEvent.prototype, "data")?.get;
+if (typeof __velarTerminalMessageData !== "function") throw new __velarTerminalNativeError("Node terminal MessageEvent data operation is unavailable");
+const __velarTerminalSetTimeout = globalThis.setTimeout;
+const __velarTerminalClearTimeout = globalThis.clearTimeout;
+const __velarTerminalProcess = globalThis.process;
+const __velarTerminalMaxArgumentCount = 256;
+const __velarTerminalMaxTextBytes = 1024 * 1024;
+const __velarTerminalMaxPending = 256;
+const __velarTerminalPending = __velarTerminalCall(__velarTerminalObjectCreate, __velarTerminalNativeObject, [null]);
+let __velarTerminalPendingCount = 0;
+let __velarTerminalNextRequest = 1;
+let __velarTerminalClosed = false;
+let __velarTerminalClosing = false;
+let __velarTerminalInteractive = false;
+let __velarTerminalReady = false;
+let __velarTerminalFailure = null;
+let __velarTerminalExpectedWorkerExit = false;
+let __velarTerminalReadyResolve;
+let __velarTerminalReadyReject;
+
+function __velarTerminalCall(operation, receiver, arguments_) {
+  return __velarTerminalApply(operation, receiver, arguments_);
+}
+
+function __velarTerminalPush(values, value) {
+  __velarTerminalCall(__velarTerminalArrayPush, values, [value]);
+}
+
+function __velarTerminalIsSafeInteger(value) {
+  return __velarTerminalCall(__velarTerminalNumberIsSafeInteger, __velarTerminalNativeNumber, [value]);
+}
+
+function __velarTerminalBoundedText(value, operation) {
+  if (typeof value !== "string") throw new __velarTerminalNativeTypeError(operation + " requires text");
+  if (__velarUtf8ByteLength(value) > __velarTerminalMaxTextBytes) {
+    throw new __velarTerminalNativeRangeError(operation + " text exceeds its 1 MiB boundary");
+  }
+  return value;
+}
+
+function __velarTerminalProgramArguments() {
+  const source = __velarTerminalProcess.argv;
+  const values = [];
+  if (source.length - 2 > __velarTerminalMaxArgumentCount) {
+    throw new __velarTerminalNativeRangeError("Terminal args cannot exceed 256 items");
+  }
+  let bytes = 0;
+  for (let index = 2; index < source.length; index += 1) {
+    const value = source[index];
+    if (typeof value !== "string") throw new __velarTerminalNativeTypeError("Terminal args must be text");
+    bytes += __velarUtf8ByteLength(value);
+    if (__velarTerminalCall(__velarTerminalStringIncludes, value, ["\0"]) || bytes > __velarTerminalMaxTextBytes) {
+      throw new __velarTerminalNativeRangeError("Terminal args are outside the supported boundary");
+    }
+    __velarTerminalPush(values, value);
+  }
+  return __velarTerminalCall(__velarTerminalObjectFreeze, __velarTerminalNativeObject, [values]);
+}
+
+function __velarTerminalRecord(value, name) {
+  if (!value || typeof value !== "object" || __velarTerminalCall(__velarTerminalArrayIsArray, __velarTerminalNativeArray, [value])) {
+    throw new __velarTerminalNativeTypeError(name + " must be a record");
+  }
+  const output = __velarTerminalCall(__velarTerminalObjectCreate, __velarTerminalNativeObject, [null]);
+  const keys = __velarTerminalCall(__velarTerminalOwnKeys, __velarTerminalNativeReflect, [value]);
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (typeof key !== "string") throw new __velarTerminalNativeTypeError(name + " fields must use string names");
+    const descriptor = __velarTerminalOwnDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) throw new __velarTerminalNativeTypeError(name + " fields must be enumerable data values");
+    output[key] = descriptor.value;
+  }
+  return output;
+}
+
+function __velarTerminalError(value) {
+  value = __velarTerminalRecord(value, "Node terminal host error");
+  if (typeof value.message !== "string" || value.message.length === 0 || value.message.length > 65536) {
+    throw new __velarTerminalNativeTypeError("Node terminal host returned an invalid error");
+  }
+  if (value.name === "RangeError") return new __velarTerminalNativeRangeError(value.message);
+  if (value.name === "TypeError") return new __velarTerminalNativeTypeError(value.message);
+  if (value.name === "Error") return new __velarTerminalNativeError(value.message);
+  throw new __velarTerminalNativeTypeError("Node terminal host returned an invalid error");
+}
+
+function __velarTerminalUpdateReference() {
+  const operation = __velarTerminalPendingCount > 0 || __velarTerminalClosing
+    ? __velarTerminalMessagePortRef
+    : __velarTerminalMessagePortUnref;
+  __velarTerminalCall(operation, __velarTerminalPort, []);
+}
+
+function __velarTerminalFail(error) {
+  if (__velarTerminalFailure) return;
+  const failure = error instanceof __velarTerminalNativeError
+    ? error
+    : new __velarTerminalNativeError("Node terminal worker failed");
+  __velarTerminalFailure = failure;
+  if (!__velarTerminalReady) __velarTerminalReadyReject(failure);
+  __velarTerminalClosed = true;
+  __velarTerminalClosing = false;
+  const keys = __velarTerminalCall(__velarTerminalOwnKeys, __velarTerminalNativeReflect, [__velarTerminalPending]);
+  for (let index = 0; index < keys.length; index += 1) {
+    const descriptor = __velarTerminalOwnDescriptor(__velarTerminalPending, keys[index]);
+    if (descriptor && "value" in descriptor) descriptor.value.reject(failure);
+    delete __velarTerminalPending[keys[index]];
+  }
+  __velarTerminalPendingCount = 0;
+  __velarTerminalUpdateReference();
+  __velarTerminalCall(__velarTerminalMessagePortClose, __velarTerminalPort, []);
+  __velarTerminalExpectedWorkerExit = true;
+  const terminated = __velarTerminalCall(__velarTerminalWorkerTerminate, __velarTerminalWorker, []);
+  __velarTerminalCall(__velarTerminalPromiseThen, terminated, [() => null, () => null]);
+}
+
+function __velarTerminalMessage(value) {
+  const message = __velarTerminalRecord(value, "Node terminal host message");
+  if (message.kind === "ready") {
+    if (__velarTerminalReady || typeof message.interactive !== "boolean") {
+      throw new __velarTerminalNativeTypeError("Node terminal worker returned invalid readiness");
+    }
+    __velarTerminalInteractive = message.interactive;
+    __velarTerminalReady = true;
+    __velarTerminalReadyResolve(null);
+    return;
+  }
+  if (message.kind === "closed") {
+    if (!__velarTerminalClosing || message.error !== null) {
+      throw message.error === null
+        ? new __velarTerminalNativeError("Node terminal worker returned unexpected closure")
+        : __velarTerminalError(message.error);
+    }
+    __velarTerminalClosing = false;
+    __velarTerminalUpdateReference();
+    __velarTerminalCall(__velarTerminalMessagePortClose, __velarTerminalPort, []);
+    __velarTerminalExpectedWorkerExit = true;
+    const terminated = __velarTerminalCall(__velarTerminalWorkerTerminate, __velarTerminalWorker, []);
+    __velarTerminalCall(__velarTerminalPromiseThen, terminated, [() => null, () => null]);
+    return;
+  }
+  if (message.kind !== "response" || !__velarTerminalIsSafeInteger(message.id) || message.id < 1 || typeof message.ok !== "boolean") {
+    throw new __velarTerminalNativeTypeError("Node terminal worker returned an invalid response");
+  }
+  const descriptor = __velarTerminalOwnDescriptor(__velarTerminalPending, __velarTerminalNativeString(message.id));
+  if (!descriptor || !("value" in descriptor)) throw new __velarTerminalNativeError("Node terminal worker returned an unknown response");
+  const pending = descriptor.value;
+  const responseError = message.ok ? null : __velarTerminalError(message.error);
+  if (pending.operation === "readLine") {
+    if (message.ok && message.value !== null && typeof message.value !== "string") throw new __velarTerminalNativeTypeError("Node terminal worker returned invalid input");
+    if (message.ok && typeof message.value === "string") __velarTerminalBoundedText(message.value, "Terminal input");
+  } else if (message.ok && message.value !== null) {
+    throw new __velarTerminalNativeTypeError("Node terminal worker returned invalid write completion");
+  }
+  delete __velarTerminalPending[message.id];
+  __velarTerminalPendingCount -= 1;
+  __velarTerminalUpdateReference();
+  if (responseError) pending.reject(responseError);
+  else pending.resolve(message.value);
+}
+
+const __velarTerminalArguments = __velarTerminalProgramArguments();
+const __velarTerminalReadyPromise = new __velarTerminalNativePromise((resolve, reject) => {
+  __velarTerminalReadyResolve = resolve;
+  __velarTerminalReadyReject = reject;
+});
+const __velarTerminalChannel = new __VelarTerminalMessageChannel();
+const __velarTerminalPort = __velarTerminalChannel.port1;
+__velarTerminalPort.onmessage = event => {
+  try { __velarTerminalMessage(__velarTerminalCall(__velarTerminalMessageData, event, [])); }
+  catch (error) { __velarTerminalFail(error); }
+};
+__velarTerminalPort.onmessageerror = () => __velarTerminalFail(new __velarTerminalNativeError("Node terminal worker returned an unreadable message"));
+__velarTerminalCall(__velarTerminalMessagePortStart, __velarTerminalPort, []);
+const __velarTerminalWorker = new __VelarTerminalWorker(WORKER_SOURCE, {
+  eval: true,
+  workerData: {port: __velarTerminalChannel.port2},
+  transferList: [__velarTerminalChannel.port2],
+});
+__velarTerminalCall(__velarTerminalEventOn, __velarTerminalWorker, ["error", error => __velarTerminalFail(error)]);
+__velarTerminalCall(__velarTerminalEventOn, __velarTerminalWorker, ["exit", code => {
+  if (!__velarTerminalExpectedWorkerExit) {
+    __velarTerminalFail(new __velarTerminalNativeError("Node terminal worker exited unexpectedly with code " + code));
+  }
+}]);
+const __velarTerminalReadyTimer = __velarTerminalSetTimeout(
+  () => __velarTerminalReadyReject(new __velarTerminalNativeError("Node terminal worker did not become ready")),
+  10000,
+);
+try { await __velarTerminalReadyPromise; }
+finally { __velarTerminalClearTimeout(__velarTerminalReadyTimer); }
+__velarTerminalCall(__velarTerminalWorkerUnref, __velarTerminalWorker, []);
+__velarTerminalCall(__velarTerminalMessagePortUnref, __velarTerminalPort, []);
+
+function __velarTerminalInvoke(operation, value) {
+  if (__velarTerminalClosed) {
+    if (__velarTerminalFailure) return new __velarTerminalNativePromise((_resolve, reject) => reject(__velarTerminalFailure));
+    if (operation === "readLine") return new __velarTerminalNativePromise(resolve => resolve(null));
+    return new __velarTerminalNativePromise((_resolve, reject) => reject(new __velarTerminalNativeError("Terminal is closed")));
+  }
+  if (__velarTerminalPendingCount >= __velarTerminalMaxPending) {
+    return new __velarTerminalNativePromise((_resolve, reject) => reject(new __velarTerminalNativeRangeError("Terminal cannot have more than 256 pending operations")));
+  }
+  const id = __velarTerminalNextRequest;
+  __velarTerminalNextRequest += 1;
+  const result = new __velarTerminalNativePromise((resolve, reject) => {
+    __velarTerminalPending[id] = {operation, resolve, reject};
+  });
+  __velarTerminalPendingCount += 1;
+  __velarTerminalUpdateReference();
+  try {
+    __velarTerminalCall(__velarTerminalMessagePortPost, __velarTerminalPort, [{kind: "request", id, operation, value}]);
+  } catch (error) {
+    delete __velarTerminalPending[id];
+    __velarTerminalPendingCount -= 1;
+    __velarTerminalUpdateReference();
+    return new __velarTerminalNativePromise((_resolve, reject) => reject(error));
+  }
+  return result;
+}
+
+export const terminal = __velarTerminalCall(__velarTerminalObjectFreeze, __velarTerminalNativeObject, [{
+  args() { return __velarTerminalCall(__velarTerminalArraySlice, __velarTerminalArguments, []); },
+  isInteractive() { return __velarTerminalInteractive; },
+  readLine(prompt = "") { return __velarTerminalInvoke("readLine", __velarTerminalBoundedText(prompt, "Terminal prompt")); },
+  write(text) { return __velarTerminalInvoke("write", __velarTerminalBoundedText(text, "Terminal write")); },
+  writeError(text) { return __velarTerminalInvoke("writeError", __velarTerminalBoundedText(text, "Terminal error write")); },
+  close() {
+    if (__velarTerminalClosed) return null;
+    __velarTerminalClosed = true;
+    const keys = __velarTerminalCall(__velarTerminalOwnKeys, __velarTerminalNativeReflect, [__velarTerminalPending]);
+    for (let index = 0; index < keys.length; index += 1) {
+      const descriptor = __velarTerminalOwnDescriptor(__velarTerminalPending, keys[index]);
+      if (descriptor && "value" in descriptor) {
+        if (descriptor.value.operation === "readLine") descriptor.value.resolve(null);
+        else descriptor.value.reject(new __velarTerminalNativeError("Terminal closed before the write completed"));
+      }
+      delete __velarTerminalPending[keys[index]];
+    }
+    __velarTerminalPendingCount = 0;
+    __velarTerminalClosing = true;
+    __velarTerminalUpdateReference();
+    __velarTerminalCall(__velarTerminalMessagePortPost, __velarTerminalPort, [{kind: "close"}]);
+    return null;
+  },
+}]);
+`.trimStart();
+//# sourceMappingURL=terminal-runtime.js.map

package/dist/terminal-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-runtime.js","sourceRoot":"","sources":["../src/terminal-runtime.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6RpD,CAAC,SAAS,EAAE,CAAC"}

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

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

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

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

package/dist/terminal-worker-runtime.js

@@ -0,0 +1,311 @@
+const VELAR_NODE_TERMINAL_INPUT_SOURCE = String.raw `
+process.stdin.pause();
+process.on("error", () => process.exit(0));
+const send = value => {
+  if (process.connected && typeof process.send === "function") {
+    process.send(value, error => { if (error) process.exit(0); });
+  }
+};
+process.stdin.on("data", data => send({kind: "input-data", data}));
+process.stdin.on("end", () => { send({kind: "input-end"}); process.disconnect(); });
+process.stdin.on("error", () => { send({kind: "input-error"}); process.disconnect(); });
+process.on("message", value => {
+  if (!value || typeof value !== "object") return;
+  if (value.kind === "input-state" && typeof value.active === "boolean") {
+    if (value.active) process.stdin.resume();
+    else process.stdin.pause();
+  } else if (value.kind === "close") {
+    process.stdin.pause();
+    process.exit(0);
+  }
+});
+process.on("disconnect", () => process.exit(0));
+send({kind: "ready"});
+`.trimStart();
+// Isolated terminal host. The Worker never loads application code or packages;
+// an on-demand child owns the inherited stdin handle so a blocking pipe read is
+// cancellable without exposing application-Realm stream prototypes.
+export const VELAR_NODE_TERMINAL_WORKER_SOURCE = String.raw `
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import { write } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { isatty } from "node:tty";
+import { workerData } from "node:worker_threads";
+
+const port = workerData.port;
+const inputHostSource = ${JSON.stringify(VELAR_NODE_TERMINAL_INPUT_SOURCE)};
+const maxTextBytes = 1024 * 1024;
+const maxQueuedLines = 256;
+const decoder = new StringDecoder("utf8");
+const waiting = [];
+const queued = [];
+let queuedBytes = 0;
+let queueOverflowed = false;
+let closed = false;
+let inputHost = null;
+let inputHostReady = false;
+let inputHostEnded = false;
+let inputHostActive = false;
+let failure = null;
+let lineParts = [];
+let lineBytes = 0;
+let lineOverflowed = false;
+let swallowLineFeed = false;
+let operationTail = Promise.resolve();
+
+function errorRecord(error) {
+  const name = error instanceof RangeError ? "RangeError" : error instanceof TypeError ? "TypeError" : "Error";
+  const message = error instanceof Error && typeof error.message === "string" && error.message.length > 0
+    ? error.message.slice(0, 65536)
+    : "Node terminal host failed";
+  return {name, message};
+}
+
+function respond(id, ok, value, error = null) {
+  port.postMessage({kind: "response", id, ok, value, error});
+}
+
+function referenceInputHost(active) {
+  if (inputHost === null) return;
+  if (active) {
+    inputHost.ref();
+    inputHost.channel?.ref();
+  } else {
+    inputHost.channel?.unref();
+    inputHost.unref();
+  }
+}
+
+function ensureInputHost() {
+  if (inputHost !== null || closed) return inputHost;
+  inputHost = spawn(process.execPath, ["--input-type=module", "--eval", inputHostSource], {
+    stdio: ["inherit", "ignore", "inherit", "ipc"],
+    serialization: "advanced",
+    windowsHide: true,
+  });
+  inputHost.on("message", value => {
+    try {
+      if (!value || typeof value !== "object") throw new TypeError("Node terminal input host returned an invalid message");
+      if (value.kind === "ready") {
+        inputHostReady = true;
+        inputHost.send({kind: "input-state", active: inputHostActive});
+      } else if (value.kind === "input-data") acceptForwardedData(value);
+      else if (value.kind === "input-end") { inputHostEnded = true; endForwardedInput(); }
+      else if (value.kind === "input-error") { inputHostEnded = true; endForwardedInput(new Error("Terminal input failed")); }
+      else throw new TypeError("Node terminal input host returned an invalid message");
+    } catch (error) { settleInput(error); }
+  });
+  inputHost.on("error", error => settleInput(error));
+  inputHost.on("exit", code => {
+    if (!closed && !inputHostEnded) settleInput(new Error("Node terminal input host exited unexpectedly with code " + code));
+  });
+  referenceInputHost(false);
+  return inputHost;
+}
+
+function requestForwardedInput(active) {
+  if (closed || inputHostActive === active) return;
+  inputHostActive = active;
+  const host = active ? ensureInputHost() : inputHost;
+  if (host === null) return;
+  referenceInputHost(active);
+  if (inputHostReady) host.send({kind: "input-state", active});
+}
+
+function requestOf(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Node terminal host received an invalid request");
+  const keys = Object.keys(value);
+  if (keys.length !== 4 || !keys.includes("kind") || !keys.includes("id") || !keys.includes("operation") || !keys.includes("value")) {
+    throw new TypeError("Node terminal host received an invalid request");
+  }
+  if (value.kind !== "request" || !Number.isSafeInteger(value.id) || value.id < 1
+    || value.operation !== "readLine" && value.operation !== "write" && value.operation !== "writeError") {
+    throw new TypeError("Node terminal host received an invalid request");
+  }
+  if (typeof value.value !== "string" || Buffer.byteLength(value.value, "utf8") > maxTextBytes) {
+    throw new RangeError("Node terminal request text exceeds its 1 MiB boundary");
+  }
+  return value;
+}
+
+function writeText(fd, text) {
+  const data = Buffer.from(text, "utf8");
+  return new Promise((resolve, reject) => {
+    let offset = 0;
+    const next = () => {
+      if (offset >= data.length) { resolve(null); return; }
+      write(fd, data, offset, data.length - offset, null, (error, written) => {
+        if (error) { reject(error); return; }
+        if (!Number.isSafeInteger(written) || written < 1) {
+          reject(new Error("Node terminal host made no write progress"));
+          return;
+        }
+        offset += written;
+        next();
+      });
+    };
+    next();
+  });
+}
+
+function deliver(entry) {
+  const request = waiting.shift();
+  if (request) {
+    if (entry.error) respond(request.id, false, null, errorRecord(entry.error));
+    else respond(request.id, true, entry.value);
+    if (waiting.length === 0) requestForwardedInput(false);
+    return;
+  }
+  if (queueOverflowed) return;
+  if (queued.length >= maxQueuedLines || queuedBytes + entry.bytes > maxTextBytes) {
+    queueOverflowed = true;
+    queued.push({
+      value: null,
+      error: new RangeError("Terminal queued input exceeds its 1 MiB boundary"),
+      bytes: 0,
+      queueOverflow: true,
+    });
+    return;
+  }
+  queued.push(entry);
+  queuedBytes += entry.bytes;
+  requestForwardedInput(false);
+}
+
+function appendLine(text, start, end) {
+  if (start >= end || lineOverflowed) return;
+  const fragment = text.slice(start, end);
+  const bytes = Buffer.byteLength(fragment, "utf8");
+  if (lineBytes + bytes > maxTextBytes) {
+    lineParts = [];
+    lineBytes = 0;
+    lineOverflowed = true;
+    return;
+  }
+  lineParts.push(fragment);
+  lineBytes += bytes;
+}
+
+function completeLine() {
+  if (lineOverflowed) {
+    deliver({
+      value: null,
+      error: new RangeError("Terminal input text exceeds its 1 MiB boundary"),
+      bytes: 0,
+      queueOverflow: false,
+    });
+  } else {
+    deliver({value: lineParts.join(""), error: null, bytes: lineBytes, queueOverflow: false});
+  }
+  lineParts = [];
+  lineBytes = 0;
+  lineOverflowed = false;
+}
+
+function consume(text) {
+  let start = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const unit = text.charCodeAt(index);
+    if (swallowLineFeed) {
+      swallowLineFeed = false;
+      if (unit === 10) { start = index + 1; continue; }
+    }
+    if (unit !== 10 && unit !== 13) continue;
+    appendLine(text, start, index);
+    completeLine();
+    start = index + 1;
+    if (unit === 13) swallowLineFeed = true;
+  }
+  appendLine(text, start, text.length);
+}
+
+function settleInput(error = null) {
+  if (closed) return;
+  closed = true;
+  failure = error;
+  requestForwardedInput(false);
+  while (waiting.length > 0) {
+    const request = waiting.shift();
+    if (error) respond(request.id, false, null, errorRecord(error));
+    else respond(request.id, true, null);
+  }
+}
+
+function acceptRead(id) {
+  if (queued.length > 0) {
+    const entry = queued.shift();
+    queuedBytes -= entry.bytes;
+    if (entry.queueOverflow) queueOverflowed = false;
+    if (entry.error) respond(id, false, null, errorRecord(entry.error));
+    else respond(id, true, entry.value);
+    return;
+  }
+  if (failure) { respond(id, false, null, errorRecord(failure)); return; }
+  if (closed) { respond(id, true, null); return; }
+  waiting.push({id});
+  requestForwardedInput(true);
+}
+
+function acceptForwardedData(value) {
+  if (closed || !value || typeof value !== "object" || !(value.data instanceof Uint8Array)
+    || value.data.byteLength > maxTextBytes) {
+    throw new TypeError("Node terminal host received invalid forwarded input");
+  }
+  consume(decoder.write(value.data));
+  if (waiting.length === 0) requestForwardedInput(false);
+}
+
+function endForwardedInput(error = null) {
+  if (closed) return;
+  if (error !== null) { settleInput(error); return; }
+  const tail = decoder.end();
+  if (tail) consume(tail);
+  if (lineParts.length > 0 || lineOverflowed) completeLine();
+  settleInput();
+}
+
+async function dispatch(value) {
+  let request;
+  try {
+    request = requestOf(value);
+    if (request.operation === "write" || request.operation === "writeError") {
+      await writeText(request.operation === "write" ? 1 : 2, request.value);
+      respond(request.id, true, null);
+      return;
+    }
+    if (request.value.length > 0) await writeText(1, request.value);
+    acceptRead(request.id);
+  } catch (error) {
+    if (request) respond(request.id, false, null, errorRecord(error));
+    else throw error;
+  }
+}
+
+function closeInput() {
+  closed = true;
+  failure = null;
+  while (waiting.length > 0) waiting.shift();
+  while (queued.length > 0) queued.shift();
+  queuedBytes = 0;
+  requestForwardedInput(false);
+  if (inputHost !== null) {
+    try { inputHost.send({kind: "close"}); } catch {}
+  }
+  port.postMessage({kind: "closed", error: null});
+}
+
+port.on("message", value => {
+  if (value && typeof value === "object" && value.kind === "close") {
+    closeInput();
+    return;
+  }
+  operationTail = operationTail.then(() => dispatch(value));
+  operationTail.catch(error => { queueMicrotask(() => { throw error; }); });
+});
+port.on("messageerror", () => { throw new Error("Node terminal host received an unreadable request"); });
+port.start();
+process.once("exit", () => { if (inputHost !== null) inputHost.kill("SIGKILL"); });
+port.postMessage({kind: "ready", interactive: isatty(0) && isatty(1)});
+`.trimStart();
+//# sourceMappingURL=terminal-worker-runtime.js.map

package/dist/terminal-worker-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-worker-runtime.js","sourceRoot":"","sources":["../src/terminal-worker-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,gCAAgC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;CAuBlD,CAAC,SAAS,EAAE,CAAC;AAEd,+EAA+E;AAC/E,gFAAgF;AAChF,oEAAoE;AACpE,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;0BASjC,IAAI,CAAC,SAAS,CAAC,gCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiRzE,CAAC,SAAS,EAAE,CAAC"}

package/dist/websocket-runtime.d.ts

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

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

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