@samva/markup 0.3.0 → 0.5.0

package/dist/input-schema.js

@@ -1,170 +1,2 @@
-import { Validator } from "@cfworker/json-schema";
-import applicator from "ajv/dist/refs/json-schema-2020-12/meta/applicator.json" with { type: "json" };
-import content from "ajv/dist/refs/json-schema-2020-12/meta/content.json" with { type: "json" };
-import core from "ajv/dist/refs/json-schema-2020-12/meta/core.json" with { type: "json" };
-import format_annotation from "ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json" with { type: "json" };
-import meta_data from "ajv/dist/refs/json-schema-2020-12/meta/meta-data.json" with { type: "json" };
-import unevaluated from "ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json" with { type: "json" };
-import validation from "ajv/dist/refs/json-schema-2020-12/meta/validation.json" with { type: "json" };
-import metaSchema from "ajv/dist/refs/json-schema-2020-12/schema.json" with { type: "json" };
-import { Predicate } from "effect";
-//#region src/input-schema.ts
-const meta = new Validator(metaSchema, "2020-12", false);
-for (const part of [
-	applicator,
-	content,
-	core,
-	format_annotation,
-	meta_data,
-	unevaluated,
-	validation
-]) meta.addSchema(part);
-/** JSON Schema dialect accepted by template publications. */
-const INPUT_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
-const canonicalJson = (value) => {
-	if (Array.isArray(value)) return value.map(canonicalJson);
-	if (Predicate.isObject(value)) return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, canonicalJson(item)]));
-	return value;
-};
-const annotations = /* @__PURE__ */ new Set([
-	"title",
-	"description",
-	"default",
-	"examples",
-	"deprecated",
-	"readOnly",
-	"writeOnly",
-	"$comment"
-]);
-const scalarKeywords = /* @__PURE__ */ new Set([
-	"$schema",
-	"$ref",
-	"type",
-	"enum",
-	"const",
-	"required",
-	"minProperties",
-	"maxProperties",
-	"minItems",
-	"maxItems",
-	"uniqueItems",
-	"minLength",
-	"maxLength",
-	"pattern",
-	"minimum",
-	"maximum",
-	"exclusiveMinimum",
-	"exclusiveMaximum",
-	"multipleOf"
-]);
-const schemaMaps = /* @__PURE__ */ new Set([
-	"properties",
-	"$defs",
-	"patternProperties",
-	"dependentSchemas"
-]);
-const schemaValues = /* @__PURE__ */ new Set([
-	"additionalProperties",
-	"items",
-	"contains",
-	"not",
-	"if",
-	"then",
-	"else",
-	"propertyNames"
-]);
-const schemaArrays = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-/** Check every schema position before deriving identity; unknown keywords never disappear. */
-const canonicalSchema = (schema, path = "#") => {
-	if (typeof schema === "boolean") return schema;
-	if (!Predicate.isObject(schema)) throw new TypeError(`Invalid schema at ${path}`);
-	const shape = meta.validate(schema);
-	if (!shape.valid) throw new TypeError(`Invalid JSON Schema at ${path}: ${JSON.stringify(shape.errors)}`);
-	const result = {};
-	for (const [key, value] of Object.entries(schema).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
-		if (annotations.has(key)) continue;
-		if (schemaMaps.has(key)) {
-			if (!Predicate.isObject(value)) throw new TypeError(`Invalid ${path}/${key}`);
-			result[key] = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, child]) => [name, canonicalSchema(child, `${path}/${key}/${name}`)]));
-		} else if (schemaValues.has(key)) result[key] = canonicalSchema(value, `${path}/${key}`);
-		else if (schemaArrays.has(key)) {
-			if (!Array.isArray(value)) throw new TypeError(`Invalid ${path}/${key}`);
-			result[key] = value.map((child, index) => canonicalSchema(child, `${path}/${key}/${index}`));
-		} else if (scalarKeywords.has(key)) {
-			if (key === "$ref" && (typeof value !== "string" || !(value === "#" || value.startsWith("#/")))) throw new TypeError(`Only local JSON Pointer references are supported at ${path}/$ref`);
-			if (key === "$schema" && value !== "https://json-schema.org/draft/2020-12/schema") throw new TypeError(`Expected JSON Schema 2020-12 at ${path}`);
-			result[key] = canonicalJson(value);
-		} else throw new TypeError(`Unsupported input schema keyword ${path}/${key}`);
-	}
-	return result;
-};
-/** Direct portable JSON Schema authoring; the caller declares its JSON input type. */
-const jsonSchema = (schema) => ({ "~standard": {
-	version: 1,
-	vendor: "samva-json-schema",
-	jsonSchema: {
-		input: () => schema,
-		output: () => schema
-	}
-} });
-/** Pinned Effect/Zod converters omit arbitrary refinements, so inspect those vendors' check metadata. */
-const rejectNonportableChecks = (source) => {
-	const vendor = source["~standard"].vendor;
-	if (vendor !== "effect" && vendor !== "zod") return;
-	const seen = /* @__PURE__ */ new WeakSet();
-	const visit = (value) => {
-		if (Array.isArray(value)) {
-			for (const child of value) visit(child);
-			return;
-		}
-		if (!Predicate.isObject(value) || seen.has(value)) return;
-		seen.add(value);
-		if (vendor === "zod" && Predicate.isObject(value._zod)) {
-			visit(value._zod.def);
-			return;
-		}
-		if (vendor === "effect" && value.encoding !== void 0) throw new TypeError("Nonportable Effect transform; use a JSON input schema without decoding transforms");
-		if (vendor === "effect" && value._tag === "Suspend") throw new TypeError("Unsupported suspended Effect converter; use local JSON Schema references");
-		if (vendor === "zod" && value.type === "lazy") throw new TypeError("Unsupported lazy Zod converter; author recursive input with local JSON Schema references");
-		if (vendor === "zod" && (value.check === "custom" || value.check === "overwrite" || [
-			"transform",
-			"default",
-			"prefault",
-			"catch"
-		].includes(String(value.type)))) throw new TypeError("Nonportable Zod refinement/transform; express constraints in JSON Schema");
-		if (vendor === "effect" && value._tag === "Filter" && (!Predicate.isObject(value.annotations) || typeof value.annotations.toJsonSchema !== "function")) throw new TypeError("Nonportable Effect refinement; provide a JSON Schema constraint");
-		for (const [key, child] of Object.entries(value)) if (key !== "~standard" && key !== "annotations") visit(child);
-	};
-	if (vendor === "effect" && Predicate.hasProperty(source, "ast")) visit(source.ast);
-	else visit(source);
-};
-/** Convert caller input, never validator output. Both conversion directions must be portable. */
-const inputSchema = (source) => {
-	rejectNonportableChecks(source);
-	const converter = source["~standard"].jsonSchema;
-	const schema = structuredClone(converter.input({ target: "draft-2020-12" }));
-	const canonical = canonicalSchema(schema);
-	const output = canonicalSchema(converter.output({ target: "draft-2020-12" }));
-	if (JSON.stringify(canonical) !== JSON.stringify(output)) throw new TypeError("Template schemas must preserve JSON input; input/output conversion differs");
-	const validator = new Validator(schema, "2020-12", false);
-	const validate = (value) => {
-		const result = validator.validate(value);
-		validate.errors = result.errors;
-		return result.valid;
-	};
-	validate.errors = [];
-	return {
-		schema,
-		validationIdentity: JSON.stringify(canonical),
-		validate
-	};
-};
-//#endregion
+import { n as inputSchema, r as jsonSchema, t as INPUT_SCHEMA_DIALECT } from "./input-schema-zjkgrXn2.js";
 export { INPUT_SCHEMA_DIALECT, inputSchema, jsonSchema };
-
-//# sourceMappingURL=input-schema.js.map

package/dist/interpolate.d.ts

@@ -1,16 +1,13 @@
-import { Schema } from "effect";
 //#region src/interpolate.d.ts
-declare const DocumentVariableTypeSchema: Schema.Literals<readonly ["string", "number", "boolean", "date", "array", "object"]>;
-type DocumentVariableType = typeof DocumentVariableTypeSchema.Type;
+type DocumentVariableType = "string" | "number" | "boolean" | "date" | "array" | "object";
 /** One entry of a template's declared variable schema. */
-declare const DocumentVariableSchema: Schema.Struct<{
-  readonly name: Schema.String;
-  readonly type: Schema.Literals<readonly ["string", "number", "boolean", "date", "array", "object"]>;
-  readonly required: Schema.Boolean;
-  readonly default: Schema.optional<Schema.Unknown>;
-  readonly description: Schema.optional<Schema.String>;
-}>;
-interface DocumentVariable extends Schema.Schema.Type<typeof DocumentVariableSchema> {}
+interface DocumentVariable {
+  readonly name: string;
+  readonly type: DocumentVariableType;
+  readonly required: boolean;
+  readonly default?: unknown;
+  readonly description?: string | undefined;
+}
 declare const variableReferencePattern: RegExp;
 declare const getVariableValue: (variables: Record<string, unknown>, variableSchema: ReadonlyArray<DocumentVariable>, name: string) => unknown;
 declare const stringifyVariable: (value: unknown) => string;
@@ -23,5 +20,5 @@ declare const interpolate: (text: string, variables: Record<string, unknown>, va
 declare const variableReferences: (text: string) => Set<string>;
 declare const addVariableReferences: (target: Set<string>, text: string) => void;
 //#endregion
-export { DocumentVariable, DocumentVariableSchema, DocumentVariableType, DocumentVariableTypeSchema, InterpolationResult, addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
+export { DocumentVariable, DocumentVariableType, InterpolationResult, addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
 //# sourceMappingURL=interpolate.d.ts.map

package/dist/interpolate.js

@@ -1,22 +1,4 @@
-import { Schema } from "effect";
 //#region src/interpolate.ts
-const limitedString = (maxLength) => Schema.String.check(Schema.isMaxLength(maxLength));
-const DocumentVariableTypeSchema = Schema.Literals([
-	"string",
-	"number",
-	"boolean",
-	"date",
-	"array",
-	"object"
-]);
-/** One entry of a template's declared variable schema. */
-const DocumentVariableSchema = Schema.Struct({
-	name: limitedString(128),
-	type: DocumentVariableTypeSchema,
-	required: Schema.Boolean,
-	default: Schema.optional(Schema.Unknown),
-	description: Schema.optional(limitedString(512))
-});
 const variableReferencePattern = /\$\{\s*\/?([\w.]+)\s*\}|\{\{\s*([\w.]+)\s*\}\}/g;
 const getVariableValue = (variables, variableSchema, name) => {
 	const schema = variableSchema.find((item) => item.name === name);
@@ -56,6 +38,6 @@ const addVariableReferences = (target, text) => {
 	variableReferences(text).forEach((name) => target.add(name));
 };
 //#endregion
-export { DocumentVariableSchema, DocumentVariableTypeSchema, addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
+export { addVariableReferences, getVariableValue, interpolate, stringifyVariable, variableReferencePattern, variableReferences };
 
 //# sourceMappingURL=interpolate.js.map

package/dist/jsx-dev-runtime.d.ts

@@ -1,5 +1,5 @@
-import { r as JsxSource } from "./source-locations-BCJQnIfU.js";
-import { a as JsxResult, i as JSX, n as Fragment, t as Component } from "./jsx-runtime-C5k_Zq0A.js";
+import { r as JsxSource } from "./source-locations-D6Te6Gy1.js";
+import { a as JsxResult, i as JSX, n as Fragment, t as Component } from "./jsx-runtime-BI4gI19E.js";
 //#region src/jsx-dev-runtime.d.ts
 interface JsxDevProps {
   readonly children?: unknown;

package/dist/{jsx-runtime-C5k_Zq0A.d.ts → jsx-runtime-BI4gI19E.d.ts}

@@ -1,5 +1,5 @@
-import { E as SmlNode, m as ElementNode, n as Attribute } from "./ast-63I-VLQx.js";
-import { s as VariableRef } from "./variables-if1VrV34.js";
+import { f as ElementNode, n as Attribute, x as SmlNode } from "./ast-BLybiDxp.js";
+import { s as VariableRef } from "./variables-BnKs1iqb.js";
 //#region src/jsx-runtime.d.ts
 /** A component is a plain function of its props that returns a draft node. */
 type Component<P> = (props: P) => SmlNode;
@@ -54,4 +54,4 @@ declare namespace JSX {
 }
 //#endregion
 export { JsxResult as a, elementDraft as c, normalizeChildren as d, JSX as i, jsx as l, Fragment as n, SmlChild as o, FragmentDraft as r, SmlChildren as s, Component as t, jsxs as u };
-//# sourceMappingURL=jsx-runtime-C5k_Zq0A.d.ts.map
+//# sourceMappingURL=jsx-runtime-BI4gI19E.d.ts.map

package/dist/jsx-runtime.d.ts

@@ -1,2 +1,2 @@
-import { a as JsxResult, c as elementDraft, d as normalizeChildren, i as JSX, l as jsx, n as Fragment, o as SmlChild, r as FragmentDraft, s as SmlChildren, t as Component, u as jsxs } from "./jsx-runtime-C5k_Zq0A.js";
+import { a as JsxResult, c as elementDraft, d as normalizeChildren, i as JSX, l as jsx, n as Fragment, o as SmlChild, r as FragmentDraft, s as SmlChildren, t as Component, u as jsxs } from "./jsx-runtime-BI4gI19E.js";
 export { Component, Fragment, FragmentDraft, JSX, JsxResult, SmlChild, SmlChildren, elementDraft, jsx, jsxs, normalizeChildren };

package/dist/jsx-runtime.js

@@ -1,14 +1,14 @@
+import { t as hasProperty } from "./guards-eV1qLbf2.js";
 import { JSX_SOURCE_LOCATION_PROP, attachJsxSourceLocation, completeJsxSourceLocation } from "./source-locations.js";
 import { VARIABLE_REF, isVariableRef } from "./variables.js";
-import { Predicate } from "effect";
 //#region src/jsx-runtime.ts
 const PLACEHOLDER_SPAN = {
 	start: 0,
 	end: 0
 };
-const isFragmentDraft = (value) => Predicate.hasProperty(value, "kind") && value.kind === "fragment";
+const isFragmentDraft = (value) => hasProperty(value, "kind") && value.kind === "fragment";
 const isSmlNode = (value) => {
-	if (!Predicate.hasProperty(value, "kind")) return false;
+	if (!hasProperty(value, "kind")) return false;
 	const kind = value.kind;
 	return kind === "element" || kind === "text" || kind === "interpolation";
 };

package/dist/model.d.ts

@@ -1,39 +1,24 @@
-import { O as SmlTag, w as SmlDocument } from "./ast-63I-VLQx.js";
-import { Result, Schema } from "effect";
+import { S as SmlTag, b as SmlDocument } from "./ast-BLybiDxp.js";
+import { Result } from "better-result";
 //#region src/model.d.ts
-declare const SmlNodeKeyAttrsSchema: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;
-declare const SmlNodeIndexEntrySchema: Schema.Struct<{
-  readonly id: Schema.String;
-  readonly tag: Schema.String;
-  readonly order: Schema.Finite;
-  readonly parentId: Schema.NullOr<Schema.String>;
-  readonly childIndex: Schema.Finite;
-  readonly depth: Schema.Finite;
-  readonly path: Schema.String;
-  readonly textPreview: Schema.String;
-  readonly attrs: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;
-}>;
-type SmlNodeIndexEntry = typeof SmlNodeIndexEntrySchema.Type & {
+/** The subset of an element's attributes the navigator and agent tools read. */
+type SmlNodeKeyAttrs = Readonly<Record<string, string | number>>;
+interface SmlNodeIndexEntry {
+  readonly id: string;
   readonly tag: SmlTag;
-};
-declare const SmlNodeIndexSchema: Schema.Struct<{
-  readonly nodes: Schema.$Array<Schema.Struct<{
-    readonly id: Schema.String;
-    readonly tag: Schema.String;
-    readonly order: Schema.Finite;
-    readonly parentId: Schema.NullOr<Schema.String>;
-    readonly childIndex: Schema.Finite;
-    readonly depth: Schema.Finite;
-    readonly path: Schema.String;
-    readonly textPreview: Schema.String;
-    readonly attrs: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite]>>;
-  }>>;
-}>;
-type SmlNodeIndex = typeof SmlNodeIndexSchema.Type & {
+  readonly order: number;
+  readonly parentId: string | null;
+  readonly childIndex: number;
+  readonly depth: number;
+  readonly path: string;
+  readonly textPreview: string;
+  readonly attrs: SmlNodeKeyAttrs;
+}
+interface SmlNodeIndex {
   readonly nodes: readonly SmlNodeIndexEntry[];
-};
+}
 declare const deriveNodeIndexFromDocument: (document: SmlDocument) => SmlNodeIndex;
-declare const deriveNodeIndex: (source: string) => Result.Result<SmlNodeIndex, string>;
+declare const deriveNodeIndex: (source: string) => Result<SmlNodeIndex, string>;
 //#endregion
-export { SmlNodeIndex, SmlNodeIndexEntry, SmlNodeIndexEntrySchema, SmlNodeIndexSchema, SmlNodeKeyAttrsSchema, deriveNodeIndex, deriveNodeIndexFromDocument };
+export { SmlNodeIndex, SmlNodeIndexEntry, SmlNodeKeyAttrs, deriveNodeIndex, deriveNodeIndexFromDocument };
 //# sourceMappingURL=model.d.ts.map

package/dist/model.js

@@ -1,19 +1,6 @@
 import { parseSml } from "./parser.js";
-import { Result, Schema } from "effect";
+import { Result } from "better-result";
 //#region src/model.ts
-const SmlNodeKeyAttrsSchema = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Finite]));
-const SmlNodeIndexEntrySchema = Schema.Struct({
-	id: Schema.String,
-	tag: Schema.String,
-	order: Schema.Finite,
-	parentId: Schema.NullOr(Schema.String),
-	childIndex: Schema.Finite,
-	depth: Schema.Finite,
-	path: Schema.String,
-	textPreview: Schema.String,
-	attrs: SmlNodeKeyAttrsSchema
-});
-const SmlNodeIndexSchema = Schema.Struct({ nodes: Schema.Array(SmlNodeIndexEntrySchema) });
 const KEY_ATTRS = /* @__PURE__ */ new Set([
 	"alt",
 	"class",
@@ -81,10 +68,10 @@ const deriveNodeIndexFromDocument = (document) => {
 };
 const deriveNodeIndex = (source) => {
 	const parsed = parseSml(source);
-	if (Result.isFailure(parsed)) return Result.fail(parsed.failure.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
-	return Result.succeed(deriveNodeIndexFromDocument(parsed.success));
+	if (Result.isError(parsed)) return Result.err(parsed.error.diagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+	return Result.ok(deriveNodeIndexFromDocument(parsed.value));
 };
 //#endregion
-export { SmlNodeIndexEntrySchema, SmlNodeIndexSchema, SmlNodeKeyAttrsSchema, deriveNodeIndex, deriveNodeIndexFromDocument };
+export { deriveNodeIndex, deriveNodeIndexFromDocument };
 
 //# sourceMappingURL=model.js.map

package/dist/ops.d.ts

@@ -1,184 +1,90 @@
-import { o as SmlParseError } from "./diagnostics-oveE-laV.js";
-import { E as SmlNode } from "./ast-63I-VLQx.js";
-import { Result, Schema } from "effect";
+import { i as SmlParseError, t as Diagnostic } from "./diagnostics-CqepLcpI.js";
+import { S as SmlTag, r as AttributeValue, x as SmlNode } from "./ast-BLybiDxp.js";
+import { Result } from "better-result";
 //#region src/ops.d.ts
+/** Where an inserted node lands relative to its reference node. */
+type SmlInsertPosition = "before" | "after" | "inside";
+interface SetPropOp {
+  readonly type: "setProp";
+  readonly nodeId: string;
+  readonly name: string;
+  readonly value: AttributeValue | null;
+}
+/**
+ * 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.
+ */
+interface SetChildrenOp {
+  readonly type: "setChildren";
+  readonly nodeId: string;
+  readonly children: ReadonlyArray<SmlNode>;
+}
+interface InsertBlockOp {
+  readonly type: "insertBlock";
+  readonly tag: SmlTag;
+  readonly referenceId: string | null;
+  readonly position: SmlInsertPosition;
+}
+interface InsertSnippetOp {
+  readonly type: "insertSnippet";
+  readonly snippet: string;
+  readonly referenceId: string | null;
+  readonly position: SmlInsertPosition;
+}
+/**
+ * `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.
+ */
+interface MoveNodeOp {
+  readonly type: "moveNode";
+  readonly nodeId: string;
+  readonly targetParentId: string;
+  readonly insertionIndex: number;
+}
+interface DuplicateNodeOp {
+  readonly type: "duplicateNode";
+  readonly nodeId: string;
+}
+interface RemoveNodeOp {
+  readonly type: "removeNode";
+  readonly nodeId: 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}.
  */
-declare const SmlOpSchema: Schema.Union<readonly [Schema.TaggedStruct<"setProp", {
-  readonly nodeId: Schema.String;
-  readonly name: Schema.String;
-  readonly value: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"string">;
-    readonly value: Schema.String;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"number">;
-    readonly value: Schema.Finite;
-  }>]>>;
-}>, Schema.TaggedStruct<"setChildren", {
-  readonly nodeId: Schema.String;
-  readonly children: Schema.$Array<Schema.Codec<SmlNode, SmlNode, never, never>>;
-}>, Schema.TaggedStruct<"insertBlock", {
-  readonly tag: Schema.Literals<readonly ["Email", "Subject", "Preview", "Container", "Section", "Row", "Column", "Heading", "Text", "Button", "Image", "Divider", "Spacer", "List", "ListItem", "If", "Else", "strong", "em", "a", "Source", "Sms", "WhatsApp", "Header", "Body", "Footer", "Buttons"]>;
-  readonly referenceId: Schema.NullOr<Schema.String>;
-  readonly position: Schema.Literals<readonly ["before", "after", "inside"]>;
-}>, Schema.TaggedStruct<"insertSnippet", {
-  readonly snippet: Schema.String;
-  readonly referenceId: Schema.NullOr<Schema.String>;
-  readonly position: Schema.Literals<readonly ["before", "after", "inside"]>;
-}>, Schema.TaggedStruct<"moveNode", {
-  readonly nodeId: Schema.String;
-  readonly targetParentId: Schema.String;
-  readonly insertionIndex: Schema.Finite;
-}>, Schema.TaggedStruct<"duplicateNode", {
-  readonly nodeId: Schema.String;
-}>, Schema.TaggedStruct<"removeNode", {
-  readonly nodeId: Schema.String;
-}>]>;
-type SmlOp = typeof SmlOpSchema.Type;
-declare const SmlOpResultSchema: Schema.Struct<{
-  readonly index: Schema.Finite;
-  readonly status: Schema.Literals<readonly ["applied", "failed"]>;
-  readonly op: Schema.Union<readonly [Schema.TaggedStruct<"setProp", {
-    readonly nodeId: Schema.String;
-    readonly name: Schema.String;
-    readonly value: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"string">;
-      readonly value: Schema.String;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"number">;
-      readonly value: Schema.Finite;
-    }>]>>;
-  }>, Schema.TaggedStruct<"setChildren", {
-    readonly nodeId: Schema.String;
-    readonly children: Schema.$Array<Schema.Codec<SmlNode, SmlNode, never, never>>;
-  }>, Schema.TaggedStruct<"insertBlock", {
-    readonly tag: Schema.Literals<readonly ["Email", "Subject", "Preview", "Container", "Section", "Row", "Column", "Heading", "Text", "Button", "Image", "Divider", "Spacer", "List", "ListItem", "If", "Else", "strong", "em", "a", "Source", "Sms", "WhatsApp", "Header", "Body", "Footer", "Buttons"]>;
-    readonly referenceId: Schema.NullOr<Schema.String>;
-    readonly position: Schema.Literals<readonly ["before", "after", "inside"]>;
-  }>, Schema.TaggedStruct<"insertSnippet", {
-    readonly snippet: Schema.String;
-    readonly referenceId: Schema.NullOr<Schema.String>;
-    readonly position: Schema.Literals<readonly ["before", "after", "inside"]>;
-  }>, Schema.TaggedStruct<"moveNode", {
-    readonly nodeId: Schema.String;
-    readonly targetParentId: Schema.String;
-    readonly insertionIndex: Schema.Finite;
-  }>, Schema.TaggedStruct<"duplicateNode", {
-    readonly nodeId: Schema.String;
-  }>, Schema.TaggedStruct<"removeNode", {
-    readonly nodeId: Schema.String;
-  }>]>;
-  readonly diagnostics: Schema.$Array<Schema.Struct<{
-    readonly code: Schema.String;
-    readonly message: Schema.String;
-    readonly span: Schema.Struct<{
-      readonly start: Schema.Finite;
-      readonly end: Schema.Finite;
-    }>;
-    readonly repair: Schema.optional<Schema.Struct<{
-      readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
-      readonly raw: Schema.optional<Schema.String>;
-      readonly suggestions: Schema.$Array<Schema.String>;
-      readonly explanation: Schema.String;
-    }>>;
-  }>>;
-}>;
-interface SmlOpResult extends Schema.Schema.Type<typeof SmlOpResultSchema> {}
-declare const ApplyOpsResultSchema: Schema.Struct<{
-  readonly source: Schema.String;
-  readonly revision: Schema.String;
-  readonly diagnostics: Schema.$Array<Schema.Struct<{
-    readonly code: Schema.String;
-    readonly message: Schema.String;
-    readonly span: Schema.Struct<{
-      readonly start: Schema.Finite;
-      readonly end: Schema.Finite;
-    }>;
-    readonly repair: Schema.optional<Schema.Struct<{
-      readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
-      readonly raw: Schema.optional<Schema.String>;
-      readonly suggestions: Schema.$Array<Schema.String>;
-      readonly explanation: Schema.String;
-    }>>;
-  }>>;
-  readonly results: Schema.$Array<Schema.Struct<{
-    readonly index: Schema.Finite;
-    readonly status: Schema.Literals<readonly ["applied", "failed"]>;
-    readonly op: Schema.Union<readonly [Schema.TaggedStruct<"setProp", {
-      readonly nodeId: Schema.String;
-      readonly name: Schema.String;
-      readonly value: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"string">;
-        readonly value: Schema.String;
-      }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"number">;
-        readonly value: Schema.Finite;
-      }>]>>;
-    }>, Schema.TaggedStruct<"setChildren", {
-      readonly nodeId: Schema.String;
-      readonly children: Schema.$Array<Schema.Codec<SmlNode, SmlNode, never, never>>;
-    }>, Schema.TaggedStruct<"insertBlock", {
-      readonly tag: Schema.Literals<readonly ["Email", "Subject", "Preview", "Container", "Section", "Row", "Column", "Heading", "Text", "Button", "Image", "Divider", "Spacer", "List", "ListItem", "If", "Else", "strong", "em", "a", "Source", "Sms", "WhatsApp", "Header", "Body", "Footer", "Buttons"]>;
-      readonly referenceId: Schema.NullOr<Schema.String>;
-      readonly position: Schema.Literals<readonly ["before", "after", "inside"]>;
-    }>, Schema.TaggedStruct<"insertSnippet", {
-      readonly snippet: Schema.String;
-      readonly referenceId: Schema.NullOr<Schema.String>;
-      readonly position: Schema.Literals<readonly ["before", "after", "inside"]>;
-    }>, Schema.TaggedStruct<"moveNode", {
-      readonly nodeId: Schema.String;
-      readonly targetParentId: Schema.String;
-      readonly insertionIndex: Schema.Finite;
-    }>, Schema.TaggedStruct<"duplicateNode", {
-      readonly nodeId: Schema.String;
-    }>, Schema.TaggedStruct<"removeNode", {
-      readonly nodeId: Schema.String;
-    }>]>;
-    readonly diagnostics: Schema.$Array<Schema.Struct<{
-      readonly code: Schema.String;
-      readonly message: Schema.String;
-      readonly span: Schema.Struct<{
-        readonly start: Schema.Finite;
-        readonly end: Schema.Finite;
-      }>;
-      readonly repair: Schema.optional<Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
-        readonly raw: Schema.optional<Schema.String>;
-        readonly suggestions: Schema.$Array<Schema.String>;
-        readonly explanation: Schema.String;
-      }>>;
-    }>>;
-  }>>;
-}>;
-interface ApplyOpsResult extends Schema.Schema.Type<typeof ApplyOpsResultSchema> {}
+type SmlOp = SetPropOp | SetChildrenOp | InsertBlockOp | InsertSnippetOp | MoveNodeOp | DuplicateNodeOp | RemoveNodeOp;
+interface SmlOpResult {
+  readonly index: number;
+  readonly status: "applied" | "failed";
+  readonly op: SmlOp;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+interface ApplyOpsResult {
+  readonly source: string;
+  readonly revision: string;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  readonly results: ReadonlyArray<SmlOpResult>;
+}
 interface ApplyOpsOptions {
   readonly expectedRevision?: string | number | undefined;
   readonly currentRevision?: string | number | undefined;
 }
-declare const SmlOpError_base: Schema.Class<SmlOpError, Schema.TaggedStruct<"SmlOpError", {
-  readonly diagnostics: Schema.$Array<Schema.Struct<{
-    readonly code: Schema.String;
-    readonly message: Schema.String;
-    readonly span: Schema.Struct<{
-      readonly start: Schema.Finite;
-      readonly end: Schema.Finite;
-    }>;
-    readonly repair: Schema.optional<Schema.Struct<{
-      readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
-      readonly raw: Schema.optional<Schema.String>;
-      readonly suggestions: Schema.$Array<Schema.String>;
-      readonly explanation: Schema.String;
-    }>>;
-  }>>;
-}>, import("effect/Cause").YieldableError>;
-declare class SmlOpError extends SmlOpError_base {
-  get message(): string;
+declare const SmlOpError_base: import("better-result").TaggedErrorClass<"SmlOpError">;
+declare class SmlOpError extends SmlOpError_base<{
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  readonly message: string;
+}> {
+  constructor(args: {
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+  });
 }
 declare const sourceRevision: (source: string) => string;
-declare const normalizeSml: (source: string) => Result.Result<string, SmlParseError>;
+declare const normalizeSml: (source: string) => Result<string, SmlParseError>;
 /**
  * Apply a batch of ops to SML source, returning the rewritten source, its new
  * revision, and a per-op result.
@@ -201,8 +107,8 @@ declare const normalizeSml: (source: string) => Result.Result<string, SmlParseEr
  * as an independent validity gate; a failing op is recorded as `failed` and
  * does not advance the working document.
  */
-declare const applyOps: (source: string, ops: readonly SmlOp[], options?: ApplyOpsOptions) => Result.Result<ApplyOpsResult, SmlOpError>;
-declare const applyOp: (source: string, op: SmlOp, options?: ApplyOpsOptions) => Result.Result<ApplyOpsResult, SmlOpError>;
+declare const applyOps: (source: string, ops: readonly SmlOp[], options?: ApplyOpsOptions) => Result<ApplyOpsResult, SmlOpError>;
+declare const applyOp: (source: string, op: SmlOp, options?: ApplyOpsOptions) => Result<ApplyOpsResult, SmlOpError>;
 //#endregion
-export { ApplyOpsOptions, ApplyOpsResult, ApplyOpsResultSchema, SmlOp, SmlOpError, SmlOpResult, SmlOpResultSchema, SmlOpSchema, applyOp, applyOps, normalizeSml, sourceRevision };
+export { ApplyOpsOptions, ApplyOpsResult, DuplicateNodeOp, InsertBlockOp, InsertSnippetOp, MoveNodeOp, RemoveNodeOp, SetChildrenOp, SetPropOp, SmlInsertPosition, SmlOp, SmlOpError, SmlOpResult, applyOp, applyOps, normalizeSml, sourceRevision };
 //# sourceMappingURL=ops.d.ts.map