@samva/markup 0.1.2 → 0.3.0

package/dist/tsx-tracer.js

@@ -0,0 +1,985 @@
+import { buildLineMap } from "./diagnostics.js";
+import { SML_TAGS, componentNameForSmlTag, smlTagForComponentName } from "./ast.js";
+import { decodeEntities } from "./lexer.js";
+import { parseSml } from "./parser.js";
+import { applyOps } from "./ops.js";
+import { Data, Predicate, Result } from "effect";
+import { parse } from "@babel/parser";
+//#region src/tsx-tracer.ts
+var TsxHeadingTraceError = class extends Data.TaggedError("TsxHeadingTraceError") {};
+const ZERO_SPAN = {
+	start: 0,
+	end: 0
+};
+const diagnostic = (code, message, span = ZERO_SPAN) => ({
+	code,
+	message,
+	span
+});
+const failure = (...diagnostics) => Result.fail(new TsxHeadingTraceError({ diagnostics }));
+const isRecord = (value) => Predicate.isObject(value) && !Array.isArray(value);
+const isAstNode = (value) => isRecord(value) && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+const childNode = (node, key) => {
+	const value = node[key];
+	return isAstNode(value) ? value : null;
+};
+const stringProperty = (node, key) => {
+	const value = node[key];
+	return typeof value === "string" ? value : null;
+};
+const astNodeSpan = (node) => ({
+	start: node.start,
+	end: node.end
+});
+const walkAst = (value, visit) => {
+	if (Array.isArray(value)) {
+		for (const item of value) walkAst(item, visit);
+		return;
+	}
+	if (!isRecord(value)) return;
+	if (isAstNode(value)) visit(value);
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "loc" || key === "extra" || key === "comments" || key === "tokens") continue;
+		walkAst(child, visit);
+	}
+};
+const jsxName = (node) => {
+	if (node.type === "JSXIdentifier") {
+		const name = stringProperty(node, "name");
+		return name === null ? { kind: "dynamic" } : {
+			kind: "literal",
+			name
+		};
+	}
+	return { kind: "dynamic" };
+};
+const jsxOpeningName = (node) => {
+	const opening = childNode(node, "openingElement");
+	const name = opening === null ? null : childNode(opening, "name");
+	return name === null ? { kind: "dynamic" } : jsxName(name);
+};
+/**
+* The text of a `{"…"}` child, or `null` when the container holds anything
+* else. A template literal qualifies only with no substitutions, so an
+* interpolation like `{v.tagline}` or `` {`${a}b`} `` stays opaque.
+*/
+const staticStringLiteralText = (node) => {
+	if (node.type !== "JSXExpressionContainer") return null;
+	const expression = node.expression;
+	if (!isAstNode(expression)) return null;
+	if (expression.type === "StringLiteral") return typeof expression.value === "string" ? expression.value : null;
+	if (expression.type !== "TemplateLiteral") return null;
+	const expressions = expression.expressions;
+	if (Array.isArray(expressions) && expressions.length > 0) return null;
+	const quasis = Array.isArray(expression.quasis) ? expression.quasis.filter(isAstNode) : [];
+	if (quasis.length !== 1) return null;
+	const cooked = isRecord(quasis[0].value) ? quasis[0].value.cooked : void 0;
+	return typeof cooked === "string" ? cooked : null;
+};
+/** True for bare JSX text that carries no visible characters. */
+const isBlankJsxText = (node, source) => node.type === "JSXText" && source.slice(node.start, node.end).trim().length === 0;
+const escapeJsxText = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("{", "&#123;");
+/**
+* Write static text back in the form the author used. A string literal is
+* serialized with `JSON.stringify`, so braces, angle brackets, and quotes
+* round-trip without JSX-text escaping.
+*/
+const serializeStaticTextChild = (form, text) => form === "string-literal" ? `{${JSON.stringify(text)}}` : escapeJsxText(text);
+const directLiteral = (node, source) => {
+	const children = node.children;
+	if (!Array.isArray(children)) return null;
+	const significant = children.filter((child) => isAstNode(child) && !isBlankJsxText(child, source));
+	if (significant.length !== 1) return null;
+	const child = significant[0];
+	const literal = staticStringLiteralText(child);
+	if (literal !== null) {
+		if (literal.trim().length === 0) return null;
+		return {
+			nodeSpan: astNodeSpan(node),
+			text: literal,
+			span: {
+				start: child.start,
+				end: child.end
+			},
+			form: "string-literal"
+		};
+	}
+	if (child.type !== "JSXText") return null;
+	const raw = source.slice(child.start, child.end);
+	const leading = raw.search(/\S/u);
+	if (leading < 0) return null;
+	let trailing = raw.length;
+	while (trailing > leading && /\s/u.test(raw[trailing - 1])) trailing -= 1;
+	const text = decodeEntities(raw.slice(leading, trailing));
+	if (text.trim().length === 0) return null;
+	return {
+		nodeSpan: astNodeSpan(node),
+		text,
+		span: {
+			start: child.start + leading,
+			end: child.start + trailing
+		},
+		form: "jsx-text"
+	};
+};
+const normalizeText = (text) => text.replace(/\s+/gu, " ").trim();
+const elementById = (node, id) => {
+	if (node.kind !== "element") return null;
+	if (node.id === id) return node;
+	for (const child of node.children) {
+		const found = elementById(child, id);
+		if (found !== null) return found;
+	}
+	return null;
+};
+const headingText = (node) => {
+	if (node.children.length !== 1 || node.children[0]?.kind !== "text") return null;
+	return node.children[0].value;
+};
+const parseAuthored = (source) => {
+	try {
+		const parsed = parse(source, {
+			plugins: ["typescript", "jsx"],
+			sourceType: "module"
+		});
+		return Result.succeed(parsed.program);
+	} catch (error) {
+		return Result.fail(diagnostic("tsx-invalid-authored-source", error instanceof Error ? error.message : "The authored TSX could not be parsed."));
+	}
+};
+const isSpanLocator = (locator) => "span" in locator;
+const locatorOffset = (source, locator) => {
+	if (isSpanLocator(locator)) return null;
+	if (!Number.isInteger(locator.lineNumber) || !Number.isInteger(locator.columnNumber) || locator.lineNumber < 1 || locator.columnNumber < 1) return null;
+	const lineMap = buildLineMap(source);
+	if (locator.lineNumber > lineMap.length) return null;
+	const lineStart = lineMap[locator.lineNumber - 1];
+	const lineEnd = lineMap[locator.lineNumber] ?? source.length;
+	const offset = lineStart + locator.columnNumber - 1;
+	return offset < lineStart || offset >= lineEnd ? null : offset;
+};
+const locatorMatches = (source, authoredFile, locator, nodeSpan) => {
+	if (locator.fileName !== authoredFile) return false;
+	if (isSpanLocator(locator)) return Number.isInteger(locator.span.start) && Number.isInteger(locator.span.end) && locator.span.start === nodeSpan.start && locator.span.end === nodeSpan.end;
+	return locatorOffset(source, locator) === nodeSpan.start;
+};
+const locatorSpan = (locator) => locator !== void 0 && isSpanLocator(locator) ? locator.span : ZERO_SPAN;
+/** Resolve one rendered Heading to one direct-literal JSX text range. */
+const traceTsxHeadingTarget = (input) => {
+	const parsed = parseSml(input.emittedSource);
+	if (Result.isFailure(parsed)) return failure(...parsed.failure.diagnostics.map(({ message, span }) => diagnostic("tsx-invalid-emitted-source", message, span)));
+	const target = elementById(parsed.success.root, input.nodeId);
+	if (target === null) return failure(diagnostic("tsx-target-not-found", `rendered node "${input.nodeId}" was not found in the emitted SML source`));
+	if (target.tag !== "Heading") return failure(diagnostic("tsx-unsupported-target", `rendered node "${input.nodeId}" is <${target.tag}>; only a Heading can be edited`, target.span));
+	const renderedText = headingText(target);
+	if (renderedText === null) return failure(diagnostic("tsx-dynamic-target", "the rendered Heading contains dynamic or structured children and has no safe literal text range", target.span));
+	const locator = input.sourceLocator;
+	if (locator === void 0) return failure(diagnostic("tsx-unsupported-target", "the selected Heading has no exact authored TSX source locator; refusing to guess a range", target.span));
+	if (locator.fileName !== input.authoredFile) return failure(diagnostic("tsx-unsupported-target", `the source locator points to "${locator.fileName}", not the authored file "${input.authoredFile}"`, locatorSpan(locator)));
+	if (isSpanLocator(locator)) {
+		if (!Number.isInteger(locator.span.start) || !Number.isInteger(locator.span.end) || locator.span.start < 0 || locator.span.end <= locator.span.start || locator.span.end > input.authoredSource.length) return failure(diagnostic("tsx-unsupported-target", "the source locator span is outside the authored TSX source", locator.span));
+	} else if (locatorOffset(input.authoredSource, locator) === null) return failure(diagnostic("tsx-unsupported-target", "the source locator does not identify a position in the authored TSX source"));
+	const authored = parseAuthored(input.authoredSource);
+	if (Result.isFailure(authored)) return failure(authored.failure);
+	const candidates = [];
+	const dynamicSpans = [];
+	const unsupportedSpans = [];
+	walkAst(authored.success, (node) => {
+		if (node.type !== "JSXElement") return;
+		const name = jsxOpeningName(node);
+		if (name.kind === "dynamic") {
+			unsupportedSpans.push(astNodeSpan(node));
+			return;
+		}
+		if (name.name !== "Heading") {
+			unsupportedSpans.push(astNodeSpan(node));
+			return;
+		}
+		const literal = directLiteral(node, input.authoredSource);
+		if (literal === null) dynamicSpans.push(astNodeSpan(node));
+		else candidates.push(literal);
+	});
+	const mappedCandidates = candidates.filter((candidate) => locatorMatches(input.authoredSource, input.authoredFile, locator, candidate.nodeSpan));
+	const mappedDynamicSpans = dynamicSpans.filter((span) => locatorMatches(input.authoredSource, input.authoredFile, locator, span));
+	const mappedUnsupportedSpans = unsupportedSpans.filter((span) => locatorMatches(input.authoredSource, input.authoredFile, locator, span));
+	if (mappedDynamicSpans.length > 0) return failure(diagnostic("tsx-dynamic-target", "the source locator identifies a Heading with dynamic or structured children; refusing to edit it", mappedDynamicSpans[0]));
+	if (mappedUnsupportedSpans.length > 0) return failure(diagnostic("tsx-unsupported-target", "the source locator identifies a JSX component that is not the editable Heading primitive", mappedUnsupportedSpans[0]));
+	if (mappedCandidates.length === 0) return failure(diagnostic("tsx-target-not-found", "the source locator does not identify a Heading element in the authored TSX source", locatorSpan(locator)));
+	if (mappedCandidates.length !== 1) return failure(diagnostic("tsx-ambiguous-target", `the source locator identifies ${mappedCandidates.length} authored Heading elements; refusing to guess a source range`, mappedCandidates[0].nodeSpan));
+	const candidate = mappedCandidates[0];
+	if (normalizeText(renderedText) !== normalizeText(candidate.text)) return failure(diagnostic("tsx-ambiguous-target", "the selected emitted Heading does not match the located authored literal; refusing to edit stale source", candidate.nodeSpan));
+	return Result.succeed({
+		nodeId: input.nodeId,
+		text: candidate.text,
+		span: candidate.span,
+		form: candidate.form
+	});
+};
+/** Replace only the mapped literal bytes; all other authored TSX stays untouched. */
+const replaceTsxHeadingText = (input) => {
+	const traced = traceTsxHeadingTarget(input);
+	if (Result.isFailure(traced)) return Result.fail(traced.failure);
+	const { start, end } = traced.success.span;
+	const replacement = serializeStaticTextChild(traced.success.form, input.text);
+	return Result.succeed(`${input.authoredSource.slice(0, start)}${replacement}${input.authoredSource.slice(end)}`);
+};
+var TsxSmlOpsError = class extends Data.TaggedError("TsxSmlOpsError") {};
+const sourceDiagnostic = (code, message, span = ZERO_SPAN) => ({
+	code,
+	message,
+	span
+});
+const sourceFailure = (...diagnostics) => Result.fail(new TsxSmlOpsError({ diagnostics }));
+const astNodes = (value) => {
+	if (!Array.isArray(value)) return [];
+	return value.filter(isAstNode);
+};
+const astNumber = (node, key) => {
+	const value = node[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+};
+const astValue = (node, key) => node[key];
+/** The authored JSX component name, or `null` when the name is computed. */
+const sourceComponentName = (node) => {
+	const name = jsxOpeningName(node);
+	return name.kind === "literal" ? name.name : null;
+};
+/**
+* The SML tag an authored JSX element emits. `<Strong>` emits `strong`, so the
+* authored name is resolved through the component registry before it is
+* compared with an emitted node. A name outside the registry is kept as-is, so
+* an imported custom component still fails `isSmlTag` exactly as before.
+*/
+const sourceElementTag = (node) => {
+	const name = sourceComponentName(node);
+	if (name === null) return null;
+	return smlTagForComponentName(name) ?? name;
+};
+const isSmlTag = (value) => value !== null && SML_TAGS.includes(value);
+const sourceAttributeName = (node) => {
+	const name = childNode(node, "name");
+	if (name === null || name.type !== "JSXIdentifier") return null;
+	return stringProperty(name, "name");
+};
+const sourceAttributes = (opening, source) => {
+	const attributes = [];
+	for (const attribute of astNodes(astValue(opening, "attributes"))) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			attributes.push({
+				name: "...",
+				start: attribute.start,
+				end: attribute.end,
+				nameStart: attribute.start,
+				valueStart: attribute.start,
+				valueEnd: attribute.end,
+				kind: "dynamic",
+				value: null
+			});
+			continue;
+		}
+		if (attribute.type !== "JSXAttribute") continue;
+		const name = sourceAttributeName(attribute);
+		const nameNode = childNode(attribute, "name");
+		const valueNode = astValue(attribute, "value");
+		if (name === null || nameNode === null) {
+			attributes.push({
+				name: name ?? "?",
+				start: attribute.start,
+				end: attribute.end,
+				nameStart: attribute.start,
+				valueStart: attribute.start,
+				valueEnd: attribute.end,
+				kind: "dynamic",
+				value: null
+			});
+			continue;
+		}
+		if (isAstNode(valueNode) && valueNode.type === "StringLiteral") {
+			const value = stringProperty(valueNode, "value");
+			if (value !== null) {
+				attributes.push({
+					name,
+					start: attribute.start,
+					end: attribute.end,
+					nameStart: nameNode.start,
+					valueStart: valueNode.start,
+					valueEnd: valueNode.end,
+					kind: "string",
+					value
+				});
+				continue;
+			}
+		}
+		if (isAstNode(valueNode) && valueNode.type === "JSXExpressionContainer") {
+			const expression = childNode(valueNode, "expression");
+			const value = expression === null ? null : astNumber(expression, "value");
+			if (expression !== null && expression.type === "NumericLiteral" && value !== null) {
+				attributes.push({
+					name,
+					start: attribute.start,
+					end: attribute.end,
+					nameStart: nameNode.start,
+					valueStart: expression.start,
+					valueEnd: expression.end,
+					kind: "number",
+					value
+				});
+				continue;
+			}
+		}
+		attributes.push({
+			name,
+			start: attribute.start,
+			end: attribute.end,
+			nameStart: nameNode.start,
+			valueStart: valueNode && isAstNode(valueNode) ? valueNode.start : attribute.end,
+			valueEnd: valueNode && isAstNode(valueNode) ? valueNode.end : attribute.end,
+			kind: "dynamic",
+			value: null
+		});
+	}
+	return attributes;
+};
+const sourceChildParts = (node, source, parent, built) => {
+	const children = [];
+	for (const child of astNodes(astValue(node, "children"))) {
+		if (child.type === "JSXElement") {
+			children.push(buildSourceElement(child, source, parent, built));
+			continue;
+		}
+		if (child.type === "JSXText") {
+			children.push({
+				kind: "text",
+				start: child.start,
+				end: child.end,
+				form: "jsx-text"
+			});
+			continue;
+		}
+		const literal = staticStringLiteralText(child);
+		if (literal !== null) {
+			children.push({
+				kind: "text",
+				start: child.start,
+				end: child.end,
+				form: "string-literal",
+				literal
+			});
+			continue;
+		}
+		children.push({
+			kind: "opaque",
+			start: child.start,
+			end: child.end
+		});
+	}
+	return children;
+};
+const buildSourceElement = (node, source, parent, built) => {
+	const opening = childNode(node, "openingElement");
+	const closing = childNode(node, "closingElement");
+	const openingStart = opening?.start ?? node.start;
+	const openingEnd = opening?.end ?? node.start;
+	const selfClosing = source.slice(Math.max(openingEnd - 2, openingStart), openingEnd) === "/>";
+	const element = {
+		kind: "element",
+		ast: node,
+		tag: sourceElementTag(node),
+		componentName: sourceComponentName(node),
+		start: node.start,
+		end: node.end,
+		openingStart,
+		openingEnd,
+		closingStart: closing?.start ?? null,
+		closingEnd: closing?.end ?? null,
+		selfClosing,
+		attributes: opening === null ? [] : sourceAttributes(opening, source),
+		children: [],
+		parent,
+		active: true,
+		propEdits: /* @__PURE__ */ new Map()
+	};
+	built.add(node);
+	element.children = sourceChildParts(node, source, element, built);
+	return element;
+};
+const collectSourceElements = (program, source) => {
+	const built = /* @__PURE__ */ new Set();
+	const elements = [];
+	const collect = (element) => {
+		elements.push(element);
+		for (const child of element.children) if (child.kind === "element") collect(child);
+	};
+	walkAst(program, (node) => {
+		if (node.type !== "JSXElement" || built.has(node)) return;
+		collect(buildSourceElement(node, source, null, built));
+	});
+	return elements;
+};
+const sourceSpan = (element) => ({
+	start: element.start,
+	end: element.end
+});
+const sourceTextValue = (part, source) => part.form === "string-literal" ? part.literal ?? "" : decodeEntities(source.slice(part.start, part.end));
+/** The name to print in a diagnostic or a synthesized closing tag: what the author wrote. */
+const sourceTagName = (element) => element.componentName ?? "<dynamic JSX component>";
+const sourceElementChildren = (element) => element.children.filter((child) => child.kind === "element");
+const sourceIsAttached = (element, root) => {
+	if (!element.active) return false;
+	let current = element;
+	while (current !== null && current !== root) current = current.parent;
+	return current === root;
+};
+const markSourceSubtree = (element, active) => {
+	element.active = active;
+	for (const child of element.children) if (child.kind === "element") markSourceSubtree(child, active);
+};
+const sourceLocatorIsValid = (source, locator) => {
+	if (isSpanLocator(locator)) return Number.isInteger(locator.span.start) && Number.isInteger(locator.span.end) && locator.span.start >= 0 && locator.span.end > locator.span.start && locator.span.end <= source.length;
+	return locatorOffset(source, locator) !== null;
+};
+const renderStaticAttribute = (name, value) => value.kind === "number" ? `${name}={${value.value}}` : `${name}="${value.value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;")}"`;
+const sourceValueMatches = (left, right) => left !== void 0 && right !== void 0 && left.kind === right.kind && left.value === right.value;
+const sourceAttributeValue = (attribute) => {
+	if (attribute.kind === "string" && typeof attribute.value === "string") return {
+		kind: "string",
+		value: attribute.value
+	};
+	if (attribute.kind === "number" && typeof attribute.value === "number") return {
+		kind: "number",
+		value: attribute.value
+	};
+};
+const sourceStaticAttributes = (element) => {
+	const values = /* @__PURE__ */ new Map();
+	for (const attribute of element.attributes) {
+		const value = sourceAttributeValue(attribute);
+		if (attribute.kind === "dynamic" || value === void 0) return Result.fail(sourceDiagnostic("tsx-dynamic-target", `authored <${sourceTagName(element)}> has a dynamic or spread attribute; refusing to rewrite it`, {
+			start: attribute.start,
+			end: attribute.end
+		}));
+		if (values.has(attribute.name)) return Result.fail(sourceDiagnostic("tsx-ambiguous-target", `authored <${sourceTagName(element)}> repeats attribute "${attribute.name}"; refusing to choose one`, {
+			start: attribute.start,
+			end: attribute.end
+		}));
+		values.set(attribute.name, value);
+	}
+	return Result.succeed(values);
+};
+const currentSourceAttributes = (element) => {
+	const original = sourceStaticAttributes(element);
+	if (Result.isFailure(original)) return original;
+	const values = new Map(original.success);
+	for (const [name, value] of element.propEdits) if (value === null || value.kind === "string" && value.value === "") values.delete(name);
+	else values.set(name, value);
+	return Result.succeed(values);
+};
+const emittedAttributes = (element) => new Map(element.attributes.map((attribute) => [attribute.name, attribute.value]));
+const attributesMatch = (source, emitted) => {
+	if (source.size !== emitted.size) return false;
+	for (const [name, value] of source) if (!sourceValueMatches(value, emitted.get(name))) return false;
+	return true;
+};
+const validateMappedElement = (source, emitted, root, authoredSource, expectedAttributes, validateAttributes = true) => {
+	if (!sourceIsAttached(source, root)) return Result.fail(sourceDiagnostic("tsx-target-not-found", `the authored JSX node for emitted "${emitted.id}" is no longer in the active source tree`, sourceSpan(source)));
+	if (!isSmlTag(source.tag)) return Result.fail(sourceDiagnostic("tsx-unsupported-target", `authored ${sourceTagName(source)} is not a recognized Samva primitive`, sourceSpan(source)));
+	if (source.tag !== emitted.tag) return Result.fail(sourceDiagnostic("tsx-ambiguous-target", `emitted node "${emitted.id}" is <${emitted.tag}> but its locator identifies authored <${sourceTagName(source)}>`, sourceSpan(source)));
+	if (validateAttributes) {
+		const sourceValues = currentSourceAttributes(source);
+		if (Result.isFailure(sourceValues)) return Result.fail(sourceValues.failure);
+		const emittedValues = expectedAttributes ?? emittedAttributes(emitted);
+		if (!attributesMatch(sourceValues.success, emittedValues)) return Result.fail(sourceDiagnostic("tsx-ambiguous-target", `emitted <${emitted.tag}> does not match the located authored JSX attributes; refusing to edit stale source`, sourceSpan(source)));
+	}
+	if (source.end > authoredSource.length || source.start < 0) return Result.fail(sourceDiagnostic("tsx-unsupported-target", "the mapped JSX element lies outside the authored source", sourceSpan(source)));
+	return Result.succeed(source);
+};
+const sourceElementForLocator = (sourceElements, authoredSource, authoredFile, locator) => {
+	if (locator.fileName !== authoredFile) return Result.fail(sourceDiagnostic("tsx-unsupported-target", `the source locator points to "${locator.fileName}", not the authored file "${authoredFile}"`, locatorSpan(locator)));
+	if (!sourceLocatorIsValid(authoredSource, locator)) return Result.fail(sourceDiagnostic("tsx-unsupported-target", "the source locator does not identify a position in the authored TSX source", locatorSpan(locator)));
+	const candidates = sourceElements.filter((element) => locatorMatches(authoredSource, authoredFile, locator, sourceSpan(element)));
+	if (candidates.length === 0) return Result.fail(sourceDiagnostic("tsx-target-not-found", "the source locator does not identify a JSX element in the authored TSX source", locatorSpan(locator)));
+	if (candidates.length !== 1) return Result.fail(sourceDiagnostic("tsx-ambiguous-target", `the source locator identifies ${candidates.length} JSX elements; refusing to guess a source range`, sourceSpan(candidates[0])));
+	return Result.succeed(candidates[0]);
+};
+const sourceElementForId = (id, emittedRoot, sourceElementsById, sourceMapErrors) => {
+	const emitted = elementById(emittedRoot, id);
+	if (emitted === null) return Result.fail(sourceDiagnostic("tsx-target-not-found", `emitted node "${id}" was not found in the SML source`));
+	const mapError = sourceMapErrors.get(id);
+	if (mapError !== void 0) return Result.fail(mapError);
+	const source = sourceElementsById.get(id);
+	if (source === void 0) return Result.fail(sourceDiagnostic("tsx-unsupported-target", `emitted node "${id}" has no exact authored TSX source locator; refusing to guess a range`, emitted.span));
+	return Result.succeed({
+		source,
+		emitted
+	});
+};
+const renderSourceOpening = (element, authoredSource) => {
+	if (element.propEdits.size === 0) return authoredSource.slice(element.openingStart, element.openingEnd);
+	const edits = [];
+	const originalNames = new Set(element.attributes.map((attribute) => attribute.name));
+	for (const attribute of element.attributes) {
+		if (attribute.kind === "dynamic") continue;
+		if (!element.propEdits.has(attribute.name)) continue;
+		const value = element.propEdits.get(attribute.name);
+		if (value === void 0) continue;
+		if (value === null || value.kind === "string" && value.value === "") {
+			edits.push({
+				start: attribute.start > element.openingStart && authoredSource[attribute.start - 1] === " " ? attribute.start - 1 : attribute.start,
+				end: attribute.end,
+				value: ""
+			});
+			continue;
+		}
+		const original = sourceAttributeValue(attribute);
+		if (original !== void 0 && sourceValueMatches(original, value)) continue;
+		if (original?.kind === value.kind) {
+			if (value.kind === "string") edits.push({
+				start: attribute.valueStart + 1,
+				end: Math.max(attribute.valueStart + 1, attribute.valueEnd - 1),
+				value: value.value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;")
+			});
+			else edits.push({
+				start: attribute.valueStart,
+				end: attribute.valueEnd,
+				value: String(value.value)
+			});
+		} else edits.push({
+			start: attribute.start,
+			end: attribute.end,
+			value: renderStaticAttribute(attribute.name, value)
+		});
+	}
+	const added = [];
+	for (const [name, value] of element.propEdits) if (!originalNames.has(name) && value !== null && !(value.kind === "string" && value.value === "")) added.push([name, value]);
+	if (added.length > 0) {
+		const closingLength = element.selfClosing ? 2 : 1;
+		const insertion = element.openingEnd - closingLength;
+		const prefix = insertion > element.openingStart && /\s/u.test(authoredSource[insertion - 1] ?? "") ? "" : " ";
+		edits.push({
+			start: insertion,
+			end: insertion,
+			value: `${prefix}${added.map(([name, value]) => renderStaticAttribute(name, value)).join(" ")}`
+		});
+	}
+	let opening = authoredSource.slice(element.openingStart, element.openingEnd);
+	for (const edit of edits.toSorted((left, right) => right.start - left.start)) {
+		const relativeStart = edit.start - element.openingStart;
+		const relativeEnd = edit.end - element.openingStart;
+		opening = `${opening.slice(0, relativeStart)}${edit.value}${opening.slice(relativeEnd)}`;
+	}
+	return opening;
+};
+const renderSourceElement = (element, authoredSource) => {
+	const opening = renderSourceOpening(element, authoredSource);
+	const children = element.children.map((child) => {
+		if (child.kind === "raw") return child.source;
+		if (child.kind === "text") return child.replacement ?? authoredSource.slice(child.start, child.end);
+		if (child.kind === "opaque") return authoredSource.slice(child.start, child.end);
+		return renderSourceElement(child, authoredSource);
+	});
+	if (children.length === 0) {
+		if (element.selfClosing) return opening;
+		return `${opening.slice(0, -1).trimEnd()} />`;
+	}
+	const open = element.selfClosing ? `${opening.slice(0, -2).trimEnd()}>` : opening;
+	const close = element.closingStart === null || element.closingEnd === null ? `</${sourceTagName(element)}>` : authoredSource.slice(element.closingStart, element.closingEnd);
+	return `${open}${children.join("")}${close}`;
+};
+const sourceElementParentIndex = (parent, child) => parent.children.findIndex((candidate) => candidate === child);
+const elementChildInsertionIndex = (children, insertionIndex) => {
+	if (insertionIndex <= 0) {
+		const first = children.findIndex((child) => child.kind === "element");
+		return first < 0 ? children.length : first;
+	}
+	let seen = 0;
+	for (let index = 0; index < children.length; index++) {
+		if (children[index]?.kind !== "element") continue;
+		if (seen === insertionIndex) return index;
+		seen++;
+	}
+	return children.length;
+};
+const activeDescendant = (ancestor, candidate) => {
+	let current = candidate.parent;
+	while (current !== null) {
+		if (current === ancestor) return true;
+		current = current.parent;
+	}
+	return false;
+};
+const detachSourceElement = (element) => {
+	if (element.parent === null) return false;
+	const parent = element.parent;
+	const index = sourceElementParentIndex(parent, element);
+	if (index < 0) return false;
+	parent.children.splice(index, 1);
+	element.parent = null;
+	markSourceSubtree(element, false);
+	return true;
+};
+const attachSourceElement = (element, parent, index) => {
+	element.parent = parent;
+	parent.children.splice(index, 0, element);
+	markSourceSubtree(element, true);
+};
+const escapedStaticText = (value) => escapeJsxText(value);
+const renderStaticSmlNode = (node) => {
+	if (node.kind === "interpolation") return Result.fail(sourceDiagnostic("tsx-dynamic-target", `cannot safely print interpolation {{${node.name}}} into a TSX child list without a variable binding`, node.span));
+	if (node.kind === "text") return Result.succeed(escapedStaticText(node.value));
+	if (!isSmlTag(node.tag)) return Result.fail(sourceDiagnostic("tsx-unsupported-target", `cannot print unknown SML tag <${node.tag}>`, node.span));
+	const attributes = node.attributes.map((attribute) => renderStaticAttribute(attribute.name, attribute.value)).join(" ");
+	const name = componentNameForSmlTag(node.tag);
+	const open = attributes.length === 0 ? `<${name}` : `<${name} ${attributes}`;
+	if (node.children.length === 0) return Result.succeed(`${open} />`);
+	const children = [];
+	for (const child of node.children) {
+		const rendered = renderStaticSmlNode(child);
+		if (Result.isFailure(rendered)) return rendered;
+		children.push(rendered.success);
+	}
+	return Result.succeed(`${open}>${children.join("")}</${name}>`);
+};
+const renderStaticSmlChildren = (children) => {
+	const rendered = [];
+	for (const child of children) {
+		const value = renderStaticSmlNode(child);
+		if (Result.isFailure(value)) return value;
+		rendered.push(value.success);
+	}
+	return Result.succeed(rendered.join(""));
+};
+/**
+* The one static text child an inline edit may rewrite. A formatter puts a
+* `{"…"}` child on its own line, so blank JSX text around it is ignored; any
+* other child kind makes the element structured and disqualifies it.
+*/
+const directTextPart = (element, source) => {
+	if (element.children.some((child) => child.kind !== "text")) return null;
+	const parts = element.children.filter((child) => child.kind === "text" && sourceTextValue(child, source).trim().length > 0);
+	return parts.length === 1 ? parts[0] : null;
+};
+const replaceDirectText = (element, emitted, source, text) => {
+	if (emitted.children.length !== 1 || emitted.children[0]?.kind !== "text") return Result.succeed(false);
+	const part = directTextPart(element, source);
+	if (part === null) return Result.succeed(false);
+	const current = sourceTextValue(part, source);
+	if (normalizeText(current) !== normalizeText(emitted.children[0].value)) return Result.fail(sourceDiagnostic("tsx-ambiguous-target", `emitted <${emitted.tag}> text does not match the located authored literal; refusing to edit stale source`, sourceSpan(element)));
+	if (part.form === "string-literal") {
+		part.replacement = serializeStaticTextChild("string-literal", text);
+		return Result.succeed(true);
+	}
+	const raw = source.slice(part.start, part.end);
+	const leading = raw.search(/\S/u);
+	if (leading < 0) return Result.succeed(false);
+	let trailing = raw.length;
+	while (trailing > leading && /\s/u.test(raw[trailing - 1])) trailing -= 1;
+	part.replacement = `${raw.slice(0, leading)}${escapedStaticText(text)}${raw.slice(trailing)}`;
+	return Result.succeed(true);
+};
+const validateStaticSnippet = (source, snippet) => {
+	let parsed;
+	try {
+		parsed = parse(`const __samvaSnippet = <>${snippet}</>;`, {
+			plugins: ["typescript", "jsx"],
+			sourceType: "module"
+		}).program;
+	} catch (error) {
+		return Result.fail(sourceDiagnostic("tsx-invalid-snippet", error instanceof Error ? error.message : "the insert snippet is not valid TSX"));
+	}
+	const fragments = [];
+	walkAst(parsed, (node) => {
+		if (node.type === "JSXFragment") fragments.push(node);
+	});
+	const fragment = fragments[0];
+	if (fragment === void 0) return Result.fail(sourceDiagnostic("tsx-invalid-snippet", "the insert snippet has no JSX fragment"));
+	const visitElement = (node) => {
+		const tag = sourceElementTag(node);
+		if (!isSmlTag(tag)) return sourceDiagnostic("tsx-unsupported-target", `insert snippet contains ${tag === null ? "a dynamic JSX component" : `<${tag}>`}, not a recognized Samva primitive`, astNodeSpan(node));
+		const opening = childNode(node, "openingElement");
+		if (opening !== null) {
+			for (const attribute of sourceAttributes(opening, source)) if (attribute.kind === "dynamic") return sourceDiagnostic("tsx-dynamic-target", `insert snippet <${tag}> contains a dynamic or spread attribute`, {
+				start: attribute.start,
+				end: attribute.end
+			});
+		}
+		for (const child of astNodes(astValue(node, "children"))) {
+			if (child.type === "JSXText") continue;
+			if (child.type !== "JSXElement") return sourceDiagnostic("tsx-dynamic-target", `insert snippet <${tag}> contains a dynamic or opaque child`, astNodeSpan(child));
+			const childFailure = visitElement(child);
+			if (childFailure !== null) return childFailure;
+		}
+		return null;
+	};
+	const directChildren = astNodes(astValue(fragment, "children"));
+	let elementCount = 0;
+	for (const child of directChildren) {
+		if (child.type === "JSXText") {
+			if (source.slice(child.start, child.end).trim().length > 0) return Result.fail(sourceDiagnostic("tsx-invalid-snippet", "insert snippet must contain only JSX elements", astNodeSpan(child)));
+			continue;
+		}
+		if (child.type !== "JSXElement") return Result.fail(sourceDiagnostic("tsx-dynamic-target", "insert snippet contains an opaque JSX child", astNodeSpan(child)));
+		elementCount++;
+		const childFailure = visitElement(child);
+		if (childFailure !== null) return Result.fail(childFailure);
+	}
+	return elementCount === 0 ? Result.fail(sourceDiagnostic("tsx-invalid-snippet", "insert snippet contains no elements")) : Result.succeed(void 0);
+};
+const allEmittedElements = (root) => {
+	const elements = [];
+	const visit = (node) => {
+		elements.push(node);
+		for (const child of node.children) if (child.kind === "element") visit(child);
+	};
+	visit(root);
+	return elements;
+};
+const sourceTargetChildrenAreStatic = (target) => {
+	for (const child of target.children) if (child.kind === "opaque" || child.kind === "raw") return Result.fail(sourceDiagnostic("tsx-dynamic-target", `authored <${sourceTagName(target)}> has a dynamic or opaque child; refusing to replace its complete child list`, child.kind === "raw" ? sourceSpan(target) : {
+		start: child.start,
+		end: child.end
+	}));
+	return Result.succeed(void 0);
+};
+const staticSourceTreeMatches = (source, emitted, authoredSource) => {
+	if (source.tag !== emitted.tag) return false;
+	const attributes = sourceStaticAttributes(source);
+	if (Result.isFailure(attributes) || !attributesMatch(attributes.success, emittedAttributes(emitted))) return false;
+	const sourceChildren = source.children.filter((child) => child.kind !== "text" || normalizeText(sourceTextValue(child, authoredSource)) !== "");
+	const emittedChildren = emitted.children.filter((child) => child.kind !== "text" || normalizeText(child.value) !== "");
+	if (sourceChildren.length !== emittedChildren.length) return false;
+	for (let index = 0; index < sourceChildren.length; index++) {
+		const sourceChild = sourceChildren[index];
+		const emittedChild = emittedChildren[index];
+		if (sourceChild.kind === "text" && emittedChild.kind === "text") {
+			if (normalizeText(sourceTextValue(sourceChild, authoredSource)) !== normalizeText(emittedChild.value)) return false;
+			continue;
+		}
+		if (sourceChild.kind !== "element" || emittedChild.kind !== "element" || !staticSourceTreeMatches(sourceChild, emittedChild, authoredSource)) return false;
+	}
+	return true;
+};
+const removeEmittedSubtree = (values, node) => {
+	values.delete(node.id);
+	for (const child of node.children) if (child.kind === "element") removeEmittedSubtree(values, child);
+};
+/**
+* Apply semantic editor operations to the authored TSX entry.
+*
+* The emitted SML document remains the validation oracle: operations are
+* preflighted through the same markup op implementation first, then each
+* mapped target is checked against the authored JSX AST and exact source
+* provenance. The mutable source tree below only moves original AST nodes or
+* inserts validated raw fragments; it never reprints the user's module.
+*/
+const applyTsxSmlOps = (input) => {
+	const emitted = parseSml(input.emittedSource);
+	if (Result.isFailure(emitted)) return sourceFailure(...emitted.failure.diagnostics.map(({ message, span }) => sourceDiagnostic("tsx-invalid-emitted-source", message, span)));
+	const authored = parseAuthored(input.authoredSource);
+	if (Result.isFailure(authored)) return sourceFailure(authored.failure);
+	if (input.ops.length === 0) return Result.succeed(input.authoredSource);
+	const preflight = applyOps(input.emittedSource, input.ops);
+	if (Result.isFailure(preflight)) return sourceFailure(...preflight.failure.diagnostics.map(({ message, span, code }) => sourceDiagnostic(code === "op-target-not-found" ? "tsx-target-not-found" : "tsx-unsupported-target", message, span)));
+	const failedOperation = preflight.success.results.find((result) => result.status === "failed");
+	if (failedOperation !== void 0) return sourceFailure(...failedOperation.diagnostics.map(({ message, span, code }) => sourceDiagnostic(code === "op-target-not-found" ? "tsx-target-not-found" : "tsx-unsupported-target", message, span)));
+	const sourceElements = collectSourceElements(authored.success, input.authoredSource);
+	const sourceElementsById = /* @__PURE__ */ new Map();
+	const sourceIdByElement = /* @__PURE__ */ new Map();
+	const sourceMapErrors = /* @__PURE__ */ new Map();
+	const firstIdBySourceElement = /* @__PURE__ */ new Map();
+	for (const [id, locator] of Object.entries(input.sourceLocations.byNodeId)) {
+		const resolved = sourceElementForLocator(sourceElements, input.authoredSource, input.authoredFile, locator);
+		if (Result.isFailure(resolved)) {
+			sourceMapErrors.set(id, resolved.failure);
+			continue;
+		}
+		const existingId = firstIdBySourceElement.get(resolved.success);
+		if (existingId !== void 0) {
+			const duplicate = sourceDiagnostic("tsx-ambiguous-target", `source locators for emitted nodes "${existingId}" and "${id}" identify the same authored JSX element`, sourceSpan(resolved.success));
+			sourceMapErrors.set(existingId, duplicate);
+			sourceMapErrors.set(id, duplicate);
+			continue;
+		}
+		firstIdBySourceElement.set(resolved.success, id);
+		sourceElementsById.set(id, resolved.success);
+		sourceIdByElement.set(resolved.success, id);
+	}
+	const rootId = emitted.success.root.id;
+	const mappedRoot = sourceElementForId(rootId, emitted.success.root, sourceElementsById, sourceMapErrors);
+	if (Result.isFailure(mappedRoot)) return sourceFailure(mappedRoot.failure);
+	if (mappedRoot.success.source.parent !== null) return sourceFailure(sourceDiagnostic("tsx-unsupported-target", "the emitted root locator identifies a nested JSX element, not the template root", sourceSpan(mappedRoot.success.source)));
+	const root = mappedRoot.success.source;
+	const rootValidation = validateMappedElement(root, mappedRoot.success.emitted, root, input.authoredSource);
+	if (Result.isFailure(rootValidation)) return sourceFailure(rootValidation.failure);
+	for (const element of sourceElements) markSourceSubtree(element, false);
+	markSourceSubtree(root, true);
+	const virtualAttributes = new Map(allEmittedElements(emitted.success.root).map((element) => [element.id, new Map(emittedAttributes(element))]));
+	const resolveTarget = (id) => {
+		const resolved = sourceElementForId(id, emitted.success.root, sourceElementsById, sourceMapErrors);
+		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+		const validated = validateMappedElement(resolved.success.source, resolved.success.emitted, root, input.authoredSource, virtualAttributes.get(id));
+		if (Result.isFailure(validated)) return Result.fail(validated.failure);
+		return Result.succeed(resolved.success);
+	};
+	const resolveParentFor = (source) => {
+		if (source.parent === null) return Result.fail(sourceDiagnostic("tsx-target-not-found", `authored <${sourceTagName(source)}> has no active JSX parent`, sourceSpan(source)));
+		const id = sourceIdByElement.get(source.parent);
+		if (id === void 0) return Result.fail(sourceDiagnostic("tsx-unsupported-target", `authored parent <${sourceTagName(source.parent)}> has no exact source-map entry`, sourceSpan(source.parent)));
+		const resolved = resolveTarget(id);
+		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+		return Result.succeed(source.parent);
+	};
+	const resolveRootTarget = () => {
+		const validated = resolveTarget(rootId);
+		if (Result.isFailure(validated)) return Result.fail(validated.failure);
+		return Result.succeed(validated.success.source);
+	};
+	const applySetProp = (op) => {
+		if (op.name === "src:dark") return Result.fail(sourceDiagnostic("tsx-unsupported-operation", "src:dark is a derived SML source and has no direct TSX attribute splice"));
+		const resolved = resolveTarget(op.nodeId);
+		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+		const value = op.value?.kind === "string" && op.value.value === "" ? null : op.value;
+		resolved.success.source.propEdits.set(op.name, value);
+		const attributes = virtualAttributes.get(op.nodeId);
+		if (attributes === void 0) return Result.fail(sourceDiagnostic("tsx-target-not-found", `emitted node "${op.nodeId}" was not found in the SML attribute map`));
+		if (value === null) attributes.delete(op.name);
+		else attributes.set(op.name, value);
+		return Result.succeed(void 0);
+	};
+	const applySetChildren = (op) => {
+		const mapped = sourceElementForId(op.nodeId, emitted.success.root, sourceElementsById, sourceMapErrors);
+		if (Result.isFailure(mapped)) return Result.fail(mapped.failure);
+		const mappedIdentity = validateMappedElement(mapped.success.source, mapped.success.emitted, root, input.authoredSource, void 0, false);
+		if (Result.isFailure(mappedIdentity)) return Result.fail(mappedIdentity.failure);
+		const rendered = renderStaticSmlChildren(op.children);
+		if (Result.isFailure(rendered)) return Result.fail(rendered.failure);
+		if (op.children.length === 1 && op.children[0]?.kind === "text") {
+			const direct = replaceDirectText(mapped.success.source, mapped.success.emitted, input.authoredSource, op.children[0].value);
+			if (Result.isFailure(direct)) return Result.fail(direct.failure);
+			if (direct.success) return Result.succeed(void 0);
+		}
+		const resolved = resolveTarget(op.nodeId);
+		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+		const { source, emitted: emittedElement } = resolved.success;
+		const staticChildren = sourceTargetChildrenAreStatic(source);
+		if (Result.isFailure(staticChildren)) return staticChildren;
+		if (!staticSourceTreeMatches(source, emittedElement, input.authoredSource)) return Result.fail(sourceDiagnostic("tsx-ambiguous-target", `emitted <${emittedElement.tag}> does not match the located static authored JSX subtree`, sourceSpan(source)));
+		for (const child of sourceElementChildren(source)) {
+			child.parent = null;
+			markSourceSubtree(child, false);
+		}
+		source.children = rendered.success.length === 0 ? [] : [{
+			kind: "raw",
+			source: rendered.success
+		}];
+		return Result.succeed(void 0);
+	};
+	const applyInsertSnippet = (op) => {
+		const validSnippet = validateStaticSnippet(input.authoredSource, op.snippet);
+		if (Result.isFailure(validSnippet)) return validSnippet;
+		let parent;
+		let insertionIndex;
+		if (op.referenceId === null || op.referenceId === rootId) {
+			const resolvedRoot = resolveRootTarget();
+			if (Result.isFailure(resolvedRoot)) return Result.fail(resolvedRoot.failure);
+			parent = resolvedRoot.success;
+			insertionIndex = op.position === "before" ? 0 : parent.children.length;
+		} else {
+			const reference = resolveTarget(op.referenceId);
+			if (Result.isFailure(reference)) return Result.fail(reference.failure);
+			if (op.position === "inside") {
+				parent = reference.success.source;
+				insertionIndex = parent.children.length;
+			} else {
+				const resolvedParent = resolveParentFor(reference.success.source);
+				if (Result.isFailure(resolvedParent)) return Result.fail(resolvedParent.failure);
+				parent = resolvedParent.success;
+				const referenceIndex = sourceElementParentIndex(parent, reference.success.source);
+				if (referenceIndex < 0) return Result.fail(sourceDiagnostic("tsx-target-not-found", `reference node "${op.referenceId}" is no longer attached`));
+				insertionIndex = referenceIndex + (op.position === "after" ? 1 : 0);
+			}
+		}
+		const parentId = sourceIdByElement.get(parent);
+		if (parentId !== void 0) {
+			const resolvedParent = resolveTarget(parentId);
+			if (Result.isFailure(resolvedParent)) return Result.fail(resolvedParent.failure);
+		}
+		parent.children.splice(insertionIndex, 0, {
+			kind: "raw",
+			source: op.snippet
+		});
+		return Result.succeed(void 0);
+	};
+	const applyDuplicate = (op) => {
+		const resolved = resolveTarget(op.nodeId);
+		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+		if (resolved.success.source === root) return Result.fail(sourceDiagnostic("tsx-unsupported-operation", "the document root cannot be duplicated"));
+		const parent = resolveParentFor(resolved.success.source);
+		if (Result.isFailure(parent)) return Result.fail(parent.failure);
+		const index = sourceElementParentIndex(parent.success, resolved.success.source);
+		if (index < 0) return Result.fail(sourceDiagnostic("tsx-target-not-found", "the node is no longer attached"));
+		parent.success.children.splice(index + 1, 0, {
+			kind: "raw",
+			source: renderSourceElement(resolved.success.source, input.authoredSource)
+		});
+		return Result.succeed(void 0);
+	};
+	const applyRemove = (op) => {
+		const resolved = resolveTarget(op.nodeId);
+		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
+		if (resolved.success.source === root) return Result.fail(sourceDiagnostic("tsx-unsupported-operation", "the document root cannot be removed"));
+		const parent = resolveParentFor(resolved.success.source);
+		if (Result.isFailure(parent)) return Result.fail(parent.failure);
+		if (!detachSourceElement(resolved.success.source)) return Result.fail(sourceDiagnostic("tsx-target-not-found", `node "${op.nodeId}" is no longer attached`));
+		const emittedNode = resolved.success.emitted;
+		removeEmittedSubtree(virtualAttributes, emittedNode);
+		return Result.succeed(void 0);
+	};
+	const applyMove = (op) => {
+		const moved = resolveTarget(op.nodeId);
+		if (Result.isFailure(moved)) return Result.fail(moved.failure);
+		const parent = resolveTarget(op.targetParentId);
+		if (Result.isFailure(parent)) return Result.fail(parent.failure);
+		if (moved.success.source === root) return Result.fail(sourceDiagnostic("tsx-unsupported-operation", "the document root cannot be moved"));
+		if (moved.success.source === parent.success.source || activeDescendant(moved.success.source, parent.success.source)) return Result.fail(sourceDiagnostic("tsx-unsupported-operation", "a node cannot be moved into itself or its descendants"));
+		const oldParent = resolveParentFor(moved.success.source);
+		if (Result.isFailure(oldParent)) return Result.fail(oldParent.failure);
+		const oldIndex = sourceElementParentIndex(oldParent.success, moved.success.source);
+		if (oldIndex < 0) return Result.fail(sourceDiagnostic("tsx-target-not-found", `node "${op.nodeId}" is no longer attached`));
+		oldParent.success.children.splice(oldIndex, 1);
+		moved.success.source.parent = null;
+		const insertionIndex = elementChildInsertionIndex(parent.success.source.children, op.insertionIndex);
+		attachSourceElement(moved.success.source, parent.success.source, insertionIndex);
+		return Result.succeed(void 0);
+	};
+	for (const op of input.ops) {
+		let result;
+		switch (op._tag) {
+			case "setProp":
+				result = applySetProp(op);
+				break;
+			case "setChildren":
+				result = applySetChildren(op);
+				break;
+			case "insertSnippet":
+				result = applyInsertSnippet(op);
+				break;
+			case "duplicateNode":
+				result = applyDuplicate(op);
+				break;
+			case "removeNode":
+				result = applyRemove(op);
+				break;
+			case "moveNode":
+				result = applyMove(op);
+				break;
+			case "insertBlock": result = Result.fail(sourceDiagnostic("tsx-unsupported-operation", "insertBlock has no authored TSX fragment; use insertSnippet with an explicit JSX fragment"));
+		}
+		if (Result.isFailure(result)) return sourceFailure(result.failure);
+	}
+	const renderedRoot = renderSourceElement(root, input.authoredSource);
+	return Result.succeed(`${input.authoredSource.slice(0, root.start)}${renderedRoot}${input.authoredSource.slice(root.end)}`);
+};
+//#endregion
+export { TsxHeadingTraceError, TsxSmlOpsError, applyTsxSmlOps, replaceTsxHeadingText, traceTsxHeadingTarget };
+
+//# sourceMappingURL=tsx-tracer.js.map