sab-ipc.js

'use strict';

const { parseCamaroJson } = require('./json-parse');

const FN = { transform: 0, toJson: 1, prettyPrint: 2 };

const CTRL = {
	STATE: 0,
	REQUEST_ID: 1,
	XML_LEN: 2,
	RESULT_LEN: 3,
	FN: 4,
	HAS_NAN: 5,
};

const STATE = { IDLE: 0, BUSY: 1, DONE: 2, ERROR: -1 };

const textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
const textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;

function sabEnabled() {
	if (typeof SharedArrayBuffer === 'undefined') return false;
	const raw = process.env.CAMARO_SAB_IPC;
	if (raw === '0' || raw === 'false' || raw === 'off') return false;
	return true;
}

function defaultXmlSabBytes() {
	const n = Number(process.env.CAMARO_SAB_XML_BYTES || 0);
	return n > 0 ? n : 512 * 1024;
}

function defaultResultSabBytes() {
	const n = Number(process.env.CAMARO_SAB_RESULT_BYTES || 0);
	return n > 0 ? n : 256 * 1024;
}

function fitsSabXmlPayload(xml) {
	const max = defaultXmlSabBytes();
	if (typeof xml === 'string') return xml.length * 3 <= max;
	if (typeof Buffer !== 'undefined' && Buffer.isBuffer(xml)) return xml.length <= max;
	if (xml instanceof ArrayBuffer) return xml.byteLength <= max;
	if (ArrayBuffer.isView(xml)) return xml.byteLength <= max;
	return false;
}

function createSabChannel() {
	return {
		control: new Int32Array(new SharedArrayBuffer(32)),
		xml: new Uint8Array(new SharedArrayBuffer(defaultXmlSabBytes())),
		result: new Uint8Array(new SharedArrayBuffer(defaultResultSabBytes())),
	};
}

function fnCode(fn) {
	if (fn === 'transform') return FN.transform;
	if (fn === 'toJson') return FN.toJson;
	if (fn === 'prettyPrint') return FN.prettyPrint;
	return -1;
}

function writeBytesToSab(channel, bytes) {
	if (bytes.byteLength > channel.xml.byteLength) {
		throw new RangeError(`XML payload (${bytes.byteLength} bytes) exceeds CAMARO_SAB_XML_BYTES (${channel.xml.byteLength})`);
	}
	channel.xml.set(bytes);
	Atomics.store(channel.control, CTRL.XML_LEN, bytes.byteLength);
}

function writeStringXmlToSab(channel, xml) {
	if (!textEncoder) {
		return writeBytesToSab(channel, new Uint8Array(Buffer.from(xml, 'utf8')));
	}
	const worstCase = xml.length * 3;
	if (worstCase > channel.xml.byteLength) {
		throw new RangeError(`XML payload (> ${worstCase} bytes) exceeds CAMARO_SAB_XML_BYTES (${channel.xml.byteLength})`);
	}
	const { written } = textEncoder.encodeInto(xml, channel.xml);
	Atomics.store(channel.control, CTRL.XML_LEN, written);
}

function writeResultToSab(channel, payload) {
	let str;
	let hasNan = 0;
	if (typeof payload === 'string') {
		str = payload;
	} else if (payload && typeof payload === 'object' && typeof payload.json === 'string') {
		str = payload.json;
		hasNan = 1;
	} else {
		str = JSON.stringify(payload);
	}

	if (textEncoder) {
		const { read, written } = textEncoder.encodeInto(str, channel.result);
		if (read !== str.length) {
			throw new RangeError(`Result exceeds CAMARO_SAB_RESULT_BYTES (${channel.result.byteLength})`);
		}
		Atomics.store(channel.control, CTRL.RESULT_LEN, written);
	} else {
		const encoded = new Uint8Array(Buffer.from(str, 'utf8'));
		if (encoded.byteLength > channel.result.byteLength) {
			throw new RangeError(`Result (${encoded.byteLength} bytes) exceeds CAMARO_SAB_RESULT_BYTES (${channel.result.byteLength})`);
		}
		channel.result.set(encoded);
		Atomics.store(channel.control, CTRL.RESULT_LEN, encoded.byteLength);
	}
	Atomics.store(channel.control, CTRL.HAS_NAN, hasNan);
	return hasNan === 1;
}

function readResultFromSab(channel) {
	const len = Atomics.load(channel.control, CTRL.RESULT_LEN);
	const hasNan = Atomics.load(channel.control, CTRL.HAS_NAN) === 1;
	const slice = channel.result.subarray(0, len);
	const str = textDecoder ? textDecoder.decode(slice) : Buffer.from(slice).toString('utf8');
	return parseCamaroJson(hasNan ? { json: str, hasNan: true } : str);
}

function stripXmlFromTask(task) {
	const args = task.args.slice();
	args[0] = null;
	return { fn: task.fn, args, recycleXml: false };
}

module.exports = {
	FN,
	CTRL,
	STATE,
	sabEnabled,
	createSabChannel,
	fnCode,
	writeBytesToSab,
	writeStringXmlToSab,
	writeResultToSab,
	readResultFromSab,
	fitsSabXmlPayload,
	stripXmlFromTask,
};