@samva/markup 0.8.0 → 0.10.0

package/README.md

@@ -6,59 +6,195 @@ directly for TSX templates or together with `@samva/vite` for the visual editor
 ## Install
 
 ```sh
-npm install --save-dev @samva/markup @samva/vite vite
+npm install --save-dev @samva/markup
 ```
 
-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:
+Configure TypeScript with `jsx: "react-jsx"` and `jsxImportSource: "@samva/markup/email"`. A
+template is one `.tsx` file that default-exports `defineTemplate`:
 
 ```tsx
-/** @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: (
+import { defineTemplate } from "@samva/markup";
+import { Button, Email, Section } from "@samva/markup/email";
+import { fmt } from "@samva/markup/fmt";
+import { jsonSchema } from "@samva/markup/input-schema";
+
+import { OrderRow } from "../partials/order-row";
+
+export default defineTemplate({
+  id: "order-shipped",
+  schema: jsonSchema<{
+    name: string;
+    orderId: string;
+    currency: string;
+    total: number;
+    items: { title: string; qty: number; price: number }[];
+    trackingUrl?: string;
+  }>({
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      orderId: { type: "string" },
+      currency: { type: "string" },
+      total: { type: "number" },
+      items: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            title: { type: "string" },
+            qty: { type: "number" },
+            price: { type: "number" },
+          },
+          required: ["title", "qty", "price"],
+          additionalProperties: false,
+        },
+      },
+      trackingUrl: { type: "string" },
+    },
+    required: ["name", "orderId", "currency", "total", "items"],
+    additionalProperties: false,
+  }),
+  fixtures: {
+    default: {
+      name: "Ada",
+      orderId: "A-1042",
+      currency: "USD",
+      total: 84,
+      items: [{ title: "Linen shirt", qty: 2, price: 42 }],
+      trackingUrl: "https://track.example.com/A-1042",
+    },
+    "no-tracking": {
+      name: "Ada",
+      orderId: "A-1042",
+      currency: "USD",
+      total: 84,
+      items: [{ title: "Linen shirt", qty: 2, price: 42 }],
+    },
+  },
+  email: {
+    subject: (input) => `Order ${input.orderId} is on its way`,
+    preheader: (input) => `${input.items.length} items, ${fmt.money(input.total, input.currency)}`,
+    body: (input) => (
       <Email>
-        <Section>
-          <h1>Welcome, {input.firstName}</h1>
-          {input.items.length > 0 && (
-            <ul>
-              {input.items.map((item) => (
-                <li key={item}>{item}</li>
-              ))}
-            </ul>
+        <Section className="px-8 py-6">
+          <h1 className="text-2xl font-semibold">Hi {input.name}, it shipped.</h1>
+          {input.items.map((item) => (
+            <OrderRow item={item} currency={input.currency} />
+          ))}
+          <p className="mt-4 font-medium">Total {fmt.money(input.total, input.currency)}</p>
+          {input.trackingUrl && (
+            <Button href={input.trackingUrl} width={200} height={44}>
+              Track package
+            </Button>
           )}
         </Section>
       </Email>
     ),
-  }),
+  },
+});
+```
+
+A template is read, not run. `@samva/markup/compiler` parses the file and the project files it
+imports without evaluating them, checks every binding against the schema, resolves Tailwind and CSS
+against the markup, and produces the template's IR: JSON, versioned (`"sml": 1`), carrying the
+markup, the bindings, the conditions, the loops and the formatters. `@samva/markup/render`
+renders that IR against an input. It is a pure function with no dependencies, so nothing executes
+at send time.
+
+```ts
+import { renderIr } from "@samva/markup/render";
+import { compileTemplate } from "@samva/markup/compiler";
+
+const compiled = await compileTemplate({
+  files, // the project's files by path; binary files become content-addressed assets
+  entry: "templates/order-shipped.tsx",
+  assetBase: "https://assets.example.com",
+  tailwind: { css: files["theme.css"] },
+});
+if (compiled.ir === undefined) throw new Error(compiled.diagnostics.map(String).join("\n"));
+
+const { subject, preheader, html, text } = renderIr(compiled.ir, compiled.fixtures.default, {
+  locale: "en-US",
+  timeZone: "UTC",
 });
 ```
 
-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.
+### The static profile
+
+The profile is the subset of TSX the compiler reads without running it: the forms an agent already
+writes for React. Anything else is a compile error that names the fix.
+
+| Form                | Example                                                                  |
+| ------------------- | ------------------------------------------------------------------------ |
+| Text binding        | `{input.name}`                                                           |
+| Attribute binding   | `href={input.trackingUrl}`                                               |
+| Template string     | `` `Order ${input.orderId}` ``                                           |
+| Conditional         | `{input.trackingUrl && <Button … />}`                                    |
+| Either/or           | `{input.vip ? <Gold /> : <Standard />}`                                  |
+| Conditions          | `===`, `!==`, `<`, `>`, `<=`, `>=`, `!`, `&&`, `\|\|`, `.length`         |
+| Loop                | `{input.items.map((item, i) => <Row … />)}`                              |
+| Filter              | `input.steps.filter((step) => step.done).map(…)`, `.filter(…).length`    |
+| Grid                | `<Columns each={input.deals} per={2}>{(deal) => <Column … />}</Columns>` |
+| Formatter           | `fmt.money(input.total, input.currency)`                                 |
+| Partial             | `<OrderRow item={item} />`, with props and `children`                    |
+| Conditional class   | `className={input.vip ? "bg-amber-100" : "bg-white"}`                    |
+| Destructured params | `body: ({ name, items }) => …`                                           |
+| Arithmetic          | `item.price * item.qty`, inside a formatter argument or a condition      |
+
+A `.filter` callback takes the item and one condition from the same grammar as `&&` and `?:`; it
+chains before `.map(...)` or `.length`. `<Columns each per>` lays a list out in rows of `per` cells
+(one row without `per`): the child is a function from an item, and its index within the row, to a
+`Column`. A `Column` that states no `width` takes an equal share of the row, whole percent rounded
+down, and a last row with fewer items keeps that share, so it leaves empty space instead of
+stretching. Both lower to a loop in the IR, so nothing is computed at send time.
+
+Rejected, each with its own diagnostic: calls other than `fmt.*` and `.map` (`dynamic-expression`),
+statements in a body (`statement-in-body`), imports other than `@samva/markup` and project files
+(`non-project-import`), event handlers, hooks and `dangerouslySetInnerHTML`, class names built at
+run time (`dynamic-class`), and recursion (`recursive-partial`). There is no escape hatch: logic the
+profile cannot express is computed by the caller and sent in the payload.
+
+Each diagnostic has a stable `code`, the exact `file:line:column`, a one-sentence `message` and a
+`fix`. `unknown-field` names the field and suggests the nearest one, `unguarded-optional` marks an
+optional field read outside a guard, and `fixture-invalid` names the fixture that no longer matches
+the schema.
+
+Only `@samva/markup` and files inside the project can be imported, so a project has no other
+dependency to install. A fixture is data: a literal, or constants and imported assets assembled from
+literals.
+
+### Formatters
+
+`@samva/markup/fmt` is the only set of functions a body may call. Each one is deterministic `Intl`
+with the locale and time zone the render supplies; the template's `locale` is the default and an
+explicit argument overrides it.
+
+| Formatter                              | Example                                            | Output        |
+| -------------------------------------- | -------------------------------------------------- | ------------- |
+| `fmt.money(amount, currency, locale?)` | `fmt.money(84, "EUR", "de")`                       | 84,00 €       |
+| `fmt.number(n, options?, locale?)`     | `fmt.number(1234.5, { maximumFractionDigits: 0 })` | 1,235         |
+| `fmt.date(iso, style?, locale?)`       | `fmt.date(input.shippedAt, "medium")`              | Sep 29, 2026  |
+| `fmt.time(iso, style?, locale?)`       | `fmt.time(input.slot, "short")`                    | 3:30 PM       |
+| `fmt.plural(n, forms, locale?)`        | `fmt.plural(n, { one: "item", other: "items" })`   | items         |
+| `fmt.list(values, locale?)`            | `fmt.list(["Ada", "Grace"])`                       | Ada and Grace |
+
+### Channels
+
+One template carries one schema and a body for each channel it supports. `@samva/markup/sms` and
+`@samva/markup/whatsapp` export the channel components (`Sms`; `WhatsApp` with `WhatsApp.Header`,
+`.Body`, `.Footer`, `.Buttons`, `.UrlButton`, `.QuickReplyButton`, `.PhoneButton` and
+`.CopyCodeButton`). Their names are distinct per channel, so a wrong prop fails in the type checker.
+WhatsApp bindings compile to Meta's positional `{{1}}` placeholders (`whatsappTemplate`), and a
+conditional in a WhatsApp text part is refused because Meta templates cannot branch. The platform
+gates these channels.
 
 ### Explicit template inputs
 
-`@samva/markup/template` exports `defineEmail({ id, schema, fixtures, render })`, the email
-channel's authoring helper; `TemplateDefinition` and `TemplateInput` are channel-neutral.
+`@samva/markup` exports `defineTemplate` and `TemplateInput`.
 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.
+inference, including 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
@@ -84,22 +220,22 @@ The pinned Zod/Effect adapter rejects lazy/suspended schema nodes before executi
 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.
+### Authoring with an agent
+
+The package ships what an agent needs without any other source. `AGENTS.md` opens with the model:
+a template is TSX in the static profile that compiles to IR, and nothing runs at send time.
+`@samva/markup/contract.json` lists the components with their props, the profile's forms, the
+formatters, the HTML elements and every diagnostic code with its fix; it is generated from the
+compiler, so it matches the version you installed. `skills/sml/SKILL.md` is the `sml` skill: it
+routes an agent through write, check, render, look and repair. Run `samva templates check --json`
+for diagnostics an agent can apply.
+
+### Previewing a render
+
+`renderIrPreview(ir, input)` from `@samva/markup/render` renders a fixture the way `renderIr` does
+and stamps `data-samva-instance` on every element. Its `selections` map each stamped element to the
+line and column of the JSX that produced it, so an editor can select an element on the canvas and
+edit the source at that span. A delivered message never carries the attribute.
 
 Portable validation uses `@cfworker/json-schema` without runtime code generation. The
 2020-12 meta-schema is checked at every supported schema position, and the explicit profile rejects

package/dist/{brand-DcoVkh_S.d.ts → assets-BIsyMQ92.d.ts}

@@ -1,12 +1,5 @@
-import { m as EmailNode } from "./elements-BzjjnoCS.js";
-//#region src/internal/unsubscribe-link.d.ts
-/**
- * The per-recipient unsubscribe URL is not known at render: the send path
- * substitutes each delivery's link for this placeholder, or removes the
- * unsubscribe row when the send resolved no unsubscribe group.
- */
-declare const UNSUBSCRIBE_URL_PLACEHOLDER = "%samva:unsubscribe-url%";
-//#endregion
+import { r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { r as EmailNode } from "./jsx-runtime-ylIOnaSf.js";
 //#region src/email/brand.d.ts
 interface EmailBrandAddress {
   readonly street1: string;
@@ -84,5 +77,42 @@ declare const withoutUnsubscribeRow: (rendered: {
   readonly text: string | undefined;
 };
 //#endregion
-export { EmailBrand as a, EmailBrandFooter as c, RenderedFooterMarkers as d, UNSUBSCRIBE_ROW_ATTRIBUTE as f, UNSUBSCRIBE_URL_PLACEHOLDER as g, withoutUnsubscribeRow as h, BrandLogoProps as i, EmailBrandSocialLink as l, renderedFooterMarkers as m, BrandComponents as n, EmailBrandAddress as o, brandComponents as p, BrandFooterProps as r, EmailBrandAssets as s, BRAND_COMPONENT_CLASSES as t, FOOTER_ATTRIBUTE as u };
-//# sourceMappingURL=brand-DcoVkh_S.d.ts.map
+//#region src/email/assets.d.ts
+/** Files a template may import, and what they are served as. */
+declare const ASSET_CONTENT_TYPES: Readonly<Record<string, string>>;
+interface AssetEntry {
+  /** Project-relative path the template imported. */
+  readonly path: string;
+  /** SHA-256 of the exact bytes, lowercase hex. */
+  readonly digest: string;
+  readonly bytes: number;
+  readonly contentType: string;
+  /** `<digest><ext>` — the name the asset has under any base. */
+  readonly fileName: string;
+}
+interface AssetManifest {
+  /** Where these assets are served from in this build. */
+  readonly base: string;
+  readonly assets: readonly AssetEntry[];
+}
+/** True when the compiler turns this import into a content-addressed asset. */
+declare const isAssetPath: (path: string) => boolean;
+/** Address one file by its content. */
+declare const assetEntry: (path: string, bytes: Uint8Array) => Promise<AssetEntry>;
+/**
+ * The URL an asset has under a base. The base is a build input: publication
+ * passes its hosted origin, and a local export passes whatever it will serve
+ * the exported files from.
+ */
+declare const assetUrl: (entry: AssetEntry, base: string) => string;
+/** Record, but never fetch, a URL the template points at. */
+declare const isExternalAsset: (reference: string) => boolean;
+/**
+ * Reject an asset base that would produce URLs a client will not load. The
+ * relative forms are the ones a page on disk resolves against its own
+ * directory, which is what a local export writes.
+ */
+declare const checkAssetBase: (base: string) => readonly EmailDiagnostic[];
+//#endregion
+export { withoutUnsubscribeRow as C, renderedFooterMarkers as S, EmailBrandSocialLink as _, assetUrl as a, UNSUBSCRIBE_ROW_ATTRIBUTE as b, isExternalAsset as c, BrandFooterProps as d, BrandLogoProps as f, EmailBrandFooter as g, EmailBrandAssets as h, assetEntry as i, BRAND_COMPONENT_CLASSES as l, EmailBrandAddress as m, AssetEntry as n, checkAssetBase as o, EmailBrand as p, AssetManifest as r, isAssetPath as s, ASSET_CONTENT_TYPES as t, BrandComponents as u, FOOTER_ATTRIBUTE as v, brandComponents as x, RenderedFooterMarkers as y };
+//# sourceMappingURL=assets-BIsyMQ92.d.ts.map

package/dist/{email/brand.js → brand-C0MKTwmX.js}

@@ -1,5 +1,65 @@
-import { Fragment, jsx } from "./jsx-runtime.js";
-import { i as UNSUBSCRIBE_URL_PLACEHOLDER, r as UNSUBSCRIBE_LINK, t as BRAND_FOOTER_MARKER } from "../unsubscribe-link-CoesnQDU.js";
+import { i as UNSUBSCRIBE_URL_PLACEHOLDER, r as UNSUBSCRIBE_LINK, t as BRAND_FOOTER_MARKER } from "./unsubscribe-link-CoesnQDU.js";
+import { a as jsx, n as Fragment } from "./jsx-runtime-CBlexoeR.js";
+//#region src/email/assets.ts
+/** Files a template may import, and what they are served as. */
+const ASSET_CONTENT_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".pdf": "application/pdf",
+	".txt": "text/plain"
+};
+const extensionOf = (path) => {
+	const dot = path.lastIndexOf(".");
+	return dot < 0 ? "" : path.slice(dot).toLowerCase();
+};
+/** True when the compiler turns this import into a content-addressed asset. */
+const isAssetPath = (path) => Object.hasOwn(ASSET_CONTENT_TYPES, extensionOf(path));
+const hex = (buffer) => Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+/** Address one file by its content. */
+const assetEntry = async (path, bytes) => {
+	const extension = extensionOf(path);
+	const view = new Uint8Array(bytes.byteLength);
+	view.set(bytes);
+	const digest = hex(await crypto.subtle.digest("SHA-256", view));
+	return {
+		path,
+		digest,
+		bytes: bytes.byteLength,
+		contentType: ASSET_CONTENT_TYPES[extension] ?? "application/octet-stream",
+		fileName: `${digest}${extension}`
+	};
+};
+/**
+* The URL an asset has under a base. The base is a build input: publication
+* passes its hosted origin, and a local export passes whatever it will serve
+* the exported files from.
+*/
+const assetUrl = (entry, base) => `${base.replace(/\/+$/, "")}/${entry.fileName}`;
+const EXTERNAL_IMAGE = /^https:\/\//i;
+/** Record, but never fetch, a URL the template points at. */
+const isExternalAsset = (reference) => EXTERNAL_IMAGE.test(reference);
+/**
+* Reject an asset base that would produce URLs a client will not load. The
+* relative forms are the ones a page on disk resolves against its own
+* directory, which is what a local export writes.
+*/
+const checkAssetBase = (base) => /^(https:\/\/|\.{1,2}\/|\/)/i.test(base) ? [] : [{
+	code: "invalid-asset-base",
+	severity: "error",
+	message: `Asset base ${JSON.stringify(base)} must be an https URL, an absolute path, or a relative path for a local export.`,
+	origins: []
+}];
+//#endregion
 //#region src/email/brand.ts
 /** Marks the block the send path recognizes as the template's own footer. */
 const FOOTER_ATTRIBUTE = "data-samva-footer";
@@ -143,6 +203,6 @@ const withoutUnsubscribeRow = (rendered) => ({
 	text: rendered.text?.split("\n").filter((line) => !line.includes(UNSUBSCRIBE_URL_PLACEHOLDER)).join("\n")
 });
 //#endregion
-export { BRAND_COMPONENT_CLASSES, FOOTER_ATTRIBUTE, UNSUBSCRIBE_ROW_ATTRIBUTE, UNSUBSCRIBE_URL_PLACEHOLDER, brandComponents, renderedFooterMarkers, withoutUnsubscribeRow };
+export { renderedFooterMarkers as a, assetEntry as c, isAssetPath as d, isExternalAsset as f, brandComponents as i, assetUrl as l, FOOTER_ATTRIBUTE as n, withoutUnsubscribeRow as o, UNSUBSCRIBE_ROW_ATTRIBUTE as r, ASSET_CONTENT_TYPES as s, BRAND_COMPONENT_CLASSES as t, checkAssetBase as u };
 
-//# sourceMappingURL=brand.js.map
+//# sourceMappingURL=brand-C0MKTwmX.js.map

package/dist/{theme-css.d.ts → brand.d.ts}

@@ -1,5 +1,14 @@
-import { t as Diagnostic } from "./diagnostics-OcQKQYSY.js";
+import { C as withoutUnsubscribeRow, S as renderedFooterMarkers, _ as EmailBrandSocialLink, a as assetUrl, b as UNSUBSCRIBE_ROW_ATTRIBUTE, c as isExternalAsset, d as BrandFooterProps, f as BrandLogoProps, g as EmailBrandFooter, h as EmailBrandAssets, i as assetEntry, l as BRAND_COMPONENT_CLASSES, m as EmailBrandAddress, n as AssetEntry, o as checkAssetBase, p as EmailBrand, r as AssetManifest, s as isAssetPath, t as ASSET_CONTENT_TYPES, u as BrandComponents, v as FOOTER_ATTRIBUTE, x as brandComponents, y as RenderedFooterMarkers } from "./assets-BIsyMQ92.js";
+import { t as Diagnostic } from "./diagnostic-model-DxthUZBT.js";
 import { Result } from "better-result";
+//#region src/internal/unsubscribe-link.d.ts
+/**
+ * The per-recipient unsubscribe URL is not known at render: the send path
+ * substitutes each delivery's link for this placeholder, or removes the
+ * unsubscribe row when the send resolved no unsubscribe group.
+ */
+declare const UNSUBSCRIBE_URL_PLACEHOLDER = "%samva:unsubscribe-url%";
+//#endregion
 //#region src/theme-css.d.ts
 /** One `@font-face` a brand declares. `src` is the declaration value as authored. */
 interface BrandFontFace {
@@ -61,5 +70,5 @@ declare const brandThemeVariables: (brand: BrandCss) => Readonly<Record<string,
 /** The stylesheet Tailwind compiles for `@import "samva:brand"`: `brandThemeVariables` and the font faces. */
 declare const brandTailwindCss: (brand: BrandCss) => string;
 //#endregion
-export { BRAND_COLOR_VARIABLE, BRAND_FOREGROUND_VARIABLE, BrandCss, BrandFontFace, brandForegroundDefaults, brandTailwindCss, brandThemeVariables, contrastForeground, darkVariableName, parseBrandCss, printBrandCss };
-//# sourceMappingURL=theme-css.d.ts.map
+export { ASSET_CONTENT_TYPES, AssetEntry, AssetManifest, BRAND_COLOR_VARIABLE, BRAND_COMPONENT_CLASSES, BRAND_FOREGROUND_VARIABLE, BrandComponents, BrandCss, BrandFontFace, BrandFooterProps, BrandLogoProps, EmailBrand, EmailBrandAddress, EmailBrandAssets, EmailBrandFooter, EmailBrandSocialLink, FOOTER_ATTRIBUTE, RenderedFooterMarkers, UNSUBSCRIBE_ROW_ATTRIBUTE, UNSUBSCRIBE_URL_PLACEHOLDER, assetEntry, assetUrl, brandComponents, brandForegroundDefaults, brandTailwindCss, brandThemeVariables, checkAssetBase, contrastForeground, darkVariableName, isAssetPath, isExternalAsset, parseBrandCss, printBrandCss, renderedFooterMarkers, withoutUnsubscribeRow };
+//# sourceMappingURL=brand.d.ts.map

package/dist/brand.js

@@ -0,0 +1,4 @@
+import { i as UNSUBSCRIBE_URL_PLACEHOLDER } from "./unsubscribe-link-CoesnQDU.js";
+import { a as brandThemeVariables, c as parseBrandCss, i as brandTailwindCss, l as printBrandCss, n as BRAND_FOREGROUND_VARIABLE, o as contrastForeground, r as brandForegroundDefaults, s as darkVariableName, t as BRAND_COLOR_VARIABLE } from "./theme-css-JtRCm1fb.js";
+import { a as renderedFooterMarkers, c as assetEntry, d as isAssetPath, f as isExternalAsset, i as brandComponents, l as assetUrl, n as FOOTER_ATTRIBUTE, o as withoutUnsubscribeRow, r as UNSUBSCRIBE_ROW_ATTRIBUTE, s as ASSET_CONTENT_TYPES, t as BRAND_COMPONENT_CLASSES, u as checkAssetBase } from "./brand-C0MKTwmX.js";
+export { ASSET_CONTENT_TYPES, BRAND_COLOR_VARIABLE, BRAND_COMPONENT_CLASSES, BRAND_FOREGROUND_VARIABLE, FOOTER_ATTRIBUTE, UNSUBSCRIBE_ROW_ATTRIBUTE, UNSUBSCRIBE_URL_PLACEHOLDER, assetEntry, assetUrl, brandComponents, brandForegroundDefaults, brandTailwindCss, brandThemeVariables, checkAssetBase, contrastForeground, darkVariableName, isAssetPath, isExternalAsset, parseBrandCss, printBrandCss, renderedFooterMarkers, withoutUnsubscribeRow };

package/dist/channel-specs-C2feJwuP.d.ts

@@ -0,0 +1,13 @@
+//#region src/channel-specs.d.ts
+declare const SMS_CATEGORIES: readonly ["transactional", "promotional", "service_implicit"];
+declare const WHATSAPP_CATEGORIES: readonly ["marketing", "utility", "authentication"];
+declare const WHATSAPP_HEADER_TYPES: readonly ["text", "image", "video", "document"];
+/** The SMS categories `<Sms category>` accepts. */
+type SmsCategory = (typeof SMS_CATEGORIES)[number];
+/** The Meta template categories `<WhatsApp category>` accepts. */
+type WhatsAppCategory = (typeof WHATSAPP_CATEGORIES)[number];
+/** The header kinds `<WhatsApp.Header type>` accepts. */
+type WhatsAppHeaderType = (typeof WHATSAPP_HEADER_TYPES)[number];
+//#endregion
+export { WhatsAppCategory as n, WhatsAppHeaderType as r, SmsCategory as t };
+//# sourceMappingURL=channel-specs-C2feJwuP.d.ts.map