@oomol-lab/open-flow 0.1.0-beta.89 → 0.1.0-beta.90

package/dist/render/node/index.js

@@ -2,6 +2,183 @@ import { createRequire } from "node:module";
 import { Buffer } from "node:buffer";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+//#region src/connector/common/providerIconCache.ts
+var defaultMaxAgeMs = 864e5;
+var dataUrl = (entry) => `data:${entry.contentType};base64,${entry.body}`;
+function decodeRecord(value) {
+	if (value == null || typeof value !== "object") return;
+	const v = value;
+	if (v.formatVersion !== 1 || typeof v.sourceUrl !== "string" || !(v.spriteVersion === null || typeof v.spriteVersion === "string") || typeof v.contentType !== "string" || !/^image\/[\w.+-]+$/i.test(v.contentType) || typeof v.body !== "string" || !v.body || v.body.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(v.body) || !(v.etag === null || typeof v.etag === "string") || !Number.isFinite(v.validatedAt) || v.validatedAt < 0 || !(v.maxAgeMs === null || Number.isFinite(v.maxAgeMs) && v.maxAgeMs >= 0)) return;
+	return v;
+}
+function encodeBytes(bytes) {
+	let text = "";
+	for (let index = 0; index < bytes.length; index += 8192) text += String.fromCharCode(...bytes.subarray(index, index + 8192));
+	return btoa(text);
+}
+function freshness(response, immutable, previous) {
+	const control = response.headers.get("cache-control") ?? "";
+	if (/\bno-cache\b/i.test(control)) return 0;
+	if (immutable) return null;
+	const maxAge = /(?:^|,)\s*max-age\s*=\s*"?(\d+)/i.exec(control);
+	if (maxAge) return Math.max(0, Number(maxAge[1]) * 1e3 - (Number(response.headers.get("age")) || 0) * 1e3);
+	const expires = Date.parse(response.headers.get("expires") ?? "");
+	if (Number.isFinite(expires)) return Math.max(0, expires - Date.parse(response.headers.get("date") ?? (/* @__PURE__ */ new Date()).toUTCString()));
+	return previous?.maxAgeMs ?? defaultMaxAgeMs;
+}
+/** Complete image responses in bounded, identity-checked slots; no catalog entities live here. */
+var ProviderIconCache = class {
+	#memory = /* @__PURE__ */ new Map();
+	#pending = /* @__PURE__ */ new Map();
+	#targets = /* @__PURE__ */ new Map();
+	#writes = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+		if (!options.scope.trim()) throw new TypeError("Provider icon cache scope must be nonempty.");
+	}
+	get(request, options = {}) {
+		if (request.url.startsWith("data:image/")) return Promise.resolve(request.url);
+		let protocol;
+		try {
+			protocol = new URL(request.url).protocol;
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		if (!["http:", "https:"].includes(protocol)) return Promise.reject(/* @__PURE__ */ new TypeError("Unsupported Provider icon URL."));
+		const slot = JSON.stringify([
+			"open-flow:provider-icons",
+			1,
+			this.options.scope,
+			request.kind,
+			request.kind === "sprite" ? request.theme : request.providerId
+		]);
+		const version = request.kind === "sprite" ? request.version : null;
+		const identity = JSON.stringify([request.url, version]);
+		const offline = options.allowNetwork === false || this.options.mode === "offline";
+		const key = JSON.stringify([
+			slot,
+			identity,
+			offline
+		]);
+		const pending = this.#pending.get(key);
+		if (pending) return pending;
+		if (!offline) this.#targets.set(slot, identity);
+		const promise = this.#load(slot, identity, request.url, version, offline).finally(() => this.#pending.delete(key));
+		this.#pending.set(key, promise);
+		return promise;
+	}
+	async #read(slot, url, version) {
+		const memory = this.#memory.get(slot);
+		if (this.#memory.has(slot) && (!memory || memory.sourceUrl === url && memory.spriteVersion === version)) return memory;
+		if (!this.options.delegate) return this.#memory.get(slot);
+		try {
+			const stored = await this.options.delegate.get(slot);
+			if (stored === void 0) return this.#memory.get(slot);
+			const entry = decodeRecord(stored);
+			if (entry) {
+				this.#memory.set(slot, entry);
+				return entry;
+			}
+			this.#memory.delete(slot);
+			await this.options.delegate.delete(slot);
+		} catch {
+			return this.#memory.get(slot);
+		}
+	}
+	async #store(slot, identity, entry) {
+		const operation = (this.#writes.get(slot) ?? Promise.resolve()).then(async () => {
+			if (this.#targets.get(slot) !== identity) return;
+			this.#memory.set(slot, entry);
+			if (!this.options.delegate) return;
+			try {
+				if (entry) await this.options.delegate.set(slot, { ...entry });
+				else await this.options.delegate.delete(slot);
+			} catch {}
+		});
+		this.#writes.set(slot, operation);
+		try {
+			await operation;
+		} finally {
+			if (this.#writes.get(slot) === operation) this.#writes.delete(slot);
+		}
+	}
+	async #load(slot, identity, url, version, offline) {
+		const stored = await this.#read(slot, url, version);
+		const cached = stored?.sourceUrl === url && stored.spriteVersion === version ? stored : void 0;
+		const age = cached == null ? Infinity : Date.now() - cached.validatedAt;
+		if (cached && (offline || this.options.mode !== "refresh" && age >= 0 && (cached.maxAgeMs === null || age < cached.maxAgeMs))) return dataUrl(cached);
+		if (offline) throw new Error(`Provider icon is not cached: ${url}`);
+		const response = await (this.options.fetch ?? globalThis.fetch)(url, {
+			credentials: "omit",
+			referrerPolicy: "no-referrer",
+			signal: AbortSignal.timeout(15e3),
+			headers: cached?.etag ? { "if-none-match": cached.etag } : {}
+		});
+		if (response.status !== 304 && !response.ok) throw new Error(`Could not load Provider icon: ${response.status}`);
+		if (response.status === 304 && !cached) throw new Error("Provider icon returned 304 without a cached image.");
+		const contentType = response.status === 304 ? cached.contentType : response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+		if (!contentType || !/^image\/[\w.+-]+$/i.test(contentType)) throw new Error("Provider icon response is not an image.");
+		const body = response.status === 304 ? cached.body : encodeBytes(new Uint8Array(await response.arrayBuffer()));
+		if (!body) throw new Error("Provider icon response is empty.");
+		const entry = {
+			formatVersion: 1,
+			sourceUrl: url,
+			spriteVersion: version,
+			contentType,
+			body,
+			etag: response.headers.get("etag") ?? (response.status === 304 ? cached.etag : null),
+			validatedAt: Date.now(),
+			maxAgeMs: freshness(response, version !== null, response.status === 304 ? cached : void 0)
+		};
+		await this.#store(slot, identity, /\bno-store\b/i.test(response.headers.get("cache-control") ?? "") ? void 0 : entry);
+		return dataUrl(entry);
+	}
+};
+//#endregion
+//#region src/flow/common/connectionUsage.ts
+function connectionUsage(document) {
+	const uses = [];
+	for (const [nodeId, node] of Object.entries(document.graph.nodes)) {
+		const task = node.kind == "task" && "executor" in node.task ? node.task : void 0;
+		const name = node.name ?? task?.name ?? nodeId;
+		const add = (kind, actionId, connectionId) => {
+			uses.push({
+				kind,
+				providerId: actionId.split(".")[0],
+				actionId,
+				connectionId,
+				nodeId,
+				name
+			});
+		};
+		if (node.kind == "poll" || node.kind == "integration") uses.push({
+			kind: "trigger",
+			triggerId: node.definition.key,
+			providerId: node.definition.provider,
+			connectionId: node.connectionId,
+			nodeId,
+			name
+		});
+		if (task?.executor.kind == "connector") add("connector", task.executor.action, task.executor.connectionId);
+		if (task?.executor.kind == "connector-proxy") uses.push({
+			kind: "connector-proxy",
+			providerId: task.executor.providerId,
+			connectionId: task.executor.connectionId,
+			nodeId,
+			name
+		});
+		if (node.kind == "task" && "moduleId" in node.task) {
+			for (const capability of node.task.capabilities ?? []) if ("mode" in capability && capability.mode == "independent") for (const action of capability.actions) add("code", action.action, action.connectionId);
+		}
+		if (task?.executor.kind == "agent") {
+			for (const tool of task.executor.tools) if (tool.kind != "workflow") add("agent", tool.action, tool.connectionId);
+			const notification = task.executor.notification;
+			if (notification != null) add("notification", notification.action, notification.connectionId);
+		}
+	}
+	return uses;
+}
+//#endregion
 //#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
 var has = Object.prototype.hasOwnProperty;
 function dequal(foo, bar) {
@@ -1050,12 +1227,12 @@ var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][
 function anchor(source) {
 	return new RegExp(`^${source}$`);
 }
-var date = /*@__PURE__*/ anchor(dateSource);
+var date$1 = /*@__PURE__*/ anchor(dateSource);
 function timeSource(args) {
 	const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
 	return typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
 }
-function time(args) {
+function time$1(args) {
 	return new RegExp(`^${timeSource(args)}$`);
 }
 function datetime$1(args) {
@@ -1713,11 +1890,11 @@ var $ZodISODateTime = /*@__PURE__*/ $constructor("$ZodISODateTime", (inst, def)
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODate = /*@__PURE__*/ $constructor("$ZodISODate", (inst, def) => {
-	def.pattern ?? (def.pattern = date);
+	def.pattern ?? (def.pattern = date$1);
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISOTime = /*@__PURE__*/ $constructor("$ZodISOTime", (inst, def) => {
-	def.pattern ?? (def.pattern = time(def));
+	def.pattern ?? (def.pattern = time$1(def));
 	$ZodStringFormat.init(inst, def);
 });
 var $ZodISODuration = /*@__PURE__*/ $constructor("$ZodISODuration", (inst, def) => {
@@ -5732,6 +5909,132 @@ function datetime(params) {
 	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
 }
 //#endregion
+//#region src/flow/common/requestParameters.ts
+var requestParameterSchema = strictObject({
+	mode: _enum(["fields", "object"]).default("fields"),
+	names: array(string()).default([])
+});
+var connectorProxyExecutorSchema = strictObject({
+	providerId: string().min(1),
+	connectionId: string().optional(),
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE"
+	]).default("GET"),
+	query: requestParameterSchema.default({
+		mode: "fields",
+		names: []
+	}),
+	headers: requestParameterSchema.default({
+		mode: "fields",
+		names: []
+	}),
+	bodyFormat: _enum(["none", "json"]).default("none")
+}).extend({ kind: literal("connector-proxy") });
+//#endregion
+//#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/format.js
+var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+var DAYS = [
+	0,
+	31,
+	28,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
+var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
+var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
+var URL_ = /^(?:(?:https?|ftp):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)(?:\.(?:[a-z\u{00a1}-\u{ffff}0-9]+-?)*[a-z\u{00a1}-\u{ffff}0-9]+)*(?:\.(?:[a-z\u{00a1}-\u{ffff}]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/iu;
+var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
+var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+var EMAIL = (input) => {
+	if (input[0] === "\"") return false;
+	const [name, host, ...rest] = input.split("@");
+	if (!name || !host || rest.length !== 0 || name.length > 64 || host.length > 253) return false;
+	if (name[0] === "." || name.endsWith(".") || name.includes("..")) return false;
+	if (!/^[a-z0-9.-]+$/i.test(host) || !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(name)) return false;
+	return host.split(".").every((part) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/i.test(part));
+};
+var IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+var IPV6 = /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i;
+var DURATION = (input) => input.length > 1 && input.length < 80 && (/^P\d+([.,]\d+)?W$/.test(input) || /^P[\dYMDTHS]*(\d[.,]\d+)?[YMDHS]$/.test(input) && /^P([.,\d]+Y)?([.,\d]+M)?([.,\d]+D)?(T([.,\d]+H)?([.,\d]+M)?([.,\d]+S)?)?$/.test(input));
+function bind(r) {
+	return r.test.bind(r);
+}
+var format = {
+	date,
+	time: time.bind(void 0, false),
+	"date-time": date_time,
+	duration: DURATION,
+	uri,
+	"uri-reference": bind(URIREF),
+	"uri-template": bind(URITEMPLATE),
+	url: bind(URL_),
+	email: EMAIL,
+	hostname: bind(HOSTNAME),
+	ipv4: bind(IPV4),
+	ipv6: bind(IPV6),
+	regex,
+	uuid: bind(UUID),
+	"json-pointer": bind(JSON_POINTER),
+	"json-pointer-uri-fragment": bind(JSON_POINTER_URI_FRAGMENT),
+	"relative-json-pointer": bind(RELATIVE_JSON_POINTER)
+};
+function isLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function date(str) {
+	const matches = str.match(DATE);
+	if (!matches) return false;
+	const year = +matches[1];
+	const month = +matches[2];
+	const day = +matches[3];
+	return month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);
+}
+function time(full, str) {
+	const matches = str.match(TIME);
+	if (!matches) return false;
+	const hour = +matches[1];
+	const minute = +matches[2];
+	const second = +matches[3];
+	const timeZone = !!matches[5];
+	return (hour <= 23 && minute <= 59 && second <= 59 || hour == 23 && minute == 59 && second == 60) && (!full || timeZone);
+}
+var DATE_TIME_SEPARATOR = /t|\s/i;
+function date_time(str) {
+	const dateTime = str.split(DATE_TIME_SEPARATOR);
+	return dateTime.length == 2 && date(dateTime[0]) && time(true, dateTime[1]);
+}
+var NOT_URI_FRAGMENT = /\/|:/;
+var URI_PATTERN = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
+function uri(str) {
+	return NOT_URI_FRAGMENT.test(str) && URI_PATTERN.test(str);
+}
+var Z_ANCHOR = /[^\\]\\Z/;
+function regex(str) {
+	if (Z_ANCHOR.test(str)) return false;
+	try {
+		new RegExp(str, "u");
+		return true;
+	} catch (e) {
+		return false;
+	}
+}
+//#endregion
 //#region src/json-schema-subset/utils.ts
 var nextId = 0;
 function createId() {
@@ -8488,32 +8791,6 @@ function createSchemaComparer() {
 }
 createSchemaComparer();
 //#endregion
-//#region src/flow/common/requestParameters.ts
-var requestParameterSchema = strictObject({
-	mode: _enum(["fields", "object"]).default("fields"),
-	names: array(string()).default([])
-});
-var connectorProxyExecutorSchema = strictObject({
-	providerId: string().min(1),
-	connectionId: string().optional(),
-	method: _enum([
-		"GET",
-		"POST",
-		"PUT",
-		"PATCH",
-		"DELETE"
-	]).default("GET"),
-	query: requestParameterSchema.default({
-		mode: "fields",
-		names: []
-	}),
-	headers: requestParameterSchema.default({
-		mode: "fields",
-		names: []
-	}),
-	bodyFormat: _enum(["none", "json"]).default("none")
-}).extend({ kind: literal("connector-proxy") });
-//#endregion
 //#region src/decision/common/decision.ts
 function isDecisionExecutor(executor) {
 	return executor.kind === "decision";
@@ -8607,12 +8884,6 @@ function answerSchema(question) {
 	};
 }
 //#endregion
-//#region src/http/common/authBindings.ts
-/** Never allow credentials to enter a Revision as literal inputs of an OpenAPI or HTTP request node. */
-function assertHttpAuthBindings(inputs) {
-	for (const [handle, mapping] of Object.entries(inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("HTTP authentication accepts deployment variables and upstream outputs only.");
-}
-//#endregion
 //#region src/http/common/hosts.ts
 /** Hosts of a Code `http` Capability: lowercase DNS names or IPv4 addresses; `*.example.com` matches subdomains only. */
 var httpHostPattern = /^(?:\*\.)?(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
@@ -8722,6 +8993,12 @@ object({
 	const encoder = new TextEncoder();
 	return response.values.reduce((bytes, item) => bytes + (item.value === null ? 0 : encoder.encode(JSON.stringify(item.value)).byteLength), 0) <= stateReadLimits.maxBytes;
 }, "State values exceed the 1 MiB read limit.");
+//#endregion
+//#region src/http/common/authBindings.ts
+/** Never allow credentials to enter a Revision as literal inputs of an OpenAPI or HTTP request node. */
+function assertHttpAuthBindings(inputs) {
+	for (const [handle, mapping] of Object.entries(inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("HTTP authentication accepts deployment variables and upstream outputs only.");
+}
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
@@ -9486,6 +9763,130 @@ function assertDocumentHttpAuthBindings(content) {
 	for (const graphNode of Object.values(content.graph.nodes)) if (graphNode.kind == "task" && "executor" in graphNode.task && ["openapi", "http-request"].includes(graphNode.task.executor.kind)) assertHttpAuthBindings(graphNode.inputs);
 }
 //#endregion
+//#region src/runtime/common/engineContract.ts
+/** v11 adds Provider API requests through Connector Proxy. */
+var currentEngineContract = "open-flow-engine/v11";
+/** The published v8 Node compatibility contract, retained for existing Publications and Runs. */
+var nodejsEngineContract = "open-flow-engine/v8/nodejs-compat-v1";
+var platformSource = (contract) => `export const engineContract = ${JSON.stringify(contract)}
+export function identity(value) { return value }
+`;
+platformSource("open-flow-engine/v8"), new Set([
+	"assert",
+	"assert/strict",
+	"buffer",
+	"console",
+	"constants",
+	"crypto",
+	"events",
+	"fs",
+	"fs/promises",
+	"os",
+	"path",
+	"path/posix",
+	"process",
+	"punycode",
+	"querystring",
+	"stream",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"timers",
+	"timers/promises",
+	"url",
+	"util",
+	"zlib"
+].flatMap((name) => [name, `node:${name}`])), platformSource(nodejsEngineContract), platformSource("open-flow-engine/v9"), platformSource("open-flow-engine/v10"), platformSource(currentEngineContract);
+//#endregion
+//#region src/flow/common/agent.ts
+var schema = lazy(() => union([boolean(), strictObject({
+	type: union([_enum([
+		"array",
+		"boolean",
+		"integer",
+		"null",
+		"number",
+		"object",
+		"string"
+	]), array(_enum([
+		"array",
+		"boolean",
+		"integer",
+		"null",
+		"number",
+		"object",
+		"string"
+	])).min(1)]).optional(),
+	const: json$1().optional(),
+	allOf: array(schema).min(1).optional(),
+	anyOf: array(schema).min(1).optional(),
+	oneOf: array(schema).min(1).optional(),
+	not: schema.optional(),
+	if: schema.optional(),
+	then: schema.optional(),
+	else: schema.optional(),
+	$ref: string().optional(),
+	$schema: _enum([
+		"http://json-schema.org/draft-07/schema#",
+		"https://json-schema.org/draft-07/schema",
+		"https://json-schema.org/draft/2019-09/schema",
+		"https://json-schema.org/draft/2020-12/schema"
+	]).optional(),
+	$defs: record$1(string(), schema).optional(),
+	definitions: record$1(string(), schema).optional(),
+	pattern: string().refine((value) => {
+		try {
+			return new RegExp(value, "u").source.length > 0;
+		} catch {
+			return false;
+		}
+	}, "Invalid regular expression.").optional(),
+	format: string().refine((value) => Object.hasOwn(format, value), "Unsupported string format.").optional(),
+	multipleOf: number().positive().optional(),
+	uniqueItems: boolean().optional(),
+	contains: schema.optional(),
+	minContains: number().int().nonnegative().optional(),
+	maxContains: number().int().nonnegative().optional(),
+	minProperties: number().int().nonnegative().optional(),
+	maxProperties: number().int().nonnegative().optional(),
+	propertyNames: schema.optional(),
+	patternProperties: record$1(string().refine((value) => {
+		try {
+			return new RegExp(value, "u").source.length > 0;
+		} catch {
+			return false;
+		}
+	}, "Invalid regular expression."), schema).optional(),
+	dependentRequired: record$1(string(), array(string())).optional(),
+	dependentSchemas: record$1(string(), schema).optional(),
+	dependencies: record$1(string(), union([schema, array(string())])).optional(),
+	prefixItems: array(schema).optional(),
+	additionalItems: schema.optional(),
+	unevaluatedItems: schema.optional(),
+	unevaluatedProperties: schema.optional(),
+	description: string().optional(),
+	title: string().optional(),
+	default: json$1().optional(),
+	examples: array(json$1()).optional(),
+	readOnly: boolean().optional(),
+	writeOnly: boolean().optional(),
+	deprecated: boolean().optional(),
+	$comment: string().optional(),
+	enum: array(json$1()).min(1).optional(),
+	properties: record$1(string(), schema).optional(),
+	required: array(string()).optional(),
+	additionalProperties: schema.optional(),
+	items: union([schema, array(schema)]).optional(),
+	minItems: number().int().nonnegative().optional(),
+	maxItems: number().int().nonnegative().optional(),
+	minLength: number().int().nonnegative().optional(),
+	maxLength: number().int().nonnegative().optional(),
+	minimum: number().optional(),
+	maximum: number().optional(),
+	exclusiveMinimum: number().optional(),
+	exclusiveMaximum: number().optional()
+}).transform(({ title: _title, default: _default, examples: _examples, readOnly: _readOnly, writeOnly: _writeOnly, deprecated: _deprecated, $comment: _comment, ...value }) => value)]));
+//#endregion
 //#region src/flow/common/workflowFile.ts
 var envelope = strictObject({
 	kind: literal("open-flow-workflow"),
@@ -9506,6 +9907,844 @@ function decodeWorkflowFile(value) {
 	};
 }
 //#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries = array(strictObject({
+	flowId: string().min(1),
+	file: unknown()
+})).min(1);
+strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries
+});
+strictObject({
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries,
+	unavailableFlowIds: array(string().min(1))
+});
+new TextEncoder();
+//#endregion
+//#region ../../node_modules/.bun/@babel+parser@8.0.4/node_modules/@babel/parser/lib/index.js
+var Position = class {
+	constructor(line, col, index) {
+		this.line = void 0;
+		this.column = void 0;
+		if (index !== void 0) this.index = void 0;
+		this.line = line;
+		this.column = col;
+		if (index !== void 0) this.index = index;
+	}
+};
+var SourceLocation = class {
+	start;
+	end;
+	filename;
+	identifierName;
+	constructor(start, end) {
+		this.start = start;
+		this.end = end;
+	}
+};
+var code = "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+var ModuleErrors = {
+	ImportMetaOutsideModule: {
+		message: `import.meta may appear only with 'sourceType: "module"'`,
+		code
+	},
+	ImportOutsideModule: {
+		message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
+		code
+	}
+};
+var NodeDescriptions = {
+	ArrayPattern: "array destructuring pattern",
+	AssignmentExpression: "assignment expression",
+	AssignmentPattern: "assignment expression",
+	ArrowFunctionExpression: "arrow function expression",
+	ConditionalExpression: "conditional expression",
+	CatchClause: "catch clause",
+	ForOfStatement: "for-of statement",
+	ForInStatement: "for-in statement",
+	ForStatement: "for-loop",
+	FormalParameters: "function parameter list",
+	Identifier: "identifier",
+	ImportSpecifier: "import specifier",
+	ImportDefaultSpecifier: "import default specifier",
+	ImportNamespaceSpecifier: "import namespace specifier",
+	ObjectPattern: "object destructuring pattern",
+	ParenthesizedExpression: "parenthesized expression",
+	RestElement: "rest element",
+	UpdateExpression: {
+		true: "prefix operation",
+		false: "postfix operation"
+	},
+	VariableDeclarator: "variable declaration",
+	YieldExpression: "yield expression"
+};
+var toNodeDescription = (node) => node.type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[`${node.prefix}`] : NodeDescriptions[node.type];
+var StandardErrors = {
+	AccessorIsGenerator: ({ kind }) => `A ${kind}ter cannot be a generator.`,
+	ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
+	AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
+	AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
+	AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
+	AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
+	AwaitUsingNotInAsyncContext: "'await using' is only allowed within async functions and at the top levels of modules.",
+	AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
+	BadGetterArity: "A 'get' accessor must not have any formal parameters.",
+	BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
+	BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
+	ConstructorClassField: "Classes may not have a field named 'constructor'.",
+	ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
+	ConstructorIsAccessor: "Class constructor may not be an accessor.",
+	ConstructorIsAsync: "Constructor can't be an async function.",
+	ConstructorIsGenerator: "Constructor can't be a generator.",
+	DeclarationMissingInitializer: ({ kind }) => `Missing initializer in ${kind} declaration.`,
+	DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
+	DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
+	DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
+	DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
+	DecoratorStaticBlock: "Decorators can't be used with a static block.",
+	DeferImportRequiresNamespace: "Only `import defer * as x from \"./module\"` is valid.",
+	DeletePrivateField: "Deleting a private field is not allowed.",
+	DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
+	DuplicateConstructor: "Duplicate constructor in the same class.",
+	DuplicateDefaultExport: "Only one default export allowed per module.",
+	DuplicateExport: ({ exportName }) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
+	DuplicateProto: "Redefinition of __proto__ property.",
+	DuplicateRegExpFlags: "Duplicate regular expression flag.",
+	ElementAfterRest: "Rest element must be last element.",
+	EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
+	ExportBindingIsString: ({ localName, exportName }) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
+	ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
+	ForInOfLoopInitializer: ({ type }) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
+	ForInUsing: "For-in loop may not start with 'using' declaration.",
+	ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
+	ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
+	GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
+	IllegalBreakContinue: ({ type }) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
+	IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
+	IllegalReturn: "'return' outside of function.",
+	ImportBindingIsString: ({ importName }) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
+	ImportCallArity: ({ phase }) => `\`import${phase ? `.${phase}` : ""}()\` requires exactly one or two arguments.`,
+	ImportCallNotNewExpression: ({ phase }) => `Cannot use new with import${phase ? `.${phase}` : ""}().`,
+	ImportCallSpreadArgument: ({ phase }) => `\`...\` is not allowed in \`import${phase ? `.${phase}` : ""}()\`.`,
+	IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
+	InvalidBigIntLiteral: "Invalid BigIntLiteral.",
+	InvalidCodePoint: "Code point out of bounds.",
+	InvalidCoverDiscardElement: "'void' must be followed by an expression when not used in a binding position.",
+	InvalidCoverInitializedName: "Invalid shorthand property initializer.",
+	InvalidDigit: ({ radix }) => `Expected number in radix ${radix}.`,
+	InvalidEscapeSequence: "Bad character escape sequence.",
+	InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
+	InvalidEscapedReservedWord: ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
+	InvalidIdentifier: ({ identifierName }) => `Invalid identifier ${identifierName}.`,
+	InvalidLhs: ({ ancestor }) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
+	InvalidLhsBinding: ({ ancestor }) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
+	InvalidLhsOptionalChaining: ({ ancestor }) => `Invalid optional chaining in the left-hand side of ${toNodeDescription(ancestor)}.`,
+	InvalidNumber: "Invalid number.",
+	InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
+	InvalidOrUnexpectedToken: ({ unexpected }) => `Unexpected character '${unexpected}'.`,
+	InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
+	InvalidPrivateFieldResolution: ({ identifierName }) => `Private name #${identifierName} is not defined.`,
+	InvalidPropertyBindingPattern: "Binding member expression.",
+	InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
+	LabelRedeclaration: ({ labelName }) => `Label '${labelName}' is already declared.`,
+	LetInLexicalBinding: "'let' is disallowed as a lexically bound name.",
+	LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
+	MalformedRegExpFlags: "Invalid regular expression flag.",
+	MissingClassName: "A class name is required.",
+	MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
+	MissingSemicolon: "Missing semicolon.",
+	MissingPlugin: ({ missingPlugin }) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
+	MissingOneOfPlugins: ({ missingPlugin }) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map((name) => JSON.stringify(name)).join(", ")}.`,
+	MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
+	MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
+	ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
+	ModuleAttributesWithDuplicateKeys: ({ key }) => `Duplicate key "${key}" is not allowed in module attributes.`,
+	ModuleExportNameHasLoneSurrogate: ({ surrogateCharCode }) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
+	ModuleExportUndefined: ({ localName }) => `Export '${localName}' is not defined.`,
+	MultipleDefaultsInSwitch: "Multiple default clauses.",
+	NewlineAfterThrow: "Illegal newline after throw.",
+	NoCatchOrFinally: "Missing catch or finally clause.",
+	NumberIdentifier: "Identifier directly after number.",
+	NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
+	ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
+	OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
+	OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
+	OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
+	ParamDupe: "Argument name clash.",
+	PatternHasAccessor: "Object pattern can't contain getter or setter.",
+	PatternHasMethod: "Object pattern can't contain methods.",
+	PrivateInExpectedIn: ({ identifierName }) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
+	PrivateNameRedeclaration: ({ identifierName }) => `Duplicate private name #${identifierName}.`,
+	RestTrailingComma: "Unexpected trailing comma after rest element.",
+	SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
+	SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
+	SourcePhaseImportRequiresDefault: "Only `import source x from \"./module\"` is valid.",
+	StaticPrototype: "Classes may not have static property named prototype.",
+	SuperCallNotNewExpression: "Cannot use new with super(...).",
+	SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
+	SuperPrivateField: "Private fields can't be accessed on super.",
+	TrailingDecorator: "Decorators must be attached to a class element.",
+	UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
+	UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
+	UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
+	UnexpectedKeyword: ({ keyword }) => `Unexpected keyword '${keyword}'.`,
+	UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
+	UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
+	UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
+	UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
+	UnexpectedPrivateField: "Unexpected private name.",
+	UnexpectedReservedWord: ({ reservedWord }) => `Unexpected reserved word '${reservedWord}'.`,
+	UnexpectedSuper: "'super' is only allowed in object methods and classes.",
+	UnexpectedToken: ({ expected, unexpected }) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
+	UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
+	UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script` or in the bare case statement.",
+	UnexpectedVoidPattern: "Unexpected void binding.",
+	UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
+	UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
+	UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
+	UnsupportedMetaProperty: ({ target, onlyValidPropertyName }) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
+	UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
+	UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
+	UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
+	UnterminatedComment: "Unterminated comment.",
+	UnterminatedRegExp: "Unterminated regular expression.",
+	UnterminatedString: "Unterminated string constant.",
+	UnterminatedTemplate: "Unterminated template.",
+	UsingDeclarationExport: "Using declaration cannot be exported.",
+	UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
+	VarRedeclaration: ({ identifierName }) => `Identifier '${identifierName}' has already been declared.`,
+	VoidPatternCatchClauseParam: "A void binding can not be the catch clause parameter. Use `try { ... } catch { ... }` if you want to discard the caught error.",
+	VoidPatternInitializer: "A void binding may not have an initializer.",
+	YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
+	YieldInParameter: "Yield expression is not allowed in formal parameters.",
+	YieldNotInGeneratorFunction: "'yield' is only allowed within generator functions.",
+	ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
+};
+var StrictModeErrors = {
+	StrictDelete: "Deleting local variable in strict mode.",
+	StrictEvalArguments: ({ referenceName }) => `Assigning to '${referenceName}' in strict mode.`,
+	StrictEvalArgumentsBinding: ({ bindingName }) => `Binding '${bindingName}' in strict mode.`,
+	StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
+	StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
+	StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
+	StrictWith: "'with' in strict mode."
+};
+var ParseExpressionErrors = {
+	ParseExpressionEmptyInput: "Unexpected parseExpression() input: The input is empty or contains only comments.",
+	ParseExpressionExpectsEOF: ({ unexpected }) => `Unexpected parseExpression() input: The input should contain exactly one expression, but the first expression is followed by the unexpected character \`${String.fromCodePoint(unexpected)}\`.`
+};
+var PipelineOperatorErrors = {
+	PipeTopicRequiresHackPipes: "Topic references are only supported when using the `\"proposal\": \"hack\"` version of the pipeline proposal.",
+	PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
+	PipeTopicUnconfiguredToken: ({ token }) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
+	PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
+	PipeUnparenthesizedBody: ({ type }) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({ type })}; please wrap it in parentheses.`,
+	PipelineUnparenthesized: "Cannot mix binary operator with solo-await F#-style pipeline. Please wrap the pipeline in parentheses."
+};
+var FunctionBindErrors = {
+	UnsupportedBind: "Binding should be performed on object property.",
+	UnsupportedBindRHS: "The right-hand side of binding can not be super or import."
+};
+function defineHidden(obj, key, value) {
+	Object.defineProperty(obj, key, {
+		enumerable: false,
+		configurable: true,
+		value
+	});
+}
+function toParseErrorConstructor({ toMessage, code, reasonCode, syntaxPlugin }) {
+	const hasMissingPlugin = reasonCode === "MissingPlugin" || reasonCode === "MissingOneOfPlugins";
+	return function constructor(loc, pos, details) {
+		const error = /* @__PURE__ */ new SyntaxError();
+		error.code = code;
+		error.reasonCode = reasonCode;
+		error.loc = loc;
+		error.pos = pos;
+		error.syntaxPlugin = syntaxPlugin;
+		if (hasMissingPlugin) error.missingPlugin = details.missingPlugin;
+		defineHidden(error, "clone", function clone(overrides = {}) {
+			const { line, column, index = pos } = overrides.loc ?? loc;
+			return constructor(new Position(line, column), index, {
+				...details,
+				...overrides.details
+			});
+		});
+		defineHidden(error, "details", details);
+		Object.defineProperty(error, "message", {
+			configurable: true,
+			get() {
+				const message = `${toMessage(details)} (${loc.line}:${loc.column})`;
+				this.message = message;
+				return message;
+			},
+			set(value) {
+				Object.defineProperty(this, "message", {
+					value,
+					writable: true
+				});
+			}
+		});
+		return error;
+	};
+}
+function ParseErrorEnum(argument, syntaxPlugin) {
+	if (Array.isArray(argument)) return (parseErrorTemplates) => ParseErrorEnum(parseErrorTemplates, argument[0]);
+	const ParseErrorConstructors = {};
+	for (const reasonCode of Object.keys(argument)) {
+		const template = argument[reasonCode];
+		const { message, ...rest } = typeof template === "string" ? { message: () => template } : typeof template === "function" ? { message: template } : template;
+		ParseErrorConstructors[reasonCode] = toParseErrorConstructor({
+			code: "BABEL_PARSER_SYNTAX_ERROR",
+			reasonCode,
+			toMessage: typeof message === "string" ? () => message : message,
+			...syntaxPlugin ? { syntaxPlugin } : {},
+			...rest
+		});
+	}
+	return ParseErrorConstructors;
+}
+({
+	...ParseErrorEnum(ModuleErrors),
+	...ParseErrorEnum(StandardErrors),
+	...ParseErrorEnum(StrictModeErrors),
+	...ParseErrorEnum(ParseExpressionErrors),
+	...ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors),
+	...ParseErrorEnum`functionBind`(FunctionBindErrors)
+});
+var beforeExpr = true;
+var startsExpr = true;
+var isLoop = true;
+var isAssign = true;
+var prefix = true;
+var postfix = true;
+var ExportedTokenType = class {
+	label;
+	keyword;
+	beforeExpr;
+	startsExpr;
+	rightAssociative;
+	isLoop;
+	isAssign;
+	prefix;
+	postfix;
+	binop;
+	constructor(label, conf = {}) {
+		this.label = label;
+		this.keyword = conf.keyword;
+		this.beforeExpr = !!conf.beforeExpr;
+		this.startsExpr = !!conf.startsExpr;
+		this.rightAssociative = !!conf.rightAssociative;
+		this.isLoop = !!conf.isLoop;
+		this.isAssign = !!conf.isAssign;
+		this.prefix = !!conf.prefix;
+		this.postfix = !!conf.postfix;
+		this.binop = conf.binop != null ? conf.binop : null;
+	}
+};
+var keywords$1 = /* @__PURE__ */ new Map();
+function createKeyword(name, options = {}) {
+	options.keyword = name;
+	const token = createToken(name, options);
+	keywords$1.set(name, token);
+	return token;
+}
+function createBinop(name, binop) {
+	return createToken(name, {
+		beforeExpr,
+		binop
+	});
+}
+var tokenTypeCounter = -1;
+var tokenTypes = [];
+var tokenLabels = [];
+var tokenBinops = [];
+var tokenBeforeExprs = [];
+var tokenStartsExprs = [];
+var tokenPrefixes = [];
+function createToken(name, options = {}) {
+	++tokenTypeCounter;
+	tokenLabels.push(name);
+	tokenBinops.push(options.binop ?? -1);
+	tokenBeforeExprs.push(options.beforeExpr ?? false);
+	tokenStartsExprs.push(options.startsExpr ?? false);
+	tokenPrefixes.push(options.prefix ?? false);
+	tokenTypes.push(new ExportedTokenType(name, options));
+	return tokenTypeCounter;
+}
+function createKeywordLike(name, options = {}) {
+	++tokenTypeCounter;
+	keywords$1.set(name, tokenTypeCounter);
+	tokenLabels.push(name);
+	tokenBinops.push(options.binop ?? -1);
+	tokenBeforeExprs.push(options.beforeExpr ?? false);
+	tokenStartsExprs.push(options.startsExpr ?? false);
+	tokenPrefixes.push(options.prefix ?? false);
+	tokenTypes.push(new ExportedTokenType("name", options));
+	return tokenTypeCounter;
+}
+var tt = {
+	bracketL: createToken("[", {
+		beforeExpr,
+		startsExpr
+	}),
+	bracketR: createToken("]"),
+	braceL: createToken("{", {
+		beforeExpr,
+		startsExpr
+	}),
+	braceBarL: createToken("{|", {
+		beforeExpr,
+		startsExpr
+	}),
+	braceR: createToken("}"),
+	braceBarR: createToken("|}"),
+	parenL: createToken("(", {
+		beforeExpr,
+		startsExpr
+	}),
+	parenR: createToken(")"),
+	comma: createToken(",", { beforeExpr }),
+	semi: createToken(";", { beforeExpr }),
+	colon: createToken(":", { beforeExpr }),
+	doubleColon: createToken("::", { beforeExpr }),
+	dot: createToken("."),
+	question: createToken("?", { beforeExpr }),
+	questionDot: createToken("?."),
+	arrow: createToken("=>", { beforeExpr }),
+	template: createToken("template"),
+	ellipsis: createToken("...", { beforeExpr }),
+	backQuote: createToken("`", { startsExpr }),
+	dollarBraceL: createToken("${", {
+		beforeExpr,
+		startsExpr
+	}),
+	templateTail: createToken("...`", { startsExpr }),
+	templateNonTail: createToken("...${", {
+		beforeExpr,
+		startsExpr
+	}),
+	at: createToken("@"),
+	hash: createToken("#", { startsExpr }),
+	interpreterDirective: createToken("#!..."),
+	eq: createToken("=", {
+		beforeExpr,
+		isAssign
+	}),
+	assign: createToken("_=", {
+		beforeExpr,
+		isAssign
+	}),
+	slashAssign: createToken("_=", {
+		beforeExpr,
+		isAssign
+	}),
+	xorAssign: createToken("_=", {
+		beforeExpr,
+		isAssign
+	}),
+	moduloAssign: createToken("_=", {
+		beforeExpr,
+		isAssign
+	}),
+	incDec: createToken("++/--", {
+		prefix,
+		postfix,
+		startsExpr
+	}),
+	bang: createToken("!", {
+		beforeExpr,
+		prefix,
+		startsExpr
+	}),
+	tilde: createToken("~", {
+		beforeExpr,
+		prefix,
+		startsExpr
+	}),
+	doubleCaret: createToken("^^", { startsExpr }),
+	doubleAt: createToken("@@", { startsExpr }),
+	pipeline: createBinop("|>", 0),
+	nullishCoalescing: createBinop("??", 1),
+	logicalOR: createBinop("||", 1),
+	logicalAND: createBinop("&&", 2),
+	bitwiseOR: createBinop("|", 3),
+	bitwiseXOR: createBinop("^", 4),
+	bitwiseAND: createBinop("&", 5),
+	equality: createBinop("==/!=/===/!==", 6),
+	lt: createBinop("</>/<=/>=", 7),
+	gt: createBinop("</>/<=/>=", 7),
+	relational: createBinop("</>/<=/>=", 7),
+	bitShift: createBinop("<</>>/>>>", 8),
+	bitShiftL: createBinop("<</>>/>>>", 8),
+	bitShiftR: createBinop("<</>>/>>>", 8),
+	plusMin: createToken("+/-", {
+		beforeExpr,
+		binop: 9,
+		prefix,
+		startsExpr
+	}),
+	modulo: createToken("%", {
+		binop: 10,
+		startsExpr
+	}),
+	star: createToken("*", { binop: 10 }),
+	slash: createBinop("/", 10),
+	exponent: createToken("**", {
+		beforeExpr,
+		binop: 11,
+		rightAssociative: true
+	}),
+	_in: createKeyword("in", {
+		beforeExpr,
+		binop: 7
+	}),
+	_instanceof: createKeyword("instanceof", {
+		beforeExpr,
+		binop: 7
+	}),
+	_break: createKeyword("break"),
+	_case: createKeyword("case", { beforeExpr }),
+	_catch: createKeyword("catch"),
+	_continue: createKeyword("continue"),
+	_debugger: createKeyword("debugger"),
+	_default: createKeyword("default", { beforeExpr }),
+	_else: createKeyword("else", { beforeExpr }),
+	_finally: createKeyword("finally"),
+	_function: createKeyword("function", { startsExpr }),
+	_if: createKeyword("if"),
+	_return: createKeyword("return", { beforeExpr }),
+	_switch: createKeyword("switch"),
+	_throw: createKeyword("throw", {
+		beforeExpr,
+		prefix,
+		startsExpr
+	}),
+	_try: createKeyword("try"),
+	_var: createKeyword("var"),
+	_const: createKeyword("const"),
+	_with: createKeyword("with"),
+	_new: createKeyword("new", {
+		beforeExpr,
+		startsExpr
+	}),
+	_this: createKeyword("this", { startsExpr }),
+	_super: createKeyword("super", { startsExpr }),
+	_class: createKeyword("class", { startsExpr }),
+	_extends: createKeyword("extends", { beforeExpr }),
+	_export: createKeyword("export"),
+	_import: createKeyword("import", { startsExpr }),
+	_null: createKeyword("null", { startsExpr }),
+	_true: createKeyword("true", { startsExpr }),
+	_false: createKeyword("false", { startsExpr }),
+	_typeof: createKeyword("typeof", {
+		beforeExpr,
+		prefix,
+		startsExpr
+	}),
+	_void: createKeyword("void", {
+		beforeExpr,
+		prefix,
+		startsExpr
+	}),
+	_delete: createKeyword("delete", {
+		beforeExpr,
+		prefix,
+		startsExpr
+	}),
+	_do: createKeyword("do", {
+		isLoop,
+		beforeExpr
+	}),
+	_for: createKeyword("for", { isLoop }),
+	_while: createKeyword("while", { isLoop }),
+	_as: createKeywordLike("as", { startsExpr }),
+	_assert: createKeywordLike("assert", { startsExpr }),
+	_async: createKeywordLike("async", { startsExpr }),
+	_await: createKeywordLike("await", { startsExpr }),
+	_defer: createKeywordLike("defer", { startsExpr }),
+	_from: createKeywordLike("from", { startsExpr }),
+	_get: createKeywordLike("get", { startsExpr }),
+	_let: createKeywordLike("let", { startsExpr }),
+	_meta: createKeywordLike("meta", { startsExpr }),
+	_of: createKeywordLike("of", { startsExpr }),
+	_sent: createKeywordLike("sent", { startsExpr }),
+	_set: createKeywordLike("set", { startsExpr }),
+	_source: createKeywordLike("source", { startsExpr }),
+	_static: createKeywordLike("static", { startsExpr }),
+	_using: createKeywordLike("using", { startsExpr }),
+	_yield: createKeywordLike("yield", { startsExpr }),
+	_asserts: createKeywordLike("asserts", { startsExpr }),
+	_checks: createKeywordLike("checks", { startsExpr }),
+	_exports: createKeywordLike("exports", { startsExpr }),
+	_global: createKeywordLike("global", { startsExpr }),
+	_implements: createKeywordLike("implements", { startsExpr }),
+	_intrinsic: createKeywordLike("intrinsic", { startsExpr }),
+	_infer: createKeywordLike("infer", { startsExpr }),
+	_is: createKeywordLike("is", { startsExpr }),
+	_mixins: createKeywordLike("mixins", { startsExpr }),
+	_proto: createKeywordLike("proto", { startsExpr }),
+	_require: createKeywordLike("require", { startsExpr }),
+	_satisfies: createKeywordLike("satisfies", { startsExpr }),
+	_keyof: createKeywordLike("keyof", { startsExpr }),
+	_readonly: createKeywordLike("readonly", { startsExpr }),
+	_unique: createKeywordLike("unique", { startsExpr }),
+	_abstract: createKeywordLike("abstract", { startsExpr }),
+	_declare: createKeywordLike("declare", { startsExpr }),
+	_enum: createKeywordLike("enum", { startsExpr }),
+	_module: createKeywordLike("module", { startsExpr }),
+	_namespace: createKeywordLike("namespace", { startsExpr }),
+	_interface: createKeywordLike("interface", { startsExpr }),
+	_type: createKeywordLike("type", { startsExpr }),
+	_opaque: createKeywordLike("opaque", { startsExpr }),
+	name: createToken("name", { startsExpr }),
+	placeholder: createToken("%%", { startsExpr }),
+	string: createToken("string", { startsExpr }),
+	num: createToken("num", { startsExpr }),
+	bigint: createToken("bigint", { startsExpr }),
+	regexp: createToken("regexp", { startsExpr }),
+	privateName: createToken("#name", { startsExpr }),
+	eof: createToken("eof"),
+	jsxName: createToken("jsxName"),
+	jsxText: createToken("jsxText", { beforeExpr }),
+	jsxTagStart: createToken("jsxTagStart", { startsExpr }),
+	jsxTagEnd: createToken("jsxTagEnd")
+};
+function getExportedToken(token) {
+	return tokenTypes[token];
+}
+var TokContext = class {
+	constructor(token, preserveSpace) {
+		this.token = token;
+		this.preserveSpace = !!preserveSpace;
+	}
+	token;
+	preserveSpace;
+};
+new TokContext("{"), new TokContext("<tag"), new TokContext("</tag"), new TokContext("<tag>...</tag>", true);
+var reservedWords = {
+	keyword: [
+		"break",
+		"case",
+		"catch",
+		"continue",
+		"debugger",
+		"default",
+		"do",
+		"else",
+		"finally",
+		"for",
+		"function",
+		"if",
+		"return",
+		"switch",
+		"throw",
+		"try",
+		"var",
+		"const",
+		"while",
+		"with",
+		"new",
+		"this",
+		"super",
+		"class",
+		"extends",
+		"export",
+		"import",
+		"null",
+		"true",
+		"false",
+		"in",
+		"instanceof",
+		"typeof",
+		"void",
+		"delete"
+	],
+	strict: [
+		"implements",
+		"interface",
+		"let",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"static",
+		"yield"
+	],
+	strictBind: ["eval", "arguments"]
+};
+new Set(reservedWords.keyword);
+new Set(reservedWords.strict);
+new Set(reservedWords.strictBind);
+ParseErrorEnum`flow`({
+	AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
+	AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
+	AssignReservedType: ({ reservedType }) => `Cannot overwrite reserved type ${reservedType}.`,
+	DeclareClassElement: "The `declare` modifier can only appear on class fields.",
+	DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
+	DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
+	EnumBooleanMemberNotInitialized: ({ memberName, enumName }) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
+	EnumDuplicateMemberName: ({ memberName, enumName }) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
+	EnumInconsistentMemberValues: ({ enumName }) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
+	EnumInvalidExplicitType: ({ invalidEnumType, enumName }) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
+	EnumInvalidExplicitTypeUnknownSupplied: ({ enumName }) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
+	EnumInvalidMemberInitializerPrimaryType: ({ enumName, memberName, explicitType }) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
+	EnumInvalidMemberInitializerSymbolType: ({ enumName, memberName }) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
+	EnumInvalidMemberInitializerUnknownType: ({ enumName, memberName }) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
+	EnumInvalidMemberName: ({ enumName, memberName, suggestion }) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
+	EnumNumberMemberNotInitialized: ({ enumName, memberName }) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
+	EnumStringMemberInconsistentlyInitialized: ({ enumName }) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
+	GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
+	ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
+	InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
+	InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
+	InexactVariance: "Explicit inexact syntax cannot have variance.",
+	InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
+	MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
+	NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
+	NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
+	PatternIsOptional: { message: "A binding pattern parameter cannot be optional in an implementation signature." },
+	SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
+	SpreadVariance: "Spread properties cannot have variance.",
+	ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
+	ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
+	ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
+	ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
+	ThisParamNoDefault: "The `this` parameter may not have a default value.",
+	TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
+	TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
+	UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
+	UnexpectedReservedType: ({ reservedType }) => `Unexpected reserved type ${reservedType}.`,
+	UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
+	UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
+	UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
+	UnexpectedSubtractionOperand: "Unexpected token, expected \"number\" or \"bigint\".",
+	UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
+	UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
+	UnsupportedDeclareExportKind: ({ unsupportedExportKind, suggestion }) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
+	UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
+	UnterminatedFlowComment: "Unterminated flow-comment."
+});
+new RegExp(/\r\n|[\r\n\u2028\u2029]/.source, "g");
+ParseErrorEnum`jsx`({
+	AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
+	MissingClosingTagElement: ({ openingTagName }) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
+	MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
+	UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
+	UnexpectedToken: ({ unexpected, HTMLEntity }) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
+	UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
+	UnterminatedJsxContent: "Unterminated JSX contents.",
+	UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
+});
+var Node = class {
+	constructor(optionFlags, filename, pos, loc) {
+		this.start = pos;
+		this.end = 0;
+		if (loc !== void 0) this.loc = new SourceLocation(loc);
+		if (optionFlags & 128) this.range = [pos, 0];
+		if (loc !== void 0 && filename) this.loc.filename = filename;
+	}
+	type = "";
+};
+Node.prototype;
+ParseErrorEnum`typescript`({
+	AbstractMethodHasImplementation: ({ methodName }) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
+	AbstractPropertyHasInitializer: ({ propertyName }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
+	AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
+	AccessorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
+	AccessorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
+	ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
+	ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
+	ConstInitializerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
+	ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
+	DeclaratorDefiniteAssertionRequiresTypeAnnotation: "Declarations with definite assignment assertions must also have type annotations.",
+	DeclaratorDefiniteAssertionWithInitializer: "Declarations with initializers cannot also have definite assignment assertions.",
+	DeclareAccessor: ({ kind }) => `'declare' is not allowed in ${kind}ters.`,
+	DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
+	DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
+	DecoratorAbstractMethod: ({ kind }) => `Decorators can't be used with ${kind.startsWith("a") ? "an" : "a"} ${kind}.`,
+	DuplicateAccessibilityModifier: ({ modifier }) => `Accessibility modifier already seen: '${modifier}'.`,
+	DuplicateModifier: ({ modifier }) => `Duplicate modifier: '${modifier}'.`,
+	EmptyHeritageClauseType: ({ token }) => `'${token}' list cannot be empty.`,
+	EmptyNamespaceName: "Namespace must be given a name.",
+	EmptyTypeArguments: "Type argument list cannot be empty.",
+	EmptyTypeParameters: "Type parameter list cannot be empty.",
+	ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
+	ExportAssignmentInTSNamespace: "An export assignment cannot be used in a namespace.",
+	ExportInTSNamespace: "Export declarations are not permitted in a namespace.",
+	ImportAliasHasImportType: "An import alias can not use 'import type'.",
+	ImportInTSNamespace: "Import declarations in a namespace cannot reference a module.",
+	IncompatibleModifiers: ({ modifiers }) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
+	IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
+	IndexSignatureHasAccessibility: ({ modifier }) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
+	IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
+	IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
+	IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
+	InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
+	InlineModuleDeclarationMustUseString: "`module ... {}` declarations must have a string name. Use `namespace ... {}` instead.",
+	InvalidHeritageClauseType: ({ token }) => `'${token}' list can only include identifiers or qualified-names with optional type arguments.`,
+	InvalidModifierOnAwaitUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on an await using declaration.`,
+	InvalidModifierOnTypeMember: ({ modifier }) => `'${modifier}' modifier cannot appear on a type member.`,
+	InvalidModifierOnTypeParameter: ({ modifier }) => `'${modifier}' modifier cannot appear on a type parameter.`,
+	InvalidModifierOnTypeParameterPositions: ({ modifier }) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
+	InvalidModifierOnUsingDeclaration: (modifier) => `'${modifier}' modifier cannot appear on a using declaration.`,
+	InvalidModifiersOrder: ({ orderedModifiers }) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
+	InvalidNamespaceName: (value) => `Namespace name cannot be '${value}'.`,
+	InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
+	InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
+	MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
+	NamespaceExportInTSNamespace: "Global module exports may only appear at top level.",
+	NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
+	NonClassMethodPropertyHasAbstractModifier: "'abstract' modifier can only appear on a class, method, or property declaration.",
+	OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
+	OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
+	PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
+	PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
+	PrivateElementHasAccessibility: ({ modifier }) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
+	ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
+	ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
+	ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
+	SetAccessorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
+	SetAccessorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
+	SetAccessorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
+	SingleTypeParameterWithoutTrailingComma: ({ typeParameterName }) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
+	StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
+	TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
+	TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
+	TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
+	TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
+	TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
+	UnexpectedParameterInitializer: "A parameter initializer is only allowed in a function or constructor implementation.",
+	UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
+	UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
+	UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
+	UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
+	UnexpectedTypeDeclaration: (type) => `'${type}' declarations can only be declared inside a block.`,
+	UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
+	UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
+	UnsupportedSignatureParameterKind: ({ type }) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`,
+	UsingDeclarationInAmbientContext: (kind) => `'${kind}' declarations are not allowed in ambient contexts.`
+});
+ParseErrorEnum`placeholders`({
+	ClassNameIsRequired: "A class name is required.",
+	UnexpectedSpace: "Unexpected space in placeholder."
+});
+function generateExportedTokenTypes(internalTokenTypes) {
+	const tokenTypes = {};
+	for (const typeName of Object.keys(internalTokenTypes)) tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
+	return tokenTypes;
+}
+generateExportedTokenTypes(tt);
+//#endregion
+//#region src/flow/common/semantics.ts
+function codeActions(flow) {
+	return Object.values(flow.graph.nodes).flatMap((node) => node.kind == "task" && "moduleId" in node.task ? (node.task.capabilities ?? []).filter((item) => item.kind == "connector") : []);
+}
+//#endregion
 //#region src/render/common/png.ts
 var flowPngAspectRatios = [
 	"auto",
@@ -9523,10 +10762,16 @@ function getFlowPngAspectRatio(value) {
 }
 //#endregion
 //#region src/render/node/index.ts
+var defaultIconCache = new ProviderIconCache({ scope: "node-renderer" });
 /** Render a workflow file without launching or closing the caller's browser. */
 async function flowToPng(browser, workflow, options = {}) {
 	const file = decodeWorkflowFile(workflow);
 	getFlowPngAspectRatio(options.aspectRatio);
+	const { client, iconCache = defaultIconCache, ...renderOptions } = options;
+	let providers;
+	if (client && (connectionUsage(file.content.document).length > 0 || codeActions(file.content.document).length > 0)) try {
+		providers = await client.listConnectorProviders(void 0, void 0, options.language ?? "en", { cacheOnly: options.allowNetwork === false });
+	} catch {}
 	const packageRoot = dirname(createRequire(import.meta.url).resolve("@oomol-lab/open-flow/package.json"));
 	const [script, style] = await Promise.all([readFile(join(packageRoot, "dist/render/browser/runtime.js"), "utf8"), readFile(join(packageRoot, "dist/render/browser/runtime.css"), "utf8")]);
 	const context = await browser.newContext({
@@ -9537,12 +10782,14 @@ async function flowToPng(browser, workflow, options = {}) {
 	try {
 		if (options.allowNetwork === false) await context.route("**/*", (route) => route.abort());
 		const page = await context.newPage();
+		await page.exposeFunction("OpenFlowProviderIcon", (request) => iconCache.get(request, { allowNetwork: options.allowNetwork }));
 		await page.setContent("<!doctype html><html><head><meta charset=\"utf-8\"></head><body></body></html>");
 		await page.addStyleTag({ content: style });
 		await page.addScriptTag({ content: script });
 		const result = await page.evaluate((serialized) => globalThis.OpenFlowRenderer.render(JSON.parse(serialized)), JSON.stringify({
 			workflow: file,
-			options
+			options: renderOptions,
+			...providers == null ? {} : { providers }
 		}));
 		return {
 			buffer: Buffer.from(result.dataUrl.slice(result.dataUrl.indexOf(",") + 1), "base64"),