@parallelworks/ui 0.36.0 → 0.38.0

package/dist/editing.d.ts

@@ -5,20 +5,386 @@ export interface GraphPosition {
 }
 /** Job name to grid slot, as stored on a workflow. */
 export type GraphLayout = Record<string, GraphPosition>;
+/** Where a dragged job lands; `insertColumn` opens a new column at `column`. */
+export interface GraphSlot {
+    column: number;
+    row: number;
+    insertColumn?: boolean;
+}
+/** One entry of a job's `needs` list. */
+export interface NeedRef {
+    job: string;
+    need: string;
+}
+export type NudgeDirection = 'up' | 'down' | 'left' | 'right';
 /** One column's boxes, top to bottom, the row each box sits in, and the column's number. */
 export interface LaidOutColumn {
     boxes: string[][];
     rows: number[];
     column: number;
 }
+/** A step by its job and its index in that job's `steps`. */
+export interface StepRef {
+    job: string;
+    index: number;
+}
+/** A matrix variable: a list of values, or a `${{ }}` expression string. */
+export type MatrixVariable = [name: string, values: unknown[] | string];
+/** Keys to write (a null value writes YAML null) and keys to remove. */
+export interface FieldPatch {
+    set?: Record<string, unknown>;
+    unset?: string[];
+}
+/** Keys from the workflow's inputs down to an input, through groups, lists and steps. */
+export type InputPath = string[];
+export type InputEdit = {
+    type: 'addInput';
+    parent: InputPath;
+    /** Position among the container's inputs; appends when omitted. */
+    index?: number;
+    /** Generated when omitted. */
+    name?: string;
+    definition: Record<string, unknown>;
+} | {
+    type: 'deleteInput';
+    path: InputPath;
+}
+/** Inputs, kept in form order, moved together to one place. */
+ | {
+    type: 'moveInputs';
+    paths: InputPath[];
+    parent: InputPath;
+    index: number;
+} | {
+    type: 'duplicateInput';
+    path: InputPath;
+} | ({
+    type: 'updateInput';
+    path: InputPath;
+    name?: string;
+} & FieldPatch)
+/** Replaces an input's settings with YAML text, as its YAML editor writes them. */
+ | {
+    type: 'setInputYaml';
+    path: InputPath;
+    yaml: string;
+} | ({
+    type: 'updateWorkflow';
+    /** Changes to the input form's `$meta`, in the same undo step. */
+    inputsMeta?: FieldPatch;
+} & FieldPatch);
+export type GraphEdit = 
+/** `anchor` lands in `to`; the other jobs keep their offsets from it. */
+{
+    type: 'move';
+    jobs: string[];
+    to: GraphSlot;
+    layout: GraphLayout;
+    anchor?: string;
+} | {
+    type: 'addJob';
+    matrix?: boolean;
+    to?: GraphSlot;
+    layout?: GraphLayout;
+} | {
+    type: 'deleteJob';
+    jobs: string[];
+} | {
+    type: 'renameJob';
+    from: string;
+    to: string;
+} | {
+    type: 'duplicateJob';
+    job: string;
+    layout?: GraphLayout;
+} | {
+    type: 'connect';
+    from: string;
+    to: string;
+}
+/** `jobs` and what depends on them move right of their needs; `layout` is the grid as drawn. */
+ | {
+    type: 'placeAfterNeeds';
+    jobs: string[];
+    layout?: GraphLayout;
+}
+/** Moves `jobs` left of what needs them; `dependents` gained a need and may leave their node. */
+ | {
+    type: 'placeBeforeDependents';
+    jobs: string[];
+    dependents: string[];
+    layout?: GraphLayout;
+}
+/** Jobs join `into`'s node: they take its slot and a copy of its needs. */
+ | {
+    type: 'groupJobs';
+    jobs: string[];
+    into: string;
+    layout: GraphLayout;
+} | {
+    type: 'disconnect';
+    needs: NeedRef[];
+} | {
+    type: 'setNeedAny';
+    jobs: string[];
+    dep: string;
+    any: boolean;
+} | {
+    type: 'setMatrix';
+    job: string;
+    variables: MatrixVariable[] | null;
+} | {
+    type: 'addStep';
+    job: string;
+} | {
+    type: 'deleteStep';
+    job: string;
+    index: number;
+} | {
+    type: 'renameStep';
+    job: string;
+    index: number;
+    name: string;
+} | {
+    type: 'moveStep';
+    job: string;
+    from: number;
+    to: number;
+}
+/** Steps, in order, to insertion point `index` of `job` (an index into its steps before the move). */
+ | {
+    type: 'moveSteps';
+    steps: StepRef[];
+    job: string;
+    index: number;
+}
+/** The steps in `yaml`, a list as stepsYaml writes it, inserted at `index` of `job`. */
+ | {
+    type: 'pasteSteps';
+    yaml: string;
+    job: string;
+    index: number;
+}
+/** The jobs in `yaml`, as jobsYaml writes it, added as new jobs; each lands at `to` plus its offset. */
+ | {
+    type: 'pasteJobs';
+    yaml: string;
+    to?: GraphSlot;
+    offsets?: Record<string, GraphPosition>;
+    layout?: GraphLayout;
+}
+/** Jobs one slot over, as the arrow keys move them. */
+ | {
+    type: 'nudge';
+    jobs: string[];
+    direction: NudgeDirection;
+    layout: GraphLayout;
+} | ({
+    type: 'updateJob';
+    job: string;
+    name?: string;
+} & FieldPatch) | ({
+    type: 'updateStep';
+    job: string;
+    index: number;
+} & FieldPatch)
+/** Replaces a job's or step's settings with YAML text, as its YAML editor writes them. */
+ | {
+    type: 'setJobYaml';
+    job: string;
+    yaml: string;
+} | {
+    type: 'setStepYaml';
+    job: string;
+    index: number;
+    yaml: string;
+}
+/** Replaces the workflow's own settings, everything but its jobs and trigger, with YAML text. */
+ | {
+    type: 'setSettingsYaml';
+    yaml: string;
+} | {
+    type: 'resetLayout';
+} | InputEdit
+/** Several edits as one undo step, such as a new input and the field that reads it. */
+ | {
+    type: 'batch';
+    edits: GraphEdit[];
+};
+export interface GraphEditState {
+    yml: string;
+    layout: GraphLayout | undefined;
+}
+export interface GraphEditResult extends GraphEditState {
+    /** Name of the job or input the edit created, if any. */
+    created?: string;
+    /** The jobs a paste added, in order. */
+    createdJobs?: string[];
+    /** Where moved or pasted steps now sit. */
+    steps?: StepRef[];
+}
+/** A step as a refusal names it: by its name, or by where it sits when it has none. */
+export type RefusedStep = {
+    name: string;
+} | {
+    job: string;
+    index: number;
+};
+/** Why the workflow can't take an edit, by code, so the editor can say it in the reader's language. */
+export type EditRefusalReason = {
+    code: 'cycle';
+    job: string;
+    need: string;
+} | {
+    code: 'needRead';
+    job: string;
+    need: string;
+} | {
+    code: 'columnRead';
+    job: string;
+    need: string;
+} | {
+    code: 'stepReadsNeed';
+    step: RefusedStep;
+    need: string;
+    job: string;
+} | {
+    code: 'stepReadsStep';
+    step: RefusedStep;
+    id: string;
+    job: string;
+} | {
+    code: 'stepReadsMatrix';
+    step: RefusedStep;
+    variable: string;
+    job: string;
+} | {
+    code: 'stepLeftBehind';
+    job: string;
+    id: string;
+    target: string;
+} | {
+    code: 'jobNameInvalid';
+} | {
+    code: 'jobNameTaken';
+    name: string;
+} | {
+    code: 'inputNameInvalid';
+} | {
+    code: 'inputNameTaken';
+    name: string;
+} | {
+    code: 'inputIntoItself';
+} | {
+    code: 'needsExpression';
+} | {
+    code: 'matrixExpression';
+} | {
+    code: 'inputsExpression';
+    name: string;
+} | {
+    code: 'notAGroup';
+    name: string;
+} | {
+    code: 'noStepsToPaste';
+} | {
+    code: 'noJobsToPaste';
+} | {
+    code: 'notASetting';
+    key: string;
+};
+/** A "did you mean": `replace` for each reference to `find` in the value, or, with `key`, the key's new name. */
+export interface LintFix {
+    find: string;
+    replace: string;
+    key: boolean;
+}
+/** One problem a workflow's schema can't catch, such as a need read but never listed. */
+export interface WorkflowLintProblem {
+    path: string;
+    message: string;
+    line: number;
+    fix?: LintFix;
+}
+/** What the checks can't work out from the document: `uses` targets' inputs, and secret variable names. */
+export interface WorkflowLintContext {
+    usesInputs?: Record<string, unknown>;
+    secretVars?: string[];
+}
+export type SettingsYamlProblem = {
+    kind: 'syntax';
+    message: string;
+} | {
+    kind: 'notMap';
+};
+/** A key or list index on the way down to a YAML node. */
+export type YamlSegment = string | number;
+type UnknownRecord = Record<string, unknown>;
+/** One input a built-in action takes in its step's `with`, labelled in the reader's language. */
+export interface WorkflowActionInput {
+    key: string;
+    kind: 'text' | 'textarea' | 'number' | 'any' | 'list' | 'bool' | 'choice' | 'flags' | 'target';
+    label: string;
+    description: string;
+    required?: boolean | undefined;
+    choices?: string[] | undefined;
+    /** A `${{ }}` expression also stands in for a choice. */
+    expression?: boolean | undefined;
+    /** Inputs of these types, or their `suffix` property, can fill this one in. */
+    refTypes?: string[] | undefined;
+    suffix?: string | undefined;
+    /** What a `bool` left unset means. */
+    fallback?: boolean | undefined;
+    /** A `target` input's own keys. */
+    fields?: {
+        key: string;
+        label: string;
+        description: string;
+    }[] | undefined;
+}
+/** A built-in action a step can use, keyed by its `uses` value in `UIData['workflowActions']`. */
+export interface WorkflowAction {
+    /** What it does, shown beside it where it's picked. */
+    description: string;
+    inputs: WorkflowActionInput[];
+}
 /**
  * The workflow editing the visual editor defers to: reading and rewriting the workflow's YAML,
  * its graph layout and its checks. A host built on a workflow package can pass that package's
  * functions of the same names.
  */
 export interface WorkflowEditing {
+    loadYaml: (text: string) => unknown;
+    dumpYaml: (data: unknown) => string;
+    /** Applies one edit to the workflow's text and layout; throws `EditRefusal` when it can't. */
+    applyGraphEdit: (state: GraphEditState, edit: GraphEdit) => GraphEditResult;
+    /** `edits` as one undo step: the edit itself when there is one, nothing when there are none. */
+    batchOf: (edits: GraphEdit[]) => GraphEdit | null;
+    /** What an edit throws when the workflow can't take it, so the reason can be told. */
+    EditRefusal: abstract new (reason: EditRefusalReason) => Error & {
+        readonly reason: EditRefusalReason;
+    };
+    /** The English wording of a refusal. */
+    refusalMessage: (reason: EditRefusalReason) => string;
+    /** Each job's `needs` entries; expression-valued needs count as none. */
+    jobNeeds: (jobs: unknown) => Record<string, string[]>;
+    /** Whether `from` already depends on `to`, directly or through other jobs. */
+    dependsOn: (needs: Record<string, string[]>, from: string, to: string) => boolean;
+    /** The first of `refs` an expression in its job reads, so cutting it would break the read. */
+    needInUse: (jobs: Record<string, unknown>, refs: NeedRef[]) => NeedRef | undefined;
     /** The job a `needs` entry points at, without a matrix's wait-for-any suffix. */
     needTarget: (need: string) => string;
+    isValidJobName: (name: string) => boolean;
+    jobYaml: (text: string, job: string) => string;
+    jobsYaml: (text: string, jobs: string[]) => string;
+    stepYaml: (text: string, job: string, index: number) => string;
+    stepsYaml: (text: string, refs: StepRef[]) => string;
+    /** What a pasted snippet holds: jobs, steps, or neither. */
+    snippetKind: (snippet: string) => 'jobs' | 'steps' | undefined;
+    /** Why moving `refs` into `job` would leave an expression reading something that isn't there. */
+    stepMoveProblem: (text: string, refs: StepRef[], job: string) => EditRefusalReason | undefined;
+    /** A job's matrix variables; null when the matrix is an expression, which may hold any. */
+    matrixNames: (job: unknown) => Set<string> | null;
     /** Jobs whose matrix runs more than once as `<job>-<n>` members, the way a run lists them. */
     expandMatrixJobs: <T>(jobs: Record<string, T>) => Record<string, T>;
     hasLayout: (layout: GraphLayout | undefined) => boolean;
@@ -29,4 +395,42 @@ export interface WorkflowEditing {
         together: (a: string, b: string) => boolean;
         alone: (job: string) => boolean;
     }) => LaidOutColumn[];
+    /** The grid as drawn, as a layout to store. */
+    layoutFromCols: (dependencyCols: string[][][], previous?: GraphLayout, rows?: number[][], columns?: number[]) => GraphLayout;
+    /** Where moved jobs land, and the needs the move would cut. */
+    moveJobs: (layout: GraphLayout, needs: Record<string, string[]>, jobs: string[], slot: GraphSlot, anchor?: string | undefined) => {
+        layout: GraphLayout;
+        cuts: NeedRef[];
+    };
+    /** Where an input of this type keeps the inputs it holds, if it holds any. */
+    inputChildrenKey: (type: unknown) => string | undefined;
+    isValidInputName: (name: string) => boolean;
+    newInputName: (existing: Iterable<string>) => string;
+    /** `base`, or `base_2`, `base_3`… when it's taken. */
+    nextName: (taken: Iterable<string>, base: string) => string;
+    /** The first of `candidate(1)`, `candidate(2)`… that `taken` doesn't hold. */
+    freeName: (taken: Iterable<string>, candidate: (n: number) => string) => string;
+    inputYaml: (text: string, path: InputPath) => string;
+    /** Whether a wizard's steps put their fields at the top level of the inputs. */
+    wizardFlattens: (schema: UnknownRecord) => boolean;
+    /** The input definitions of a parsed workflow. */
+    workflowInputsSchema: (workflow: UnknownRecord | undefined | null) => UnknownRecord | undefined;
+    /** The workflow's own settings as YAML: everything but its jobs and trigger. */
+    settingsYaml: (text: string) => string;
+    /** What's wrong with YAML text written as a job's, step's or input's settings, if anything. */
+    settingsYamlProblem: (snippet: string) => SettingsYamlProblem | undefined;
+    /** The first and last 1-based line of the node at `path`, its key included. */
+    linesAt: (text: string, path: YamlSegment[]) => {
+        start: number;
+        end: number;
+    } | undefined;
+    /** `value` with each whole reference to `find` replaced by `replace`. */
+    replaceReference: (value: string, find: string, replace: string) => string;
+    /** The workflow's problems its schema can't catch; none until the checks have loaded. */
+    lintWorkflow: (yaml: string, context?: WorkflowLintContext) => WorkflowLintProblem[];
+    /** Form definitions for picking a workflow file from a repository. */
+    WORKFLOW_FORMS: {
+        github: UnknownRecord;
+    };
 }
+export {};

package/dist/editor/EditorField.js

@@ -1,5 +1,5 @@
-import Editor from "./Editor.js";
 import { FieldWrapper } from "../form/FieldWrapper.js";
+import Editor from "./Editor.js";
 import cx from "classnames";
 import { useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";

package/dist/editor/Monaco.d.ts

@@ -1,5 +1,11 @@
 import * as monaco from 'monaco-editor';
+import { type NestedWorkflowText } from './nestedText.js';
 export type ISchemaError = monaco.editor.IMarker;
+/** A problem to mark on one line of the editor. */
+export interface EditorMarker {
+    line: number;
+    message: string;
+}
 export interface IEditorProps extends monaco.editor.IStandaloneEditorConstructionOptions {
     className?: string;
     disabled?: boolean | undefined;
@@ -8,5 +14,13 @@ export interface IEditorProps extends monaco.editor.IStandaloneEditorConstructio
     width?: string | number;
     height?: string | number;
     path?: 'file:///workflow.yaml' | string;
+    /** Apply outside `value` changes as undoable edits instead of resetting the undo history. */
+    preserveUndo?: boolean;
+    /** Checks a whole workflow for what the schema can't, such as needs read but never listed. */
+    lint?: boolean;
+    /** Problems found elsewhere to mark in the text, such as a job's in the workflow around it. */
+    markers?: EditorMarker[];
+    /** Set when the text is one job or step, for completions that touch the rest of the workflow. */
+    nested?: NestedWorkflowText;
 }
-export default function MonacoEditor({ className, disabled, onChange, onValidate, width, height, path, ...options }: IEditorProps): import("react").JSX.Element;
+export default function MonacoEditor({ className, disabled, onChange, onValidate, width, height, path, preserveUndo, lint, markers, nested, ...options }: IEditorProps): import("react").JSX.Element;

package/dist/editor/Monaco.js

@@ -1,6 +1,11 @@
 import { useCssIsDark } from "../components/useCssIsDark.js";
+import { HOST_MARKER_OWNER, LINT_OWNER } from "./lintOwner.js";
+import { publishNestedText } from "./nestedText.js";
+import { registerRevealer } from "./reveal.js";
 import { defineEditorThemes, getThemeName } from "./themes.js";
 import { setupMonacoWorkers } from "./workers.js";
+import { holdListeners, modelFor } from "./editorModel.js";
+import { lintContext, useLintEditing, useLintSources } from "./lintContext.js";
 import { ensureYamlLanguage } from "./yamlLanguage.js";
 import cx from "classnames";
 import { useEffect, useLayoutEffect, useRef } from "react";
@@ -8,20 +13,68 @@ import { jsx } from "react/jsx-runtime";
 import * as monaco from "monaco-editor";
 //#region src/editor/Monaco.tsx
 setupMonacoWorkers();
+var SCHEMA_UNREADABLE = "768";
+function lintMarker(model, { line, message }) {
+	const at = Math.min(Math.max(line || 1, 1), model.getLineCount());
+	return {
+		severity: monaco.MarkerSeverity.Error,
+		message,
+		startLineNumber: at,
+		startColumn: model.getLineFirstNonWhitespaceColumn(at) || 1,
+		endLineNumber: at,
+		endColumn: model.getLineMaxColumn(at)
+	};
+}
+function sameMarkers(a, b) {
+	return a.length === b.length && a.every((marker, i) => marker.message === b[i]?.message && marker.startLineNumber === b[i]?.startLineNumber);
+}
+function setMarkers(model, owner, wanted) {
+	if (!sameMarkers(monaco.editor.getModelMarkers({
+		resource: model.uri,
+		owner
+	}), wanted)) monaco.editor.setModelMarkers(model, owner, wanted);
+}
 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", ...options }) {
+function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop, width = "100%", height = "100%", path = "file:///default", preserveUndo = false, lint = false, markers, nested, ...options }) {
 	const isDark = useCssIsDark();
-	const readOnly = disabled || options.readOnly;
+	const readOnly = Boolean(disabled || options.readOnly);
 	const monacoRef = useRef(null);
 	const isSyncingValueRef = useRef(false);
+	const lintSources = useLintSources();
+	const lintSourcesRef = useRef(lintSources);
+	lintSourcesRef.current = lintSources;
+	const runLintRef = useRef(null);
+	const unregisterRevealRef = useRef(null);
+	const listenersRef = useRef([]);
+	const nestedRef = useRef(nested);
+	nestedRef.current = nested;
+	const isNested = nested !== void 0;
+	const lintEditing = useLintEditing(lint);
+	const lintEditingRef = useRef(lintEditing);
+	lintEditingRef.current = lintEditing;
+	const lintRef = useRef(lint);
+	lintRef.current = lint;
+	useEffect(() => {
+		const model = monacoRef.current?.getModel();
+		if (!lint && model) setMarkers(model, LINT_OWNER, []);
+		else if (lint && lintEditing) runLintRef.current?.();
+	}, [lint, lintEditing]);
+	useEffect(() => {
+		const model = monacoRef.current?.getModel();
+		if (model) setMarkers(model, HOST_MARKER_OWNER, (markers ?? []).map((marker) => lintMarker(model, marker)));
+	}, [markers]);
+	useEffect(() => {
+		if (!isNested) return;
+		return publishNestedText(monaco.Uri.parse(path).toString(), nestedRef);
+	}, [path, isNested]);
 	useEffect(() => {
 		if (!monacoRef.current) return;
 		defineEditorThemes(monaco.editor);
 		monaco.editor.setTheme(getThemeName(isDark, disabled));
-		monacoRef.current.updateOptions(readOnly === void 0 ? {} : { readOnly });
+		monacoRef.current.updateOptions({ readOnly });
 	}, [
 		disabled,
 		isDark,
@@ -32,13 +85,23 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 		if (!model || options.value === void 0 || editorText(model.getValue()) === editorText(options.value)) return;
 		isSyncingValueRef.current = true;
 		try {
-			model.setValue(options.value);
+			if (preserveUndo) {
+				const editor = monacoRef.current;
+				editor?.pushUndoStop();
+				model.pushEditOperations([], [{
+					range: model.getFullModelRange(),
+					text: options.value
+				}], () => null);
+				editor?.pushUndoStop();
+			} else model.setValue(options.value);
 		} finally {
 			isSyncingValueRef.current = false;
 		}
-	}, [options.value]);
+	}, [options.value, preserveUndo]);
 	useEffect(() => {
 		return () => {
+			unregisterRevealRef.current?.();
+			for (const listener of listenersRef.current) listener.dispose();
 			monacoRef.current?.dispose();
 			monacoRef.current = null;
 		};
@@ -56,15 +119,14 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 		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 model = modelFor(monaco.Uri.parse(path), options.value ?? "", options.language);
 				const editor = monaco.editor.create(ref, {
 					automaticLayout: true,
 					model,
 					...options,
-					...readOnly === void 0 ? {} : { readOnly },
+					readOnly,
 					fixedOverflowWidgets: true,
 					suggest: {
 						preview: true,
@@ -72,12 +134,54 @@ function MonacoEditor({ className, disabled, onChange = noop, onValidate = noop,
 						showInlineDetails: true
 					}
 				});
-				model.onDidChangeContent(() => {
-					if (isSyncingValueRef.current) return;
-					onChangeWrapper(editor.getValue());
-				});
-				model.onDidChangeDecorations(() => {
+				setMarkers(model, HOST_MARKER_OWNER, (markers ?? []).map((marker) => lintMarker(model, marker)));
+				setMarkers(model, LINT_OWNER, []);
+				const runLint = () => {
+					const editing = lintEditingRef.current;
+					if (!lintRef.current || !editing || model.isDisposed()) return;
+					const schema = monaco.editor.getModelMarkers({ resource: model.uri }).filter((marker) => marker.owner !== "workflowlint" && marker.owner !== "workflowmarkers" && String(marker.code ?? "") !== SCHEMA_UNREADABLE);
+					const source = model.getValue();
+					setMarkers(model, LINT_OWNER, schema.length > 0 ? [] : editing.lintWorkflow(source, lintContext(editing, source, lintSourcesRef.current, runLint)).map((problem) => lintMarker(model, problem)));
+				};
+				runLintRef.current = runLint;
+				let lintTimer;
+				const validate = () => {
+					runLint();
 					onValidate(monaco.editor.getModelMarkers({ resource: model.uri }));
+				};
+				const modelListeners = [
+					model.onDidChangeContent(() => {
+						if (lintRef.current) {
+							window.clearTimeout(lintTimer);
+							lintTimer = window.setTimeout(runLint, 300);
+						}
+						if (isSyncingValueRef.current) return;
+						onChangeWrapper(editor.getValue());
+					}),
+					monaco.editor.onDidChangeMarkers((resources) => {
+						const uri = model.uri.toString();
+						if (resources.some((resource) => resource.toString() === uri)) validate();
+					}),
+					{ dispose: () => window.clearTimeout(lintTimer) }
+				];
+				holdListeners(model, modelListeners);
+				listenersRef.current = modelListeners;
+				validate();
+				unregisterRevealRef.current = registerRevealer(path, (start, end) => {
+					const last = Math.min(Math.max(start, end), model.getLineCount());
+					editor.revealLinesInCenterIfOutsideViewport(start, last);
+					editor.setPosition({
+						lineNumber: start,
+						column: model.getLineFirstNonWhitespaceColumn(start) || 1
+					});
+					const flash = editor.createDecorationsCollection([{
+						range: new monaco.Range(start, 1, last, 1),
+						options: {
+							isWholeLine: true,
+							className: "bg-(--theme-element)/20"
+						}
+					}]);
+					window.setTimeout(() => flash.clear(), 1500);
 				});
 				ensureYamlLanguage();
 				monacoRef.current = editor;

package/dist/editor/editorModel.d.ts

@@ -0,0 +1,5 @@
+import * as monaco from 'monaco-editor';
+/** The model a new editor on `uri` edits, holding `value`. */
+export declare function modelFor(uri: monaco.Uri, value: string, language: string | undefined): monaco.editor.ITextModel;
+/** An editor's listeners on its model, dropped when the next editor takes the model over. */
+export declare function holdListeners(model: monaco.editor.ITextModel, disposables: monaco.IDisposable[]): void;

package/dist/editor/editorModel.js

@@ -0,0 +1,23 @@
+import * as monaco from "monaco-editor";
+//#region src/editor/editorModel.ts
+var listeners = /* @__PURE__ */ new WeakMap();
+/** The model a new editor on `uri` edits, holding `value`. */
+function modelFor(uri, value, language) {
+	const existing = monaco.editor.getModel(uri);
+	if (existing && language === "yaml" && existing.getLanguageId() === "yaml") {
+		for (const listener of listeners.get(existing) ?? []) listener.dispose();
+		const owners = new Set(monaco.editor.getModelMarkers({ resource: uri }).map((marker) => marker.owner));
+		for (const owner of owners) monaco.editor.setModelMarkers(existing, owner, []);
+		existing.setValue(value);
+		existing.detectIndentation(true, 4);
+		return existing;
+	}
+	existing?.dispose();
+	return monaco.editor.createModel(value, language, uri);
+}
+/** An editor's listeners on its model, dropped when the next editor takes the model over. */
+function holdListeners(model, disposables) {
+	listeners.set(model, disposables);
+}
+//#endregion
+export { holdListeners, modelFor };

package/dist/editor/index.d.ts

@@ -1,7 +1,11 @@
 export { default as Editor } from './Editor.js';
 export { default as EditorField, type IEditorField } from './EditorField.js';
 export { default as FormCodePanel } from './FormCodePanel.js';
+export { HOST_MARKER_OWNER, LINT_OWNER } from './lintOwner.js';
 export type { IEditorProps, ISchemaError } from './Monaco.js';
+export { type NestedWorkflowText, nestedWorkflowText } from './nestedText.js';
+export { revealLines } from './reveal.js';
+export { INPUT_YAML_PATH, JOB_YAML_PATH, type JsonSchema, SETTINGS_YAML_PATH, STEP_YAML_PATH, settingsSchemas, } from './settingsYaml.js';
 export { defineEditorThemes, getThemeName } from './themes.js';
 export { setupMonacoWorkers } from './workers.js';
 export { configureEditorYaml } from './yaml.js';