@samva/markup 0.1.2 → 0.3.0

package/AGENTS.md

@@ -1,8 +1,28 @@
 # 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.
+Email entries default-export `defineEmail` definitions. SMS and WhatsApp use the structured
+channel runtime at `@samva/markup` and components at `@samva/markup/components`.
+Use documented package subpaths only. Template entry discovery is `.tsx` 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()`.
+Object email templates use `jsxImportSource: "@samva/markup/email"` and
+`defineEmail` from `@samva/markup/template`. Their render function receives actual validated
+JSON input and returns subject, optional preheader, body, and optional text. A template id and a
+fixture key are both written into file paths, so each must match `TEMPLATE_NAME_PATTERN` — one
+plain path segment — and `defineEmail` refuses anything else where the name is declared. A consumer
+that resolves a path from those names imports that pattern; it never restates it. The derived
+semantic tree lowers directly to HTML/text via `@samva/markup/email/render`; do not route object
+templates through recording proxies or textual SML. Authoring-source provenance belongs to semantic
+nodes.
+
+Ordinary HTML is typed. `@samva/markup/email/elements` is the one table behind both the JSX
+intrinsic prop types and the serializer's allowlist, so an unsupported element or attribute fails at
+typecheck and again at compile with a source location. Email primitives — `Email`, `Section`,
+`Columns`/`Column`, `Button`, `Spacer`, `Divider`, `Image`, `Link` — come from
+`@samva/markup/email/components`; they generate table markup and classic-Outlook fallbacks, and
+every wrapper they generate carries the authoring call site as its origin. Findings are
+`EmailDiagnostic` values from `@samva/markup/email/diagnostics`: errors throw `EmailCompileError`,
+warnings ride back on the render result. Nothing an author passes as a string becomes markup.
+
+`@samva/markup/compiler` is the bundler-agnostic compiler boundary. `@samva/vite` and
+`apps/agents/src/editor` are adapters over it — they own resolution, watching and transport, never
+compilation semantics — and the module imports no Vite, esbuild or Node builtins.

package/README.md

@@ -9,33 +9,99 @@ directly for TSX templates or together with `@samva/vite` for the visual editor
 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:
+Configure TypeScript with `jsx: "react-jsx"` and
+`jsxImportSource: "@samva/markup/email"`. Install `effect` for this schema example
+(or use a Zod 4 schema). Email entries use `.tsx` and default-export a definition:
 
 ```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>
-  );
-}
+/** @jsxImportSource @samva/markup/email */
+import { Schema } from "effect";
+import { Email, Section } from "@samva/markup/email/components";
+import { defineEmail } from "@samva/markup/template";
+
+export default defineEmail({
+  id: "welcome",
+  schema: Schema.toStandardJSONSchemaV1(
+    Schema.Struct({ firstName: Schema.String, items: Schema.Array(Schema.String) }),
+  ),
+  fixtures: { basic: { firstName: "Ada", items: ["Your first project"] } },
+  render: (input) => ({
+    subject: `Welcome, ${input.firstName}`,
+    preheader: "Your account is ready",
+    body: (
+      <Email>
+        <Section>
+          <h1>Welcome, {input.firstName}</h1>
+          {input.items.length > 0 && (
+            <ul>
+              {input.items.map((item) => (
+                <li key={item}>{item}</li>
+              ))}
+            </ul>
+          )}
+        </Section>
+      </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.
+The definition owns a stable, project-unique `id`, a portable JSON input schema, named fixtures,
+and a synchronous render function. Imported helpers are ordinary modules, not catalog entries.
+Email executes real TypeScript against validated input and lowers a semantic tree to HTML and text.
+SMS and WhatsApp keep their structured channel compiler and `@samva/markup` JSX runtime.
+
+### Explicit template inputs
+
+`@samva/markup/template` exports `defineEmail({ id, schema, fixtures, render })`, the email
+channel's authoring helper; `TemplateDefinition` and `TemplateInput` are channel-neutral.
+The schema must implement Standard **JSON Schema** v1; a validator-only Standard Schema is
+insufficient. `Schema.toStandardJSONSchemaV1` (Effect) and Zod 4 schemas support caller-input
+inference, including imported render functions and named fixtures. `TemplateInput<typeof template>`
+extracts the caller type. Rendering receives input unchanged.
+
+The portable profile uses JSON Schema 2020-12. Supported validation keywords are `type`, `enum`,
+`const`, `required`, numeric bounds and `multipleOf`, string lengths and `pattern`, object/array
+size bounds, `uniqueItems`, `properties`, `patternProperties`, `additionalProperties`,
+`dependentSchemas`, `propertyNames`, `items`, `prefixItems`, `contains`, `allOf`, `anyOf`, `oneOf`,
+`not`, `if`, `then`, `else`, `$defs`, and local JSON Pointer `$ref`. Boolean schemas are supported.
+Remote references, alternative dialects, `$id`, dynamic references, `format`, and unknown keywords
+fail. Regex constraints use the validator's Unicode JavaScript regular-expression semantics.
+
+`title`, `description`, `default`, `examples`, `deprecated`, `readOnly`, `writeOnly`, and `$comment`
+are annotations retained in the complete schema but excluded from `validationIdentity`. Defaults
+are never inserted, values are never coerced, and extra properties are never removed. Identity
+sorts schema object keys; it is a canonical document, not a semantic-equivalence proof.
+
+Converters must export portable input and output schemas with equal validation documents.
+Transforms that cannot export output, differing input/output documents, and non-JSON exports fail.
+Custom library refinements are not portable merely because their validator works: converters must
+reject unsupported refinements instead of silently dropping them. This interface cannot detect an
+arbitrary dishonest or lossy converter. The tested Effect and Zod fixtures cover structural nested
+objects, arrays, primitive constraints, and rejection of nonportable exports.
+
+The pinned Zod/Effect adapter rejects lazy/suspended schema nodes before executing their getters;
+author recursive contracts directly using local JSON Schema references. Custom predicate metadata
+is checked for these vendors, but a converter-supplied JSON Schema constraint remains its contract.
+
+### Actual-input email JSX
+
+Use `jsxImportSource: "@samva/markup/email"` for object template bodies. Ordinary HTML JSX,
+imported synchronous components, nested JSON, conditionals and mapped arrays lower directly to a
+semantic tree. `renderEmail(template, data)` validates unchanged input and returns subject,
+preheader, escaped HTML, explicit or derived text, and the derived tree. Development JSX preserves
+source origins and component call sites. This synchronous library call requires an isolated host
+before executing untrusted source; it is not itself a sandbox.
+
+The rendering host has no ambient clock and no entropy source. Reading the current instant or a
+random value throws unless the template declares the matching fixed value in `runtime`, which takes
+an optional `now` (epoch milliseconds) and `randomSeed` (32-bit unsigned integer). A declaration is
+recorded on the publication and applies to every render, including module initializers that capture
+a value at import. `new Date(value)` with an explicit argument always works, so a message either
+takes its time from validated input or states it once as configuration. Locale (`en-US`) and time
+zone (UTC) are publication-wide and back every `Intl` constructor and `toLocale*` call.
+
+Portable validation uses `@cfworker/json-schema` 4.1.1 without runtime code generation. The
+2020-12 meta-schema is checked at every supported schema position, and the explicit profile rejects
+keywords outside its contract before interpretation. The AJV dependency supplies static meta-schema
+JSON; its code generator is not invoked in a loaded template.

package/dist/{ast-DAhnAvQN.d.ts → ast-63I-VLQx.d.ts}

@@ -8,6 +8,19 @@ 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"];
+/**
+ * JSX component name → the SML tag that component emits. TSX authors write
+ * capitalized component names, and the inline tags are lowercase in SML, so
+ * `<Strong>` emits `strong` and `<A>` emits `a`. The table is derived from
+ * `SML_TAGS` rather than written out, so a new tag is mapped the moment it
+ * joins the vocabulary. `components.ts` is held to it by the component test
+ * suite, and `tsx-tracer.ts` resolves authored JSX names through it.
+ */
+declare const SML_TAG_BY_COMPONENT_NAME: Readonly<Record<string, SmlTag>>;
+/** The SML tag a JSX component name emits, or `undefined` when it is not a Samva primitive. */
+declare const smlTagForComponentName: (name: string) => SmlTag | undefined;
+/** The JSX component name that emits an SML tag, for printing SML back into TSX. */
+declare const componentNameForSmlTag: (tag: SmlTag) => string;
 type BlockTag = (typeof BLOCK_TAGS)[number];
 type InlineTag = (typeof INLINE_TAGS)[number];
 type AuxiliaryTag = (typeof AUXILIARY_TAGS)[number];
@@ -116,5 +129,5 @@ declare const isHiddenNode: (node: ElementNode) => boolean;
  */
 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
+export { TextNodeSchema as A, stringAttribute as B, SML_TAG_BY_COMPONENT_NAME as C, SmlNodeSchema as D, SmlNode as E, isHiddenNode as F, isRootTag as I, nodeLabel as L, collectVariableReferences as M, componentNameForSmlTag as N, SmlTag as O, documentChannel as P, numberAttribute as R, SML_TAGS as S, SmlDocumentSchema 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, attributeValue as j, TextNode 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, SmlDocument as w, RootTag as x, InterpolationNodeSchema as y, smlTagForComponentName as z };
+//# sourceMappingURL=ast-63I-VLQx.d.ts.map

package/dist/ast.d.ts

@@ -1,2 +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 };
+import { A as TextNodeSchema, B as stringAttribute, C as SML_TAG_BY_COMPONENT_NAME, D as SmlNodeSchema, E as SmlNode, F as isHiddenNode, I as isRootTag, L as nodeLabel, M as collectVariableReferences, N as componentNameForSmlTag, O as SmlTag, P as documentChannel, R as numberAttribute, S as SML_TAGS, T as SmlDocumentSchema, _ 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 attributeValue, k as TextNode, 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 SmlDocument, x as RootTag, y as InterpolationNodeSchema, z as smlTagForComponentName } from "./ast-63I-VLQx.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, SML_TAG_BY_COMPONENT_NAME, SmlDocument, SmlDocumentSchema, SmlNode, SmlNodeSchema, SmlTag, TextNode, TextNodeSchema, attributeValue, collectVariableReferences, componentNameForSmlTag, documentChannel, isHiddenNode, isRootTag, nodeLabel, numberAttribute, smlTagForComponentName, stringAttribute };

package/dist/ast.js

@@ -43,6 +43,19 @@ const SML_TAGS = [
 	...AUXILIARY_TAGS,
 	...CHANNEL_TAGS
 ];
+/**
+* JSX component name → the SML tag that component emits. TSX authors write
+* capitalized component names, and the inline tags are lowercase in SML, so
+* `<Strong>` emits `strong` and `<A>` emits `a`. The table is derived from
+* `SML_TAGS` rather than written out, so a new tag is mapped the moment it
+* joins the vocabulary. `components.ts` is held to it by the component test
+* suite, and `tsx-tracer.ts` resolves authored JSX names through it.
+*/
+const SML_TAG_BY_COMPONENT_NAME = Object.freeze(Object.fromEntries(SML_TAGS.map((tag) => [`${tag[0].toUpperCase()}${tag.slice(1)}`, tag])));
+/** The SML tag a JSX component name emits, or `undefined` when it is not a Samva primitive. */
+const smlTagForComponentName = (name) => SML_TAG_BY_COMPONENT_NAME[name];
+/** The JSX component name that emits an SML tag, for printing SML back into TSX. */
+const componentNameForSmlTag = (tag) => `${tag[0].toUpperCase()}${tag.slice(1)}`;
 /** 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. */
@@ -154,6 +167,6 @@ const collectVariableReferences = (document) => {
 	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 };
+export { AUXILIARY_TAGS, AttributeSchema, AttributeValueSchema, BLOCK_TAGS, CHANNEL_BY_ROOT_TAG, CHANNEL_TAGS, DEFAULT_EMAIL_WIDTH, ElementNodeSchema, INLINE_TAGS, InterpolationNodeSchema, ROOT_TAGS, SML_TAGS, SML_TAG_BY_COMPONENT_NAME, SmlDocumentSchema, SmlNodeSchema, TextNodeSchema, attributeValue, collectVariableReferences, componentNameForSmlTag, documentChannel, isHiddenNode, isRootTag, nodeLabel, numberAttribute, smlTagForComponentName, stringAttribute };
 
 //# sourceMappingURL=ast.js.map

package/dist/{checks-D-zFQt5R.js → checks-DXuERO4B.js}

@@ -58591,6 +58591,39 @@ const PRIMITIVE_FEATURES = {
 		"css-font-size"
 	]
 };
+const DELIVERY_ASSET_ATTRIBUTES = {
+	Container: ["backgroundImage"],
+	Image: ["src"],
+	Section: ["backgroundImage"],
+	Source: ["src"]
+};
+/**
+* Finds site-relative assets that work in Vite preview but cannot resolve
+* after an email leaves the author's site. Values backed entirely by one
+* variable are excluded because their runtime value is a delivery concern.
+*/
+const checkDeliveryAssetDiagnostics = (source) => {
+	const parsed = parseSml(source);
+	if (Result.isFailure(parsed)) return [];
+	const diagnostics = [];
+	const visit = (node) => {
+		if (node.kind !== "element") return;
+		for (const name of DELIVERY_ASSET_ATTRIBUTES[node.tag] ?? []) {
+			const attribute = node.attributes.find((candidate) => candidate.name === name);
+			if (attribute?.value.kind !== "string") continue;
+			const value = attribute.value.value.trim();
+			if (!value.startsWith("/") || value.startsWith("//") || /^\{\{[^{}]+\}\}$/.test(value)) continue;
+			diagnostics.push({
+				code: "site-relative-delivery-asset",
+				message: `static ${name}=${JSON.stringify(value)} will not resolve in delivered email; use an absolute URL, a data URL, or a variable-backed asset`,
+				span: attribute.valueSpan
+			});
+		}
+		for (const child of node.children) visit(child);
+	};
+	visit(parsed.success.root);
+	return diagnostics;
+};
 function isBreakingCompatibilityCheck(message) {
 	return message.startsWith("error:");
 }
@@ -58912,11 +58945,12 @@ function checkSmlCompatibility(input) {
 	const analysis = analyzeDocument(parsed.success);
 	return [
 		...predicateDiagnosticMessages(input.source, parsed.success, input.declaredVariables),
+		...checkDeliveryAssetDiagnostics(input.source).map((diagnostic) => `error: ${formatDiagnostic(input.source, diagnostic)}`),
 		...caniemailMessages(analysis.featureSlugs, profile),
 		...darkModeMessages(analysis, profile)
 	];
 }
 //#endregion
-export { worstCaseArtifactBytes as a, isBreakingCompatibilityCheck as i, checkSmlCompatibility as n, collectSmlFeatureSlugs as r, DEFAULT_EMAIL_TARGET_CLIENT_PROFILE as t };
+export { isBreakingCompatibilityCheck as a, collectSmlFeatureSlugs as i, checkDeliveryAssetDiagnostics as n, worstCaseArtifactBytes as o, checkSmlCompatibility as r, DEFAULT_EMAIL_TARGET_CLIENT_PROFILE as t };
 
-//# sourceMappingURL=checks-D-zFQt5R.js.map
+//# sourceMappingURL=checks-DXuERO4B.js.map

package/dist/checks.d.ts

@@ -1,3 +1,4 @@
+import { t as Diagnostic } from "./diagnostics-oveE-laV.js";
 //#region src/checks.d.ts
 type EmailClientDarkBehavior = "honors" | "force-inverts" | "no dark mode";
 interface EmailClientTarget {
@@ -17,10 +18,16 @@ interface EmailCompatibilityInput {
   readonly declaredVariables?: readonly string[] | undefined;
 }
 declare const DEFAULT_EMAIL_TARGET_CLIENT_PROFILE: TargetClientProfile;
+/**
+ * Finds site-relative assets that work in Vite preview but cannot resolve
+ * after an email leaves the author's site. Values backed entirely by one
+ * variable are excluded because their runtime value is a delivery concern.
+ */
+declare const checkDeliveryAssetDiagnostics: (source: string) => readonly Diagnostic[];
 declare function isBreakingCompatibilityCheck(message: string): boolean;
 declare function collectSmlFeatureSlugs(source: string): readonly string[];
 declare function worstCaseArtifactBytes(html: string): number;
 declare function checkSmlCompatibility(input: EmailCompatibilityInput): readonly string[];
 //#endregion
-export { DEFAULT_EMAIL_TARGET_CLIENT_PROFILE, EmailClientDarkBehavior, EmailClientTarget, EmailCompatibilityInput, TargetClientProfile, checkSmlCompatibility, collectSmlFeatureSlugs, isBreakingCompatibilityCheck, worstCaseArtifactBytes };
+export { DEFAULT_EMAIL_TARGET_CLIENT_PROFILE, EmailClientDarkBehavior, EmailClientTarget, EmailCompatibilityInput, TargetClientProfile, checkDeliveryAssetDiagnostics, checkSmlCompatibility, collectSmlFeatureSlugs, isBreakingCompatibilityCheck, worstCaseArtifactBytes };
 //# sourceMappingURL=checks.d.ts.map

package/dist/checks.js

@@ -1,2 +1,2 @@
-import { a as worstCaseArtifactBytes, i as isBreakingCompatibilityCheck, n as checkSmlCompatibility, r as collectSmlFeatureSlugs, t as DEFAULT_EMAIL_TARGET_CLIENT_PROFILE } from "./checks-D-zFQt5R.js";
-export { DEFAULT_EMAIL_TARGET_CLIENT_PROFILE, checkSmlCompatibility, collectSmlFeatureSlugs, isBreakingCompatibilityCheck, worstCaseArtifactBytes };
+import { a as isBreakingCompatibilityCheck, i as collectSmlFeatureSlugs, n as checkDeliveryAssetDiagnostics, o as worstCaseArtifactBytes, r as checkSmlCompatibility, t as DEFAULT_EMAIL_TARGET_CLIENT_PROFILE } from "./checks-DXuERO4B.js";
+export { DEFAULT_EMAIL_TARGET_CLIENT_PROFILE, checkDeliveryAssetDiagnostics, checkSmlCompatibility, collectSmlFeatureSlugs, isBreakingCompatibilityCheck, worstCaseArtifactBytes };

package/dist/compile-sms.d.ts

@@ -1,6 +1,6 @@
 import { t as Diagnostic } from "./diagnostics-oveE-laV.js";
-import { m as ElementNode } from "./ast-DAhnAvQN.js";
-import { a as SMS_TAG_SPECS } from "./parser-DkQKIjDa.js";
+import { m as ElementNode } from "./ast-63I-VLQx.js";
+import { a as SMS_TAG_SPECS } from "./parser-CGBS73Gz.js";
 import { t as SmsEncoding } from "./sms-segments-y4FpPilJ.js";
 //#region src/compile-sms.d.ts
 /** Documented worst-case rendered width of one `{{variable}}`. */

package/dist/compile-whatsapp.d.ts

@@ -1,6 +1,6 @@
 import { a as SmlCompileError, t as Diagnostic } from "./diagnostics-oveE-laV.js";
-import { m as ElementNode } from "./ast-DAhnAvQN.js";
-import { l as WHATSAPP_TAG_SPECS } from "./parser-DkQKIjDa.js";
+import { m as ElementNode } from "./ast-63I-VLQx.js";
+import { l as WHATSAPP_TAG_SPECS } from "./parser-CGBS73Gz.js";
 import { Result } from "effect";
 //#region src/compile-whatsapp.d.ts
 type WhatsAppSpecs = typeof WHATSAPP_TAG_SPECS;

package/dist/compile.d.ts

@@ -1,7 +1,5 @@
-import { a as SmlCompileError, o as SmlParseError, t as Diagnostic } from "./diagnostics-oveE-laV.js";
-import { C as SmlDocument } from "./ast-DAhnAvQN.js";
-import { a as ThemeLayers, s as TokenTable } from "./theme-6ApjjiBo.js";
-import { Declaration } from "./registry.js";
+import { a as SmlCompileError, o as SmlParseError } from "./diagnostics-oveE-laV.js";
+import { w as SmlDocument } from "./ast-63I-VLQx.js";
 import { CompiledSms } from "./compile-sms.js";
 import { CompiledWhatsApp } from "./compile-whatsapp.js";
 import { Result } from "effect";
@@ -9,85 +7,12 @@ import { Result } from "effect";
 declare const COMPILER_VERSION = "0.1.0";
 //#endregion
 //#region src/compile.d.ts
-type CompileBase = "outlook-safe" | "modern";
-/** Email-only knobs; sms/whatsapp compile ignores both (no theming, no bases). */
-interface CompileOptions {
-  readonly base?: CompileBase | undefined;
-  readonly theme?: (Omit<ThemeLayers, "base"> & {
-    readonly base?: TokenTable | undefined;
-  }) | undefined;
-  /** Omit editor DOM instrumentation from exported/sent HTML artifacts. */
-  readonly stripInstrumentation?: boolean | undefined;
-}
-interface CompiledEmail {
-  readonly channel: "email";
-  readonly html: string;
-  /** Plain-text alternative ({{vars}} verbatim, envelope metadata skipped). */
-  readonly text: string;
-  /** Authored <Subject> text with interpolation tokens preserved; null when absent. */
-  readonly subjectText: string | null;
-  readonly warnings: ReadonlyArray<Diagnostic>;
-  readonly base: CompileBase;
-  readonly compilerVersion: string;
-}
-/**
- * The compile result, discriminated on `channel` — which the root tag
- * declares. email → HTML + plain-text artifacts; sms → body + segment math;
- * whatsapp → whatsapp_template_variants column shapes.
- */
-type CompiledTemplate = CompiledEmail | CompiledSms | CompiledWhatsApp;
-interface HtmlElement {
-  readonly kind: "element";
-  readonly tag: string;
-  /** Ordered; serialized before style. */
-  readonly attrs: ReadonlyArray<readonly [string, string]>;
-  /** Serialized as style="" in order — CSS last-wins handles overrides. */
-  readonly style: ReadonlyArray<Declaration>;
-  readonly children: ReadonlyArray<HtmlNode>;
-  readonly void?: boolean | undefined;
-}
-type HtmlTextNode = {
-  readonly kind: "text";
-  readonly value: string;
-};
-type HtmlRawNode = {
-  readonly kind: "raw";
-  readonly html: string;
-};
-/** Children spliced into the parent's block flow — <If> lowers to one. */
-interface HtmlFragment {
-  readonly kind: "fragment";
-  readonly children: ReadonlyArray<HtmlNode>;
-}
-type HtmlNode = HtmlElement | HtmlTextNode | HtmlRawNode | HtmlFragment;
-interface CompileHeadStyleAsset {
-  readonly kind: "style";
-  readonly css: string;
-  /** Serialized style asset as emitted in <head>. */
-  readonly html: string;
-  /** True for the Outlook-hidden webfont style block. */
-  readonly outlookHidden: boolean;
-}
-interface CompileHeadAssets {
-  readonly styles: ReadonlyArray<CompileHeadStyleAsset>;
-  readonly links: ReadonlyArray<HtmlElement>;
-}
-type HtmlNodeIdMap = Readonly<Record<string, ReadonlyArray<HtmlElement>>>;
-interface CompiledEmailArtifact extends CompiledEmail {
-  /** Resolved primary document width in pixels. */
-  readonly width: number;
-  readonly tree: HtmlElement;
-  readonly doctype: string;
-  readonly headAssets: CompileHeadAssets;
-  readonly nodeIdMap: HtmlNodeIdMap;
-}
-type CompiledTemplateArtifact = CompiledEmailArtifact | CompiledSms | CompiledWhatsApp;
-declare const serializeHtmlNode: (node: HtmlNode) => string;
-/** Compile a parsed document; the root tag routes to its channel backend. */
-declare const compileSml: (document: SmlDocument, options?: CompileOptions) => Result.Result<CompiledTemplate, SmlCompileError>;
-declare const compileSmlArtifact: (document: SmlDocument, options?: CompileOptions) => Result.Result<CompiledTemplateArtifact, SmlCompileError>;
-declare const compileSource: (source: string, options?: CompileOptions) => Result.Result<CompiledTemplate, SmlParseError | SmlCompileError>;
-declare const compileSourceArtifact: (source: string, options?: CompileOptions) => Result.Result<CompiledTemplateArtifact, SmlParseError | SmlCompileError>;
+/** Structured channel payloads compiled from recorded SML. */
+type CompiledTemplate = CompiledSms | CompiledWhatsApp;
+/** Compile a structured document; email definitions execute through the email runtime. */
+declare const compileSml: (document: SmlDocument) => Result.Result<CompiledTemplate, SmlCompileError>;
+/** Parse and compile a structured SMS or WhatsApp document. */
+declare const compileSource: (source: string) => Result.Result<CompiledTemplate, SmlParseError | SmlCompileError>;
 //#endregion
-export { COMPILER_VERSION, CompileBase, CompileHeadAssets, CompileHeadStyleAsset, CompileOptions, CompiledEmail, CompiledEmailArtifact, CompiledTemplate, CompiledTemplateArtifact, HtmlElement, HtmlFragment, HtmlNode, HtmlNodeIdMap, HtmlRawNode, HtmlTextNode, compileSml, compileSmlArtifact, compileSource, compileSourceArtifact, serializeHtmlNode };
+export { COMPILER_VERSION, CompiledTemplate, compileSml, compileSource };
 //# sourceMappingURL=compile.d.ts.map