@samva/markup 0.1.0

package/dist/conditionals.js

@@ -0,0 +1,42 @@
+import { evaluatePredicate, parsePredicate } from "./predicate.js";
+import { Result } from "effect";
+//#region src/conditionals.ts
+const IF_MARKER = "<!--sml:if:";
+const MARKER_CLOSE = "-->";
+const resolve = (content, variables) => {
+	const start = content.indexOf(IF_MARKER);
+	if (start === -1) return content;
+	const headEnd = content.indexOf(MARKER_CLOSE, start);
+	if (headEnd === -1) return content;
+	const header = content.slice(start + 11, headEnd);
+	const spaceIndex = header.indexOf(" ");
+	const id = spaceIndex === -1 ? header : header.slice(0, spaceIndex);
+	const predicateSource = spaceIndex === -1 ? "" : header.slice(spaceIndex + 1);
+	const elseMarker = `<!--sml:else:${id}-->`;
+	const endMarker = `<!--sml:endif:${id}-->`;
+	const bodyStart = headEnd + 3;
+	const endIndex = content.indexOf(endMarker, bodyStart);
+	if (endIndex === -1) return content;
+	const elseCandidate = content.indexOf(elseMarker, bodyStart);
+	const elseIndex = elseCandidate !== -1 && elseCandidate < endIndex ? elseCandidate : -1;
+	const parsed = parsePredicate(predicateSource);
+	const condition = Result.isSuccess(parsed) && evaluatePredicate(parsed.success, variables);
+	const branchA = content.slice(bodyStart, elseIndex === -1 ? endIndex : elseIndex);
+	const branchB = elseIndex === -1 ? "" : content.slice(elseIndex + elseMarker.length, endIndex);
+	const selected = resolve(condition ? branchA : branchB, variables).trim();
+	const rest = resolve(content.slice(endIndex + endMarker.length), variables);
+	return content.slice(0, start) + selected + rest;
+};
+/**
+* Selects <If> branches in a compiled artifact (html or plain-text alt) for
+* one recipient's variables and strips all sml: markers. Marker-free content
+* passes through unchanged.
+*/
+const resolveArtifactConditionals = (content, variables) => {
+	if (!content.includes(IF_MARKER)) return content;
+	return resolve(content, variables).replace(/\n{3,}/g, "\n\n");
+};
+//#endregion
+export { resolveArtifactConditionals };
+
+//# sourceMappingURL=conditionals.js.map

package/dist/conditionals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.js","names":[],"sources":["../src/conditionals.ts"],"sourcesContent":["import { Result } from \"effect\";\n\nimport { evaluatePredicate, parsePredicate } from \"./predicate\";\n\n// Send-time / preview branch selection over compiled artifacts. The compiler\n// leaves both branches of every <If> in the artifact behind comment markers:\n//\n//   <!--sml:if:n4 plan == 'pro'--> A <!--sml:else:n4--> B <!--sml:endif:n4-->\n//\n// (else segment omitted when the <If> has no <Else>). Node ids are unique per\n// document, so nested regions resolve by exact-id matching — no depth\n// counting. The same markers appear in the plain-text alt, so this runs\n// identically on both artifacts. It must run BEFORE {{}} interpolation: sent\n// mail never contains markers.\n\nconst IF_MARKER = \"<!--sml:if:\";\nconst MARKER_CLOSE = \"-->\";\n\nconst resolve = (content: string, variables: Record<string, unknown>): string => {\n  const start = content.indexOf(IF_MARKER);\n  if (start === -1) return content;\n  const headEnd = content.indexOf(MARKER_CLOSE, start);\n  if (headEnd === -1) {\n    // Unterminated marker — impossible for compiler-produced artifacts. Leave\n    // the region visible rather than guessing at a repair.\n    return content;\n  }\n  const header = content.slice(start + IF_MARKER.length, headEnd);\n  const spaceIndex = header.indexOf(\" \");\n  const id = spaceIndex === -1 ? header : header.slice(0, spaceIndex);\n  const predicateSource = spaceIndex === -1 ? \"\" : header.slice(spaceIndex + 1);\n\n  const elseMarker = `<!--sml:else:${id}-->`;\n  const endMarker = `<!--sml:endif:${id}-->`;\n  const bodyStart = headEnd + MARKER_CLOSE.length;\n  const endIndex = content.indexOf(endMarker, bodyStart);\n  if (endIndex === -1) {\n    // Missing endif — same corrupt-input posture as above.\n    return content;\n  }\n  const elseCandidate = content.indexOf(elseMarker, bodyStart);\n  const elseIndex = elseCandidate !== -1 && elseCandidate < endIndex ? elseCandidate : -1;\n\n  // An unparsable predicate cannot occur in compiler output (the parser\n  // validates and canonicalizes it); resolve it like a missing variable: false.\n  const parsed = parsePredicate(predicateSource);\n  const condition = Result.isSuccess(parsed) && evaluatePredicate(parsed.success, variables);\n\n  const branchA = content.slice(bodyStart, elseIndex === -1 ? endIndex : elseIndex);\n  const branchB = elseIndex === -1 ? \"\" : content.slice(elseIndex + elseMarker.length, endIndex);\n  // Trim after nested resolution: dropped inner regions leave edge whitespace\n  // of their own. Branch boundaries are block-level, so trimming is safe.\n  const selected = resolve(condition ? branchA : branchB, variables).trim();\n  const rest = resolve(content.slice(endIndex + endMarker.length), variables);\n  return content.slice(0, start) + selected + rest;\n};\n\n/**\n * Selects <If> branches in a compiled artifact (html or plain-text alt) for\n * one recipient's variables and strips all sml: markers. Marker-free content\n * passes through unchanged.\n */\nexport const resolveArtifactConditionals = (\n  content: string,\n  variables: Record<string, unknown>,\n): string => {\n  if (!content.includes(IF_MARKER)) return content;\n  // Dropped branches leave blank runs behind; both artifacts use at most one\n  // blank line legitimately, so deeper runs are always resolution residue.\n  return resolve(content, variables).replace(/\\n{3,}/g, \"\\n\\n\");\n};\n"],"mappings":";;;AAeA,MAAM,YAAY;AAClB,MAAM,eAAe;AAErB,MAAM,WAAW,SAAiB,cAA+C;CAC/E,MAAM,QAAQ,QAAQ,QAAQ,SAAS;CACvC,IAAI,UAAU,IAAI,OAAO;CACzB,MAAM,UAAU,QAAQ,QAAQ,cAAc,KAAK;CACnD,IAAI,YAAY,IAGd,OAAO;CAET,MAAM,SAAS,QAAQ,MAAM,QAAQ,IAAkB,OAAO;CAC9D,MAAM,aAAa,OAAO,QAAQ,GAAG;CACrC,MAAM,KAAK,eAAe,KAAK,SAAS,OAAO,MAAM,GAAG,UAAU;CAClE,MAAM,kBAAkB,eAAe,KAAK,KAAK,OAAO,MAAM,aAAa,CAAC;CAE5E,MAAM,aAAa,gBAAgB,GAAG;CACtC,MAAM,YAAY,iBAAiB,GAAG;CACtC,MAAM,YAAY,UAAU;CAC5B,MAAM,WAAW,QAAQ,QAAQ,WAAW,SAAS;CACrD,IAAI,aAAa,IAEf,OAAO;CAET,MAAM,gBAAgB,QAAQ,QAAQ,YAAY,SAAS;CAC3D,MAAM,YAAY,kBAAkB,MAAM,gBAAgB,WAAW,gBAAgB;CAIrF,MAAM,SAAS,eAAe,eAAe;CAC7C,MAAM,YAAY,OAAO,UAAU,MAAM,KAAK,kBAAkB,OAAO,SAAS,SAAS;CAEzF,MAAM,UAAU,QAAQ,MAAM,WAAW,cAAc,KAAK,WAAW,SAAS;CAChF,MAAM,UAAU,cAAc,KAAK,KAAK,QAAQ,MAAM,YAAY,WAAW,QAAQ,QAAQ;CAG7F,MAAM,WAAW,QAAQ,YAAY,UAAU,SAAS,SAAS,CAAC,CAAC,KAAK;CACxE,MAAM,OAAO,QAAQ,QAAQ,MAAM,WAAW,UAAU,MAAM,GAAG,SAAS;CAC1E,OAAO,QAAQ,MAAM,GAAG,KAAK,IAAI,WAAW;AAC9C;;;;;;AAOA,MAAa,+BACX,SACA,cACW;CACX,IAAI,CAAC,QAAQ,SAAS,SAAS,GAAG,OAAO;CAGzC,OAAO,QAAQ,SAAS,SAAS,CAAC,CAAC,QAAQ,WAAW,MAAM;AAC9D"}

package/dist/diagnostics-oveE-laV.d.ts

@@ -0,0 +1,79 @@
+import { Schema } from "effect";
+//#region src/diagnostics.d.ts
+declare const SpanSchema: Schema.Struct<{
+  readonly start: Schema.Finite;
+  readonly end: Schema.Finite;
+}>;
+interface Span extends Schema.Schema.Type<typeof SpanSchema> {}
+declare const DiagnosticRepairSchema: Schema.Struct<{
+  readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
+  readonly raw: Schema.optional<Schema.String>;
+  readonly suggestions: Schema.$Array<Schema.String>;
+  readonly explanation: Schema.String;
+}>;
+interface DiagnosticRepair extends Schema.Schema.Type<typeof DiagnosticRepairSchema> {}
+declare const DiagnosticSchema: Schema.Struct<{
+  readonly code: Schema.String;
+  readonly message: Schema.String;
+  readonly span: Schema.Struct<{
+    readonly start: Schema.Finite;
+    readonly end: Schema.Finite;
+  }>;
+  readonly repair: Schema.optional<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
+    readonly raw: Schema.optional<Schema.String>;
+    readonly suggestions: Schema.$Array<Schema.String>;
+    readonly explanation: Schema.String;
+  }>>;
+}>;
+interface Diagnostic extends Schema.Schema.Type<typeof DiagnosticSchema> {}
+declare const SmlParseError_base: Schema.Class<SmlParseError, Schema.TaggedStruct<"SmlParseError", {
+  readonly diagnostics: Schema.$Array<Schema.Struct<{
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly span: Schema.Struct<{
+      readonly start: Schema.Finite;
+      readonly end: Schema.Finite;
+    }>;
+    readonly repair: Schema.optional<Schema.Struct<{
+      readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
+      readonly raw: Schema.optional<Schema.String>;
+      readonly suggestions: Schema.$Array<Schema.String>;
+      readonly explanation: Schema.String;
+    }>>;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+declare class SmlParseError extends SmlParseError_base {
+  get message(): string;
+}
+declare const SmlCompileError_base: Schema.Class<SmlCompileError, Schema.TaggedStruct<"SmlCompileError", {
+  readonly diagnostics: Schema.$Array<Schema.Struct<{
+    readonly code: Schema.String;
+    readonly message: Schema.String;
+    readonly span: Schema.Struct<{
+      readonly start: Schema.Finite;
+      readonly end: Schema.Finite;
+    }>;
+    readonly repair: Schema.optional<Schema.Struct<{
+      readonly kind: Schema.Literals<readonly ["replace-class", "remove-class", "rewrite-node", "use-primitive"]>;
+      readonly raw: Schema.optional<Schema.String>;
+      readonly suggestions: Schema.$Array<Schema.String>;
+      readonly explanation: Schema.String;
+    }>>;
+  }>>;
+}>, import("effect/Cause").YieldableError>;
+declare class SmlCompileError extends SmlCompileError_base {
+  get message(): string;
+}
+/** 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 { SmlCompileError as a, SpanSchema as c, lineColumn as d, DiagnosticSchema as i, buildLineMap as l, DiagnosticRepair as n, SmlParseError as o, DiagnosticRepairSchema as r, Span as s, Diagnostic as t, formatDiagnostic as u };
+//# sourceMappingURL=diagnostics-oveE-laV.d.ts.map

package/dist/diagnostics.d.ts

@@ -0,0 +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 };

package/dist/diagnostics.js

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+//#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.TaggedErrorClass()("SmlParseError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
+	get message() {
+		return this.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+	}
+};
+var SmlCompileError = class extends Schema.TaggedErrorClass()("SmlCompileError", { diagnostics: Schema.Array(DiagnosticSchema) }) {
+	get message() {
+		return this.diagnostics.map((diagnostic) => diagnostic.message).join("\n");
+	}
+};
+/** Newline-offset line map. Build once per source, query with `lineColumn`. */
+const buildLineMap = (source) => {
+	const lineStarts = [0];
+	for (let index = 0; index < source.length; index++) if (source.charCodeAt(index) === 10) lineStarts.push(index + 1);
+	return lineStarts;
+};
+/** 1-based line/column for an absolute offset, via binary search. */
+const lineColumn = (lineMap, offset) => {
+	let low = 0;
+	let high = lineMap.length - 1;
+	while (low < high) {
+		const middle = low + high + 1 >> 1;
+		if (lineMap[middle] <= offset) low = middle;
+		else high = middle - 1;
+	}
+	return {
+		line: low + 1,
+		column: offset - lineMap[low] + 1
+	};
+};
+/** "line 12:8 unknown class ..." — the shape agents iterate on. */
+const formatDiagnostic = (source, diagnostic) => {
+	const { line, column } = lineColumn(buildLineMap(source), diagnostic.span.start);
+	return `line ${line}:${column} ${diagnostic.message}`;
+};
+//#endregion
+export { DiagnosticRepairSchema, DiagnosticSchema, SmlCompileError, SmlParseError, SpanSchema, buildLineMap, formatDiagnostic, lineColumn };
+
+//# sourceMappingURL=diagnostics.js.map

package/dist/diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.js","names":[],"sources":["../src/diagnostics.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n// Every SML diagnostic carries a source span and a message that names the fix.\n// Spans are absolute character offsets into the source; line/column rendering\n// is derived on demand via a newline-offset line map + binary search (the same\n// model as the TypeScript scanner), so tokens and nodes stay (start, end) pairs.\n\nexport const SpanSchema = Schema.Struct({\n  start: Schema.Finite,\n  end: Schema.Finite,\n});\n\nexport interface Span extends Schema.Schema.Type<typeof SpanSchema> {}\n\nexport const DiagnosticRepairSchema = Schema.Struct({\n  kind: Schema.Literals([\"replace-class\", \"remove-class\", \"rewrite-node\", \"use-primitive\"]),\n  raw: Schema.optional(Schema.String),\n  suggestions: Schema.Array(Schema.String),\n  explanation: Schema.String,\n});\n\nexport interface DiagnosticRepair extends Schema.Schema.Type<typeof DiagnosticRepairSchema> {}\n\nexport const DiagnosticSchema = Schema.Struct({\n  code: Schema.String,\n  message: Schema.String,\n  span: SpanSchema,\n  repair: Schema.optional(DiagnosticRepairSchema),\n});\n\nexport interface Diagnostic extends Schema.Schema.Type<typeof DiagnosticSchema> {}\n\nexport class SmlParseError extends Schema.TaggedErrorClass<SmlParseError>()(\"SmlParseError\", {\n  diagnostics: Schema.Array(DiagnosticSchema),\n}) {\n  override get message() {\n    return this.diagnostics.map((diagnostic) => diagnostic.message).join(\"\\n\");\n  }\n}\n\nexport class SmlCompileError extends Schema.TaggedErrorClass<SmlCompileError>()(\"SmlCompileError\", {\n  diagnostics: Schema.Array(DiagnosticSchema),\n}) {\n  override get message() {\n    return this.diagnostics.map((diagnostic) => diagnostic.message).join(\"\\n\");\n  }\n}\n\n/** Newline-offset line map. Build once per source, query with `lineColumn`. */\nexport const buildLineMap = (source: string): ReadonlyArray<number> => {\n  const lineStarts = [0];\n  for (let index = 0; index < source.length; index++) {\n    if (source.charCodeAt(index) === 10 /* \\n */) lineStarts.push(index + 1);\n  }\n  return lineStarts;\n};\n\n/** 1-based line/column for an absolute offset, via binary search. */\nexport const lineColumn = (\n  lineMap: ReadonlyArray<number>,\n  offset: number,\n): { readonly line: number; readonly column: number } => {\n  let low = 0;\n  let high = lineMap.length - 1;\n  while (low < high) {\n    const middle = (low + high + 1) >> 1;\n    if (lineMap[middle]! <= offset) low = middle;\n    else high = middle - 1;\n  }\n  return { line: low + 1, column: offset - lineMap[low]! + 1 };\n};\n\n/** \"line 12:8 unknown class ...\" — the shape agents iterate on. */\nexport const formatDiagnostic = (source: string, diagnostic: Diagnostic): string => {\n  const { line, column } = lineColumn(buildLineMap(source), diagnostic.span.start);\n  return `line ${line}:${column} ${diagnostic.message}`;\n};\n"],"mappings":";;AAOA,MAAa,aAAa,OAAO,OAAO;CACtC,OAAO,OAAO;CACd,KAAK,OAAO;AACd,CAAC;AAID,MAAa,yBAAyB,OAAO,OAAO;CAClD,MAAM,OAAO,SAAS;EAAC;EAAiB;EAAgB;EAAgB;CAAe,CAAC;CACxF,KAAK,OAAO,SAAS,OAAO,MAAM;CAClC,aAAa,OAAO,MAAM,OAAO,MAAM;CACvC,aAAa,OAAO;AACtB,CAAC;AAID,MAAa,mBAAmB,OAAO,OAAO;CAC5C,MAAM,OAAO;CACb,SAAS,OAAO;CAChB,MAAM;CACN,QAAQ,OAAO,SAAS,sBAAsB;AAChD,CAAC;AAID,IAAa,gBAAb,cAAmC,OAAO,iBAAgC,CAAC,CAAC,iBAAiB,EAC3F,aAAa,OAAO,MAAM,gBAAgB,EAC5C,CAAC,CAAC,CAAC;CACD,IAAa,UAAU;EACrB,OAAO,KAAK,YAAY,KAAK,eAAe,WAAW,OAAO,CAAC,CAAC,KAAK,IAAI;CAC3E;AACF;AAEA,IAAa,kBAAb,cAAqC,OAAO,iBAAkC,CAAC,CAAC,mBAAmB,EACjG,aAAa,OAAO,MAAM,gBAAgB,EAC5C,CAAC,CAAC,CAAC;CACD,IAAa,UAAU;EACrB,OAAO,KAAK,YAAY,KAAK,eAAe,WAAW,OAAO,CAAC,CAAC,KAAK,IAAI;CAC3E;AACF;;AAGA,MAAa,gBAAgB,WAA0C;CACrE,MAAM,aAAa,CAAC,CAAC;CACrB,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,QAAQ,SACzC,IAAI,OAAO,WAAW,KAAK,MAAM,IAAa,WAAW,KAAK,QAAQ,CAAC;CAEzE,OAAO;AACT;;AAGA,MAAa,cACX,SACA,WACuD;CACvD,IAAI,MAAM;CACV,IAAI,OAAO,QAAQ,SAAS;CAC5B,OAAO,MAAM,MAAM;EACjB,MAAM,SAAU,MAAM,OAAO,KAAM;EACnC,IAAI,QAAQ,WAAY,QAAQ,MAAM;OACjC,OAAO,SAAS;CACvB;CACA,OAAO;EAAE,MAAM,MAAM;EAAG,QAAQ,SAAS,QAAQ,OAAQ;CAAE;AAC7D;;AAGA,MAAa,oBAAoB,QAAgB,eAAmC;CAClF,MAAM,EAAE,MAAM,WAAW,WAAW,aAAa,MAAM,GAAG,WAAW,KAAK,KAAK;CAC/E,OAAO,QAAQ,KAAK,GAAG,OAAO,GAAG,WAAW;AAC9C"}

package/dist/emit.d.ts

@@ -0,0 +1,50 @@
+import { t as Diagnostic } from "./diagnostics-oveE-laV.js";
+import { TemplateVariable } from "./render-template.js";
+//#region src/emit.d.ts
+/**
+ * One template's emission outcome. `ok` is true only when the template rendered
+ * cleanly with zero diagnostics (valid grammar AND stable emission). `source` is
+ * the first render's canonical SML whenever the render itself succeeded — it is
+ * present even for an unstable template (so the build can show what it produced),
+ * and `undefined` only when the print → parse validation failed outright.
+ */
+type EmittedTemplate = {
+  readonly name: string;
+  readonly ok: true;
+  readonly source: string;
+  readonly variables: ReadonlyArray<TemplateVariable>;
+  readonly diagnostics: readonly [];
+} | {
+  readonly name: string;
+  readonly ok: false;
+  readonly source: string | undefined;
+  readonly variables: ReadonlyArray<TemplateVariable>;
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+};
+/** The aggregate emit result for a module. */
+interface EmittedModule {
+  /** True when at least one template was found and every found template emitted cleanly. */
+  readonly ok: boolean;
+  readonly templates: ReadonlyArray<EmittedTemplate>;
+  /**
+   * Module-level diagnostics not tied to a single template — currently only the
+   * zero-templates-found case. Per-template failures live on each entry.
+   */
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+}
+/**
+ * Discovers template functions in an already-evaluated module object, renders
+ * each to canonical SML with a determinism guard, and returns per-template
+ * results plus an aggregate ok/fail. `moduleExports` is a plain record of the
+ * module's exports (the vite plugin imports the TSX; this stays bundler-agnostic
+ * and pure).
+ *
+ * Discovery is exhaustive and order-preserving over `Object.entries`: every
+ * function export is probed, non-templates (helpers, constants, types-erased
+ * exports) are ignored silently, and a module with zero templates yields a
+ * single `no-templates` diagnostic with `ok: false`.
+ */
+declare const emitModule: (moduleExports: Record<string, unknown>) => EmittedModule;
+//#endregion
+export { EmittedModule, EmittedTemplate, emitModule };
+//# sourceMappingURL=emit.d.ts.map

package/dist/emit.js

@@ -0,0 +1,151 @@
+import { isRootTag } from "./ast.js";
+import { createVariablesProxy } from "./variables.js";
+import { renderTemplate } from "./render-template.js";
+import { Result } from "effect";
+//#region src/emit.ts
+/**
+* emitModule — the module-level emit boundary for the TSX authoring layer
+* (design brief §7b). The vite plugin (M12) does the importing: TSX runs at the
+* USER's build time and this receives the already-evaluated module object (a
+* record of its exports). emitModule stays bundler-agnostic — it never touches
+* the filesystem, esbuild, or vite. It discovers the named template functions,
+* runs each through renderTemplate (print → parse validation), and additionally
+* renders each one TWICE to guard emission determinism (a build-time clock or
+* RNG produces a different second emission and is reported as unstable).
+*
+* Non-function and helper exports are ignored silently; a module with zero
+* templates is a distinct diagnostic (the common "forgot to export the function"
+* / "imported the wrong file" mistake).
+*
+* Template discovery
+*
+* Discovery is by PROBING, not by an explicit `isTemplate` marker. A module
+* export is a template iff it is a function that, when invoked with a fresh
+* recording proxy, returns a channel root element (JsxResult with
+* `kind: "element"` and an <Email>/<Sms>/<WhatsApp> tag). Rationale for
+* probing over a marker:
+*
+*   • The canonical template shape (brief §7b) is a plain named exported
+*     function of `Variables<T>` — requiring a `Foo.isTemplate = true` tag or a
+*     `defineTemplate()` wrapper would add ceremony the brief explicitly avoids
+*     ("named exported function is the canonical template shape").
+*   • The proxy makes the probe cheap and side-effect-free for well-formed
+*     templates: property accesses record variables and return refs; no network,
+*     no I/O. Composition helpers that assemble sub-trees also just build AST.
+*
+* Soundness boundary (documented tradeoff): probing invokes the function, so a
+* helper export with arbitrary arity or side effects is executed once during
+* discovery. We contain the two failure shapes:
+*
+*   • A helper that THROWS when called with a proxy (wrong argument shape, a
+*     coercion-guard trip, an invalid-child assembly) is classified as a
+*     non-template and skipped — the throw is swallowed only for the probe. This
+*     is the one place we catch, and it is confined to classification.
+*   • A helper that RETURNS a non-<Email> node (a bare <Container>, a Fragment,
+*     a string) is likewise skipped.
+*
+* The corollary: a genuine template whose body throws (a real authoring bug —
+* coercing a variable, a malformed child) is misclassified as a helper and
+* silently skipped rather than surfacing its error. That is acceptable because
+* the same bug breaks the template's real emit regardless, and the zero-template
+* diagnostic fires when it was the module's only template. The probe re-runs the
+* function; renderTemplate runs it again on the confirmed templates, so a
+* template function must be a pure builder of its AST (no external side effects)
+* — which the recording-proxy model already requires.
+*/
+/** Probe one export: is it a function that yields a channel root document? */
+const isTemplateFunction = (value) => {
+	if (typeof value !== "function") return false;
+	const { proxy } = createVariablesProxy();
+	let result;
+	try {
+		result = value(proxy);
+	} catch {
+		return false;
+	}
+	return result !== null && typeof result === "object" && result.kind === "element" && isRootTag(result.tag);
+};
+const ZERO_TEMPLATES = {
+	code: "no-templates",
+	message: "no template exports found — a template is a named exported function returning a channel root element (e.g. `export function WelcomeEmail(v: Variables<{…}>) { return <Email>…</Email>; }`; <Sms> and <WhatsApp> roots work the same way)",
+	span: {
+		start: 0,
+		end: 0
+	}
+};
+const unstableDiagnostic = (name) => ({
+	code: "unstable-emission",
+	message: `template "${name}" emits different source on each render — its output depends on non-deterministic build-time data (a clock or random source); templates must be pure functions of their variables`,
+	span: {
+		start: 0,
+		end: 0
+	}
+});
+/**
+* Discovers template functions in an already-evaluated module object, renders
+* each to canonical SML with a determinism guard, and returns per-template
+* results plus an aggregate ok/fail. `moduleExports` is a plain record of the
+* module's exports (the vite plugin imports the TSX; this stays bundler-agnostic
+* and pure).
+*
+* Discovery is exhaustive and order-preserving over `Object.entries`: every
+* function export is probed, non-templates (helpers, constants, types-erased
+* exports) are ignored silently, and a module with zero templates yields a
+* single `no-templates` diagnostic with `ok: false`.
+*/
+const emitModule = (moduleExports) => {
+	const templates = [];
+	for (const [name, value] of Object.entries(moduleExports)) {
+		if (!isTemplateFunction(value)) continue;
+		templates.push(emitOne(name, value));
+	}
+	if (templates.length === 0) return {
+		ok: false,
+		templates: [],
+		diagnostics: [ZERO_TEMPLATES]
+	};
+	return {
+		ok: templates.every((template) => template.ok),
+		templates,
+		diagnostics: []
+	};
+};
+/**
+* Renders one confirmed template with the determinism guard. The first render is
+* the authoritative emission; the second exists only to detect instability
+* (a build-time clock or random source). Both renders run at BUILD time only
+* (the plugin) —
+* runtime send-path rendering never double-renders. For a deterministic template
+* the second render is pure redundant work at build time; that is the accepted
+* cost of the guard, paid once per template per build.
+*/
+const emitOne = (name, template) => {
+	const first = renderTemplate(template);
+	if (Result.isFailure(first)) return {
+		name,
+		ok: false,
+		source: void 0,
+		variables: [],
+		diagnostics: first.failure.diagnostics
+	};
+	const rendered = first.success;
+	const second = renderTemplate(template);
+	if (Result.isSuccess(second) && second.success.source === rendered.source) return {
+		name,
+		ok: true,
+		source: rendered.source,
+		variables: rendered.variables,
+		diagnostics: []
+	};
+	return {
+		name,
+		ok: false,
+		source: rendered.source,
+		variables: rendered.variables,
+		diagnostics: [unstableDiagnostic(name)]
+	};
+};
+//#endregion
+export { emitModule };
+
+//# sourceMappingURL=emit.js.map

package/dist/emit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.js","names":[],"sources":["../src/emit.ts"],"sourcesContent":["import { Result } from \"effect\";\n\nimport { isRootTag } from \"./ast\";\nimport type { Diagnostic } from \"./diagnostics\";\nimport type { JsxResult } from \"./jsx-runtime\";\nimport { renderTemplate, type Template, type TemplateVariable } from \"./render-template\";\nimport { createVariablesProxy } from \"./variables\";\n\n/**\n * emitModule — the module-level emit boundary for the TSX authoring layer\n * (design brief §7b). The vite plugin (M12) does the importing: TSX runs at the\n * USER's build time and this receives the already-evaluated module object (a\n * record of its exports). emitModule stays bundler-agnostic — it never touches\n * the filesystem, esbuild, or vite. It discovers the named template functions,\n * runs each through renderTemplate (print → parse validation), and additionally\n * renders each one TWICE to guard emission determinism (a build-time clock or\n * RNG produces a different second emission and is reported as unstable).\n *\n * Non-function and helper exports are ignored silently; a module with zero\n * templates is a distinct diagnostic (the common \"forgot to export the function\"\n * / \"imported the wrong file\" mistake).\n *\n * Template discovery\n *\n * Discovery is by PROBING, not by an explicit `isTemplate` marker. A module\n * export is a template iff it is a function that, when invoked with a fresh\n * recording proxy, returns a channel root element (JsxResult with\n * `kind: \"element\"` and an <Email>/<Sms>/<WhatsApp> tag). Rationale for\n * probing over a marker:\n *\n *   • The canonical template shape (brief §7b) is a plain named exported\n *     function of `Variables<T>` — requiring a `Foo.isTemplate = true` tag or a\n *     `defineTemplate()` wrapper would add ceremony the brief explicitly avoids\n *     (\"named exported function is the canonical template shape\").\n *   • The proxy makes the probe cheap and side-effect-free for well-formed\n *     templates: property accesses record variables and return refs; no network,\n *     no I/O. Composition helpers that assemble sub-trees also just build AST.\n *\n * Soundness boundary (documented tradeoff): probing invokes the function, so a\n * helper export with arbitrary arity or side effects is executed once during\n * discovery. We contain the two failure shapes:\n *\n *   • A helper that THROWS when called with a proxy (wrong argument shape, a\n *     coercion-guard trip, an invalid-child assembly) is classified as a\n *     non-template and skipped — the throw is swallowed only for the probe. This\n *     is the one place we catch, and it is confined to classification.\n *   • A helper that RETURNS a non-<Email> node (a bare <Container>, a Fragment,\n *     a string) is likewise skipped.\n *\n * The corollary: a genuine template whose body throws (a real authoring bug —\n * coercing a variable, a malformed child) is misclassified as a helper and\n * silently skipped rather than surfacing its error. That is acceptable because\n * the same bug breaks the template's real emit regardless, and the zero-template\n * diagnostic fires when it was the module's only template. The probe re-runs the\n * function; renderTemplate runs it again on the confirmed templates, so a\n * template function must be a pure builder of its AST (no external side effects)\n * — which the recording-proxy model already requires.\n */\n\n/** Probe one export: is it a function that yields a channel root document? */\nconst isTemplateFunction = (value: unknown): value is Template<Record<string, unknown>> => {\n  if (typeof value !== \"function\") return false;\n  const { proxy } = createVariablesProxy<Record<string, unknown>>();\n  let result: JsxResult;\n  // oxlint-disable-next-line samva/no-try-catch-or-throw -- Discovery probe: a helper export that throws when invoked with a recording proxy is not a template. This catch is confined to classification (brief §7b probing decision); confirmed templates are rendered by renderTemplate, which lets authoring errors propagate.\n  try {\n    result = (value as Template<Record<string, unknown>>)(proxy);\n  } catch {\n    return false;\n  }\n  return (\n    // oxlint-disable-next-line samva/no-hand-rolled-object-guard -- This narrows the already-typed JsxResult union; Predicate.isObject erases its discriminant and breaks the kind/tag narrowing below.\n    result !== null &&\n    typeof result === \"object\" &&\n    result.kind === \"element\" &&\n    isRootTag(result.tag)\n  );\n};\n\n// ── Result shapes ────────────────────────────────────────────────────────────────\n\n/**\n * One template's emission outcome. `ok` is true only when the template rendered\n * cleanly with zero diagnostics (valid grammar AND stable emission). `source` is\n * the first render's canonical SML whenever the render itself succeeded — it is\n * present even for an unstable template (so the build can show what it produced),\n * and `undefined` only when the print → parse validation failed outright.\n */\nexport type EmittedTemplate =\n  | {\n      readonly name: string;\n      readonly ok: true;\n      readonly source: string;\n      readonly variables: ReadonlyArray<TemplateVariable>;\n      readonly diagnostics: readonly [];\n    }\n  | {\n      readonly name: string;\n      readonly ok: false;\n      readonly source: string | undefined;\n      readonly variables: ReadonlyArray<TemplateVariable>;\n      readonly diagnostics: ReadonlyArray<Diagnostic>;\n    };\n\n/** The aggregate emit result for a module. */\nexport interface EmittedModule {\n  /** True when at least one template was found and every found template emitted cleanly. */\n  readonly ok: boolean;\n  readonly templates: ReadonlyArray<EmittedTemplate>;\n  /**\n   * Module-level diagnostics not tied to a single template — currently only the\n   * zero-templates-found case. Per-template failures live on each entry.\n   */\n  readonly diagnostics: ReadonlyArray<Diagnostic>;\n}\n\nconst ZERO_TEMPLATES: Diagnostic = {\n  code: \"no-templates\",\n  message:\n    \"no template exports found — a template is a named exported function returning a channel root element (e.g. `export function WelcomeEmail(v: Variables<{…}>) { return <Email>…</Email>; }`; <Sms> and <WhatsApp> roots work the same way)\",\n  span: { start: 0, end: 0 },\n};\n\nconst unstableDiagnostic = (name: string): Diagnostic => ({\n  code: \"unstable-emission\",\n  message: `template \"${name}\" emits different source on each render — its output depends on non-deterministic build-time data (a clock or random source); templates must be pure functions of their variables`,\n  span: { start: 0, end: 0 },\n});\n\n// ── The module emitter ────────────────────────────────────────────────────────────\n\n/**\n * Discovers template functions in an already-evaluated module object, renders\n * each to canonical SML with a determinism guard, and returns per-template\n * results plus an aggregate ok/fail. `moduleExports` is a plain record of the\n * module's exports (the vite plugin imports the TSX; this stays bundler-agnostic\n * and pure).\n *\n * Discovery is exhaustive and order-preserving over `Object.entries`: every\n * function export is probed, non-templates (helpers, constants, types-erased\n * exports) are ignored silently, and a module with zero templates yields a\n * single `no-templates` diagnostic with `ok: false`.\n */\nexport const emitModule = (moduleExports: Record<string, unknown>): EmittedModule => {\n  const templates: Array<EmittedTemplate> = [];\n\n  for (const [name, value] of Object.entries(moduleExports)) {\n    if (!isTemplateFunction(value)) continue;\n    templates.push(emitOne(name, value));\n  }\n\n  if (templates.length === 0) {\n    return { ok: false, templates: [], diagnostics: [ZERO_TEMPLATES] };\n  }\n  return {\n    ok: templates.every((template) => template.ok),\n    templates,\n    diagnostics: [],\n  };\n};\n\n/**\n * Renders one confirmed template with the determinism guard. The first render is\n * the authoritative emission; the second exists only to detect instability\n * (a build-time clock or random source). Both renders run at BUILD time only\n * (the plugin) —\n * runtime send-path rendering never double-renders. For a deterministic template\n * the second render is pure redundant work at build time; that is the accepted\n * cost of the guard, paid once per template per build.\n */\nconst emitOne = (name: string, template: Template<Record<string, unknown>>): EmittedTemplate => {\n  const first = renderTemplate(template);\n  if (Result.isFailure(first)) {\n    return {\n      name,\n      ok: false,\n      source: undefined,\n      variables: [],\n      diagnostics: first.failure.diagnostics,\n    };\n  }\n  const rendered = first.success;\n\n  // Determinism guard: a second render must produce byte-identical source. A\n  // grammar failure on the second pass would itself be an instability, so treat\n  // any non-matching second emission (failure or differing source) as unstable.\n  const second = renderTemplate(template);\n  const stable = Result.isSuccess(second) && second.success.source === rendered.source;\n  if (stable) {\n    return {\n      name,\n      ok: true,\n      source: rendered.source,\n      variables: rendered.variables,\n      diagnostics: [],\n    };\n  }\n\n  // Unstable: keep the first render's source (for the build to display) but mark\n  // the template not-ok so the module aggregate fails.\n  return {\n    name,\n    ok: false,\n    source: rendered.source,\n    variables: rendered.variables,\n    diagnostics: [unstableDiagnostic(name)],\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,MAAM,sBAAsB,UAA+D;CACzF,IAAI,OAAO,UAAU,YAAY,OAAO;CACxC,MAAM,EAAE,UAAU,qBAA8C;CAChE,IAAI;CAEJ,IAAI;EACF,SAAU,MAA4C,KAAK;CAC7D,QAAQ;EACN,OAAO;CACT;CACA,OAEE,WAAW,QACX,OAAO,WAAW,YAClB,OAAO,SAAS,aAChB,UAAU,OAAO,GAAG;AAExB;AAuCA,MAAM,iBAA6B;CACjC,MAAM;CACN,SACE;CACF,MAAM;EAAE,OAAO;EAAG,KAAK;CAAE;AAC3B;AAEA,MAAM,sBAAsB,UAA8B;CACxD,MAAM;CACN,SAAS,aAAa,KAAK;CAC3B,MAAM;EAAE,OAAO;EAAG,KAAK;CAAE;AAC3B;;;;;;;;;;;;;AAgBA,MAAa,cAAc,kBAA0D;CACnF,MAAM,YAAoC,CAAC;CAE3C,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,aAAa,GAAG;EACzD,IAAI,CAAC,mBAAmB,KAAK,GAAG;EAChC,UAAU,KAAK,QAAQ,MAAM,KAAK,CAAC;CACrC;CAEA,IAAI,UAAU,WAAW,GACvB,OAAO;EAAE,IAAI;EAAO,WAAW,CAAC;EAAG,aAAa,CAAC,cAAc;CAAE;CAEnE,OAAO;EACL,IAAI,UAAU,OAAO,aAAa,SAAS,EAAE;EAC7C;EACA,aAAa,CAAC;CAChB;AACF;;;;;;;;;;AAWA,MAAM,WAAW,MAAc,aAAiE;CAC9F,MAAM,QAAQ,eAAe,QAAQ;CACrC,IAAI,OAAO,UAAU,KAAK,GACxB,OAAO;EACL;EACA,IAAI;EACJ,QAAQ,KAAA;EACR,WAAW,CAAC;EACZ,aAAa,MAAM,QAAQ;CAC7B;CAEF,MAAM,WAAW,MAAM;CAKvB,MAAM,SAAS,eAAe,QAAQ;CAEtC,IADe,OAAO,UAAU,MAAM,KAAK,OAAO,QAAQ,WAAW,SAAS,QAE5E,OAAO;EACL;EACA,IAAI;EACJ,QAAQ,SAAS;EACjB,WAAW,SAAS;EACpB,aAAa,CAAC;CAChB;CAKF,OAAO;EACL;EACA,IAAI;EACJ,QAAQ,SAAS;EACjB,WAAW,SAAS;EACpB,aAAa,CAAC,mBAAmB,IAAI,CAAC;CACxC;AACF"}

package/dist/footer.d.ts

@@ -0,0 +1,66 @@
+import { s as TokenTable } from "./theme-6ApjjiBo.js";
+//#region src/footer.d.ts
+/** The per-recipient unsubscribe URL is not known at accept time (the body is
+ * shared across a send's deliveries), so the footer is composed with this
+ * placeholder in the unsubscribe href and the plain-text tail. The email queue
+ * processor substitutes each delivery's minted token URL at dispatch. The link
+ * carries `ses:no-track` so click tracking never rewrites (and thereby breaks)
+ * the placeholder. */
+declare const FOOTER_UNSUBSCRIBE_PLACEHOLDER = "%samva:unsubscribe-url%";
+/** One labelled social link. Structurally mirrors `DesignSocialLink`. */
+interface FooterSocialLink {
+  readonly label: string;
+  readonly url: string;
+}
+/** A structured postal address. Structurally mirrors `DesignAddress`. */
+interface FooterAddress {
+  readonly street1: string;
+  readonly street2?: string | undefined;
+  readonly city: string;
+  readonly region: string;
+  readonly postalCode: string;
+  readonly country: string;
+}
+/** The effective footer content. Structurally mirrors `DesignFooter`. */
+interface FooterContent {
+  readonly companyName?: string | undefined;
+  readonly address?: FooterAddress | undefined;
+  readonly socialLinks?: ReadonlyArray<FooterSocialLink> | undefined;
+  readonly customHtml?: string | undefined;
+}
+/** Which compliance-relevant footer fields the effective content is missing,
+ *  surfaced on the design read path for M6's dashboard nudge. */
+interface FooterCompleteness {
+  /** No physical mailing address is set anywhere in the cascade (CAN-SPAM). */
+  readonly missingAddress: boolean;
+}
+interface RenderedFooter {
+  /** Table-based footer block, ready to inject before the body's `</body>`. */
+  readonly html: string;
+  /** Plain-text footer tail, appended to the text alternative. */
+  readonly text: string;
+  readonly completeness: FooterCompleteness;
+}
+/**
+ * Which compliance-relevant fields the footer content lacks — the signal M6's
+ * dashboard nudge reads. Derivable from `design.footer` alone (no token table),
+ * so the design read path can report it without composing the block. A
+ * `customHtml` footer is treated as complete (the org owns its own content).
+ */
+declare const footerCompleteness: (footer: FooterContent | undefined) => FooterCompleteness;
+/**
+ * Compose the injected footer for one send. `unsubscribeUrl` is the placeholder
+ * (`FOOTER_UNSUBSCRIBE_PLACEHOLDER`) when a group resolved and dispatch will
+ * mint the per-recipient link, or `null` to omit the unsubscribe row entirely
+ * (no group resolved). Never throws and never blocks: whatever content exists
+ * renders, and the missing pieces are reported via `completeness`.
+ */
+declare const renderFooterBlock: (input: {
+  readonly footer: FooterContent;
+  readonly tokens: TokenTable;
+  readonly unsubscribeUrl: string | null;
+  readonly unsubscribeLabel?: string | undefined;
+}) => RenderedFooter;
+//#endregion
+export { FOOTER_UNSUBSCRIBE_PLACEHOLDER, FooterAddress, FooterCompleteness, FooterContent, FooterSocialLink, RenderedFooter, footerCompleteness, renderFooterBlock };
+//# sourceMappingURL=footer.d.ts.map

package/dist/footer.js

@@ -0,0 +1,90 @@
+//#region src/footer.ts
+/** The per-recipient unsubscribe URL is not known at accept time (the body is
+* shared across a send's deliveries), so the footer is composed with this
+* placeholder in the unsubscribe href and the plain-text tail. The email queue
+* processor substitutes each delivery's minted token URL at dispatch. The link
+* carries `ses:no-track` so click tracking never rewrites (and thereby breaks)
+* the placeholder. */
+const FOOTER_UNSUBSCRIBE_PLACEHOLDER = "%samva:unsubscribe-url%";
+const escapeText = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const escapeAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll("\"", "&quot;");
+const isSafeUrl = (url) => /^(https?:|mailto:)/i.test(url.trim());
+const addressLines = (address) => {
+	const region = [
+		address.city,
+		address.region,
+		address.postalCode
+	].filter(Boolean).join(", ");
+	return [
+		address.street1,
+		address.street2,
+		region,
+		address.country
+	].filter((line) => typeof line === "string" && line.trim().length > 0);
+};
+/**
+* Which compliance-relevant fields the footer content lacks — the signal M6's
+* dashboard nudge reads. Derivable from `design.footer` alone (no token table),
+* so the design read path can report it without composing the block. A
+* `customHtml` footer is treated as complete (the org owns its own content).
+*/
+const footerCompleteness = (footer) => ({ missingAddress: footer?.customHtml === void 0 && (footer?.address === void 0 || addressLines(footer.address).length === 0) });
+/**
+* Compose the injected footer for one send. `unsubscribeUrl` is the placeholder
+* (`FOOTER_UNSUBSCRIBE_PLACEHOLDER`) when a group resolved and dispatch will
+* mint the per-recipient link, or `null` to omit the unsubscribe row entirely
+* (no group resolved). Never throws and never blocks: whatever content exists
+* renders, and the missing pieces are reported via `completeness`.
+*/
+const renderFooterBlock = (input) => {
+	const { footer, tokens, unsubscribeUrl } = input;
+	const unsubscribeLabel = input.unsubscribeLabel ?? "Unsubscribe";
+	const fontFamily = tokens.fontFamilies["body"] ?? tokens.fontFamilies["sans"] ?? "sans-serif";
+	const mutedColor = tokens.colors["gray-500"] ?? tokens.colors["neutral-500"] ?? "#6a7282";
+	const linkColor = tokens.colors["brand"] ?? mutedColor;
+	const containerPx = tokens.containerPx["xl"] ?? 600;
+	const fontSizePx = tokens.text["xs"]?.sizePx ?? 12;
+	const lineHeightPx = tokens.text["xs"]?.lineHeightPx ?? 18;
+	const rows = [];
+	const textLines = [];
+	if (typeof footer.customHtml === "string" && footer.customHtml.trim().length > 0) rows.push(`<tr><td style="padding:0 0 12px 0;">${footer.customHtml}</td></tr>`);
+	else {
+		if (typeof footer.companyName === "string" && footer.companyName.trim().length > 0) {
+			rows.push(`<tr><td style="padding:0 0 4px 0;font-weight:600;">${escapeText(footer.companyName)}</td></tr>`);
+			textLines.push(footer.companyName);
+		}
+		if (footer.address !== void 0) {
+			const lines = addressLines(footer.address);
+			if (lines.length > 0) {
+				rows.push(`<tr><td style="padding:0 0 8px 0;">${lines.map(escapeText).join("<br />")}</td></tr>`);
+				textLines.push(lines.join(", "));
+			}
+		}
+		if (footer.socialLinks !== void 0 && footer.socialLinks.length > 0) {
+			const links = footer.socialLinks.map((link) => isSafeUrl(link.url) ? `<a href="${escapeAttribute(link.url.trim())}" style="color:${linkColor};text-decoration:underline;" ses:no-track>${escapeText(link.label)}</a>` : escapeText(link.label));
+			rows.push(`<tr><td style="padding:0 0 8px 0;">${links.join("<span style=\"padding:0 6px;\">·</span>")}</td></tr>`);
+			textLines.push(footer.socialLinks.map((link) => `${link.label}: ${link.url}`).join("  "));
+		}
+	}
+	if (unsubscribeUrl !== null) {
+		rows.push(`<tr><td style="padding:0;"><a href="${escapeAttribute(unsubscribeUrl)}" style="color:${mutedColor};text-decoration:underline;" ses:no-track>${escapeText(unsubscribeLabel)}</a></td></tr>`);
+		textLines.push(`${unsubscribeLabel}: ${unsubscribeUrl}`);
+	}
+	return {
+		html: rows.length === 0 ? "" : [
+			`<table role="presentation" cellpadding="0" cellspacing="0" border="0" width="100%" style="width:100%;border-collapse:collapse;">`,
+			`<tr><td align="center" style="padding:32px 16px;">`,
+			`<table role="presentation" cellpadding="0" cellspacing="0" border="0" width="${containerPx}" style="width:100%;max-width:${containerPx}px;border-collapse:collapse;font-family:${fontFamily};font-size:${fontSizePx}px;line-height:${lineHeightPx}px;color:${mutedColor};text-align:center;">`,
+			...rows,
+			`</table>`,
+			`</td></tr>`,
+			`</table>`
+		].join(""),
+		text: textLines.length === 0 ? "" : `\n\n---\n${textLines.join("\n")}`,
+		completeness: footerCompleteness(footer)
+	};
+};
+//#endregion
+export { FOOTER_UNSUBSCRIBE_PLACEHOLDER, footerCompleteness, renderFooterBlock };
+
+//# sourceMappingURL=footer.js.map

package/dist/footer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.js","names":[],"sources":["../src/footer.ts"],"sourcesContent":["import type { TokenTable } from \"./theme.js\";\n\n// The injected email footer (settings cascade M5). A send whose resolved\n// `email.footer.enabled` is true appends this block beneath the body: the\n// sender's company identity (name, CAN-SPAM physical address, social links)\n// plus the per-recipient unsubscribe link. It is composed from the send's\n// effective `design.footer` content and the resolved theme token table, so the\n// footer inherits the org/domain/template brand (font + brand color) without a\n// separate styling system. Callers map their effective footer settings onto\n// `FooterContent`.\n\n/** The per-recipient unsubscribe URL is not known at accept time (the body is\n * shared across a send's deliveries), so the footer is composed with this\n * placeholder in the unsubscribe href and the plain-text tail. The email queue\n * processor substitutes each delivery's minted token URL at dispatch. The link\n * carries `ses:no-track` so click tracking never rewrites (and thereby breaks)\n * the placeholder. */\nexport const FOOTER_UNSUBSCRIBE_PLACEHOLDER = \"%samva:unsubscribe-url%\";\n\n/** One labelled social link. Structurally mirrors `DesignSocialLink`. */\nexport interface FooterSocialLink {\n  readonly label: string;\n  readonly url: string;\n}\n\n/** A structured postal address. Structurally mirrors `DesignAddress`. */\nexport interface FooterAddress {\n  readonly street1: string;\n  readonly street2?: string | undefined;\n  readonly city: string;\n  readonly region: string;\n  readonly postalCode: string;\n  readonly country: string;\n}\n\n/** The effective footer content. Structurally mirrors `DesignFooter`. */\nexport interface FooterContent {\n  readonly companyName?: string | undefined;\n  readonly address?: FooterAddress | undefined;\n  readonly socialLinks?: ReadonlyArray<FooterSocialLink> | undefined;\n  readonly customHtml?: string | undefined;\n}\n\n/** Which compliance-relevant footer fields the effective content is missing,\n *  surfaced on the design read path for M6's dashboard nudge. */\nexport interface FooterCompleteness {\n  /** No physical mailing address is set anywhere in the cascade (CAN-SPAM). */\n  readonly missingAddress: boolean;\n}\n\nexport interface RenderedFooter {\n  /** Table-based footer block, ready to inject before the body's `</body>`. */\n  readonly html: string;\n  /** Plain-text footer tail, appended to the text alternative. */\n  readonly text: string;\n  readonly completeness: FooterCompleteness;\n}\n\nconst escapeText = (value: string): string =>\n  value.replaceAll(\"&\", \"&amp;\").replaceAll(\"<\", \"&lt;\").replaceAll(\">\", \"&gt;\");\n\nconst escapeAttribute = (value: string): string =>\n  value.replaceAll(\"&\", \"&amp;\").replaceAll(\"<\", \"&lt;\").replaceAll('\"', \"&quot;\");\n\n// Only http(s) and mailto links are emitted as anchors; anything else (e.g. a\n// `javascript:` scheme in org-authored social data) renders as inert text so a\n// footer can never smuggle an active link into delivered mail.\nconst isSafeUrl = (url: string): boolean => /^(https?:|mailto:)/i.test(url.trim());\n\nconst addressLines = (address: FooterAddress): ReadonlyArray<string> => {\n  const region = [address.city, address.region, address.postalCode].filter(Boolean).join(\", \");\n  return [address.street1, address.street2, region, address.country].filter(\n    (line): line is string => typeof line === \"string\" && line.trim().length > 0,\n  );\n};\n\n/**\n * Which compliance-relevant fields the footer content lacks — the signal M6's\n * dashboard nudge reads. Derivable from `design.footer` alone (no token table),\n * so the design read path can report it without composing the block. A\n * `customHtml` footer is treated as complete (the org owns its own content).\n */\nexport const footerCompleteness = (footer: FooterContent | undefined): FooterCompleteness => ({\n  missingAddress:\n    footer?.customHtml === undefined &&\n    (footer?.address === undefined || addressLines(footer.address).length === 0),\n});\n\n/**\n * Compose the injected footer for one send. `unsubscribeUrl` is the placeholder\n * (`FOOTER_UNSUBSCRIBE_PLACEHOLDER`) when a group resolved and dispatch will\n * mint the per-recipient link, or `null` to omit the unsubscribe row entirely\n * (no group resolved). Never throws and never blocks: whatever content exists\n * renders, and the missing pieces are reported via `completeness`.\n */\nexport const renderFooterBlock = (input: {\n  readonly footer: FooterContent;\n  readonly tokens: TokenTable;\n  readonly unsubscribeUrl: string | null;\n  readonly unsubscribeLabel?: string | undefined;\n}): RenderedFooter => {\n  const { footer, tokens, unsubscribeUrl } = input;\n  const unsubscribeLabel = input.unsubscribeLabel ?? \"Unsubscribe\";\n\n  // Muted-on-surface footer type, inheriting the brand body font and brand link\n  // color from the resolved token table so an org theme carries into the footer.\n  const fontFamily = tokens.fontFamilies[\"body\"] ?? tokens.fontFamilies[\"sans\"] ?? \"sans-serif\";\n  const mutedColor = tokens.colors[\"gray-500\"] ?? tokens.colors[\"neutral-500\"] ?? \"#6a7282\";\n  const linkColor = tokens.colors[\"brand\"] ?? mutedColor;\n  const containerPx = tokens.containerPx[\"xl\"] ?? 600;\n  const fontSizePx = tokens.text[\"xs\"]?.sizePx ?? 12;\n  const lineHeightPx = tokens.text[\"xs\"]?.lineHeightPx ?? 18;\n\n  const rows: string[] = [];\n  const textLines: string[] = [];\n\n  if (typeof footer.customHtml === \"string\" && footer.customHtml.trim().length > 0) {\n    // Escape hatch: org-authored footer HTML replaces the structured block. The\n    // compliance unsubscribe row below is still appended — its link is the\n    // per-recipient token the org cannot author into static HTML.\n    rows.push(`<tr><td style=\"padding:0 0 12px 0;\">${footer.customHtml}</td></tr>`);\n  } else {\n    if (typeof footer.companyName === \"string\" && footer.companyName.trim().length > 0) {\n      rows.push(\n        `<tr><td style=\"padding:0 0 4px 0;font-weight:600;\">${escapeText(footer.companyName)}</td></tr>`,\n      );\n      textLines.push(footer.companyName);\n    }\n    if (footer.address !== undefined) {\n      const lines = addressLines(footer.address);\n      if (lines.length > 0) {\n        rows.push(\n          `<tr><td style=\"padding:0 0 8px 0;\">${lines.map(escapeText).join(\"<br />\")}</td></tr>`,\n        );\n        textLines.push(lines.join(\", \"));\n      }\n    }\n    if (footer.socialLinks !== undefined && footer.socialLinks.length > 0) {\n      const links = footer.socialLinks.map((link) =>\n        isSafeUrl(link.url)\n          ? `<a href=\"${escapeAttribute(link.url.trim())}\" style=\"color:${linkColor};text-decoration:underline;\" ses:no-track>${escapeText(link.label)}</a>`\n          : escapeText(link.label),\n      );\n      rows.push(\n        `<tr><td style=\"padding:0 0 8px 0;\">${links.join('<span style=\"padding:0 6px;\">·</span>')}</td></tr>`,\n      );\n      textLines.push(footer.socialLinks.map((link) => `${link.label}: ${link.url}`).join(\"  \"));\n    }\n  }\n\n  if (unsubscribeUrl !== null) {\n    rows.push(\n      `<tr><td style=\"padding:0;\"><a href=\"${escapeAttribute(unsubscribeUrl)}\" style=\"color:${mutedColor};text-decoration:underline;\" ses:no-track>${escapeText(unsubscribeLabel)}</a></td></tr>`,\n    );\n    textLines.push(`${unsubscribeLabel}: ${unsubscribeUrl}`);\n  }\n\n  const html =\n    rows.length === 0\n      ? \"\"\n      : [\n          `<table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"100%\" style=\"width:100%;border-collapse:collapse;\">`,\n          `<tr><td align=\"center\" style=\"padding:32px 16px;\">`,\n          `<table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" border=\"0\" width=\"${containerPx}\" style=\"width:100%;max-width:${containerPx}px;border-collapse:collapse;font-family:${fontFamily};font-size:${fontSizePx}px;line-height:${lineHeightPx}px;color:${mutedColor};text-align:center;\">`,\n          ...rows,\n          `</table>`,\n          `</td></tr>`,\n          `</table>`,\n        ].join(\"\");\n\n  return {\n    html,\n    text: textLines.length === 0 ? \"\" : `\\n\\n---\\n${textLines.join(\"\\n\")}`,\n    completeness: footerCompleteness(footer),\n  };\n};\n"],"mappings":";;;;;;;AAiBA,MAAa,iCAAiC;AAyC9C,MAAM,cAAc,UAClB,MAAM,WAAW,KAAK,OAAO,CAAC,CAAC,WAAW,KAAK,MAAM,CAAC,CAAC,WAAW,KAAK,MAAM;AAE/E,MAAM,mBAAmB,UACvB,MAAM,WAAW,KAAK,OAAO,CAAC,CAAC,WAAW,KAAK,MAAM,CAAC,CAAC,WAAW,MAAK,QAAQ;AAKjF,MAAM,aAAa,QAAyB,sBAAsB,KAAK,IAAI,KAAK,CAAC;AAEjF,MAAM,gBAAgB,YAAkD;CACtE,MAAM,SAAS;EAAC,QAAQ;EAAM,QAAQ;EAAQ,QAAQ;CAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,IAAI;CAC3F,OAAO;EAAC,QAAQ;EAAS,QAAQ;EAAS;EAAQ,QAAQ;CAAO,CAAC,CAAC,QAChE,SAAyB,OAAO,SAAS,YAAY,KAAK,KAAK,CAAC,CAAC,SAAS,CAC7E;AACF;;;;;;;AAQA,MAAa,sBAAsB,YAA2D,EAC5F,gBACE,QAAQ,eAAe,KAAA,MACtB,QAAQ,YAAY,KAAA,KAAa,aAAa,OAAO,OAAO,CAAC,CAAC,WAAW,GAC9E;;;;;;;;AASA,MAAa,qBAAqB,UAKZ;CACpB,MAAM,EAAE,QAAQ,QAAQ,mBAAmB;CAC3C,MAAM,mBAAmB,MAAM,oBAAoB;CAInD,MAAM,aAAa,OAAO,aAAa,WAAW,OAAO,aAAa,WAAW;CACjF,MAAM,aAAa,OAAO,OAAO,eAAe,OAAO,OAAO,kBAAkB;CAChF,MAAM,YAAY,OAAO,OAAO,YAAY;CAC5C,MAAM,cAAc,OAAO,YAAY,SAAS;CAChD,MAAM,aAAa,OAAO,KAAK,KAAK,EAAE,UAAU;CAChD,MAAM,eAAe,OAAO,KAAK,KAAK,EAAE,gBAAgB;CAExD,MAAM,OAAiB,CAAC;CACxB,MAAM,YAAsB,CAAC;CAE7B,IAAI,OAAO,OAAO,eAAe,YAAY,OAAO,WAAW,KAAK,CAAC,CAAC,SAAS,GAI7E,KAAK,KAAK,uCAAuC,OAAO,WAAW,WAAW;MACzE;EACL,IAAI,OAAO,OAAO,gBAAgB,YAAY,OAAO,YAAY,KAAK,CAAC,CAAC,SAAS,GAAG;GAClF,KAAK,KACH,sDAAsD,WAAW,OAAO,WAAW,EAAE,WACvF;GACA,UAAU,KAAK,OAAO,WAAW;EACnC;EACA,IAAI,OAAO,YAAY,KAAA,GAAW;GAChC,MAAM,QAAQ,aAAa,OAAO,OAAO;GACzC,IAAI,MAAM,SAAS,GAAG;IACpB,KAAK,KACH,sCAAsC,MAAM,IAAI,UAAU,CAAC,CAAC,KAAK,QAAQ,EAAE,WAC7E;IACA,UAAU,KAAK,MAAM,KAAK,IAAI,CAAC;GACjC;EACF;EACA,IAAI,OAAO,gBAAgB,KAAA,KAAa,OAAO,YAAY,SAAS,GAAG;GACrE,MAAM,QAAQ,OAAO,YAAY,KAAK,SACpC,UAAU,KAAK,GAAG,IACd,YAAY,gBAAgB,KAAK,IAAI,KAAK,CAAC,EAAE,iBAAiB,UAAU,4CAA4C,WAAW,KAAK,KAAK,EAAE,QAC3I,WAAW,KAAK,KAAK,CAC3B;GACA,KAAK,KACH,sCAAsC,MAAM,KAAK,yCAAuC,EAAE,WAC5F;GACA,UAAU,KAAK,OAAO,YAAY,KAAK,SAAS,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;EAC1F;CACF;CAEA,IAAI,mBAAmB,MAAM;EAC3B,KAAK,KACH,uCAAuC,gBAAgB,cAAc,EAAE,iBAAiB,WAAW,4CAA4C,WAAW,gBAAgB,EAAE,eAC9K;EACA,UAAU,KAAK,GAAG,iBAAiB,IAAI,gBAAgB;CACzD;CAeA,OAAO;EACL,MAbA,KAAK,WAAW,IACZ,KACA;GACE;GACA;GACA,gFAAgF,YAAY,gCAAgC,YAAY,0CAA0C,WAAW,aAAa,WAAW,iBAAiB,aAAa,WAAW,WAAW;GACzQ,GAAG;GACH;GACA;GACA;EACF,CAAC,CAAC,KAAK,EAAE;EAIb,MAAM,UAAU,WAAW,IAAI,KAAK,YAAY,UAAU,KAAK,IAAI;EACnE,cAAc,mBAAmB,MAAM;CACzC;AACF"}