@samva/markup 0.4.0 → 0.6.0

package/dist/tsx-tracer.js

@@ -1,12 +1,13 @@
+import { n as isObject } from "./guards-eV1qLbf2.js";
 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 { r as applyOps } from "./ops-2aiiYO7m.js";
+import { Result, TaggedError } from "better-result";
 import { parse } from "@babel/parser";
 //#region src/tsx-tracer.ts
-var TsxHeadingTraceError = class extends Data.TaggedError("TsxHeadingTraceError") {};
+var TsxHeadingTraceError = class extends TaggedError("TsxHeadingTraceError") {};
 const ZERO_SPAN = {
 	start: 0,
 	end: 0
@@ -16,9 +17,8 @@ const diagnostic = (code, message, span = ZERO_SPAN) => ({
 	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 failure = (...diagnostics) => Result.err(new TsxHeadingTraceError({ diagnostics }));
+const isAstNode = (value) => isObject(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;
@@ -36,7 +36,7 @@ const walkAst = (value, visit) => {
 		for (const item of value) walkAst(item, visit);
 		return;
 	}
-	if (!isRecord(value)) return;
+	if (!isObject(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;
@@ -73,7 +73,7 @@ const staticStringLiteralText = (node) => {
 	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;
+	const cooked = isObject(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. */
@@ -142,9 +142,9 @@ const parseAuthored = (source) => {
 			plugins: ["typescript", "jsx"],
 			sourceType: "module"
 		});
-		return Result.succeed(parsed.program);
+		return Result.ok(parsed.program);
 	} catch (error) {
-		return Result.fail(diagnostic("tsx-invalid-authored-source", error instanceof Error ? error.message : "The authored TSX could not be parsed."));
+		return Result.err(diagnostic("tsx-invalid-authored-source", error instanceof Error ? error.message : "The authored TSX could not be parsed."));
 	}
 };
 const isSpanLocator = (locator) => "span" in locator;
@@ -167,8 +167,8 @@ const locatorSpan = (locator) => locator !== void 0 && isSpanLocator(locator) ?
 /** 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 (Result.isError(parsed)) return failure(...parsed.error.diagnostics.map(({ message, span }) => diagnostic("tsx-invalid-emitted-source", message, span)));
+	const target = elementById(parsed.value.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);
@@ -180,11 +180,11 @@ const traceTsxHeadingTarget = (input) => {
 		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);
+	if (Result.isError(authored)) return failure(authored.error);
 	const candidates = [];
 	const dynamicSpans = [];
 	const unsupportedSpans = [];
-	walkAst(authored.success, (node) => {
+	walkAst(authored.value, (node) => {
 		if (node.type !== "JSXElement") return;
 		const name = jsxOpeningName(node);
 		if (name.kind === "dynamic") {
@@ -208,7 +208,7 @@ const traceTsxHeadingTarget = (input) => {
 	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({
+	return Result.ok({
 		nodeId: input.nodeId,
 		text: candidate.text,
 		span: candidate.span,
@@ -218,18 +218,18 @@ const traceTsxHeadingTarget = (input) => {
 /** 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)}`);
+	if (Result.isError(traced)) return Result.err(traced.error);
+	const { start, end } = traced.value.span;
+	const replacement = serializeStaticTextChild(traced.value.form, input.text);
+	return Result.ok(`${input.authoredSource.slice(0, start)}${replacement}${input.authoredSource.slice(end)}`);
 };
-var TsxSmlOpsError = class extends Data.TaggedError("TsxSmlOpsError") {};
+var TsxSmlOpsError = class extends TaggedError("TsxSmlOpsError") {};
 const sourceDiagnostic = (code, message, span = ZERO_SPAN) => ({
 	code,
 	message,
 	span
 });
-const sourceFailure = (...diagnostics) => Result.fail(new TsxSmlOpsError({ diagnostics }));
+const sourceFailure = (...diagnostics) => Result.err(new TsxSmlOpsError({ diagnostics }));
 const astNodes = (value) => {
 	if (!Array.isArray(value)) return [];
 	return value.filter(isAstNode);
@@ -454,25 +454,25 @@ 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`, {
+		if (attribute.kind === "dynamic" || value === void 0) return Result.err(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`, {
+		if (values.has(attribute.name)) return Result.err(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);
+	return Result.ok(values);
 };
 const currentSourceAttributes = (element) => {
 	const original = sourceStaticAttributes(element);
-	if (Result.isFailure(original)) return original;
-	const values = new Map(original.success);
+	if (Result.isError(original)) return original;
+	const values = new Map(original.value);
 	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);
+	return Result.ok(values);
 };
 const emittedAttributes = (element) => new Map(element.attributes.map((attribute) => [attribute.name, attribute.value]));
 const attributesMatch = (source, emitted) => {
@@ -481,34 +481,34 @@ const attributesMatch = (source, emitted) => {
 	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 (!sourceIsAttached(source, root)) return Result.err(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.err(sourceDiagnostic("tsx-unsupported-target", `authored ${sourceTagName(source)} is not a recognized Samva primitive`, sourceSpan(source)));
+	if (source.tag !== emitted.tag) return Result.err(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);
+		if (Result.isError(sourceValues)) return Result.err(sourceValues.error);
 		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 (!attributesMatch(sourceValues.value, emittedValues)) return Result.err(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);
+	if (source.end > authoredSource.length || source.start < 0) return Result.err(sourceDiagnostic("tsx-unsupported-target", "the mapped JSX element lies outside the authored source", sourceSpan(source)));
+	return Result.ok(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)));
+	if (locator.fileName !== authoredFile) return Result.err(sourceDiagnostic("tsx-unsupported-target", `the source locator points to "${locator.fileName}", not the authored file "${authoredFile}"`, locatorSpan(locator)));
+	if (!sourceLocatorIsValid(authoredSource, locator)) return Result.err(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]);
+	if (candidates.length === 0) return Result.err(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.err(sourceDiagnostic("tsx-ambiguous-target", `the source locator identifies ${candidates.length} JSX elements; refusing to guess a source range`, sourceSpan(candidates[0])));
+	return Result.ok(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`));
+	if (emitted === null) return Result.err(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);
+	if (mapError !== void 0) return Result.err(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({
+	if (source === void 0) return Result.err(sourceDiagnostic("tsx-unsupported-target", `emitted node "${id}" has no exact authored TSX source locator; refusing to guess a range`, emitted.span));
+	return Result.ok({
 		source,
 		emitted
 	});
@@ -624,29 +624,29 @@ const attachSourceElement = (element, parent, index) => {
 };
 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));
+	if (node.kind === "interpolation") return Result.err(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.ok(escapedStaticText(node.value));
+	if (!isSmlTag(node.tag)) return Result.err(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} />`);
+	if (node.children.length === 0) return Result.ok(`${open} />`);
 	const children = [];
 	for (const child of node.children) {
 		const rendered = renderStaticSmlNode(child);
-		if (Result.isFailure(rendered)) return rendered;
-		children.push(rendered.success);
+		if (Result.isError(rendered)) return rendered;
+		children.push(rendered.value);
 	}
-	return Result.succeed(`${open}>${children.join("")}</${name}>`);
+	return Result.ok(`${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);
+		if (Result.isError(value)) return value;
+		rendered.push(value.value);
 	}
-	return Result.succeed(rendered.join(""));
+	return Result.ok(rendered.join(""));
 };
 /**
 * The one static text child an inline edit may rewrite. A formatter puts a
@@ -659,22 +659,22 @@ const directTextPart = (element, source) => {
 	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);
+	if (emitted.children.length !== 1 || emitted.children[0]?.kind !== "text") return Result.ok(false);
 	const part = directTextPart(element, source);
-	if (part === null) return Result.succeed(false);
+	if (part === null) return Result.ok(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 (normalizeText(current) !== normalizeText(emitted.children[0].value)) return Result.err(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);
+		return Result.ok(true);
 	}
 	const raw = source.slice(part.start, part.end);
 	const leading = raw.search(/\S/u);
-	if (leading < 0) return Result.succeed(false);
+	if (leading < 0) return Result.ok(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);
+	return Result.ok(true);
 };
 const validateStaticSnippet = (source, snippet) => {
 	let parsed;
@@ -684,14 +684,14 @@ const validateStaticSnippet = (source, snippet) => {
 			sourceType: "module"
 		}).program;
 	} catch (error) {
-		return Result.fail(sourceDiagnostic("tsx-invalid-snippet", error instanceof Error ? error.message : "the insert snippet is not valid TSX"));
+		return Result.err(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"));
+	if (fragment === void 0) return Result.err(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));
@@ -714,15 +714,15 @@ const validateStaticSnippet = (source, snippet) => {
 	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)));
+			if (source.slice(child.start, child.end).trim().length > 0) return Result.err(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)));
+		if (child.type !== "JSXElement") return Result.err(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);
+		if (childFailure !== null) return Result.err(childFailure);
 	}
-	return elementCount === 0 ? Result.fail(sourceDiagnostic("tsx-invalid-snippet", "insert snippet contains no elements")) : Result.succeed(void 0);
+	return elementCount === 0 ? Result.err(sourceDiagnostic("tsx-invalid-snippet", "insert snippet contains no elements")) : Result.ok(void 0);
 };
 const allEmittedElements = (root) => {
 	const elements = [];
@@ -734,16 +734,16 @@ const allEmittedElements = (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) : {
+	for (const child of target.children) if (child.kind === "opaque" || child.kind === "raw") return Result.err(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);
+	return Result.ok(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;
+	if (Result.isError(attributes) || !attributesMatch(attributes.value, 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;
@@ -773,187 +773,187 @@ const removeEmittedSubtree = (values, node) => {
 */
 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)));
+	if (Result.isError(emitted)) return sourceFailure(...emitted.error.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);
+	if (Result.isError(authored)) return sourceFailure(authored.error);
+	if (input.ops.length === 0) return Result.ok(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 (Result.isError(preflight)) return sourceFailure(...preflight.error.diagnostics.map(({ message, span, code }) => sourceDiagnostic(code === "op-target-not-found" ? "tsx-target-not-found" : "tsx-unsupported-target", message, span)));
+	const failedOperation = preflight.value.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 sourceElements = collectSourceElements(authored.value, 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);
+		if (Result.isError(resolved)) {
+			sourceMapErrors.set(id, resolved.error);
 			continue;
 		}
-		const existingId = firstIdBySourceElement.get(resolved.success);
+		const existingId = firstIdBySourceElement.get(resolved.value);
 		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));
+			const duplicate = sourceDiagnostic("tsx-ambiguous-target", `source locators for emitted nodes "${existingId}" and "${id}" identify the same authored JSX element`, sourceSpan(resolved.value));
 			sourceMapErrors.set(existingId, duplicate);
 			sourceMapErrors.set(id, duplicate);
 			continue;
 		}
-		firstIdBySourceElement.set(resolved.success, id);
-		sourceElementsById.set(id, resolved.success);
-		sourceIdByElement.set(resolved.success, id);
+		firstIdBySourceElement.set(resolved.value, id);
+		sourceElementsById.set(id, resolved.value);
+		sourceIdByElement.set(resolved.value, 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);
+	const rootId = emitted.value.root.id;
+	const mappedRoot = sourceElementForId(rootId, emitted.value.root, sourceElementsById, sourceMapErrors);
+	if (Result.isError(mappedRoot)) return sourceFailure(mappedRoot.error);
+	if (mappedRoot.value.source.parent !== null) return sourceFailure(sourceDiagnostic("tsx-unsupported-target", "the emitted root locator identifies a nested JSX element, not the template root", sourceSpan(mappedRoot.value.source)));
+	const root = mappedRoot.value.source;
+	const rootValidation = validateMappedElement(root, mappedRoot.value.emitted, root, input.authoredSource);
+	if (Result.isError(rootValidation)) return sourceFailure(rootValidation.error);
 	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 virtualAttributes = new Map(allEmittedElements(emitted.value.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 resolved = sourceElementForId(id, emitted.value.root, sourceElementsById, sourceMapErrors);
+		if (Result.isError(resolved)) return Result.err(resolved.error);
+		const validated = validateMappedElement(resolved.value.source, resolved.value.emitted, root, input.authoredSource, virtualAttributes.get(id));
+		if (Result.isError(validated)) return Result.err(validated.error);
+		return Result.ok(resolved.value);
 	};
 	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)));
+		if (source.parent === null) return Result.err(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)));
+		if (id === void 0) return Result.err(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);
+		if (Result.isError(resolved)) return Result.err(resolved.error);
+		return Result.ok(source.parent);
 	};
 	const resolveRootTarget = () => {
 		const validated = resolveTarget(rootId);
-		if (Result.isFailure(validated)) return Result.fail(validated.failure);
-		return Result.succeed(validated.success.source);
+		if (Result.isError(validated)) return Result.err(validated.error);
+		return Result.ok(validated.value.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"));
+		if (op.name === "src:dark") return Result.err(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);
+		if (Result.isError(resolved)) return Result.err(resolved.error);
 		const value = op.value?.kind === "string" && op.value.value === "" ? null : op.value;
-		resolved.success.source.propEdits.set(op.name, value);
+		resolved.value.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 (attributes === void 0) return Result.err(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);
+		return Result.ok(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 mapped = sourceElementForId(op.nodeId, emitted.value.root, sourceElementsById, sourceMapErrors);
+		if (Result.isError(mapped)) return Result.err(mapped.error);
+		const mappedIdentity = validateMappedElement(mapped.value.source, mapped.value.emitted, root, input.authoredSource, void 0, false);
+		if (Result.isError(mappedIdentity)) return Result.err(mappedIdentity.error);
 		const rendered = renderStaticSmlChildren(op.children);
-		if (Result.isFailure(rendered)) return Result.fail(rendered.failure);
+		if (Result.isError(rendered)) return Result.err(rendered.error);
 		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 direct = replaceDirectText(mapped.value.source, mapped.value.emitted, input.authoredSource, op.children[0].value);
+			if (Result.isError(direct)) return Result.err(direct.error);
+			if (direct.value) return Result.ok(void 0);
 		}
 		const resolved = resolveTarget(op.nodeId);
-		if (Result.isFailure(resolved)) return Result.fail(resolved.failure);
-		const { source, emitted: emittedElement } = resolved.success;
+		if (Result.isError(resolved)) return Result.err(resolved.error);
+		const { source, emitted: emittedElement } = resolved.value;
 		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)));
+		if (Result.isError(staticChildren)) return staticChildren;
+		if (!staticSourceTreeMatches(source, emittedElement, input.authoredSource)) return Result.err(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 ? [] : [{
+		source.children = rendered.value.length === 0 ? [] : [{
 			kind: "raw",
-			source: rendered.success
+			source: rendered.value
 		}];
-		return Result.succeed(void 0);
+		return Result.ok(void 0);
 	};
 	const applyInsertSnippet = (op) => {
 		const validSnippet = validateStaticSnippet(input.authoredSource, op.snippet);
-		if (Result.isFailure(validSnippet)) return validSnippet;
+		if (Result.isError(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;
+			if (Result.isError(resolvedRoot)) return Result.err(resolvedRoot.error);
+			parent = resolvedRoot.value;
 			insertionIndex = op.position === "before" ? 0 : parent.children.length;
 		} else {
 			const reference = resolveTarget(op.referenceId);
-			if (Result.isFailure(reference)) return Result.fail(reference.failure);
+			if (Result.isError(reference)) return Result.err(reference.error);
 			if (op.position === "inside") {
-				parent = reference.success.source;
+				parent = reference.value.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`));
+				const resolvedParent = resolveParentFor(reference.value.source);
+				if (Result.isError(resolvedParent)) return Result.err(resolvedParent.error);
+				parent = resolvedParent.value;
+				const referenceIndex = sourceElementParentIndex(parent, reference.value.source);
+				if (referenceIndex < 0) return Result.err(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);
+			if (Result.isError(resolvedParent)) return Result.err(resolvedParent.error);
 		}
 		parent.children.splice(insertionIndex, 0, {
 			kind: "raw",
 			source: op.snippet
 		});
-		return Result.succeed(void 0);
+		return Result.ok(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, {
+		if (Result.isError(resolved)) return Result.err(resolved.error);
+		if (resolved.value.source === root) return Result.err(sourceDiagnostic("tsx-unsupported-operation", "the document root cannot be duplicated"));
+		const parent = resolveParentFor(resolved.value.source);
+		if (Result.isError(parent)) return Result.err(parent.error);
+		const index = sourceElementParentIndex(parent.value, resolved.value.source);
+		if (index < 0) return Result.err(sourceDiagnostic("tsx-target-not-found", "the node is no longer attached"));
+		parent.value.children.splice(index + 1, 0, {
 			kind: "raw",
-			source: renderSourceElement(resolved.success.source, input.authoredSource)
+			source: renderSourceElement(resolved.value.source, input.authoredSource)
 		});
-		return Result.succeed(void 0);
+		return Result.ok(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;
+		if (Result.isError(resolved)) return Result.err(resolved.error);
+		if (resolved.value.source === root) return Result.err(sourceDiagnostic("tsx-unsupported-operation", "the document root cannot be removed"));
+		const parent = resolveParentFor(resolved.value.source);
+		if (Result.isError(parent)) return Result.err(parent.error);
+		if (!detachSourceElement(resolved.value.source)) return Result.err(sourceDiagnostic("tsx-target-not-found", `node "${op.nodeId}" is no longer attached`));
+		const emittedNode = resolved.value.emitted;
 		removeEmittedSubtree(virtualAttributes, emittedNode);
-		return Result.succeed(void 0);
+		return Result.ok(void 0);
 	};
 	const applyMove = (op) => {
 		const moved = resolveTarget(op.nodeId);
-		if (Result.isFailure(moved)) return Result.fail(moved.failure);
+		if (Result.isError(moved)) return Result.err(moved.error);
 		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);
+		if (Result.isError(parent)) return Result.err(parent.error);
+		if (moved.value.source === root) return Result.err(sourceDiagnostic("tsx-unsupported-operation", "the document root cannot be moved"));
+		if (moved.value.source === parent.value.source || activeDescendant(moved.value.source, parent.value.source)) return Result.err(sourceDiagnostic("tsx-unsupported-operation", "a node cannot be moved into itself or its descendants"));
+		const oldParent = resolveParentFor(moved.value.source);
+		if (Result.isError(oldParent)) return Result.err(oldParent.error);
+		const oldIndex = sourceElementParentIndex(oldParent.value, moved.value.source);
+		if (oldIndex < 0) return Result.err(sourceDiagnostic("tsx-target-not-found", `node "${op.nodeId}" is no longer attached`));
+		oldParent.value.children.splice(oldIndex, 1);
+		moved.value.source.parent = null;
+		const insertionIndex = elementChildInsertionIndex(parent.value.source.children, op.insertionIndex);
+		attachSourceElement(moved.value.source, parent.value.source, insertionIndex);
+		return Result.ok(void 0);
 	};
 	for (const op of input.ops) {
 		let result;
-		switch (op._tag) {
+		switch (op.type) {
 			case "setProp":
 				result = applySetProp(op);
 				break;
@@ -972,12 +972,12 @@ const applyTsxSmlOps = (input) => {
 			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"));
+			case "insertBlock": result = Result.err(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);
+		if (Result.isError(result)) return sourceFailure(result.error);
 	}
 	const renderedRoot = renderSourceElement(root, input.authoredSource);
-	return Result.succeed(`${input.authoredSource.slice(0, root.start)}${renderedRoot}${input.authoredSource.slice(root.end)}`);
+	return Result.ok(`${input.authoredSource.slice(0, root.start)}${renderedRoot}${input.authoredSource.slice(root.end)}`);
 };
 //#endregion
 export { TsxHeadingTraceError, TsxSmlOpsError, applyTsxSmlOps, replaceTsxHeadingText, traceTsxHeadingTarget };