@parallelworks/ui 0.15.0 → 0.17.0

package/dist/chunks/{Monaco-BXDH2jVj.js → Monaco-DVyIpyv4.js}

@@ -1,16 +1,307 @@
-import { l as useWorkflowJsonResolver } from "./Provider-CbFVFB7O.js";
+import { d as useWorkflowJsonResolver, s as useRepoSuggestions } from "./Provider-DHmZ3v9i.js";
 import { t as useCssIsDark } from "./useCssIsDark-DHr05dG2.js";
-import { n as defineEditorThemes, r as getThemeName, t as setupMonacoWorkers } from "./editor-Ko3zX22Y.js";
+import { n as defineEditorThemes, r as getThemeName, t as setupMonacoWorkers } from "./editor-mNznodJN.js";
 import cx from "classnames";
 import { jsx } from "react/jsx-runtime";
-import { useEffect, useRef } from "react";
+import { useEffect, useLayoutEffect, useRef } 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/usesGitlab.ts
+/** Splits GROUP/PROJECT@REF; the ref is null when no @ has been typed yet. */
+function splitAtRef(typed) {
+	const at = typed.indexOf("@");
+	if (at === -1) return [typed, null];
+	return [typed.slice(0, at), typed.slice(at + 1)];
+}
+/** What to insert for a chosen project, given what is already typed. A typed prefix is
+* completed like the github one; a mid-path match has to replace what is there. */
+function projectInsert(typed, path) {
+	if (path.toLowerCase().startsWith(typed.toLowerCase())) return {
+		text: path.slice(typed.length),
+		replace: false
+	};
+	return {
+		text: path,
+		replace: true
+	};
+}
+/** Indent of a line, or -1 when it is blank. */
+function indentOf(content) {
+	if (content.trim() === "") return -1;
+	return content.length - content.trimStart().length;
+}
+/** Every line belonging to the step a uses: is part of, in order. */
+function stepBody(model, usesLine, maxLines = 40) {
+	const keyIndent = model.getLineContent(usesLine).match(/^(\s*(?:-\s+)?)/)?.[1]?.length ?? 0;
+	const out = [];
+	for (let ln = usesLine + 1; ln <= usesLine + maxLines; ln++) {
+		let content;
+		try {
+			content = model.getLineContent(ln);
+		} catch {
+			break;
+		}
+		const indent = indentOf(content);
+		if (indent === -1) continue;
+		if (indent < keyIndent) break;
+		out.push({
+			line: ln,
+			content
+		});
+	}
+	return out;
+}
+/** The $host the step pins, or undefined. Quotes and a trailing comment are stripped,
+* so a pinned host is recognised however it was written. */
+function stepHostAbove(model, usesLine, maxLines = 40) {
+	for (const { content } of stepBody(model, usesLine, maxLines)) {
+		const match = content.match(/^\s*\$host\s*:\s*(.+?)\s*$/);
+		if (match) return unquoteScalar(match[1] ?? "");
+	}
+}
+/** A YAML scalar as written: quotes removed, a trailing comment dropped. */
+function unquoteScalar(raw) {
+	let value = raw.trim();
+	const quoted = value.match(/^(['"])(.*)\1\s*(?:#.*)?$/);
+	if (quoted) return quoted[2] ?? "";
+	const hash = value.indexOf(" #");
+	if (hash !== -1) value = value.slice(0, hash);
+	return value.trim();
+}
+/** How to add `$host` to a step. Always an edit of its own: monaco re-indents a
+* multi-line insertText, and the cursor has to stay after the project. */
+function hostCompletion(model, usesLine, host) {
+	const none = {
+		appendText: "",
+		edits: []
+	};
+	if (!host || host === "gitlab.com") return none;
+	const usesContent = model.getLineContent(usesLine);
+	const keyIndent = " ".repeat(usesContent.match(/^(\s*(?:-\s+)?)uses/)?.[1]?.length ?? indentOf(usesContent));
+	for (const { line, content } of stepBody(model, usesLine)) if (/^\s*with\s*:\s*$/.test(content)) {
+		const withIndent = content.match(/^(\s*)/)?.[1] ?? keyIndent;
+		return place(model, line + 1, `${withIndent}  $host: ${host}`);
+	}
+	return place(model, usesLine + 1, `${keyIndent}with:\n${keyIndent}  $host: ${host}`);
+}
+/** Whole lines that belong before `line`. With nothing there to sit above, they ride along
+* in the completion's own text: a second edit would share the last line's end offset with
+* the item insert, and monaco decides which of the two lands first. */
+function place(model, line, text) {
+	if (line > model.getLineCount()) return {
+		appendText: `\n${text}`,
+		edits: []
+	};
+	return {
+		appendText: "",
+		edits: [lineEdit(model, line, text)]
+	};
+}
+/** An insert of whole lines before `line`, which the completion cannot shift because it
+* never spans a newline. */
+function lineEdit(model, line, text) {
+	return {
+		range: {
+			startLineNumber: line,
+			startColumn: 1,
+			endLineNumber: line,
+			endColumn: 1
+		},
+		text: `${text}\n`
+	};
+}
+/** A trailing slash or @ after a known project is the ref separator, the way a trailing
+* slash is for github/OWNER/REPO. The slash is swapped for @ when a ref is accepted. */
+function refTrigger(typed, knownPaths) {
+	const at = typed.indexOf("@");
+	if (at !== -1) return typed.slice(at + 1) === "" ? {
+		projectPath: typed.slice(0, at),
+		replaceSlash: false
+	} : void 0;
+	if (!typed.endsWith("/")) return;
+	const projectPath = typed.slice(0, -1);
+	return knownPaths.includes(projectPath) ? {
+		projectPath,
+		replaceSlash: true
+	} : void 0;
+}
+/** What to ask the platform for when completing a project path: everything before the
+* first slash. Typing deeper then filters that answer instead of asking again. */
+function projectSearchKey(typed) {
+	const slash = typed.indexOf("/");
+	return slash === -1 ? typed : typed.slice(0, slash);
+}
+/** Where a `$yaml:`/`$thumbnail:` value's files come from: the nearest `uses:` above,
+* addressed the way the platform's file endpoint expects. A gitlab/ path carries no
+* host, so the step's $host supplies it. */
+function usesFileSource(model, fromLine, maxLines = 30) {
+	for (let ln = fromLine - 1; ln >= Math.max(fromLine - maxLines, 1); ln--) {
+		const uses = model.getLineContent(ln).trim().match(/^(?:-\s+)?uses\s*:\s*(\S+)\s*$/);
+		if (!uses) continue;
+		const [target, ref] = splitAtRef(uses[1] ?? "");
+		const github = target.match(/^github\/([^/]+\/.+)$/);
+		if (github) return {
+			repo: github[1] ?? "",
+			ref: ref ?? ""
+		};
+		const gitlab = target.match(/^gitlab\/(.+)$/);
+		if (gitlab) return {
+			repo: `https://${stepHostAbove(model, ln) ?? "gitlab.com"}/${gitlab[1] ?? ""}`,
+			ref: ref ?? ""
+		};
+		return;
+	}
+}
+var FILE_VALUE_KINDS = {
+	$yaml: {
+		detail: "yaml file",
+		keep: (path) => path.endsWith(".yaml") || path.endsWith(".yml")
+	},
+	$thumbnail: {
+		detail: "image file",
+		keep: (path) => [
+			".png",
+			".jpg",
+			".jpeg",
+			".gif",
+			".svg",
+			".webp"
+		].some((ext) => path.toLowerCase().endsWith(ext))
+	}
+};
+/** Which of the two file-valued keys the cursor sits on, if either. */
+function fileValueKey(textUntilCursor) {
+	return textUntilCursor.match(/^\s*(\$yaml|\$thumbnail)\s*:\s*$/)?.[1] ?? void 0;
+}
+/** The files worth offering for a `$yaml:`/`$thumbnail:` value, from whichever
+* repository the step's `uses:` names. Empty when the line is not one of those keys,
+* no `uses:` is above it, or the tree cannot be read. */
+async function fileValueSuggestions(model, line, textUntilCursor, loadTree) {
+	const key = fileValueKey(textUntilCursor);
+	if (!key) return [];
+	const source = usesFileSource(model, line);
+	if (!source) return [];
+	const { detail, keep } = FILE_VALUE_KINDS[key];
+	return (await loadTree(source.repo, source.ref)).filter((entry) => entry.type === "blob" && keep(entry.path)).map((entry) => ({
+		path: entry.path,
+		detail
+	}));
+}
+/** Every $-prefixed key a step already sets, mapped to its value. Nothing already
+* written is offered a second time, and an existing one must not suppress the rest. */
+function specialKeysNearUses(model, usesLineNumber) {
+	const found = /* @__PURE__ */ new Map();
+	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;
+		const match = content.match(/^(\$[A-Za-z]+)\s*:\s*(.*)$/);
+		if (match) found.set(match[1], match[2].trim());
+	}
+	return found;
+}
+/** The same, for a with: block located by its own indentation. */
+function specialKeysInWithBlock(model, withLineNumber) {
+	const found = /* @__PURE__ */ new Map();
+	const withIndent = model.getLineContent(withLineNumber).match(/^(\s*)/)?.[1]?.length ?? 0;
+	const totalLines = model.getLineCount();
+	for (let ln = withLineNumber + 1; ln <= totalLines; ln++) {
+		const line = model.getLineContent(ln);
+		if (line.trim() === "") continue;
+		if ((line.match(/^(\s*)/)?.[1]?.length ?? 0) <= withIndent) break;
+		const match = line.match(/^\s*(\$[A-Za-z]+)\s*:\s*(.*)$/);
+		if (match) found.set(match[1], match[2].trim());
+	}
+	return found;
+}
+/** Text to be inserted as a snippet, with the characters monaco's snippet parser would
+* otherwise read as placeholders escaped. */
+function snippetLiteral(text) {
+	return text.replace(/[\\$}]/g, "\\$&");
+}
+/** How a completion inserts its text when a `$host` block has to travel with it. The
+* cursor stop is what keeps the caret on the uses: line rather than after the block;
+* without a block there is nothing to escape and it stays a plain insert. */
+function completionInsert(text, appendText) {
+	if (!appendText) return {
+		insertText: text,
+		isSnippet: false
+	};
+	return {
+		insertText: `${snippetLiteral(text)}$0${snippetLiteral(appendText)}`,
+		isSnippet: true
+	};
+}
+//#endregion
 //#region src/editor/Monaco.tsx
 setupMonacoWorkers();
 var activeWorkflowJsonResolver;
+var activeRepoSuggestions;
+var suggestionCache = /* @__PURE__ */ new Map();
+var CACHE_MS = 3e4;
+var OWNER_CACHE_MS = 5 * 6e4;
+var asSnippet = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet | monaco.languages.CompletionItemInsertTextRule.KeepWhitespace;
+var MAX_PROJECT_SUGGESTIONS = 200;
+async function cached(key, fallback, load, ttl = CACHE_MS) {
+	if (!activeRepoSuggestions) return fallback;
+	const hit = suggestionCache.get(key);
+	if (hit && Date.now() - hit.at < ttl) try {
+		return await hit.value;
+	} catch {
+		return fallback;
+	}
+	if (suggestionCache.size > 100) suggestionCache.clear();
+	const value = load();
+	suggestionCache.set(key, {
+		at: Date.now(),
+		value
+	});
+	try {
+		return await value;
+	} catch {
+		suggestionCache.delete(key);
+		return fallback;
+	}
+}
+/** Refs of a repository, or [] when the host bound nothing or the call fails. */
+async function repoRefs(repo) {
+	return cached(`refs\u0000${repo}`, [], () => activeRepoSuggestions.refs(repo));
+}
+/** Repositories under an owner, or every one the account can reach when the owner is
+* empty. [] when the host bound nothing. */
+async function repoOwnerRepos(owner) {
+	return cached(`repos\u0000${owner}`, [], () => activeRepoSuggestions.repos(owner), OWNER_CACHE_MS);
+}
+/** Owners a reference can name: accounts and organizations, or GitLab groups. */
+async function repoOwners(provider, search, host) {
+	return cached(`owners\u0000${provider}\u0000${host ?? ""}\u0000${search}`, [], () => activeRepoSuggestions.owners(provider, search, host), OWNER_CACHE_MS);
+}
+/** Projects matching what is typed, fetched once per group rather than once per
+* keystroke. The platform caps its answer, so a group that fills the cap is re-asked
+* with the full path instead of filtering an already-truncated list. */
+async function matchingProjects(typed, host) {
+	const key = projectSearchKey(typed);
+	const byGroup = await gitlabProjects(key, host);
+	const wanted = typed.toLowerCase();
+	const narrowed = byGroup.filter((project) => project.path.toLowerCase().includes(wanted));
+	if (key !== typed && byGroup.length >= MAX_PROJECT_SUGGESTIONS) return gitlabProjects(typed, host);
+	return narrowed;
+}
+/** GitLab projects matching a partial path, across every connected server. */
+async function gitlabProjects(search, host) {
+	return cached(`gitlab\u0000${host ?? ""}\u0000${search}`, [], () => activeRepoSuggestions.gitlabProjects(search, host), OWNER_CACHE_MS);
+}
+/** One file's contents, or '' on the same terms. */
+async function repoFile(repo, ref, path) {
+	return cached(`file\u0000${repo}\u0000${ref}\u0000${path}`, "", () => activeRepoSuggestions.file(repo, ref, path));
+}
+/** Tree entries of a repository, or [] on the same terms. */
+async function repoFiles(repo, ref, path) {
+	return cached(`files\u0000${repo}\u0000${ref}\u0000${path}`, [], () => activeRepoSuggestions.files(repo, ref, path));
+}
 var monacoWithWorkerBridge = {
 	...monaco,
 	editor: {
@@ -47,16 +338,23 @@ function readExecuteInputs(doc) {
 	const inputs = execute["inputs"];
 	return isWorkflowInputs(inputs) ? inputs : {};
 }
+function editorText(value) {
+	return value.replace(/\r/g, "");
+}
 var noop = () => {};
 function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop, width = "100%", height = "100%", path = "file:///default", marketplaceItems = [], workflows = [], ...options }) {
 	const isDark = useCssIsDark();
 	const readOnly = disabled || options.readOnly;
 	const resolveWorkflowJson = useWorkflowJsonResolver();
+	const repoSuggestions = useRepoSuggestions();
 	const monacoRef = useRef(null);
 	const isSyncingValueRef = useRef(false);
 	useEffect(() => {
 		activeWorkflowJsonResolver = resolveWorkflowJson;
 	}, [resolveWorkflowJson]);
+	useEffect(() => {
+		activeRepoSuggestions = repoSuggestions;
+	}, [repoSuggestions]);
 	useEffect(() => {
 		if (!monacoRef.current) return;
 		defineEditorThemes(monaco.editor);
@@ -67,12 +365,13 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 		isDark,
 		readOnly
 	]);
-	useEffect(() => {
-		if (!monacoRef.current) return;
-		const model = monacoRef.current.getModel();
-		if (model && options.value !== void 0 && model.getValue() !== options.value) {
-			isSyncingValueRef.current = true;
+	useLayoutEffect(() => {
+		const model = monacoRef.current?.getModel();
+		if (!model || options.value === void 0 || editorText(model.getValue()) === editorText(options.value)) return;
+		isSyncingValueRef.current = true;
+		try {
 			model.setValue(options.value);
+		} finally {
 			isSyncingValueRef.current = false;
 		}
 	}, [options.value]);
@@ -99,7 +398,7 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 	]);
 	/** Strips CR (\r) — Windows line endings break bash scripts. */
 	const onChangeWrapper = (value) => {
-		value = value.replace(/\r/g, "");
+		value = editorText(value);
 		onChange(value);
 	};
 	return /* @__PURE__ */ jsx("div", {
@@ -164,8 +463,9 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 						const workflowIndex = textUntilPos.lastIndexOf("workflow/");
 						const pwIndex = textUntilPos.lastIndexOf("parallelworks/");
 						const githubIndex = textUntilPos.lastIndexOf("github/");
+						const gitlabIndex = textUntilPos.lastIndexOf("gitlab/");
 						const usesText = textUntilPos.match(/^\s*(?:-\s+)?uses\s*:\s*([^\n\r]*)$/)?.[1]?.trim() ?? "";
-						if (marketIndex === -1 && workflowIndex === -1 && pwIndex === -1 && githubIndex === -1) {
+						if (marketIndex === -1 && workflowIndex === -1 && pwIndex === -1 && githubIndex === -1 && gitlabIndex === -1) {
 							if (usesText.trim().length > 0) return { suggestions };
 							return { suggestions: [
 								{
@@ -186,7 +486,14 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 									label: "github",
 									sortText: "4",
 									insertText: "github",
-									detail: "use a workflow from a public GitHub repository",
+									detail: "use a workflow from a GitHub repository",
+									...defaultItem
+								},
+								{
+									label: "gitlab",
+									sortText: "5",
+									insertText: "gitlab",
+									detail: "use a workflow from a GitLab project",
 									...defaultItem
 								}
 							] };
@@ -195,7 +502,8 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 							"marketplace/",
 							"workflow/",
 							"parallelworks/",
-							"github/"
+							"github/",
+							"gitlab/"
 						].includes(usesText);
 						if (workflowIndex !== -1 && noExtra) {
 							if (lineContent.substring(workflowIndex, position.column - 1).split("/").length === 2) suggestions = workflows.map((item) => {
@@ -238,20 +546,25 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 								label: "Type a GitHub username or organization",
 								insertText: "",
 								detail: "e.g. github/myorg/",
+								sortText: "0",
 								...defaultItem
-							}];
+							}, ...(await repoOwners("github", "")).map((owner, index) => ({
+								label: owner.name,
+								filterText: owner.name,
+								insertText: owner.name,
+								detail: owner.kind,
+								sortText: `1${String(index).padStart(4, "0")}`,
+								...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 {}
+								if (rest === "") suggestions = (await repoOwnerRepos(ghOwner ?? "")).map((r) => ({
+									label: r.description ? `${r.name} — ${r.description}` : r.name,
+									insertText: r.name,
+									detail: r.description || (r.private ? "private repository" : "repository"),
+									...defaultItem
+								}));
 								else {
 									let ghRepo = "";
 									let isRefTrigger = false;
@@ -279,46 +592,105 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 											},
 											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 {}
+										const refs = await repoRefs(`${ghOwner}/${ghRepo}`);
+										suggestions.push(...refs.map((ref, index) => ({
+											label: ref.kind === "commit" ? ref.name.slice(0, 7) : ref.name,
+											insertText: ref.name,
+											detail: ref.detail || ref.kind,
+											sortText: String(index).padStart(4, "0"),
+											additionalTextEdits: slashToAtEdit,
+											...defaultItem
+										})));
 									}
 								}
 							}
+						} else if (gitlabIndex !== -1) {
+							const typed = usesText.replace("gitlab/", "");
+							const pinned = stepHostAbove(model, position.lineNumber);
+							const projects = typed === "" ? [] : await matchingProjects(typed.replace(/[@/]$/, ""), pinned);
+							const trigger = refTrigger(typed, projects.map((project) => project.path));
+							if (trigger) {
+								const slashToAtEdit = trigger.replaceSlash ? [{
+									range: {
+										startLineNumber: position.lineNumber,
+										startColumn: position.column - 1,
+										endLineNumber: position.lineNumber,
+										endColumn: position.column
+									},
+									text: "@"
+								}] : [];
+								const host = pinned ?? projects.find((project) => project.path === trigger.projectPath)?.host;
+								if (!host) return { suggestions };
+								const refs = await repoRefs(`https://${host}/${trigger.projectPath}`);
+								const withHost = pinned ? {
+									appendText: "",
+									edits: []
+								} : hostCompletion(model, position.lineNumber, host);
+								suggestions = refs.map((ref, index) => {
+									const inserted = completionInsert(ref.name, withHost.appendText);
+									return {
+										label: ref.kind === "commit" ? ref.name.slice(0, 7) : ref.name,
+										insertText: inserted.insertText,
+										...inserted.isSnippet ? { insertTextRules: asSnippet } : {},
+										detail: ref.detail || ref.kind,
+										sortText: String(index).padStart(4, "0"),
+										additionalTextEdits: [...slashToAtEdit, ...withHost.edits],
+										...defaultItem
+									};
+								});
+							} else if (typed === "") suggestions = [{
+								label: "Type a GitLab group or namespace",
+								insertText: "",
+								detail: "e.g. gitlab/mygroup/",
+								sortText: "0",
+								...defaultItem
+							}, ...(await repoOwners("gitlab", "", pinned)).map((owner, index) => {
+								const withHost = pinned ? {
+									appendText: "",
+									edits: []
+								} : hostCompletion(model, position.lineNumber, owner.host ?? "");
+								const ownerInsert = completionInsert(owner.name, withHost.appendText);
+								return {
+									label: owner.name,
+									filterText: owner.name,
+									insertText: ownerInsert.insertText,
+									...ownerInsert.isSnippet ? { insertTextRules: asSnippet } : {},
+									detail: pinned ? owner.kind : `${owner.host} — ${owner.kind}`,
+									additionalTextEdits: withHost.edits,
+									sortText: `1${String(index).padStart(4, "0")}`,
+									...defaultItem
+								};
+							})];
+							else if (!typed.includes("@")) suggestions = (await matchingProjects(typed, pinned)).map((project, index) => {
+								const insert = projectInsert(typed, project.path);
+								const withHost = pinned ? {
+									appendText: "",
+									edits: []
+								} : hostCompletion(model, position.lineNumber, project.host);
+								const projectInserted = completionInsert(insert.text, withHost.appendText);
+								const shown = insert.replace ? project.path : insert.text;
+								return {
+									label: project.description ? `${shown} — ${project.description}` : shown,
+									filterText: project.path,
+									insertText: projectInserted.insertText,
+									...projectInserted.isSnippet ? { insertTextRules: asSnippet } : {},
+									detail: pinned ? project.description || (project.private ? "private project" : "project") : `${project.host}${project.description ? ` — ${project.description}` : ""}`,
+									additionalTextEdits: withHost.edits,
+									range: insert.replace ? {
+										startLineNumber: position.lineNumber,
+										startColumn: gitlabIndex + 7 + 1,
+										endLineNumber: position.lineNumber,
+										endColumn: position.column
+									} : {
+										startLineNumber: position.lineNumber,
+										startColumn: position.column,
+										endLineNumber: position.lineNumber,
+										endColumn: position.column
+									},
+									sortText: `1${String(index).padStart(4, "0")}`,
+									kind: monaco.languages.CompletionItemKind.Value
+								};
+							});
 						}
 						return { suggestions };
 					}
@@ -330,76 +702,18 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 						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;
-								}
+						if (fileValueKey(textUntilPos)) return { suggestions: (await fileValueSuggestions(model, lineNumber, textUntilPos, (repo, ref) => repoFiles(repo, ref, ""))).map((file) => ({
+							label: file.path,
+							insertText: file.path,
+							detail: file.detail,
+							kind: monaco.languages.CompletionItemKind.File,
+							range: {
+								startLineNumber: lineNumber,
+								startColumn: position.column,
+								endLineNumber: lineNumber,
+								endColumn: position.column
 							}
-							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;
@@ -424,7 +738,7 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 						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;
+							if (/^\$[A-Za-z]+\s*:/.test(content)) continue;
 							return { suggestions: [] };
 						}
 						const needsNewline = isOnWithLine || isOnYamlLine;
@@ -502,24 +816,34 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 								...defaultItem
 							}] };
 						}
-						if (!(usesValue.startsWith("marketplace/") || usesValue.startsWith("workflow/") || usesValue.startsWith("github/"))) return { suggestions: [] };
+						if (!(usesValue.startsWith("marketplace/") || usesValue.startsWith("workflow/") || usesValue.startsWith("github/") || usesValue.startsWith("gitlab/"))) 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 isGitlab = usesValue.startsWith("gitlab/");
+						const isRepoRef = isGithub || isGitlab;
+						const present = needsWithLine ? specialKeysNearUses(model, usesLineNum) : specialKeysInWithBlock(model, withLineNum);
+						const offers = (key) => isRepoRef && !present.has(key);
+						if (isGitlab) {
+							const [projectPath, ref] = splitAtRef(usesValue.replace("gitlab/", ""));
+							const host = stepHostAbove(model, usesLineNum) || "gitlab.com";
+							if (!projectPath || !ref) return { suggestions: [] };
+							usesWorkflowRef = [projectPath];
+							const yamlPath = (!needsWithLine ? present.get("$yaml") : void 0) || "workflow.yaml";
+							const text = await repoFile(`https://${host}/${projectPath}`, ref, yamlPath);
+							if (text) try {
+								inputs = readExecuteInputs(yaml.load(text));
+							} catch {}
+						} else 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 = readExecuteInputs(yaml.load(text));
-								}
+							const yamlPath = (!needsWithLine ? present.get("$yaml") : void 0) || "workflow.yaml";
+							const text = await repoFile(`${owner}/${repo}`, ref ?? "", yamlPath);
+							if (text) try {
+								inputs = readExecuteInputs(yaml.load(text));
 							} catch {}
 						} else {
 							usesWorkflowRef = usesValue.split("/").slice(1);
@@ -547,15 +871,22 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 								insertText: "",
 								...defaultItem
 							}];
-							if (isGithub) {
-								if (!hasYamlOverride) noInputSuggestions.unshift({
+							if (isGitlab && !present.has("$host")) noInputSuggestions.unshift({
+								label: "$host",
+								detail: "The registered GitLab server this project lives on (default: gitlab.com)",
+								sortText: "0b",
+								insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $host:` : needsIndent ? "\n  $host:" : "$host:",
+								...defaultItem
+							});
+							if (isRepoRef) {
+								if (offers("$yaml")) noInputSuggestions.unshift({
 									label: "$yaml",
-									detail: "Specify the yaml path in the GitHub repo (default: workflow.yaml)",
+									detail: "Specify the yaml path in the repository (default: workflow.yaml)",
 									sortText: "0",
 									insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $yaml:` : needsIndent ? "\n  $yaml:" : "$yaml:",
 									...defaultItem
 								});
-								noInputSuggestions.unshift({
+								if (offers("$thumbnail")) noInputSuggestions.unshift({
 									label: "$thumbnail",
 									detail: "Specify a thumbnail image path or URL for this subworkflow",
 									sortText: "0a",
@@ -657,15 +988,22 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 							insertText: withSuggestionYaml,
 							...defaultItem
 						}];
-						if (isGithub) {
-							if (!hasYamlOverride) suggestions.unshift({
+						if (isGitlab && !present.has("$host")) suggestions.unshift({
+							label: "$host (GitLab server)",
+							detail: "The registered GitLab server this project lives on (default: gitlab.com)",
+							sortText: "0b",
+							insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $host:` : needsIndent ? "\n  $host:" : "$host:",
+							...defaultItem
+						});
+						if (isRepoRef) {
+							if (offers("$yaml")) suggestions.unshift({
 								label: "$yaml (custom yaml path)",
-								detail: "Override the default workflow.yaml path in the GitHub repo",
+								detail: "Override the default workflow.yaml path in the repository",
 								sortText: "0",
 								insertText: needsWithLine ? `${withIndent}with:\n${withIndent}  $yaml:` : needsIndent ? "\n  $yaml:" : "$yaml:",
 								...defaultItem
 							});
-							suggestions.unshift({
+							if (offers("$thumbnail")) suggestions.unshift({
 								label: "$thumbnail (custom thumbnail)",
 								detail: "Specify a thumbnail image path or URL for this subworkflow",
 								sortText: "0a",
@@ -704,30 +1042,5 @@ function prepareWithSuggestion(needsNewline, needsIndent, needsWithLine, withInd
 	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 };