@poe-platform/safe-bash 0.1.0

package/dist/safe-bash/commands/node/program.js

@@ -0,0 +1,216 @@
+import { nodeLimits } from "./types.js";
+import { text } from "./values.js";
+import { lowerNodeSource } from "./lower.js";
+import { nodeValueRules } from "./rules.js";
+const library = String.raw `
+
+(function (__vnodeRaw, __vnodeContext, __vnodeGuest) {
+  const nativeJSON = JSON;
+  const nativeObject = Object;
+  const nativeArray = Array;
+  const nativePromise = Promise;
+  const nativeString = String;
+  const nativeError = Error;
+${nodeValueRules}
+  function unsupported() { const error = new nativeError('Unsupported restricted Node operation'); error.code = 'ERR_VNODE_UNSUPPORTED'; throw error; }
+  function utf8(value, maximum) {
+    if (typeof value !== 'string' || value.length > maximum) unsupported();
+    let total = 0;
+    for (let offset = 0; offset < value.length; offset = offset + 1) {
+      const first = value.charCodeAt(offset);
+      if (first < 128) total = total + 1;
+      else if (first < 2048) total = total + 2;
+      else if (first >= 55296 && first <= 56319 && offset + 1 < value.length && value.charCodeAt(offset + 1) >= 56320 && value.charCodeAt(offset + 1) <= 57343) { total = total + 4; offset = offset + 1; }
+      else total = total + 3;
+      if (total > maximum) unsupported();
+    }
+    return total;
+  }
+  function primitive(value) {
+    if (value !== null && typeof value !== 'undefined' && typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') unsupported();
+    return nativeString(value);
+  }
+  function tuple(argumentsValue, maximum) {
+    if (argumentsValue.length > maximum) unsupported();
+    const result = [];
+    for (let index = 0; index < argumentsValue.length; index = index + 1) result.push(argumentsValue[index]);
+    return result;
+  }
+  function pathValue(value) { utf8(value, 1024); if (value.indexOf('\u0000') !== -1) unsupported(); return value; }
+  function call(op, authority, path, flag, body, moduleKey) {
+    const envelope = nativeJSON.parse(__vnodeRaw(op, authority, path, flag, body, moduleKey));
+    let failure;
+    if (envelope.error !== null) {
+      failure = new nativeError(envelope.error.message);
+      failure.name = envelope.error.name;
+      failure.code = envelope.error.code;
+      if (envelope.kind === 'fsError') {
+        failure.errno = envelope.error.errno;
+        if (envelope.error.path !== null) failure.path = envelope.error.path;
+        if (envelope.error.syscall !== null) failure.syscall = envelope.error.syscall;
+        if (envelope.error.dest !== null) failure.dest = envelope.error.dest;
+      }
+      remember(failure, 'error', false);
+    }
+    __vnodeRaw('delivered', 'postcopy-v1', nativeString(envelope.sequence), envelope.kind, null, null);
+    if (failure !== undefined) throw failure;
+    return envelope;
+  }
+  function options(value, writing, fd) {
+    if (value === 'utf8') return writing ? 'w' : 'r';
+    if (value === null || typeof value !== 'object' || nativeArray.isArray(value)) unsupported();
+    const keys = nativeObject.keys(value);
+    if (keys.length > 2) unsupported();
+    for (let index = 0; index < keys.length; index = index + 1) if (keys[index] !== 'encoding' && keys[index] !== 'flag') unsupported();
+    if (nativeObject.hasOwn(value, 'encoding') ? value.encoding !== 'utf8' : !writing) unsupported();
+    if (nativeObject.hasOwn(value, 'flag') && (fd || (writing ? value.flag !== 'w' && value.flag !== 'wx' : value.flag !== 'r'))) unsupported();
+    return nativeObject.hasOwn(value, 'flag') ? value.flag : writing ? 'w' : 'r';
+  }
+  const fs = nativeObject.freeze({
+    readFileSync: function (path, encoding) {
+      if (arguments.length !== 2) unsupported();
+      options(encoding, false, path === 0);
+      if (path === 0) return call('readText', 'stdin', null, 'r', null, null).text;
+      return call('readText', 'data', pathValue(path), 'r', null, null).text;
+    },
+    writeFileSync: function (path, value, encoding) {
+      if (arguments.length !== 2 && arguments.length !== 3) unsupported();
+      const filename = pathValue(path);
+      utf8(value, 1048576);
+      const flag = arguments.length === 2 ? 'w' : options(encoding, true, false);
+      call('writeText', 'data', filename, flag, value, null);
+      return undefined;
+    }
+  });
+  function write(channel, value) { utf8(value, 1048576); call('writeOutput', channel, null, null, value, null); return true; }
+  const process = nativeObject.freeze({
+    argv: __vnodeContext.argv,
+    env: __vnodeContext.env,
+    cwd: function () { if (arguments.length !== 0) unsupported(); return __vnodeContext.cwd; },
+    execPath: '/virtual/bin/node',
+    stdin: nativeObject.freeze({fd: 0}),
+    stdout: nativeObject.freeze({fd: 1, write: function (value) { if (arguments.length !== 1) unsupported(); return write('stdout', value); }}),
+    stderr: nativeObject.freeze({fd: 2, write: function (value) { if (arguments.length !== 1) unsupported(); return write('stderr', value); }})
+  });
+  function logging(channel, values) {
+    let output = '';
+    for (let index = 0; index < values.length; index = index + 1) {
+      const current = primitive(values[index]);
+      utf8(current, 1048576);
+      if (output.length + current.length + 2 > 1048576) unsupported();
+      if (index > 0) output = output + ' ';
+      output = output + current;
+    }
+    utf8(output, 1048575);
+    write(channel, output + '\n');
+  }
+  const console = nativeObject.freeze({
+    log: function () { logging('stdout', tuple(arguments, 16)); },
+    error: function () { logging('stderr', tuple(arguments, 16)); }
+  });
+  function pathMethod(method, minimum, maximum) {
+    return function () {
+      const values = tuple(arguments, maximum);
+      if (values.length < minimum) unsupported();
+      for (let index = 0; index < values.length; index = index + 1) pathValue(values[index]);
+      const result = call('path', 'path', null, null, nativeJSON.stringify(values), method).text;
+      return method === 'isAbsolute' ? result === 'true' : result;
+    };
+  }
+  const path = {
+    join: pathMethod('join', 0, 16), resolve: pathMethod('resolve', 0, 16),
+    normalize: pathMethod('normalize', 1, 1), dirname: pathMethod('dirname', 1, 1),
+    basename: pathMethod('basename', 1, 2), extname: pathMethod('extname', 1, 1),
+    relative: pathMethod('relative', 2, 2), isAbsolute: pathMethod('isAbsolute', 1, 1),
+    sep: '/', delimiter: ':'
+  };
+  path.posix = path;
+  nativeObject.freeze(path);
+  const cache = {};
+  let roots = 0;
+  let jsonBytes = 0;
+  function require(target) {
+    if (arguments.length !== 1 || typeof target !== 'string') unsupported();
+    utf8(target, 1024);
+    const name = target.slice(0, 5) === 'node:' ? target.slice(5) : target;
+    if (name === 'fs' || name === 'path' || name === 'process') {
+      call('authorizeModule', 'module', null, null, null, name);
+      return name === 'fs' ? fs : name === 'path' ? path : process;
+    }
+    if ((target.slice(0, 2) !== './' && target.slice(0, 3) !== '../' && target.slice(0, 1) !== '/') || target.slice(-5) !== '.json') unsupported();
+    const authorized = call('authorizeJson', 'json', pathValue(target), 'r', null, null).cacheKey;
+    const key = nativeJSON.stringify([authorized.namespace, authorized.path]);
+    if (nativeObject.hasOwn(cache, key)) return cache[key];
+    if (roots >= 32) unsupported();
+    const result = call('readText', 'json', authorized.path, 'r', null, null);
+    if (result.cacheKey.namespace !== authorized.namespace || result.cacheKey.path !== authorized.path) unsupported();
+    const size = utf8(result.text, 1048576);
+    if (size > 1048576 - jsonBytes) unsupported();
+    jsonBytes = jsonBytes + size;
+    const parsed = recordTree(nativeJSON.parse(result.text), 0);
+    cache[key] = parsed;
+    roots = roots + 1;
+    return parsed;
+  }
+  function jsonValue(value, ancestors) {
+    const kind = typeof value;
+    if (value === null || kind === 'string' || kind === 'number' || kind === 'boolean' || kind === 'undefined') return;
+    if (kind !== 'object') unsupported();
+    if (category(value).kind === 'error' || category(value).kind === 'promise') unsupported();
+    if (ancestors.length >= 128) unsupported();
+    for (let index = 0; index < ancestors.length; index = index + 1) if (ancestors[index] === value) throw new TypeError('Cyclic JSON value');
+    const path = ancestors.slice(); path.push(value);
+    const keys = nativeObject.keys(value);
+    if (nativeArray.isArray(value)) {
+      if (keys.length !== value.length) unsupported();
+      for (let index = 0; index < value.length; index = index + 1) { if (!nativeObject.hasOwn(value, nativeString(index))) unsupported(); jsonValue(value[index], path); }
+    } else for (let index = 0; index < keys.length; index = index + 1) jsonValue(value[keys[index]], path);
+  }
+  const safeJSON = nativeObject.freeze({
+    parse: function (value) { if (arguments.length !== 1) unsupported(); utf8(value, 1048576); return recordTree(nativeJSON.parse(value), 0); },
+    stringify: function (value, replacer, space) {
+      if (arguments.length !== 1 && arguments.length !== 3) unsupported();
+      if (arguments.length === 3 && (replacer !== undefined || typeof space !== 'number' || space < 0 || space > 10 || space % 1 !== 0)) unsupported();
+      jsonValue(value, []);
+      const result = arguments.length === 1 ? nativeJSON.stringify(value) : nativeJSON.stringify(value, undefined, space);
+      if (result !== undefined) utf8(result, 1048576);
+      return result;
+    }
+  });
+  const safeObject = nativeObject.freeze({
+    keys: function (value) { if (arguments.length !== 1) unsupported(); return ownKeys(value); },
+    hasOwn: function (value, name) { if (arguments.length !== 2 || typeof name !== 'string') unsupported(); const keys = ownKeys(value); for (let index = 0; index < keys.length; index = index + 1) if (keys[index] === name) return true; return false; }
+  });
+  const safeArray = nativeObject.freeze({ isArray: function (value) { if (arguments.length !== 1) unsupported(); return nativeArray.isArray(value); } });
+  const safePromise = nativeObject.freeze({
+    resolve: function (value) { if (arguments.length !== 1) unsupported(); if (value !== null && typeof value === 'object' && category(value).kind !== 'promise' && typeof value.then === 'function') unsupported(); return remember(nativePromise.resolve(value), 'promise', true); },
+    reject: function (value) { if (arguments.length !== 1) unsupported(); return remember(nativePromise.reject(value), 'promise', true); },
+    race: function (value) { if (arguments.length !== 1 || !nativeArray.isArray(value) || value.length !== 0 || nativeObject.keys(value).length !== 0) unsupported(); return remember(nativePromise.race(value), 'promise', true); }
+  });
+  function errorConstructor(factory) { return function (message) { if (arguments.length > 1 || arguments.length === 1 && typeof message !== 'string') unsupported(); return remember(arguments.length === 0 ? new factory() : new factory(message), 'error', false); }; }
+  function stringConstructor(value) { if (arguments.length !== 1) unsupported(); return primitive(value); }
+  remember(process, 'facade', true); remember(process.env, 'env', false); remember(process.argv, 'array', false);
+  remember(process.stdin, 'facade', true); remember(process.stdout, 'facade', true); remember(process.stderr, 'facade', true);
+  remember(console, 'facade', true); remember(fs, 'facade', true); remember(path, 'facade', true);
+  remember(safeJSON, 'facade', true); remember(safeObject, 'facade', true); remember(safeArray, 'facade', true); remember(safePromise, 'facade', true);
+  const returned = __vnodeGuest(require, console, process, safeJSON, safeObject, safeArray, safePromise, errorConstructor(Error), errorConstructor(TypeError), errorConstructor(RangeError), errorConstructor(SyntaxError), errorConstructor(ReferenceError), stringConstructor, __vnodeContext.filename, __vnodeContext.directory, __vnodeRules);
+  if (__vnodeContext.selector === 'print') {
+    if (returned !== null && typeof returned !== 'undefined' && typeof returned !== 'string' && typeof returned !== 'number' && typeof returned !== 'boolean') {
+      __vnodeRaw('printRefusal', null, null, null, null, null);
+      unsupported();
+    }
+    logging('stdout', [returned]);
+  }
+  __vnodeRaw('cutoff', null, null, null, null, null);
+})(__vnodeBridge, __vnodeContext, __vnodeEntry);
+`;
+export function buildNodeProgram(source, selector) {
+    const names = "require,console,process,JSON,Object,Array,Promise,Error,TypeError,RangeError,SyntaxError,ReferenceError,String,__vnodeFilename,__vnodeDirectory,__vnodeRules";
+    const lowered = lowerNodeSource(source, selector);
+    const body = selector === "print" ? "return (\n" + lowered + "\n);" : lowered;
+    const bindings = selector === "file" ? "const __filename = __vnodeFilename; const __dirname = __vnodeDirectory;\n" : "";
+    const marker = "__vnodeBridge('entry', null, null, null, null, null);\n";
+    const program = "const __vnodeEntry = function(" + names + ") {\n" + marker + bindings + body + "\n};\n" + library;
+    return text(program, nodeLimits.sourceBytes, "combined interpreted source");
+}
+//# sourceMappingURL=program.js.map

package/dist/safe-bash/commands/node/program.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.js","sourceRoot":"","sources":["../../../src/commands/node/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAqB,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;EASxB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgMf,CAAC;AAEF,MAAM,UAAU,gBAAgB,CAAC,MAAc,EAAE,QAAsB;IACrE,MAAM,KAAK,GAAG,8JAA8J,CAAC;IAC7K,MAAM,OAAO,GAAG,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClD,MAAM,IAAI,GAAG,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,YAAY,GAAG,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;IAC9E,MAAM,QAAQ,GAAG,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,2EAA2E,CAAC,CAAC,CAAC,EAAE,CAAC;IACxH,MAAM,MAAM,GAAG,yDAAyD,CAAC;IACzE,MAAM,OAAO,GAAG,gCAAgC,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,IAAI,GAAG,QAAQ,GAAG,OAAO,CAAC;IACnH,OAAO,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,EAAE,6BAA6B,CAAC,CAAC;AAC9E,CAAC"}

package/dist/safe-bash/commands/node/rules.d.ts

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

package/dist/safe-bash/commands/node/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/commands/node/rules.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,QAoI1B,CAAC"}

package/dist/safe-bash/commands/node/rules.js

@@ -0,0 +1,134 @@
+export const nodeValueRules = String.raw `
+  const valueRecords = [];
+  function remember(value, kind, locked) {
+    if (value === null || typeof value !== 'object') return value;
+    for (let index = 0; index < valueRecords.length; index = index + 1) if (valueRecords[index].value === value) return value;
+    if (valueRecords.length >= 100000) unsupported();
+    valueRecords.push({value: value, kind: kind, locked: locked});
+    return value;
+  }
+  function category(value) {
+    if (typeof value !== 'object' || value === null) return {kind: typeof value, locked: true};
+    for (let index = 0; index < valueRecords.length; index = index + 1) if (valueRecords[index].value === value) return valueRecords[index];
+    if (nativeArray.isArray(value)) { remember(value, 'array', false); return category(value); }
+    if (typeof value.then === 'function') { remember(value, 'promise', true); return category(value); }
+    if (typeof value.name === 'string' && typeof value.message === 'string') { remember(value, 'error', false); return category(value); }
+    unsupported();
+  }
+  function recordTree(value, depth) {
+    if (value === null || typeof value !== 'object') return value;
+    if (depth > 128) unsupported();
+    remember(value, nativeArray.isArray(value) ? 'array' : 'record', false);
+    const keys = nativeObject.keys(value);
+    for (let index = 0; index < keys.length; index = index + 1) recordTree(value[keys[index]], depth + 1);
+    return value;
+  }
+  function propertyKey(value) { if (typeof value !== 'string' && typeof value !== 'number') unsupported(); return nativeString(value); }
+  function computedKey(value) { if (typeof value !== 'string') unsupported(); return value; }
+  function arrayIndex(key) {
+    if (key === '') return -1;
+    const index = +key;
+    if (index < 0 || index % 1 !== 0 || nativeString(index) !== key) return -1;
+    return index;
+  }
+  function primitiveValue(value) { if (value !== null && (typeof value === 'object' || typeof value === 'function')) unsupported(); return value; }
+  function detached() { unsupported(); }
+  function getValue(object, rawKey) {
+    const key = propertyKey(rawKey);
+    if (object === null || object === undefined) throw new TypeError('Cannot read a nullish value');
+    const record = category(object);
+    if (typeof object === 'string') {
+      if (key === 'length') return object.length;
+      const index = arrayIndex(key); if (index >= 0) return object[index];
+      if (key === 'slice' || key === 'trim') return detached;
+      unsupported();
+    }
+    if (typeof object === 'function') { if (key === 'name' || key === 'length') return object[key]; unsupported(); }
+    if (record.kind === 'array') {
+      if (key === 'length') return object.length;
+      const index = arrayIndex(key); if (index >= 0) return index < object.length ? object[index] : undefined;
+      if (key === 'push' || key === 'map') return detached;
+      unsupported();
+    }
+    if (record.kind === 'promise') { if (key === 'then' || key === 'catch' || key === 'finally') return detached; unsupported(); }
+    if (record.kind === 'error' && key !== 'name' && key !== 'message' && key !== 'code' && key !== 'errno' && key !== 'path' && key !== 'syscall' && key !== 'dest') unsupported();
+    if (record.kind === 'record' || record.kind === 'facade' || record.kind === 'env' || record.kind === 'error') return nativeObject.hasOwn(object, key) ? object[key] : undefined;
+    unsupported();
+  }
+  function reference(object, rawKey, read) { const key = propertyKey(rawKey); return {object: object, key: key, value: read ? getValue(object, key) : undefined}; }
+  function assign(target, value) {
+    const object = target.object; const key = target.key; const record = category(object);
+    if (record.locked || object === null || typeof object !== 'object') unsupported();
+    if (record.kind === 'array') {
+      if (key === 'length') { if (typeof value !== 'number' || value < 0 || value % 1 !== 0 || value > object.length) unsupported(); }
+      else { const index = arrayIndex(key); if (index < 0 || index > object.length || object === process.argv && typeof value !== 'string') unsupported(); }
+    } else if (record.kind === 'env') { if (typeof value !== 'string' || key.indexOf('\u0000') !== -1 || key.indexOf('=') !== -1 || value.indexOf('\u0000') !== -1) unsupported(); }
+    else if (record.kind === 'error') { if (key !== 'name' && key !== 'message' && key !== 'code' && key !== 'errno' && key !== 'path' && key !== 'syscall' && key !== 'dest') unsupported(); }
+    else if (record.kind !== 'record') unsupported();
+    object[key] = value; return value;
+  }
+  function binary(operator, left, right) {
+    if ((operator === '==' || operator === '!=') && left !== null && right !== null && (typeof left === 'object' || typeof left === 'function') && (typeof right === 'object' || typeof right === 'function')) return operator === '==' ? left === right : left !== right;
+    primitiveValue(left); primitiveValue(right);
+    if (operator === '+') return left + right;
+    if (operator === '-') return left - right;
+    if (operator === '*') return left * right;
+    if (operator === '/') return left / right;
+    if (operator === '%') return left % right;
+    if (operator === '**') return left ** right;
+    if (operator === '<') return left < right;
+    if (operator === '>') return left > right;
+    if (operator === '<=') return left <= right;
+    if (operator === '>=') return left >= right;
+    if (operator === '==') return left == right;
+    if (operator === '!=') return left != right;
+    unsupported();
+  }
+  function unary(operator, value) { primitiveValue(value); return operator === '+' ? +value : -value; }
+  function compound(target, operator, value) { return assign(target, binary(operator, target.value, value)); }
+  function update(target, delta, prefix) { const before = unary('+', target.value); const after = before + delta; assign(target, after); return prefix ? after : before; }
+  function updateVariable(getter, setter, delta, prefix) { const before = unary('+', getter()); const after = before + delta; setter(after); return prefix ? after : before; }
+  function remove(object, rawKey) { const key = propertyKey(rawKey); const record = category(object); if (record.locked || record.kind !== 'record' && record.kind !== 'env') unsupported(); return delete object[key]; }
+  function callable(value) { if (typeof value !== 'function') unsupported(); return value; }
+  function adopt(value) { if (value !== null && typeof value === 'object' && category(value).kind !== 'promise' && typeof value.then === 'function') unsupported(); return value; }
+  function reaction(callback, noArguments) { if (callback === undefined) return undefined; callable(callback); return function (value) { return adopt(noArguments ? callback() : callback(value)); }; }
+  function callValue(callback, args) { if (args.length > 16) unsupported(); return callable(callback)(...args); }
+  function method(object, rawKey, args) {
+    const key = propertyKey(rawKey); if (args.length > 16) unsupported();
+    if (object === null || object === undefined) throw new TypeError('Cannot call a nullish value');
+    const record = category(object);
+    if (typeof object === 'string') {
+      if (key === 'trim' && args.length === 0) return object.trim();
+      if (key === 'slice' && (args.length === 1 || args.length === 2)) {
+        for (let index = 0; index < args.length; index = index + 1) if (typeof args[index] !== 'number' || args[index] % 1 !== 0) unsupported();
+        return args.length === 1 ? object.slice(args[0]) : object.slice(args[0], args[1]);
+      }
+      unsupported();
+    }
+    if (record.kind === 'array') {
+      if (key === 'push') { for (let index = 0; index < args.length; index = index + 1) assign(reference(object, object.length, false), args[index]); return object.length; }
+      if (key === 'map' && args.length === 1) {
+        callable(args[0]); const length = object.length; const result = remember([], 'array', false);
+        for (let index = 0; index < length; index = index + 1) { if (!nativeObject.hasOwn(object, nativeString(index))) unsupported(); result.push(args[0](object[index], index, object)); }
+        return result;
+      }
+      unsupported();
+    }
+    if (record.kind === 'promise') {
+      if (key === 'then' && args.length <= 2) return remember(object.then(reaction(args[0], false), reaction(args[1], false)), 'promise', true);
+      if (key === 'catch' && args.length === 1) return remember(object.catch(reaction(callable(args[0]), false)), 'promise', true);
+      if (key === 'finally' && args.length === 1) return remember(object.finally(reaction(callable(args[0]), true)), 'promise', true);
+      unsupported();
+    }
+    return callValue(getValue(object, key), args);
+  }
+  function unbound(name) { throw new ReferenceError(name + ' is not defined'); }
+  function ownKeys(value) {
+    if (value === null || typeof value !== 'object') unsupported();
+    const kind = category(value).kind; if (kind !== 'array' && kind !== 'record' && kind !== 'env' && kind !== 'facade' && kind !== 'error') unsupported();
+    const keys = nativeObject.keys(value); if (kind !== 'error') return keys;
+    const result = []; for (let index = 0; index < keys.length; index = index + 1) if (keys[index] === 'name' || keys[index] === 'message' || keys[index] === 'code' || keys[index] === 'errno' || keys[index] === 'path' || keys[index] === 'syscall' || keys[index] === 'dest') result.push(keys[index]); return result;
+  }
+  const __vnodeRules = nativeObject.freeze({adopt: adopt, get: getValue, key: computedKey, reference: reference, assign: assign, binary: binary, unary: unary, compound: compound, update: update, updateVariable: updateVariable, remove: remove, call: callValue, method: method, unbound: unbound, object: function (value) { return remember(value, 'record', false); }, array: function (value) { return remember(value, 'array', false); }});
+`;
+//# sourceMappingURL=rules.js.map

package/dist/safe-bash/commands/node/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../../src/commands/node/rules.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoIvC,CAAC"}

package/dist/safe-bash/commands/node/safejs.d.ts

@@ -0,0 +1,4 @@
+import type { CommandDefinition } from "../../contracts/command.js";
+import type { NodeSafeJsCommandOptions } from "./types.js";
+export declare function createSafeJsNodeCommand<Budget>(options: NodeSafeJsCommandOptions<Budget>): CommandDefinition;
+//# sourceMappingURL=safejs.d.ts.map

package/dist/safe-bash/commands/node/safejs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safejs.d.ts","sourceRoot":"","sources":["../../../src/commands/node/safejs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAiC3D,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GAAG,iBAAiB,CAmC5G"}

package/dist/safe-bash/commands/node/safejs.js

@@ -0,0 +1,79 @@
+import { UsageError } from "../internal.js";
+import { createSafeJsCommands } from "../safejs/index.js";
+function invocation(args) {
+    let source;
+    let print = false;
+    let index = 0;
+    for (; index < args.length; index++) {
+        const argument = args[index];
+        if (argument === "--") {
+            index++;
+            break;
+        }
+        if (argument === "-h" || argument === "--help")
+            return { file: "-", args: [], print: false, help: true };
+        if (argument === "--input-type" || argument.startsWith("--input-type=")) {
+            const value = argument === "--input-type" ? args[++index] : argument.slice(13);
+            if (value !== "module")
+                throw new UsageError("SafeJS node supports only --input-type=module");
+            continue;
+        }
+        const mode = argument === "--eval" || argument.startsWith("--eval=") || argument.startsWith("-e") ? "eval"
+            : argument === "--print" || argument.startsWith("--print=") || argument.startsWith("-p") ? "print" : undefined;
+        if (mode) {
+            if (source !== undefined)
+                throw new UsageError("conflicting source selectors");
+            print = mode === "print";
+            const equal = argument.indexOf("=");
+            source = argument.startsWith("--") ? equal >= 0 ? argument.slice(equal + 1) : args[++index]
+                : argument.length > 2 ? argument.slice(2) : args[++index];
+            if (source === undefined)
+                throw new UsageError(`${argument} requires JavaScript source`);
+            continue;
+        }
+        if (argument !== "-" && argument.startsWith("-"))
+            throw new UsageError(`unsupported node option '${argument}'`);
+        break;
+    }
+    if (source !== undefined)
+        return { source, file: print ? "<node -p>" : "<node -e>", args: args.slice(index), print, help: false };
+    return { file: args[index] ?? "-", args: args.slice(index + 1), print: false, help: false };
+}
+export function createSafeJsNodeCommand(options) {
+    const definitions = createSafeJsCommands(options, {
+        name: "node",
+        description: "Execute JavaScript with an injected SafeJS runtime and virtual I/O",
+        help: "Usage: node [-e SOURCE | -p EXPRESSION | FILE | -] [ARG...]\nExecutes with the injected SafeJS interpreter; no native Node.js process.\nSupports --eval, --print, --input-type=module and -- before operands.\nNo source operand reads stdin. Files and inline source leave stdin for guest data.\nUse async imports from fs or require(\"node:fs/promises\").\nNative modules, synchronous fs and local module loading are not supported.\n",
+        invocation,
+        prepare(source, selected, modules) {
+            const command = modules.command;
+            const stdio = modules.stdio;
+            const fs = modules.fs;
+            const processModule = {
+                argv: ["/virtual/bin/node", ...(selected.source === undefined ? [selected.file] : []), ...selected.args],
+                env: command.env,
+                cwd: options.runtime.declareHostOperation(() => command.cwd, "read-side-effect"),
+                exitCode: 0,
+                stdin: { readText: stdio.readText, readBytes: stdio.readBytes },
+                stdout: { write: stdio.write },
+                stderr: { write: stdio.error },
+            };
+            modules.fs = { ...fs, default: fs };
+            const requiredModules = new Map([["fs/promises", fs], ["node:fs/promises", fs]]);
+            return {
+                source: (selected.print ? `console.log((\n${source}\n));` : source) + "\n;__safeBashSetExitCode(process.exitCode);",
+                bindings: {
+                    process: processModule, __safeBashSetExitCode: command.setExitCode,
+                    require: options.runtime.declareHostOperation((name) => {
+                        const module = typeof name === "string" ? requiredModules.get(name) : undefined;
+                        if (!module)
+                            throw new TypeError("Unsupported node module; use fs/promises or node:fs/promises");
+                        return module;
+                    }, "read-side-effect"),
+                },
+            };
+        },
+    });
+    return Object.freeze(definitions[0]);
+}
+//# sourceMappingURL=safejs.js.map

package/dist/safe-bash/commands/node/safejs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safejs.js","sourceRoot":"","sources":["../../../src/commands/node/safejs.ts"],"names":[],"mappings":"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"}

package/dist/safe-bash/commands/node/types.d.ts

@@ -0,0 +1,143 @@
+import type { CommandDefinition } from "../../contracts/command.js";
+import type { SafeJsCommandLimits, SafeJsRuntime } from "../safejs/types.js";
+export declare const NODE_PROFILE: "NP1-CJS-WRQ-L-SYNC-1";
+export declare const nodeLimits: Readonly<{
+    sourceBytes: 262144;
+    contextBytes: 65536;
+    pathBytes: 1024;
+    metadataBytes: 8192;
+    errorBytes: 1024;
+    operations: 128;
+    frames: 4096;
+    wakes: 8192;
+    operationBytes: 1048576;
+    readBytes: 4194304;
+    writeBytes: 4194304;
+    outputBytes: 1048576;
+    jsonBytes: 1048576;
+    jsonEntries: 32;
+    memoryBytes: 16777216;
+    diagnosticReserve: 1048576;
+    sabBytes: 197056;
+    admissionMs: 5000;
+    steps: 100000;
+    callDepth: 128;
+    oldGenerationMiB: 32;
+    youngGenerationMiB: 8;
+    codeMiB: 8;
+    stackMiB: 4;
+}>;
+export interface NodeGrants {
+    readonly sourceRead?: boolean;
+    readonly dataRead?: boolean;
+    readonly dataWrite?: boolean;
+    readonly jsonModules?: boolean;
+    readonly stdinRead?: boolean;
+    readonly stdoutWrite?: boolean;
+    readonly stderrWrite?: boolean;
+}
+export type NodeSelector = "eval" | "print" | "file" | "stdin";
+export interface NodeSourceRequest {
+    readonly profile: typeof NODE_PROFILE;
+    readonly selector: NodeSelector;
+    readonly source: string;
+    readonly program: string;
+    readonly filename: string;
+    readonly cwd: string;
+    readonly argv: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+    readonly grants: Readonly<Required<NodeGrants>>;
+    readonly limits: typeof nodeLimits;
+}
+export type NodeOperation = "authorizeModule" | "authorizeJson" | "readText" | "writeText" | "writeOutput" | "path";
+export interface NodeHostRequest {
+    readonly sequence: number;
+    readonly op: NodeOperation;
+    readonly authority: "module" | "json" | "data" | "stdin" | "stdout" | "stderr" | "path";
+    readonly path: string | null;
+    readonly flag: "r" | "w" | "wx" | null;
+    readonly text: string | null;
+    readonly moduleKey: string | null;
+}
+export interface NodeGuestError {
+    readonly name: string;
+    readonly message: string;
+    readonly code: string;
+    readonly errno: number | null;
+    readonly path: string | null;
+    readonly syscall: string | null;
+    readonly dest: string | null;
+}
+export interface NodeHostResponse {
+    readonly sequence: number;
+    readonly kind: "void" | "text" | "fsError" | "unsupported" | "denied";
+    readonly text: string | null;
+    readonly error: NodeGuestError | null;
+    readonly cacheKey: {
+        readonly namespace: number;
+        readonly path: string;
+    } | null;
+}
+export interface NodeReason {
+    readonly present: true;
+    readonly value: unknown;
+}
+export interface NodeObservation {
+    readonly state: "captured" | "unknown";
+    readonly fault: boolean;
+    readonly name: string | null;
+    readonly message: string | null;
+    readonly code: string | null;
+}
+export interface NodeCompletion {
+    readonly kind: "entryReturned" | "guestFailure" | "profileFailure";
+    readonly observation: NodeObservation;
+}
+export interface NodeRetirement {
+    readonly acquisition: "none" | "exited";
+    readonly exitCode: number | null;
+}
+export interface NodeHostServices {
+    readonly signal: AbortSignal;
+    readonly request: (request: NodeHostRequest) => Promise<NodeHostResponse>;
+    readonly delivered: (sequence: number) => void;
+    readonly reserve: (label: string, bytes: number) => () => void;
+    readonly cutoff: () => void;
+    readonly fail: (reason: NodeReason) => void;
+    readonly stopProfile: (reason: NodeReason) => void;
+    readonly job: <Value>(start: () => Value | PromiseLike<Value>) => Promise<Value>;
+}
+export interface NodeSession {
+    readonly start: () => Promise<NodeCompletion>;
+    readonly cancel: (reason: NodeReason) => void;
+    readonly retire: () => Promise<NodeRetirement>;
+}
+export interface NodeRuntimeProvider {
+    readonly profile: typeof NODE_PROFILE;
+    readonly identity: string;
+    readonly prepare: (request: NodeSourceRequest, services: NodeHostServices) => NodeSession;
+}
+export interface NodeProviderCommandOptions {
+    readonly provider: NodeRuntimeProvider;
+    readonly grants?: NodeGrants;
+    readonly runtime?: never;
+    readonly limits?: never;
+}
+export interface NodeSafeJsCommandOptions<Budget = unknown> {
+    readonly runtime: SafeJsRuntime<Budget>;
+    readonly limits?: Partial<SafeJsCommandLimits>;
+    readonly provider?: never;
+    readonly grants?: never;
+}
+export type NodeCommandOptions<Budget = unknown> = NodeProviderCommandOptions | NodeSafeJsCommandOptions<Budget>;
+export type NodeCommandFactory = (options: NodeCommandOptions) => CommandDefinition;
+export declare class NodeProfileError extends Error {
+    readonly resource: string;
+    readonly code = "ERR_VNODE_PROFILE";
+    constructor(resource: string);
+}
+export declare class NodeUsageError extends Error {
+    readonly code = "ERR_VNODE_UNSUPPORTED";
+    constructor(message: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/safe-bash/commands/node/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/commands/node/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE7E,eAAO,MAAM,YAAY,EAAG,sBAA+B,CAAC;AAC5D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;EAA4d,CAAC;AAEpf,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AACD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;AAC/D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,OAAO,YAAY,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,OAAO,UAAU,CAAC;CACpC;AACD,MAAM,MAAM,aAAa,GAAG,iBAAiB,GAAG,eAAe,GAAG,UAAU,GAAG,WAAW,GAAG,aAAa,GAAG,MAAM,CAAC;AACpH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,aAAa,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AACD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AACD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,QAAQ,CAAC;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACjF;AACD,MAAM,WAAW,UAAU;IAAG,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CAAE;AAChF,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AACD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,cAAc,GAAG,gBAAgB,CAAC;IACnE,QAAQ,CAAC,WAAW,EAAE,eAAe,CAAC;CACvC;AACD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AACD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC1E,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,IAAI,CAAC;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;IAC5C,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;CAClF;AACD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;CAChD;AACD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,YAAY,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,gBAAgB,KAAK,WAAW,CAAC;CAC3F;AACD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC;CACzB;AACD,MAAM,WAAW,wBAAwB,CAAC,MAAM,GAAG,OAAO;IACxD,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC/C,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC;CACzB;AACD,MAAM,MAAM,kBAAkB,CAAC,MAAM,GAAG,OAAO,IAAI,0BAA0B,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC;AACjH,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE,kBAAkB,KAAK,iBAAiB,CAAC;AAEpF,qBAAa,gBAAiB,SAAQ,KAAK;IAE7B,QAAQ,CAAC,QAAQ,EAAE,MAAM;IADrC,QAAQ,CAAC,IAAI,uBAAuB;gBACf,QAAQ,EAAE,MAAM;CACtC;AACD,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,2BAA2B;gBAC5B,OAAO,EAAE,MAAM;CAC5B"}

package/dist/safe-bash/commands/node/types.js

@@ -0,0 +1,16 @@
+export const NODE_PROFILE = "NP1-CJS-WRQ-L-SYNC-1";
+export const nodeLimits = Object.freeze({ sourceBytes: 262144, contextBytes: 65536, pathBytes: 1024, metadataBytes: 8192, errorBytes: 1024, operations: 128, frames: 4096, wakes: 8192, operationBytes: 1048576, readBytes: 4194304, writeBytes: 4194304, outputBytes: 1048576, jsonBytes: 1048576, jsonEntries: 32, memoryBytes: 16777216, diagnosticReserve: 1048576, sabBytes: 197056, admissionMs: 5000, steps: 100000, callDepth: 128, oldGenerationMiB: 32, youngGenerationMiB: 8, codeMiB: 8, stackMiB: 4 });
+export class NodeProfileError extends Error {
+    resource;
+    code = "ERR_VNODE_PROFILE";
+    constructor(resource) {
+        super("Restricted node profile: " + resource);
+        this.resource = resource;
+        this.name = "NodeProfileError";
+    }
+}
+export class NodeUsageError extends Error {
+    code = "ERR_VNODE_UNSUPPORTED";
+    constructor(message) { super(message); this.name = "NodeUsageError"; }
+}
+//# sourceMappingURL=types.js.map