@camstack/system 1.2.57 → 1.2.59

package/dist/{manifest-python-deps-Ck4-9K9m.mjs → manifest-python-deps-CX5tGRqf.mjs}

@@ -1,10 +1,10 @@
 import { ensureBinary, ensureFfmpeg, ensurePython, installPythonPackages, installPythonRequirements } from "@camstack/types/node";
+import * as crypto$1 from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import { isAbsolute, join } from "node:path";
-import * as crypto$1 from "node:crypto";
-import { randomBytes, randomUUID } from "node:crypto";
 import { DATAPLANE_SECRET_HEADER, DeviceType, DisposerChain, EventCategory, ReadinessRegistry, asJsonObject, asString, createDeviceProxy, deviceOpsCapability, emitReadiness, errMsg, expandCapMethods, readNodePin, scopeKey, sleep, withCapInputDefaults } from "@camstack/types/addon";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -3518,20 +3518,105 @@ function encodeFrame(value) {
 	Buffer.from(body.buffer, body.byteOffset, body.byteLength).copy(out, 4);
 	return out;
 }
-/** Reassembles length-prefixed MsgPack frames from a byte stream. */
+/** Bytes in the big-endian length prefix that opens every frame. */
+var HEADER_BYTES = 4;
+/**
+* Reassembles length-prefixed MsgPack frames from a byte stream.
+*
+* **Why this is a chunk LIST and not a growing Buffer.** The original
+* accumulator did `this.buf = Buffer.concat([this.buf, chunk])` on every
+* socket `data` event. A frame of N bytes delivered in C-byte pieces
+* therefore copied ~N²/2C bytes: a 4 MiB native crop arriving in 64 KiB
+* chunks is ~128 MiB of memcpy plus 64 intermediate Buffer allocations,
+* synchronously, on the thread that also serves every tRPC request. Media
+* transits this router constantly, and hub-main was measured busy 82.2 s out
+* of 120 with 22 uninterrupted blocks ≥1 s.
+*
+* Here the pending chunks are kept as-is and joined ONCE, when a frame is
+* complete — and not even then in the common case, because a frame that
+* arrived whole inside one chunk is sliced out with zero copying. Total work
+* is linear in the bytes received.
+*
+* The wire contract is unchanged: 4-byte big-endian length, then that many
+* MsgPack bytes; a partial frame is buffered; several frames in one chunk are
+* all returned; a frame spanning any number of chunks is reassembled. There
+* is still no upper bound on a declared length — an oversized prefix parks
+* bytes in `chunks` until the peer completes or the socket closes, exactly as
+* before. Bounding it is a transport-protocol change, not a decoder cleanup.
+*/
 var FrameDecoder = class {
-	buf = Buffer.alloc(0);
+	/** Unconsumed bytes, oldest first. `chunks[0]` starts at a frame boundary. */
+	chunks = [];
+	/** Sum of `chunks[i].byteLength` — tracked so length checks cost nothing. */
+	buffered = 0;
 	push(chunk) {
-		this.buf = this.buf.byteLength === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+		if (chunk.byteLength > 0) {
+			this.chunks.push(chunk);
+			this.buffered += chunk.byteLength;
+		}
 		const frames = [];
-		while (this.buf.byteLength >= 4) {
-			const len = this.buf.readUInt32BE(0);
-			if (this.buf.byteLength < 4 + len) break;
-			frames.push(decode(this.buf.subarray(4, 4 + len)));
-			this.buf = this.buf.subarray(4 + len);
+		while (this.buffered >= HEADER_BYTES) {
+			const total = HEADER_BYTES + this.readLength();
+			if (this.buffered < total) break;
+			frames.push(decode(this.take(total).subarray(HEADER_BYTES)));
 		}
 		return frames;
 	}
+	/**
+	* Read the frame length without consuming it. The prefix itself can land
+	* across a chunk boundary (a 3-byte first chunk is a real socket event), so
+	* the slow path walks bytes until it has all four.
+	*/
+	readLength() {
+		const head = this.chunks[0];
+		if (head === void 0) throw new Error("FrameDecoder: buffered bytes with no chunks");
+		if (head.byteLength >= HEADER_BYTES) return head.readUInt32BE(0);
+		let value = 0;
+		let seen = 0;
+		for (const c of this.chunks) {
+			for (let i = 0; i < c.byteLength && seen < HEADER_BYTES; i++, seen++) value = value * 256 + (c[i] ?? 0);
+			if (seen === HEADER_BYTES) break;
+		}
+		return value;
+	}
+	/**
+	* Consume and return exactly `n` contiguous bytes.
+	*
+	* Three cases, cheapest first: the head chunk already holds the whole frame
+	* (no copy at all, just a view); the head chunk holds more than the frame
+	* (a view plus a rebased head); the frame spans chunks (ONE `Buffer.concat`
+	* sized to the frame — the single copy this class is allowed).
+	*/
+	take(n) {
+		const head = this.chunks[0];
+		if (head === void 0) throw new Error("FrameDecoder: take() with no chunks");
+		this.buffered -= n;
+		if (head.byteLength === n) {
+			this.chunks.shift();
+			return head;
+		}
+		if (head.byteLength > n) {
+			this.chunks[0] = head.subarray(n);
+			return head.subarray(0, n);
+		}
+		const parts = [];
+		let collected = 0;
+		while (collected < n) {
+			const next = this.chunks[0];
+			if (next === void 0) throw new Error("FrameDecoder: ran out of chunks mid-frame");
+			const remaining = n - collected;
+			if (next.byteLength <= remaining) {
+				parts.push(next);
+				collected += next.byteLength;
+				this.chunks.shift();
+				continue;
+			}
+			parts.push(next.subarray(0, remaining));
+			this.chunks[0] = next.subarray(remaining);
+			collected = n;
+		}
+		return Buffer.concat(parts, n);
+	}
 };
 //#endregion
 //#region src/kernel/transport/local-endpoint-path.ts

package/dist/{manifest-python-deps-BqE5j0-O.js → manifest-python-deps-d4acYXVV.js}

@@ -1,12 +1,12 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
 let _camstack_types_node = require("@camstack/types/node");
+let node_crypto = require("node:crypto");
+node_crypto = require_chunk.__toESM(node_crypto);
 let node_http = require("node:http");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
-let node_crypto = require("node:crypto");
-node_crypto = require_chunk.__toESM(node_crypto);
 let _camstack_types_addon = require("@camstack/types/addon");
 let node_child_process = require("node:child_process");
 let node_util = require("node:util");
@@ -3520,20 +3520,105 @@ function encodeFrame(value) {
 	Buffer.from(body.buffer, body.byteOffset, body.byteLength).copy(out, 4);
 	return out;
 }
-/** Reassembles length-prefixed MsgPack frames from a byte stream. */
+/** Bytes in the big-endian length prefix that opens every frame. */
+var HEADER_BYTES = 4;
+/**
+* Reassembles length-prefixed MsgPack frames from a byte stream.
+*
+* **Why this is a chunk LIST and not a growing Buffer.** The original
+* accumulator did `this.buf = Buffer.concat([this.buf, chunk])` on every
+* socket `data` event. A frame of N bytes delivered in C-byte pieces
+* therefore copied ~N²/2C bytes: a 4 MiB native crop arriving in 64 KiB
+* chunks is ~128 MiB of memcpy plus 64 intermediate Buffer allocations,
+* synchronously, on the thread that also serves every tRPC request. Media
+* transits this router constantly, and hub-main was measured busy 82.2 s out
+* of 120 with 22 uninterrupted blocks ≥1 s.
+*
+* Here the pending chunks are kept as-is and joined ONCE, when a frame is
+* complete — and not even then in the common case, because a frame that
+* arrived whole inside one chunk is sliced out with zero copying. Total work
+* is linear in the bytes received.
+*
+* The wire contract is unchanged: 4-byte big-endian length, then that many
+* MsgPack bytes; a partial frame is buffered; several frames in one chunk are
+* all returned; a frame spanning any number of chunks is reassembled. There
+* is still no upper bound on a declared length — an oversized prefix parks
+* bytes in `chunks` until the peer completes or the socket closes, exactly as
+* before. Bounding it is a transport-protocol change, not a decoder cleanup.
+*/
 var FrameDecoder = class {
-	buf = Buffer.alloc(0);
+	/** Unconsumed bytes, oldest first. `chunks[0]` starts at a frame boundary. */
+	chunks = [];
+	/** Sum of `chunks[i].byteLength` — tracked so length checks cost nothing. */
+	buffered = 0;
 	push(chunk) {
-		this.buf = this.buf.byteLength === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+		if (chunk.byteLength > 0) {
+			this.chunks.push(chunk);
+			this.buffered += chunk.byteLength;
+		}
 		const frames = [];
-		while (this.buf.byteLength >= 4) {
-			const len = this.buf.readUInt32BE(0);
-			if (this.buf.byteLength < 4 + len) break;
-			frames.push(decode(this.buf.subarray(4, 4 + len)));
-			this.buf = this.buf.subarray(4 + len);
+		while (this.buffered >= HEADER_BYTES) {
+			const total = HEADER_BYTES + this.readLength();
+			if (this.buffered < total) break;
+			frames.push(decode(this.take(total).subarray(HEADER_BYTES)));
 		}
 		return frames;
 	}
+	/**
+	* Read the frame length without consuming it. The prefix itself can land
+	* across a chunk boundary (a 3-byte first chunk is a real socket event), so
+	* the slow path walks bytes until it has all four.
+	*/
+	readLength() {
+		const head = this.chunks[0];
+		if (head === void 0) throw new Error("FrameDecoder: buffered bytes with no chunks");
+		if (head.byteLength >= HEADER_BYTES) return head.readUInt32BE(0);
+		let value = 0;
+		let seen = 0;
+		for (const c of this.chunks) {
+			for (let i = 0; i < c.byteLength && seen < HEADER_BYTES; i++, seen++) value = value * 256 + (c[i] ?? 0);
+			if (seen === HEADER_BYTES) break;
+		}
+		return value;
+	}
+	/**
+	* Consume and return exactly `n` contiguous bytes.
+	*
+	* Three cases, cheapest first: the head chunk already holds the whole frame
+	* (no copy at all, just a view); the head chunk holds more than the frame
+	* (a view plus a rebased head); the frame spans chunks (ONE `Buffer.concat`
+	* sized to the frame — the single copy this class is allowed).
+	*/
+	take(n) {
+		const head = this.chunks[0];
+		if (head === void 0) throw new Error("FrameDecoder: take() with no chunks");
+		this.buffered -= n;
+		if (head.byteLength === n) {
+			this.chunks.shift();
+			return head;
+		}
+		if (head.byteLength > n) {
+			this.chunks[0] = head.subarray(n);
+			return head.subarray(0, n);
+		}
+		const parts = [];
+		let collected = 0;
+		while (collected < n) {
+			const next = this.chunks[0];
+			if (next === void 0) throw new Error("FrameDecoder: ran out of chunks mid-frame");
+			const remaining = n - collected;
+			if (next.byteLength <= remaining) {
+				parts.push(next);
+				collected += next.byteLength;
+				this.chunks.shift();
+				continue;
+			}
+			parts.push(next.subarray(0, remaining));
+			this.chunks[0] = next.subarray(remaining);
+			collected = n;
+		}
+		return Buffer.concat(parts, n);
+	}
 };
 //#endregion
 //#region src/kernel/transport/local-endpoint-path.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.57",
+  "version": "1.2.59",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",

package/dist/{model-download-service-hf0ookyy.js → model-download-service-Cpc6SWzV.js}

@@ -1,10 +1,10 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
+let node_crypto = require("node:crypto");
 let node_http = require("node:http");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
-let node_crypto = require("node:crypto");
 //#region src/http/authenticated-file-server.ts
 /**
 * Authenticated data-plane file-server — a shared host primitive for addons that

package/dist/{model-download-service-Cp9f4dk6.mjs → model-download-service-D8B-4ktF.mjs}

@@ -1,9 +1,9 @@
+import { createHash } from "node:crypto";
 import { createServer } from "node:http";
 import * as fs from "node:fs";
 import { createReadStream, promises } from "node:fs";
 import * as path$1 from "node:path";
 import path from "node:path";
-import { createHash } from "node:crypto";
 //#region src/http/authenticated-file-server.ts
 /**
 * Authenticated data-plane file-server — a shared host primitive for addons that