@samva/vite 0.8.0 → 0.10.0

package/AGENTS.md

@@ -1,92 +1,96 @@
 # @samva/vite agent guide
 
 `@samva/vite` is the local authoring toolchain for Samva templates written with `@samva/markup`: a
-Vite plugin that serves the visual editor, and programmatic entry points that build, render, and
-export a template project. It compiles nothing itself; every render goes through
-`@samva/markup/compiler`'s `compileEmailProject`, the same compile step a hosted Samva build runs, so
-a local render does not drift from a published one. Publishing and hosted synchronization are not
+Vite plugin that serves the visual editor, a config-free dev server, and programmatic entry points
+that build, render, and export a template project. A template is one TSX file in a static profile,
+and nothing here runs it: every check, render and preview is `compileTemplate` from
+`@samva/markup/compiler` followed by `renderIr`, the same two steps a hosted Samva build takes, so a
+local render does not drift from a published one. Publishing and hosted synchronization are not
 here: they are ordinary Git plus `samva templates publish` from `@samva/cli` (see
 `samva templates --help`).
 
 ## Entry points
 
-- `@samva/vite` — `samvaEditor()`, the plugin you add to `vite.config.ts`. Options are typed by
-  `SamvaEditorPluginOptions`; the README lists them.
-- `@samva/vite/build` — `buildTemplates()` and `createTemplateBuildSession()` for programmatic
-  checks and builds. The `samva` CLI loads this module from your project, not from its own bundle.
-- `@samva/vite/project` — the folder-of-templates surface: `loadEmailCatalog()`,
-  `renderEmailFixtures()`, `createEmailProjectSession()`, `exportEmailProject()`.
-- `@samva/vite/email` — `createEmailRenderer()` and `renderEmailProject()` for rendering one email
-  project from source.
-- `@samva/vite/emit` — module-preview integration for structured SMS and WhatsApp entries.
+- `@samva/vite` — `samvaEditor()`, the plugin you add to `vite.config.ts` when the defaults do not
+  cover your setup. Options are typed by `SamvaEditorPluginOptions`; the README lists them.
+- `@samva/vite/dev` — `startDevServer({ root, dir?, port?, host?, open? })`: a Vite server with no
+  config file, `samvaEditor()`, and defaults. It is what `samva templates dev` starts.
+- `@samva/vite/build` — `buildTemplates(options)` and `createTemplateBuildSession(options)` for
+  programmatic checks and builds. The `samva` CLI loads this module from your project, not from its
+  own bundle.
+- `@samva/vite/render` — `renderTemplate()` and `renderChannel()`: one template and fixture to a
+  plain JSON result.
+- `@samva/vite/project` — the folder-of-templates surface: `loadProject()`, `compileProject()`,
+  `createProjectSession()`, `exportProject()` and the render helpers over a compiled entry.
 
 Install `@samva/markup`, `@samva/vite`, and the `vite` peer as dev dependencies of the template
-project and keep them in its lockfile. The CLI's `templates check`, `templates build`, and the
-editor all resolve these packages from the project, so the lockfile is what pins the compiler
-version your previews, checks, and builds use.
+project and keep them in its lockfile. The CLI's `templates check`, `templates build`,
+`templates render` and the editor all resolve these packages from the project, so the lockfile is
+what pins the compiler version your previews, checks, and builds use.
 
 ## How you hurt yourself here
 
-- **Expecting your Vite config to apply to email rendering.** Every email render, in the editor,
-  the CLI, and the programmatic entry points, runs in an evaluator this package roots at its own
-  directory with no config file, so your `vite.config.ts` aliases and plugins never reach an email
-  template. Bare imports resolve from the package root, which is what makes `@samva/markup` resolve
-  under both hoisted and per-package installs. Import shared helpers by relative path; an alias that
-  works elsewhere in your app fails here.
-- **Side effects at module scope.** Discovery imports every `.tsx` under the templates directory
-  and asks whether its default export is a template definition, and a rebuild re-reads the whole
-  project. Top-level code in every module, helpers included, runs whenever the project is
-  evaluated; keep it free of I/O and mutable global state.
+- **Expecting a template module to run.** The compiler reads the file and never executes it, so
+  top-level code, imports of constants, and helper calls do nothing. A value a template needs is
+  input data, a fixture literal, or an import the static profile allows (a partial, a stylesheet,
+  an asset). `samva templates check` reports what the profile refuses, with a location and a fix.
+- **Expecting your Vite config to apply to templates.** Nothing about a template goes through
+  Vite's module graph, so your `vite.config.ts` aliases and plugins never reach one. Import
+  partials by relative path.
+- **Putting templates where the project root cannot see them.** Files are addressed relative to
+  the project root, which holds `theme.css`, shared imports and `.samva/`. A templates directory
+  outside it is refused rather than half-read. Set `projectRoot` (plugin) or `root` (entry points)
+  to a folder that contains both.
+- **Scanning the wrong directories.** With no `dir`, `templates/` and `emails/` are both scanned,
+  whichever exist. Setting `dir` scans only that one, so a project that keeps templates in both
+  and sets `dir` loses the other.
 - **Relying on a file path as template identity.** Identity is the `id` the definition declares.
   Two definitions declaring one id is a reported error, and moving a file does not change its id.
-  Helper modules need no marker or exclusion list: a module is a template only if its default export
-  is a definition.
-- **Exporting for delivery with the default asset base.** `exportEmailProject` renders with relative
+  Helper modules need no marker or exclusion list: a module is a template only if its default
+  export is `defineTemplate`. An editor document is a template's path plus its channel.
+- **A broken file elsewhere in the project.** The compiler reads an entry and the files it imports.
+  A file it cannot parse is a finding that names the file, and it stops the templates that import
+  it; the others keep their render.
+- **Exporting for delivery with the default asset base.** `exportProject` renders with relative
   URLs and writes each page at `templates/<id>/<fixture>.html` beside a content-addressed `assets/`
   directory, so its default base, `DEFAULT_EXPORT_ASSET_BASE`, only works when those files are
-  browsed from disk. An inbox has no directory to resolve a relative URL against, so delivery refuses
-  one. For an export you will send, pass the https origin that will serve the assets.
-- **Reusing a renderer without a stable namespace.** `createEmailRenderer` keeps one evaluator
-  across renders, as a dev server does, and gives each project its own module-id namespace. Omit
-  `namespace` and every `load` takes a fresh one, which isolates unrelated projects but grows the
-  graph on every reload. A watch loop over one project passes the same `namespace` each time so its
-  ids stay stable. Each `load` re-evaluates its own namespace's modules; `invalidate()` also drops
-  the modules namespaces share. `close()` releases the evaluator.
-- **Expecting the email editor to overwrite concurrent edits.** The editor writes back to the
-  entry's canonical `.tsx` source after checking that the file on disk is still the revision it
-  read, so a change you saved elsewhere is not overwritten; reload the entry and retry. SMS and
-  WhatsApp entries are read-only in the editor.
-- **Committing or hand-editing `.samva/brands`.** `samva:brand` resolves live first and falls
-  back to the snapshot `samva brands pull` writes there, warning when it is older than the live
-  brand. The API owns the brand, so the directory is gitignored and refreshed with `pull`; a
-  project with neither credentials nor a snapshot fails with `brand-unavailable`.
+  browsed from disk. An inbox has no directory to resolve a relative URL against, so delivery
+  refuses one. For an export you will send, pass the https origin that will serve the assets.
+- **Expecting the editor to overwrite concurrent edits.** The editor writes back to the entry's
+  `.tsx` source after checking that the file on disk is still the revision it read, so a change you
+  saved elsewhere is not overwritten; reload the entry and retry.
+- **Committing or hand-editing `.samva/`.** `.samva/` holds files this package generates. It is
+  gitignored, like `.next/` and `.tanstack/`, and changes inside it never recompile templates.
+  `samva:brand` resolves live first, refreshes `.samva/brands/<slug>.json` from every live answer,
+  and falls back to that copy, warning when it is used or was older than the live brand. The API
+  owns the brand; a project with neither credentials nor a cached copy fails with
+  `brand-unavailable`.
 
 ## Rules
 
-- **Template entries are `.tsx`.** Discovery ignores every other extension.
+- **Template entries are `.tsx`.** Discovery ignores every other extension, hidden folders and
+  `node_modules`.
 - **Template ids and fixture keys match `TEMPLATE_NAME_PATTERN`** from `@samva/markup/template`,
   because both are written into export paths. Code that builds a path from them imports that
   pattern instead of restating it.
 - **Fixtures are validated against the template's own schema before they render.** A bad fixture is
   a finding on that template, not a runtime surprise at send time.
 - **One failure stays with its template.** A refused render reports against its fixture, and an
-  email entry that does not build stays in the catalog with a null render and the findings that
-  stopped it. SMS and WhatsApp entries that stop compiling keep their last successful preview,
-  labeled stale, until the file compiles again or is deleted.
-- **Results are values.** `@samva/vite/build` and the preview surfaces return discriminated results
-  with an `ok` field, and `@samva/vite/emit` passes through the compiler's better-result `Result`. A
-  missing `vite` peer, or an entry whose default export is not a template definition where one is
-  required, throws.
+  entry that does not compile stays in the catalog with a null render and the findings that
+  stopped it; an editor document whose file stops compiling keeps its place the same way.
+- **Results are values.** `buildTemplates`, `renderTemplate` and `renderChannel` return
+  discriminated results with an `ok` field and never throw for a finding about your source. A
+  missing `vite` peer, or a templates directory outside the project root, throws.
 - **The asset base is a build input, not authored source.** The same content can be built for one
   origin and exported for another. The dev server is not an https origin, so editor previews
   reference assets through the editor's own route by path.
 
 ## Proving your setup
 
-- `samva templates check --dir <templates-dir>` executes every declared fixture and reports
+- `samva templates check` compiles every template, renders every declared fixture, and reports
   findings; `--watch` keeps it running while you edit.
-- `vite` with `samvaEditor()` configured serves the editor at the configured `route`; every entry
-  should appear with its fixtures.
-- `exportEmailProject({ dir, out })` writes browsable HTML and text for every fixture and a
+- `samva templates dev`, or `vite` with `samvaEditor()` configured, serves the editor at the
+  configured `route`; every template should appear with its fixtures, one document per channel.
+- `exportProject({ root, out })` writes browsable HTML and text for every fixture and a
   `catalog.json` with the asset mapping and findings, without Samva credentials unless the project
-  imports `samva:brand` and has no snapshot.
+  imports `samva:brand` and has no cached copy.

package/CHANGELOG.md

@@ -0,0 +1,339 @@
+## @samva/vite@0.10.0
+
+### Breaking: `@samva/markup` publishes 17 entries in two tiers
+
+Template files import `@samva/markup`, `@samva/markup/email`, `@samva/markup/fmt`,
+`@samva/markup/sms`, `@samva/markup/whatsapp` and `@samva/markup/input-schema`. Email components
+move from `@samva/markup/email/components` to `@samva/markup/email`, the entry `jsxImportSource`
+already names. A template that still imports the old path fails with `moved-import`, which names
+the replacement.
+
+Hosts import five tooling entries:
+
+| Entry                       | Replaces                                                                                                                   |
+| --------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `@samva/markup/compiler`    | `./compiler`, `./static`, `./template` (`TEMPLATE_NAME_PATTERN`), `./email/brand-footer`                                   |
+| `@samva/markup/diagnostics` | `./diagnostics`, `./diagnostic-codes`, `./email/diagnostics`                                                               |
+| `@samva/markup/render`      | `./ir`, `./render-ir`, `./preview`, `./email/render`, `./email/html`, `./email/text`, `./email/elements`, `./sms-segments` |
+| `@samva/markup/edit`        | `./source-edit`, `./channel-edit`, `./source-locations`                                                                    |
+| `@samva/markup/brand`       | `./email/brand`, `./email/assets`, `./theme-css`                                                                           |
+
+`@samva/markup/reference.md` replaces `@samva/markup/generated/*`. `tailwindcss`, `css-tree`,
+`caniemail` and `@babel/parser` are dependencies instead of optional peers, so a project that
+depends on `@samva/markup` alone can run `samva templates check`.
+
+## @samva/vite@0.9.0
+
+### Breaking: the editor, build and render run on the compiled template, not on evaluated code
+
+`@samva/vite` compiles every template with the static compiler from `@samva/markup` and renders the
+IR, so nothing in your project is executed to preview, check, build or export it. A local render is
+the render a published template produces, and top-level code in a template module no longer runs.
+Templates are `defineTemplate` files; a `defineEmail` entry is reported as an error.
+
+- **Directories.** Templates live in `templates/` by default, and `emails/` is recognized beside it.
+  Set `templatesDir` on `samvaEditor()` (or `dir` on the entry points) to scan one directory
+  instead; `projectRoot` names the folder that holds `theme.css`, shared imports and `.samva/` when
+  it is not the Vite root. Document ids are project-relative paths, and a template that declares
+  SMS or WhatsApp gets one editor document per channel over the same file.
+- **`.samva/`.** The brand record `samva:brand` resolves is fetched live and cached in
+  `.samva/brands/<slug>.json`, refreshed by every live fetch, and used with a warning when the API
+  is unreachable. Keep `.samva` in `.gitignore`.
+- **`@samva/vite/dev`** adds `startDevServer({ root, dir?, port?, host?, open? })`, a Vite dev server
+  with no config file that serves the editor; `samva templates dev` runs it.
+- **`@samva/vite/render`** adds `renderTemplate` and `renderChannel`, which compile a project and
+  render one template and fixture to plain JSON, for `samva templates render`.
+- **`@samva/vite/build`** takes one options object: `buildTemplates({ root, dir, theme, assetBase })`
+  and `createTemplateBuildSession(options)`. Results carry `ok`, per-template IR, input schema,
+  every fixture rendered through every declared channel, and client-compatibility findings.
+- **`@samva/vite/project`** replaces `loadEmailCatalog`, `renderEmailFixtures`,
+  `createEmailProjectSession` and `exportEmailProject` with `loadProject`, `compileProject`,
+  `createProjectSession` and `exportProject`. Exports also write `<fixture>.sms.txt` and
+  `<fixture>.whatsapp.json` for those channels.
+- **Removed.** `@samva/vite/email`, `@samva/vite/emit`, the Vite config-file and alias caveats of
+  the old evaluator, and the `better-result` dependency.
+
+### Breaking: remove textual email SML APIs
+
+`@samva/markup` removes textual email SML components and grammar types, plus the
+`@samva/markup/candidate`, `/classes`, `/checks`, `/model`, `/ops`, `/registry`, and `/tsx-tracer`
+subpaths. Email templates use TSX `defineEmail` modules and lower directly to subject, HTML, and text
+through the email semantic tree. The structured SML language and compiler remain for SMS and
+WhatsApp.
+
+`@samva/vite` removes `darkClassCount` from the public `AuthoringValidationSummary` returned by its
+emit API. Email validation no longer reports a count derived from textual email SML classes.
+
+### Breaking: templates are `defineTemplate` in a static profile
+
+`@samva/markup` adds `defineTemplate({ id, schema, fixtures, locale?, email, sms?, whatsapp? })` at
+its root. A template is one TSX file in a static profile that the new compiler reads without running:
+text and attribute bindings, template strings, `&&`, `?:`, comparisons, `||`, `.length`, `.map`,
+`fmt.*` calls, arithmetic inside formatter arguments and conditions, partials with props and
+children, conditional class names, `.filter(condition)` before `.map` or `.length`, and
+`<Columns each per>` for grids (a `Column` without a `width` takes an equal share of its row). Everything else is a compile error with a stable code, a
+`file:line:column` location and a fix.
+
+- `@samva/markup/static` compiles a project to a versioned JSON IR (`"sml": 1`) and checks every
+  binding against the input schema: `unknown-field` with a did-you-mean, `unguarded-optional`, and
+  `fixture-invalid` per fixture. Tailwind, project CSS, brand themes, fonts and assets resolve at
+  compile time, and `checkTemplateCompatibility` locates client findings at source.
+- `@samva/markup/render-ir` renders the IR against an input as a pure, dependency-free function.
+  It escapes for text, attribute and URL contexts and rejects unsafe bound values.
+- `@samva/markup/fmt` adds the deterministic formatters `money`, `number`, `date`, `time`, `plural`
+  and `list`, which take their locale and time zone from the render.
+- `@samva/markup/sms` and `@samva/markup/whatsapp` add channel components with distinct names per
+  channel; WhatsApp bindings become Meta's positional `{{n}}` placeholders.
+- `id` is lowercase kebab-case, the rule the CLI and API slugs share. `subject` and `preheader`
+  belong to the channel; the `Email` component no longer takes a `preheader` prop.
+
+`defineEmail` remains for templates that compute over their input, and it stays outside the static
+profile.
+
+## @samva/vite@0.8.0
+
+### Breaking: `@samva/markup/presets` is `@samva/markup/starters`
+
+Every `@samva/markup/presets*` subpath is renamed to `@samva/markup/starters*`, and its exports
+follow: `presetCatalog` is `starterCatalog`, `presetProject` is `starterProject`,
+`presetEmailFixtures` is `starterEmailFixtures`, and every other `preset*` / `Preset*` name reads
+`starter*` / `Starter*`. A public gallery entry's `presetId` is `starterId`, and the corpus
+record types are `OwnedEditableStarter` and `BrandRecreationStarter`. `RECOMMENDED_THEME` and
+`showcaseProjectPaths` are removed.
+
+### Starters on theme variables
+
+Every starter styles each color and font through a theme variable, and keeps its look in its own
+`starter.css`. `@samva/markup/starters/theme` names the variables every starter defines and a
+brand sets to restyle one (`STARTER_THEME_VARIABLES`: `--color-brand`, `--color-surface`,
+`--font-body` and the rest; `starterThemeVariableNames` adds each color's `-dark` pair) and writes
+the `theme.css` a project starts with (`starterThemeCss({ brand })`), which imports `samva:brand`
+only when `brand` is true:
+
+```css
+@import "./starter.css";
+@import "samva:brand";
+@theme {
+}
+```
+
+`var()` now resolves in a `Button`'s classic Outlook shape and in a `bgcolor`, so
+`<Button backgroundColor="var(--color-brand)">` paints the theme color everywhere. Every `@theme`
+in project and brand CSS compiles as `static`, so a variable a project stylesheet reads reaches
+the inliner even when no utility class reads it.
+
+### Theme imports and brand themes
+
+A project `theme.css` layers with `@import`: another project stylesheet by relative path, then the
+organization's brand, then the project's own `@theme` overrides.
+
+```css
+@import "./starter.css";
+@import "samva:brand";
+
+@theme {
+  --color-accent: #0f766e;
+}
+```
+
+`samva:brand` names the organization's default brand and `samva:brand/<slug>` names one brand; the
+build supplies it through `compileEmailProject`'s `brand` option. `parseBrandCss` and
+`printBrandCss` (`@samva/markup/theme-css`) read and write the brand theme grammar: `@theme`
+variables in the color, font, text, leading, tracking, radius, spacing, container and shadow
+namespaces, `--color-*` variables in a `@media (prefers-color-scheme: dark)` block, and
+`@font-face` rules with https WOFF2 sources. A dark-mode color compiles to its `--color-*-dark`
+theme variable, read by `dark:` utilities.
+
+A project compiles against one brand: importing two fails with `brand-import-conflict`, and a
+`samva:brand` import the build has no brand for, or whose slug names another brand, fails with
+`brand-unavailable`. A brand theme outside the grammar fails with its `brand-css-*` finding.
+`@samva/markup/compiler` exports `parseBrandSpecifier`, `projectBrandSpecifier` and the
+`EmailBrand` types.
+
+Breaking: any other `@import` in the theme — including `@import "tailwindcss"` — now refuses the
+compile with `css-import-unresolved` instead of resolving to nothing. An `@import` with layer,
+supports or media conditions, one that imports itself, or a `.css` path outside the project is
+refused the same way. A theme with no utility class in use still compiles its `@font-face` rules.
+
+### `BrandLogo` and `BrandFooter`
+
+```tsx
+import { BrandFooter, BrandLogo } from "samva:brand";
+```
+
+`BrandLogo` renders the brand's logo and swaps to its dark logo where the client honors dark mode.
+It takes `width` (default 120), `alt`, `align` and `className`, and renders nothing when the brand
+has no logo. `BrandFooter` takes `unsubscribeLabel` and `className`.
+`BrandFooter` renders the company name, postal address, social links and an unsubscribe row; the
+send path fills the unsubscribe link per delivery and never click-tracks it, and a template that
+renders `BrandFooter` gets no appended footer. Add `"types": ["@samva/markup/samva-brand"]` to the
+project's tsconfig so `tsc` knows the module.
+
+### Breaking: token-table exports removed
+
+`@samva/markup/footer`, `@samva/markup/theme`, and `@samva/markup/tokens` are removed; a brand's
+footer renders through `BrandFooter`. `parseThemeCss` and `printThemeCss` are replaced by
+`parseBrandCss` and `printBrandCss` in `@samva/markup/theme-css`.
+
+### Local builds resolve `samva:brand`
+
+`samvaEditor()`, `buildTemplates()` and `exportEmailProject()` compile a project that imports
+`samva:brand` or `samva:brand/<slug>` against its organization's brand, resolved in this order:
+
+1. Live. With `SAMVA_API_KEY` in the environment or the project's `.env` (and `SAMVA_API_URL` for
+   another API), the brand is fetched from `/v1/brands`. Without one, the `samva` CLI on `PATH`
+   answers `samva brands get --json` with its `samva login` session; `@samva/vite` stores no
+   credential.
+2. Snapshot. `.samva/brands/<slug>.json`, written by `samva brands pull [slug]`, with a
+   `brand-offline` warning. The default brand reads the most recent snapshot pulled while it was
+   the default.
+3. Neither. The build fails with `brand-unavailable`, naming both fixes.
+
+When the live brand's digest differs from the snapshot's, the build warns with
+`brand-snapshot-stale`; run `samva brands pull` again. Warnings are build diagnostics and editor log
+lines and never fail a build. The editor and `check --watch` reuse a resolution for up to 30
+seconds. Keep `.samva` in `.gitignore`; a project that imports no brand needs no credentials.
+
+`@samva/vite/project` exports `resolveProjectBrand`, `loadBrandEnv`, `BRAND_SNAPSHOT_DIR` and the
+`BrandResolution`, `BrandSnapshot`, `BrandWarning` and `ResolvedBrand` types. The editor recompiles
+the theme when any stylesheet it imports changes.
+
+### Breaking: `exportEmailProject` themes the export
+
+`exportEmailProject` drops `tailwind` and takes `root` and `theme`. `dir` holds the templates and
+`root` (default `dir`) is the project: its `theme.css` themes the export as in `buildTemplates()`,
+`theme` names another file or `false` disables it, and only `.tsx` files under `dir` are entries.
+
+```ts
+const receipt = await exportEmailProject({ dir: "emails", root: ".", out: "dist/email" });
+```
+
+### Project fonts in `@font-face`
+
+A template project declares a webfont with ordinary CSS: an `@font-face` in `theme.css` (or any
+imported stylesheet) whose `src` names a `.woff2` file in the project, plus a `--font-*` token in
+`@theme`.
+
+```css
+@font-face {
+  font-family: "Brand Sans";
+  src: url("./fonts/brand-sans.woff2") format("woff2");
+  font-weight: 400;
+}
+@theme {
+  --font-brand: "Brand Sans", Helvetica, Arial, sans-serif;
+}
+```
+
+The compiler serves the file as a content-addressed asset, so local previews, exports and
+publications all load the same bytes, and it puts the rule in a `<style>` classic Outlook does not
+read, so Outlook uses the rest of the stack instead of Times New Roman.
+
+Breaking for projects that already declared fonts: a relative `src` that names no project file, a
+source that is not WOFF2, and an `http:` or `data:` source are compile errors, and a `font-family`
+stack that names a project font without ending in a generic family fails with
+`email-font-fallback`. `Stylesheet` gains `fontFaces`, and `@font-face` no longer appears in
+`headAtRules`.
+
+## @samva/vite@0.7.0
+
+### Breaking: WhatsApp `category="service"` removed
+
+`<WhatsApp category>` accepts `marketing`, `utility`, or `authentication`, the categories Meta
+approves templates under.
+
+## @samva/vite@0.6.0
+
+### Improve markup compilation safety
+
+Invalid or unsafe markup is now rejected earlier, preventing malformed email output. Complex styles
+and conditions also compile more reliably.
+
+### Carry the plain-text alternative on a public preview artifact
+
+`buildPublicTemplatePreviewArtifact` returns `text` alongside `html`, `subject` and `preheader`, so
+a surface that mounts a preset's published preview has the whole executed fixture rather than its
+HTML half. It is the same value `renderEmail` derived when the artifact was built; nothing is
+recomputed.
+
+## @samva/vite@0.5.0
+
+### Breaking: a template project no longer installs Effect
+
+- **A much smaller install:** `@samva/markup` has no Effect dependency and no `ajv` dependency, so a template project's lockfile and `node_modules` drop both graphs. The JSON Schema 2020-12 dialect the input validator checks against ships inside the package. Writing templates is unchanged: JSX, `defineEmail`, components, fixtures, and the input schema all work exactly as before, and you can still declare template input with an Effect, Zod, or plain JSON schema.
+- **`@samva/vite` drops Effect too:** The Vite plugin carries no Effect dependency either, so `samva email templates build`, the editor dev server, and a template project that installs both packages resolve neither graph.
+- **Breaking: compile and render results:** Everything the compiler returns is now a [better-result](https://better-result.dev) `Result`. Read a success with `Result.isOk(result)` and `result.value`, a failure with `Result.isError(result)` and `result.error`. Errors keep their names and tags — `SmlParseError`, `SmlCompileError`, `SmlOpError`, `EmailCompileError` — so code that matches on `_tag` or catches `EmailCompileError` still works.
+- **Breaking: data unions discriminate on `type`:** `EmailNode` and the editor-op, corpus and gallery unions name their variant with `type` instead of `_tag` — `node.type === "Element"`, `op.type === "setProp"`. Compiler errors are unaffected: `SmlParseError`, `SmlCompileError`, `SmlOpError` and `EmailCompileError` keep `_tag`, which is their error library's own field.
+- **Breaking: schema values are gone:** The package declares its data models as TypeScript types only. Runtime schema values such as `EmailDiagnostic`, `EmailElementSelection`, `SmlOpSchema`, and `SmlDocumentSchema` no longer exist; the types of the same name do, and the shapes are identical. If you decoded one of these at a boundary, declare the schema in your own project against the exported type.
+
+## @samva/vite@0.4.0
+
+### Faster, reliable saves in large projects
+
+- **Saves in large projects are quick again:** Saving a template no longer re-evaluates every template in the project, so previews come back in about the time one template takes to build.
+- **No false "Document changed elsewhere" banner:** Your own edits and fixture switches are recognized as yours, so the editor no longer locks the source panel and undo after a save. Edits made outside the editor are still detected.
+
+### Breaking: every email template is a complete, editable project
+
+- **28 templates rebuilt:** The 28 remaining single-file presets are rebuilt as showcase projects with their own stylesheet, drawn artwork, and `default` and `long-content` sample data. Marketing, digest, lifecycle, commerce, and notification templates are covered, authored for five fictional senders: Northwick, Kestrel, Northloop, Fernhollow, and Meridian. Template ids and their gallery pages are unchanged.
+- **Breaking: simpler template inputs:** Repeating content such as stories, deals, agenda items, checklist steps, and order lines is a list instead of numbered fields. Images are bundled with the project instead of passed as URLs, and headline and body copy is edited in the template source rather than supplied as input. Optional sections such as sponsors, gift cards, and reminders appear only when you send them. Dates, days remaining, and step numbers come from your input, so scheduled sends never depend on the clock. If you render one of these templates with your own data, move to the new input shape; each template's sample data shows it.
+- **Breaking: four presets retired:** `receipt`, `newsletter`, `promo`, and `order-delivered` are removed from the catalog, the public gallery, and the `PresetId` types. Use `order-receipt`, `product-newsletter`, and `product-launch-promo` instead.
+- **Stock photography removed:** The onboarding tour and setup checklist templates now use drawn artwork, so no template depends on third-party images.
+
+## @samva/vite@0.3.0
+
+- **Reliable project styling:** Switching between projects or preview fixtures preserves each template's styles and avoids unexpected revision changes.
+- **Better Outlook buttons:** `<Button>` sizes to its label without requiring a fixed width. Explicit widths remain supported.
+- **New editable templates:** Product newsletter, order receipt, product launch promotion, and an attributed Vercel invitation, including styles, images, and sample data.
+- **Richer template inputs:** Use lists and objects for repeating content such as newsletter stories and receipt items.
+- **Cleaner plain-text emails:** Empty table cells no longer leave unnecessary separators.
+- **For custom render integrations:** `bindStylesheets` from `@samva/markup/email/render` binds a renderer to one project's styles.
+
+## @samva/vite@0.2.0
+
+### Breaking: author email templates with typed input and executable TSX
+
+Email entries now default-export `defineEmail({ id, schema, fixtures, render })` from
+`@samva/markup/template`. Replace function-based email entries and `Variables<T>` placeholders
+with a schema and a `render(input)` function. Set `jsxImportSource` to `@samva/markup/email`,
+import email components from `@samva/markup/email/components`, and upgrade `@samva/markup` and
+`@samva/vite` together to 0.2.0. Regenerate the project's dependency lockfile before publishing.
+
+The input contract supports Standard JSON Schema, including Effect and Zod schema adapters.
+`TemplateInput<typeof template>` extracts the inferred input type. Named fixtures supply preview
+and validation inputs; rendering evaluates ordinary TSX, imported components, conditionals and
+mapped arrays against actual input. Time and randomness must come from input or fixed `runtime`
+configuration.
+
+The shared local and hosted compiler resolves CSS, Tailwind and imported assets, validates fixture
+inputs, and produces HTML, text and email-client diagnostics. Diagnostics identify known support
+constraints; they do not certify rendering in every email client.
+
+The Vite editor maps rendered instances to canonical TSX source. Literal edits preserve the
+source expression; computed or structural changes use reviewed source edits. Fixture switching,
+undo/redo, save/reopen and revision-conflict handling keep source edits tied to the preview.
+
+Published email templates pin an executable, input contract, dependency graph and runtime
+configuration. Existing email source must adopt the new contract and be republished; previously
+published HTML snapshots are not executable publications.
+
+## @samva/vite@0.1.2
+
+### Reject oversized SML templates before compilation
+
+Templates that exceed supported size, nesting, or node limits now return a validation error before
+compilation.
+
+## @samva/vite@0.1.1
+
+### Release the 0.1.1 package family
+
+`@samva/vite` publishes with the rest of the 0.1.1 family.
+
+## @samva/vite@0.1.0
+
+### Publish the Samva template authoring toolchain
+
+`@samva/markup` and `@samva/vite` are published on npm. They provide typed TSX authoring, local
+visual editing, and deterministic template builds. `samva templates push` uploads the compiled
+templates.