@codemation/core 0.12.0 → 0.13.1

package/dist/{runtime-CyW9c9XM.cjs → runtime-rrH8-Ouq.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 });
+		}
 	}
 };
 
@@ -4926,12 +5003,26 @@ var InlineDrivingScheduler = class {
 	drainingRuns = /* @__PURE__ */ new Set();
 	queuesByRunId = /* @__PURE__ */ new Map();
 	scheduledRuns = /* @__PURE__ */ new Set();
+	stopped = false;
+	activeDrainPromises = /* @__PURE__ */ new Set();
 	constructor(nodeExecutor) {
 		this.nodeExecutor = nodeExecutor;
 	}
 	setContinuation(continuation) {
 		this.continuation = continuation;
 	}
+	/**
+	* Prevents new drain cycles from being scheduled and waits for all currently-running
+	* drains to complete. Call before closing the DB connection or rolling back test transactions
+	* to ensure no in-flight writes hit a closed/rolled-back connection.
+	*
+	* Bounded: only the drains already in-flight at call time are awaited. Runs that keep
+	* re-scheduling will not schedule new work once stopped is set.
+	*/
+	async stop() {
+		this.stopped = true;
+		if (this.activeDrainPromises.size > 0) await Promise.allSettled(this.activeDrainPromises);
+	}
 	async prepareDispatch(request) {
 		const receipt = {
 			receiptId: request.activationId,
@@ -4981,11 +5072,15 @@ var InlineDrivingScheduler = class {
 		}
 	}
 	scheduleDrain(runId) {
-		if (this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) return;
+		if (this.stopped || this.drainingRuns.has(runId) || this.scheduledRuns.has(runId)) return;
 		this.scheduledRuns.add(runId);
 		setImmediate(() => {
 			this.scheduledRuns.delete(runId);
-			this.drainRun(runId);
+			if (this.stopped) return;
+			const p = this.drainRun(runId).finally(() => {
+				this.activeDrainPromises.delete(p);
+			});
+			this.activeDrainPromises.add(p);
 		});
 	}
 	async resumeAfterExecutionResult(continuation, request, outputs) {
@@ -7056,4 +7151,4 @@ Object.defineProperty(exports, 'tool', {
     return tool;
   }
 });
-//# sourceMappingURL=runtime-CyW9c9XM.cjs.map
+//# sourceMappingURL=runtime-rrH8-Ouq.cjs.map