@samva/markup 0.4.0 → 0.5.0

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