n8n-editor-ui 2.3.3 → 2.4.1

package/dist/assets/{nodeIcon-CIlNGIQ6.js → nodeIcon-G45tSifH.js}

@@ -1,6 +1,6 @@
-import { Jt as removePreviewToken, Kt as isNodePreviewKey, N as useWorkflowsStore, Nt as useNodeTypesStore, oa as useUIStore, wi as getThemedValue } from "./builder.store-CgMqPgnW.js";
-import { Mi as isExpression } from "./constants-B5yiZflE.js";
-import { r as useRootStore } from "./_baseOrderBy-DwurmLcj.js";
+import { C as useNodeTypesStore, Di as getThemedValue, I as removePreviewToken, P as isNodePreviewKey, r as useUIStore, s as useWorkflowsStore } from "./users.store-KBMG-745.js";
+import { Mi as isExpression } from "./constants-CRdXn3zB.js";
+import { r as useRootStore } from "./_baseOrderBy-Cy5MGJv_.js";
 var resolveIconExpression = (icon, nodeType, node) => {
 	try {
 		const workflowsStore = useWorkflowsStore();

package/dist/assets/{nodeTransforms-yL73Ok-c.js → nodeTransforms-CjgwHZte.js}

@@ -1,5 +1,5 @@
-import { Nt as useNodeTypesStore } from "./builder.store-CgMqPgnW.js";
-import { Pt as AI_MCP_TOOL_NODE_TYPE, Si as traverseNodeParameters, Xi as displayParameter, ct as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, gr as WIKIPEDIA_TOOL_NODE_TYPE, ta as getNodeParameters } from "./constants-B5yiZflE.js";
+import { C as useNodeTypesStore } from "./users.store-KBMG-745.js";
+import { $i as getNodeParameters, Ji as displayParameter, Nt as AI_MCP_TOOL_NODE_TYPE, Si as traverseNodeParameters, ct as AI_CODE_TOOL_LANGCHAIN_NODE_TYPE, gr as WIKIPEDIA_TOOL_NODE_TYPE } from "./constants-CRdXn3zB.js";
 function getNodeTypeDisplayableCredentials(nodeTypeProvider, node) {
 	const nodeType = nodeTypeProvider.getNodeType(node.type, node.typeVersion);
 	if (!nodeType?.credentials) return [];

package/dist/assets/{orderBy-DLgDRKnZ.js → orderBy-CI4ht8Wh.js}

@@ -1,6 +1,6 @@
-import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
-import { m as require_isArray } from "./_MapCache-ficiegRb.js";
-import { t as require__baseOrderBy } from "./_baseOrderBy-DwurmLcj.js";
+import { t as __commonJSMin } from "./chunk-r2Y0G7H8.js";
+import { m as require_isArray } from "./_MapCache-DkLivSSb.js";
+import { t as require__baseOrderBy } from "./_baseOrderBy-Cy5MGJv_.js";
 var require_orderBy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var baseOrderBy = require__baseOrderBy(), isArray = require_isArray();
 	function orderBy(collection, iteratees, orders, guard) {

package/dist/assets/{personalizedTemplatesV3.store-Bs_2J_OQ.js → personalizedTemplatesV3.store-EQdiv-tM.js}

@@ -1,7 +1,7 @@
-import { C as computed, It as ref, _t as watch } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { Ec as STORES, N as useWorkflowsStore, O as useTelemetry, c as useTemplatesStore, gs as useSettingsStore, j as usePostHog, p as useCloudPlanStore } from "./builder.store-CgMqPgnW.js";
-import { Bo as VIEWS, mc as PERSONALIZED_TEMPLATES_V3, yc as TEMPLATE_RECO_V2 } from "./constants-B5yiZflE.js";
-import { k as defineStore } from "./_baseOrderBy-DwurmLcj.js";
+import { C as computed, It as ref, _t as watch } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { Mt as useTelemetry, ls as useSettingsStore, nr as useCloudPlanStore, pn as useTemplatesStore, s as useWorkflowsStore, vc as STORES, wr as usePostHog } from "./users.store-KBMG-745.js";
+import { _c as TEMPLATE_RECO_V2, fc as PERSONALIZED_TEMPLATES_V3, zo as VIEWS } from "./constants-CRdXn3zB.js";
+import { k as defineStore } from "./_baseOrderBy-Cy5MGJv_.js";
 const NODE_DATA = {
 	"@n8n/n8n-nodes-langchain.agent": {
 		starter: [

package/dist/assets/{pickBy-DYW-ATsL.js → pickBy-CS854Y6u.js}

@@ -1,6 +1,6 @@
-import { t as __commonJSMin } from "./chunk-6z4oVpB-.js";
-import { c as require__arrayMap } from "./truncate-B1HVeveJ.js";
-import { _i as require__baseIteratee, bi as require__getAllKeysIn, si as require__basePickBy } from "./constants-B5yiZflE.js";
+import { t as __commonJSMin } from "./chunk-r2Y0G7H8.js";
+import { c as require__arrayMap } from "./truncate-BrM_9cme.js";
+import { _i as require__baseIteratee, bi as require__getAllKeysIn, oi as require__basePickBy } from "./constants-CRdXn3zB.js";
 var require_pickBy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var arrayMap = require__arrayMap(), baseIteratee = require__baseIteratee(), basePickBy = require__basePickBy(), getAllKeysIn = require__getAllKeysIn();
 	function pickBy(object, predicate) {

package/dist/assets/pushConnection.store-Rp8-mZo7.js

@@ -0,0 +1,496 @@
+import { C as computed, It as ref, _t as watch } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { M as useLocalStorage } from "./_MapCache-DkLivSSb.js";
+import { ls as useSettingsStore, vc as STORES } from "./users.store-KBMG-745.js";
+import { Vs as LOCAL_STORAGE_RUN_DATA_WORKER, qr as createHeartbeatMessage } from "./constants-CRdXn3zB.js";
+import { k as defineStore, r as useRootStore } from "./_baseOrderBy-Cy5MGJv_.js";
+/**
+* @license
+* Copyright 2019 Google LLC
+* SPDX-License-Identifier: Apache-2.0
+*/
+var proxyMarker = Symbol("Comlink.proxy");
+var createEndpoint = Symbol("Comlink.endpoint");
+var releaseProxy = Symbol("Comlink.releaseProxy");
+var finalizer = Symbol("Comlink.finalizer");
+var throwMarker = Symbol("Comlink.thrown");
+var isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+var transferHandlers = new Map([["proxy", {
+	canHandle: (val) => isObject(val) && val[proxyMarker],
+	serialize(obj) {
+		const { port1, port2 } = new MessageChannel();
+		expose(obj, port1);
+		return [port2, [port2]];
+	},
+	deserialize(port) {
+		port.start();
+		return wrap(port);
+	}
+}], ["throw", {
+	canHandle: (value) => isObject(value) && throwMarker in value,
+	serialize({ value }) {
+		let serialized;
+		if (value instanceof Error) serialized = {
+			isError: true,
+			value: {
+				message: value.message,
+				name: value.name,
+				stack: value.stack
+			}
+		};
+		else serialized = {
+			isError: false,
+			value
+		};
+		return [serialized, []];
+	},
+	deserialize(serialized) {
+		if (serialized.isError) throw Object.assign(new Error(serialized.value.message), serialized.value);
+		throw serialized.value;
+	}
+}]]);
+function isAllowedOrigin(allowedOrigins, origin) {
+	for (const allowedOrigin of allowedOrigins) {
+		if (origin === allowedOrigin || allowedOrigin === "*") return true;
+		if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) return true;
+	}
+	return false;
+}
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+	ep.addEventListener("message", function callback(ev) {
+		if (!ev || !ev.data) return;
+		if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+			console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+			return;
+		}
+		const { id, type, path } = Object.assign({ path: [] }, ev.data);
+		const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+		let returnValue;
+		try {
+			const parent = path.slice(0, -1).reduce((obj$1, prop) => obj$1[prop], obj);
+			const rawValue = path.reduce((obj$1, prop) => obj$1[prop], obj);
+			switch (type) {
+				case "GET":
+					returnValue = rawValue;
+					break;
+				case "SET":
+					parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+					returnValue = true;
+					break;
+				case "APPLY":
+					returnValue = rawValue.apply(parent, argumentList);
+					break;
+				case "CONSTRUCT":
+					returnValue = proxy(new rawValue(...argumentList));
+					break;
+				case "ENDPOINT":
+					{
+						const { port1, port2 } = new MessageChannel();
+						expose(obj, port2);
+						returnValue = transfer(port1, [port1]);
+					}
+					break;
+				case "RELEASE":
+					returnValue = void 0;
+					break;
+				default: return;
+			}
+		} catch (value) {
+			returnValue = {
+				value,
+				[throwMarker]: 0
+			};
+		}
+		Promise.resolve(returnValue).catch((value) => {
+			return {
+				value,
+				[throwMarker]: 0
+			};
+		}).then((returnValue$1) => {
+			const [wireValue, transferables] = toWireValue(returnValue$1);
+			ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+			if (type === "RELEASE") {
+				ep.removeEventListener("message", callback);
+				closeEndPoint(ep);
+				if (finalizer in obj && typeof obj[finalizer] === "function") obj[finalizer]();
+			}
+		}).catch((error) => {
+			const [wireValue, transferables] = toWireValue({
+				value: /* @__PURE__ */ new TypeError("Unserializable return value"),
+				[throwMarker]: 0
+			});
+			ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+		});
+	});
+	if (ep.start) ep.start();
+}
+function isMessagePort(endpoint) {
+	return endpoint.constructor.name === "MessagePort";
+}
+function closeEndPoint(endpoint) {
+	if (isMessagePort(endpoint)) endpoint.close();
+}
+function wrap(ep, target) {
+	return createProxy(ep, [], target);
+}
+function throwIfProxyReleased(isReleased) {
+	if (isReleased) throw new Error("Proxy has been released and is not useable");
+}
+function releaseEndpoint(ep) {
+	return requestResponseMessage(ep, { type: "RELEASE" }).then(() => {
+		closeEndPoint(ep);
+	});
+}
+var proxyCounter = /* @__PURE__ */ new WeakMap();
+var proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+	const newCount = (proxyCounter.get(ep) || 0) - 1;
+	proxyCounter.set(ep, newCount);
+	if (newCount === 0) releaseEndpoint(ep);
+});
+function registerProxy(proxy$1, ep) {
+	const newCount = (proxyCounter.get(ep) || 0) + 1;
+	proxyCounter.set(ep, newCount);
+	if (proxyFinalizers) proxyFinalizers.register(proxy$1, ep, proxy$1);
+}
+function unregisterProxy(proxy$1) {
+	if (proxyFinalizers) proxyFinalizers.unregister(proxy$1);
+}
+function createProxy(ep, path = [], target = function() {}) {
+	let isProxyReleased = false;
+	const proxy$1 = new Proxy(target, {
+		get(_target, prop) {
+			throwIfProxyReleased(isProxyReleased);
+			if (prop === releaseProxy) return () => {
+				unregisterProxy(proxy$1);
+				releaseEndpoint(ep);
+				isProxyReleased = true;
+			};
+			if (prop === "then") {
+				if (path.length === 0) return { then: () => proxy$1 };
+				const r = requestResponseMessage(ep, {
+					type: "GET",
+					path: path.map((p) => p.toString())
+				}).then(fromWireValue);
+				return r.then.bind(r);
+			}
+			return createProxy(ep, [...path, prop]);
+		},
+		set(_target, prop, rawValue) {
+			throwIfProxyReleased(isProxyReleased);
+			const [value, transferables] = toWireValue(rawValue);
+			return requestResponseMessage(ep, {
+				type: "SET",
+				path: [...path, prop].map((p) => p.toString()),
+				value
+			}, transferables).then(fromWireValue);
+		},
+		apply(_target, _thisArg, rawArgumentList) {
+			throwIfProxyReleased(isProxyReleased);
+			const last = path[path.length - 1];
+			if (last === createEndpoint) return requestResponseMessage(ep, { type: "ENDPOINT" }).then(fromWireValue);
+			if (last === "bind") return createProxy(ep, path.slice(0, -1));
+			const [argumentList, transferables] = processArguments(rawArgumentList);
+			return requestResponseMessage(ep, {
+				type: "APPLY",
+				path: path.map((p) => p.toString()),
+				argumentList
+			}, transferables).then(fromWireValue);
+		},
+		construct(_target, rawArgumentList) {
+			throwIfProxyReleased(isProxyReleased);
+			const [argumentList, transferables] = processArguments(rawArgumentList);
+			return requestResponseMessage(ep, {
+				type: "CONSTRUCT",
+				path: path.map((p) => p.toString()),
+				argumentList
+			}, transferables).then(fromWireValue);
+		}
+	});
+	registerProxy(proxy$1, ep);
+	return proxy$1;
+}
+function myFlat(arr) {
+	return Array.prototype.concat.apply([], arr);
+}
+function processArguments(argumentList) {
+	const processed = argumentList.map(toWireValue);
+	return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+}
+var transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+	transferCache.set(obj, transfers);
+	return obj;
+}
+function proxy(obj) {
+	return Object.assign(obj, { [proxyMarker]: true });
+}
+function toWireValue(value) {
+	for (const [name, handler] of transferHandlers) if (handler.canHandle(value)) {
+		const [serializedValue, transferables] = handler.serialize(value);
+		return [{
+			type: "HANDLER",
+			name,
+			value: serializedValue
+		}, transferables];
+	}
+	return [{
+		type: "RAW",
+		value
+	}, transferCache.get(value) || []];
+}
+function fromWireValue(value) {
+	switch (value.type) {
+		case "HANDLER": return transferHandlers.get(value.name).deserialize(value.value);
+		case "RAW": return value.value;
+	}
+}
+function requestResponseMessage(ep, msg, transfers) {
+	return new Promise((resolve) => {
+		const id = generateUUID();
+		ep.addEventListener("message", function l(ev) {
+			if (!ev.data || !ev.data.id || ev.data.id !== id) return;
+			ep.removeEventListener("message", l);
+			resolve(ev.data);
+		});
+		if (ep.start) ep.start();
+		ep.postMessage(Object.assign({ id }, msg), transfers);
+	});
+}
+function generateUUID() {
+	return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+const useHeartbeat = (options) => {
+	const { interval, onHeartbeat } = options;
+	const heartbeatTimer = ref(null);
+	const startHeartbeat = () => {
+		heartbeatTimer.value = setInterval(onHeartbeat, interval);
+	};
+	const stopHeartbeat = () => {
+		if (heartbeatTimer.value) {
+			clearInterval(heartbeatTimer.value);
+			heartbeatTimer.value = null;
+		}
+	};
+	return {
+		startHeartbeat,
+		stopHeartbeat
+	};
+};
+const useReconnectTimer = ({ onAttempt, onAttemptScheduled }) => {
+	const initialReconnectDelay = 1e3;
+	const maxReconnectDelay = 15e3;
+	const reconnectTimer = ref(null);
+	const reconnectAttempts = ref(0);
+	const scheduleReconnect = () => {
+		const delay = Math.min(initialReconnectDelay * 2 ** reconnectAttempts.value, maxReconnectDelay);
+		reconnectAttempts.value++;
+		onAttemptScheduled(delay);
+		reconnectTimer.value = setTimeout(() => {
+			onAttempt();
+		}, delay);
+	};
+	const stopReconnectTimer = () => {
+		if (reconnectTimer.value) {
+			clearTimeout(reconnectTimer.value);
+			reconnectTimer.value = null;
+		}
+	};
+	const resetConnectionAttempts = () => {
+		reconnectAttempts.value = 0;
+	};
+	return {
+		scheduleReconnect,
+		stopReconnectTimer,
+		resetConnectionAttempts
+	};
+};
+const useWebSocketClient = (options) => {
+	const isConnected = ref(false);
+	const socket = ref(null);
+	const { startHeartbeat, stopHeartbeat } = useHeartbeat({
+		interval: 3e4,
+		onHeartbeat: () => {
+			socket.value?.send(JSON.stringify(createHeartbeatMessage()));
+		}
+	});
+	const onConnected = () => {
+		socket.value?.removeEventListener("open", onConnected);
+		isConnected.value = true;
+		startHeartbeat();
+		reconnectTimer.resetConnectionAttempts();
+	};
+	const onConnectionLost = (event) => {
+		console.warn(`[WebSocketClient] Connection lost, code=${event.code ?? "unknown"}`);
+		disconnect();
+		reconnectTimer.scheduleReconnect();
+	};
+	const onMessage = (event) => {
+		options.onMessage(event.data);
+	};
+	const onError = (error) => {
+		console.warn("[WebSocketClient] Connection error:", error);
+	};
+	const disconnect = () => {
+		if (socket.value) {
+			stopHeartbeat();
+			reconnectTimer.stopReconnectTimer();
+			socket.value.removeEventListener("message", onMessage);
+			socket.value.removeEventListener("error", onError);
+			socket.value.removeEventListener("close", onConnectionLost);
+			socket.value.close(1e3);
+			socket.value = null;
+		}
+		isConnected.value = false;
+	};
+	const connect = () => {
+		disconnect();
+		socket.value = new WebSocket(options.url);
+		socket.value.addEventListener("open", onConnected);
+		socket.value.addEventListener("message", onMessage);
+		socket.value.addEventListener("error", onError);
+		socket.value.addEventListener("close", onConnectionLost);
+		socket.value.binaryType = "arraybuffer";
+	};
+	const reconnectTimer = useReconnectTimer({
+		onAttempt: connect,
+		onAttemptScheduled: (delay) => {
+			console.log(`[WebSocketClient] Attempting to reconnect in ${delay}ms`);
+		}
+	});
+	const sendMessage = (serializedMessage) => {
+		if (!isConnected.value || !socket.value) throw new Error("Not connected to the server");
+		socket.value.send(serializedMessage);
+	};
+	return {
+		isConnected,
+		connect,
+		disconnect,
+		sendMessage
+	};
+};
+const useEventSourceClient = (options) => {
+	const isConnected = ref(false);
+	const eventSource = ref(null);
+	const onConnected = () => {
+		isConnected.value = true;
+		reconnectTimer.resetConnectionAttempts();
+	};
+	const onConnectionLost = () => {
+		console.warn("[EventSourceClient] Connection lost");
+		isConnected.value = false;
+		reconnectTimer.scheduleReconnect();
+	};
+	const onMessage = (event) => {
+		options.onMessage(event.data);
+	};
+	const disconnect = () => {
+		if (eventSource.value) {
+			reconnectTimer.stopReconnectTimer();
+			eventSource.value.close();
+			eventSource.value = null;
+		}
+		isConnected.value = false;
+	};
+	const connect = () => {
+		disconnect();
+		eventSource.value = new EventSource(options.url, { withCredentials: true });
+		eventSource.value.addEventListener("open", onConnected);
+		eventSource.value.addEventListener("message", onMessage);
+		eventSource.value.addEventListener("close", onConnectionLost);
+	};
+	const reconnectTimer = useReconnectTimer({
+		onAttempt: connect,
+		onAttemptScheduled: (delay) => {
+			console.log(`[EventSourceClient] Attempting to reconnect in ${delay}ms`);
+		}
+	});
+	const sendMessage = (_) => {};
+	return {
+		isConnected,
+		connect,
+		disconnect,
+		sendMessage
+	};
+};
+const runDataWorker = wrap(new Worker(new URL(
+	/* @vite-ignore */
+	"/%7B%7BBASE_PATH%7D%7D/assets/worker-BnP12nj7.js",
+	"" + import.meta.url
+), { type: "module" }));
+const usePushConnectionStore = defineStore(STORES.PUSH, () => {
+	const rootStore = useRootStore();
+	const settingsStore = useSettingsStore();
+	const isRunDataWorkerEnabled = useLocalStorage(LOCAL_STORAGE_RUN_DATA_WORKER, false);
+	const outgoingQueue = ref([]);
+	const isConnectionRequested = ref(false);
+	const onMessageReceivedHandlers = ref([]);
+	const addEventListener = (handler) => {
+		onMessageReceivedHandlers.value.push(handler);
+		return () => {
+			const index = onMessageReceivedHandlers.value.indexOf(handler);
+			if (index !== -1) onMessageReceivedHandlers.value.splice(index, 1);
+		};
+	};
+	const useWebSockets = computed(() => settingsStore.pushBackend === "websocket");
+	const getConnectionUrl = () => {
+		const restUrl = rootStore.restUrl;
+		const url$1 = `/push?pushRef=${rootStore.pushRef}`;
+		if (useWebSockets.value) {
+			const { protocol, host } = window.location;
+			return `${restUrl.startsWith("http") ? restUrl.replace(/^http/, "ws") : `${protocol === "https:" ? "wss" : "ws"}://${host + restUrl}`}${url$1}`;
+		} else return `${restUrl}${url$1}`;
+	};
+	async function onMessage(data) {
+		if (data instanceof ArrayBuffer) if (isRunDataWorkerEnabled.value) {
+			await runDataWorker.onNodeExecuteAfterData(data);
+			return;
+		} else data = new TextDecoder("utf-8").decode(new Uint8Array(data));
+		let parsedData;
+		try {
+			parsedData = JSON.parse(data);
+		} catch (error) {
+			return;
+		}
+		onMessageReceivedHandlers.value.forEach((handler) => handler(parsedData));
+	}
+	const url = getConnectionUrl();
+	const client = computed(() => useWebSockets.value ? useWebSocketClient({
+		url,
+		onMessage
+	}) : useEventSourceClient({
+		url,
+		onMessage
+	}));
+	function serializeAndSend(message) {
+		if (client.value.isConnected.value) client.value.sendMessage(JSON.stringify(message));
+		else outgoingQueue.value.push(message);
+	}
+	const pushConnect = () => {
+		isConnectionRequested.value = true;
+		client.value.connect();
+	};
+	const pushDisconnect = () => {
+		isConnectionRequested.value = false;
+		client.value.disconnect();
+	};
+	watch(() => client.value.isConnected.value, (didConnect) => {
+		if (!didConnect) return;
+		if (outgoingQueue.value.length) {
+			for (const message of outgoingQueue.value) serializeAndSend(message);
+			outgoingQueue.value = [];
+		}
+	});
+	const clearQueue = () => {
+		outgoingQueue.value = [];
+	};
+	return {
+		isConnected: computed(() => client.value.isConnected.value),
+		isConnectionRequested,
+		onMessageReceivedHandlers,
+		addEventListener,
+		pushConnect,
+		pushDisconnect,
+		send: serializeAndSend,
+		clearQueue
+	};
+});
+export { proxy as n, wrap as r, usePushConnectionStore as t };

package/dist/assets/{radio-BeejvdFG.js → radio-I_Y35sEo.js}

@@ -1,5 +1,5 @@
-import { C as computed, Cn as toDisplayString, D as createElementBlock, G as nextTick, Gt as unref, Ht as toRefs, It as ref, P as defineComponent, Pt as reactive, Z as onMounted, _t as watch, at as renderSlot, bn as normalizeStyle, d as vModelRadio, et as openBlock, h as withModifiers, j as createTextVNode, jt as isRef, mn as isString, nt as provide, tn as init_shared_esm_bundler, vn as normalizeClass, w as createBaseVNode, xt as withDirectives, z as inject } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { Jt as debugWarn, L as _export_sfc, M as useFormItemInputId, N as useFormDisabled, P as useFormSize, U as useId, V as useSizeProp, _t as buildProps, at as UPDATE_MODEL_EVENT, ct as withInstall, en as isBoolean, j as useFormItem, q as useNamespace, rn as isNumber, rt as CHANGE_EVENT, ut as withNoopInstall } from "./truncate-B1HVeveJ.js";
+import { C as computed, Cn as toDisplayString, D as createElementBlock, G as nextTick, Gt as unref, Ht as toRefs, It as ref, P as defineComponent, Pt as reactive, Z as onMounted, _t as watch, at as renderSlot, bn as normalizeStyle, d as vModelRadio, et as openBlock, h as withModifiers, j as createTextVNode, jt as isRef, mn as isString, nt as provide, tn as init_shared_esm_bundler, vn as normalizeClass, w as createBaseVNode, xt as withDirectives, z as inject } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { Jt as debugWarn, L as _export_sfc, M as useFormItemInputId, N as useFormDisabled, P as useFormSize, U as useId, V as useSizeProp, _t as buildProps, at as UPDATE_MODEL_EVENT, ct as withInstall, en as isBoolean, j as useFormItem, q as useNamespace, rn as isNumber, rt as CHANGE_EVENT, ut as withNoopInstall } from "./truncate-BrM_9cme.js";
 init_shared_esm_bundler();
 var radioPropsBase = buildProps({
 	size: useSizeProp,

package/dist/assets/{readyToRun.store-DX00OlhN.js → readyToRun.store-i9gaUDlh.js}

@@ -1,10 +1,10 @@
-import { C as computed, It as ref, Pt as reactive } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { M as useLocalStorage, _t as useI18n } from "./_MapCache-ficiegRb.js";
-import { v as useRoute, y as useRouter } from "./truncate-B1HVeveJ.js";
-import { Dr as useUsersStore, Ec as STORES, N as useWorkflowsStore, O as useTelemetry, gn as useCredentialsStore, gs as useSettingsStore, j as usePostHog, p as useCloudPlanStore, v as useToast } from "./builder.store-CgMqPgnW.js";
-import { Bo as VIEWS, Ea as deepCopy, gc as READY_TO_RUN_V2_P3_EXPERIMENT, uo as OPEN_AI_API_CREDENTIAL_TYPE } from "./constants-B5yiZflE.js";
-import { k as defineStore } from "./_baseOrderBy-DwurmLcj.js";
-import { t as useFoldersStore } from "./folders.store-BqKf5TBS.js";
+import { C as computed, It as ref, Pt as reactive } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { M as useLocalStorage, _t as useI18n } from "./_MapCache-DkLivSSb.js";
+import { v as useRoute, y as useRouter } from "./truncate-BrM_9cme.js";
+import { Mt as useTelemetry, br as useToast, ls as useSettingsStore, nr as useCloudPlanStore, nt as useCredentialsStore, s as useWorkflowsStore, t as useUsersStore, vc as STORES, wr as usePostHog } from "./users.store-KBMG-745.js";
+import { Ta as deepCopy, lo as OPEN_AI_API_CREDENTIAL_TYPE, pc as READY_TO_RUN_V2_P3_EXPERIMENT, zo as VIEWS } from "./constants-CRdXn3zB.js";
+import { k as defineStore } from "./_baseOrderBy-Cy5MGJv_.js";
+import { t as useFoldersStore } from "./folders.store-DHmLGEYl.js";
 const READY_TO_RUN_AI_WORKFLOW = {
 	name: "AI Agent workflow",
 	meta: { templateId: "ready-to-run-ai-workflow" },
@@ -525,6 +525,11 @@ const useReadyToRunWorkflowsV2Store = defineStore(STORES.EXPERIMENT_READY_TO_RUN
 });
 var LOCAL_STORAGE_CREDENTIAL_KEY = "N8N_READY_TO_RUN_OPENAI_CREDENTIAL_ID";
 const useReadyToRunStore = defineStore(STORES.READY_TO_RUN, () => {
+	const READY_TO_RUN_TEMPLATE_IDS = [
+		"ready-to-run-ai-workflow",
+		"ready-to-run-ai-workflow-v5",
+		"ready-to-run-ai-workflow-v6"
+	];
 	const telemetry = useTelemetry();
 	const i18n = useI18n();
 	const toast = useToast();
@@ -610,6 +615,9 @@ const useReadyToRunStore = defineStore(STORES.READY_TO_RUN, () => {
 	const getSimplifiedLayoutVisibility = (route) => {
 		return isTrulyEmpty(route);
 	};
+	const isReadyToRunTemplateId = (templateId) => {
+		return !!templateId && READY_TO_RUN_TEMPLATE_IDS.includes(templateId);
+	};
 	return {
 		claimingCredits,
 		userCanClaimOpenAiCredits,
@@ -620,7 +628,8 @@ const useReadyToRunStore = defineStore(STORES.READY_TO_RUN, () => {
 		getButtonVisibility,
 		getSimplifiedLayoutVisibility,
 		trackExecuteAiWorkflow,
-		trackExecuteAiWorkflowSuccess
+		trackExecuteAiWorkflowSuccess,
+		isReadyToRunTemplateId
 	};
 });
 export { useProjectPages as n, useReadyToRunStore as t };

package/dist/assets/{readyToRunWorkflows.store-CR7Yn6At.js → readyToRunWorkflows.store-gcTSDf1M.js}

@@ -1,9 +1,9 @@
-import { C as computed } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { M as useLocalStorage, _t as useI18n } from "./_MapCache-ficiegRb.js";
-import { Ec as STORES, N as useWorkflowsStore, O as useTelemetry, j as usePostHog, p as useCloudPlanStore } from "./builder.store-CgMqPgnW.js";
-import { cc as BATCH_11AUG_EXPERIMENT } from "./constants-B5yiZflE.js";
-import { k as defineStore } from "./_baseOrderBy-DwurmLcj.js";
-import { t as useFoldersStore } from "./folders.store-BqKf5TBS.js";
+import { C as computed } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { M as useLocalStorage, _t as useI18n } from "./_MapCache-DkLivSSb.js";
+import { Mt as useTelemetry, nr as useCloudPlanStore, s as useWorkflowsStore, vc as STORES, wr as usePostHog } from "./users.store-KBMG-745.js";
+import { oc as BATCH_11AUG_EXPERIMENT } from "./constants-CRdXn3zB.js";
+import { k as defineStore } from "./_baseOrderBy-Cy5MGJv_.js";
+import { t as useFoldersStore } from "./folders.store-DHmLGEYl.js";
 const PLAYGROUND_1 = {
 	meta: { templateId: "37_onboarding_experiments_batch_aug11-1_filter_data" },
 	name: "▶️ 1. Filter data coming from an API",

package/dist/assets/{roles.store-DeGSYcWL.js → roles.store-ByEYbWMb.js}

@@ -1,7 +1,7 @@
-import { C as computed, It as ref } from "./vue.runtime.esm-bundler-tP5dCd7J.js";
-import { Fs as createProjectRole, Is as deleteProjectRole, Ls as getRoleBySlug, Rs as getRoles, gs as useSettingsStore, zs as updateProjectRole } from "./builder.store-CgMqPgnW.js";
-import { Mo as PROJECT_CHAT_USER_ROLE_SLUG, No as PROJECT_OWNER_ROLE_SLUG } from "./constants-B5yiZflE.js";
-import { k as defineStore, r as useRootStore } from "./_baseOrderBy-DwurmLcj.js";
+import { C as computed, It as ref } from "./vue.runtime.esm-bundler-XtMkEjzB.js";
+import { As as getRoleBySlug, Ms as updateProjectRole, Os as createProjectRole, js as getRoles, ks as deleteProjectRole, ls as useSettingsStore } from "./users.store-KBMG-745.js";
+import { Mo as PROJECT_OWNER_ROLE_SLUG, jo as PROJECT_CHAT_USER_ROLE_SLUG } from "./constants-CRdXn3zB.js";
+import { k as defineStore, r as useRootStore } from "./_baseOrderBy-Cy5MGJv_.js";
 const useRolesStore = defineStore("roles", () => {
 	const rootStore = useRootStore();
 	const settingsStore = useSettingsStore();