@samva/markup 0.1.0

package/AGENTS.md

@@ -0,0 +1,8 @@
+# Samva Markup consumer guide
+
+Author TSX with `jsxImportSource: "@samva/markup"`. Import components from
+`@samva/markup/components` and variable types from `@samva/markup/variables`; a template file should
+default-export at most one template. Use documented package subpaths only.
+
+Samva templates emit SML for server-side compilation. Do not replace SML with precompiled HTML in
+CLI push workflows. Use `@samva/vite` for discovery, local preview, and `buildTemplates()`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arya Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @samva/markup
+
+Type-safe authoring and compilation primitives for Samva email, SMS, and WhatsApp templates. Use it
+directly for TSX templates or together with `@samva/vite` for the visual editor and project build.
+
+## Install
+
+```sh
+npm install --save-dev @samva/markup @samva/vite vite
+```
+
+Configure TypeScript to use the Samva JSX runtime:
+
+```json
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "jsxImportSource": "@samva/markup"
+  }
+}
+```
+
+Then author a default-exported template:
+
+```tsx
+import { Email, Heading, Text } from "@samva/markup/components";
+import type { Variables } from "@samva/markup/variables";
+
+export default function Welcome(v: Variables<{ firstName: string }>) {
+  return (
+    <Email>
+      <Heading level={1}>Welcome, {v.firstName}</Heading>
+      <Text>Thanks for joining Samva.</Text>
+    </Email>
+  );
+}
+```
+
+The public subpaths also expose the SML parser, printer, compiler, diagnostics, variables, theme
+primitives, channel compilers, and gallery preset data. Prefer the highest-level entrypoint that
+matches the task instead of depending on implementation files.

package/dist/ast-DAhnAvQN.d.ts

@@ -0,0 +1,120 @@
+import { c as SpanSchema } from "./diagnostics-oveE-laV.js";
+import { Schema } from "effect";
+//#region src/ast.d.ts
+declare const BLOCK_TAGS: readonly ["Email", "Subject", "Preview", "Container", "Section", "Row", "Column", "Heading", "Text", "Button", "Image", "Divider", "Spacer", "List", "ListItem", "If", "Else"];
+declare const INLINE_TAGS: readonly ["strong", "em", "a"];
+/** Email-only helper tags scoped by their parent primitive. */
+declare const AUXILIARY_TAGS: readonly ["Source"];
+/** Structured-channel tags: the sms/whatsapp vocabulary beyond shared If/Else. */
+declare const CHANNEL_TAGS: readonly ["Sms", "WhatsApp", "Header", "Body", "Footer", "Buttons"];
+declare const SML_TAGS: 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"];
+type BlockTag = (typeof BLOCK_TAGS)[number];
+type InlineTag = (typeof INLINE_TAGS)[number];
+type AuxiliaryTag = (typeof AUXILIARY_TAGS)[number];
+type ChannelTag = (typeof CHANNEL_TAGS)[number];
+type SmlTag = (typeof SML_TAGS)[number];
+/** Channels supported by the public SML document model. */
+type Channel = "email" | "sms" | "whatsapp";
+/** Resolved primary width for email documents that omit `<Email width={…}>`. */
+declare const DEFAULT_EMAIL_WIDTH = 600;
+/** Root tag → channel. The root tag IS the channel declaration. */
+declare const CHANNEL_BY_ROOT_TAG: {
+  readonly Email: "email";
+  readonly Sms: "sms";
+  readonly WhatsApp: "whatsapp";
+};
+type RootTag = keyof typeof CHANNEL_BY_ROOT_TAG;
+declare const ROOT_TAGS: ReadonlyArray<RootTag>;
+declare const isRootTag: (tag: string) => tag is RootTag;
+/** The channel a parsed document targets, read off its root tag. */
+declare const documentChannel: (document: SmlDocument) => Channel;
+declare const AttributeValueSchema: 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;
+}>]>;
+type AttributeValue = typeof AttributeValueSchema.Type;
+declare const AttributeSchema: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly value: 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;
+  }>]>;
+  /** Span of the whole `name="value"` pair. */
+  readonly span: Schema.Struct<{
+    readonly start: Schema.Finite;
+    readonly end: Schema.Finite;
+  }>;
+  /** Span of the value contents (inside quotes/braces) — class diagnostics point here. */
+  readonly valueSpan: Schema.Struct<{
+    readonly start: Schema.Finite;
+    readonly end: Schema.Finite;
+  }>;
+}>;
+interface Attribute extends Schema.Schema.Type<typeof AttributeSchema> {}
+declare const TextNodeSchema: Schema.Struct<{
+  readonly kind: Schema.Literal<"text">;
+  readonly id: Schema.String;
+  readonly value: Schema.String;
+  readonly span: Schema.Struct<{
+    readonly start: Schema.Finite;
+    readonly end: Schema.Finite;
+  }>;
+}>;
+interface TextNode extends Schema.Schema.Type<typeof TextNodeSchema> {}
+declare const InterpolationNodeSchema: Schema.Struct<{
+  readonly kind: Schema.Literal<"interpolation">;
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+  /** {{name}} vs ${name} — both today's syntaxes, preserved through print. */
+  readonly syntax: Schema.Literals<readonly ["curly", "dollar"]>;
+  readonly span: Schema.Struct<{
+    readonly start: Schema.Finite;
+    readonly end: Schema.Finite;
+  }>;
+}>;
+interface InterpolationNode extends Schema.Schema.Type<typeof InterpolationNodeSchema> {}
+interface ElementNode {
+  readonly kind: "element";
+  readonly id: string;
+  readonly tag: SmlTag;
+  readonly attributes: ReadonlyArray<Attribute>;
+  readonly children: ReadonlyArray<SmlNode>;
+  readonly span: typeof SpanSchema.Type;
+}
+type SmlNode = ElementNode | TextNode | InterpolationNode;
+declare const ElementNodeSchema: Schema.Codec<ElementNode>;
+declare const SmlNodeSchema: Schema.Codec<SmlNode>;
+declare const SmlDocumentSchema: Schema.Struct<{
+  readonly kind: Schema.Literal<"document">;
+  /** Always a root element: `<Email>`, `<Sms>`, or `<WhatsApp>`. */
+  readonly root: Schema.Codec<ElementNode, ElementNode, never, never>;
+}>;
+interface SmlDocument extends Schema.Schema.Type<typeof SmlDocumentSchema> {}
+declare const attributeValue: (node: ElementNode, name: string) => AttributeValue | undefined;
+declare const stringAttribute: (node: ElementNode, name: string) => string | undefined;
+declare const numberAttribute: (node: ElementNode, name: string) => number | undefined;
+/**
+ * The editor-only display label (navigator rename) — a universal attribute the
+ * compiler never reads, so it never reaches HTML. Absent when unset.
+ */
+declare const nodeLabel: (node: ElementNode) => string | undefined;
+/**
+ * The editor-only visibility flag. A `hidden="true"` node stays in the source
+ * (and the navigator, dimmed) but is dropped from every compile — preview and
+ * send alike. Any other value / absence means visible.
+ */
+declare const isHiddenNode: (node: ElementNode) => boolean;
+/**
+ * All variable references in the document: `{{name}}` / `${name}` in children
+ * and attribute values, plus names referenced by `<If test="...">` predicates.
+ */
+declare const collectVariableReferences: (document: SmlDocument) => ReadonlySet<string>;
+//#endregion
+export { attributeValue as A, SmlDocument as C, SmlTag as D, SmlNodeSchema as E, nodeLabel as F, numberAttribute as I, stringAttribute as L, documentChannel as M, isHiddenNode as N, TextNode as O, isRootTag as P, SML_TAGS as S, SmlNode as T, InlineTag as _, AttributeValueSchema as a, ROOT_TAGS as b, BlockTag as c, Channel as d, ChannelTag as f, INLINE_TAGS as g, ElementNodeSchema as h, AttributeValue as i, collectVariableReferences as j, TextNodeSchema as k, CHANNEL_BY_ROOT_TAG as l, ElementNode as m, Attribute as n, AuxiliaryTag as o, DEFAULT_EMAIL_WIDTH as p, AttributeSchema as r, BLOCK_TAGS as s, AUXILIARY_TAGS as t, CHANNEL_TAGS as u, InterpolationNode as v, SmlDocumentSchema as w, RootTag as x, InterpolationNodeSchema as y };
+//# sourceMappingURL=ast-DAhnAvQN.d.ts.map

package/dist/ast.d.ts

@@ -0,0 +1,2 @@
+import { A as attributeValue, C as SmlDocument, D as SmlTag, E as SmlNodeSchema, F as nodeLabel, I as numberAttribute, L as stringAttribute, M as documentChannel, N as isHiddenNode, O as TextNode, P as isRootTag, S as SML_TAGS, T as SmlNode, _ as InlineTag, a as AttributeValueSchema, b as ROOT_TAGS, c as BlockTag, d as Channel, f as ChannelTag, g as INLINE_TAGS, h as ElementNodeSchema, i as AttributeValue, j as collectVariableReferences, k as TextNodeSchema, l as CHANNEL_BY_ROOT_TAG, m as ElementNode, n as Attribute, o as AuxiliaryTag, p as DEFAULT_EMAIL_WIDTH, r as AttributeSchema, s as BLOCK_TAGS, t as AUXILIARY_TAGS, u as CHANNEL_TAGS, v as InterpolationNode, w as SmlDocumentSchema, x as RootTag, y as InterpolationNodeSchema } from "./ast-DAhnAvQN.js";
+export { AUXILIARY_TAGS, Attribute, AttributeSchema, AttributeValue, AttributeValueSchema, AuxiliaryTag, BLOCK_TAGS, BlockTag, CHANNEL_BY_ROOT_TAG, CHANNEL_TAGS, Channel, ChannelTag, DEFAULT_EMAIL_WIDTH, ElementNode, ElementNodeSchema, INLINE_TAGS, InlineTag, InterpolationNode, InterpolationNodeSchema, ROOT_TAGS, RootTag, SML_TAGS, SmlDocument, SmlDocumentSchema, SmlNode, SmlNodeSchema, SmlTag, TextNode, TextNodeSchema, attributeValue, collectVariableReferences, documentChannel, isHiddenNode, isRootTag, nodeLabel, numberAttribute, stringAttribute };

package/dist/ast.js

@@ -0,0 +1,159 @@
+import { SpanSchema } from "./diagnostics.js";
+import { collectPredicateVariables, parsePredicate } from "./predicate.js";
+import { Result, Schema } from "effect";
+//#region src/ast.ts
+const BLOCK_TAGS = [
+	"Email",
+	"Subject",
+	"Preview",
+	"Container",
+	"Section",
+	"Row",
+	"Column",
+	"Heading",
+	"Text",
+	"Button",
+	"Image",
+	"Divider",
+	"Spacer",
+	"List",
+	"ListItem",
+	"If",
+	"Else"
+];
+const INLINE_TAGS = [
+	"strong",
+	"em",
+	"a"
+];
+/** Email-only helper tags scoped by their parent primitive. */
+const AUXILIARY_TAGS = ["Source"];
+/** Structured-channel tags: the sms/whatsapp vocabulary beyond shared If/Else. */
+const CHANNEL_TAGS = [
+	"Sms",
+	"WhatsApp",
+	"Header",
+	"Body",
+	"Footer",
+	"Buttons"
+];
+const SML_TAGS = [
+	...BLOCK_TAGS,
+	...INLINE_TAGS,
+	...AUXILIARY_TAGS,
+	...CHANNEL_TAGS
+];
+/** Resolved primary width for email documents that omit `<Email width={…}>`. */
+const DEFAULT_EMAIL_WIDTH = 600;
+/** Root tag → channel. The root tag IS the channel declaration. */
+const CHANNEL_BY_ROOT_TAG = {
+	Email: "email",
+	Sms: "sms",
+	WhatsApp: "whatsapp"
+};
+const ROOT_TAGS = Object.keys(CHANNEL_BY_ROOT_TAG);
+const isRootTag = (tag) => tag in CHANNEL_BY_ROOT_TAG;
+/** The channel a parsed document targets, read off its root tag. */
+const documentChannel = (document) => CHANNEL_BY_ROOT_TAG[document.root.tag];
+const AttributeValueSchema = Schema.Union([Schema.Struct({
+	kind: Schema.Literal("string"),
+	value: Schema.String
+}), Schema.Struct({
+	kind: Schema.Literal("number"),
+	value: Schema.Finite
+})]);
+const AttributeSchema = Schema.Struct({
+	name: Schema.String,
+	value: AttributeValueSchema,
+	/** Span of the whole `name="value"` pair. */
+	span: SpanSchema,
+	/** Span of the value contents (inside quotes/braces) — class diagnostics point here. */
+	valueSpan: SpanSchema
+});
+const TextNodeSchema = Schema.Struct({
+	kind: Schema.Literal("text"),
+	id: Schema.String,
+	value: Schema.String,
+	span: SpanSchema
+});
+const InterpolationNodeSchema = Schema.Struct({
+	kind: Schema.Literal("interpolation"),
+	id: Schema.String,
+	name: Schema.String,
+	/** {{name}} vs ${name} — both today's syntaxes, preserved through print. */
+	syntax: Schema.Literals(["curly", "dollar"]),
+	span: SpanSchema
+});
+const ElementNodeSchema = Schema.Struct({
+	kind: Schema.Literal("element"),
+	id: Schema.String,
+	tag: Schema.Literals(SML_TAGS),
+	attributes: Schema.Array(AttributeSchema),
+	children: Schema.Array(Schema.suspend(() => SmlNodeSchema)),
+	span: SpanSchema
+});
+const SmlNodeSchema = Schema.Union([
+	ElementNodeSchema,
+	TextNodeSchema,
+	InterpolationNodeSchema
+]);
+const SmlDocumentSchema = Schema.Struct({
+	kind: Schema.Literal("document"),
+	/** Always a root element: `<Email>`, `<Sms>`, or `<WhatsApp>`. */
+	root: ElementNodeSchema
+});
+const attributeValue = (node, name) => node.attributes.find((attribute) => attribute.name === name)?.value;
+const stringAttribute = (node, name) => {
+	const value = attributeValue(node, name);
+	return value?.kind === "string" ? value.value : void 0;
+};
+const numberAttribute = (node, name) => {
+	const value = attributeValue(node, name);
+	if (value === void 0) return void 0;
+	return value.kind === "number" ? value.value : Number.parseInt(value.value, 10);
+};
+/**
+* The editor-only display label (navigator rename) — a universal attribute the
+* compiler never reads, so it never reaches HTML. Absent when unset.
+*/
+const nodeLabel = (node) => stringAttribute(node, "label");
+/**
+* The editor-only visibility flag. A `hidden="true"` node stays in the source
+* (and the navigator, dimmed) but is dropped from every compile — preview and
+* send alike. Any other value / absence means visible.
+*/
+const isHiddenNode = (node) => stringAttribute(node, "hidden") === "true";
+/**
+* All variable references in the document: `{{name}}` / `${name}` in children
+* and attribute values, plus names referenced by `<If test="...">` predicates.
+*/
+const collectVariableReferences = (document) => {
+	const names = /* @__PURE__ */ new Set();
+	const attributePattern = /\$\{\s*\/?([\w.]+)\s*\}|\{\{\s*([\w.]+)\s*\}\}/g;
+	const visit = (node) => {
+		if (node.kind === "interpolation") {
+			names.add(node.name);
+			return;
+		}
+		if (node.kind === "text") return;
+		for (const attribute of node.attributes) {
+			if (attribute.value.kind !== "string") continue;
+			if (node.tag === "If" && attribute.name === "test") {
+				const parsed = parsePredicate(attribute.value.value);
+				if (Result.isSuccess(parsed)) for (const name of collectPredicateVariables(parsed.success)) names.add(name);
+				continue;
+			}
+			for (const match of attribute.value.value.matchAll(attributePattern)) {
+				const name = match[1] ?? match[2];
+				if (name !== void 0) names.add(name);
+			}
+		}
+		for (const child of node.children) visit(child);
+	};
+	visit(document.root);
+	return names;
+};
+//#endregion
+export { AUXILIARY_TAGS, AttributeSchema, AttributeValueSchema, BLOCK_TAGS, CHANNEL_BY_ROOT_TAG, CHANNEL_TAGS, DEFAULT_EMAIL_WIDTH, ElementNodeSchema, INLINE_TAGS, InterpolationNodeSchema, ROOT_TAGS, SML_TAGS, SmlDocumentSchema, SmlNodeSchema, TextNodeSchema, attributeValue, collectVariableReferences, documentChannel, isHiddenNode, isRootTag, nodeLabel, numberAttribute, stringAttribute };
+
+//# sourceMappingURL=ast.js.map

package/dist/ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.js","names":[],"sources":["../src/ast.ts"],"sourcesContent":["import { Result, Schema } from \"effect\";\n\nimport { SpanSchema } from \"./diagnostics\";\nimport { collectPredicateVariables, parsePredicate } from \"./predicate\";\n\n// Typed SML AST. The parser is the only producer; the schema exists for\n// boundaries that ship AST JSON (editor ops, agent tools). Shape only — the\n// content model (what may nest where) is the parser's job, so decoding an AST\n// someone assembled by hand still round-trips through print → parse for full\n// validation.\n//\n// Node ids are assigned in document order at parse time (\"n0\", \"n1\", ...):\n// identical source always yields identical ids, which the compiler relies on\n// for deterministic artifacts and the editor for DOM ⇄ AST mapping.\n//\n// `tag` is a closed vocabulary — permanently: composition lives in the TSX\n// authoring layer, so SML stays a flat closed grammar. New tags (e.g. <For>)\n// land by widening the unions — nothing else about the node shape assumes a\n// fixed set.\n//\n// One document = one channel, declared by the root tag: <Email> (blocks +\n// inline + Tailwind subset), <Sms> (verbatim text body), <WhatsApp> (Meta's\n// template anatomy as the closed grammar). Cross-channel compile is rejected\n// by design; what the channels share is the language machinery.\n\nexport const BLOCK_TAGS = [\n  \"Email\",\n  \"Subject\",\n  \"Preview\",\n  \"Container\",\n  \"Section\",\n  \"Row\",\n  \"Column\",\n  \"Heading\",\n  \"Text\",\n  \"Button\",\n  \"Image\",\n  \"Divider\",\n  \"Spacer\",\n  \"List\",\n  \"ListItem\",\n  \"If\",\n  \"Else\",\n] as const;\n\nexport const INLINE_TAGS = [\"strong\", \"em\", \"a\"] as const;\n\n/** Email-only helper tags scoped by their parent primitive. */\nexport const AUXILIARY_TAGS = [\"Source\"] as const;\n\n/** Structured-channel tags: the sms/whatsapp vocabulary beyond shared If/Else. */\nexport const CHANNEL_TAGS = [\"Sms\", \"WhatsApp\", \"Header\", \"Body\", \"Footer\", \"Buttons\"] as const;\n\nexport const SML_TAGS = [\n  ...BLOCK_TAGS,\n  ...INLINE_TAGS,\n  ...AUXILIARY_TAGS,\n  ...CHANNEL_TAGS,\n] as const;\n\nexport type BlockTag = (typeof BLOCK_TAGS)[number];\nexport type InlineTag = (typeof INLINE_TAGS)[number];\nexport type AuxiliaryTag = (typeof AUXILIARY_TAGS)[number];\nexport type ChannelTag = (typeof CHANNEL_TAGS)[number];\nexport type SmlTag = (typeof SML_TAGS)[number];\n\n// ── Channels ─────────────────────────────────────────────────────────────────\n\n/** Channels supported by the public SML document model. */\nexport type Channel = \"email\" | \"sms\" | \"whatsapp\";\n\n/** Resolved primary width for email documents that omit `<Email width={…}>`. */\nexport const DEFAULT_EMAIL_WIDTH = 600;\n\n/** Root tag → channel. The root tag IS the channel declaration. */\nexport const CHANNEL_BY_ROOT_TAG = {\n  Email: \"email\",\n  Sms: \"sms\",\n  WhatsApp: \"whatsapp\",\n} as const satisfies Partial<Record<SmlTag, Channel>>;\n\nexport type RootTag = keyof typeof CHANNEL_BY_ROOT_TAG;\n\nexport const ROOT_TAGS = Object.keys(CHANNEL_BY_ROOT_TAG) as ReadonlyArray<RootTag>;\n\nexport const isRootTag = (tag: string): tag is RootTag => tag in CHANNEL_BY_ROOT_TAG;\n\n/** The channel a parsed document targets, read off its root tag. */\nexport const documentChannel = (document: SmlDocument): Channel =>\n  CHANNEL_BY_ROOT_TAG[document.root.tag as RootTag];\n\nexport const AttributeValueSchema = Schema.Union([\n  Schema.Struct({\n    kind: Schema.Literal(\"string\"),\n    value: Schema.String,\n  }),\n  Schema.Struct({\n    kind: Schema.Literal(\"number\"),\n    value: Schema.Finite,\n  }),\n]);\n\nexport type AttributeValue = typeof AttributeValueSchema.Type;\n\nexport const AttributeSchema = Schema.Struct({\n  name: Schema.String,\n  value: AttributeValueSchema,\n  /** Span of the whole `name=\"value\"` pair. */\n  span: SpanSchema,\n  /** Span of the value contents (inside quotes/braces) — class diagnostics point here. */\n  valueSpan: SpanSchema,\n});\n\nexport interface Attribute extends Schema.Schema.Type<typeof AttributeSchema> {}\n\nexport const TextNodeSchema = Schema.Struct({\n  kind: Schema.Literal(\"text\"),\n  id: Schema.String,\n  value: Schema.String,\n  span: SpanSchema,\n});\n\nexport interface TextNode extends Schema.Schema.Type<typeof TextNodeSchema> {}\n\nexport const InterpolationNodeSchema = Schema.Struct({\n  kind: Schema.Literal(\"interpolation\"),\n  id: Schema.String,\n  name: Schema.String,\n  /** {{name}} vs ${name} — both today's syntaxes, preserved through print. */\n  syntax: Schema.Literals([\"curly\", \"dollar\"]),\n  span: SpanSchema,\n});\n\nexport interface InterpolationNode extends Schema.Schema.Type<typeof InterpolationNodeSchema> {}\n\nexport interface ElementNode {\n  readonly kind: \"element\";\n  readonly id: string;\n  readonly tag: SmlTag;\n  readonly attributes: ReadonlyArray<Attribute>;\n  readonly children: ReadonlyArray<SmlNode>;\n  readonly span: typeof SpanSchema.Type;\n}\n\nexport type SmlNode = ElementNode | TextNode | InterpolationNode;\n\nexport const ElementNodeSchema: Schema.Codec<ElementNode> = Schema.Struct({\n  kind: Schema.Literal(\"element\"),\n  id: Schema.String,\n  tag: Schema.Literals(SML_TAGS),\n  attributes: Schema.Array(AttributeSchema),\n  children: Schema.Array(Schema.suspend((): Schema.Codec<SmlNode> => SmlNodeSchema)),\n  span: SpanSchema,\n});\n\nexport const SmlNodeSchema: Schema.Codec<SmlNode> = Schema.Union([\n  ElementNodeSchema,\n  TextNodeSchema,\n  InterpolationNodeSchema,\n]);\n\nexport const SmlDocumentSchema = Schema.Struct({\n  kind: Schema.Literal(\"document\"),\n  /** Always a root element: `<Email>`, `<Sms>`, or `<WhatsApp>`. */\n  root: ElementNodeSchema,\n});\n\nexport interface SmlDocument extends Schema.Schema.Type<typeof SmlDocumentSchema> {}\n\nexport const attributeValue = (node: ElementNode, name: string): AttributeValue | undefined =>\n  node.attributes.find((attribute) => attribute.name === name)?.value;\n\nexport const stringAttribute = (node: ElementNode, name: string): string | undefined => {\n  const value = attributeValue(node, name);\n  return value?.kind === \"string\" ? value.value : undefined;\n};\n\nexport const numberAttribute = (node: ElementNode, name: string): number | undefined => {\n  const value = attributeValue(node, name);\n  if (value === undefined) return undefined;\n  return value.kind === \"number\" ? value.value : Number.parseInt(value.value, 10);\n};\n\n/**\n * The editor-only display label (navigator rename) — a universal attribute the\n * compiler never reads, so it never reaches HTML. Absent when unset.\n */\nexport const nodeLabel = (node: ElementNode): string | undefined => stringAttribute(node, \"label\");\n\n/**\n * The editor-only visibility flag. A `hidden=\"true\"` node stays in the source\n * (and the navigator, dimmed) but is dropped from every compile — preview and\n * send alike. Any other value / absence means visible.\n */\nexport const isHiddenNode = (node: ElementNode): boolean =>\n  stringAttribute(node, \"hidden\") === \"true\";\n\n/**\n * All variable references in the document: `{{name}}` / `${name}` in children\n * and attribute values, plus names referenced by `<If test=\"...\">` predicates.\n */\nexport const collectVariableReferences = (document: SmlDocument): ReadonlySet<string> => {\n  const names = new Set<string>();\n  const attributePattern = /\\$\\{\\s*\\/?([\\w.]+)\\s*\\}|\\{\\{\\s*([\\w.]+)\\s*\\}\\}/g;\n  const visit = (node: SmlNode): void => {\n    if (node.kind === \"interpolation\") {\n      names.add(node.name);\n      return;\n    }\n    if (node.kind === \"text\") return;\n    for (const attribute of node.attributes) {\n      if (attribute.value.kind !== \"string\") continue;\n      if (node.tag === \"If\" && attribute.name === \"test\") {\n        // Parser-produced documents always carry a valid predicate; a\n        // hand-assembled AST with a broken one contributes nothing here and is\n        // caught by the print → parse validation round-trip.\n        const parsed = parsePredicate(attribute.value.value);\n        if (Result.isSuccess(parsed)) {\n          for (const name of collectPredicateVariables(parsed.success)) names.add(name);\n        }\n        continue;\n      }\n      for (const match of attribute.value.value.matchAll(attributePattern)) {\n        const name = match[1] ?? match[2];\n        if (name !== undefined) names.add(name);\n      }\n    }\n    for (const child of node.children) visit(child);\n  };\n  visit(document.root);\n  return names;\n};\n"],"mappings":"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"}

package/dist/candidate.d.ts

@@ -0,0 +1,29 @@
+//#region src/candidate.d.ts
+interface ParsedCandidate {
+  readonly raw: string;
+  /** Variant names in written order (validity is checked by the resolver). */
+  readonly variants: ReadonlyArray<string>;
+  /** root[-value] with variants/modifier/important stripped. */
+  readonly base: string;
+  /** Contents after the last `/` outside brackets, or null. */
+  readonly modifier: string | null;
+  /** Trailing `!`. */
+  readonly important: boolean;
+}
+declare const parseCandidate: (raw: string) => ParsedCandidate;
+/**
+ * Splits `base` into (root, value) against a known root set, preferring the
+ * longest matching root ("max-w-lg" → root "max-w", not "max").
+ * `value` is `null` for a bare root ("border", "rounded"),
+ * `{ kind: "arbitrary" }` for `root-[...]`, else `{ kind: "named" }`.
+ */
+declare const splitRoot: (base: string, roots: ReadonlySet<string>) => {
+  readonly root: string;
+  readonly value: {
+    kind: "named" | "arbitrary";
+    value: string;
+  } | null;
+} | null;
+//#endregion
+export { ParsedCandidate, parseCandidate, splitRoot };
+//# sourceMappingURL=candidate.d.ts.map

package/dist/candidate.js

@@ -0,0 +1,88 @@
+//#region src/candidate.ts
+const splitOutsideBrackets = (value, separator) => {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let index = 0; index < value.length; index++) {
+		const char = value[index];
+		if (char === "[") depth++;
+		else if (char === "]") depth = Math.max(0, depth - 1);
+		else if (char === separator && depth === 0) {
+			parts.push(value.slice(start, index));
+			start = index + 1;
+		}
+	}
+	parts.push(value.slice(start));
+	return parts;
+};
+const parseCandidate = (raw) => {
+	let rest = raw;
+	const important = rest.endsWith("!");
+	if (important) rest = rest.slice(0, -1);
+	const segments = splitOutsideBrackets(rest, ":");
+	const base = segments[segments.length - 1];
+	const variants = segments.slice(0, -1);
+	const lastSlash = (() => {
+		let depth = 0;
+		for (let index = base.length - 1; index >= 0; index--) {
+			const char = base[index];
+			if (char === "]") depth++;
+			else if (char === "[") depth = Math.max(0, depth - 1);
+			else if (char === "/" && depth === 0) return index;
+		}
+		return -1;
+	})();
+	if (lastSlash === -1) return {
+		raw,
+		variants,
+		base,
+		modifier: null,
+		important
+	};
+	return {
+		raw,
+		variants,
+		base: base.slice(0, lastSlash),
+		modifier: base.slice(lastSlash + 1),
+		important
+	};
+};
+/**
+* Splits `base` into (root, value) against a known root set, preferring the
+* longest matching root ("max-w-lg" → root "max-w", not "max").
+* `value` is `null` for a bare root ("border", "rounded"),
+* `{ kind: "arbitrary" }` for `root-[...]`, else `{ kind: "named" }`.
+*/
+const splitRoot = (base, roots) => {
+	if (roots.has(base)) return {
+		root: base,
+		value: null
+	};
+	let dash = base.lastIndexOf("-");
+	while (dash > 0) {
+		const root = base.slice(0, dash);
+		if (roots.has(root)) {
+			const rawValue = base.slice(dash + 1);
+			if (rawValue.startsWith("[") && rawValue.endsWith("]")) return {
+				root,
+				value: {
+					kind: "arbitrary",
+					value: rawValue.slice(1, -1)
+				}
+			};
+			return {
+				root,
+				value: {
+					kind: "named",
+					value: rawValue
+				}
+			};
+		}
+		dash = base.lastIndexOf("-", dash - 1);
+	}
+	return null;
+};
+//#endregion
+export { parseCandidate, splitRoot };
+
+//# sourceMappingURL=candidate.js.map

package/dist/candidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate.js","names":[],"sources":["../src/candidate.ts"],"sourcesContent":["// Tailwind candidate segmentation: `[sm:|dark:]root[-value | -[arbitrary]][/modifier][!]`.\n// Bracket-aware splitting only — which roots exist and what values mean is the\n// registry's job (registry.ts). Mirrors the shape of tailwindcss/src/candidate.ts\n// at ~10% of the grammar.\n\nexport interface ParsedCandidate {\n  readonly raw: string;\n  /** Variant names in written order (validity is checked by the resolver). */\n  readonly variants: ReadonlyArray<string>;\n  /** root[-value] with variants/modifier/important stripped. */\n  readonly base: string;\n  /** Contents after the last `/` outside brackets, or null. */\n  readonly modifier: string | null;\n  /** Trailing `!`. */\n  readonly important: boolean;\n}\n\nconst splitOutsideBrackets = (value: string, separator: string): Array<string> => {\n  const parts: Array<string> = [];\n  let depth = 0;\n  let start = 0;\n  for (let index = 0; index < value.length; index++) {\n    const char = value[index]!;\n    if (char === \"[\") depth++;\n    else if (char === \"]\") depth = Math.max(0, depth - 1);\n    else if (char === separator && depth === 0) {\n      parts.push(value.slice(start, index));\n      start = index + 1;\n    }\n  }\n  parts.push(value.slice(start));\n  return parts;\n};\n\nexport const parseCandidate = (raw: string): ParsedCandidate => {\n  let rest = raw;\n  const important = rest.endsWith(\"!\");\n  if (important) rest = rest.slice(0, -1);\n\n  const segments = splitOutsideBrackets(rest, \":\");\n  const base = segments[segments.length - 1]!;\n  const variants = segments.slice(0, -1);\n\n  const lastSlash = (() => {\n    let depth = 0;\n    for (let index = base.length - 1; index >= 0; index--) {\n      const char = base[index]!;\n      if (char === \"]\") depth++;\n      else if (char === \"[\") depth = Math.max(0, depth - 1);\n      else if (char === \"/\" && depth === 0) return index;\n    }\n    return -1;\n  })();\n\n  if (lastSlash === -1) return { raw, variants, base, modifier: null, important };\n  return {\n    raw,\n    variants,\n    base: base.slice(0, lastSlash),\n    modifier: base.slice(lastSlash + 1),\n    important,\n  };\n};\n\n/**\n * Splits `base` into (root, value) against a known root set, preferring the\n * longest matching root (\"max-w-lg\" → root \"max-w\", not \"max\").\n * `value` is `null` for a bare root (\"border\", \"rounded\"),\n * `{ kind: \"arbitrary\" }` for `root-[...]`, else `{ kind: \"named\" }`.\n */\nexport const splitRoot = (\n  base: string,\n  roots: ReadonlySet<string>,\n): {\n  readonly root: string;\n  readonly value: { kind: \"named\" | \"arbitrary\"; value: string } | null;\n} | null => {\n  if (roots.has(base)) return { root: base, value: null };\n  let dash = base.lastIndexOf(\"-\");\n  while (dash > 0) {\n    const root = base.slice(0, dash);\n    if (roots.has(root)) {\n      const rawValue = base.slice(dash + 1);\n      if (rawValue.startsWith(\"[\") && rawValue.endsWith(\"]\")) {\n        return { root, value: { kind: \"arbitrary\", value: rawValue.slice(1, -1) } };\n      }\n      return { root, value: { kind: \"named\", value: rawValue } };\n    }\n    dash = base.lastIndexOf(\"-\", dash - 1);\n  }\n  return null;\n};\n"],"mappings":";AAiBA,MAAM,wBAAwB,OAAe,cAAqC;CAChF,MAAM,QAAuB,CAAC;CAC9B,IAAI,QAAQ;CACZ,IAAI,QAAQ;CACZ,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;EACjD,MAAM,OAAO,MAAM;EACnB,IAAI,SAAS,KAAK;OACb,IAAI,SAAS,KAAK,QAAQ,KAAK,IAAI,GAAG,QAAQ,CAAC;OAC/C,IAAI,SAAS,aAAa,UAAU,GAAG;GAC1C,MAAM,KAAK,MAAM,MAAM,OAAO,KAAK,CAAC;GACpC,QAAQ,QAAQ;EAClB;CACF;CACA,MAAM,KAAK,MAAM,MAAM,KAAK,CAAC;CAC7B,OAAO;AACT;AAEA,MAAa,kBAAkB,QAAiC;CAC9D,IAAI,OAAO;CACX,MAAM,YAAY,KAAK,SAAS,GAAG;CACnC,IAAI,WAAW,OAAO,KAAK,MAAM,GAAG,EAAE;CAEtC,MAAM,WAAW,qBAAqB,MAAM,GAAG;CAC/C,MAAM,OAAO,SAAS,SAAS,SAAS;CACxC,MAAM,WAAW,SAAS,MAAM,GAAG,EAAE;CAErC,MAAM,mBAAmB;EACvB,IAAI,QAAQ;EACZ,KAAK,IAAI,QAAQ,KAAK,SAAS,GAAG,SAAS,GAAG,SAAS;GACrD,MAAM,OAAO,KAAK;GAClB,IAAI,SAAS,KAAK;QACb,IAAI,SAAS,KAAK,QAAQ,KAAK,IAAI,GAAG,QAAQ,CAAC;QAC/C,IAAI,SAAS,OAAO,UAAU,GAAG,OAAO;EAC/C;EACA,OAAO;CACT,EAAA,CAAG;CAEH,IAAI,cAAc,IAAI,OAAO;EAAE;EAAK;EAAU;EAAM,UAAU;EAAM;CAAU;CAC9E,OAAO;EACL;EACA;EACA,MAAM,KAAK,MAAM,GAAG,SAAS;EAC7B,UAAU,KAAK,MAAM,YAAY,CAAC;EAClC;CACF;AACF;;;;;;;AAQA,MAAa,aACX,MACA,UAIU;CACV,IAAI,MAAM,IAAI,IAAI,GAAG,OAAO;EAAE,MAAM;EAAM,OAAO;CAAK;CACtD,IAAI,OAAO,KAAK,YAAY,GAAG;CAC/B,OAAO,OAAO,GAAG;EACf,MAAM,OAAO,KAAK,MAAM,GAAG,IAAI;EAC/B,IAAI,MAAM,IAAI,IAAI,GAAG;GACnB,MAAM,WAAW,KAAK,MAAM,OAAO,CAAC;GACpC,IAAI,SAAS,WAAW,GAAG,KAAK,SAAS,SAAS,GAAG,GACnD,OAAO;IAAE;IAAM,OAAO;KAAE,MAAM;KAAa,OAAO,SAAS,MAAM,GAAG,EAAE;IAAE;GAAE;GAE5E,OAAO;IAAE;IAAM,OAAO;KAAE,MAAM;KAAS,OAAO;IAAS;GAAE;EAC3D;EACA,OAAO,KAAK,YAAY,KAAK,OAAO,CAAC;CACvC;CACA,OAAO;AACT"}