@parallelworks/ui 0.1.0 → 0.2.0

package/dist/chunks/Monaco-CP_cL9gp.js

@@ -0,0 +1,745 @@
+import { s as useWorkflowJsonResolver } from "./Provider-C2VtPnh5.js";
+import { n as defineEditorThemes, r as getThemeName, t as setupMonacoWorkers } from "./workers-Cjfjb8E7.js";
+import cx from "classnames";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { dumpYaml } from "@parallelworks/workflow-parser";
+import yaml from "js-yaml";
+import * as monaco from "monaco-editor";
+import { configureMonacoYaml } from "monaco-yaml";
+//#region src/editor/Monaco.tsx
+setupMonacoWorkers();
+var activeWorkflowJsonResolver;
+function readIsDark() {
+	const scheme = getComputedStyle(document.documentElement).colorScheme;
+	const dark = scheme.includes("dark");
+	if (dark !== scheme.includes("light")) return dark;
+	return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+function useCssIsDark() {
+	const [isDark, setIsDark] = useState(readIsDark);
+	useEffect(() => {
+		const update = () => setIsDark(readIsDark());
+		const media = window.matchMedia("(prefers-color-scheme: dark)");
+		media.addEventListener("change", update);
+		const observer = new MutationObserver(update);
+		observer.observe(document.documentElement, {
+			attributes: true,
+			attributeFilter: [
+				"style",
+				"class",
+				"data-theme"
+			]
+		});
+		return () => {
+			media.removeEventListener("change", update);
+			observer.disconnect();
+		};
+	}, []);
+	return isDark;
+}
+var monacoWithWorkerBridge = {
+	...monaco,
+	editor: {
+		...monaco.editor,
+		createWebWorker: (opts) => "worker" in opts ? monaco.editor.createWebWorker(opts) : monaco.createWebWorker(opts)
+	}
+};
+var monacoYamlConfigured = false;
+function ensureMonacoYamlConfigured() {
+	if (monacoYamlConfigured) return;
+	monacoYamlConfigured = true;
+	configureMonacoYaml(monacoWithWorkerBridge, {
+		enableSchemaRequest: true,
+		completion: true,
+		validate: true,
+		hover: true,
+		format: { enable: true },
+		schemas: [{
+			fileMatch: ["file:///workflow.yaml"],
+			uri: `${window.location.origin}/workflow.schema.json`
+		}]
+	});
+}
+var workflowCompletionContexts = /* @__PURE__ */ new Map();
+var registeredCompletionProviders = [];
+var workflowCompletionProvidersRegistered = false;
+var noop = () => {};
+function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop, width = "100%", height = "100%", path = "file:///default", marketplaceItems = [], workflows = [], ...options }) {
+	const isDark = useCssIsDark();
+	const resolveWorkflowJson = useWorkflowJsonResolver();
+	const monacoRef = useRef(null);
+	const isSyncingValueRef = useRef(false);
+	useEffect(() => {
+		activeWorkflowJsonResolver = resolveWorkflowJson;
+	}, [resolveWorkflowJson]);
+	useEffect(() => {
+		if (!monacoRef.current) return;
+		defineEditorThemes(monaco.editor);
+		monaco.editor.setTheme(getThemeName(isDark, disabled));
+		monacoRef.current.updateOptions({ readOnly: disabled });
+	}, [disabled, isDark]);
+	useEffect(() => {
+		if (!monacoRef.current) return;
+		const model = monacoRef.current.getModel();
+		if (model && options.value !== void 0 && model.getValue() !== options.value) {
+			isSyncingValueRef.current = true;
+			model.setValue(options.value);
+			isSyncingValueRef.current = false;
+		}
+	}, [options.value]);
+	useEffect(() => {
+		return () => {
+			monacoRef.current?.dispose();
+			monacoRef.current = null;
+		};
+	}, []);
+	useEffect(() => {
+		const uri = monaco.Uri.parse(path).toString();
+		if (marketplaceItems.length > 0 || workflows.length > 0) workflowCompletionContexts.set(uri, {
+			marketplaceItems,
+			workflows
+		});
+		else workflowCompletionContexts.delete(uri);
+		return () => {
+			workflowCompletionContexts.delete(uri);
+		};
+	}, [
+		marketplaceItems,
+		workflows,
+		path
+	]);
+	/** Strips CR (\r) — Windows line endings break bash scripts. */
+	const onChangeWrapper = (value) => {
+		value = value.replace(/\r/g, "");
+		onChange(value);
+	};
+	return /* @__PURE__ */ jsx("div", {
+		style: {
+			width,
+			height
+		},
+		className: cx("relative border rounded", className),
+		ref: (ref) => {
+			if (ref && !monacoRef.current) {
+				monaco.editor.getModel(monaco.Uri.parse(path))?.dispose();
+				defineEditorThemes(monaco.editor);
+				monaco.editor.setTheme(getThemeName(isDark, disabled));
+				const model = monaco.editor.createModel(options.value ?? "", options.language, monaco.Uri.parse(path));
+				const editor = monaco.editor.create(ref, {
+					automaticLayout: true,
+					model,
+					...options,
+					readOnly: disabled || options.readOnly,
+					fixedOverflowWidgets: true,
+					suggest: {
+						preview: true,
+						showWords: false,
+						showInlineDetails: true
+					}
+				});
+				model.onDidChangeContent(() => {
+					if (isSyncingValueRef.current) return;
+					onChangeWrapper(editor.getValue());
+				});
+				model.onDidChangeDecorations(() => {
+					onValidate(monaco.editor.getModelMarkers({ resource: model.uri }));
+				});
+				ensureMonacoYamlConfigured();
+				monacoRef.current = editor;
+				if (workflowCompletionProvidersRegistered) return;
+				workflowCompletionProvidersRegistered = true;
+				registeredCompletionProviders.push(monaco.languages.registerCompletionItemProvider("yaml", {
+					triggerCharacters: [
+						"/",
+						" ",
+						"@"
+					],
+					provideCompletionItems: async (model, position) => {
+						const context = workflowCompletionContexts.get(model.uri.toString());
+						if (!context) return { suggestions: [] };
+						const { marketplaceItems, workflows } = context;
+						const lineContent = model.getLineContent(position.lineNumber);
+						const textUntilPos = lineContent.substring(0, position.column - 1);
+						const defaultItem = {
+							kind: monaco.languages.CompletionItemKind.Value,
+							range: {
+								startLineNumber: position.lineNumber,
+								startColumn: position.column,
+								endLineNumber: position.lineNumber,
+								endColumn: position.column
+							}
+						};
+						let suggestions = [];
+						if (!/^\s*(?:-\s+)?uses\s*:\s*([^\n\r]*)$/.test(textUntilPos)) return { suggestions };
+						const marketIndex = textUntilPos.lastIndexOf("marketplace/");
+						const workflowIndex = textUntilPos.lastIndexOf("workflow/");
+						const pwIndex = textUntilPos.lastIndexOf("parallelworks/");
+						const githubIndex = textUntilPos.lastIndexOf("github/");
+						const usesText = textUntilPos.match(/^\s*(?:-\s+)?uses\s*:\s*([^\n\r]*)$/)?.[1]?.trim() ?? "";
+						if (marketIndex === -1 && workflowIndex === -1 && pwIndex === -1 && githubIndex === -1) {
+							if (usesText.trim().length > 0) return { suggestions };
+							return { suggestions: [
+								{
+									label: "marketplace",
+									sortText: "2",
+									insertText: "marketplace",
+									detail: "use a workflow from the marketplace",
+									...defaultItem
+								},
+								{
+									label: "workflow",
+									sortText: "3",
+									insertText: "workflow",
+									detail: "use one of your workflows",
+									...defaultItem
+								},
+								{
+									label: "github",
+									sortText: "4",
+									insertText: "github",
+									detail: "use a workflow from a public GitHub repository",
+									...defaultItem
+								}
+							] };
+						}
+						const noExtra = [
+							"marketplace/",
+							"workflow/",
+							"parallelworks/",
+							"github/"
+						].includes(usesText);
+						if (workflowIndex !== -1 && noExtra) {
+							if (lineContent.substring(workflowIndex, position.column - 1).split("/").length === 2) suggestions = workflows.map((item) => {
+								const name = item.name ?? "";
+								return {
+									label: item.displayName && item.displayName !== name ? `${item.displayName} (${name})` : name,
+									insertText: name,
+									detail: item.description ? item.description : `${item.type ?? ""} workflow`,
+									...defaultItem
+								};
+							});
+						} else if (marketIndex !== -1) {
+							const sections = lineContent.substring(marketIndex, position.column - 1).split("/");
+							if (sections.length === 2 && noExtra) suggestions = marketplaceItems.filter((item) => item.type === "workflow").map((item) => {
+								const slug = item.slug ?? "";
+								return {
+									label: item.name && item.name !== slug ? `${item.name} (${slug})` : slug,
+									insertText: slug,
+									detail: item.description ? item.description : `${item.subtype ?? ""} workflow`,
+									...defaultItem
+								};
+							});
+							else if (sections.length === 3 && sections[2] === "") {
+								const mpItem = marketplaceItems.find((item) => item.slug === sections[1]);
+								if (mpItem && mpItem.versions) suggestions = [...mpItem.versions.map((v) => {
+									return {
+										label: v,
+										insertText: v,
+										...defaultItem
+									};
+								}), {
+									label: "latest",
+									insertText: "latest",
+									...defaultItem
+								}];
+							}
+						} else if (githubIndex !== -1) {
+							const afterGithub = usesText.replace("github/", "");
+							if (afterGithub === "") suggestions = [{
+								label: "Type a GitHub username or organization",
+								insertText: "",
+								detail: "e.g. github/myorg/",
+								...defaultItem
+							}];
+							else if (!afterGithub.includes("/")) {} else {
+								const ghOwner = afterGithub.split("/")[0];
+								const rest = afterGithub.split("/").slice(1).join("/");
+								if (rest === "") try {
+									const resp = await fetch(`https://api.github.com/users/${ghOwner}/repos?per_page=100&sort=updated`);
+									if (resp.ok) suggestions = (await resp.json()).map((r) => ({
+										label: r.description ? `${r.name} — ${r.description}` : r.name,
+										insertText: r.name,
+										detail: r.description || "GitHub repository",
+										...defaultItem
+									}));
+								} catch {}
+								else {
+									let ghRepo = "";
+									let isRefTrigger = false;
+									let replaceSlash = false;
+									const slashRefMatch = rest.match(/^([^@/]+)\/$/);
+									if (slashRefMatch) {
+										ghRepo = slashRefMatch[1];
+										isRefTrigger = true;
+										replaceSlash = true;
+									} else if (rest.includes("@")) {
+										const atRepo = rest.split("@")[0];
+										const refPart = rest.split("@").slice(1).join("@");
+										if (atRepo && refPart === "") {
+											ghRepo = atRepo;
+											isRefTrigger = true;
+										}
+									}
+									if (isRefTrigger && ghRepo) {
+										const slashToAtEdit = replaceSlash ? [{
+											range: {
+												startLineNumber: position.lineNumber,
+												startColumn: position.column - 1,
+												endLineNumber: position.lineNumber,
+												endColumn: position.column
+											},
+											text: "@"
+										}] : [];
+										try {
+											const [branchResp, tagResp, commitResp] = await Promise.all([
+												fetch(`https://api.github.com/repos/${ghOwner}/${ghRepo}/branches?per_page=100`),
+												fetch(`https://api.github.com/repos/${ghOwner}/${ghRepo}/tags?per_page=100`),
+												fetch(`https://api.github.com/repos/${ghOwner}/${ghRepo}/commits?per_page=10`)
+											]);
+											if (branchResp.ok) {
+												const branches = await branchResp.json();
+												suggestions.push(...branches.map((b) => ({
+													label: b.name,
+													insertText: b.name,
+													detail: "branch",
+													additionalTextEdits: slashToAtEdit,
+													...defaultItem
+												})));
+											}
+											if (tagResp.ok) {
+												const tags = await tagResp.json();
+												suggestions.push(...tags.map((t) => ({
+													label: t.name,
+													insertText: t.name,
+													detail: "tag",
+													additionalTextEdits: slashToAtEdit,
+													...defaultItem
+												})));
+											}
+											if (commitResp.ok) {
+												const commits = await commitResp.json();
+												suggestions.push(...commits.map((c) => ({
+													label: `${c.sha.slice(0, 7)} — ${c.commit.message.split("\n")[0]}`,
+													insertText: c.sha,
+													detail: "commit",
+													additionalTextEdits: slashToAtEdit,
+													...defaultItem
+												})));
+											}
+										} catch {}
+									}
+								}
+							}
+						}
+						return { suggestions };
+					}
+				}));
+				registeredCompletionProviders.push(monaco.languages.registerCompletionItemProvider("yaml", {
+					triggerCharacters: [" ", "\n"],
+					provideCompletionItems: async (model, position) => {
+						if (!workflowCompletionContexts.has(model.uri.toString())) return { suggestions: [] };
+						const lineNumber = position.lineNumber;
+						const lineContent = model.getLineContent(lineNumber);
+						const textUntilPos = lineContent.substring(0, position.column - 1);
+						if (/^\s*\$yaml\s*:\s*$/.test(textUntilPos)) {
+							for (let ln = lineNumber - 1; ln >= Math.max(lineNumber - 30, 1); ln--) {
+								const m = model.getLineContent(ln).trim().match(/^(?:-\s+)?uses\s*:\s*github\/([^/]+)\/([^@]+)@(.+)$/);
+								if (m) {
+									const [, owner, repo, ref] = m;
+									try {
+										const resp = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`);
+										if (resp.ok) {
+											const data = await resp.json();
+											const defaultItem = {
+												kind: monaco.languages.CompletionItemKind.File,
+												range: {
+													startLineNumber: lineNumber,
+													startColumn: position.column,
+													endLineNumber: lineNumber,
+													endColumn: position.column
+												}
+											};
+											return { suggestions: (data.tree || []).filter((item) => item.type === "blob" && (item.path.endsWith(".yaml") || item.path.endsWith(".yml"))).map((f) => ({
+												label: f.path,
+												insertText: f.path,
+												detail: "yaml file",
+												...defaultItem
+											})) };
+										}
+									} catch {}
+									break;
+								}
+							}
+							return { suggestions: [] };
+						}
+						if (/^\s*\$thumbnail\s*:\s*$/.test(textUntilPos)) {
+							for (let ln = lineNumber - 1; ln >= Math.max(lineNumber - 30, 1); ln--) {
+								const m = model.getLineContent(ln).trim().match(/^(?:-\s+)?uses\s*:\s*github\/([^/]+)\/([^@]+)@(.+)$/);
+								if (m) {
+									const [, owner, repo, ref] = m;
+									try {
+										const resp = await fetch(`https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`);
+										if (resp.ok) {
+											const data = await resp.json();
+											const defaultItem = {
+												kind: monaco.languages.CompletionItemKind.File,
+												range: {
+													startLineNumber: lineNumber,
+													startColumn: position.column,
+													endLineNumber: lineNumber,
+													endColumn: position.column
+												}
+											};
+											const imageExts = [
+												".png",
+												".jpg",
+												".jpeg",
+												".gif",
+												".svg",
+												".webp"
+											];
+											return { suggestions: (data.tree || []).filter((item) => item.type === "blob" && imageExts.some((ext) => item.path.toLowerCase().endsWith(ext))).map((f) => ({
+												label: f.path,
+												insertText: f.path,
+												detail: "image file",
+												...defaultItem
+											})) };
+										}
+									} catch {}
+									break;
+								}
+							}
+							return { suggestions: [] };
+						}
+						const isOnWithLine = /^\s*with\s*:\s*([^\n\r]*)$/.test(textUntilPos);
+						const isOnYamlLine = /^\s*\$(yaml|thumbnail)\s*:\s*\S/.test(textUntilPos);
+						let withLineNum = -1;
+						if (isOnWithLine) withLineNum = lineNumber;
+						else if (isOnYamlLine) for (let ln = lineNumber - 1; ln >= Math.max(lineNumber - 20, 1); ln--) {
+							const content = model.getLineContent(ln);
+							if (content.trim() === "") continue;
+							if (/^\s*with\s*:\s*([^\n\r]*)$/.test(content)) {
+								withLineNum = ln;
+								break;
+							}
+						}
+						else if (textUntilPos.trim() === "") for (let ln = lineNumber - 1; ln >= Math.max(lineNumber - 20, 1); ln--) {
+							const content = model.getLineContent(ln);
+							if (content.trim() === "") continue;
+							if (/^\s*with\s*:\s*([^\n\r]*)$/.test(content)) {
+								withLineNum = ln;
+								break;
+							}
+						}
+						if (withLineNum === -1) return { suggestions: [] };
+						if (!isOnWithLine && !isOnYamlLine && withLineNum !== -1) for (let ln = withLineNum + 1; ln < lineNumber; ln++) {
+							const content = model.getLineContent(ln).trim();
+							if (content === "") continue;
+							if (/^\$(yaml|thumbnail)\s*:/.test(content)) continue;
+							return { suggestions: [] };
+						}
+						const needsNewline = isOnWithLine || isOnYamlLine;
+						const needsIndent = isOnWithLine;
+						let usesLine = "";
+						let usesLineNum = -1;
+						for (let ln = lineNumber - 1; ln >= Math.max(lineNumber - 20, 1); ln--) {
+							const content = model.getLineContent(ln).trim();
+							if (/^(?:-\s+)?uses\s*:\s*(.+)$/.test(content)) {
+								usesLine = content;
+								usesLineNum = ln;
+								break;
+							}
+						}
+						const needsWithLine = usesLineNum !== -1 && withLineNum < usesLineNum;
+						let withIndent = "";
+						if (needsWithLine && usesLineNum !== -1) {
+							const indentMatch = model.getLineContent(usesLineNum).match(/^(\s*(?:-\s+)?)uses/);
+							if (indentMatch) withIndent = " ".repeat(indentMatch[1].length);
+						}
+						const defaultItem = {
+							kind: monaco.languages.CompletionItemKind.Value,
+							range: needsWithLine ? {
+								startLineNumber: lineNumber,
+								startColumn: 1,
+								endLineNumber: lineNumber,
+								endColumn: lineContent.length + 1
+							} : {
+								startLineNumber: lineNumber,
+								startColumn: position.column,
+								endLineNumber: lineNumber,
+								endColumn: position.column
+							}
+						};
+						if (usesLine === "") return { suggestions: [] };
+						const m = usesLine.match(/^(?:-\s+)?uses\s*:\s*(.+)$/);
+						if (!m) return { suggestions: [] };
+						const usesValue = m[1].trim();
+						if (!usesValue) return { suggestions: [] };
+						if (usesValue.startsWith("parallelworks/")) {
+							if (!needsWithLine && !isOnWithLine) return { suggestions: [] };
+							const actionDef = {
+								"parallelworks/checkout": {
+									label: "checkout",
+									required: {
+										repo: "https://github.com/parallelworks/interactive_session.git",
+										branch: "main"
+									}
+								},
+								"parallelworks/scheduler-agent": {
+									label: "scheduler-agent",
+									required: { "scheduler-type": "slurm" }
+								},
+								"parallelworks/wait-for-agent": {
+									label: "wait-for-agent",
+									required: { agentId: "${{ needs.JOB.steps.STEP.outputs.agentId }}" }
+								},
+								"parallelworks/cancel-jobs": {
+									label: "cancel-jobs",
+									required: {}
+								},
+								"parallelworks/update-session": {
+									label: "update-session",
+									required: { name: "session-name" }
+								}
+							}[usesValue];
+							if (!actionDef || Object.keys(actionDef.required).length === 0) return { suggestions: [] };
+							const withObj = { ...actionDef.required };
+							const withSuggestionYaml = prepareWithSuggestion(needsNewline, needsIndent, needsWithLine, withIndent, withObj);
+							return { suggestions: [{
+								label: actionDef.label + " inputs",
+								detail: "inputs for the " + actionDef.label + " action",
+								sortText: "1",
+								insertText: withSuggestionYaml,
+								...defaultItem
+							}] };
+						}
+						if (!(usesValue.startsWith("marketplace/") || usesValue.startsWith("workflow/") || usesValue.startsWith("github/"))) return { suggestions: [] };
+						let inputs = {};
+						let usesWorkflowRef;
+						const isGithub = usesValue.startsWith("github/");
+						const hasYamlOverride = isGithub && (needsWithLine ? hasYamlNearUses(model, usesLineNum) : scanForYamlInWithBlock(model, withLineNum) !== void 0);
+						if (isGithub) {
+							const [ownerRepo, ref] = usesValue.replace("github/", "").split("@");
+							if (!ownerRepo || !ref) return { suggestions: [] };
+							const [owner, repo] = ownerRepo.split("/");
+							if (!owner || !repo) return { suggestions: [] };
+							usesWorkflowRef = [ownerRepo];
+							const yamlPath = (!needsWithLine ? scanForYamlInWithBlock(model, withLineNum) : void 0) || "workflow.yaml";
+							try {
+								const response = await fetch(`https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${yamlPath}`);
+								if (response.ok) {
+									const text = await response.text();
+									inputs = yaml.load(text)?.on?.execute?.inputs || {};
+								}
+							} catch {}
+						} else {
+							usesWorkflowRef = usesValue.split("/").slice(1);
+							const resolveJson = activeWorkflowJsonResolver;
+							if (!resolveJson) return { suggestions: [] };
+							try {
+								const data = await resolveJson(usesValue.startsWith("marketplace/") ? {
+									kind: "marketplace",
+									slug: usesWorkflowRef[0],
+									version: usesWorkflowRef.length > 1 ? usesWorkflowRef[1] : "latest"
+								} : {
+									kind: "workflow",
+									name: usesWorkflowRef[0]
+								});
+								if (!data) return { suggestions: [] };
+								inputs = data?.on?.execute?.inputs || {};
+							} catch {
+								return { suggestions: [] };
+							}
+						}
+						if (Object.keys(inputs).length === 0) {
+							const noInputSuggestions = [{
+								label: "No inputs found",
+								detail: usesWorkflowRef[0] + " has no inputs.",
+								insertText: "",
+								...defaultItem
+							}];
+							if (isGithub) {
+								if (!hasYamlOverride) noInputSuggestions.unshift({
+									label: "$yaml",
+									detail: "Specify the yaml path in the GitHub repo (default: workflow.yaml)",
+									sortText: "0",
+									insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $yaml:` : needsIndent ? "\n  $yaml:" : "$yaml:",
+									...defaultItem
+								});
+								noInputSuggestions.unshift({
+									label: "$thumbnail",
+									detail: "Specify a thumbnail image path or URL for this subworkflow",
+									sortText: "0a",
+									insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $thumbnail:` : needsIndent ? "\n  $thumbnail:" : "$thumbnail:",
+									...defaultItem
+								});
+							}
+							return { suggestions: noInputSuggestions };
+						}
+						let groupname = usesValue.replaceAll("/", "_").replaceAll(".", "-").replaceAll("@", "_");
+						const fullText = model.getValue();
+						let groupidx = 0;
+						try {
+							const basename = groupname;
+							while (true) if (yaml.load(fullText)?.on?.execute?.inputs?.[groupname]) {
+								groupidx++;
+								groupname = `${basename}_${groupidx}`;
+							} else break;
+						} catch {}
+						const withSuggestionYaml = prepareWithSuggestion(needsNewline, needsIndent, needsWithLine, withIndent, constructWithSuggestion(inputs, groupname));
+						const lines = fullText.split(/\r?\n/);
+						let inputsLineIndex = -1;
+						for (let i = 0; i < lines.length; i++) if (/^[ \t]*inputs\s*:\s*(#.*)?$/.test(lines[i])) {
+							const inputsIndentMatch = lines[i].match(/^([ \t]*)/);
+							const inputsIndent = inputsIndentMatch ? inputsIndentMatch[1].length : 0;
+							let executeIndex = -1;
+							for (let j = i - 1; j >= 0; j--) {
+								const m = lines[j].match(/^([ \t]*)([^\s:]+)\s*:\s*(#.*)?$/);
+								if (!m) continue;
+								const indent = m[1].length;
+								if (m[2] === "execute" && indent < inputsIndent) {
+									executeIndex = j;
+									break;
+								}
+							}
+							if (executeIndex === -1) continue;
+							const execIndentMatch = lines[executeIndex].match(/^([ \t]*)/);
+							const execIndent = execIndentMatch ? execIndentMatch[1].length : 0;
+							let onFound = false;
+							for (let k = executeIndex - 1; k >= 0; k--) {
+								const mOn = lines[k].match(/^([ \t]*)(?:'on'|on)\s*:\s*(#.*)?$/);
+								if (!mOn) continue;
+								if (mOn[1].length < execIndent) {
+									onFound = true;
+									break;
+								}
+							}
+							if (onFound) {
+								inputsLineIndex = i;
+								break;
+							}
+						}
+						const additionalTextEdits = [];
+						const yamlInputs = `      ${groupname}:\nlabel: ${usesWorkflowRef[0]} inputs${groupidx === 0 ? "" : ` ${groupidx}`}\ntype: group\nitems:\n  `.replaceAll("\n", "\n        ") + rewriteInputExpressionsForGroup(dumpYaml(inputs), groupname).trim().replaceAll("\n", "\n          ") + "\n";
+						if (inputsLineIndex !== -1) {
+							const insertLineNumber = inputsLineIndex + 2;
+							additionalTextEdits.push({
+								range: {
+									startLineNumber: insertLineNumber,
+									startColumn: 1,
+									endLineNumber: insertLineNumber,
+									endColumn: 1
+								},
+								text: yamlInputs
+							});
+						} else {
+							if (position.lineNumber === lines.length) {
+								const editor = monaco.editor.getEditors().find((e) => e.getModel()?.uri.toString() === model.uri.toString());
+								editor?.executeEdits("ensure-trailing-newline", [{
+									range: new monaco.Range(lines.length, lineContent.length + 1, lines.length, lineContent.length + 1),
+									text: "\n",
+									forceMoveMarkers: true
+								}], () => {
+									const sel = editor?.getSelection();
+									return sel ? [sel] : null;
+								});
+							}
+							additionalTextEdits.push({
+								range: {
+									startLineNumber: lines.length + 1,
+									startColumn: 1,
+									endLineNumber: lines.length + 1,
+									endColumn: 1
+								},
+								text: "\non:\n  execute:\n    inputs:\n" + yamlInputs
+							});
+						}
+						const suggestions = [{
+							label: usesWorkflowRef[0] + " inputs",
+							detail: "all input expressions and dynamic form additions",
+							sortText: "1",
+							insertText: withSuggestionYaml,
+							additionalTextEdits,
+							...defaultItem
+						}, {
+							label: usesWorkflowRef[0] + " inputs only",
+							detail: "all input expressions only, no dynamic form additions",
+							sortText: "2",
+							insertText: withSuggestionYaml,
+							...defaultItem
+						}];
+						if (isGithub) {
+							if (!hasYamlOverride) suggestions.unshift({
+								label: "$yaml (custom yaml path)",
+								detail: "Override the default workflow.yaml path in the GitHub repo",
+								sortText: "0",
+								insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $yaml:` : needsIndent ? "\n  $yaml:" : "$yaml:",
+								...defaultItem
+							});
+							suggestions.unshift({
+								label: "$thumbnail (custom thumbnail)",
+								detail: "Specify a thumbnail image path or URL for this subworkflow",
+								sortText: "0a",
+								insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $thumbnail:` : needsIndent ? "\n  $thumbnail:" : "$thumbnail:",
+								...defaultItem
+							});
+						}
+						return { suggestions };
+					}
+				}));
+			}
+		}
+	});
+}
+/** When a workflow is imported as a group, rewrites bare `inputs.X` → `inputs.<groupname>.X` so expressions still resolve. */
+function rewriteInputExpressionsForGroup(yamlStr, groupname) {
+	return yamlStr.replace(/\$\{\{(.*?)\}\}/g, (_match, expr) => {
+		return "${{ " + expr.replace(/\binputs\./g, `inputs.${groupname}.`).trim() + " }}";
+	});
+}
+function constructWithSuggestion(inputs, path) {
+	const withSuggestion = {};
+	Object.keys(inputs).map((k) => {
+		const input = inputs[k];
+		if (input.type === "group" && input.items) withSuggestion[k] = constructWithSuggestion(input.items, path + "." + k);
+		else withSuggestion[k] = "${{ inputs." + path + "." + k + " }}";
+	});
+	return withSuggestion;
+}
+function prepareWithSuggestion(needsNewline, needsIndent, needsWithLine, withIndent, withSuggestion) {
+	let withSuggestionYaml = dumpYaml(withSuggestion);
+	if (needsWithLine) {
+		const childIndent = withIndent + "  ";
+		withSuggestionYaml = (withIndent + "with:\n" + withSuggestionYaml).replaceAll("\n", "\n" + childIndent);
+	} else if (needsNewline && needsIndent) withSuggestionYaml = ("\n" + withSuggestionYaml).replaceAll("\n", "\n  ");
+	else if (needsNewline) withSuggestionYaml = "\n" + withSuggestionYaml;
+	return withSuggestionYaml;
+}
+/** Scan lines below a `uses:` line for a `$yaml:` key, stopping at another step. */
+function hasYamlNearUses(model, usesLineNumber) {
+	const totalLines = model.getLineCount();
+	for (let ln = usesLineNumber + 1; ln <= Math.min(usesLineNumber + 20, totalLines); ln++) {
+		const content = model.getLineContent(ln).trim();
+		if (content === "") continue;
+		if (/^-\s/.test(content)) break;
+		if (/^\$yaml\s*:/.test(content)) return true;
+	}
+	return false;
+}
+/** Scan lines below a `with:` line for a `$yaml:` key within the same indent block. */
+function scanForYamlInWithBlock(model, withLineNumber) {
+	const withIndentMatch = model.getLineContent(withLineNumber).match(/^(\s*)/);
+	const withIndent = withIndentMatch ? withIndentMatch[1].length : 0;
+	const totalLines = model.getLineCount();
+	for (let ln = withLineNumber + 1; ln <= totalLines; ln++) {
+		const line = model.getLineContent(ln);
+		if (line.trim() === "") continue;
+		const indentMatch = line.match(/^(\s*)/);
+		if ((indentMatch ? indentMatch[1].length : 0) <= withIndent) break;
+		const yamlMatch = line.match(/^\s*\$yaml\s*:\s*(.*)$/);
+		if (yamlMatch) return yamlMatch[1].trim();
+	}
+}
+//#endregion
+export { MonacoEditor as default };