@codemation/core 0.12.0 → 0.13.0

package/dist/{runtime-CyW9c9XM.cjs → runtime-DjYXgOo0.cjs}

@@ -1,4 +1,4 @@
-const require_di = require('./di-tO6R7VJV.cjs');
+const require_di = require('./di-C-2ep8NZ.cjs');
 let zod = require("zod");
 zod = require_di.__toESM(zod);
 let node_stream_web = require("node:stream/web");
@@ -895,6 +895,58 @@ var NodeEventPublisher = class {
 	}
 };
 
+//#endregion
+//#region src/binaries/boundedReadBinary.types.ts
+/**
+* Reads all bytes from an already-opened binary stream into a contiguous `Uint8Array`.
+*
+* Safety contract:
+*  - `attachment.size` is checked against `maxBytes` *before* any allocation (no OOM).
+*  - A single buffer of exactly `attachment.size` is pre-allocated; the stream fills it
+*    directly — no chunks array, no doubling.
+*  - A byte-count mismatch between the declared size and actual stream content is an error.
+*
+* This is the single canonical implementation; `ExecutionBinaryService.getBytes`,
+* `getText`, and `getJson` all delegate here. The per-package `readBinaryBody` helpers
+* in `core-nodes` and `core-nodes-ocr` have been removed in favour of this function.
+*/
+async function boundedReadBinary(result, attachment, maxBytes = require_di.BINARY_DEFAULT_MAX_BYTES) {
+	if (attachment.size > maxBytes) throw new Error(`Binary attachment size ${attachment.size} bytes exceeds maxBytes ${maxBytes}. Raise the node's maxBytes setting if this document is expected to be larger.`);
+	const out = new Uint8Array(attachment.size);
+	const reader = result.body.getReader();
+	let offset = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (!value) continue;
+		if (offset + value.byteLength > out.byteLength) throw new Error(`Binary stream produced more bytes than the attachment's declared size (${attachment.size}).`);
+		out.set(value, offset);
+		offset += value.byteLength;
+	}
+	if (offset !== out.byteLength) throw new Error(`Binary stream produced ${offset} bytes but attachment declared size ${attachment.size}.`);
+	return out;
+}
+/** Shared implementation of `getBytes` used by both binary-service classes. */
+async function readBinaryAsBytes(storage, attachment, maxBytes) {
+	const result = await storage.openReadStream(attachment.storageKey);
+	if (!result) throw new Error("Binary attachment stream is unavailable.");
+	return boundedReadBinary(result, attachment, maxBytes);
+}
+/** Shared implementation of `getText` used by both binary-service classes. */
+async function readBinaryAsText(storage, attachment, maxBytes) {
+	const bytes = await readBinaryAsBytes(storage, attachment, maxBytes);
+	return new TextDecoder().decode(bytes);
+}
+/** Shared implementation of `getJson` used by both binary-service classes. */
+async function readBinaryAsJson(storage, attachment, maxBytes) {
+	const text = await readBinaryAsText(storage, attachment, maxBytes);
+	try {
+		return JSON.parse(text);
+	} catch (cause) {
+		throw new SyntaxError(`Binary attachment at storage key "${attachment.storageKey}" is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+	}
+}
+
 //#endregion
 //#region src/binaries/DefaultNodeBinaryAttachmentServiceFactory.ts
 var DefaultNodeBinaryAttachmentService = class DefaultNodeBinaryAttachmentService {
@@ -945,6 +997,15 @@ var DefaultNodeBinaryAttachmentService = class DefaultNodeBinaryAttachmentServic
 	async openReadStream(attachment) {
 		return await this.storage.openReadStream(attachment.storageKey);
 	}
+	async getBytes(attachment, maxBytes) {
+		return readBinaryAsBytes(this.storage, attachment, maxBytes);
+	}
+	async getText(attachment, maxBytes) {
+		return readBinaryAsText(this.storage, attachment, maxBytes);
+	}
+	async getJson(attachment, maxBytes) {
+		return readBinaryAsJson(this.storage, attachment, maxBytes);
+	}
 	createAttachmentId() {
 		return DefaultNodeBinaryAttachmentService.createAttachmentIdValue(`${this.activationId}-${this.now().getTime()}`);
 	}
@@ -1008,8 +1069,24 @@ var DefaultExecutionBinaryService = class {
 	forNode(args) {
 		return new DefaultNodeBinaryAttachmentService(this.storage, this.workflowId, this.runId, args.nodeId, args.activationId, this.now);
 	}
-	async openReadStream(attachment) {
-		return await this.storage.openReadStream(attachment.storageKey);
+	openReadStream(attachment) {
+		return this.storage.openReadStream(attachment.storageKey);
+	}
+	async getBytes(attachment, maxBytes) {
+		const stream = await this.openReadStream(attachment);
+		if (!stream) throw new Error("Binary attachment stream is unavailable.");
+		return boundedReadBinary(stream, attachment, maxBytes);
+	}
+	async getText(attachment, maxBytes) {
+		return new TextDecoder().decode(await this.getBytes(attachment, maxBytes));
+	}
+	async getJson(attachment, maxBytes) {
+		const text = await this.getText(attachment, maxBytes);
+		try {
+			return JSON.parse(text);
+		} catch (cause) {
+			throw new SyntaxError(`Binary attachment at storage key "${attachment.storageKey}" is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+		}
 	}
 };
 
@@ -7056,4 +7133,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-CyW9c9XM.cjs.map
+//# sourceMappingURL=runtime-DjYXgOo0.cjs.map