@velarscript/node 0.10.1

package/dist/node-host-runtime.js

@@ -0,0 +1,314 @@
+import { VELAR_ERROR_NORMALIZATION_MODULE, VELAR_HOST_ERROR_NAMES, VELAR_HOST_ERROR_PATH_NAMES } from "@velarscript/compiler/extension";
+// Application-facing proxy for the shared privileged Node worker. This module
+// is a private compiler-extension dependency and has no VelarScript interface.
+export const VELAR_NODE_HOST_RUNTIME = String.raw `
+import { ${VELAR_HOST_ERROR_NAMES.map((name) => `${name} as __Velar${name}`).join(", ")} } from ${JSON.stringify(VELAR_ERROR_NORMALIZATION_MODULE)};
+import { EventEmitter as __VelarNodeHostEventEmitter } from "node:events";
+import { MessageChannel as __VelarNodeHostMessageChannel, MessagePort as __VelarNodeHostMessagePort, Worker as __VelarNodeHostWorker } from "node:worker_threads";
+
+const __velarNodeHostArray = globalThis.Array;
+const __velarNodeHostError = globalThis.Error;
+const __velarNodeHostNumber = globalThis.Number;
+const __velarNodeHostObject = globalThis.Object;
+const __velarNodeHostPromise = globalThis.Promise;
+const __velarNodeHostRangeError = globalThis.RangeError;
+const __velarNodeHostReflect = globalThis.Reflect;
+const __velarNodeHostString = globalThis.String;
+const __velarNodeHostTypeError = globalThis.TypeError;
+const __velarNodeHostOwnDescriptor = __velarNodeHostObject.getOwnPropertyDescriptor;
+const __velarNodeHostApply = __velarNodeHostReflect.apply;
+function __velarNodeHostDataOperation(target, name) {
+  const descriptor = __velarNodeHostOwnDescriptor(target, name);
+  if (!descriptor || !("value" in descriptor) || typeof descriptor.value !== "function") {
+    throw new __velarNodeHostError("VelarScript Node host operation '" + name + "' is unavailable");
+  }
+  return descriptor.value;
+}
+const __velarNodeHostArrayIsArray = __velarNodeHostDataOperation(__velarNodeHostArray, "isArray");
+const __velarNodeHostNumberIsSafeInteger = __velarNodeHostDataOperation(__velarNodeHostNumber, "isSafeInteger");
+const __velarNodeHostObjectCreate = __velarNodeHostDataOperation(__velarNodeHostObject, "create");
+const __velarNodeHostObjectGetPrototypeOf = __velarNodeHostDataOperation(__velarNodeHostObject, "getPrototypeOf");
+const __velarNodeHostOwnKeys = __velarNodeHostDataOperation(__velarNodeHostReflect, "ownKeys");
+const __velarNodeHostMessagePortPost = __velarNodeHostDataOperation(__VelarNodeHostMessagePort.prototype, "postMessage");
+const __velarNodeHostMessagePortStart = __velarNodeHostDataOperation(__VelarNodeHostMessagePort.prototype, "start");
+const __velarNodeHostMessagePortRef = __velarNodeHostDataOperation(__VelarNodeHostMessagePort.prototype, "ref");
+const __velarNodeHostMessagePortUnref = __velarNodeHostDataOperation(__VelarNodeHostMessagePort.prototype, "unref");
+const __velarNodeHostMessagePortClose = __velarNodeHostDataOperation(__VelarNodeHostMessagePort.prototype, "close");
+const __velarNodeHostWorkerUnref = __velarNodeHostDataOperation(__VelarNodeHostWorker.prototype, "unref");
+const __velarNodeHostWorkerTerminate = __velarNodeHostDataOperation(__VelarNodeHostWorker.prototype, "terminate");
+const __velarNodeHostEventOn = __velarNodeHostDataOperation(__VelarNodeHostEventEmitter.prototype, "on");
+const __velarNodeHostPromiseThen = __velarNodeHostDataOperation(__velarNodeHostPromise.prototype, "then");
+const __velarNodeHostMessageData = __velarNodeHostOwnDescriptor(globalThis.MessageEvent.prototype, "data")?.get;
+if (typeof __velarNodeHostMessageData !== "function") throw new __velarNodeHostError("Node host MessageEvent data operation is unavailable");
+const __velarNodeHostSetTimeout = globalThis.setTimeout;
+const __velarNodeHostClearTimeout = globalThis.clearTimeout;
+const __velarNodeHostPending = __velarNodeHostApply(__velarNodeHostObjectCreate, __velarNodeHostObject, [null]);
+const __velarNodeHostEventHandlers = __velarNodeHostApply(__velarNodeHostObjectCreate, __velarNodeHostObject, [null]);
+const __velarNodeHostActiveHttpHandles = __velarNodeHostApply(__velarNodeHostObjectCreate, __velarNodeHostObject, [null]);
+const __velarNodeHostActiveFileWatchers = __velarNodeHostApply(__velarNodeHostObjectCreate, __velarNodeHostObject, [null]);
+const __velarNodeHostMaxPending = 1024;
+let __velarNodeHostNextRequest = 1;
+let __velarNodeHostPendingCount = 0;
+let __velarNodeHostActiveServers = 0;
+let __velarNodeHostActiveHttpRequests = 0;
+let __velarNodeHostActiveWatcherCount = 0;
+let __velarNodeHostReady = false;
+let __velarNodeHostFailure = null;
+let __velarNodeHostReadyResolve;
+let __velarNodeHostReadyReject;
+
+function __velarNodeHostCall(operation, receiver, args) {
+  return __velarNodeHostApply(operation, receiver, args);
+}
+
+function __velarNodeHostRecord(value, name) {
+  if (!value || typeof value !== "object" || __velarNodeHostCall(__velarNodeHostArrayIsArray, __velarNodeHostArray, [value])) {
+    throw new __velarNodeHostTypeError(name + " must be a record");
+  }
+  const prototype = __velarNodeHostCall(__velarNodeHostObjectGetPrototypeOf, __velarNodeHostObject, [value]);
+  if (prototype !== __velarNodeHostObject.prototype && prototype !== null) throw new __velarNodeHostTypeError(name + " must be a plain record");
+  const output = __velarNodeHostCall(__velarNodeHostObjectCreate, __velarNodeHostObject, [null]);
+  const keys = __velarNodeHostCall(__velarNodeHostOwnKeys, __velarNodeHostReflect, [value]);
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (typeof key !== "string") throw new __velarNodeHostTypeError(name + " fields must use string names");
+    const descriptor = __velarNodeHostOwnDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) throw new __velarNodeHostTypeError(name + " fields must be enumerable data values");
+    output[key] = descriptor.value;
+  }
+  return output;
+}
+
+export class __velarNodeHostHttpTransportError extends __velarNodeHostError {
+  constructor(message, phase) {
+    super(message);
+    this.name = "HttpTransportError";
+    this.phase = phase;
+  }
+}
+
+const __velarNodeHostPathErrorClasses = __velarNodeHostObjectCreate(null);
+${VELAR_HOST_ERROR_PATH_NAMES.map((name) => `__velarNodeHostPathErrorClasses[${JSON.stringify(name)}] = __Velar${name};`).join("\n")}
+
+function __velarNodeHostErrorOf(value, operation) {
+  value = __velarNodeHostRecord(value, "Node host error");
+  if (typeof value.message !== "string" || value.message.length === 0 || value.message.length > 65536) {
+    throw new __velarNodeHostTypeError("Node host returned an invalid error");
+  }
+  if (value.name === "HttpTransportError") {
+    if ((operation !== "http.request" && operation !== "http.read")
+      || (value.phase !== "request" && value.phase !== "response")
+      || (operation === "http.request" ? value.phase !== "request" : value.phase !== "response")) {
+      throw new __velarNodeHostTypeError("Node host returned an invalid HTTP transport error");
+    }
+    return new __velarNodeHostHttpTransportError(value.message, value.phase);
+  }
+  // D50 rule 89: the worker names the failures a caller recovers from
+  // differently. Only the class name and its path cross the boundary; the
+  // proxy rebuilds the Realm-owned class so no privileged object escapes.
+  const pathed = __velarNodeHostPathErrorClasses[value.name];
+  if (pathed) {
+    if (typeof value.path !== "string" || value.path.length > 65536) {
+      throw new __velarNodeHostTypeError("Node host returned an invalid error path");
+    }
+    return new pathed(value.message, value.path.length > 0 ? value.path : null);
+  }
+  if (value.name === "AddressInUseError") return new __VelarAddressInUseError(value.message);
+  if (value.name === "RangeError") return new __velarNodeHostRangeError(value.message);
+  if (value.name === "TypeError") return new __velarNodeHostTypeError(value.message);
+  if (value.name === "Error") return new __velarNodeHostError(value.message);
+  throw new __velarNodeHostTypeError("Node host returned an invalid error");
+}
+
+function __velarNodeHostUpdateReference() {
+  const operation = __velarNodeHostPendingCount > 0 || __velarNodeHostActiveServers > 0 || __velarNodeHostActiveHttpRequests > 0 || __velarNodeHostActiveWatcherCount > 0
+    ? __velarNodeHostMessagePortRef
+    : __velarNodeHostMessagePortUnref;
+  __velarNodeHostCall(operation, __velarNodeHostPort, []);
+}
+
+function __velarNodeHostRequestId() {
+  let attempts = 0;
+  while (__velarNodeHostOwnDescriptor(__velarNodeHostPending, __velarNodeHostString(__velarNodeHostNextRequest))) {
+    __velarNodeHostNextRequest = __velarNodeHostNextRequest >= __velarNodeHostNumber.MAX_SAFE_INTEGER
+      ? 1
+      : __velarNodeHostNextRequest + 1;
+    attempts += 1;
+    if (attempts > __velarNodeHostMaxPending) throw new __velarNodeHostRangeError("Node host request identity space is unavailable");
+  }
+  const id = __velarNodeHostNextRequest;
+  __velarNodeHostNextRequest = id >= __velarNodeHostNumber.MAX_SAFE_INTEGER ? 1 : id + 1;
+  return id;
+}
+
+function __velarNodeHostFail(error) {
+  if (__velarNodeHostFailure) return;
+  const failure = error instanceof __velarNodeHostError ? error : new __velarNodeHostError("Node host worker failed");
+  __velarNodeHostFailure = failure;
+  if (!__velarNodeHostReady) __velarNodeHostReadyReject(failure);
+  const keys = __velarNodeHostCall(__velarNodeHostOwnKeys, __velarNodeHostReflect, [__velarNodeHostPending]);
+  for (let index = 0; index < keys.length; index += 1) {
+    const descriptor = __velarNodeHostOwnDescriptor(__velarNodeHostPending, keys[index]);
+    if (descriptor && "value" in descriptor) descriptor.value.reject(failure);
+    delete __velarNodeHostPending[keys[index]];
+  }
+  __velarNodeHostPendingCount = 0;
+  __velarNodeHostActiveServers = 0;
+  __velarNodeHostActiveHttpRequests = 0;
+  __velarNodeHostActiveWatcherCount = 0;
+  const httpKeys = __velarNodeHostCall(__velarNodeHostOwnKeys, __velarNodeHostReflect, [__velarNodeHostActiveHttpHandles]);
+  for (let index = 0; index < httpKeys.length; index += 1) delete __velarNodeHostActiveHttpHandles[httpKeys[index]];
+  const watcherKeys = __velarNodeHostCall(__velarNodeHostOwnKeys, __velarNodeHostReflect, [__velarNodeHostActiveFileWatchers]);
+  for (let index = 0; index < watcherKeys.length; index += 1) delete __velarNodeHostActiveFileWatchers[watcherKeys[index]];
+  __velarNodeHostUpdateReference();
+  __velarNodeHostCall(__velarNodeHostMessagePortClose, __velarNodeHostPort, []);
+  const terminated = __velarNodeHostCall(__velarNodeHostWorkerTerminate, __velarNodeHostWorker, []);
+  __velarNodeHostCall(__velarNodeHostPromiseThen, terminated, [() => null, () => null]);
+}
+
+function __velarNodeHostMessage(value) {
+  const message = __velarNodeHostRecord(value, "Node host message");
+  if (message.kind === "ready") {
+    if (__velarNodeHostReady) throw new __velarNodeHostError("Node host worker sent duplicate readiness");
+    __velarNodeHostReady = true;
+    __velarNodeHostReadyResolve(null);
+    return;
+  }
+  if (message.kind === "event") {
+    if (message.event !== "serve.request") throw new __velarNodeHostTypeError("Node host worker returned an unknown event");
+    const handler = __velarNodeHostOwnDescriptor(__velarNodeHostEventHandlers, message.event);
+    if (!handler || !("value" in handler)) throw new __velarNodeHostError("Node host event has no registered owner");
+    try { handler.value(message.value); }
+    catch {
+      const request = message.value && typeof message.value === "object" ? __velarNodeHostOwnDescriptor(message.value, "request") : null;
+      if (request && "value" in request) __velarNodeHostInvoke("serve.fail", [request.value]);
+    }
+    return;
+  }
+  if (message.kind !== "response" || !__velarNodeHostCall(__velarNodeHostNumberIsSafeInteger, __velarNodeHostNumber, [message.id])
+    || message.id < 1 || typeof message.ok !== "boolean") {
+    throw new __velarNodeHostTypeError("Node host worker returned an invalid response");
+  }
+  const descriptor = __velarNodeHostOwnDescriptor(__velarNodeHostPending, __velarNodeHostString(message.id));
+  if (!descriptor || !("value" in descriptor)) throw new __velarNodeHostError("Node host worker returned an unknown response");
+  const pending = descriptor.value;
+  const responseError = message.ok ? null : __velarNodeHostErrorOf(message.error, pending.operation);
+  let activeHttpDelta = 0;
+  let activeWatcherDelta = 0;
+  if (message.ok && pending.operation === "http.request") {
+    const result = __velarNodeHostRecord(message.value, "Node HTTP response");
+    const body = __velarNodeHostOwnDescriptor(result, "body");
+    if (!body || !("value" in body) || typeof body.value !== "boolean") throw new __velarNodeHostTypeError("Node host returned an invalid HTTP response");
+    if (body.value) {
+      const key = __velarNodeHostString(pending.handle);
+      if (__velarNodeHostOwnDescriptor(__velarNodeHostActiveHttpHandles, key)) throw new __velarNodeHostError("Node host returned a duplicate HTTP handle");
+      __velarNodeHostActiveHttpHandles[key] = true;
+      activeHttpDelta = 1;
+    }
+  } else if (message.ok && (pending.operation === "http.close" || pending.operation === "http.cancel")) {
+    if (typeof message.value !== "boolean") throw new __velarNodeHostTypeError("Node host returned an invalid HTTP release result");
+    const key = __velarNodeHostString(pending.handle);
+    if (message.value && __velarNodeHostOwnDescriptor(__velarNodeHostActiveHttpHandles, key)) {
+      delete __velarNodeHostActiveHttpHandles[key];
+      activeHttpDelta = -1;
+    }
+  }
+  if (message.ok && pending.operation === "fs.watchStart") {
+    if (!__velarNodeHostCall(__velarNodeHostNumberIsSafeInteger, __velarNodeHostNumber, [message.value]) || message.value < 1) {
+      throw new __velarNodeHostTypeError("Node host returned an invalid file watcher handle");
+    }
+    const key = __velarNodeHostString(message.value);
+    if (__velarNodeHostOwnDescriptor(__velarNodeHostActiveFileWatchers, key)) throw new __velarNodeHostError("Node host returned a duplicate file watcher handle");
+    __velarNodeHostActiveFileWatchers[key] = true;
+    activeWatcherDelta = 1;
+  } else if (pending.operation === "fs.watchNext" && (!message.ok || message.value === null)) {
+    const key = __velarNodeHostString(pending.handle);
+    if (__velarNodeHostOwnDescriptor(__velarNodeHostActiveFileWatchers, key)) {
+      delete __velarNodeHostActiveFileWatchers[key];
+      activeWatcherDelta = -1;
+    }
+  } else if (message.ok && pending.operation === "fs.watchClose") {
+    if (typeof message.value !== "boolean") throw new __velarNodeHostTypeError("Node host returned an invalid file watcher release result");
+    const key = __velarNodeHostString(pending.handle);
+    if (message.value && __velarNodeHostOwnDescriptor(__velarNodeHostActiveFileWatchers, key)) {
+      delete __velarNodeHostActiveFileWatchers[key];
+      activeWatcherDelta = -1;
+    }
+  }
+  delete __velarNodeHostPending[message.id];
+  __velarNodeHostPendingCount -= 1;
+  if (message.ok && pending.operation === "serve.start") __velarNodeHostActiveServers += 1;
+  else if (message.ok && pending.operation === "serve.stop" && __velarNodeHostActiveServers > 0) __velarNodeHostActiveServers -= 1;
+  __velarNodeHostActiveHttpRequests += activeHttpDelta;
+  __velarNodeHostActiveWatcherCount += activeWatcherDelta;
+  __velarNodeHostUpdateReference();
+  if (message.ok) pending.resolve(message.value);
+  else pending.reject(responseError);
+}
+
+const __velarNodeHostReadyPromise = new __velarNodeHostPromise((resolve, reject) => {
+  __velarNodeHostReadyResolve = resolve;
+  __velarNodeHostReadyReject = reject;
+});
+const __velarNodeHostChannel = new __VelarNodeHostMessageChannel();
+const __velarNodeHostPort = __velarNodeHostChannel.port1;
+__velarNodeHostPort.onmessage = event => {
+  try { __velarNodeHostMessage(__velarNodeHostCall(__velarNodeHostMessageData, event, [])); }
+  catch (error) { __velarNodeHostFail(error); }
+};
+__velarNodeHostPort.onmessageerror = () => __velarNodeHostFail(new __velarNodeHostError("Node host worker returned an unreadable message"));
+__velarNodeHostCall(__velarNodeHostMessagePortStart, __velarNodeHostPort, []);
+const __velarNodeHostWorker = new __VelarNodeHostWorker(WORKER_SOURCE, {
+  eval: true,
+  workerData: __velarNodeHostChannel.port2,
+  transferList: [__velarNodeHostChannel.port2],
+});
+__velarNodeHostCall(__velarNodeHostEventOn, __velarNodeHostWorker, ["error", () => __velarNodeHostFail(new __velarNodeHostError("Node host worker failed"))]);
+__velarNodeHostCall(__velarNodeHostEventOn, __velarNodeHostWorker, ["exit", code => {
+  __velarNodeHostFail(new __velarNodeHostError("Node host worker exited unexpectedly with code " + code));
+}]);
+const __velarNodeHostReadyTimer = __velarNodeHostCall(__velarNodeHostSetTimeout, globalThis, [
+  () => __velarNodeHostReadyReject(new __velarNodeHostError("Node host worker did not become ready")),
+  10000,
+]);
+try { await __velarNodeHostReadyPromise; }
+finally { __velarNodeHostCall(__velarNodeHostClearTimeout, globalThis, [__velarNodeHostReadyTimer]); }
+__velarNodeHostCall(__velarNodeHostWorkerUnref, __velarNodeHostWorker, []);
+__velarNodeHostCall(__velarNodeHostMessagePortUnref, __velarNodeHostPort, []);
+
+export function __velarNodeHostInvoke(operation, args) {
+  if (typeof operation !== "string" || operation.length === 0 || !__velarNodeHostCall(__velarNodeHostArrayIsArray, __velarNodeHostArray, [args])) {
+    return new __velarNodeHostPromise((_resolve, reject) => reject(new __velarNodeHostTypeError("Node host invocation is invalid")));
+  }
+  if (__velarNodeHostPendingCount >= __velarNodeHostMaxPending) {
+    return new __velarNodeHostPromise((_resolve, reject) => reject(new __velarNodeHostRangeError("Node host cannot have more than 1024 pending operations")));
+  }
+  if (__velarNodeHostFailure) return new __velarNodeHostPromise((_resolve, reject) => reject(__velarNodeHostFailure));
+  const id = __velarNodeHostRequestId();
+  return new __velarNodeHostPromise((resolve, reject) => {
+    const handle = operation === "http.request" || operation === "http.read" || operation === "http.cancel" || operation === "http.close"
+      || operation === "fs.watchNext" || operation === "fs.watchClose"
+      ? args[0]
+      : null;
+    __velarNodeHostPending[id] = {operation, handle, resolve, reject};
+    __velarNodeHostPendingCount += 1;
+    __velarNodeHostUpdateReference();
+    try { __velarNodeHostCall(__velarNodeHostMessagePortPost, __velarNodeHostPort, [{id, operation, args}]); }
+    catch (error) {
+      delete __velarNodeHostPending[id];
+      __velarNodeHostPendingCount -= 1;
+      __velarNodeHostUpdateReference();
+      reject(error);
+    }
+  });
+}
+
+export function __velarNodeHostOn(event, handler) {
+  if (event !== "serve.request" || typeof handler !== "function") throw new __velarNodeHostTypeError("Node host event registration is invalid");
+  if (__velarNodeHostFailure) throw __velarNodeHostFailure;
+  if (__velarNodeHostOwnDescriptor(__velarNodeHostEventHandlers, event)) throw new __velarNodeHostError("Node host event already has an owner");
+  __velarNodeHostEventHandlers[event] = handler;
+  return null;
+}
+`.trimStart();
+//# sourceMappingURL=node-host-runtime.js.map

package/dist/node-host-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-host-runtime.js","sourceRoot":"","sources":["../src/node-host-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAExI,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,CAAC,MAAM,uBAAuB,GAAG,MAAM,CAAC,GAAG,CAAA;WACtC,sBAAsB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,cAAc,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,SAAS,CAAC,gCAAgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsFhJ,2BAA2B,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,mCAAmC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8NnI,CAAC,SAAS,EAAE,CAAC"}

package/dist/node-host-worker-runtime.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"node-host-worker-runtime.d.ts","sourceRoot":"","sources":["../src/node-host-worker-runtime.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,6BAA6B,QAmnC7B,CAAC"}