@presidio-dev/hai-guardrails
Version:
A set of guards for LLM Apps
1,375 lines (1,349 loc) • 475 kB
JavaScript
import { createRequire } from "node:module";
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __require = /* @__PURE__ */ createRequire(import.meta.url);
// node_modules/piscina/package.json
var require_package = __commonJS((exports, module) => {
module.exports = {
name: "piscina",
version: "5.1.1",
description: "A fast, efficient Node.js Worker Thread Pool implementation",
main: "./dist/main.js",
types: "./dist/index.d.ts",
exports: {
types: "./dist/index.d.ts",
import: "./dist/esm-wrapper.mjs",
require: "./dist/main.js"
},
engines: {
node: ">=20.x"
},
scripts: {
build: "tsc && gen-esm-wrapper . dist/esm-wrapper.mjs",
lint: "eslint",
test: "node scripts/run-tests.js --pattern='test/**/*test.ts'",
"test:ci": "npm run lint && npm run build && npm run test:coverage",
"test:coverage": "node scripts/run-tests.js --coverage --pattern='test/**/*test.ts'",
prepack: "npm run build",
benchmark: "npm run benchmark:queue && npm run benchmark:piscina",
"benchmark:piscina": "npm run benchmark:default && npm run benchmark:queue:fixed && npm run benchmark:default:comparison",
"benchmark:default": "node benchmark/simple-benchmark.js",
"benchmark:default:async": "node benchmark/simple-benchmark.js",
"benchmark:default:comparison": "node benchmark/piscina-queue-comparison.js",
"benchmark:queue": "npm run benchmark:queue:comparison",
"benchmark:queue:fixed": "node benchmark/simple-benchmark-fixed-queue.js",
"benchmark:queue:comparison": "node benchmark/queue-comparison.js"
},
repository: {
type: "git",
url: "git+https://github.com/piscinajs/piscina.git"
},
keywords: [
"fast",
"worker threads",
"thread pool",
"wade wilson"
],
author: "James M Snell <jasnell@gmail.com>",
contributors: [
"Anna Henningsen <anna@addaleax.net>",
"Matteo Collina <matteo.collina@gmail.com>",
"Carlos Fuentes <me@metcoder.dev>"
],
license: "MIT",
devDependencies: {
"@types/node": "^24.0.1",
"abort-controller": "^3.0.0",
c8: "^10.1.2",
"concat-stream": "^2.0.0",
eslint: "^9.16.0",
"gen-esm-wrapper": "^1.1.1",
glob: "^11.0.2",
neostandard: "^0.12.0",
tinybench: "^4.0.1",
tsx: "^4.19.4",
typescript: "5.8.3"
},
optionalDependencies: {
"@napi-rs/nice": "^1.0.1"
},
bugs: {
url: "https://github.com/piscinajs/piscina/issues"
},
homepage: "https://github.com/piscinajs/piscina#readme",
directories: {
example: "examples",
test: "test"
}
};
});
// node_modules/piscina/dist/symbols.js
var require_symbols = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.kFieldCount = exports.kResponseCountField = exports.kRequestCountField = exports.kQueueOptions = exports.kValue = exports.kTransferable = exports.kWorkerData = exports.kMovable = undefined;
exports.kMovable = Symbol("Piscina.kMovable");
exports.kWorkerData = Symbol("Piscina.kWorkerData");
exports.kTransferable = Symbol.for("Piscina.transferable");
exports.kValue = Symbol.for("Piscina.valueOf");
exports.kQueueOptions = Symbol.for("Piscina.queueOptions");
exports.kRequestCountField = 0;
exports.kResponseCountField = 1;
exports.kFieldCount = 2;
});
// node_modules/piscina/dist/common.js
var require_common = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.commonState = exports.READY = undefined;
exports.isTransferable = isTransferable;
exports.isMovable = isMovable;
exports.markMovable = markMovable;
exports.maybeFileURLToPath = maybeFileURLToPath;
exports.getAvailableParallelism = getAvailableParallelism;
var node_url_1 = __require("node:url");
var node_os_1 = __require("node:os");
var symbols_1 = require_symbols();
exports.READY = "_WORKER_READY";
function isTransferable(value) {
return value != null && typeof value === "object" && symbols_1.kTransferable in value && symbols_1.kValue in value;
}
function isMovable(value) {
return isTransferable(value) && value[symbols_1.kMovable] === true;
}
function markMovable(value) {
Object.defineProperty(value, symbols_1.kMovable, {
enumerable: false,
configurable: true,
writable: true,
value: true
});
}
exports.commonState = {
isWorkerThread: false,
workerData: undefined
};
function maybeFileURLToPath(filename) {
return filename.startsWith("file:") ? (0, node_url_1.fileURLToPath)(new node_url_1.URL(filename)) : filename;
}
function getAvailableParallelism() {
return (0, node_os_1.availableParallelism)();
}
});
// node_modules/piscina/dist/task_queue/array_queue.js
var require_array_queue = __commonJS((exports) => {
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ArrayTaskQueue = undefined;
var node_assert_1 = __importDefault(__require("node:assert"));
class ArrayTaskQueue {
constructor() {
this.tasks = [];
}
get size() {
return this.tasks.length;
}
shift() {
var _a;
return (_a = this.tasks.shift()) !== null && _a !== undefined ? _a : null;
}
push(task) {
this.tasks.push(task);
}
remove(task) {
const index = this.tasks.indexOf(task);
node_assert_1.default.notStrictEqual(index, -1);
this.tasks.splice(index, 1);
}
}
exports.ArrayTaskQueue = ArrayTaskQueue;
});
// node_modules/piscina/dist/task_queue/fixed_queue.js
var require_fixed_queue = __commonJS((exports) => {
var __classPrivateFieldGet = exports && exports.__classPrivateFieldGet || function(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __classPrivateFieldSet = exports && exports.__classPrivateFieldSet || function(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
};
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
var _FixedQueue_size;
Object.defineProperty(exports, "__esModule", { value: true });
exports.FixedQueue = undefined;
var node_assert_1 = __importDefault(__require("node:assert"));
var kSize = 2048;
var kMask = kSize - 1;
class FixedCircularBuffer {
constructor() {
this.bottom = 0;
this.top = 0;
this.list = new Array(kSize);
this.next = null;
}
isEmpty() {
return this.top === this.bottom;
}
isFull() {
return (this.top + 1 & kMask) === this.bottom;
}
push(data) {
this.list[this.top] = data;
this.top = this.top + 1 & kMask;
}
shift() {
const nextItem = this.list[this.bottom];
if (nextItem === undefined) {
return null;
}
this.list[this.bottom] = undefined;
this.bottom = this.bottom + 1 & kMask;
return nextItem;
}
remove(task) {
const indexToRemove = this.list.indexOf(task);
node_assert_1.default.notStrictEqual(indexToRemove, -1);
let curr = indexToRemove;
while (true) {
const next = curr + 1 & kMask;
this.list[curr] = this.list[next];
if (this.list[curr] === undefined) {
break;
}
if (next === indexToRemove) {
this.list[curr] = undefined;
break;
}
curr = next;
}
this.top = this.top - 1 & kMask;
}
}
class FixedQueue {
constructor() {
_FixedQueue_size.set(this, 0);
this.head = this.tail = new FixedCircularBuffer;
}
isEmpty() {
return this.head.isEmpty();
}
push(data) {
var _a;
if (this.head.isFull()) {
this.head = this.head.next = new FixedCircularBuffer;
}
this.head.push(data);
__classPrivateFieldSet(this, _FixedQueue_size, (_a = __classPrivateFieldGet(this, _FixedQueue_size, "f"), _a++, _a), "f");
}
shift() {
var _a;
const tail = this.tail;
const next = tail.shift();
if (next !== null)
__classPrivateFieldSet(this, _FixedQueue_size, (_a = __classPrivateFieldGet(this, _FixedQueue_size, "f"), _a--, _a), "f");
if (tail.isEmpty() && tail.next !== null) {
this.tail = tail.next;
tail.next = null;
}
return next;
}
remove(task) {
var _a;
let prev = null;
let buffer = this.tail;
while (true) {
if (buffer.list.includes(task)) {
buffer.remove(task);
__classPrivateFieldSet(this, _FixedQueue_size, (_a = __classPrivateFieldGet(this, _FixedQueue_size, "f"), _a--, _a), "f");
break;
}
if (buffer.next === null)
break;
prev = buffer;
buffer = buffer.next;
}
if (buffer.isEmpty()) {
if (prev === null) {
if (buffer.next !== null)
this.tail = buffer.next;
} else {
if (buffer.next === null) {
this.head = prev;
} else {
prev.next = buffer.next;
}
}
}
}
get size() {
return __classPrivateFieldGet(this, _FixedQueue_size, "f");
}
}
exports.FixedQueue = FixedQueue;
_FixedQueue_size = new WeakMap;
});
// node_modules/piscina/dist/task_queue/index.js
var require_task_queue = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.TaskInfo = exports.FixedQueue = exports.ArrayTaskQueue = undefined;
exports.isTaskQueue = isTaskQueue;
var node_perf_hooks_1 = __require("node:perf_hooks");
var node_async_hooks_1 = __require("node:async_hooks");
var common_1 = require_common();
var symbols_1 = require_symbols();
var array_queue_1 = require_array_queue();
Object.defineProperty(exports, "ArrayTaskQueue", { enumerable: true, get: function() {
return array_queue_1.ArrayTaskQueue;
} });
var fixed_queue_1 = require_fixed_queue();
Object.defineProperty(exports, "FixedQueue", { enumerable: true, get: function() {
return fixed_queue_1.FixedQueue;
} });
function isTaskQueue(value) {
return typeof value === "object" && value !== null && "size" in value && typeof value.shift === "function" && typeof value.remove === "function" && typeof value.push === "function";
}
var taskIdCounter = 0;
class TaskInfo extends node_async_hooks_1.AsyncResource {
constructor(task, transferList, filename, name, callback, abortSignal, triggerAsyncId) {
super("Piscina.Task", { requireManualDestroy: true, triggerAsyncId });
this.workerInfo = null;
this.aborted = false;
this._abortListener = null;
this.callback = callback;
this.task = task;
this.transferList = transferList;
if ((0, common_1.isMovable)(task)) {
if (this.transferList == null) {
this.transferList = [];
}
this.transferList = this.transferList.concat(task[symbols_1.kTransferable]);
this.task = task[symbols_1.kValue];
}
this.filename = filename;
this.name = name;
this.taskId = taskIdCounter++;
this.abortSignal = abortSignal;
this.created = node_perf_hooks_1.performance.now();
this.started = 0;
}
set abortListener(value) {
this._abortListener = () => {
this.aborted = true;
value();
};
}
get abortListener() {
return this._abortListener;
}
releaseTask() {
const ret = this.task;
this.task = null;
return ret;
}
done(err, result) {
this.runInAsyncScope(this.callback, null, err, result);
this.emitDestroy();
if (this.abortSignal && this.abortListener) {
if ("removeEventListener" in this.abortSignal && this.abortListener) {
this.abortSignal.removeEventListener("abort", this.abortListener);
} else {
this.abortSignal.off("abort", this.abortListener);
}
}
}
get [symbols_1.kQueueOptions]() {
var _a, _b;
return (_b = (_a = this.task) === null || _a === undefined ? undefined : _a[symbols_1.kQueueOptions]) !== null && _b !== undefined ? _b : null;
}
get interface() {
return {
taskId: this.taskId,
filename: this.filename,
name: this.name,
created: this.created,
isAbortable: this.abortSignal !== null,
[symbols_1.kQueueOptions]: this[symbols_1.kQueueOptions]
};
}
}
exports.TaskInfo = TaskInfo;
});
// node_modules/piscina/dist/errors.js
var require_errors = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Errors = undefined;
exports.Errors = {
ThreadTermination: () => new Error("Terminating worker thread"),
FilenameNotProvided: () => new Error("filename must be provided to run() or in options object"),
TaskQueueAtLimit: () => new Error("Task queue is at limit"),
NoTaskQueueAvailable: () => new Error("No task queue available and all Workers are busy"),
CloseTimeout: () => new Error("Close operation timed out")
};
});
// node_modules/piscina/dist/histogram.js
var require_histogram = __commonJS((exports) => {
var __classPrivateFieldSet = exports && exports.__classPrivateFieldSet || function(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
};
var __classPrivateFieldGet = exports && exports.__classPrivateFieldGet || function(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _PiscinaHistogramHandler_runTime;
var _PiscinaHistogramHandler_waitTime;
Object.defineProperty(exports, "__esModule", { value: true });
exports.PiscinaHistogramHandler = undefined;
var node_perf_hooks_1 = __require("node:perf_hooks");
class PiscinaHistogramHandler {
constructor() {
_PiscinaHistogramHandler_runTime.set(this, undefined);
_PiscinaHistogramHandler_waitTime.set(this, undefined);
__classPrivateFieldSet(this, _PiscinaHistogramHandler_runTime, (0, node_perf_hooks_1.createHistogram)(), "f");
__classPrivateFieldSet(this, _PiscinaHistogramHandler_waitTime, (0, node_perf_hooks_1.createHistogram)(), "f");
}
get runTimeSummary() {
return PiscinaHistogramHandler.createHistogramSummary(__classPrivateFieldGet(this, _PiscinaHistogramHandler_runTime, "f"));
}
get waitTimeSummary() {
return PiscinaHistogramHandler.createHistogramSummary(__classPrivateFieldGet(this, _PiscinaHistogramHandler_waitTime, "f"));
}
get runTimeCount() {
return __classPrivateFieldGet(this, _PiscinaHistogramHandler_runTime, "f").count;
}
recordRunTime(value) {
__classPrivateFieldGet(this, _PiscinaHistogramHandler_runTime, "f").record(PiscinaHistogramHandler.toHistogramIntegerNano(value));
}
recordWaitTime(value) {
__classPrivateFieldGet(this, _PiscinaHistogramHandler_waitTime, "f").record(PiscinaHistogramHandler.toHistogramIntegerNano(value));
}
resetWaitTime() {
__classPrivateFieldGet(this, _PiscinaHistogramHandler_waitTime, "f").reset();
}
resetRunTime() {
__classPrivateFieldGet(this, _PiscinaHistogramHandler_runTime, "f").reset();
}
static createHistogramSummary(histogram) {
const { mean, stddev, min, max } = histogram;
return {
average: mean / 1000,
mean: mean / 1000,
stddev,
min: min / 1000,
max: max / 1000,
p0_001: histogram.percentile(0.001) / 1000,
p0_01: histogram.percentile(0.01) / 1000,
p0_1: histogram.percentile(0.1) / 1000,
p1: histogram.percentile(1) / 1000,
p2_5: histogram.percentile(2.5) / 1000,
p10: histogram.percentile(10) / 1000,
p25: histogram.percentile(25) / 1000,
p50: histogram.percentile(50) / 1000,
p75: histogram.percentile(75) / 1000,
p90: histogram.percentile(90) / 1000,
p97_5: histogram.percentile(97.5) / 1000,
p99: histogram.percentile(99) / 1000,
p99_9: histogram.percentile(99.9) / 1000,
p99_99: histogram.percentile(99.99) / 1000,
p99_999: histogram.percentile(99.999) / 1000
};
}
static toHistogramIntegerNano(milliseconds) {
return Math.max(1, Math.trunc(milliseconds * 1000));
}
}
exports.PiscinaHistogramHandler = PiscinaHistogramHandler;
_PiscinaHistogramHandler_runTime = new WeakMap, _PiscinaHistogramHandler_waitTime = new WeakMap;
});
// node_modules/piscina/dist/worker_pool/base.js
var require_base = __commonJS((exports) => {
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsynchronouslyCreatedResourcePool = exports.AsynchronouslyCreatedResource = undefined;
var node_assert_1 = __importDefault(__require("node:assert"));
class AsynchronouslyCreatedResource {
constructor() {
this.onreadyListeners = [];
this.ondestroyListeners = [];
}
markAsReady() {
const listeners = this.onreadyListeners;
(0, node_assert_1.default)(listeners !== null);
this.onreadyListeners = null;
for (const listener of listeners) {
listener();
}
}
isReady() {
return this.onreadyListeners === null;
}
onReady(fn) {
if (this.onreadyListeners === null) {
fn();
return;
}
this.onreadyListeners.push(fn);
}
onDestroy(fn) {
if (this.ondestroyListeners === null) {
return;
}
this.ondestroyListeners.push(fn);
}
markAsDestroyed() {
const listeners = this.ondestroyListeners;
(0, node_assert_1.default)(listeners !== null);
this.ondestroyListeners = null;
for (const listener of listeners) {
listener();
}
}
isDestroyed() {
return this.ondestroyListeners === null;
}
}
exports.AsynchronouslyCreatedResource = AsynchronouslyCreatedResource;
class AsynchronouslyCreatedResourcePool {
constructor(maximumUsage) {
this.pendingItems = new Set;
this.readyItems = new Set;
this.maximumUsage = maximumUsage;
this.onAvailableListeners = [];
this.onTaskDoneListeners = [];
}
add(item) {
this.pendingItems.add(item);
item.onReady(() => {
if (this.pendingItems.has(item)) {
this.pendingItems.delete(item);
this.readyItems.add(item);
this.maybeAvailable(item);
}
});
}
delete(item) {
this.pendingItems.delete(item);
this.readyItems.delete(item);
}
*[Symbol.iterator]() {
yield* this.pendingItems;
yield* this.readyItems;
}
get size() {
return this.pendingItems.size + this.readyItems.size;
}
maybeAvailable(item) {
if (item.currentUsage() < this.maximumUsage) {
for (const listener of this.onAvailableListeners) {
listener(item);
}
}
}
onAvailable(fn) {
this.onAvailableListeners.push(fn);
}
taskDone(item) {
for (let i = 0;i < this.onTaskDoneListeners.length; i++) {
this.onTaskDoneListeners[i](item);
}
}
onTaskDone(fn) {
this.onTaskDoneListeners.push(fn);
}
getCurrentUsage() {
let inFlight = 0;
for (const worker of this.readyItems) {
const currentUsage = worker.currentUsage();
if (Number.isFinite(currentUsage))
inFlight += currentUsage;
}
return inFlight;
}
}
exports.AsynchronouslyCreatedResourcePool = AsynchronouslyCreatedResourcePool;
});
// node_modules/piscina/dist/worker_pool/balancer/index.js
var require_balancer = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.LeastBusyBalancer = LeastBusyBalancer;
function LeastBusyBalancer(opts) {
const { maximumUsage } = opts;
return (task, workers) => {
let candidate = null;
let checkpoint = maximumUsage;
for (const worker of workers) {
if (worker.currentUsage === 0) {
candidate = worker;
break;
}
if (worker.isRunningAbortableTask)
continue;
if (!task.isAbortable && worker.currentUsage < checkpoint) {
candidate = worker;
checkpoint = worker.currentUsage;
}
}
return candidate;
};
}
});
// node_modules/piscina/dist/worker_pool/index.js
var require_worker_pool = __commonJS((exports) => {
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() {
return m[k];
} };
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
var __exportStar = exports && exports.__exportStar || function(m, exports2) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
__createBinding(exports2, m, p);
};
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsynchronouslyCreatedResourcePool = exports.WorkerInfo = undefined;
var node_worker_threads_1 = __require("node:worker_threads");
var node_perf_hooks_1 = __require("node:perf_hooks");
var node_assert_1 = __importDefault(__require("node:assert"));
var errors_1 = require_errors();
var symbols_1 = require_symbols();
var histogram_1 = require_histogram();
var base_1 = require_base();
Object.defineProperty(exports, "AsynchronouslyCreatedResourcePool", { enumerable: true, get: function() {
return base_1.AsynchronouslyCreatedResourcePool;
} });
__exportStar(require_balancer(), exports);
class WorkerInfo extends base_1.AsynchronouslyCreatedResource {
constructor(worker, port, onMessage, enableHistogram) {
super();
this.idleTimeout = null;
this.lastSeenResponseCount = 0;
this.terminating = false;
this.destroyed = false;
this.worker = worker;
this.port = port;
this.port.on("message", (message) => this._handleResponse(message));
this.onMessage = onMessage;
this.taskInfos = new Map;
this.sharedBuffer = new Int32Array(new SharedArrayBuffer(symbols_1.kFieldCount * Int32Array.BYTES_PER_ELEMENT));
this.histogram = enableHistogram ? (0, node_perf_hooks_1.createHistogram)() : null;
}
get id() {
return this.worker.threadId;
}
destroy() {
if (this.terminating || this.destroyed)
return;
this.terminating = true;
this.worker.terminate();
this.port.close();
this.clearIdleTimeout();
for (const taskInfo of this.taskInfos.values()) {
taskInfo.done(errors_1.Errors.ThreadTermination());
}
this.taskInfos.clear();
this.terminating = false;
this.destroyed = true;
this.markAsDestroyed();
}
clearIdleTimeout() {
if (this.idleTimeout != null) {
clearTimeout(this.idleTimeout);
this.idleTimeout = null;
}
}
ref() {
this.port.ref();
return this;
}
unref() {
this.port.unref();
return this;
}
_handleResponse(message) {
var _a;
if (message.time != null) {
(_a = this.histogram) === null || _a === undefined || _a.record(histogram_1.PiscinaHistogramHandler.toHistogramIntegerNano(message.time));
}
this.onMessage(message);
if (this.taskInfos.size === 0) {
this.unref();
}
}
postTask(taskInfo) {
(0, node_assert_1.default)(!this.taskInfos.has(taskInfo.taskId));
(0, node_assert_1.default)(!this.terminating && !this.destroyed);
const message = {
task: taskInfo.releaseTask(),
taskId: taskInfo.taskId,
filename: taskInfo.filename,
name: taskInfo.name,
histogramEnabled: this.histogram != null ? 1 : 0
};
try {
this.clearIdleTimeout();
this.port.postMessage(message, taskInfo.transferList);
} catch (err) {
taskInfo.done(err);
return;
}
taskInfo.workerInfo = this;
this.taskInfos.set(taskInfo.taskId, taskInfo);
this.ref();
Atomics.add(this.sharedBuffer, symbols_1.kRequestCountField, 1);
Atomics.notify(this.sharedBuffer, symbols_1.kRequestCountField, 1);
}
processPendingMessages() {
if (this.destroyed)
return;
const actualResponseCount = Atomics.load(this.sharedBuffer, symbols_1.kResponseCountField);
if (actualResponseCount !== this.lastSeenResponseCount) {
this.lastSeenResponseCount = actualResponseCount;
let entry;
while ((entry = (0, node_worker_threads_1.receiveMessageOnPort)(this.port)) !== undefined) {
this._handleResponse(entry.message);
}
}
}
isRunningAbortableTask() {
if (this.taskInfos.size !== 1)
return false;
const [[, task]] = this.taskInfos;
return task.abortSignal !== null;
}
currentUsage() {
if (this.isRunningAbortableTask())
return Infinity;
return this.taskInfos.size;
}
get interface() {
const worker = this;
return {
get id() {
return worker.worker.threadId;
},
get currentUsage() {
return worker.currentUsage();
},
get isRunningAbortableTask() {
return worker.isRunningAbortableTask();
},
get histogram() {
return worker.histogram != null ? histogram_1.PiscinaHistogramHandler.createHistogramSummary(worker.histogram) : null;
},
get terminating() {
return worker.terminating;
},
get destroyed() {
return worker.destroyed;
},
[symbols_1.kWorkerData]: worker
};
}
}
exports.WorkerInfo = WorkerInfo;
});
// node_modules/piscina/dist/abort.js
var require_abort = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
exports.AbortError = undefined;
exports.onabort = onabort;
class AbortError extends Error {
constructor(reason) {
super("The task has been aborted", { cause: reason });
}
get name() {
return "AbortError";
}
}
exports.AbortError = AbortError;
function onabort(abortSignal, listener) {
if ("addEventListener" in abortSignal) {
abortSignal.addEventListener("abort", listener, { once: true });
} else {
abortSignal.once("abort", listener);
}
}
});
// node_modules/piscina/dist/index.js
var require_dist = __commonJS((exports) => {
var __dirname = "/home/runner/work/hai-guardrails/hai-guardrails/node_modules/piscina/dist";
var __classPrivateFieldSet = exports && exports.__classPrivateFieldSet || function(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
};
var __classPrivateFieldGet = exports && exports.__classPrivateFieldGet || function(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { default: mod };
};
var _DirectlyTransferable_value;
var _ArrayBufferViewTransferable_view;
var _Piscina_pool;
var _Piscina_histogram;
Object.defineProperty(exports, "__esModule", { value: true });
exports.FixedQueue = exports.version = exports.queueOptionsSymbol = exports.valueSymbol = exports.transferableSymbol = exports.Piscina = exports.workerData = exports.isWorkerThread = exports.move = undefined;
var node_worker_threads_1 = __require("node:worker_threads");
var node_events_1 = __require("node:events");
var node_path_1 = __require("node:path");
var node_util_1 = __require("node:util");
var node_perf_hooks_1 = __require("node:perf_hooks");
var promises_1 = __require("node:timers/promises");
var node_assert_1 = __importDefault(__require("node:assert"));
var package_json_1 = require_package();
Object.defineProperty(exports, "version", { enumerable: true, get: function() {
return package_json_1.version;
} });
var symbols_1 = require_symbols();
Object.defineProperty(exports, "queueOptionsSymbol", { enumerable: true, get: function() {
return symbols_1.kQueueOptions;
} });
Object.defineProperty(exports, "transferableSymbol", { enumerable: true, get: function() {
return symbols_1.kTransferable;
} });
Object.defineProperty(exports, "valueSymbol", { enumerable: true, get: function() {
return symbols_1.kValue;
} });
var task_queue_1 = require_task_queue();
Object.defineProperty(exports, "FixedQueue", { enumerable: true, get: function() {
return task_queue_1.FixedQueue;
} });
var worker_pool_1 = require_worker_pool();
var abort_1 = require_abort();
var histogram_1 = require_histogram();
var errors_1 = require_errors();
var common_1 = require_common();
var cpuParallelism = (0, common_1.getAvailableParallelism)();
var kDefaultOptions = {
filename: null,
name: "default",
minThreads: Math.max(Math.floor(cpuParallelism / 2), 1),
maxThreads: cpuParallelism * 1.5,
idleTimeout: 0,
maxQueue: Infinity,
concurrentTasksPerWorker: 1,
atomics: "sync",
taskQueue: new task_queue_1.ArrayTaskQueue,
niceIncrement: 0,
trackUnmanagedFds: true,
closeTimeout: 30000,
recordTiming: true,
workerHistogram: false
};
var kDefaultRunOptions = {
transferList: undefined,
filename: null,
signal: null,
name: null
};
var kDefaultCloseOptions = {
force: false
};
class DirectlyTransferable {
constructor(value) {
_DirectlyTransferable_value.set(this, undefined);
__classPrivateFieldSet(this, _DirectlyTransferable_value, value, "f");
}
get [(_DirectlyTransferable_value = new WeakMap, symbols_1.kTransferable)]() {
return __classPrivateFieldGet(this, _DirectlyTransferable_value, "f");
}
get [symbols_1.kValue]() {
return __classPrivateFieldGet(this, _DirectlyTransferable_value, "f");
}
}
class ArrayBufferViewTransferable {
constructor(view) {
_ArrayBufferViewTransferable_view.set(this, undefined);
__classPrivateFieldSet(this, _ArrayBufferViewTransferable_view, view, "f");
}
get [(_ArrayBufferViewTransferable_view = new WeakMap, symbols_1.kTransferable)]() {
return __classPrivateFieldGet(this, _ArrayBufferViewTransferable_view, "f").buffer;
}
get [symbols_1.kValue]() {
return __classPrivateFieldGet(this, _ArrayBufferViewTransferable_view, "f");
}
}
class ThreadPool {
constructor(publicInterface, options) {
var _a, _b, _c;
this.skipQueue = [];
this.completed = 0;
this.histogram = null;
this.start = node_perf_hooks_1.performance.now();
this.inProcessPendingMessages = false;
this.startingUp = false;
this.closingUp = false;
this.workerFailsDuringBootstrap = false;
this.destroying = false;
this.publicInterface = publicInterface;
this.taskQueue = (_a = options.taskQueue) !== null && _a !== undefined ? _a : new task_queue_1.FixedQueue;
const filename = options.filename ? (0, common_1.maybeFileURLToPath)(options.filename) : null;
this.options = { ...kDefaultOptions, ...options, filename, maxQueue: 0 };
if (this.options.recordTiming) {
this.histogram = new histogram_1.PiscinaHistogramHandler;
}
if (options.maxThreads !== undefined && this.options.minThreads >= options.maxThreads) {
this.options.minThreads = options.maxThreads;
}
if (options.minThreads !== undefined && this.options.maxThreads <= options.minThreads) {
this.options.maxThreads = options.minThreads;
}
if (options.maxQueue === "auto") {
this.options.maxQueue = this.options.maxThreads ** 2;
} else {
this.options.maxQueue = (_b = options.maxQueue) !== null && _b !== undefined ? _b : kDefaultOptions.maxQueue;
}
this.balancer = (_c = this.options.loadBalancer) !== null && _c !== undefined ? _c : (0, worker_pool_1.LeastBusyBalancer)({ maximumUsage: this.options.concurrentTasksPerWorker });
this.workers = new worker_pool_1.AsynchronouslyCreatedResourcePool(this.options.concurrentTasksPerWorker);
this.workers.onTaskDone((w) => this._onWorkerTaskDone(w));
this.maxCapacity = this.options.maxThreads * this.options.concurrentTasksPerWorker;
this.startingUp = true;
this._ensureMinimumWorkers();
this.startingUp = false;
this._needsDrain = false;
}
_ensureMinimumWorkers() {
if (this.closingUp || this.destroying) {
return;
}
while (this.workers.size < this.options.minThreads) {
this._addNewWorker();
}
}
_addNewWorker() {
if (this.closingUp)
return;
const pool = this;
const worker = new node_worker_threads_1.Worker((0, node_path_1.resolve)(__dirname, "worker.js"), {
env: this.options.env,
argv: this.options.argv,
execArgv: this.options.execArgv,
resourceLimits: this.options.resourceLimits,
workerData: this.options.workerData,
trackUnmanagedFds: this.options.trackUnmanagedFds
});
const { port1, port2 } = new node_worker_threads_1.MessageChannel;
const workerInfo = new worker_pool_1.WorkerInfo(worker, port1, onMessage, this.options.workerHistogram);
workerInfo.onDestroy(() => {
this.publicInterface.emit("workerDestroy", workerInfo.interface);
});
if (this.startingUp) {
workerInfo.markAsReady();
queueMicrotask(() => {
this.publicInterface.emit("workerCreate", workerInfo.interface);
this._onWorkerReady(workerInfo);
});
} else {
workerInfo.onReady(() => {
this.publicInterface.emit("workerCreate", workerInfo.interface);
this._onWorkerReady(workerInfo);
});
}
const message = {
filename: this.options.filename,
name: this.options.name,
port: port2,
sharedBuffer: workerInfo.sharedBuffer,
atomics: this.options.atomics,
niceIncrement: this.options.niceIncrement
};
worker.postMessage(message, [port2]);
function onMessage(message2) {
const { taskId, result } = message2;
const taskInfo = workerInfo.taskInfos.get(taskId);
workerInfo.taskInfos.delete(taskId);
pool.workers.taskDone(workerInfo);
if (taskInfo === undefined) {
const err = new Error(`Unexpected message from Worker: ${(0, node_util_1.inspect)(message2)}`);
pool.publicInterface.emit("error", err);
} else {
taskInfo.done(message2.error, result);
}
pool._processPendingMessages();
}
function onReady() {
if (workerInfo.currentUsage() === 0) {
workerInfo.unref();
}
if (!workerInfo.isReady()) {
workerInfo.markAsReady();
}
}
function onEventMessage(message2) {
pool.publicInterface.emit("message", message2);
}
worker.on("message", (message2) => {
message2 instanceof Object && common_1.READY in message2 ? onReady() : onEventMessage(message2);
});
worker.on("error", (err) => {
this._onError(worker, workerInfo, err, false);
});
worker.on("exit", (exitCode) => {
if (this.destroying) {
return;
}
const err = new Error(`worker exited with code: ${exitCode}`);
this._onError(worker, workerInfo, err, true);
});
worker.unref();
port1.on("close", () => {
worker.ref();
});
this.workers.add(workerInfo);
}
_onError(worker, workerInfo, err, onlyErrorUnfinishedTasks) {
worker.ref = () => {
};
const taskInfos = [...workerInfo.taskInfos.values()];
workerInfo.taskInfos.clear();
this._removeWorker(workerInfo);
if (workerInfo.isReady() && !this.workerFailsDuringBootstrap) {
this._ensureMinimumWorkers();
} else {
this.workerFailsDuringBootstrap = true;
}
if (taskInfos.length > 0) {
for (const taskInfo of taskInfos) {
taskInfo.done(err, null);
}
} else if (!onlyErrorUnfinishedTasks) {
this.publicInterface.emit("error", err);
}
}
_processPendingMessages() {
if (this.inProcessPendingMessages || this.options.atomics === "disabled") {
return;
}
this.inProcessPendingMessages = true;
try {
for (const workerInfo of this.workers) {
workerInfo.processPendingMessages();
}
} finally {
this.inProcessPendingMessages = false;
}
}
_removeWorker(workerInfo) {
workerInfo.destroy();
this.workers.delete(workerInfo);
}
_onWorkerReady(workerInfo) {
this._onWorkerAvailable(workerInfo);
}
_onWorkerTaskDone(workerInfo) {
this._onWorkerAvailable(workerInfo);
}
_onWorkerAvailable(workerInfo) {
let workers = null;
while (this.taskQueue.size > 0 || this.skipQueue.length > 0) {
const taskInfo = this.skipQueue.shift() || this.taskQueue.shift();
if (workers == null) {
workers = [...this.workers].map((workerInfo2) => workerInfo2.interface);
}
const distributed = this._distributeTask(taskInfo, workers);
if (distributed) {
continue;
} else if (this.workers.size < this.options.maxThreads) {
this._addNewWorker();
continue;
} else {
break;
}
}
if (this.options.idleTimeout === Infinity) {
return;
}
if (workerInfo.currentUsage() === 0 && this.workers.size > this.options.minThreads) {
workerInfo.idleTimeout = setTimeout(() => {
node_assert_1.default.strictEqual(workerInfo.currentUsage(), 0);
if (this.workers.size > this.options.minThreads) {
this._removeWorker(workerInfo);
}
}, this.options.idleTimeout).unref();
}
}
_distributeTask(task, workers) {
var _a;
if (task.aborted)
return true;
const candidate = this.balancer(task.interface, workers);
if (candidate != null && candidate[symbols_1.kWorkerData] != null) {
const now = node_perf_hooks_1.performance.now();
(_a = this.histogram) === null || _a === undefined || _a.recordWaitTime(now - task.created);
task.started = now;
candidate[symbols_1.kWorkerData].postTask(task);
this._maybeDrain();
return true;
}
if (task.abortSignal) {
this.skipQueue.push(task);
} else {
this.taskQueue.push(task);
}
return false;
}
runTask(task, options) {
var _a;
let { filename, name } = options;
const { transferList = [] } = options;
if (filename == null) {
filename = this.options.filename;
}
if (name == null) {
name = this.options.name;
}
if (typeof filename !== "string") {
return Promise.reject(errors_1.Errors.FilenameNotProvided());
}
filename = (0, common_1.maybeFileURLToPath)(filename);
let signal;
if (this.closingUp || this.destroying) {
const closingUpAbortController = new AbortController;
closingUpAbortController.abort("queue is being terminated");
signal = closingUpAbortController.signal;
} else {
signal = (_a = options.signal) !== null && _a !== undefined ? _a : null;
}
let resolve;
let reject;
const ret = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
const taskInfo = new task_queue_1.TaskInfo(task, transferList, filename, name, (err, result) => {
var _a2;
this.completed++;
if (taskInfo.started) {
(_a2 = this.histogram) === null || _a2 === undefined || _a2.recordRunTime(node_perf_hooks_1.performance.now() - taskInfo.started);
}
if (err !== null) {
reject(err);
} else {
resolve(result);
}
this._maybeDrain();
}, signal, this.publicInterface.asyncResource.asyncId());
if (signal !== null) {
if (signal.aborted) {
reject(new abort_1.AbortError(signal.reason));
return ret;
}
taskInfo.abortListener = () => {
reject(new abort_1.AbortError(signal.reason));
if (taskInfo.workerInfo !== null) {
this._removeWorker(taskInfo.workerInfo);
this._ensureMinimumWorkers();
} else {
this.taskQueue.remove(taskInfo);
}
};
(0, abort_1.onabort)(signal, taskInfo.abortListener);
}
if (this.taskQueue.size > 0) {
const totalCapacity = this.options.maxQueue + this.pendingCapacity();
if (this.taskQueue.size >= totalCapacity) {
if (this.options.maxQueue === 0) {
reject(errors_1.Errors.NoTaskQueueAvailable());
} else {
reject(errors_1.Errors.TaskQueueAtLimit());
}
} else {
this.taskQueue.push(taskInfo);
}
this._maybeDrain();
return ret;
}
const workers = [...this.workers.readyItems].map((workerInfo) => workerInfo.interface);
const distributed = this._distributeTask(taskInfo, workers);
if (!distributed) {
if (this.workers.size < this.options.maxThreads) {
this._addNewWorker();
}
if (this.options.maxQueue <= 0 && this.pendingCapacity() === 0) {
reject(errors_1.Errors.NoTaskQueueAvailable());
}
}
this._maybeDrain();
return ret;
}
pendingCapacity() {
return this.workers.pendingItems.size * this.options.concurrentTasksPerWorker;
}
_maybeDrain() {
const { maxCapacity } = this;
const currentUsage = this.workers.getCurrentUsage();
if (maxCapacity === currentUsage) {
this._needsDrain = true;
this.publicInterface.emit("needsDrain");
} else if (maxCapacity > currentUsage && this._needsDrain) {
this._needsDrain = false;
this.publicInterface.emit("drain");
}
}
async destroy() {
this.destroying = true;
while (this.skipQueue.length > 0) {
const taskInfo = this.skipQueue.shift();
taskInfo.done(new Error("Terminating worker thread"));
}
while (this.taskQueue.size > 0) {
const taskInfo = this.taskQueue.shift();
taskInfo.done(new Error("Terminating worker thread"));
}
const exitEvents = [];
while (this.workers.size > 0) {
const [workerInfo] = this.workers;
exitEvents.push((0, node_events_1.once)(workerInfo.worker, "exit"));
this._removeWorker(workerInfo);
}
try {
await Promise.all(exitEvents);
} finally {
this.destroying = false;
}
}
async close(options) {
this.closingUp = true;
if (options.force) {
const skipQueueLength = this.skipQueue.length;
for (let i = 0;i < skipQueueLength; i++) {
const taskInfo = this.skipQueue.shift();
if (taskInfo.workerInfo === null) {
taskInfo.done(new abort_1.AbortError("pool is closed"));
} else {
this.skipQueue.push(taskInfo);
}
}
const taskQueueLength = this.taskQueue.size;
for (let i = 0;i < taskQueueLength; i++) {
const taskInfo = this.taskQueue.shift();
if (taskInfo.workerInfo === null) {
taskInfo.done(new abort_1.AbortError("pool is closed"));
} else {
this.taskQueue.push(taskInfo);
}
}
}
const onPoolFlushed = () => new Promise((resolve) => {
const numberOfWorkers = this.workers.size;
if (numberOfWorkers === 0) {
resolve();
return;
}
let numberOfWorkersDone = 0;
const checkIfWorkerIsDone = (workerInfo) => {
if (workerInfo.taskInfos.size === 0) {
numberOfWorkersDone++;
}
if (numberOfWorkers === numberOfWorkersDone) {
resolve();
}
};
for (const workerInfo of this.workers) {
checkIfWorkerIsDone(workerInfo);
this.workers.onTaskDone(checkIfWorkerIsDone);
}
});
const throwOnTimeOut = async (timeout) => {
await (0, promises_1.setTimeout)(timeout, null, { ref: false });
throw errors_1.Errors.CloseTimeout();
};
try {
await Promise.race([
onPoolFlushed(),
throwOnTimeOut(this.options.closeTimeout)
]);
} catch (error) {
this.publicInterface.emit("error", error);
} finally {
await this.destroy();
this.publicInterface.emit("close");
this.closingUp = false;
}
}
}
class Piscina extends node_events_1.EventEmitterAsyncResource {
constructor(options = {}) {
super({ ...options, name: "Piscina" });
_Piscina_pool.set(this, undefined);
_Piscina_histogram.set(this, null);
if (typeof options.filename !== "string" && options.filename != null) {
throw new TypeError("options.filename must be a string or null");
}
if (typeof options.name !== "string" && options.name != null) {
throw new TypeError("options.name must be a string or null");
}
if (options.minThreads !== undefined && (typeof options.minThreads !== "number" || options.minThreads < 0)) {
throw new TypeError("options.minThreads must be a non-negative integer");
}
if (options.maxThreads !== undefined && (typeof options.maxThreads !== "number" || options.maxThreads < 1)) {
throw new TypeError("options.maxThreads must be a positive integer");
}
if (options.minThreads !== undefined && options.maxThreads !== undefined