@lovable.dev/sdk 1.4.0 → 1.6.1

package/dist/workflows.js

@@ -0,0 +1,1250 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../workflow-sdk/src/index.ts
+function defineTask(config) {
+	assertEntryName(config.name);
+	if (config.environment !== "cloudflare") throw new Error("workflow-sdk: only Cloudflare tasks are supported");
+	if (config.maxConcurrency !== void 0 && (!Number.isInteger(config.maxConcurrency) || config.maxConcurrency < 1 || config.maxConcurrency > 256)) throw new Error("workflow-sdk: maxConcurrency must be an integer between 1 and 256");
+	return config;
+}
+/** A durable promise was rejected (explicitly or by its timeout sweep). Catchable to branch on rejection. */
+var PromiseRejectedError = class extends Error {
+	promiseName;
+	reason;
+	constructor(promiseName, reason) {
+		super(`workflow-sdk: promise "${promiseName}" rejected: ${reason}`);
+		this.promiseName = promiseName;
+		this.reason = reason;
+	}
+};
+function defineWorkflow(name, handler) {
+	return {
+		name,
+		handler
+	};
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function taskDispatchPromise(start) {
+	const pending = new Promise(() => void 0);
+	let started = false;
+	return interceptPromiseMethods(pending, (_method, args, invoke) => {
+		if (!started) {
+			started = true;
+			start();
+		}
+		return invoke(args);
+	});
+}
+function interceptPromiseMethods(promise, intercept) {
+	return new Proxy(promise, { get(target, property) {
+		if (property !== "then" && property !== "catch" && property !== "finally") return Reflect.get(target, property, target);
+		const method = Reflect.get(target, property, target);
+		return (...args) => intercept(property, args, (interceptedArgs) => Reflect.apply(method, target, interceptedArgs));
+	} });
+}
+function hasDurableTaskDispatch(lineage) {
+	let current = lineage;
+	while (current !== void 0) {
+		if (current.durableTaskDispatched) return true;
+		current = current.parent;
+	}
+	return false;
+}
+var Execution = class {
+	input;
+	journal;
+	offload;
+	completed = Object.create(null);
+	dispatches = [];
+	seenStepNames = /* @__PURE__ */ new Set();
+	seenPromiseNames = /* @__PURE__ */ new Set();
+	seenAutomaticEntries = /* @__PURE__ */ new Set();
+	startedSteps = [];
+	unconsumedInlineSteps = /* @__PURE__ */ new Map();
+	unconsumedTasks = /* @__PURE__ */ new Map();
+	inlineStep = new AsyncLocalStorage();
+	inlinePromiseLineage = new AsyncLocalStorage();
+	dispatchReady;
+	resolveDispatch;
+	logger;
+	journalRemaining;
+	constructor(input, journal, offload, emit) {
+		this.input = input;
+		this.journal = journal;
+		this.offload = offload;
+		this.dispatchReady = new Promise((resolve) => {
+			this.resolveDispatch = resolve;
+		});
+		this.journalRemaining = Object.keys(journal).length;
+		this.logger = createWorkflowLogger(emit, () => this.journalRemaining > 0);
+	}
+	consumeJournalEntry() {
+		if (this.journalRemaining > 0) this.journalRemaining -= 1;
+	}
+	async readOrRecord(key, createValue) {
+		if (hasOwn(this.journal, key)) {
+			this.consumeJournalEntry();
+			return readJournalResult(this.journal[key]);
+		}
+		const createdValue = await createValue();
+		if (createdValue instanceof PayloadFile) {
+			this.completed[key] = {
+				resultType: "ref",
+				ref: structuredClone(createdValue.ref)
+			};
+			return createdValue;
+		}
+		if (createdValue === void 0) {
+			this.completed[key] = {
+				result: null,
+				resultType: "undefined"
+			};
+			return;
+		}
+		const encoded = encodeJSONValue(createdValue, "step results");
+		if (this.offload !== void 0) {
+			const serialized = utf8PayloadBytes(encoded);
+			if (serialized.byteLength > this.offload.threshold) {
+				const ref = await uploadPayload(this.offload, serialized, "application/json");
+				this.completed[key] = {
+					resultType: "ref",
+					ref,
+					transparent: true
+				};
+				return JSON.parse(encoded);
+			}
+		}
+		this.completed[key] = { result: JSON.parse(encoded) };
+		return JSON.parse(encoded);
+	}
+	automaticEntry(kind, name, createValue) {
+		assertEntryName(name);
+		const key = `@${kind}/${name}`;
+		if (this.seenAutomaticEntries.has(key)) throw new Error(`workflow-sdk: duplicate ${kind} name "${name}"`);
+		this.seenAutomaticEntries.add(key);
+		const started = this.readOrRecord(key, createValue);
+		this.startedSteps.push(started);
+		return started;
+	}
+	runStep(nameOrTask, effectOrInput, options) {
+		if (typeof nameOrTask === "string") {
+			const name = nameOrTask;
+			if (typeof effectOrInput !== "function") throw new Error("workflow-sdk: inline step effect must be a function");
+			assertEntryName(name);
+			if (this.seenStepNames.has(name)) throw new Error(`workflow-sdk: duplicate step name "${name}"`);
+			this.seenStepNames.add(name);
+			const started = this.inlineStep.run(name, () => this.readOrRecord(name, effectOrInput)).catch((error) => {
+				throw error instanceof StepFailure ? error : new StepFailure(name, error);
+			});
+			this.startedSteps.push(started);
+			return this.trackInlineStepPromise(name, started);
+		}
+		const inlineStep = this.inlineStep.getStore();
+		if (inlineStep !== void 0) throw new Error(`workflow-sdk: engine-dispatched tasks cannot run inside inline step "${inlineStep}"`);
+		const id = options?.id ?? nameOrTask.name;
+		assertEntryName(id);
+		if (this.seenStepNames.has(id)) throw new Error(`workflow-sdk: duplicate step name "${id}"`);
+		this.seenStepNames.add(id);
+		if (hasOwn(this.journal, id)) {
+			this.consumeJournalEntry();
+			return Promise.resolve().then(() => readJournalResult(this.journal[id])).catch((error) => {
+				throw error instanceof StepFailure ? error : new StepFailure(id, error);
+			});
+		}
+		let input;
+		try {
+			input = cloneJSONValue(effectOrInput, "step input");
+		} catch (error) {
+			throw new StepFailure(id, error);
+		}
+		const unconsumed = new StepFailure(id, /* @__PURE__ */ new Error(`workflow-sdk: task step "${id}" must be awaited or returned`));
+		this.unconsumedTasks.set(id, unconsumed);
+		const lineage = this.inlinePromiseLineage.getStore();
+		return taskDispatchPromise(() => {
+			if (lineage !== void 0) lineage.durableTaskDispatched = true;
+			this.unconsumedTasks.delete(id);
+			this.dispatches.push({
+				id,
+				task: nameOrTask.name,
+				environment: nameOrTask.environment,
+				input,
+				...nameOrTask.maxConcurrency === void 0 ? {} : { maxConcurrency: nameOrTask.maxConcurrency }
+			});
+			this.resolveDispatch();
+		});
+	}
+	step = { run: ((nameOrTask, effectOrInput, options) => this.runStep(nameOrTask, effectOrInput, options)) };
+	files = { create: (data, options) => {
+		if (this.offload === void 0) return Promise.reject(/* @__PURE__ */ new Error("workflow-sdk: payload offload is not enabled for this run"));
+		return createWorkflowFile(this.offload, data, options);
+	} };
+	now = (name) => this.automaticEntry("now", name, () => Date.now());
+	uuid = (name) => this.automaticEntry("uuid", name, () => crypto.randomUUID());
+	promise = (name, options) => {
+		assertEntryName(name);
+		const key = `@promise/${name}`;
+		if (this.seenPromiseNames.has(name)) throw new Error(`workflow-sdk: duplicate promise name "${name}"`);
+		this.seenPromiseNames.add(name);
+		const timeoutSeconds = options?.timeoutSeconds;
+		if (timeoutSeconds !== void 0 && (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > 86400)) throw new Error("workflow-sdk: promise timeoutSeconds must be an integer between 1 and 86400");
+		if (hasOwn(this.journal, key)) {
+			this.consumeJournalEntry();
+			const entry = readJournalResult(this.journal[key]);
+			if (entry.status === "resolved") return Promise.resolve(structuredClone(entry.value));
+			return Promise.reject(new PromiseRejectedError(name, entry.reason ?? "promise rejected"));
+		}
+		this.unconsumedTasks.set(key, new StepFailure(key, /* @__PURE__ */ new Error(`workflow-sdk: promise "${name}" must be awaited or returned`)));
+		return taskDispatchPromise(() => {
+			this.unconsumedTasks.delete(key);
+			this.dispatches.push({
+				id: key,
+				task: "@promise",
+				environment: "cloudflare",
+				input: null,
+				promise: {
+					name,
+					...timeoutSeconds === void 0 ? {} : { timeoutSeconds }
+				}
+			});
+			this.resolveDispatch();
+		});
+	};
+	async settleStartedSteps() {
+		await Promise.allSettled(this.startedSteps);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+	}
+	unconsumedInlineFailure() {
+		for (const branch of this.unconsumedInlineSteps.values()) {
+			if (branch.state.status === "rejected") {
+				if (branch.inheritsRootRejection && branch.root.failureObserved && branch.root.state.status === "rejected" && branch.state.reason === branch.root.state.reason) continue;
+				return branch.state.reason instanceof StepFailure ? branch.state.reason : new StepFailure(branch.root.name, branch.state.reason);
+			}
+			if (branch.state.status === "fulfilled" || hasDurableTaskDispatch(branch.lineage)) continue;
+			if (branch.root.state.status === "rejected" && !branch.root.failureObserved) return branch.root.state.reason instanceof StepFailure ? branch.root.state.reason : new StepFailure(branch.root.name, branch.root.state.reason);
+			return new StepFailure(branch.root.name, /* @__PURE__ */ new Error(`workflow-sdk: inline step branch "${branch.root.name}" must be awaited or returned`));
+		}
+	}
+	unconsumedTaskFailure() {
+		return this.unconsumedTasks.values().next().value;
+	}
+	waitForDispatch() {
+		return this.dispatchReady;
+	}
+	hasDispatches() {
+		return this.dispatches.length > 0;
+	}
+	context() {
+		return {
+			input: this.input,
+			step: this.step,
+			files: this.files,
+			log: this.logger,
+			now: this.now,
+			uuid: this.uuid,
+			promise: this.promise
+		};
+	}
+	trackInlineStepPromise(name, promise, root, inheritsRootRejection = true, lineage) {
+		const state = { status: "pending" };
+		const inlineRoot = root ?? {
+			name,
+			failureObserved: false,
+			state
+		};
+		const inlineLineage = lineage ?? { durableTaskDispatched: false };
+		const branch = {
+			root: inlineRoot,
+			lineage: inlineLineage,
+			inheritsRootRejection,
+			state
+		};
+		this.unconsumedInlineSteps.set(promise, branch);
+		promise.then(() => {
+			state.status = "fulfilled";
+		}, (reason) => {
+			state.status = "rejected";
+			state.reason = reason;
+		});
+		let consumed = false;
+		return interceptPromiseMethods(promise, (method, args, invoke) => {
+			if (!consumed) {
+				consumed = true;
+				this.unconsumedInlineSteps.delete(promise);
+			}
+			const handlesRejection = method === "then" && typeof args[1] === "function" || method === "catch" && typeof args[0] === "function";
+			if (branch.inheritsRootRejection && handlesRejection) inlineRoot.failureObserved = true;
+			const childLineage = {
+				parent: inlineLineage,
+				durableTaskDispatched: false
+			};
+			const derived = invoke(args.map((arg) => typeof arg === "function" ? (...callbackArgs) => this.inlinePromiseLineage.run(childLineage, () => Reflect.apply(arg, void 0, callbackArgs)) : arg));
+			return this.trackInlineStepPromise(name, derived, inlineRoot, branch.inheritsRootRejection && !handlesRejection, childLineage);
+		});
+	}
+};
+var StepFailure = class extends Error {
+	stepName;
+	reason;
+	constructor(stepName, reason) {
+		super(errorMessage(reason));
+		this.stepName = stepName;
+		this.reason = reason;
+	}
+};
+function assertEntryName(name) {
+	if (!/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(name)) throw new Error(`workflow-sdk: invalid journal entry name "${name}"`);
+}
+function encodeJSONValue(value, kind) {
+	try {
+		const encoded = JSON.stringify(value);
+		if (encoded === void 0) throw new Error("unsupported value");
+		return encoded;
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("workflow-sdk:")) throw error;
+		throw new Error(`workflow-sdk: ${kind} must be JSON-serializable`);
+	}
+}
+function cloneJSONValue(value, kind) {
+	return JSON.parse(encodeJSONValue(value, kind));
+}
+function readJournalResult(entry) {
+	if (entry.resultType === "undefined") return void 0;
+	if (entry.resultType === "ref") return resolveJournalRef(entry);
+	return structuredClone(entry.result);
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function utf8PayloadBytes(text) {
+	return new TextEncoder().encode(text).slice();
+}
+const PAYLOAD_SCHEME = "CHUNKED_AES_256_GCM_V1";
+const PAYLOAD_SEGMENT_SIZE = 1048576;
+const PAYLOAD_NONCE_BYTES = 12;
+const PAYLOAD_TAG_BYTES = 16;
+const PAYLOAD_AAD_PREFIX = new TextEncoder().encode("lovable-workflow-payload/v1");
+const PAYLOAD_MAX_FRAME_BYTES = 1048604;
+const payloadOffloadPath = "/runtime/v1/payloads";
+function isPayloadRefValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && hasOwn(value, "bucket") && typeof value.bucket === "string" && value.bucket.length > 0 && value.bucket.length <= 128 && hasOwn(value, "key") && typeof value.key === "string" && value.key.length > 0 && value.key.length <= 1024 && hasOwn(value, "sha256") && typeof value.sha256 === "string" && /^[0-9a-f]{64}$/.test(value.sha256) && hasOwn(value, "sizeBytes") && typeof value.sizeBytes === "number" && Number.isSafeInteger(value.sizeBytes) && value.sizeBytes >= 0 && hasOwn(value, "contentType") && typeof value.contentType === "string" && value.contentType.length > 0 && value.contentType.length <= 256 && hasOwn(value, "wrappedDek") && typeof value.wrappedDek === "string" && hasOwn(value, "kekId") && typeof value.kekId === "string" && value.kekId.length > 0 && value.kekId.length <= 128 && hasOwn(value, "scheme") && value.scheme === PAYLOAD_SCHEME;
+}
+function isPayloadGrantValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && hasOwn(value, "getUrl") && typeof value.getUrl === "string" && value.getUrl.length > 0 && hasOwn(value, "dek") && typeof value.dek === "string" && value.dek.length > 0;
+}
+function isPayloadOffloadValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && hasOwn(value, "endpoint") && typeof value.endpoint === "string" && value.endpoint.length > 0 && value.endpoint.length <= 2048 && hasOwn(value, "threshold") && typeof value.threshold === "number" && Number.isSafeInteger(value.threshold) && value.threshold >= 0 && hasOwn(value, "maxBytes") && typeof value.maxBytes === "number" && Number.isSafeInteger(value.maxBytes) && value.maxBytes >= 1;
+}
+function normalizedPayloadOffload(value) {
+	if (value === void 0) return void 0;
+	if (!isPayloadOffloadValue(value)) throw new Error("workflow-sdk: invalid payload offload configuration");
+	return {
+		endpoint: value.endpoint,
+		threshold: value.threshold,
+		maxBytes: value.maxBytes
+	};
+}
+function isJournalEntryValue(entry) {
+	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return false;
+	if (hasOwn(entry, "resultType") && entry.resultType === "ref") return !hasOwn(entry, "result") && hasOwn(entry, "ref") && isPayloadRefValue(entry.ref) && (!hasOwn(entry, "transparent") || typeof entry.transparent === "boolean") && (!hasOwn(entry, "grant") || isPayloadGrantValue(entry.grant));
+	return hasOwn(entry, "result") && (!hasOwn(entry, "resultType") || entry.resultType === "undefined");
+}
+const SHA256_K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+function rotr32(value, count) {
+	return value >>> count | value << 32 - count;
+}
+var Sha256 = class {
+	state = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	block = /* @__PURE__ */ new Uint8Array(64);
+	schedule = /* @__PURE__ */ new Uint32Array(64);
+	blockBytes = 0;
+	totalBytes = 0;
+	update(data) {
+		this.totalBytes += data.length;
+		let offset = 0;
+		while (offset < data.length) {
+			const take = Math.min(64 - this.blockBytes, data.length - offset);
+			this.block.set(data.subarray(offset, offset + take), this.blockBytes);
+			this.blockBytes += take;
+			offset += take;
+			if (this.blockBytes === 64) {
+				this.compress();
+				this.blockBytes = 0;
+			}
+		}
+	}
+	/** Finalizes the digest; the instance must not be updated afterwards. */
+	hex() {
+		const bitLength = BigInt(this.totalBytes) * 8n;
+		this.update(new Uint8Array([128]));
+		while (this.blockBytes !== 56) this.update(/* @__PURE__ */ new Uint8Array(1));
+		const length = /* @__PURE__ */ new Uint8Array(8);
+		new DataView(length.buffer).setBigUint64(0, bitLength, false);
+		this.update(length);
+		let hex = "";
+		for (const word of this.state) hex += word.toString(16).padStart(8, "0");
+		return hex;
+	}
+	compress() {
+		const words = this.schedule;
+		const view = new DataView(this.block.buffer);
+		for (let index = 0; index < 16; index++) words[index] = view.getUint32(index * 4, false);
+		for (let index = 16; index < 64; index++) {
+			const s0 = rotr32(words[index - 15], 7) ^ rotr32(words[index - 15], 18) ^ words[index - 15] >>> 3;
+			const s1 = rotr32(words[index - 2], 17) ^ rotr32(words[index - 2], 19) ^ words[index - 2] >>> 10;
+			words[index] = words[index - 16] + s0 + words[index - 7] + s1;
+		}
+		let [a, b, c, d, e, f, g, h] = this.state;
+		for (let index = 0; index < 64; index++) {
+			const s1 = rotr32(e, 6) ^ rotr32(e, 11) ^ rotr32(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = h + s1 + ch + SHA256_K[index] + words[index] | 0;
+			const t2 = (rotr32(a, 2) ^ rotr32(a, 13) ^ rotr32(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		this.state[0] += a;
+		this.state[1] += b;
+		this.state[2] += c;
+		this.state[3] += d;
+		this.state[4] += e;
+		this.state[5] += f;
+		this.state[6] += g;
+		this.state[7] += h;
+	}
+};
+var ByteQueue = class {
+	chunks = [];
+	length = 0;
+	get size() {
+		return this.length;
+	}
+	push(chunk) {
+		if (chunk.length === 0) return;
+		this.chunks.push(chunk);
+		this.length += chunk.length;
+	}
+	peek(count) {
+		if (this.length < count) return void 0;
+		const out = new Uint8Array(count);
+		let offset = 0;
+		for (const chunk of this.chunks) {
+			const slice = chunk.subarray(0, Math.min(chunk.length, count - offset));
+			out.set(slice, offset);
+			offset += slice.length;
+			if (offset === count) break;
+		}
+		return out;
+	}
+	take(count) {
+		const out = new Uint8Array(count);
+		let offset = 0;
+		while (offset < count) {
+			const head = this.chunks[0];
+			const needed = count - offset;
+			if (head.length <= needed) {
+				out.set(head, offset);
+				offset += head.length;
+				this.chunks.shift();
+			} else {
+				out.set(head.subarray(0, needed), offset);
+				this.chunks[0] = head.subarray(needed);
+				offset = count;
+			}
+		}
+		this.length -= count;
+		return out;
+	}
+};
+function payloadSegmentAad(index, final) {
+	const aad = new Uint8Array(PAYLOAD_AAD_PREFIX.length + 9);
+	aad.set(PAYLOAD_AAD_PREFIX, 0);
+	new DataView(aad.buffer).setBigUint64(PAYLOAD_AAD_PREFIX.length, BigInt(index), false);
+	aad[aad.length - 1] = final ? 1 : 0;
+	return aad;
+}
+async function sealPayloadSegment(key, index, final, plaintext) {
+	const nonce = crypto.getRandomValues(new Uint8Array(PAYLOAD_NONCE_BYTES));
+	const sealed = new Uint8Array(await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: nonce,
+		additionalData: payloadSegmentAad(index, final)
+	}, key, plaintext));
+	const frame = new Uint8Array(16 + sealed.length);
+	new DataView(frame.buffer).setUint32(0, PAYLOAD_NONCE_BYTES + sealed.length, false);
+	frame.set(nonce, 4);
+	frame.set(sealed, 16);
+	return frame;
+}
+async function openPayloadSegment(key, nonce, sealed, index, final) {
+	try {
+		return new Uint8Array(await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv: nonce,
+			additionalData: payloadSegmentAad(index, final)
+		}, key, sealed));
+	} catch {
+		return;
+	}
+}
+/** Chunked AES-256-GCM encryptor emitting [payloadLen u32 BE][nonce 12][ciphertext||tag] frames. */
+function encryptPayloadStream(key) {
+	const pending = new ByteQueue();
+	let index = 0;
+	return new TransformStream({
+		async transform(chunk, controller) {
+			if (!(chunk instanceof Uint8Array)) throw new Error("workflow-sdk: payload streams must produce Uint8Array chunks");
+			pending.push(chunk.slice());
+			while (pending.size > PAYLOAD_SEGMENT_SIZE) {
+				controller.enqueue(await sealPayloadSegment(key, index, false, pending.take(PAYLOAD_SEGMENT_SIZE)));
+				index += 1;
+			}
+		},
+		async flush(controller) {
+			controller.enqueue(await sealPayloadSegment(key, index, true, pending.take(pending.size)));
+		}
+	});
+}
+/** Decrypts CHUNKED_AES_256_GCM_V1; rejects truncation, reordering, splices, and digest or size mismatches. */
+function decryptPayloadStream(key, expected) {
+	const pending = new ByteQueue();
+	const digest = new Sha256();
+	let index = 0;
+	let finalSeen = false;
+	let plaintextBytes = 0;
+	const drain = async (controller) => {
+		for (;;) {
+			const header = pending.peek(4);
+			if (header === void 0) return;
+			const payloadLength = new DataView(header.buffer).getUint32(0, false);
+			if (payloadLength < 28 || payloadLength > PAYLOAD_MAX_FRAME_BYTES) throw new Error("workflow-sdk: offloaded payload frame has an invalid length");
+			if (pending.size < 4 + payloadLength) return;
+			if (finalSeen) throw new Error("workflow-sdk: offloaded payload has data after the final segment");
+			pending.take(4);
+			const frame = pending.take(payloadLength);
+			const nonce = frame.subarray(0, PAYLOAD_NONCE_BYTES);
+			const sealed = frame.subarray(PAYLOAD_NONCE_BYTES);
+			let plaintext = sealed.length - PAYLOAD_TAG_BYTES === PAYLOAD_SEGMENT_SIZE ? await openPayloadSegment(key, nonce, sealed, index, false) : void 0;
+			if (plaintext === void 0) {
+				plaintext = await openPayloadSegment(key, nonce, sealed, index, true);
+				if (plaintext === void 0) throw new Error("workflow-sdk: offloaded payload segment failed authentication");
+				finalSeen = true;
+			}
+			index += 1;
+			plaintextBytes += plaintext.length;
+			digest.update(plaintext);
+			if (plaintext.length > 0) controller.enqueue(plaintext);
+		}
+	};
+	return new TransformStream({
+		async transform(chunk, controller) {
+			if (!(chunk instanceof Uint8Array)) throw new Error("workflow-sdk: payload streams must produce Uint8Array chunks");
+			pending.push(chunk.slice());
+			await drain(controller);
+		},
+		async flush(controller) {
+			await drain(controller);
+			if (!finalSeen) throw new Error("workflow-sdk: offloaded payload is truncated before its final segment");
+			if (pending.size > 0) throw new Error("workflow-sdk: offloaded payload has trailing bytes after the final segment");
+			if (plaintextBytes !== expected.sizeBytes) throw new Error("workflow-sdk: offloaded payload size does not match its journal pointer");
+			if (digest.hex() !== expected.sha256) throw new Error("workflow-sdk: offloaded payload digest does not match its journal pointer");
+		}
+	});
+}
+function decodeBase64(value, kind) {
+	try {
+		const decoded = atob(value);
+		const bytes = new Uint8Array(decoded.length);
+		for (let index = 0; index < decoded.length; index++) bytes[index] = decoded.charCodeAt(index);
+		return bytes;
+	} catch {
+		throw new Error(`workflow-sdk: ${kind} is not valid base64`);
+	}
+}
+function hexDigest(bytes) {
+	let hex = "";
+	for (const byte of new Uint8Array(bytes)) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+}
+async function importPayloadDek(dek) {
+	const raw = decodeBase64(dek, "payload DEK");
+	if (raw.length !== 32) throw new Error("workflow-sdk: payload DEK must be 32 bytes");
+	return crypto.subtle.importKey("raw", raw, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+function httpsUrl(value, kind) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		throw new Error(`workflow-sdk: ${kind} is not a valid URL`);
+	}
+	if (url.protocol !== "https:") throw new Error(`workflow-sdk: ${kind} must use https`);
+	return value;
+}
+async function collectStream(stream) {
+	const reader = stream.getReader();
+	const pending = new ByteQueue();
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (!(value instanceof Uint8Array)) {
+			reader.cancel().catch(() => void 0);
+			throw new Error("workflow-sdk: payload streams must produce Uint8Array chunks");
+		}
+		pending.push(value.slice());
+	}
+	return pending.take(pending.size);
+}
+async function encryptPayloadBytes(key, plaintext) {
+	return collectStream(new ReadableStream({ start(controller) {
+		if (plaintext.length > 0) controller.enqueue(plaintext);
+		controller.close();
+	} }).pipeThrough(encryptPayloadStream(key)));
+}
+function payloadOffloadEndpoint(endpoint) {
+	for (const origin of workflowApiOrigins) if (endpoint === `${origin}${payloadOffloadPath}`) return endpoint;
+	throw new Error("workflow-sdk: payload offload endpoint is not an allowed workflows origin");
+}
+async function requestPayloadUpload(offload, sha256, sizeBytes, contentType) {
+	const endpoint = payloadOffloadEndpoint(offload.endpoint);
+	let response;
+	try {
+		response = await fetch(endpoint, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				sha256,
+				sizeBytes,
+				contentType
+			}),
+			redirect: "error"
+		});
+	} catch {
+		throw new Error("workflow-sdk: payload offload request failed");
+	}
+	if (!response.ok) throw new Error("workflow-sdk: payload offload request failed");
+	let body;
+	try {
+		body = await response.json();
+	} catch {
+		throw new Error("workflow-sdk: invalid payload offload response");
+	}
+	if (typeof body !== "object" || body === null || Array.isArray(body) || !hasOwn(body, "putUrl") || typeof body.putUrl !== "string" || !hasOwn(body, "dek") || typeof body.dek !== "string" || !hasOwn(body, "ref") || !isPayloadRefValue(body.ref)) throw new Error("workflow-sdk: invalid payload offload response");
+	const ref = structuredClone(body.ref);
+	if (ref.sha256 !== sha256 || ref.sizeBytes !== sizeBytes || ref.contentType !== contentType) throw new Error("workflow-sdk: payload offload response does not match the requested payload");
+	return {
+		putUrl: httpsUrl(body.putUrl, "payload upload URL"),
+		key: await importPayloadDek(body.dek),
+		ref
+	};
+}
+async function uploadPayload(offload, plaintext, contentType) {
+	if (plaintext.byteLength > offload.maxBytes) throw new Error(`workflow-sdk: payload of ${plaintext.byteLength} bytes exceeds the offload limit of ${offload.maxBytes} bytes`);
+	const ticket = await requestPayloadUpload(offload, hexDigest(await crypto.subtle.digest("SHA-256", plaintext)), plaintext.byteLength, contentType);
+	const ciphertext = await encryptPayloadBytes(ticket.key, plaintext);
+	let response;
+	try {
+		response = await fetch(ticket.putUrl, {
+			method: "PUT",
+			headers: { "content-type": "application/octet-stream" },
+			body: ciphertext,
+			redirect: "error"
+		});
+	} catch {
+		throw new Error("workflow-sdk: payload upload failed");
+	}
+	if (!response.ok) throw new Error("workflow-sdk: payload upload failed");
+	return ticket.ref;
+}
+function openPayloadReadStream(ref, grant) {
+	const relay = new TransformStream();
+	(async () => {
+		const getUrl = httpsUrl(grant.getUrl, "payload read URL");
+		const key = await importPayloadDek(grant.dek);
+		let response;
+		try {
+			response = await fetch(getUrl, {
+				method: "GET",
+				redirect: "error"
+			});
+		} catch {
+			throw new Error("workflow-sdk: offloaded payload download failed");
+		}
+		if (!response.ok || response.body === null) throw new Error("workflow-sdk: offloaded payload download failed");
+		await response.body.pipeThrough(decryptPayloadStream(key, {
+			sha256: ref.sha256,
+			sizeBytes: ref.sizeBytes
+		})).pipeTo(relay.writable);
+	})().catch((error) => {
+		relay.writable.abort(error).catch(() => void 0);
+	});
+	return relay.readable;
+}
+var PayloadFile = class {
+	ref;
+	source;
+	constructor(ref, source) {
+		this.ref = ref;
+		this.source = source;
+	}
+	get sha256() {
+		return this.ref.sha256;
+	}
+	get sizeBytes() {
+		return this.ref.sizeBytes;
+	}
+	get contentType() {
+		return this.ref.contentType;
+	}
+	stream() {
+		if (this.source.kind === "local") {
+			const bytes = this.source.bytes.slice();
+			return new ReadableStream({ start(controller) {
+				if (bytes.length > 0) controller.enqueue(bytes);
+				controller.close();
+			} });
+		}
+		return openPayloadReadStream(this.ref, this.source.grant);
+	}
+	async arrayBuffer() {
+		const bytes = this.source.kind === "local" ? this.source.bytes : await collectStream(this.stream());
+		const copy = new ArrayBuffer(bytes.byteLength);
+		new Uint8Array(copy).set(bytes);
+		return copy;
+	}
+	async text() {
+		return new TextDecoder().decode(await this.arrayBuffer());
+	}
+	async json() {
+		return JSON.parse(await this.text());
+	}
+	/** Handles journal as their pointer only as a step's direct result; nesting fails loudly. */
+	toJSON() {
+		throw new Error("workflow-sdk: a WorkflowFile must be a step's direct result, not nested inside a JSON value");
+	}
+};
+function resolveJournalRef(entry) {
+	const ref = entry.ref;
+	if (ref === void 0 || !isPayloadRefValue(ref)) throw new Error("workflow-sdk: offloaded journal entry carries a malformed payload pointer");
+	if (entry.grant === void 0) throw new Error("workflow-sdk: journal entry points at an offloaded payload but carries no read grant; the engine must hydrate grants before invocation (permanent)");
+	if (!isPayloadGrantValue(entry.grant)) throw new Error("workflow-sdk: offloaded journal entry carries a malformed read grant");
+	const file = new PayloadFile(structuredClone(ref), {
+		kind: "remote",
+		grant: structuredClone(entry.grant)
+	});
+	return entry.transparent === true ? file.json() : file;
+}
+async function payloadCreateBytes(data) {
+	if (typeof data === "string") return utf8PayloadBytes(data);
+	if (data instanceof Uint8Array) return data.slice();
+	if (data instanceof ArrayBuffer) return new Uint8Array(data.slice(0));
+	if (data instanceof ReadableStream) return collectStream(data);
+	throw new Error("workflow-sdk: files.create accepts a ReadableStream, ArrayBuffer, Uint8Array, or string");
+}
+async function createWorkflowFile(offload, data, options) {
+	if (typeof options !== "object" || options === null || typeof options.contentType !== "string") throw new Error("workflow-sdk: files.create requires a contentType");
+	if (options.contentType.length === 0 || options.contentType.length > 256) throw new Error("workflow-sdk: files.create contentType must be 1-256 characters");
+	const plaintext = await payloadCreateBytes(data);
+	return new PayloadFile(await uploadPayload(offload, plaintext, options.contentType), {
+		kind: "local",
+		bytes: plaintext
+	});
+}
+const WORKFLOW_LOG_ENVELOPE_KEY = "__lovable_workflow_log";
+const MAX_LOG_MESSAGE_CHARS = 8192;
+const MAX_LOGS_PER_INVOCATION = 512;
+const MAX_LOG_FIELDS = 64;
+const MAX_LOG_FIELD_CHARS = 2048;
+const CREDENTIAL_NAME_ALTERNATION = [
+	"password",
+	"passwd",
+	"secret",
+	"token",
+	"authorization",
+	"auth",
+	"signature",
+	"sig",
+	"credential",
+	"cookie",
+	"session",
+	"key"
+].join("|");
+const LOG_SCRUB_RULES = [
+	{
+		pattern: /-----BEGIN[A-Z ]*PRIVATE KEY-----[\s\S]+?-----END[A-Z ]*PRIVATE KEY-----/g,
+		replacement: "[REDACTED:private-key]"
+	},
+	{
+		pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}(?:\.[A-Za-z0-9_-]+)?/g,
+		replacement: "[REDACTED:jwt]"
+	},
+	{
+		pattern: /\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{12,}/gi,
+		replacement: "$1 [REDACTED]"
+	},
+	{
+		pattern: /\bsk[-_][A-Za-z0-9_-]{10,}/g,
+		replacement: "[REDACTED:api-key]"
+	},
+	{
+		pattern: /\brk_(?:live|test)_[A-Za-z0-9]{10,}/g,
+		replacement: "[REDACTED:api-key]"
+	},
+	{
+		pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+		replacement: "[REDACTED:github-token]"
+	},
+	{
+		pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+		replacement: "[REDACTED:github-token]"
+	},
+	{
+		pattern: /\bxox[abeprst]-[A-Za-z0-9-]{10,}/g,
+		replacement: "[REDACTED:slack-token]"
+	},
+	{
+		pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+		replacement: "[REDACTED:aws-key]"
+	},
+	{
+		pattern: /\bAIza[0-9A-Za-z_-]{30,}/g,
+		replacement: "[REDACTED:google-key]"
+	},
+	{
+		pattern: /\bya29\.[0-9A-Za-z_-]{20,}/g,
+		replacement: "[REDACTED:google-token]"
+	},
+	{
+		pattern: /\bglpat-[A-Za-z0-9_-]{20,}/g,
+		replacement: "[REDACTED:gitlab-token]"
+	},
+	{
+		pattern: /\bnpm_[A-Za-z0-9]{30,}/g,
+		replacement: "[REDACTED:npm-token]"
+	},
+	{
+		pattern: new RegExp(`((?:${CREDENTIAL_NAME_ALTERNATION})s?["']?\\s*[:=]\\s*["']?)[^\\s"'\`,;&]{6,}`, "gi"),
+		replacement: "$1[REDACTED]"
+	}
+];
+const SENSITIVE_FIELD_KEY = new RegExp(`(?:${CREDENTIAL_NAME_ALTERNATION})`, "i");
+function truncateLogText(text, max) {
+	if (text.length <= max) return text;
+	let end = max;
+	const tail = text.charCodeAt(end - 1);
+	if (tail >= 55296 && tail <= 56319) end -= 1;
+	return `${text.slice(0, end)}…[truncated]`;
+}
+function scrubLogText(text) {
+	let scrubbed = text;
+	for (const rule of LOG_SCRUB_RULES) scrubbed = scrubbed.replace(rule.pattern, rule.replacement);
+	return scrubbed;
+}
+function sanitizeLogFields(fields) {
+	const sanitized = {};
+	let count = 0;
+	for (const [key, value] of Object.entries(fields)) {
+		if (key.length === 0 || key.length > 128) continue;
+		if (count >= MAX_LOG_FIELDS) {
+			sanitized.__fields_truncated = true;
+			break;
+		}
+		count += 1;
+		if (SENSITIVE_FIELD_KEY.test(key)) {
+			sanitized[key] = "[REDACTED]";
+			continue;
+		}
+		if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+			sanitized[key] = value;
+			continue;
+		}
+		let text;
+		if (typeof value === "string") text = value;
+		else try {
+			text = JSON.stringify(value) ?? String(value);
+		} catch {
+			text = "[unserializable]";
+		}
+		sanitized[key] = truncateLogText(scrubLogText(text), MAX_LOG_FIELD_CHARS);
+	}
+	return count > 0 || hasOwn(sanitized, "__fields_truncated") ? sanitized : void 0;
+}
+function safeEmit(emit, entry) {
+	try {
+		emit(entry);
+	} catch {}
+}
+function createWorkflowLogger(emit, isReplaying) {
+	let emitted = 0;
+	let limitReported = false;
+	const record = (level, message, fields) => {
+		if (isReplaying?.() === true) return;
+		if (emitted >= MAX_LOGS_PER_INVOCATION) {
+			if (!limitReported) {
+				limitReported = true;
+				safeEmit(emit, {
+					level: "warn",
+					message: `workflow-sdk: log limit of ${MAX_LOGS_PER_INVOCATION} entries reached; further logs dropped`
+				});
+			}
+			return;
+		}
+		emitted += 1;
+		const text = truncateLogText(scrubLogText(typeof message === "string" ? message : String(message)), MAX_LOG_MESSAGE_CHARS);
+		const sanitizedFields = fields === null || typeof fields !== "object" || Array.isArray(fields) ? void 0 : sanitizeLogFields(fields);
+		safeEmit(emit, {
+			level,
+			message: text,
+			...sanitizedFields === void 0 ? {} : { fields: sanitizedFields }
+		});
+	};
+	return {
+		debug: (message, fields) => record("debug", message, fields),
+		info: (message, fields) => record("info", message, fields),
+		warn: (message, fields) => record("warn", message, fields),
+		error: (message, fields) => record("error", message, fields)
+	};
+}
+const envelopeLogEmitter = (entry) => {
+	const line = JSON.stringify({
+		[WORKFLOW_LOG_ENVELOPE_KEY]: 1,
+		level: entry.level,
+		message: entry.message,
+		...entry.fields === void 0 ? {} : { fields: entry.fields }
+	});
+	if (entry.level === "debug") console.debug(line);
+	else if (entry.level === "warn") console.warn(line);
+	else if (entry.level === "error") console.error(line);
+	else console.info(line);
+};
+async function invoke(workflow, request, options = {}) {
+	const execution = new Execution(request.input, request.journal ?? {}, normalizedPayloadOffload(request.payloadOffload), options.onLog ?? envelopeLogEmitter);
+	let settledHandlerOutcome;
+	const settleHandler = (outcome) => {
+		settledHandlerOutcome = outcome;
+		return outcome;
+	};
+	const dispatchOutcome = execution.waitForDispatch().then(() => ({ kind: "dispatch" }));
+	const handlerOutcome = Promise.resolve().then(() => workflow.handler(execution.context())).then((output) => settleHandler({
+		kind: "done",
+		output
+	}), (error) => settleHandler({
+		kind: "failed",
+		error
+	}));
+	const outcome = await Promise.race([dispatchOutcome, handlerOutcome]);
+	await execution.settleStartedSteps();
+	if (outcome.kind === "dispatch" || execution.hasDispatches()) {
+		if (settledHandlerOutcome?.kind === "failed") return failedWorkerResponse(settledHandlerOutcome.error, execution.completed);
+		const unconsumedInlineFailure = execution.unconsumedInlineFailure();
+		if (unconsumedInlineFailure !== void 0) return failedWorkerResponse(unconsumedInlineFailure, execution.completed);
+		const unconsumedTask = execution.unconsumedTaskFailure();
+		if (unconsumedTask !== void 0) return failedWorkerResponse(unconsumedTask, execution.completed);
+		return {
+			status: "dispatch",
+			steps: execution.dispatches,
+			completed: execution.completed
+		};
+	}
+	if (outcome.kind === "done") {
+		const unconsumedInlineFailure = execution.unconsumedInlineFailure();
+		if (unconsumedInlineFailure !== void 0) return failedWorkerResponse(unconsumedInlineFailure, execution.completed);
+		const unconsumedTask = execution.unconsumedTaskFailure();
+		if (unconsumedTask !== void 0) return failedWorkerResponse(unconsumedTask, execution.completed);
+		if (outcome.output === void 0) return {
+			status: "done",
+			output: null,
+			outputType: "undefined",
+			completed: execution.completed
+		};
+		return {
+			status: "done",
+			output: outcome.output,
+			completed: execution.completed
+		};
+	}
+	return failedWorkerResponse(outcome.error, execution.completed);
+}
+function failedWorkerResponse(error, completed) {
+	const stepFailure = error instanceof StepFailure ? error : void 0;
+	const failedStep = stepFailure?.stepName ?? (error instanceof PromiseRejectedError ? `@promise/${error.promiseName}` : void 0);
+	return {
+		status: "failed",
+		error: errorMessage(stepFailure?.reason ?? error),
+		...failedStep === void 0 ? {} : { failedStep },
+		completed
+	};
+}
+function jsonResponse(body, status) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+function isWorkerRequest(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (!hasOwn(value, "input") || !hasOwn(value, "journal")) return false;
+	if (hasOwn(value, "payloadOffload") && value.payloadOffload !== void 0 && !isPayloadOffloadValue(value.payloadOffload)) return false;
+	const journal = value.journal;
+	if (typeof journal !== "object" || journal === null || Array.isArray(journal)) return false;
+	return Object.entries(journal).every(([name, entry]) => (/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(name) || /^@(now|uuid|promise)\/[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(name)) && isJournalEntryValue(entry));
+}
+function isWorkerTaskRequest(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (!hasOwn(value, "operation") || !hasOwn(value, "task") || !hasOwn(value, "input") || !hasOwn(value, "runName") || !hasOwn(value, "stepId") || !hasOwn(value, "attempt") || !hasOwn(value, "workflowTenant") || !hasOwn(value, "workflowApiUrl")) return false;
+	return value.operation === "task" && typeof value.task === "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(value.task) && typeof value.runName === "string" && value.runName.length > 0 && value.runName.length <= 2048 && typeof value.stepId === "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(value.stepId) && typeof value.attempt === "number" && Number.isInteger(value.attempt) && value.attempt > 0 && value.attempt <= 2147483647 && typeof value.workflowTenant === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value.workflowTenant) && typeof value.workflowApiUrl === "string";
+}
+const workflowApiOrigins = /* @__PURE__ */ new Set(["https://workflows.lovable.dev", "https://workflows.d.l5e.io"]);
+function workflowApiOrigin(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.endsWith("/") ? value.slice(0, -1) : value;
+	return workflowApiOrigins.has(normalized) ? normalized : void 0;
+}
+function workflowIdentifier(value, kind) {
+	if (typeof value !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(value)) throw new Error(`workflow-sdk: invalid ${kind}`);
+	return value;
+}
+function workflowRunResponse(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("workflow-sdk: invalid workflow invocation response");
+	const id = hasOwn(value, "id") ? value.id : void 0;
+	const state = hasOwn(value, "state") ? value.state : void 0;
+	const codeAttempt = hasOwn(value, "code_attempt") ? value.code_attempt : void 0;
+	if (typeof id !== "string" || typeof state !== "string" || codeAttempt !== void 0 && (typeof codeAttempt !== "number" || !Number.isInteger(codeAttempt))) throw new Error("workflow-sdk: invalid workflow invocation response");
+	return {
+		id,
+		state,
+		...hasOwn(value, "error") && typeof value.error === "string" ? { error: value.error } : {},
+		...hasOwn(value, "inputs") ? { inputs: value.inputs } : {},
+		...hasOwn(value, "outputs") ? { outputs: value.outputs } : {},
+		...codeAttempt === void 0 ? {} : { codeAttempt },
+		...hasOwn(value, "create_time") && typeof value.create_time === "string" ? { createTime: value.create_time } : {},
+		...hasOwn(value, "start_time") && typeof value.start_time === "string" ? { startTime: value.start_time } : {},
+		...hasOwn(value, "end_time") && typeof value.end_time === "string" ? { endTime: value.end_time } : {}
+	};
+}
+function workflowsApi(origin, tenantId) {
+	const invocations = /* @__PURE__ */ new Set();
+	return { async run(request) {
+		if (origin === void 0) throw new Error("workflow-sdk: workflow API is not configured");
+		if (typeof request !== "object" || request === null || Array.isArray(request)) throw new Error("workflow-sdk: invalid workflow invocation");
+		const workspaceId = workflowIdentifier(request.workspaceId, "workflow workspace ID");
+		const projectId = workflowIdentifier(request.projectId, "workflow project ID");
+		const workflowId = workflowIdentifier(request.workflowId, "workflow ID");
+		if (request.invocationKey !== void 0 && (typeof request.invocationKey !== "string" || request.invocationKey.length > 128)) throw new Error("workflow-sdk: invalid workflow invocation key");
+		const parent = `tenants/${tenantId}/workspaces/${workspaceId}/workflows/${workflowId}`;
+		const invocation = `${parent}\0${request.invocationKey ?? ""}`;
+		if (invocations.has(invocation)) throw new Error("workflow-sdk: duplicate workflow invocation key");
+		invocations.add(invocation);
+		const inputs = request.inputs === void 0 ? void 0 : cloneJSONValue(request.inputs, "workflow inputs");
+		let response;
+		try {
+			response = await fetch(`${origin}/runtime/v1/runs`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					parent,
+					project_id: projectId,
+					run: inputs === void 0 ? {} : { inputs },
+					...request.invocationKey === void 0 ? {} : { invocation_key: request.invocationKey }
+				}),
+				redirect: "error"
+			});
+		} catch {
+			throw new Error("workflow-sdk: workflow invocation failed");
+		}
+		if (!response.ok) throw new Error("workflow-sdk: workflow invocation failed");
+		try {
+			return workflowRunResponse(await response.json());
+		} catch (error) {
+			if (error instanceof Error && error.message === "workflow-sdk: invalid workflow invocation response") throw error;
+			throw new Error("workflow-sdk: invalid workflow invocation response");
+		}
+	} };
+}
+function validatedWorkflowDefinition(value) {
+	if (typeof value !== "object" || value === null || !hasOwn(value, "name") || !hasOwn(value, "handler")) throw new Error("workflow-sdk: invalid workflow definition");
+	if (typeof value.name !== "string" || typeof value.handler !== "function") throw new Error("workflow-sdk: invalid workflow definition");
+	assertEntryName(value.name);
+	return value;
+}
+function validatedTaskDefinition(value) {
+	if (typeof value !== "object" || value === null || !hasOwn(value, "name") || !hasOwn(value, "environment") || !hasOwn(value, "run") || typeof value.name !== "string" || value.environment !== "cloudflare" || typeof value.run !== "function") throw new Error("workflow-sdk: invalid task definition");
+	return defineTask(value);
+}
+function validatedTaskDefinitions(value) {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error("workflow-sdk: tasks must be an array of task definitions");
+	return value.map((task) => validatedTaskDefinition(task));
+}
+function toWorker(workflowValue, options = {}) {
+	const workflow = validatedWorkflowDefinition(workflowValue);
+	const tasks = /* @__PURE__ */ new Map();
+	for (const task of validatedTaskDefinitions(options.tasks)) {
+		if (tasks.has(task.name)) throw new Error(`workflow-sdk: duplicate registered task name "${task.name}"`);
+		tasks.set(task.name, task);
+	}
+	return { async fetch(request) {
+		let body;
+		try {
+			body = await request.json();
+		} catch {
+			return jsonResponse({
+				status: "failed",
+				error: "invalid request body",
+				completed: {}
+			}, 400);
+		}
+		if (isWorkerTaskRequest(body)) {
+			const workflowApiUrl = workflowApiOrigin(body.workflowApiUrl);
+			if (body.workflowApiUrl !== "" && workflowApiUrl === void 0) return jsonResponse({
+				status: "failed",
+				error: "workflow API is not configured",
+				completed: {}
+			}, 503);
+			const task = tasks.get(body.task);
+			if (task?.environment !== "cloudflare") return jsonResponse({
+				status: "failed",
+				error: "task is not registered",
+				completed: {}
+			}, 400);
+			try {
+				const result = await task.run(body.input, {
+					runName: body.runName,
+					stepId: body.stepId,
+					attempt: body.attempt,
+					workflows: workflowsApi(workflowApiUrl, body.workflowTenant),
+					log: createWorkflowLogger(envelopeLogEmitter)
+				});
+				return jsonResponse({
+					status: "done",
+					output: result === void 0 ? null : cloneJSONValue(result, "task output"),
+					...result === void 0 ? { outputType: "undefined" } : {},
+					completed: {}
+				}, 200);
+			} catch (err) {
+				return jsonResponse({
+					status: "failed",
+					error: errorMessage(err),
+					failedStep: body.task,
+					completed: {}
+				}, 200);
+			}
+		}
+		if (!isWorkerRequest(body)) return jsonResponse({
+			status: "failed",
+			error: "invalid request body",
+			completed: {}
+		}, 400);
+		const response = await invoke(workflow, body);
+		try {
+			return jsonResponse(response, 200);
+		} catch {
+			return jsonResponse({
+				status: "failed",
+				error: "workflow output is not JSON-serializable",
+				completed: response.completed
+			}, 200);
+		}
+	} };
+}
+async function driveToCompletion(workflow, input, options = {}) {
+	const journal = Object.create(null);
+	const maxAttempts = Math.max(1, options.maxAttempts ?? 1);
+	for (let attempt = 1;; attempt++) {
+		const response = await invoke(workflow, {
+			input,
+			journal
+		}, { onLog: options.onLog });
+		Object.assign(journal, response.completed);
+		if (response.status === "done") {
+			if (response.outputType === "undefined") return;
+			return response.output;
+		}
+		if (response.status === "dispatch") throw new Error("workflow-sdk: driveToCompletion cannot execute engine-dispatched steps");
+		if (attempt >= maxAttempts) throw new Error(response.error);
+	}
+}
+//#endregion
+export { PromiseRejectedError, decryptPayloadStream, defineTask, defineWorkflow, driveToCompletion, encryptPayloadStream, invoke, toWorker };
+
+//# sourceMappingURL=workflows.js.map