@samva/vite 0.1.1 → 0.2.0

package/AGENTS.md

@@ -5,4 +5,73 @@ Install `@samva/markup`, `@samva/vite`, and the Vite peer in the template projec
 programmatic template builds and `@samva/vite/emit` only for module-preview integration.
 
 The CLI loads `@samva/vite/build` from the current project. Keep these authoring dependencies in the
-project lockfile so local preview and `samva templates push` use the same compiler version.
+project lockfile so local preview, check, and build use the same compiler version as the project.
+
+Hosted synchronization is ordinary Git. A CLI-created project has a repository-local Samva
+credential helper, and `samva templates publish` accepts only a clean exact commit reachable from
+the fetched `origin` default branch. Publish creates an immutable receipt; it does not push or
+rewrite history.
+
+Template discovery is `.tsx` only. The local email editor writes the canonical TSX entry with a
+revision check and a fresh comparison against disk; SMS and WhatsApp stay read-only. Every discovered entry is imported once through the dev
+server's own SSR graph, and a default export that is a template definition takes the email lane —
+compiled and rendered through `compileEmailProject`, so a local render cannot drift from a published
+one. Email requires an executable definition. Structured SMS/WhatsApp entries emit SML, and
+for SMS and WhatsApp an invalid current TSX keeps and visibly labels the last successful emission
+while the same file remains discovered; deleting the file removes it.
+
+The email document is one executed render of one declared fixture: the fixture names the template
+declares, the fixture being viewed, the render stamped with `data-samva-instance`, and the compile
+and client findings taken from rendering every declared fixture as it will be delivered. An entry
+that does not build keeps its place with a null render and the findings that stopped it. Its
+revision is a digest of authored source and what the declared fixtures render, so source locations
+cannot stay pinned after a formatting-only edit. It stays put when only the viewed fixture changes. The dev server is not an https origin, so a local
+render points at the editor's own asset route by path — every render here is a preview or the input
+to a finding, and the base a publication serves from is a build input rather than authored.
+
+Object email projects compile through `@samva/vite/email`. It is an adapter: the whole compile step
+is `@samva/markup/compiler`'s `compileEmailProject`, the same call the hosted build makes, and this
+package owns only module resolution and evaluation. The asset base is an explicit input, so a
+build and an export can address the same content from different origins. Both entry points evaluate
+the compiler's generated wrapper rather than the authored entry: the render has to happen inside the
+graph the project's stylesheets registered into.
+
+`createEmailRenderer` keeps one evaluator across renders, as a dev server does, and gives each
+project its own id namespace so their modules coexist. Anything the compiler rewrote into
+JavaScript — a stylesheet, an imported asset — is served under a `.js` id; its authored extension
+would be claimed by Vite's CSS or asset pipeline. A caller that reloads the same project passes a
+stable `namespace` so ids survive the reload and `invalidate()` is what makes changed source take
+effect; omitting it takes a fresh namespace, which is what isolates unrelated projects.
+
+`@samva/vite/project` is the folder-of-templates surface. A project holds many definitions with
+shared components and CSS between them; which `.tsx` files are templates is decided by evaluating
+the compiler's generated wrapper and asking whether the default export is a template definition, so
+an ordinary helper module needs no marker and no exclusion list. Identity is the id the definition
+declares, never its path, and two definitions declaring one id is a reported error. Fixtures are
+validated against the template's own schema before they render, so a bad fixture is a source defect
+the author sees locally.
+
+`exportEmailProject` renders in the compiler's export mode (`relativeUrls: true`). It writes one
+page at `templates/<id>/<fixture>.html` and every asset once under `assets/`, so its default
+`../../assets` base is the path from a page's own directory to those bytes. Delivery keeps
+refusing a relative reference — an inbox has no directory to resolve one against — so an export
+destined for sending names the https origin it will be served from instead. Either way the export
+writes each asset under its content address and records the base, so the manifest is the whole
+mapping.
+
+A refused render reports against the one fixture rather than throwing at the caller: one template
+that cannot render must not take the rest of the catalog with it.
+
+The evaluator roots itself at this package's own directory and refuses an ambient Vite config.
+Virtual ids have no directory, so bare imports resolve against the server root; rooting here is what
+makes `@samva/markup` resolve under a per-package install as well as a hoisted one.
+
+A golden-digest test in `tests/email-parity.test.ts` pins this adapter's output against the same
+value the hosted build asserts in `apps/agents/tests/workerd/email-parity.test.ts`.
+
+## Verification
+
+`bun run --filter @samva/vite test:browser` builds the plugin and embedded editor, then runs the
+Chromium source-editing integration tests. `test:browser:cross` runs Chromium, Firefox, and WebKit.
+These tests own temporary template projects and plugin servers; the editor library's browser suite
+tests its standalone host separately.

package/README.md

@@ -1,8 +1,8 @@
 # @samva/vite
 
 The unified local editor for Samva email, SMS, and WhatsApp templates. One Vite
-plugin discovers `.samva` and `.tsx` files, evaluates TSX through the Samva JSX
-runtime, applies the project theme, and serves the full visual editor with HMR.
+plugin discovers `.tsx` files, evaluates them through the Samva JSX runtime,
+applies the project theme, and serves the full visual editor with HMR.
 
 ## Install
 
@@ -12,9 +12,8 @@ Keep the authoring library and editor in the project, with Vite provided as the
 npm install --save-dev @samva/markup @samva/vite vite
 ```
 
-`samva templates init` writes these dependencies, an equivalent `samva.vite.config.ts`, and
-collision-resistant `samva:dev` / `samva:push` package scripts. Existing project scripts remain
-untouched.
+`samva templates init` creates a project from the canonical starter, which contains these
+dependencies and an equivalent `vite.config.ts`. Existing project scripts remain untouched.
 
 ```ts
 import { samvaEditor } from "@samva/vite";
@@ -44,65 +43,114 @@ to the rest of the Vite middleware stack.
 
 ## Authoring files
 
-- `.samva` files are editable for every channel.
-- `.tsx` files are code-authored and always read-only in the editor. The source
-  view shows authored TSX beside the emitted SML used for rendering.
-- A `.tsx` file contains at most one template, and that template must be its
-  `default` export. Named exports are ignored, so they remain available for
-  helpers and constants. A file without a default export is excluded with a
-  warning; an invalid default export is a diagnostic.
+Email `.tsx` entries default-export `defineEmail({ id, schema, fixtures, render })` from
+`@samva/markup/template`. Use the `@samva/markup/email` JSX runtime and primitives from
+`@samva/markup/email/components`. Ordinary synchronous helpers, conditions and loops execute
+against actual validated JSON. Shared helper modules are excluded from the template catalog;
+ids are stable independently of paths and must be unique within the project.
 
 ```tsx
-import { Email, Text } from "@samva/markup/components";
-import type { Variables } from "@samva/markup/variables";
-
-export const subjectPrefix = "Hello"; // helper, ignored by discovery
-
-export default function Welcome(v: Variables<{ firstName: string }>) {
-  return (
-    <Email>
-      <Text>
-        {subjectPrefix}, {v.firstName}
-      </Text>
-    </Email>
-  );
-}
+/** @jsxImportSource @samva/markup/email */
+import { Schema } from "effect";
+import { Email, Section } from "@samva/markup/email/components";
+import { defineEmail } from "@samva/markup/template";
+
+export default defineEmail({
+  id: "welcome",
+  schema: Schema.toStandardJSONSchemaV1(
+    Schema.Struct({ firstName: Schema.String, items: Schema.Array(Schema.String) }),
+  ),
+  fixtures: { basic: { firstName: "Ada", items: ["Your first project"] } },
+  render: (input) => ({
+    subject: `Welcome, ${input.firstName}`,
+    preheader: "Your account is ready",
+    body: (
+      <Email>
+        <Section>
+          <h1>Welcome, {input.firstName}</h1>
+          {input.items.length > 0 && (
+            <ul>
+              {input.items.map((item) => (
+                <li key={item}>{item}</li>
+              ))}
+            </ul>
+          )}
+        </Section>
+      </Email>
+    ),
+  }),
+});
 ```
 
-The editor keeps preview, SML, compiled HTML/plain text or channel payload,
-light/dark email rendering, responsive widths, diagnostics, and variable samples
-in one surface. Editing a template, imported dependency, or `theme.css` refreshes
-the relevant catalog and open document.
+The email editor previews declared fixtures and offers source-aware edits where the source intent
+is unambiguous. Source is canonical. Failed email entries remain visible with diagnostics and a
+null render. SMS and WhatsApp remain read-only structured previews; an invalid edit retains their
+last successful emission and labels it stale. Deleting an entry removes its preview.
+
+The browser canvas is a structural preview of Samva's modern and Outlook-safe
+compiler output. It does not emulate the exact Gmail, Outlook, Apple Mail, or
+Yahoo rendering engines. Use compatibility findings and inbox tests for
+client-specific proof.
 
 ## Options
 
 | Option         | Type              | Default       | Description                                                      |
 | -------------- | ----------------- | ------------- | ---------------------------------------------------------------- |
-| `templatesDir` | `string`          | `"emails"`    | Recursive `.samva` / `.tsx` template directory.                  |
+| `templatesDir` | `string`          | `"emails"`    | Recursive `.tsx` template directory.                             |
 | `route`        | `string`          | `"/"`         | Absolute editor UI route; API and assets are mounted beneath it. |
 | `theme`        | `string \| false` | `"theme.css"` | Project theme file, or `false` to disable discovery.             |
-| `compile`      | `CompileOptions`  | —             | Extra compile options applied to local rendering and validation. |
 
-## Theme and push
+## Theme, check, and publish
 
 A root `theme.css` uses Tailwind v4 `@theme` syntax. Theme changes recompile
 local previews while preserving the last valid theme when an edit is temporarily
 invalid.
 
-`samva templates push --dir emails` and `buildTemplates()` run the same default-export
-TSX evaluation and emit pipeline. They send or return SML, never compiled HTML;
-the platform recompiles the SML with the organization theme.
+`samva templates check` and `buildTemplates()` execute every email fixture and validate its
+actual input. `buildTemplates()` returns `files`, each with a `preview.kind` discriminator:
+`email` contains input schema, compiled module graph, actual fixture subject/HTML/text and
+structured diagnostics; `structured` contains the SMS/WhatsApp preview. Helper modules have no
+file entry. An email requires at least one fixture.
+
+`samva templates build --dir emails --out dist/templates.json` writes the CLI's version 2 local
+artifact. Check writes no files. `check --watch` observes changes; `--jsonl` emits one observation
+per rebuild and `--json` is one-shot. A successful fixture check does not prove every possible
+input branch.
 
-The runnable `examples/email-starter` workspace exercises this exact setup.
+Imported email assets require `assetBase` in `buildTemplates()` or `--asset-base` in CLI checks
+and builds, naming their actual HTTPS serving base. No credentials are needed for local work.
 
-## Template identity
+For a hosted project, commit and push the checked TSX tree with ordinary Git, then publish one exact
+commit:
+
+```sh
+git add .
+git commit -m "feat: update welcome email"
+git push origin main
+samva templates publish --commit HEAD
+```
 
-Template identity comes from the file name, and only the default export is
-evaluated — `welcome-email.tsx` owns the platform slug `welcome-email`.
-Renaming a file changes template identity; the CLI treats the new name as a
-different template and `--force` does not remap identities. Direct
-`@samva/vite/emit` callers pass the file-backed template name:
+The CLI's repository-local credential helper obtains a short-lived Artifact credential through
+Samva's credential protocol when Git needs one. It validates the repository host/path and does not
+store the token in Git config or the remote URL. `templates publish` requires a clean worktree and
+an exact commit reachable from the fetched `origin` default branch; it creates an immutable
+publication receipt and does not push or rewrite history.
+
+Hosted builds consume the committed Bun text lockfile version 2 or npm lockfile version 3.
+Keep dependencies and the supported lockfile in the project. Sending selects an exact immutable
+publication by default; later source edits do not change that publication.
+
+## Local export
 
 ```ts
-emitModulePreview("welcome-email", moduleExports, compileOptions);
+import { exportEmailProject } from "@samva/vite/project";
+
+const receipt = await exportEmailProject({ dir: ".", out: "dist/email" });
 ```
+
+Export writes `templates/<id>/<fixture>.html` and `.txt`, content-addressed files under `assets/`,
+and `catalog.json` with the asset mapping and findings. The default `../../assets` base resolves
+from each exported page. For delivery, supply the actual HTTPS `assetBase` and serve those bytes
+there; relative URLs are for local export. External HTTPS images stay external references.
+
+The runnable `examples/email-starter` workspace exercises the authoring setup.

package/dist/build.d.ts

@@ -1,42 +1,61 @@
 import { ModulePreview } from "./emit.js";
-import { CompileOptions } from "@samva/markup/compile";
-import { Diagnostic } from "@samva/markup/diagnostics";
+import { CompiledEmailProject } from "@samva/markup/compiler";
+import { EmailDiagnostic } from "@samva/markup/email/diagnostics";
 //#region src/build.d.ts
+/** One declared input rendered through executable email source. */
+interface EmailFixtureBuild {
+  readonly name: string;
+  readonly input: unknown;
+  readonly ok: boolean;
+  readonly subject?: string | undefined;
+  readonly preheader?: string | undefined;
+  readonly html?: string | undefined;
+  readonly text?: string | undefined;
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/** Executable email artifacts retain their input contract, module graph and actual fixture output. */
+interface EmailBuildPreview {
+  readonly kind: "email";
+  readonly ok: boolean;
+  readonly compilerVersion: string;
+  readonly diagnostics: readonly EmailDiagnostic[];
+  readonly templates: readonly {
+    readonly name: string;
+    readonly channel: "email";
+    readonly ok: boolean;
+    readonly source: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+    readonly compiled: CompiledEmailProject;
+    readonly fixtures: readonly EmailFixtureBuild[];
+  }[];
+}
+type TemplateBuildPreview = EmailBuildPreview | (ModulePreview & {
+  readonly kind: "structured";
+});
 interface BuildTemplatesResult {
-  /** One entry per discovered template file, in discovery (sorted) order. */
+  /** Authored entry paths, sorted; helper modules have no entry here. */
   readonly files: ReadonlyArray<{
     readonly id: string;
-    readonly kind: "tsx" | "samva";
-    readonly preview: ModulePreview;
+    readonly kind: "tsx";
+    readonly preview: TemplateBuildPreview;
   }>;
-  /**
-   * Project theme.css parse diagnostics (spans into theme.css). `buildTemplates`
-   * always sets it (empty when the theme parsed or there is no theme file);
-   * optional so callers constructing a result by hand needn't supply it.
-   */
-  readonly themeDiagnostics?: ReadonlyArray<Diagnostic> | undefined;
 }
 interface BuildTemplatesOptions {
-  readonly compile?: CompileOptions | undefined;
-  /**
-   * Project root to discover `theme.css` from (design brief §7e), themed into
-   * every compiled preview as the org-token layer. Defaults to the parent of
-   * `dir` (templates live under the project root, e.g. `emails/`).
-   */
+  /** Project root containing shared imports and theme.css; defaults to the parent of dir. */
   readonly root?: string | undefined;
-  /**
-   * Theme file override, relative to `root`. `false` disables theme discovery.
-   * Default: `theme.css`.
-   */
   readonly theme?: string | false | undefined;
+  /** Required for imported email assets. Must be their actual HTTPS serving base. */
+  readonly assetBase?: string | undefined;
+}
+interface TemplateBuildSession {
+  readonly build: () => Promise<BuildTemplatesResult>;
+  readonly subscribe: (listener: (path: string) => void) => () => void;
+  readonly close: () => Promise<void>;
 }
-/**
- * Discovers and evaluates every `.tsx`/`.samva` template under `dir`, returning
- * emitted SML + compiled artifacts per template — themed by the project's
- * `theme.css` if present. Throws if `vite` is not installed (the optional peer) —
- * the caller surfaces that as a user error.
- */
+/** Execute each email definition's fixtures; compile structured SMS/WhatsApp through their channel compiler. */
 declare const buildTemplates: (dir: string, options?: BuildTemplatesOptions) => Promise<BuildTemplatesResult>;
+/** A watcher and module evaluator over the project's installed authoring toolchain. */
+declare const createTemplateBuildSession: (dir: string, options?: BuildTemplatesOptions) => Promise<TemplateBuildSession>;
 //#endregion
-export { BuildTemplatesOptions, BuildTemplatesResult, buildTemplates };
+export { BuildTemplatesOptions, BuildTemplatesResult, EmailBuildPreview, EmailFixtureBuild, TemplateBuildPreview, TemplateBuildSession, buildTemplates, createTemplateBuildSession };
 //# sourceMappingURL=build.d.ts.map

package/dist/build.js

@@ -1,87 +1,186 @@
-import { a as discoverTemplateFiles, i as withThemeLayer, n as loadProjectTheme, r as resolveThemePath } from "./theme-CfJe8s3k.js";
-import { COMPILER_VERSION, compileSourcePreview, emitModulePreview } from "./emit.js";
-import { dirname, parse, resolve } from "node:path";
+import { n as resolveThemePath, r as discoverTemplateFiles, t as readProjectThemeCss } from "./theme-CBF6Czjm.js";
+import { COMPILER_VERSION, emitModulePreview } from "./emit.js";
+import { createEmailRenderer } from "./email.js";
+import { isTemplateDefinition, readEmailProject, renderEmailFixtures } from "./project.js";
+import { dirname, parse, relative, resolve, sep } from "node:path";
 //#region src/build.ts
-/**
-* Discovers and evaluates every `.tsx`/`.samva` template under `dir`, returning
-* emitted SML + compiled artifacts per template — themed by the project's
-* `theme.css` if present. Throws if `vite` is not installed (the optional peer) —
-* the caller surfaces that as a user error.
-*/
+/** Execute each email definition's fixtures; compile structured SMS/WhatsApp through their channel compiler. */
 const buildTemplates = async (dir, options = {}) => {
-	const templatesDir = resolve(dir);
-	const root = options.root ?? dirname(templatesDir);
-	const theme = await loadProjectTheme(resolveThemePath(root, options.theme));
-	const compile = withThemeLayer(options.compile, theme.tokens);
-	const files = await discoverTemplateFiles(templatesDir);
-	const server = files.filter((file) => file.kind === "tsx").length > 0 ? await createEvaluator(templatesDir) : void 0;
+	const session = await createTemplateBuildSession(dir, options);
 	try {
-		return {
-			files: await Promise.all(files.map(async (file) => {
-				if (file.kind === "samva") {
-					const { readFile } = await import("node:fs/promises");
-					const source = await readFile(file.path, "utf8");
-					const name = file.id.replace(/\.samva$/, "");
-					const template = compileSourcePreview(name, source, compile);
-					const preview = {
-						ok: template.ok,
-						compilerVersion: COMPILER_VERSION,
-						templates: [template],
-						diagnostics: []
-					};
-					return {
+		return await session.build();
+	} finally {
+		await session.close();
+	}
+};
+const emailFinding = (code, message) => ({
+	code,
+	severity: "error",
+	message,
+	origins: []
+});
+const emailFailure = (cause, code = "email-build-error") => ({
+	kind: "email",
+	ok: false,
+	compilerVersion: COMPILER_VERSION,
+	templates: [],
+	diagnostics: Array.isArray(cause?.diagnostics) ? cause.diagnostics : [emailFinding(code, cause instanceof Error ? cause.message : String(cause))]
+});
+/** A watcher and module evaluator over the project's installed authoring toolchain. */
+const createTemplateBuildSession = async (dir, options = {}) => {
+	const templatesDir = resolve(dir);
+	const root = resolve(options.root ?? dirname(templatesDir));
+	const themePath = resolveThemePath(root, options.theme);
+	await discoverTemplateFiles(templatesDir);
+	const server = await createEvaluator(templatesDir);
+	server.watcher.add(root);
+	if (themePath !== void 0) server.watcher.add(themePath);
+	let closed = false;
+	let emailRenderer;
+	let previousTheme;
+	const build = async () => {
+		server.moduleGraph.invalidateAll();
+		const themeCss = await readProjectThemeCss(themePath);
+		if (emailRenderer !== void 0 && themeCss !== previousTheme) {
+			await emailRenderer.close();
+			emailRenderer = void 0;
+		}
+		previousTheme = themeCss;
+		emailRenderer?.invalidate();
+		const files = await discoverTemplateFiles(templatesDir);
+		const sourceFiles = await readEmailProject(root);
+		const entries = [];
+		const emailIds = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const evaluated = await server.ssrLoadModule(file.path).then((moduleExports) => ({
+				ok: true,
+				moduleExports
+			}), (cause) => ({
+				ok: false,
+				cause
+			}));
+			if (!evaluated.ok) {
+				entries.push({
+					id: file.id,
+					kind: file.kind,
+					preview: emailFailure(evaluated.cause)
+				});
+				continue;
+			}
+			const definition = evaluated.moduleExports.default;
+			if (definition === void 0) continue;
+			if (isTemplateDefinition(definition)) {
+				const entryPath = relative(root, file.path).split(sep).join("/");
+				const previous = emailIds.get(definition.id);
+				if (previous !== void 0) {
+					entries.push({
 						id: file.id,
 						kind: file.kind,
-						preview
-					};
+						preview: emailFailure(`Duplicate template id ${definition.id}: ${previous} and ${file.id}`, "duplicate-template-id")
+					});
+					continue;
 				}
-				const name = parse(file.id).name;
-				const evaluated = await server.ssrLoadModule(file.path).then((value) => ({
-					ok: true,
-					moduleExports: value
-				})).catch((cause) => ({
-					ok: false,
-					message: cause instanceof Error ? cause.message : String(cause)
-				}));
-				if (!evaluated.ok) return {
-					id: file.id,
-					kind: file.kind,
-					preview: {
-						ok: false,
+				emailIds.set(definition.id, file.id);
+				const preview = await (async () => {
+					emailRenderer ??= await createEmailRenderer({
+						assetBase: options.assetBase ?? "",
+						...themeCss === void 0 ? {} : { tailwind: { css: themeCss } }
+					});
+					const loaded = await emailRenderer.load(sourceFiles, entryPath, entryPath);
+					const template = loaded.template;
+					if (!isTemplateDefinition(template)) return emailFailure(`${file.id} does not export defineEmail`);
+					const fixtures = renderEmailFixtures({
+						id: template.id,
+						entryPath,
+						definition: template,
+						loaded
+					}).map((fixture) => ({
+						name: fixture.fixture,
+						input: template.fixtures[fixture.fixture],
+						ok: fixture.rendered !== void 0 && !fixture.diagnostics.some((finding) => finding.severity === "error"),
+						...fixture.rendered === void 0 ? {} : {
+							subject: fixture.rendered.subject,
+							preheader: fixture.rendered.preheader,
+							html: fixture.rendered.html,
+							text: fixture.rendered.text
+						},
+						diagnostics: fixture.diagnostics
+					}));
+					const diagnostics = [...loaded.compiled.diagnostics];
+					if (fixtures.length === 0) diagnostics.push(emailFinding("missing-fixtures", `${template.id} must declare at least one fixture for check and build.`));
+					if (loaded.compiled.assets.length > 0 && options.assetBase === void 0) diagnostics.push(emailFinding("missing-asset-base", "Imported email assets require --asset-base with their HTTPS serving origin."));
+					if (loaded.compiled.assets.length > 0 && options.assetBase !== void 0 && !/^https:\/\//i.test(options.assetBase)) diagnostics.push(emailFinding("invalid-asset-base", "Email check and build require an HTTPS --asset-base; relative URLs belong to templates export."));
+					const ok = !diagnostics.some((finding) => finding.severity === "error") && fixtures.every((fixture) => fixture.ok);
+					return {
+						kind: "email",
+						ok,
 						compilerVersion: COMPILER_VERSION,
-						templates: [],
-						diagnostics: [{
-							code: "module-load-error",
-							message: evaluated.message,
-							span: {
-								start: 0,
-								end: 0
-							}
+						diagnostics,
+						templates: [{
+							name: template.id,
+							channel: "email",
+							ok,
+							source: String(sourceFiles[entryPath]),
+							inputSchema: template.schema.schema,
+							compiled: loaded.compiled,
+							fixtures
 						}]
-					}
-				};
-				return {
+					};
+				})().catch(emailFailure);
+				entries.push({
 					id: file.id,
 					kind: file.kind,
-					preview: emitModulePreview(name, evaluated.moduleExports, compile)
-				};
-			})),
-			themeDiagnostics: theme.diagnostics
-		};
-	} finally {
-		await server?.close();
-	}
+					preview
+				});
+				continue;
+			}
+			const preview = emitModulePreview(parse(file.id).name, evaluated.moduleExports);
+			if (preview.templates.length === 0) continue;
+			if (preview.templates.some((template) => /^\s*<Email(?:\s|>)/.test(template.source ?? ""))) entries.push({
+				id: file.id,
+				kind: file.kind,
+				preview: emailFailure(`${file.id}: email templates must default-export defineEmail with an input schema and fixtures.`, "email-requires-object-template")
+			});
+			else entries.push({
+				id: file.id,
+				kind: file.kind,
+				preview: {
+					...preview,
+					kind: "structured"
+				}
+			});
+		}
+		return { files: entries };
+	};
+	const subscribe = (listener) => {
+		const onChange = (_event, path) => listener(path);
+		server.watcher.on("all", onChange);
+		return () => server.watcher.off("all", onChange);
+	};
+	return {
+		build,
+		subscribe,
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			try {
+				await emailRenderer?.close();
+			} finally {
+				await server.close();
+			}
+		}
+	};
 };
 const createEvaluator = async (root) => {
 	const vite = await import("vite").catch(() => void 0);
-	if (vite === void 0) throw new Error("`vite` is required for `samva templates push`. Install it as a dev dependency (it ships as an optional peer of @samva/vite).");
+	if (vite === void 0) throw new Error("`vite` is required for template authoring. Install it as a dev dependency.");
 	return vite.createServer({
 		root,
+		configFile: false,
 		logLevel: "silent",
 		server: {
 			middlewareMode: true,
-			hmr: false,
-			watch: null
+			hmr: false
 		},
 		oxc: { jsx: {
 			runtime: "automatic",
@@ -94,6 +193,6 @@ const createEvaluator = async (root) => {
 	});
 };
 //#endregion
-export { buildTemplates };
+export { buildTemplates, createTemplateBuildSession };
 
 //# sourceMappingURL=build.js.map