@samva/markup 0.4.0 → 0.5.0

package/dist/corpus-CM7rKX41.d.ts

@@ -0,0 +1,106 @@
+import { n as OwnedShowcaseId, t as BrandRecreationShowcaseId } from "./showcase-dvJMn-Lo.js";
+import { Result } from "better-result";
+//#region presets/corpus.d.ts
+type TemplateCorpusKind = "owned-editable-sml" | "brand-recreation-sml" | "inspiration-reference";
+declare const templateFacetOptions: {
+  readonly jobType: readonly ["account-access", "commerce", "product-communication", "lifecycle", "publishing-campaigns"];
+  readonly lifecycle: readonly ["acquisition", "activation", "engagement", "transaction", "retention", "recovery"];
+  readonly industry: readonly ["saas", "ecommerce", "developer-tools", "newsletters-media"];
+  readonly season: readonly ["evergreen", "seasonal"];
+  readonly audience: readonly ["product-users", "customers", "members", "readers", "shoppers", "teams"];
+  readonly design: readonly ["minimal", "branded", "editorial", "data-heavy", "single-cta"];
+  readonly brandProvenance: readonly ["samva-original", "third-party-reference"];
+};
+/** Every facet dimension, with the closed value list each accepts. */
+type TemplateFacetSet = { readonly [Dimension in keyof typeof templateFacetOptions]: ReadonlyArray<(typeof templateFacetOptions)[Dimension][number]>; };
+interface CorpusReview {
+  readonly state: "draft" | "approved" | "rejected";
+  readonly reviewedBy: string;
+  readonly reviewedAt: string;
+  readonly notes: string;
+}
+interface CorpusDisplay {
+  readonly state: "hidden" | "public";
+  readonly attributionLabel: string;
+}
+interface CorpusRetention {
+  readonly policy: "retain-until-withdrawn" | "retain-while-linked";
+  readonly reviewedAt: string;
+}
+interface CorpusTakedown {
+  readonly state: "active" | "removed";
+  readonly contact: string;
+  readonly procedureUrl: string;
+}
+interface OwnedEditablePreset {
+  readonly type: "OwnedEditablePreset";
+  readonly corpusKind: "owned-editable-sml";
+  readonly provenance: {
+    readonly owner: "Samva";
+    readonly sourcePath: string;
+    readonly recordedAt: string;
+  };
+  readonly review: CorpusReview;
+  readonly display: CorpusDisplay;
+  readonly retention: CorpusRetention;
+  readonly takedown: CorpusTakedown;
+}
+interface BrandRecreationPreset {
+  readonly type: "BrandRecreationPreset";
+  readonly corpusKind: "brand-recreation-sml";
+  readonly provenance: {
+    readonly owner: "Samva";
+    readonly sourcePath: string;
+    readonly recordedAt: string;
+    /** The brand whose own email is recreated, named on every public surface. */
+    readonly brand: string;
+    /** What that brand's email does, in the customer's words. */
+    readonly subject: string;
+    readonly reviewedNote: string;
+  };
+  readonly review: CorpusReview;
+  readonly display: CorpusDisplay;
+  readonly retention: CorpusRetention;
+  readonly takedown: CorpusTakedown;
+}
+/** Clean-room recreations of a named brand's own email, authored as editable Samva projects. */
+declare const brandRecreationProvenance: Record<BrandRecreationShowcaseId, BrandRecreationPreset["provenance"]>;
+/**
+ * Owned presets authored as complete showcase projects with their own stylesheet and assets.
+ * Every other owned preset is the single module `packages/markup/presets/<id>.tsx`.
+ */
+declare const ownedShowcasePresetSources: Record<OwnedShowcaseId, string>;
+declare const ownedPresetSourcePath: (id: string) => string;
+interface InspirationReference {
+  readonly type: "InspirationReference";
+  readonly corpusKind: "inspiration-reference";
+  readonly provenance: {
+    readonly publisher: string;
+    readonly sourceUrl: string;
+    readonly capturedAt: string;
+    readonly rightsBasis: "display-link-and-commentary" | "permission";
+  };
+  readonly review: CorpusReview;
+  readonly display: CorpusDisplay;
+  readonly retention: CorpusRetention;
+  readonly takedown: CorpusTakedown;
+}
+type TemplateCorpusRecord = OwnedEditablePreset | BrandRecreationPreset | InspirationReference;
+interface PublicCorpusRegistration {
+  readonly id: string;
+  readonly corpus: TemplateCorpusRecord;
+  readonly facets: TemplateFacetSet;
+}
+interface PublicCorpusRegistrationIssue {
+  readonly id: string;
+  readonly message: string;
+}
+/** Decode and gate a record before it can enter any public projection. */
+declare const registerPublicCorpusEntry: (input: unknown) => Result<PublicCorpusRegistration, PublicCorpusRegistrationIssue>;
+/** A facet selection: any dimension may be left unselected. */
+type TemplateFacetQuery = Partial<TemplateFacetSet>;
+/** Strict intersection: every selected value in every selected dimension must match. */
+declare const matchesTemplateFacets: (facets: TemplateFacetSet, query: TemplateFacetQuery) => boolean;
+//#endregion
+export { PublicCorpusRegistrationIssue as a, TemplateFacetQuery as c, matchesTemplateFacets as d, ownedPresetSourcePath as f, templateFacetOptions as h, PublicCorpusRegistration as i, TemplateFacetSet as l, registerPublicCorpusEntry as m, InspirationReference as n, TemplateCorpusKind as o, ownedShowcasePresetSources as p, OwnedEditablePreset as r, TemplateCorpusRecord as s, BrandRecreationPreset as t, brandRecreationProvenance as u };
+//# sourceMappingURL=corpus-CM7rKX41.d.ts.map

package/dist/{css-ar2lU3NC.d.ts → css-DoNc7CiC.d.ts}

@@ -1,10 +1,9 @@
-import "./source-locations-BCJQnIfU.js";
-import { r as EmailDiagnostic } from "./diagnostics-Djd9ckLg.js";
-import { m as EmailNode } from "./elements-DtwKlFVH.js";
+import { r as EmailDiagnostic } from "./diagnostics-eFM9A_TU.js";
+import { m as EmailNode } from "./elements-ChJULZlh.js";
 import "css-tree";
 //#region src/email/selectors.d.ts
 type EmailElementNode = Extract<EmailNode, {
-  _tag: "Element";
+  type: "Element";
 }>;
 interface AttributeTest {
   readonly name: string;
@@ -81,4 +80,4 @@ declare const parseStylesheet: (source: string, options?: {
 }) => Stylesheet;
 //#endregion
 export { compileSelector as a, CompiledSelector as c, matchesSelector as d, Stylesheet as i, Compound as l, CssRule as n, parseStylesheet as o, Specificity as r, Ancestry as s, CssDeclaration as t, classListOf as u };
-//# sourceMappingURL=css-ar2lU3NC.d.ts.map
+//# sourceMappingURL=css-DoNc7CiC.d.ts.map

package/dist/diagnostics-CqepLcpI.d.ts

@@ -0,0 +1,47 @@
+//#region src/diagnostics.d.ts
+interface Span {
+  readonly start: number;
+  readonly end: number;
+}
+interface DiagnosticRepair {
+  readonly kind: "replace-class" | "remove-class" | "rewrite-node" | "use-primitive";
+  readonly raw?: string | undefined;
+  readonly suggestions: ReadonlyArray<string>;
+  readonly explanation: string;
+}
+interface Diagnostic {
+  readonly code: string;
+  readonly message: string;
+  readonly span: Span;
+  readonly repair?: DiagnosticRepair | undefined;
+}
+declare const SmlParseError_base: import("better-result").TaggedErrorClass<"SmlParseError">;
+declare class SmlParseError extends SmlParseError_base<{
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  readonly message: string;
+}> {
+  constructor(args: {
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+  });
+}
+declare const SmlCompileError_base: import("better-result").TaggedErrorClass<"SmlCompileError">;
+declare class SmlCompileError extends SmlCompileError_base<{
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  readonly message: string;
+}> {
+  constructor(args: {
+    readonly diagnostics: ReadonlyArray<Diagnostic>;
+  });
+}
+/** Newline-offset line map. Build once per source, query with `lineColumn`. */
+declare const buildLineMap: (source: string) => ReadonlyArray<number>;
+/** 1-based line/column for an absolute offset, via binary search. */
+declare const lineColumn: (lineMap: ReadonlyArray<number>, offset: number) => {
+  readonly line: number;
+  readonly column: number;
+};
+/** "line 12:8 unknown class ..." — the shape agents iterate on. */
+declare const formatDiagnostic: (source: string, diagnostic: Diagnostic) => string;
+//#endregion
+export { Span as a, lineColumn as c, SmlParseError as i, DiagnosticRepair as n, buildLineMap as o, SmlCompileError as r, formatDiagnostic as s, Diagnostic as t };
+//# sourceMappingURL=diagnostics-CqepLcpI.d.ts.map

package/dist/diagnostics-eFM9A_TU.d.ts

@@ -0,0 +1,46 @@
+import { i as JsxSourceLocation } from "./source-locations-D6Te6Gy1.js";
+//#region src/email/diagnostics.d.ts
+type EmailDiagnosticSeverity = "error" | "warning" | "info";
+/** What the emitted document establishes beyond the client feature matrix. */
+interface EmailCompatibilityAssessment {
+  readonly assessment: "risk" | "degradation" | "unverified" | "not-applicable";
+  /** A short description of the consequence or the remaining verification. */
+  readonly title: string;
+}
+interface EmailDiagnostic {
+  /** Stable identifier, e.g. `unsupported-element` or `caniemail/css-border-radius`. */
+  readonly code: string;
+  readonly severity: EmailDiagnosticSeverity;
+  /** States what is wrong and what to write instead. */
+  readonly message: string;
+  /** Innermost authoring element first, then each enclosing component call site. */
+  readonly origins: ReadonlyArray<JsxSourceLocation>;
+  /** Target clients a compatibility finding applies to. */
+  readonly clients?: ReadonlyArray<string> | undefined;
+  /** Partial-support notes and other caveats a client matrix carries. */
+  readonly notes?: string | undefined;
+  /** Which pinned rule data produced the finding. */
+  readonly provenance?: string | undefined;
+  /** Declared fixtures whose rendered output produced this finding. */
+  readonly fixtures?: ReadonlyArray<string> | undefined;
+  /** Source chains for every located emitted occurrence; origins identifies the first. */
+  readonly occurrences?: ReadonlyArray<ReadonlyArray<JsxSourceLocation>> | undefined;
+  /** Compatibility observations are not automatically defects or proof of client rendering. */
+  readonly compatibility?: EmailCompatibilityAssessment | undefined;
+}
+declare const EmailCompileError_base: import("better-result").TaggedErrorClass<"EmailCompileError">;
+declare class EmailCompileError extends EmailCompileError_base<{
+  readonly diagnostics: ReadonlyArray<EmailDiagnostic>;
+  readonly message: string;
+}> {
+  constructor(args: {
+    readonly diagnostics: ReadonlyArray<EmailDiagnostic>;
+  });
+}
+/** `emails/welcome.tsx:12:3 unsupported-element: …` — the shape agents iterate on. */
+declare const formatEmailDiagnostic: (diagnostic: EmailDiagnostic) => string;
+/** True when a set of findings must stop the compile or refuse a publication. */
+declare const hasBlockingDiagnostic: (diagnostics: readonly EmailDiagnostic[]) => boolean;
+//#endregion
+export { formatEmailDiagnostic as a, EmailDiagnosticSeverity as i, EmailCompileError as n, hasBlockingDiagnostic as o, EmailDiagnostic as r, EmailCompatibilityAssessment as t };
+//# sourceMappingURL=diagnostics-eFM9A_TU.d.ts.map

package/dist/diagnostics.d.ts

@@ -1,2 +1,2 @@
-import { a as SmlCompileError, c as SpanSchema, d as lineColumn, i as DiagnosticSchema, l as buildLineMap, n as DiagnosticRepair, o as SmlParseError, r as DiagnosticRepairSchema, s as Span, t as Diagnostic, u as formatDiagnostic } from "./diagnostics-oveE-laV.js";
-export { Diagnostic, DiagnosticRepair, DiagnosticRepairSchema, DiagnosticSchema, SmlCompileError, SmlParseError, Span, SpanSchema, buildLineMap, formatDiagnostic, lineColumn };
+import { a as Span, c as lineColumn, i as SmlParseError, n as DiagnosticRepair, o as buildLineMap, r as SmlCompileError, s as formatDiagnostic, t as Diagnostic } from "./diagnostics-CqepLcpI.js";
+export { Diagnostic, DiagnosticRepair, SmlCompileError, SmlParseError, Span, buildLineMap, formatDiagnostic, lineColumn };

package/dist/diagnostics.js

@@ -1,34 +1,20 @@
-import { Schema } from "effect";
+import { TaggedError } from "better-result";
 //#region src/diagnostics.ts
-const SpanSchema = Schema.Struct({
-	start: Schema.Finite,
-	end: Schema.Finite
-});
-const DiagnosticRepairSchema = Schema.Struct({
-	kind: Schema.Literals([
-		"replace-class",
-		"remove-class",
-		"rewrite-node",
-		"use-primitive"
-	]),
-	raw: Schema.optional(Schema.String),
-	suggestions: Schema.Array(Schema.String),
-	explanation: Schema.String
-});
-const DiagnosticSchema = Schema.Struct({
-	code: Schema.String,
-	message: Schema.String,
-	span: SpanSchema,
-	repair: Schema.optional(DiagnosticRepairSchema)
-});
-var SmlParseError = class extends Schema.TaggedError()("SmlParseError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
-	get message() {
-		return this.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+const diagnosticsMessage = (diagnostics) => diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+var SmlParseError = class extends TaggedError("SmlParseError") {
+	constructor(args) {
+		super({
+			diagnostics: args.diagnostics,
+			message: diagnosticsMessage(args.diagnostics)
+		});
 	}
 };
-var SmlCompileError = class extends Schema.TaggedError()("SmlCompileError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
-	get message() {
-		return this.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+var SmlCompileError = class extends TaggedError("SmlCompileError") {
+	constructor(args) {
+		super({
+			diagnostics: args.diagnostics,
+			message: diagnosticsMessage(args.diagnostics)
+		});
 	}
 };
 /** Newline-offset line map. Build once per source, query with `lineColumn`. */
@@ -60,6 +46,6 @@ const formatDiagnostic = (source, diagnostic) => {
 	return `line ${line}:${column} ${diagnostic.message}`;
 };
 //#endregion
-export { DiagnosticRepairSchema, DiagnosticSchema, SmlCompileError, SmlParseError, SpanSchema, buildLineMap, formatDiagnostic, lineColumn };
+export { SmlCompileError, SmlParseError, buildLineMap, formatDiagnostic, lineColumn };
 
 //# sourceMappingURL=diagnostics.js.map

package/dist/{elements-DtwKlFVH.d.ts → elements-ChJULZlh.d.ts}

@@ -1,169 +1,48 @@
-import { i as JsxSourceLocation } from "./source-locations-BCJQnIfU.js";
-import { r as EmailDiagnostic } from "./diagnostics-Djd9ckLg.js";
-import { Data } from "effect";
+import { i as JsxSourceLocation } from "./source-locations-D6Te6Gy1.js";
+import { r as EmailDiagnostic } from "./diagnostics-eFM9A_TU.js";
 //#region src/email/jsx-runtime.d.ts
 /** Derived authoring tree; source stays canonical. Origins run from inner element to component call sites. */
-type EmailNode = Data.TaggedEnum<{
-  Text: {
-    readonly value: string;
-  };
-  Element: {
-    readonly tag: string;
-    readonly props: Readonly<Record<string, unknown>>;
-    readonly children: readonly EmailNode[];
-    readonly origins: readonly JsxSourceLocation[];
-    /**
-     * True when this element is written at `origins[0]`; false when a compiler
-     * primitive generated it and `origins[0]` is the call site that asked for
-     * it. Both point at the same authoring target, but only an authored element
-     * can have its own props edited there.
-     */
-    readonly authored: boolean;
-  };
-  Fragment: {
-    readonly children: readonly EmailNode[];
-  };
+type EmailNode = {
+  readonly type: "Text";
+  readonly value: string;
+} | {
+  readonly type: "Element";
+  readonly tag: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly children: readonly EmailNode[];
+  readonly origins: readonly JsxSourceLocation[];
   /**
-   * Compatibility markup a compiler primitive emits verbatim — conditional
-   * comments and VML. Only the primitives in `./components` construct it;
-   * nothing an author passes as a string reaches this node.
+   * True when this element is written at `origins[0]`; false when a compiler
+   * primitive generated it and `origins[0]` is the call site that asked for
+   * it. Both point at the same authoring target, but only an authored element
+   * can have its own props edited there.
    */
-  Raw: {
-    readonly html: string;
-    readonly text: string;
-    readonly origins: readonly JsxSourceLocation[];
-  };
+  readonly authored: boolean;
+} | {
+  readonly type: "Fragment";
+  readonly children: readonly EmailNode[];
+} |
+/**
+ * Compatibility markup a compiler primitive emits verbatim — conditional
+ * comments and VML. Only the primitives in `./components` construct it;
+ * nothing an author passes as a string reaches this node.
+ */
+{
+  readonly type: "Raw";
+  readonly html: string;
+  readonly text: string;
+  readonly origins: readonly JsxSourceLocation[];
+};
+type EmailNodeOf<Type extends EmailNode["type"]> = Extract<EmailNode, {
+  readonly type: Type;
 }>;
+type EmailNodeFields<Type extends EmailNode["type"]> = Omit<EmailNodeOf<Type>, "type">;
+/** Constructors for the authoring tree. The tree is data; nothing here validates it. */
 declare const EmailNode: {
-  readonly $is: <Tag extends "Element" | "Fragment" | "Raw" | "Text">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Element";
-    readonly tag: string;
-    readonly props: Readonly<Record<string, unknown>>;
-    readonly children: readonly EmailNode[];
-    readonly origins: readonly JsxSourceLocation[];
-    readonly authored: boolean;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Fragment";
-    readonly children: readonly EmailNode[];
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Raw";
-    readonly html: string;
-    readonly text: string;
-    readonly origins: readonly JsxSourceLocation[];
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Text";
-    readonly value: string;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Element" | "Fragment" | "Raw" | "Text"]: (args: Extract<{
-      readonly _tag: "Element";
-      readonly tag: string;
-      readonly props: Readonly<Record<string, unknown>>;
-      readonly children: readonly EmailNode[];
-      readonly origins: readonly JsxSourceLocation[];
-      readonly authored: boolean;
-    } | {
-      readonly _tag: "Fragment";
-      readonly children: readonly EmailNode[];
-    } | {
-      readonly _tag: "Raw";
-      readonly html: string;
-      readonly text: string;
-      readonly origins: readonly JsxSourceLocation[];
-    } | {
-      readonly _tag: "Text";
-      readonly value: string;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Element";
-      readonly tag: string;
-      readonly props: Readonly<Record<string, unknown>>;
-      readonly children: readonly EmailNode[];
-      readonly origins: readonly JsxSourceLocation[];
-      readonly authored: boolean;
-    } | {
-      readonly _tag: "Fragment";
-      readonly children: readonly EmailNode[];
-    } | {
-      readonly _tag: "Raw";
-      readonly html: string;
-      readonly text: string;
-      readonly origins: readonly JsxSourceLocation[];
-    } | {
-      readonly _tag: "Text";
-      readonly value: string;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Element" | "Fragment" | "Raw" | "Text"]>>;
-    <Cases extends { readonly [Tag in "Element" | "Fragment" | "Raw" | "Text"]: (args: Extract<{
-      readonly _tag: "Element";
-      readonly tag: string;
-      readonly props: Readonly<Record<string, unknown>>;
-      readonly children: readonly EmailNode[];
-      readonly origins: readonly JsxSourceLocation[];
-      readonly authored: boolean;
-    } | {
-      readonly _tag: "Fragment";
-      readonly children: readonly EmailNode[];
-    } | {
-      readonly _tag: "Raw";
-      readonly html: string;
-      readonly text: string;
-      readonly origins: readonly JsxSourceLocation[];
-    } | {
-      readonly _tag: "Text";
-      readonly value: string;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Element";
-      readonly tag: string;
-      readonly props: Readonly<Record<string, unknown>>;
-      readonly children: readonly EmailNode[];
-      readonly origins: readonly JsxSourceLocation[];
-      readonly authored: boolean;
-    } | {
-      readonly _tag: "Fragment";
-      readonly children: readonly EmailNode[];
-    } | {
-      readonly _tag: "Raw";
-      readonly html: string;
-      readonly text: string;
-      readonly origins: readonly JsxSourceLocation[];
-    } | {
-      readonly _tag: "Text";
-      readonly value: string;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Element" | "Fragment" | "Raw" | "Text"]>>;
-  };
-  readonly Element: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Element";
-    readonly tag: string;
-    readonly props: Readonly<Record<string, unknown>>;
-    readonly children: readonly EmailNode[];
-    readonly origins: readonly JsxSourceLocation[];
-    readonly authored: boolean;
-  }, "_tag">;
-  readonly Fragment: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Fragment";
-    readonly children: readonly EmailNode[];
-  }, "_tag">;
-  readonly Raw: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Raw";
-    readonly html: string;
-    readonly text: string;
-    readonly origins: readonly JsxSourceLocation[];
-  }, "_tag">;
-  readonly Text: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Text";
-    readonly value: string;
-  }, "_tag">;
+  readonly Text: (fields: EmailNodeFields<"Text">) => EmailNodeOf<"Text">;
+  readonly Element: (fields: EmailNodeFields<"Element">) => EmailNodeOf<"Element">;
+  readonly Fragment: (fields: EmailNodeFields<"Fragment">) => EmailNodeOf<"Fragment">;
+  readonly Raw: (fields: EmailNodeFields<"Raw">) => EmailNodeOf<"Raw">;
 };
 type EmailChild = EmailNode | string | number | boolean | null | undefined | readonly EmailChild[];
 type EmailComponent<P = never> = (props: P) => EmailChild;
@@ -817,4 +696,4 @@ type ChildrenProp<Content extends EmailElementSpec["content"]> = Content extends
 type EmailIntrinsicElements = { readonly [Tag in EmailTag]: EmailGlobalProps & AttributeProps<typeof EMAIL_GLOBAL_ATTRIBUTES> & AttributeProps<(typeof EMAIL_ELEMENTS)[Tag]["attributes"]> & ChildrenProp<(typeof EMAIL_ELEMENTS)[Tag]["content"]>; };
 //#endregion
 export { reportEmailDiagnostic as C, rawMarkup as S, currentEmailOrigins as _, EmailGlobalProps as a, jsxs as b, EmailStyle as c, isUrlAttribute as d, EmailChild as f, JSX as g, Fragment as h, EmailElementSpec as i, EmailTag as l, EmailNode as m, EMAIL_GLOBAL_ATTRIBUTES as n, EmailIntrinsicElements as o, EmailComponent as p, EmailAttributeSpec as r, EmailLayout as s, EMAIL_ELEMENTS as t, emailElement as u, drainEmailDiagnostics as v, normalizeChildren as x, jsx as y };
-//# sourceMappingURL=elements-DtwKlFVH.d.ts.map
+//# sourceMappingURL=elements-ChJULZlh.d.ts.map

package/dist/email/components.d.ts

@@ -1,4 +1,4 @@
-import { c as EmailStyle, f as EmailChild, m as EmailNode } from "../elements-DtwKlFVH.js";
+import { c as EmailStyle, f as EmailChild, m as EmailNode } from "../elements-ChJULZlh.js";
 //#region src/email/components.d.ts
 /** Marks the hidden preview block so the renderer can read it back and the text lane can keep it. */
 declare const PREHEADER_ATTRIBUTE = "data-samva-preheader";

package/dist/email/diagnostics.d.ts

@@ -1,2 +1,2 @@
-import { a as formatEmailDiagnostic, i as EmailDiagnosticSeverity, n as EmailCompileError, o as hasBlockingDiagnostic, r as EmailDiagnostic, t as EmailCompatibilityAssessment } from "../diagnostics-Djd9ckLg.js";
+import { a as formatEmailDiagnostic, i as EmailDiagnosticSeverity, n as EmailCompileError, o as hasBlockingDiagnostic, r as EmailDiagnostic, t as EmailCompatibilityAssessment } from "../diagnostics-eFM9A_TU.js";
 export { EmailCompatibilityAssessment, EmailCompileError, EmailDiagnostic, EmailDiagnosticSeverity, formatEmailDiagnostic, hasBlockingDiagnostic };

package/dist/email/diagnostics.js

@@ -1,46 +1,11 @@
-import { JsxSourceLocation } from "../source-locations.js";
-import { Schema } from "effect";
+import { TaggedError } from "better-result";
 //#region src/email/diagnostics.ts
-const EmailDiagnosticSeverity = Schema.Literals([
-	"error",
-	"warning",
-	"info"
-]);
-/** What the emitted document establishes beyond the client feature matrix. */
-const EmailCompatibilityAssessment = Schema.Struct({
-	assessment: Schema.Literals([
-		"risk",
-		"degradation",
-		"unverified",
-		"not-applicable"
-	]),
-	/** A short description of the consequence or the remaining verification. */
-	title: Schema.String
-});
-const EmailDiagnostic = Schema.Struct({
-	/** Stable identifier, e.g. `unsupported-element` or `caniemail/css-border-radius`. */
-	code: Schema.String,
-	severity: EmailDiagnosticSeverity,
-	/** States what is wrong and what to write instead. */
-	message: Schema.String,
-	/** Innermost authoring element first, then each enclosing component call site. */
-	origins: Schema.Array(JsxSourceLocation),
-	/** Target clients a compatibility finding applies to. */
-	clients: Schema.optional(Schema.Array(Schema.String)),
-	/** Partial-support notes and other caveats a client matrix carries. */
-	notes: Schema.optional(Schema.String),
-	/** Which pinned rule data produced the finding. */
-	provenance: Schema.optional(Schema.String),
-	/** Declared fixtures whose rendered output produced this finding. */
-	fixtures: Schema.optional(Schema.Array(Schema.String)),
-	/** Source chains for every located emitted occurrence; origins identifies the first. */
-	occurrences: Schema.optional(Schema.Array(Schema.Array(JsxSourceLocation))),
-	/** Compatibility observations are not automatically defects or proof of client rendering. */
-	compatibility: Schema.optional(EmailCompatibilityAssessment)
-});
-var EmailCompileError = class extends Schema.TaggedError()("EmailCompileError", { diagnostics: Schema.Array(EmailDiagnostic) }) {
-	get message() {
-		return this.diagnostics.map(formatEmailDiagnostic).join("\n");
+var EmailCompileError = class extends TaggedError("EmailCompileError") {
+	constructor(args) {
+		super({
+			diagnostics: args.diagnostics,
+			message: args.diagnostics.map(formatEmailDiagnostic).join("\n")
+		});
 	}
 };
 /** `emails/welcome.tsx:12:3 unsupported-element: …` — the shape agents iterate on. */
@@ -51,6 +16,6 @@ const formatEmailDiagnostic = (diagnostic) => {
 /** True when a set of findings must stop the compile or refuse a publication. */
 const hasBlockingDiagnostic = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error");
 //#endregion
-export { EmailCompatibilityAssessment, EmailCompileError, EmailDiagnostic, EmailDiagnosticSeverity, formatEmailDiagnostic, hasBlockingDiagnostic };
+export { EmailCompileError, formatEmailDiagnostic, hasBlockingDiagnostic };
 
 //# sourceMappingURL=diagnostics.js.map

package/dist/email/elements.d.ts

@@ -1,2 +1,2 @@
-import { a as EmailGlobalProps, c as EmailStyle, d as isUrlAttribute, i as EmailElementSpec, l as EmailTag, n as EMAIL_GLOBAL_ATTRIBUTES, o as EmailIntrinsicElements, r as EmailAttributeSpec, s as EmailLayout, t as EMAIL_ELEMENTS, u as emailElement } from "../elements-DtwKlFVH.js";
+import { a as EmailGlobalProps, c as EmailStyle, d as isUrlAttribute, i as EmailElementSpec, l as EmailTag, n as EMAIL_GLOBAL_ATTRIBUTES, o as EmailIntrinsicElements, r as EmailAttributeSpec, s as EmailLayout, t as EMAIL_ELEMENTS, u as emailElement } from "../elements-ChJULZlh.js";
 export { EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, EmailAttributeSpec, EmailElementSpec, EmailGlobalProps, EmailIntrinsicElements, EmailLayout, EmailStyle, EmailTag, emailElement, isUrlAttribute };

package/dist/email/html.d.ts

@@ -1,5 +1,5 @@
-import { r as EmailDiagnostic } from "../diagnostics-Djd9ckLg.js";
-import { m as EmailNode } from "../elements-DtwKlFVH.js";
+import { r as EmailDiagnostic } from "../diagnostics-eFM9A_TU.js";
+import { m as EmailNode } from "../elements-ChJULZlh.js";
 import { EmittedPosition } from "./selection.js";
 //#region src/email/html.d.ts
 /** Escape a value for element content. */

package/dist/email/html.js

@@ -1,6 +1,6 @@
+import { n as isObject } from "../guards-eV1qLbf2.js";
 import { EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, emailElement } from "./elements.js";
 import { INSTANCE_PATH_ATTRIBUTE } from "./selection.js";
-import { Predicate } from "effect";
 //#region src/email/html.ts
 /** Escape a value for element content. */
 const escapeText = (value) => value.replace(/[&<>]/g, (character) => ({
@@ -136,7 +136,7 @@ const attributes = (sink, tag, spec, props, origins) => {
 		}
 		if (name === "style") {
 			if (value === void 0 || value === null) continue;
-			if (!Predicate.isObject(value) || Array.isArray(value)) {
+			if (!isObject(value) || Array.isArray(value)) {
 				report(sink, "invalid-style", `<${tag} style> must be a property object, for example style={{ backgroundColor: "#fff" }}.`, origins);
 				continue;
 			}
@@ -172,24 +172,24 @@ const attributes = (sink, tag, spec, props, origins) => {
 	return emitted.join("");
 };
 /** Fragments are transparent to a content model; raw compatibility markup is not content. */
-const contentChildren = (children) => children.flatMap((child) => child._tag === "Fragment" ? contentChildren(child.children) : [child]);
+const contentChildren = (children) => children.flatMap((child) => child.type === "Fragment" ? contentChildren(child.children) : [child]);
 const checkContentModel = (sink, tag, spec, children, origins) => {
 	if (spec.content === "void") {
 		if (contentChildren(children).length > 0) report(sink, "void-element-children", `<${tag}> cannot have children.`, origins);
 		return;
 	}
 	if (spec.content === "text" || spec.content === "raw") {
-		for (const child of contentChildren(children)) if (child._tag !== "Text") report(sink, "invalid-content", `<${tag}> accepts text only.`, child._tag === "Element" ? child.origins : origins);
+		for (const child of contentChildren(children)) if (child.type !== "Text") report(sink, "invalid-content", `<${tag}> accepts text only.`, child.type === "Element" ? child.origins : origins);
 		return;
 	}
 	if (spec.childElements === void 0) return;
 	for (const child of contentChildren(children)) {
-		if (child._tag === "Raw") continue;
-		if (child._tag === "Text") {
+		if (child.type === "Raw") continue;
+		if (child.type === "Text") {
 			if (child.value.trim() !== "") report(sink, "invalid-content", `<${tag}> cannot contain text directly; put it inside <${spec.childElements[0]}>.`, origins);
 			continue;
 		}
-		if (child._tag === "Element" && !spec.childElements.includes(child.tag)) report(sink, "invalid-content", `<${tag}> accepts only ${spec.childElements.map((name) => `<${name}>`).join(", ")}; found <${child.tag}>.`, child.origins);
+		if (child.type === "Element" && !spec.childElements.includes(child.tag)) report(sink, "invalid-content", `<${tag}> accepts only ${spec.childElements.map((name) => `<${name}>`).join(", ")}; found <${child.tag}>.`, child.origins);
 	}
 };
 /** Every write goes through here so `sink.written` stays the emitted offset. */
@@ -198,7 +198,7 @@ const emit = (sink, text) => {
 	return text;
 };
 const serialize = (sink, node, parentPath, counter) => {
-	switch (node._tag) {
+	switch (node.type) {
 		case "Text": return emit(sink, escapeText(node.value));
 		case "Raw": return emit(sink, node.html);
 		case "Fragment": return node.children.map((child) => serialize(sink, child, parentPath, counter)).join("");
@@ -215,7 +215,7 @@ const serialize = (sink, node, parentPath, counter) => {
 			}
 			checkContentModel(sink, node.tag, spec, node.children, node.origins);
 			if (spec.content === "raw") {
-				const css = node.children.map((child) => child._tag === "Text" ? child.value : "").join("");
+				const css = node.children.map((child) => child.type === "Text" ? child.value : "").join("");
 				if (/<\/|<!--/i.test(css)) {
 					report(sink, "unsafe-raw-text", `<${node.tag}> content cannot contain markup.`, node.origins);
 					return "";