@samva/markup 0.4.0 → 0.6.0

package/dist/ops.js

@@ -1,546 +1,2 @@
-import { DiagnosticSchema } from "./diagnostics.js";
-import { AttributeValueSchema, SML_TAGS, SmlNodeSchema, documentChannel } from "./ast.js";
-import { CHANNEL_TAG_SPECS, allowedChildren, parseSml } from "./parser.js";
-import { compileSml } from "./compile.js";
-import { a as isBreakingCompatibilityCheck, r as checkSmlCompatibility } from "./checks-DXuERO4B.js";
-import { printSml } from "./printer.js";
-import { Result, Schema } from "effect";
-//#region src/ops.ts
-const InsertPositionSchema = Schema.Literals([
-	"before",
-	"after",
-	"inside"
-]);
-const SetPropOpSchema = Schema.TaggedStruct("setProp", {
-	nodeId: Schema.String,
-	name: Schema.String,
-	value: Schema.NullOr(AttributeValueSchema)
-});
-/**
-* Replace a node's complete child list. The normal print → parse → compile
-* preflight remains the authority on whether the replacement satisfies the
-* target's content model.
-*/
-const SetChildrenOpSchema = Schema.TaggedStruct("setChildren", {
-	nodeId: Schema.String,
-	children: Schema.Array(SmlNodeSchema)
-});
-const InsertBlockOpSchema = Schema.TaggedStruct("insertBlock", {
-	tag: Schema.Literals(SML_TAGS),
-	referenceId: Schema.NullOr(Schema.String),
-	position: InsertPositionSchema
-});
-const InsertSnippetOpSchema = Schema.TaggedStruct("insertSnippet", {
-	snippet: Schema.String,
-	referenceId: Schema.NullOr(Schema.String),
-	position: InsertPositionSchema
-});
-/**
-* `insertionIndex` is an element-child index into `targetParentId` evaluated
-* AFTER the moved node has left its old position — the lifted-out model, so a
-* same-parent caller must compute the index against the sibling list without
-* the node. Indexes past the end append.
-*/
-const MoveNodeOpSchema = Schema.TaggedStruct("moveNode", {
-	nodeId: Schema.String,
-	targetParentId: Schema.String,
-	insertionIndex: Schema.Finite
-});
-const DuplicateNodeOpSchema = Schema.TaggedStruct("duplicateNode", { nodeId: Schema.String });
-const RemoveNodeOpSchema = Schema.TaggedStruct("removeNode", { nodeId: Schema.String });
-/**
-* A single edit against SML source. `nodeId` (and `referenceId` /
-* `targetParentId`) are positional ids from the source the caller last read;
-* within a batch they always resolve against that snapshot — see {@link applyOps}.
-*/
-const SmlOpSchema = Schema.Union([
-	SetPropOpSchema,
-	SetChildrenOpSchema,
-	InsertBlockOpSchema,
-	InsertSnippetOpSchema,
-	MoveNodeOpSchema,
-	DuplicateNodeOpSchema,
-	RemoveNodeOpSchema
-]);
-const SmlOpResultSchema = Schema.Struct({
-	index: Schema.Finite,
-	status: Schema.Literals(["applied", "failed"]),
-	op: SmlOpSchema,
-	diagnostics: Schema.Array(DiagnosticSchema)
-});
-const ApplyOpsResultSchema = Schema.Struct({
-	source: Schema.String,
-	revision: Schema.String,
-	diagnostics: Schema.Array(DiagnosticSchema),
-	results: Schema.Array(SmlOpResultSchema)
-});
-var SmlOpError = class extends Schema.TaggedError()("SmlOpError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
-	get message() {
-		return this.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
-	}
-};
-const zeroSpan = {
-	start: 0,
-	end: 0
-};
-const diagnostic = (code, message, span = zeroSpan) => ({
-	code,
-	message,
-	span
-});
-const cloneAttribute = (attribute) => ({ ...attribute });
-/**
-* Deep-copy a subtree, blanking every id to "". A duplicated node must not
-* alias the original's object graph or share its ids: batch ids resolve
-* against the pre-batch snapshot, and mapElement transforms every node whose
-* id matches — so two live copies sharing an id would both be rewritten by a
-* later op. Blank ids make the clone unaddressable (like any freshly created
-* node) until the next reprint reassigns positional ids.
-*/
-const cloneSubtree = (node) => {
-	if (node.kind === "element") return {
-		...node,
-		id: "",
-		attributes: node.attributes.map(cloneAttribute),
-		children: node.children.map(cloneSubtree)
-	};
-	return {
-		...node,
-		id: ""
-	};
-};
-const makeAttribute = (name, value) => ({
-	name,
-	value,
-	span: zeroSpan,
-	valueSpan: zeroSpan
-});
-const classAttr = (value) => makeAttribute("class", {
-	kind: "string",
-	value
-});
-const sourceRevision = (source) => {
-	let hash = 2166136261;
-	for (let index = 0; index < source.length; index++) {
-		hash ^= source.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return `sml:${(hash >>> 0).toString(16).padStart(8, "0")}`;
-};
-const normalizeSml = (source) => {
-	const parsed = parseSml(source);
-	if (Result.isFailure(parsed)) return Result.fail(parsed.failure);
-	return Result.succeed(printSml(parsed.success));
-};
-const findElement = (node, nodeId) => {
-	if (node.kind !== "element") return null;
-	if (node.id === nodeId) return node;
-	for (const child of node.children) {
-		const found = findElement(child, nodeId);
-		if (found !== null) return found;
-	}
-	return null;
-};
-const mapElement = (node, targetId, transform) => {
-	if (node.kind !== "element") return node;
-	if (node.id === targetId) return transform(node);
-	return {
-		...node,
-		children: node.children.map((child) => mapElement(child, targetId, transform))
-	};
-};
-const transformElement = (document, targetId, transform) => {
-	if (findElement(document.root, targetId) === null) return Result.fail([diagnostic("op-target-not-found", `node "${targetId}" was not found in the current source`)]);
-	return Result.succeed({
-		...document,
-		root: mapElement(document.root, targetId, transform)
-	});
-};
-const setElementAttribute = (element, name, value) => {
-	const rest = element.attributes.filter((attribute) => attribute.name !== name);
-	if (value === null || value.kind === "string" && value.value === "") return {
-		...element,
-		attributes: rest
-	};
-	const next = makeAttribute(name, value);
-	const attributes = element.attributes.some((attribute) => attribute.name === name) ? element.attributes.map((attribute) => attribute.name === name ? next : cloneAttribute(attribute)) : [...element.attributes, next];
-	return {
-		...element,
-		attributes
-	};
-};
-const setImageSchemeSource = (document, nodeId, scheme, value) => transformElement(document, nodeId, (element) => {
-	if (element.tag !== "Image") return element;
-	const src = value?.kind === "string" ? value.value : "";
-	const children = element.children.filter((child) => !(child.kind === "element" && child.tag === "Source" && child.attributes.some((attribute) => attribute.name === "scheme" && attribute.value.kind === "string" && attribute.value.value === scheme)));
-	if (src === "") return {
-		...element,
-		children
-	};
-	const sourceNode = {
-		kind: "element",
-		id: "",
-		tag: "Source",
-		attributes: [makeAttribute("scheme", {
-			kind: "string",
-			value: scheme
-		}), makeAttribute("src", {
-			kind: "string",
-			value: src
-		})],
-		children: [],
-		span: zeroSpan
-	};
-	return {
-		...element,
-		children: [...children, sourceNode]
-	};
-});
-const setProp = (document, op) => {
-	if (op.name === "src:dark") return setImageSchemeSource(document, op.nodeId, "dark", op.value);
-	return transformElement(document, op.nodeId, (element) => {
-		const value = op.name === "class" && op.value?.kind === "string" ? {
-			kind: "string",
-			value: op.value.value.trim().replace(/\s+/g, " ")
-		} : op.value;
-		return setElementAttribute(element, op.name, value);
-	});
-};
-const setChildren = (document, op) => transformElement(document, op.nodeId, (element) => ({
-	...element,
-	children: [...op.children]
-}));
-const makeColumn = () => ({
-	kind: "element",
-	id: "",
-	tag: "Column",
-	attributes: [classAttr("px-8")],
-	children: [{
-		kind: "element",
-		id: "",
-		tag: "Text",
-		attributes: [classAttr("text-base text-gray-700")],
-		children: [{
-			kind: "text",
-			id: "",
-			value: "Column",
-			span: zeroSpan
-		}],
-		span: zeroSpan
-	}],
-	span: zeroSpan
-});
-const makeBlock = (tag) => {
-	const base = (attributes, children) => ({
-		kind: "element",
-		id: "",
-		tag,
-		attributes,
-		children,
-		span: zeroSpan
-	});
-	const text = (value) => ({
-		kind: "text",
-		id: "",
-		value,
-		span: zeroSpan
-	});
-	switch (tag) {
-		case "Heading": return base([makeAttribute("level", {
-			kind: "number",
-			value: 2
-		}), classAttr("text-xl text-gray-900")], [text("Heading")]);
-		case "Text": return base([classAttr("text-base text-gray-700")], [text("Add your text here.")]);
-		case "Button": return base([makeAttribute("href", {
-			kind: "string",
-			value: "https://example.com"
-		}), classAttr("bg-blue-600 text-white px-20 py-12 rounded-md")], [text("Button")]);
-		case "Image": return base([
-			makeAttribute("src", {
-				kind: "string",
-				value: "https://placehold.co/600x200"
-			}),
-			makeAttribute("alt", {
-				kind: "string",
-				value: ""
-			}),
-			makeAttribute("width", {
-				kind: "number",
-				value: 600
-			})
-		], []);
-		case "Divider": return base([classAttr("border-gray-200")], []);
-		case "Spacer": return base([makeAttribute("height", {
-			kind: "number",
-			value: 24
-		})], []);
-		case "Section": return base([classAttr("py-16")], [makeBlock("Text")]);
-		case "Container": return base([classAttr("bg-white p-24")], [makeBlock("Text")]);
-		case "Row": return base([], [makeColumn(), makeColumn()]);
-		default: return base([], []);
-	}
-};
-const elementChildIndexToNodeIndex = (children, insertionIndex) => {
-	if (insertionIndex <= 0) {
-		const firstElement = children.findIndex((child) => child.kind === "element");
-		return firstElement === -1 ? children.length : firstElement;
-	}
-	let elementIndex = 0;
-	for (let index = 0; index < children.length; index++) {
-		if (children[index]?.kind !== "element") continue;
-		if (elementIndex === insertionIndex) return index;
-		elementIndex++;
-	}
-	return children.length;
-};
-const insertChildren = (document, childrenToInsert, referenceId, position) => {
-	if (childrenToInsert.length === 0) return Result.fail([diagnostic("op-empty-insert", "insert operation produced no element nodes")]);
-	if (referenceId === null || referenceId === document.root.id) {
-		const children = position === "before" ? [...childrenToInsert, ...document.root.children] : [...document.root.children, ...childrenToInsert];
-		return Result.succeed({
-			...document,
-			root: {
-				...document.root,
-				children
-			}
-		});
-	}
-	if (findElement(document.root, referenceId) === null) return Result.fail([diagnostic("op-target-not-found", `node "${referenceId}" was not found in the current source`)]);
-	if (position === "inside") return transformElement(document, referenceId, (element) => ({
-		...element,
-		children: [...element.children, ...childrenToInsert]
-	}));
-	const insertInParent = (node) => {
-		if (node.kind !== "element") return node;
-		const index = node.children.findIndex((child) => child.kind === "element" && child.id === referenceId);
-		if (index >= 0) {
-			const at = position === "after" ? index + 1 : index;
-			return {
-				...node,
-				children: [
-					...node.children.slice(0, at),
-					...childrenToInsert,
-					...node.children.slice(at)
-				]
-			};
-		}
-		return {
-			...node,
-			children: node.children.map(insertInParent)
-		};
-	};
-	return Result.succeed({
-		...document,
-		root: insertInParent(document.root)
-	});
-};
-const insertBlock = (document, op) => insertChildren(document, [makeBlock(op.tag)], op.referenceId, op.position);
-const insertSnippet = (document, op) => {
-	const rootTag = document.root.tag;
-	const parsed = parseSml(`<${rootTag}>${op.snippet}</${rootTag}>`);
-	if (Result.isFailure(parsed)) return Result.fail(parsed.failure.diagnostics);
-	const children = parsed.success.root.children.filter((child) => child.kind === "element");
-	return insertChildren(document, children, op.referenceId, op.position);
-};
-const removeNodeById = (document, nodeId) => {
-	if (document.root.id === nodeId) return Result.fail([diagnostic("op-root-target", "the document root cannot be removed")]);
-	if (findElement(document.root, nodeId) === null) return Result.fail([diagnostic("op-target-not-found", `node "${nodeId}" was not found in the current source`)]);
-	const prune = (node) => {
-		if (node.kind !== "element") return node;
-		return {
-			...node,
-			children: node.children.filter((child) => !(child.kind === "element" && child.id === nodeId)).map(prune)
-		};
-	};
-	return Result.succeed({
-		...document,
-		root: prune(document.root)
-	});
-};
-const isDescendant = (ancestor, nodeId) => ancestor.children.some((child) => {
-	if (child.kind !== "element") return false;
-	return child.id === nodeId || isDescendant(child, nodeId);
-});
-const removeElement = (node, nodeId) => {
-	let removed = null;
-	const children = [];
-	for (const child of node.children) {
-		if (child.kind === "element" && child.id === nodeId) {
-			removed = child;
-			continue;
-		}
-		if (child.kind === "element") {
-			const result = removeElement(child, nodeId);
-			if (result.removed !== null) removed = result.removed;
-			children.push(result.node);
-		} else children.push(child);
-	}
-	return {
-		node: {
-			...node,
-			children
-		},
-		removed
-	};
-};
-const insertIntoParent = (node, targetParentId, insertionIndex, moved) => {
-	if (node.id === targetParentId) {
-		const at = elementChildIndexToNodeIndex(node.children, insertionIndex);
-		return {
-			...node,
-			children: [
-				...node.children.slice(0, at),
-				moved,
-				...node.children.slice(at)
-			]
-		};
-	}
-	return {
-		...node,
-		children: node.children.map((child) => child.kind === "element" ? insertIntoParent(child, targetParentId, insertionIndex, moved) : child)
-	};
-};
-const moveNode = (document, op) => {
-	if (document.root.id === op.nodeId) return Result.fail([diagnostic("op-root-target", "the document root cannot be moved")]);
-	const moved = findElement(document.root, op.nodeId);
-	if (moved === null) return Result.fail([diagnostic("op-target-not-found", `node "${op.nodeId}" was not found in the current source`)]);
-	const parent = findElement(document.root, op.targetParentId);
-	if (parent === null) return Result.fail([diagnostic("op-target-not-found", `target parent "${op.targetParentId}" was not found in the current source`)]);
-	if (moved.id === parent.id || isDescendant(moved, parent.id)) return Result.fail([diagnostic("op-invalid-reparent", "a node cannot be moved into itself or its descendants")]);
-	const channel = documentChannel(document);
-	const childModel = CHANNEL_TAG_SPECS[channel][parent.tag]?.content;
-	if (!(childModel === void 0 ? [] : allowedChildren(childModel)).includes(moved.tag)) return Result.fail([diagnostic("op-invalid-reparent", `<${moved.tag}> is not allowed directly inside <${parent.tag}>`, parent.span)]);
-	const { node: rootWithoutMoved, removed } = removeElement(document.root, op.nodeId);
-	if (removed === null) return Result.fail([diagnostic("op-target-not-found", `node "${op.nodeId}" was not found in the current source`)]);
-	return Result.succeed({
-		...document,
-		root: insertIntoParent(rootWithoutMoved, op.targetParentId, op.insertionIndex, removed)
-	});
-};
-const duplicateNode = (document, nodeId) => {
-	if (document.root.id === nodeId) return Result.fail([diagnostic("op-root-target", "the document root cannot be duplicated")]);
-	if (findElement(document.root, nodeId) === null) return Result.fail([diagnostic("op-target-not-found", `node "${nodeId}" was not found in the current source`)]);
-	const insertClone = (node) => {
-		if (node.kind !== "element") return node;
-		const index = node.children.findIndex((child) => child.kind === "element" && child.id === nodeId);
-		if (index >= 0) {
-			const clone = cloneSubtree(node.children[index]);
-			return {
-				...node,
-				children: [
-					...node.children.slice(0, index + 1),
-					clone,
-					...node.children.slice(index + 1)
-				]
-			};
-		}
-		return {
-			...node,
-			children: node.children.map(insertClone)
-		};
-	};
-	return Result.succeed({
-		...document,
-		root: insertClone(document.root)
-	});
-};
-const mutate = (document, op) => {
-	switch (op._tag) {
-		case "setProp": return setProp(document, op);
-		case "setChildren": return setChildren(document, op);
-		case "insertBlock": return insertBlock(document, op);
-		case "insertSnippet": return insertSnippet(document, op);
-		case "moveNode": return moveNode(document, op);
-		case "duplicateNode": return duplicateNode(document, op.nodeId);
-		case "removeNode": return removeNodeById(document, op.nodeId);
-	}
-};
-const preflight = (source) => {
-	const reparsed = parseSml(source);
-	if (Result.isFailure(reparsed)) return Result.fail(reparsed.failure.diagnostics);
-	const compiled = compileSml(reparsed.success);
-	if (Result.isFailure(compiled)) return Result.fail(compiled.failure.diagnostics);
-	const compatibilityErrors = checkSmlCompatibility({ source }).filter(isBreakingCompatibilityCheck).map((message) => diagnostic("compatibility-error", message));
-	if (compatibilityErrors.length > 0) return Result.fail(compatibilityErrors);
-	return Result.succeed(reparsed.success);
-};
-const failedResult = (index, op, diagnostics) => ({
-	index,
-	status: "failed",
-	op,
-	diagnostics: [...diagnostics]
-});
-/**
-* Apply a batch of ops to SML source, returning the rewritten source, its new
-* revision, and a per-op result.
-*
-* Id contract: every id in the batch resolves against the id-space of the
-* source the caller read (the `expectedRevision` snapshot). Ids are positional
-* (`n0..nN` in document order) and are NOT rewritten between ops, so:
-*
-* - An op cannot target a node created earlier in the same batch — freshly
-*   inserted/duplicated nodes carry a blank id until the next reprint reassigns
-*   positional ids, and are unaddressable within the batch (fails with
-*   `op-target-not-found`).
-* - After `duplicateNode`, the duplicated id still addresses the ORIGINAL (the
-*   first match in document order); the clone is a blank-id copy.
-* - Structural ops (insert/remove/move) do not shift the ids of the nodes that
-*   survive, so a later op targeting a surviving sibling lands on the intended
-*   node regardless of what earlier ops did.
-*
-* Each op is still preflighted (reprint, reparse, compile, compatibility check)
-* as an independent validity gate; a failing op is recorded as `failed` and
-* does not advance the working document.
-*/
-const applyOps = (source, ops, options) => {
-	const parsed = parseSml(source);
-	if (Result.isFailure(parsed)) return Result.fail(new SmlOpError({ diagnostics: parsed.failure.diagnostics }));
-	const currentRevision = String(options?.currentRevision ?? sourceRevision(source));
-	if (options?.expectedRevision !== void 0 && String(options.expectedRevision) !== currentRevision) {
-		const stale = diagnostic("stale-revision", `source revision changed from ${String(options.expectedRevision)} to ${currentRevision}`);
-		return Result.succeed({
-			source,
-			revision: currentRevision,
-			diagnostics: [stale],
-			results: ops.map((op, index) => failedResult(index, op, [stale]))
-		});
-	}
-	let currentSource = source;
-	let currentDocument = parsed.success;
-	const results = [];
-	const diagnostics = [];
-	ops.forEach((op, index) => {
-		const mutated = mutate(currentDocument, op);
-		if (Result.isFailure(mutated)) {
-			results.push(failedResult(index, op, mutated.failure));
-			diagnostics.push(...mutated.failure);
-			return;
-		}
-		const candidateSource = printSml(mutated.success);
-		const checked = preflight(candidateSource);
-		if (Result.isFailure(checked)) {
-			results.push(failedResult(index, op, checked.failure));
-			diagnostics.push(...checked.failure);
-			return;
-		}
-		currentSource = candidateSource;
-		currentDocument = mutated.success;
-		results.push({
-			index,
-			status: "applied",
-			op,
-			diagnostics: []
-		});
-	});
-	return Result.succeed({
-		source: currentSource,
-		revision: sourceRevision(currentSource),
-		diagnostics,
-		results
-	});
-};
-const applyOp = (source, op, options) => applyOps(source, [op], options);
-//#endregion
-export { ApplyOpsResultSchema, SmlOpError, SmlOpResultSchema, SmlOpSchema, applyOp, applyOps, normalizeSml, sourceRevision };
-
-//# sourceMappingURL=ops.js.map
+import { a as sourceRevision, i as normalizeSml, n as applyOp, r as applyOps, t as SmlOpError } from "./ops-2aiiYO7m.js";
+export { SmlOpError, applyOp, applyOps, normalizeSml, sourceRevision };

package/dist/{parser-CGBS73Gz.d.ts → parser-CQcASEyy.d.ts}

@@ -1,6 +1,6 @@
-import { o as SmlParseError } from "./diagnostics-oveE-laV.js";
-import { O as SmlTag, d as Channel, w as SmlDocument } from "./ast-63I-VLQx.js";
-import { Result } from "effect";
+import { i as SmlParseError } from "./diagnostics-OcQKQYSY.js";
+import { S as SmlTag, b as SmlDocument, l as Channel } from "./ast-BrDtApwS.js";
+import { Result } from "better-result";
 //#region src/limits.d.ts
 /** Hard ceilings shared by SML documents and standalone predicate parsing. */
 declare const SML_PARSER_LIMITS: {
@@ -390,7 +390,7 @@ declare const UNIVERSAL_ATTRIBUTES: {
 declare const UNIVERSAL_ATTRIBUTE_TAGS: ReadonlySet<SmlTag>;
 /** Tags a content model admits as direct children (public alongside the spec tables). */
 declare const allowedChildren: (model: ContentModel) => ReadonlyArray<SmlTag>;
-declare const parseSml: (source: string) => Result.Result<SmlDocument, SmlParseError>;
+declare const parseSml: (source: string) => Result<SmlDocument, SmlParseError>;
 //#endregion
 export { SMS_TAG_SPECS as a, UNIVERSAL_ATTRIBUTE_TAGS as c, parseSml as d, SML_PARSER_LIMITS as f, EMAIL_TAG_SPECS as i, WHATSAPP_TAG_SPECS as l, CHANNEL_TAG_SPECS as n, TagSpec as o, ContentModel as r, UNIVERSAL_ATTRIBUTES as s, AttributeSpec as t, allowedChildren as u };
-//# sourceMappingURL=parser-CGBS73Gz.d.ts.map
+//# sourceMappingURL=parser-CQcASEyy.d.ts.map

package/dist/parser.d.ts

@@ -1,2 +1,2 @@
-import { a as SMS_TAG_SPECS, c as UNIVERSAL_ATTRIBUTE_TAGS, d as parseSml, f as SML_PARSER_LIMITS, i as EMAIL_TAG_SPECS, l as WHATSAPP_TAG_SPECS, n as CHANNEL_TAG_SPECS, o as TagSpec, r as ContentModel, s as UNIVERSAL_ATTRIBUTES, t as AttributeSpec, u as allowedChildren } from "./parser-CGBS73Gz.js";
+import { a as SMS_TAG_SPECS, c as UNIVERSAL_ATTRIBUTE_TAGS, d as parseSml, f as SML_PARSER_LIMITS, i as EMAIL_TAG_SPECS, l as WHATSAPP_TAG_SPECS, n as CHANNEL_TAG_SPECS, o as TagSpec, r as ContentModel, s as UNIVERSAL_ATTRIBUTES, t as AttributeSpec, u as allowedChildren } from "./parser-CQcASEyy.js";
 export { AttributeSpec, CHANNEL_TAG_SPECS, ContentModel, EMAIL_TAG_SPECS, SML_PARSER_LIMITS, SMS_TAG_SPECS, TagSpec, UNIVERSAL_ATTRIBUTES, UNIVERSAL_ATTRIBUTE_TAGS, WHATSAPP_TAG_SPECS, allowedChildren, parseSml };

package/dist/parser.js

@@ -1,10 +1,10 @@
 import { SmlParseError } from "./diagnostics.js";
-import { a as printPredicate, i as parsePredicate, o as SML_PARSER_LIMITS } from "./predicate-CvkzT-a2.js";
+import { a as printPredicate, i as parsePredicate, o as SML_PARSER_LIMITS } from "./predicate-BI6uRRM-.js";
 import { CHANNEL_BY_ROOT_TAG, ROOT_TAGS, SML_TAGS, isRootTag } from "./ast.js";
 import { TokenKind, createLexer } from "./lexer.js";
-import { Result } from "effect";
+import { Result } from "better-result";
 //#region src/parser.ts
-const parserLimitFailure = (code, message, sourceLength) => Result.fail(new SmlParseError({ diagnostics: [{
+const parserLimitFailure = (code, message, sourceLength) => Result.err(new SmlParseError({ diagnostics: [{
 	code,
 	message,
 	span: {
@@ -649,15 +649,15 @@ const parseSml = (source) => {
 			const testAttribute = element.attributes[testIndex];
 			if (testAttribute.value.kind === "string") {
 				const parsed = parsePredicate(testAttribute.value.value, testAttribute.valueSpan.start);
-				if (Result.isFailure(parsed)) {
-					const first = parsed.failure[0];
+				if (Result.isError(parsed)) {
+					const first = parsed.error[0];
 					return fail(first.code, first.message, first.span);
 				}
 				element.attributes[testIndex] = {
 					...testAttribute,
 					value: {
 						kind: "string",
-						value: printPredicate(parsed.success)
+						value: printPredicate(parsed.value)
 					}
 				};
 			}
@@ -815,7 +815,7 @@ const parseSml = (source) => {
 			root = null;
 		}
 	}
-	if (root === null || diagnostic !== void 0) return Result.fail(new SmlParseError({ diagnostics: [diagnostic ?? {
+	if (root === null || diagnostic !== void 0) return Result.err(new SmlParseError({ diagnostics: [diagnostic ?? {
 		code: "parse-failed",
 		message: "parse failed",
 		span: {
@@ -824,7 +824,7 @@ const parseSml = (source) => {
 		}
 	}] }));
 	assignNodeIds(root);
-	return Result.succeed({
+	return Result.ok({
 		kind: "document",
 		root
 	});