Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio: JSON and Markdown validator blocks (#10710)

Sourav Rajvi9834db033140
diff --git a/studio/backend/core/data_recipe/service.py b/studio/backend/core/data_recipe/service.py
index afd9c0a80b0..5b08e3c778b 100644
--- a/studio/backend/core/data_recipe/service.py
+++ b/studio/backend/core/data_recipe/service.py
@@ -19,6 +19,10 @@ from .local_callable_validators import (
register_oxc_local_callable_validators,
split_oxc_local_callable_validators,
)
+from .text_format_validators import (
+ register_text_format_local_callable_validators,
+ split_text_format_local_callable_validators,
+)
_IMAGE_CONTEXT_PATCHED = False
@@ -379,11 +383,16 @@ def build_config_builder(recipe: dict[str, Any]):
}
recipe_core = _strip_frontend_model_config_metadata(recipe_core)
recipe_core, oxc_local_callable_specs = split_oxc_local_callable_validators(recipe_core)
+ recipe_core, text_format_specs = split_text_format_local_callable_validators(recipe_core)
builder = DataDesignerConfigBuilder.from_config({"data_designer": recipe_core})
register_oxc_local_callable_validators(
builder = builder,
specs = oxc_local_callable_specs,
)
+ register_text_format_local_callable_validators(
+ builder = builder,
+ specs = text_format_specs,
+ )
# DataDesignerConfigBuilder.from_config skips processors; re-attach so drop_columns/schema_transform
# survive the API payload.
diff --git a/studio/backend/core/data_recipe/text_format_validators.py b/studio/backend/core/data_recipe/text_format_validators.py
new file mode 100644
index 00000000000..098d12ccfa6
--- /dev/null
+++ b/studio/backend/core/data_recipe/text_format_validators.py
@@ -0,0 +1,255 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from __future__ import annotations
+
+import json
+import re
+from copy import deepcopy
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Any
+
+JSON_VALIDATION_FN_MARKER = "unsloth_json_validator"
+MARKDOWN_VALIDATION_FN_MARKER = "unsloth_markdown_validator"
+
+# CommonMark fenced code blocks: https://spec.commonmark.org/0.31.2/#fenced-code-blocks
+_MARKDOWN_FENCE_OPEN_RE = re.compile(r"^ {0,3}(`{3,}(?=[^`]*$)|~{3,})")
+_MARKDOWN_FENCE_CLOSE_RE = re.compile(r"^ {0,3}(`{3,}|~{3,})[ \t]*$")
+
+
+@dataclass(frozen = True)
+class TextFormatLocalCallableValidatorSpec:
+ name: str
+ drop: bool
+ target_columns: list[str]
+ batch_size: int
+ format_kind: str
+
+
+def split_text_format_local_callable_validators(
+ recipe_core: dict[str, Any],
+) -> tuple[dict[str, Any], list[TextFormatLocalCallableValidatorSpec]]:
+ columns = recipe_core.get("columns")
+ if not isinstance(columns, list):
+ return recipe_core, []
+
+ sanitized = deepcopy(recipe_core)
+ sanitized_columns = sanitized.get("columns")
+ if not isinstance(sanitized_columns, list):
+ return sanitized, []
+
+ kept_columns: list[Any] = []
+ specs: list[TextFormatLocalCallableValidatorSpec] = []
+
+ for column in sanitized_columns:
+ if not isinstance(column, dict):
+ kept_columns.append(column)
+ continue
+
+ maybe_spec = _parse_text_format_spec(column = column)
+ if maybe_spec is None:
+ kept_columns.append(column)
+ continue
+ specs.append(maybe_spec)
+
+ sanitized["columns"] = kept_columns
+ return sanitized, specs
+
+
+def register_text_format_local_callable_validators(
+ *, builder, specs: list[TextFormatLocalCallableValidatorSpec]
+) -> None:
+ if not specs:
+ return
+
+ from data_designer.config.column_configs import ValidationColumnConfig
+ from data_designer.config.validator_params import (
+ LocalCallableValidatorParams,
+ ValidatorType,
+ )
+
+ for spec in specs:
+ validation_function = _build_text_format_validation_function(spec.format_kind)
+ builder.add_column(
+ ValidationColumnConfig(
+ name = spec.name,
+ drop = spec.drop,
+ target_columns = spec.target_columns,
+ validator_type = ValidatorType.LOCAL_CALLABLE,
+ validator_params = LocalCallableValidatorParams(
+ validation_function = validation_function,
+ ),
+ batch_size = spec.batch_size,
+ )
+ )
+
+
+def _parse_text_format_spec(
+ *, column: dict[str, Any]
+) -> TextFormatLocalCallableValidatorSpec | None:
+ if str(column.get("column_type") or "").strip() != "validation":
+ return None
+ if str(column.get("validator_type") or "").strip() != "local_callable":
+ return None
+
+ params = column.get("validator_params")
+ if not isinstance(params, dict):
+ return None
+
+ fn_raw = params.get("validation_function")
+ fn_name = fn_raw.strip() if isinstance(fn_raw, str) else ""
+ format_kind = _text_format_kind_from_marker(fn_name)
+ if format_kind is None:
+ return None
+
+ name = str(column.get("name") or "").strip()
+ if not name:
+ return None
+
+ target_columns_raw = column.get("target_columns")
+ target_columns = (
+ [value.strip() for value in target_columns_raw if isinstance(value, str) and value.strip()]
+ if isinstance(target_columns_raw, list)
+ else []
+ )
+ if not target_columns:
+ return None
+
+ return TextFormatLocalCallableValidatorSpec(
+ name = name,
+ drop = bool(column.get("drop") is True),
+ target_columns = target_columns,
+ batch_size = _parse_batch_size(column.get("batch_size")),
+ format_kind = format_kind,
+ )
+
+
+def _text_format_kind_from_marker(fn_name: str) -> str | None:
+ if fn_name == JSON_VALIDATION_FN_MARKER:
+ return "json"
+ if fn_name == MARKDOWN_VALIDATION_FN_MARKER:
+ return "markdown"
+ return None
+
+
+def _parse_batch_size(value: Any) -> int:
+ try:
+ parsed = int(value)
+ except (TypeError, ValueError):
+ return 10
+ return parsed if parsed >= 1 else 10
+
+
+@lru_cache(maxsize = 4)
+def _build_text_format_validation_function(format_kind: str):
+ def _validator(df):
+ import pandas as pd
+
+ row_count = int(len(df.index))
+ if row_count == 0:
+ return pd.DataFrame({"is_valid": []})
+
+ value_column = str(df.columns[0]) if len(df.columns) > 0 else ""
+ values = (
+ ["" for _ in range(row_count)]
+ if not value_column
+ else [_coerce_validation_value(value) for value in df[value_column].tolist()]
+ )
+
+ results = [_validate_text_format(value = value, format_kind = format_kind) for value in values]
+ return pd.DataFrame(results)
+
+ _validator.__name__ = f"{format_kind}_format_validator"
+ return _validator
+
+
+def _coerce_validation_value(value: Any) -> Any:
+ import pandas as pd
+
+ if isinstance(value, (dict, list)):
+ return value
+ if value is None or pd.isna(value):
+ return ""
+ if isinstance(value, (bool, int, float)):
+ return value
+ return str(value)
+
+
+def _reject_json_constant(constant: str) -> float:
+ raise ValueError(f"Invalid JSON constant: {constant}")
+
+
+def _validate_text_format(*, value: Any, format_kind: str) -> dict[str, Any]:
+ if format_kind == "json":
+ return _validate_json_text(value)
+ return _validate_markdown_text(value)
+
+
+def _validate_json_text(value: Any) -> dict[str, Any]:
+ if isinstance(value, (dict, list, bool, int, float)):
+ payload = value
+ else:
+ stripped = str(value).strip()
+ if not stripped:
+ return _invalid_result("JSON value is empty.")
+ try:
+ payload = json.loads(stripped, parse_constant = _reject_json_constant)
+ except (json.JSONDecodeError, ValueError, RecursionError) as exc:
+ return _invalid_result(str(exc))
+ try:
+ json.dumps(payload, allow_nan = False)
+ except (TypeError, ValueError) as exc:
+ return _invalid_result(str(exc))
+ return _valid_result()
+
+
+# Markdown accepts unmatched brackets and parentheses as text ("1) item", "Status (draft"),
+# so an unclosed code fence is the only structural break worth rejecting.
+def _has_unclosed_markdown_fence(text: str) -> bool:
+ fence = ""
+ for line in text.splitlines():
+ if not fence:
+ match = _MARKDOWN_FENCE_OPEN_RE.match(line)
+ if match:
+ fence = match.group(1)
+ continue
+ match = _MARKDOWN_FENCE_CLOSE_RE.match(line)
+ if match and match.group(1)[0] == fence[0] and len(match.group(1)) >= len(fence):
+ fence = ""
+ return bool(fence)
+
+
+def _validate_markdown_text(value: Any) -> dict[str, Any]:
+ text = str(value)
+ if not text.strip():
+ return _invalid_result("Markdown value is empty.")
+ if _has_unclosed_markdown_fence(text):
+ return _invalid_result("Markdown has an unclosed code fence.")
+ return _valid_result()
+
+
+def _valid_result() -> dict[str, Any]:
+ return {
+ "is_valid": True,
+ "error_count": 0,
+ "error_message": "",
+ "severity": None,
+ "code": None,
+ "labels": [],
+ "codeframe": None,
+ "warning_count": 0,
+ }
+
+
+def _invalid_result(message: str) -> dict[str, Any]:
+ return {
+ "is_valid": False,
+ "error_count": 1,
+ "error_message": message,
+ "severity": None,
+ "code": None,
+ "labels": [],
+ "codeframe": None,
+ "warning_count": 0,
+ }
diff --git a/studio/backend/tests/test_text_format_validators.py b/studio/backend/tests/test_text_format_validators.py
new file mode 100644
index 00000000000..5f26cf3994b
--- /dev/null
+++ b/studio/backend/tests/test_text_format_validators.py
@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+from core.data_recipe.text_format_validators import (
+ JSON_VALIDATION_FN_MARKER,
+ MARKDOWN_VALIDATION_FN_MARKER,
+ _validate_json_text,
+ _validate_markdown_text,
+ split_text_format_local_callable_validators,
+)
+
+
+def test_validate_json_text_accepts_object_payload():
+ result = _validate_json_text('{"answer": "ok"}')
+ assert result["is_valid"] is True
+
+
+def test_validate_json_text_rejects_invalid_payload():
+ result = _validate_json_text("{not json")
+ assert result["is_valid"] is False
+ assert result["error_message"]
+
+
+def test_validate_markdown_text_rejects_unclosed_fence():
+ result = _validate_markdown_text("```python\nprint('hi')")
+ assert result["is_valid"] is False
+ assert "fence" in result["error_message"].lower()
+
+
+def test_validate_markdown_text_accepts_simple_markdown():
+ result = _validate_markdown_text("# Title\n\nSome **bold** text.")
+ assert result["is_valid"] is True
+
+
+def test_split_text_format_local_callable_validators_extracts_json_and_markdown_specs():
+ recipe = {
+ "columns": [
+ {
+ "column_type": "validation",
+ "name": "json_check",
+ "target_columns": ["payload"],
+ "validator_type": "local_callable",
+ "validator_params": {
+ "validation_function": JSON_VALIDATION_FN_MARKER,
+ },
+ },
+ {
+ "column_type": "validation",
+ "name": "md_check",
+ "target_columns": ["body"],
+ "validator_type": "local_callable",
+ "validator_params": {
+ "validation_function": MARKDOWN_VALIDATION_FN_MARKER,
+ },
+ },
+ {"column_type": "llm-text", "name": "payload"},
+ ],
+ }
+
+ sanitized, specs = split_text_format_local_callable_validators(recipe)
+
+ assert len(sanitized["columns"]) == 1
+ assert [spec.format_kind for spec in specs] == ["json", "markdown"]
+
+
+def test_validate_markdown_text_accepts_unmatched_brackets_and_parens():
+ for text in ("1) first\n2) second", "Status (draft", "Smile :)", "see arr[0 here"):
+ assert _validate_markdown_text(text)["is_valid"] is True, text
+
+
+def test_validate_json_text_rejects_nan_and_accepts_native_values():
+ assert _validate_json_text("NaN")["is_valid"] is False
+ assert _validate_json_text({"a": True})["is_valid"] is True
+
+
+def test_validate_markdown_text_follows_commonmark_fences():
+ for text in (
+ "````md\nuse ```python\n````",
+ "Wrap code in ``` fences.",
+ "```markdown\n# T\n```python\nx = 1\n```",
+ ):
+ assert _validate_markdown_text(text)["is_valid"] is True, text
+ for text in ("```python\nprint(1)", "~~~\nx", "````\nx\n```"):
+ assert _validate_markdown_text(text)["is_valid"] is False, text
+
+
+def test_validate_json_text_accepts_native_scalars():
+ for value in (True, False, 0, 2.5):
+ assert _validate_json_text(value)["is_valid"] is True, value
+ assert _validate_json_text(float("nan"))["is_valid"] is False
+
+
+def test_validate_markdown_text_keeps_leading_indented_code_block():
+ assert _validate_markdown_text(" ```\n literal backticks")["is_valid"] is True
+
+
+def test_missing_values_fail_both_checks():
+ import math
+
+ import pandas as pd
+
+ from core.data_recipe.text_format_validators import _build_text_format_validation_function
+
+ df = pd.DataFrame({"x": [math.nan, pd.NA, None, "# ok"]}, dtype = object)
+ for kind, expected in (("markdown", [False, False, False, True]), ("json", [False] * 4)):
+ result = _build_text_format_validation_function(kind)(df)
+ assert result["is_valid"].tolist() == expected, kind
diff --git a/studio/frontend/src/features/recipe-studio/blocks/definitions.ts b/studio/frontend/src/features/recipe-studio/blocks/definitions.ts
index ed58d1418d2..73959c827af 100644
--- a/studio/frontend/src/features/recipe-studio/blocks/definitions.ts
+++ b/studio/frontend/src/features/recipe-studio/blocks/definitions.ts
@@ -47,12 +47,17 @@ export type BlockKind =
| "expression"
| "seed"
| "note";
-export type BlockType =
- | SamplerType
- | LlmType
+export type ValidatorBlockType =
| "validator_python"
| "validator_sql"
| "validator_oxc"
+ | "validator_json"
+ | "validator_markdown";
+
+export type BlockType =
+ | SamplerType
+ | LlmType
+ | ValidatorBlockType
| "expression"
| "markdown_note"
| "seed"
@@ -358,6 +363,26 @@ const BLOCK_DEFINITIONS: BlockDefinition[] = [
createConfig: (id, existing) =>
makeValidatorConfig(id, "oxc", "javascript", existing),
},
+ {
+ kind: "validator",
+ type: "validator_json",
+ title: "JSON check",
+ description: "Verify a field contains valid JSON and filter out rows that fail.",
+ icon: Shield02Icon,
+ dialogKey: "validator",
+ createConfig: (id, existing) =>
+ makeValidatorConfig(id, "json", "json", existing),
+ },
+ {
+ kind: "validator",
+ type: "validator_markdown",
+ title: "Markdown check",
+ description: "Verify a field contains well-formed markdown and filter out rows that fail.",
+ icon: Shield02Icon,
+ dialogKey: "validator",
+ createConfig: (id, existing) =>
+ makeValidatorConfig(id, "markdown", "markdown", existing),
+ },
{
kind: "expression",
type: "expression",
@@ -416,6 +441,12 @@ export function getBlockDefinitionForConfig(
return getBlockDefinition("llm", config.llm_type);
}
if (config.kind === "validator") {
+ if (config.validator_type === "json") {
+ return getBlockDefinition("validator", "validator_json");
+ }
+ if (config.validator_type === "markdown") {
+ return getBlockDefinition("validator", "validator_markdown");
+ }
if (config.validator_type === "oxc") {
return getBlockDefinition("validator", "validator_oxc");
}
diff --git a/studio/frontend/src/features/recipe-studio/blocks/registry.ts b/studio/frontend/src/features/recipe-studio/blocks/registry.ts
index 29d6f7151ca..97eb978428c 100644
--- a/studio/frontend/src/features/recipe-studio/blocks/registry.ts
+++ b/studio/frontend/src/features/recipe-studio/blocks/registry.ts
@@ -8,6 +8,7 @@ export type {
BlockKind,
BlockType,
SeedBlockType,
+ ValidatorBlockType,
} from "./definitions";
export {
BLOCK_GROUPS,
diff --git a/studio/frontend/src/features/recipe-studio/components/block-sheet.tsx b/studio/frontend/src/features/recipe-studio/components/block-sheet.tsx
index d1c78487b26..3cde1b34290 100644
--- a/studio/frontend/src/features/recipe-studio/components/block-sheet.tsx
+++ b/studio/frontend/src/features/recipe-studio/components/block-sheet.tsx
@@ -42,6 +42,7 @@ import {
getBlocksForKind,
type BlockType,
type SeedBlockType,
+ type ValidatorBlockType,
} from "../blocks/registry";
import {
RECIPE_STUDIO_ONBOARDING_ICON_TONE,
@@ -87,7 +88,7 @@ type BlockSheetProps = {
onAddToolProfile: () => void;
onAddExpression: () => void;
onAddValidator: (
- type: "validator_python" | "validator_sql" | "validator_oxc",
+ type: ValidatorBlockType,
) => void;
onAddMarkdownNote: () => void;
onOpenProcessors: () => void;
@@ -401,7 +402,7 @@ export function BlockSheet({
}
if (kind === "validator") {
onAddValidator(
- type as "validator_python" | "validator_sql" | "validator_oxc",
+ type as ValidatorBlockType,
);
return;
}
diff --git a/studio/frontend/src/features/recipe-studio/dialogs/validators/validator-dialog.tsx b/studio/frontend/src/features/recipe-studio/dialogs/validators/validator-dialog.tsx
index f1d50510c35..3cbdff02a13 100644
--- a/studio/frontend/src/features/recipe-studio/dialogs/validators/validator-dialog.tsx
+++ b/studio/frontend/src/features/recipe-studio/dialogs/validators/validator-dialog.tsx
@@ -63,10 +63,20 @@ export function ValidatorDialog({
const advancedOpen = config.advancedOpen === true;
const selectedOxcMode = normalizeOxcValidationMode(config.oxc_validation_mode);
const selectedOxcCodeShape = normalizeOxcCodeShape(config.oxc_code_shape);
- const codeOptions = useMemo(
+ const targetOptions = useMemo(
() =>
Object.values(configs)
.flatMap((item) => {
+ if (config.validator_type === "json" || config.validator_type === "markdown") {
+ if (
+ item.kind === "llm" ||
+ item.kind === "expression" ||
+ item.kind === "sampler"
+ ) {
+ return [{ name: item.name, codeLang: config.code_lang }];
+ }
+ return [];
+ }
if (!(item.kind === "llm" && item.llm_type === "code")) {
return [];
}
@@ -95,7 +105,7 @@ export function ValidatorDialog({
})
.filter((item) => item.name.trim())
.sort((a, b) => a.name.localeCompare(b.name)),
- [configs],
+ [config.code_lang, config.validator_type, configs],
);
const currentTarget = config.target_columns[0] ?? "";
@@ -109,9 +119,17 @@ export function ValidatorDialog({
/>
<div className="grid gap-1.5">
<FieldLabel
- label="Code to check"
+ label={config.validator_type === "json" || config.validator_type === "markdown"
+ ? "Field to check"
+ : "Code to check"}
htmlFor={targetColumnId}
- hint="Choose the AI code step this check should review."
+ hint={
+ config.validator_type === "json"
+ ? "Choose the column that should contain valid JSON."
+ : config.validator_type === "markdown"
+ ? "Choose the column that should contain valid markdown."
+ : "Choose the AI code step this check should review."
+ }
/>
<Select
value={currentTarget || NONE_VALUE}
@@ -123,7 +141,7 @@ export function ValidatorDialog({
});
return;
}
- const targetConfig = codeOptions.find((item) => item.name === value);
+ const targetConfig = targetOptions.find((item) => item.name === value);
const nextCodeLang = targetConfig?.codeLang?.trim();
onUpdate({
// biome-ignore lint/style/useNamingConvention: api schema
@@ -141,16 +159,20 @@ export function ValidatorDialog({
</SelectTrigger>
<SelectContent>
<SelectItem value={NONE_VALUE}>None</SelectItem>
- {codeOptions.map((item) => (
+ {targetOptions.map((item) => (
<SelectItem key={item.name} value={item.name}>
{item.name}
</SelectItem>
))}
</SelectContent>
</Select>
- {codeOptions.length === 0 && (
+ {targetOptions.length === 0 && (
<p className="text-xs text-muted-foreground">
- {config.validator_type === "oxc"
+ {config.validator_type === "json"
+ ? "Add a generation step that outputs JSON first."
+ : config.validator_type === "markdown"
+ ? "Add a generation step that outputs markdown first."
+ : config.validator_type === "oxc"
? "Add an AI code step that generates JavaScript or TypeScript first."
: "Add an AI code step first."}
</p>
diff --git a/studio/frontend/src/features/recipe-studio/hooks/use-recipe-editor-graph.ts b/studio/frontend/src/features/recipe-studio/hooks/use-recipe-editor-graph.ts
index d59d3cad050..7479a8c1184 100644
--- a/studio/frontend/src/features/recipe-studio/hooks/use-recipe-editor-graph.ts
+++ b/studio/frontend/src/features/recipe-studio/hooks/use-recipe-editor-graph.ts
@@ -16,7 +16,7 @@ import {
useMemo,
} from "react";
import { RECIPE_BLOCK_DND_MIME, type RecipeBlockDragPayload } from "../components/block-sheet";
-import type { SeedBlockType } from "../blocks/registry";
+import type { SeedBlockType, ValidatorBlockType } from "../blocks/registry";
import type {
LlmType,
NodeConfig,
@@ -73,7 +73,7 @@ type UseRecipeEditorGraphArgs = {
addToolProfileNode: (position?: XYPosition, openDialog?: boolean) => void;
addExpressionNode: (position?: XYPosition, openDialog?: boolean) => void;
addValidatorNode: (
- type: "validator_python" | "validator_sql" | "validator_oxc",
+ type: ValidatorBlockType,
position?: XYPosition,
openDialog?: boolean,
) => void;
@@ -97,7 +97,7 @@ type UseRecipeEditorGraphResult = {
handleAddToolProfileFromSheet: () => void;
handleAddExpressionFromSheet: () => void;
handleAddValidatorFromSheet: (
- type: "validator_python" | "validator_sql" | "validator_oxc",
+ type: ValidatorBlockType,
) => void;
handleAddMarkdownNoteFromSheet: () => void;
};
@@ -219,7 +219,7 @@ export function useRecipeEditorGraph({
}
if (payload.kind === "validator") {
addValidatorNode(
- payload.type as "validator_python" | "validator_sql" | "validator_oxc",
+ payload.type as ValidatorBlockType,
position,
false,
);
@@ -306,7 +306,7 @@ export function useRecipeEditorGraph({
}, [addToolProfileNode, getViewportCenterPosition]);
const handleAddValidatorFromSheet = useCallback(
- (type: "validator_python" | "validator_sql" | "validator_oxc") => {
+ (type: ValidatorBlockType) => {
addValidatorNode(type, getViewportCenterPosition());
},
[addValidatorNode, getViewportCenterPosition],
diff --git a/studio/frontend/src/features/recipe-studio/stores/helpers/edge-sync.ts b/studio/frontend/src/features/recipe-studio/stores/helpers/edge-sync.ts
index 43a2edf727b..9768378e0c4 100644
--- a/studio/frontend/src/features/recipe-studio/stores/helpers/edge-sync.ts
+++ b/studio/frontend/src/features/recipe-studio/stores/helpers/edge-sync.ts
@@ -11,6 +11,7 @@ import type {
} from "../../types";
import { applyRecipeConnection } from "../../utils/graph";
import { isCategoryConfig, isSubcategoryConfig } from "../../utils";
+import { isTextFormatValidatorTarget, isTextFormatValidator } from "../../utils/graph/relations";
import { HANDLE_IDS } from "../../utils/handles";
function findNodeIdByName(
@@ -238,6 +239,8 @@ export function syncEdgesForConfigPatch(
"target_columns",
);
if (current.kind === "validator" && hasValidatorTargetsPatch) {
+ const validator = current;
+ const isTextFormat = isTextFormatValidator(validator);
const nextTargets =
((patch as Partial<ValidatorConfig>).target_columns ?? [])
.map((value) => value.trim())
@@ -248,23 +251,28 @@ export function syncEdgesForConfigPatch(
}
const otherId = edge.source === current.id ? edge.target : edge.source;
const other = configs[otherId];
- return !(
- other &&
- other.kind === "llm" &&
- other.llm_type === "code"
- );
+ if (!other) {
+ return true;
+ }
+ if (isTextFormat) {
+ return edge.source === current.id || !isTextFormatValidatorTarget(other);
+ }
+ return !(other.kind === "llm" && other.llm_type === "code");
});
const nextTargetName = nextTargets[0];
if (nextTargetName) {
const targetId = findNodeIdByName(configs, nextTargetName);
const target = targetId ? configs[targetId] : null;
- if (
- targetId &&
- target &&
- target.kind === "llm" &&
- target.llm_type === "code"
- ) {
- nextEdges = addValidatorSemanticEdge(nextEdges, targetId, current.id);
+ if (targetId && target) {
+ if (isTextFormat && isTextFormatValidatorTarget(target)) {
+ nextEdges = addValidatorSemanticEdge(nextEdges, targetId, current.id);
+ } else if (
+ !isTextFormat &&
+ target.kind === "llm" &&
+ target.llm_type === "code"
+ ) {
+ nextEdges = addValidatorSemanticEdge(nextEdges, targetId, current.id);
+ }
}
}
}
diff --git a/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts b/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts
index cb3d55c53dd..2a70e94b77f 100644
--- a/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts
+++ b/studio/frontend/src/features/recipe-studio/stores/recipe-studio.ts
@@ -16,6 +16,7 @@ import {
type BlockKind,
type BlockType,
type SeedBlockType,
+ type ValidatorBlockType,
getBlockDefinition,
} from "../blocks/registry";
import type {
@@ -114,7 +115,7 @@ type RecipeStudioState = {
addToolProfileNode: (position?: XYPosition, openDialog?: boolean) => void;
addExpressionNode: (position?: XYPosition, openDialog?: boolean) => void;
addValidatorNode: (
- type: "validator_python" | "validator_sql" | "validator_oxc",
+ type: ValidatorBlockType,
position?: XYPosition,
openDialog?: boolean,
) => void;
diff --git a/studio/frontend/src/features/recipe-studio/types/index.ts b/studio/frontend/src/features/recipe-studio/types/index.ts
index 9231c5f7a37..4035dcff02b 100644
--- a/studio/frontend/src/features/recipe-studio/types/index.ts
+++ b/studio/frontend/src/features/recipe-studio/types/index.ts
@@ -22,13 +22,15 @@ export type ValidatorCodeLang =
| "jsx"
| "tsx"
| "python"
+ | "json"
+ | "markdown"
| "sql:sqlite"
| "sql:postgres"
| "sql:mysql"
| "sql:tsql"
| "sql:bigquery"
| "sql:ansi";
-export type ValidatorType = "code" | "oxc";
+export type ValidatorType = "code" | "oxc" | "json" | "markdown";
export type OxcValidationMode = "syntax" | "lint" | "syntax+lint";
export type OxcCodeShape = "auto" | "module" | "snippet";
@@ -68,6 +70,8 @@ export type RecipeNodeData = {
| "validator_python"
| "validator_sql"
| "validator_oxc"
+ | "validator_json"
+ | "validator_markdown"
| "expression"
| "seed"
| "markdown_note"
diff --git a/studio/frontend/src/features/recipe-studio/utils/config-factories.ts b/studio/frontend/src/features/recipe-studio/utils/config-factories.ts
index 74e95643e7f..9035db11665 100644
--- a/studio/frontend/src/features/recipe-studio/utils/config-factories.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/config-factories.ts
@@ -353,11 +353,17 @@ export function makeValidatorConfig(
): ValidatorConfig {
const isSql = validatorType === "code" && codeLang.startsWith("sql:");
const isOxc = validatorType === "oxc";
+ const isJson = validatorType === "json";
+ const isMarkdown = validatorType === "markdown";
let namePrefix = "validator_python";
if (isSql) {
namePrefix = "validator_sql";
} else if (isOxc) {
namePrefix = "validator_oxc";
+ } else if (isJson) {
+ namePrefix = "validator_json";
+ } else if (isMarkdown) {
+ namePrefix = "validator_markdown";
}
return {
id,
diff --git a/studio/frontend/src/features/recipe-studio/utils/graph/recipe-graph-connection.ts b/studio/frontend/src/features/recipe-studio/utils/graph/recipe-graph-connection.ts
index db4d2379ef0..aa2c84c67a8 100644
--- a/studio/frontend/src/features/recipe-studio/utils/graph/recipe-graph-connection.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/graph/recipe-graph-connection.ts
@@ -20,7 +20,11 @@ import {
VALIDATOR_OXC_CODE_LANGS,
VALIDATOR_SQL_CODE_LANGS,
} from "../validators/code-lang";
-import { isSemanticRelation } from "./relations";
+import {
+ isSemanticRelation,
+ isTextFormatValidator,
+ isTextFormatValidatorTarget,
+} from "./relations";
function buildTemplateWithRef(template: string, ref: string): string {
if (template.includes(ref)) {
@@ -92,6 +96,10 @@ type SingleRefRelation =
| "subcategory_parent"
| "validator_target_columns";
+function isCodeValidatorSource(source: NodeConfig): boolean {
+ return source.kind === "llm" && source.llm_type === "code";
+}
+
function getSingleRefRelation(
source: NodeConfig,
target: NodeConfig,
@@ -116,12 +124,13 @@ function getSingleRefRelation(
if (isCategoryConfig(source) && isSubcategoryConfig(target)) {
return "subcategory_parent";
}
- if (
- source.kind === "llm" &&
- source.llm_type === "code" &&
- target.kind === "validator"
- ) {
- return "validator_target_columns";
+ if (target.kind === "validator") {
+ if (isTextFormatValidator(target) && isTextFormatValidatorTarget(source)) {
+ return "validator_target_columns";
+ }
+ if (isCodeValidatorSource(source)) {
+ return "validator_target_columns";
+ }
}
return null;
}
@@ -152,7 +161,11 @@ function isCompetingIncomingEdge(
return isCategoryConfig(source);
}
if (relation === "validator_target_columns") {
- return source.kind === "llm" && source.llm_type === "code";
+ const target = configs[targetId];
+ if (target && isTextFormatValidator(target)) {
+ return isTextFormatValidatorTarget(source);
+ }
+ return isCodeValidatorSource(source);
}
return source.kind === "sampler" && source.sampler_type === "datetime";
}
@@ -290,6 +303,7 @@ function normalizeValidatorSemanticConnection(
): Connection {
if (
source.kind === "validator" &&
+ !isTextFormatValidator(source) &&
target.kind === "llm" &&
target.llm_type === "code"
) {
@@ -439,6 +453,17 @@ export function applyRecipeConnection(
};
return { edges: nextEdges, configs: { ...configs, [target.id]: next } };
}
+ if (target.kind === "validator" && isTextFormatValidator(target)) {
+ if (!isTextFormatValidatorTarget(source)) {
+ return { edges: nextEdges };
+ }
+ const next = {
+ ...target,
+ // biome-ignore lint/style/useNamingConvention: api schema
+ target_columns: [source.name],
+ };
+ return { edges: nextEdges, configs: { ...configs, [target.id]: next } };
+ }
if (
source.kind === "llm" &&
source.llm_type === "code" &&
diff --git a/studio/frontend/src/features/recipe-studio/utils/graph/relations.ts b/studio/frontend/src/features/recipe-studio/utils/graph/relations.ts
index 7744c478d20..89b39de0d31 100644
--- a/studio/frontend/src/features/recipe-studio/utils/graph/relations.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/graph/relations.ts
@@ -3,6 +3,21 @@
import type { NodeConfig } from "../../types";
+export function isTextFormatValidator(config: NodeConfig): boolean {
+ return (
+ config.kind === "validator" &&
+ (config.validator_type === "json" || config.validator_type === "markdown")
+ );
+}
+
+export function isTextFormatValidatorTarget(config: NodeConfig): boolean {
+ return (
+ config.kind === "llm" ||
+ config.kind === "expression" ||
+ config.kind === "sampler"
+ );
+}
+
export function isSemanticRelation(
source: NodeConfig,
target: NodeConfig,
@@ -23,8 +38,12 @@ export function isSemanticRelation(
) {
return true;
}
+ if (isTextFormatValidator(target) && isTextFormatValidatorTarget(source)) {
+ return true;
+ }
return (
source.kind === "validator" &&
+ !isTextFormatValidator(source) &&
target.kind === "llm" &&
target.llm_type === "code"
);
diff --git a/studio/frontend/src/features/recipe-studio/utils/import/edges.ts b/studio/frontend/src/features/recipe-studio/utils/import/edges.ts
index d00f78d70ac..24f8d59424a 100644
--- a/studio/frontend/src/features/recipe-studio/utils/import/edges.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/import/edges.ts
@@ -14,30 +14,11 @@ import {
isSemanticTargetHandle,
normalizeRecipeHandleId,
} from "../handles";
+import { isSemanticRelation } from "../graph/relations";
import { extractRefs } from "./helpers";
function isSemanticConnection(source: NodeConfig, target: NodeConfig): boolean {
- if (source.kind === "model_provider" && target.kind === "model_config") {
- return true;
- }
- if (source.kind === "model_config" && target.kind === "llm") {
- return true;
- }
- if (source.kind === "tool_config" && target.kind === "llm") {
- return true;
- }
- if (
- source.kind === "llm" &&
- source.llm_type === "code" &&
- target.kind === "validator"
- ) {
- return true;
- }
- return (
- source.kind === "validator" &&
- target.kind === "llm" &&
- target.llm_type === "code"
- );
+ return isSemanticRelation(source, target);
}
export function buildEdges(
diff --git a/studio/frontend/src/features/recipe-studio/utils/import/parsers/validator-parser.ts b/studio/frontend/src/features/recipe-studio/utils/import/parsers/validator-parser.ts
index 2c7484ffc5e..908fba6525d 100644
--- a/studio/frontend/src/features/recipe-studio/utils/import/parsers/validator-parser.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/import/parsers/validator-parser.ts
@@ -8,6 +8,8 @@ import { normalizeOxcCodeShape } from "../../validators/oxc-code-shape";
import { normalizeOxcValidationMode } from "../../validators/oxc-mode";
const OXC_VALIDATION_FN_MARKER = "unsloth_oxc_validator";
+const JSON_VALIDATION_FN_MARKER = "unsloth_json_validator";
+const MARKDOWN_VALIDATION_FN_MARKER = "unsloth_markdown_validator";
function parseOxcValidationMarker(
validationFunctionRaw: string,
@@ -50,12 +52,24 @@ export function parseValidator(
typeof params.validation_function === "string"
? params.validation_function.trim()
: "";
+ const isLocalCallable =
+ String(column.validator_type ?? "").trim() === "local_callable";
const isOxc =
- String(column.validator_type ?? "").trim() === "local_callable" &&
- validationFunctionRaw.startsWith(OXC_VALIDATION_FN_MARKER);
+ isLocalCallable && validationFunctionRaw.startsWith(OXC_VALIDATION_FN_MARKER);
+ const isJson =
+ isLocalCallable && validationFunctionRaw === JSON_VALIDATION_FN_MARKER;
+ const isMarkdown =
+ isLocalCallable && validationFunctionRaw === MARKDOWN_VALIDATION_FN_MARKER;
const marker = isOxc
? parseOxcValidationMarker(validationFunctionRaw)
: { codeLang: "", mode: "syntax", codeShape: "auto" };
+ const validatorType = isJson
+ ? "json"
+ : isMarkdown
+ ? "markdown"
+ : isOxc
+ ? "oxc"
+ : "code";
return {
id,
kind: "validator",
@@ -63,10 +77,16 @@ export function parseValidator(
drop: column.drop === true,
// biome-ignore lint/style/useNamingConvention: api schema
target_columns: targetColumns,
- validator_type: isOxc ? "oxc" : "code",
+ validator_type: validatorType,
// biome-ignore lint/style/useNamingConvention: api schema
code_lang: normalizeValidatorCodeLang(
- isOxc ? marker.codeLang || "javascript" : params.code_lang,
+ isJson
+ ? "json"
+ : isMarkdown
+ ? "markdown"
+ : isOxc
+ ? marker.codeLang || "javascript"
+ : params.code_lang,
),
oxc_validation_mode: isOxc
? normalizeOxcValidationMode(marker.mode)
diff --git a/studio/frontend/src/features/recipe-studio/utils/node-data.ts b/studio/frontend/src/features/recipe-studio/utils/node-data.ts
index 96042b5919f..1fd626eaa06 100644
--- a/studio/frontend/src/features/recipe-studio/utils/node-data.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/node-data.ts
@@ -34,10 +34,18 @@ export function nodeDataFromConfig(
}
if (config.kind === "validator") {
const isOxc = config.validator_type === "oxc";
+ const isJson = config.validator_type === "json";
+ const isMarkdown = config.validator_type === "markdown";
const isSql = config.code_lang.startsWith("sql:");
let subtype = "Python";
let blockType: RecipeNodeData["blockType"] = "validator_python";
- if (isOxc) {
+ if (isJson) {
+ subtype = "JSON";
+ blockType = "validator_json";
+ } else if (isMarkdown) {
+ subtype = "Markdown";
+ blockType = "validator_markdown";
+ } else if (isOxc) {
subtype = "OXC";
blockType = "validator_oxc";
} else if (isSql) {
diff --git a/studio/frontend/src/features/recipe-studio/utils/payload/builders-validator.ts b/studio/frontend/src/features/recipe-studio/utils/payload/builders-validator.ts
index 3e4ca573a9d..e28979c2dc6 100644
--- a/studio/frontend/src/features/recipe-studio/utils/payload/builders-validator.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/payload/builders-validator.ts
@@ -5,6 +5,8 @@ import type { NodeConfig, ValidatorConfig } from "../../types";
import { isValidatorCodeLang } from "../validators/code-lang";
const OXC_VALIDATION_FN_MARKER = "unsloth_oxc_validator";
+const JSON_VALIDATION_FN_MARKER = "unsloth_json_validator";
+const MARKDOWN_VALIDATION_FN_MARKER = "unsloth_markdown_validator";
function parseBatchSize(value: string): number {
const parsed = Number.parseInt(value, 10);
@@ -23,7 +25,32 @@ export function buildValidatorColumn(
.map((value) => value.trim())
.filter(Boolean);
if (targetColumns.length === 0) {
- errors.push(`Validator ${config.name}: target code column required.`);
+ errors.push(`Validator ${config.name}: target column required.`);
+ }
+ if (
+ config.validator_type === "json" ||
+ config.validator_type === "markdown"
+ ) {
+ return {
+ // biome-ignore lint/style/useNamingConvention: api schema
+ column_type: "validation",
+ name: config.name,
+ drop: config.drop ?? false,
+ // biome-ignore lint/style/useNamingConvention: api schema
+ target_columns: targetColumns,
+ // biome-ignore lint/style/useNamingConvention: api schema
+ validator_type: "local_callable",
+ // biome-ignore lint/style/useNamingConvention: api schema
+ validator_params: {
+ // biome-ignore lint/style/useNamingConvention: api schema
+ validation_function:
+ config.validator_type === "json"
+ ? JSON_VALIDATION_FN_MARKER
+ : MARKDOWN_VALIDATION_FN_MARKER,
+ },
+ // biome-ignore lint/style/useNamingConvention: api schema
+ batch_size: parseBatchSize(config.batch_size),
+ };
}
if (config.validator_type === "oxc") {
const targetName = targetColumns[0] ?? "";
diff --git a/studio/frontend/src/features/recipe-studio/utils/payload/validate.ts b/studio/frontend/src/features/recipe-studio/utils/payload/validate.ts
index 2e3c13d4b23..d35a61180ef 100644
--- a/studio/frontend/src/features/recipe-studio/utils/payload/validate.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/payload/validate.ts
@@ -165,6 +165,21 @@ export function validateValidatorConfigs(
errors.push(`Validator ${config.name}: target '${target}' not found.`);
continue;
}
+ if (
+ config.validator_type === "json" ||
+ config.validator_type === "markdown"
+ ) {
+ if (
+ targetConfig.kind !== "llm" &&
+ targetConfig.kind !== "expression" &&
+ targetConfig.kind !== "sampler"
+ ) {
+ errors.push(
+ `Validator ${config.name}: target '${target}' must be a generated field.`,
+ );
+ }
+ continue;
+ }
if (targetConfig.kind !== "llm" || targetConfig.llm_type !== "code") {
errors.push(
`Validator ${config.name}: target '${target}' must be LLM Code.`,
diff --git a/studio/frontend/src/features/recipe-studio/utils/validation.ts b/studio/frontend/src/features/recipe-studio/utils/validation.ts
index d5200eeed0b..52e23eac285 100644
--- a/studio/frontend/src/features/recipe-studio/utils/validation.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/validation.ts
@@ -242,12 +242,15 @@ export function getConfigErrors(config: NodeConfig | null): string[] {
.map((value) => value.trim())
.filter(Boolean);
if (targets.length === 0) {
- errors.push("Choose the code step to check.");
+ errors.push("Choose the field to check.");
}
const batch = parseIntNumber(config.batch_size);
if (batch === null || batch < 1) {
errors.push("Batch size must be an integer >= 1.");
}
+ if (config.validator_type === "json" || config.validator_type === "markdown") {
+ return errors;
+ }
if (!config.code_lang.trim()) {
errors.push("Choose a code language for this check.");
} else if (config.validator_type === "oxc") {
diff --git a/studio/frontend/src/features/recipe-studio/utils/validators/code-lang.ts b/studio/frontend/src/features/recipe-studio/utils/validators/code-lang.ts
index 7f47278cc40..e46d78e05d6 100644
--- a/studio/frontend/src/features/recipe-studio/utils/validators/code-lang.ts
+++ b/studio/frontend/src/features/recipe-studio/utils/validators/code-lang.ts
@@ -22,6 +22,8 @@ export const VALIDATOR_SQL_CODE_LANGS: ValidatorCodeLang[] = [
const VALIDATOR_CODE_LANG_SET = new Set<ValidatorCodeLang>([
...VALIDATOR_OXC_CODE_LANGS,
"python",
+ "json",
+ "markdown",
...VALIDATOR_SQL_CODE_LANGS,
]);
@@ -42,6 +44,12 @@ export function normalizeValidatorCodeLang(
if (raw === "python") {
return "python";
}
+ if (raw === "json") {
+ return "json";
+ }
+ if (raw === "markdown") {
+ return "markdown";
+ }
if (raw.startsWith("sql:")) {
if (VALIDATOR_SQL_CODE_LANGS.includes(raw as ValidatorCodeLang)) {
return raw as ValidatorCodeLang;
diff --git a/studio/frontend/tests/recipe-studio-text-format-validators.test.ts b/studio/frontend/tests/recipe-studio-text-format-validators.test.ts
new file mode 100644
index 00000000000..c3305a5cf8b
--- /dev/null
+++ b/studio/frontend/tests/recipe-studio-text-format-validators.test.ts
@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { registerBundlerResolver } from "./helpers/kit.ts";
+
+registerBundlerResolver();
+
+const { makeValidatorConfig } = await import(
+ "../src/features/recipe-studio/utils/config-factories.ts"
+);
+const { buildValidatorColumn } = await import(
+ "../src/features/recipe-studio/utils/payload/builders-validator.ts"
+);
+const { parseValidator } = await import(
+ "../src/features/recipe-studio/utils/import/parsers/validator-parser.ts"
+);
+
+for (const [kind, marker] of [
+ ["json", "unsloth_json_validator"],
+ ["markdown", "unsloth_markdown_validator"],
+] as const) {
+ test(`a ${kind} check survives a save and reopen`, () => {
+ const config = {
+ ...makeValidatorConfig("v1", kind, kind, []),
+ // biome-ignore lint/style/useNamingConvention: api schema
+ target_columns: ["answer"],
+ };
+ const errors: string[] = [];
+ const column = buildValidatorColumn(config, errors);
+ assert.deepEqual(errors, []);
+ assert.equal(column.validator_type, "local_callable");
+ assert.deepEqual(column.validator_params, {
+ // biome-ignore lint/style/useNamingConvention: api schema
+ validation_function: marker,
+ });
+
+ const parsed = parseValidator(column, config.name, config.id);
+ assert.equal(parsed.validator_type, kind);
+ assert.equal(parsed.code_lang, kind);
+ assert.deepEqual(parsed.target_columns, ["answer"]);
+ });
+}
+
+const { makeLlmConfig, makeSamplerConfig } = await import(
+ "../src/features/recipe-studio/utils/config-factories.ts"
+);
+const { applyRecipeConnection } = await import(
+ "../src/features/recipe-studio/utils/graph/recipe-graph-connection.ts"
+);
+const { HANDLE_IDS } = await import(
+ "../src/features/recipe-studio/utils/handles.ts"
+);
+
+for (const [label, source] of [
+ ["an AI text", makeLlmConfig("src", "text", [])],
+ ["a sampler", makeSamplerConfig("src", "category", [])],
+] as const) {
+ test(`dragging ${label} output onto a JSON check's semantic input sets its target`, () => {
+ const validator = makeValidatorConfig("v1", "json", "json", []);
+ const configs = { [source.id]: source, [validator.id]: validator };
+ const result = applyRecipeConnection(
+ {
+ source: source.id,
+ target: validator.id,
+ sourceHandle: HANDLE_IDS.dataOut,
+ targetHandle: HANDLE_IDS.semanticIn,
+ },
+ configs,
+ [],
+ );
+ assert.equal(result.edges.length, 1);
+ assert.equal(result.edges[0].type, "semantic");
+ const next = result.configs?.[validator.id];
+ assert.ok(next && next.kind === "validator");
+ assert.deepEqual(next.target_columns, [source.name]);
+ });
+}
+
+for (const downstreamType of ["text", "code"] as const) {
+ test(`a JSON check's result can feed a later AI ${downstreamType} step without retargeting the check`, () => {
+ const source = makeLlmConfig("src", "text", []);
+ const validator = {
+ ...makeValidatorConfig("v1", "json", "json", []),
+ // biome-ignore lint/style/useNamingConvention: api schema
+ target_columns: [source.name],
+ };
+ const downstream = makeLlmConfig("down", downstreamType, [source]);
+ const configs = {
+ [source.id]: source,
+ [validator.id]: validator,
+ [downstream.id]: downstream,
+ };
+ const result = applyRecipeConnection(
+ {
+ source: validator.id,
+ target: downstream.id,
+ sourceHandle: HANDLE_IDS.dataOut,
+ targetHandle: HANDLE_IDS.dataIn,
+ },
+ configs,
+ [],
+ );
+ assert.equal(result.edges.length, 1);
+ assert.equal(result.edges[0].source, validator.id);
+ assert.notEqual(result.edges[0].type, "semantic");
+ const next = result.configs?.[validator.id] ?? validator;
+ assert.ok(next.kind === "validator");
+ assert.deepEqual(next.target_columns, [source.name]);
+ });
+}
+
+const { syncEdgesForConfigPatch } = await import(
+ "../src/features/recipe-studio/stores/helpers/edge-sync.ts"
+);
+
+test("changing a JSON check's field keeps the edge to a step reading its result", () => {
+ const first = makeLlmConfig("a", "text", []);
+ const second = makeLlmConfig("b", "text", [first]);
+ const downstream = makeLlmConfig("c", "text", [first, second]);
+ const validator = {
+ ...makeValidatorConfig("v1", "json", "json", []),
+ // biome-ignore lint/style/useNamingConvention: api schema
+ target_columns: [first.name],
+ };
+ const configs = {
+ [first.id]: first,
+ [second.id]: second,
+ [downstream.id]: downstream,
+ [validator.id]: validator,
+ };
+ const edges = [
+ { id: "in", source: first.id, target: validator.id, type: "semantic" },
+ { id: "out", source: validator.id, target: downstream.id, type: "canvas" },
+ ];
+ const next = syncEdgesForConfigPatch(
+ validator,
+ // biome-ignore lint/style/useNamingConvention: api schema
+ { target_columns: [second.name] },
+ configs,
+ edges,
+ "LR",
+ );
+ const pairs = next.map((edge) => `${edge.source}->${edge.target}`).sort();
+ assert.deepEqual(pairs, [
+ `${second.id}->${validator.id}`,
+ `${validator.id}->${downstream.id}`,
+ ]);
+});