@samva/vite 0.1.2 → 0.3.0

package/dist/editor/index.html

@@ -4,8 +4,8 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Samva editor</title>
-    <script type="module" crossorigin src="./assets/index-DbdWiln3.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-CI_j2PFe.css">
+    <script type="module" crossorigin src="./assets/index-Cot9JDdw.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-Cg4x6ewh.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/email.d.ts

@@ -0,0 +1,60 @@
+import { CompiledEmailProject, TransformOptions, compileEmailProject } from "@samva/markup/compiler";
+import { TemplateDefinition } from "@samva/markup/template";
+import { SerializeEmailOptions } from "@samva/markup/email/html";
+import { renderEmail } from "@samva/markup/email/render";
+//#region src/email.d.ts
+interface EmailProjectSource {
+  /** Project-relative path to text content, or to bytes for an imported file. */
+  readonly [path: string]: string | Uint8Array;
+}
+interface RenderedEmailProject extends ReturnType<typeof renderEmail> {
+  readonly compiled: CompiledEmailProject;
+}
+/**
+ * One compiled entry, evaluated. `template` is `undefined` when the entry has no
+ * default export, which is how a helper module is told apart from a template
+ * without inspecting authored source.
+ */
+interface LoadedEmailEntry {
+  readonly template: TemplateDefinition<unknown> | undefined;
+  readonly renderEmail: typeof renderEmail;
+  readonly compiled: CompiledEmailProject;
+}
+/** A long-lived evaluator. Every render shares its module graph, as a dev server does. */
+interface EmailRenderer {
+  /**
+   * Compile one entry and evaluate the compiler's generated wrapper. Callers
+   * that render several inputs against one template load once and render many
+   * times; nothing here renders on its own.
+   *
+   * `namespace` names the id space the entry's modules occupy. Reusing one
+   * keeps a watch session's ids stable across reloads, while a fresh one
+   * isolates an unrelated project. Omitting it takes a new namespace each time.
+   * Every load re-evaluates the namespace's own modules, so the wrapper binds
+   * the sheets its imports registered; `invalidate` reaches the modules shared
+   * between namespaces.
+   */
+  readonly load: (source: EmailProjectSource, entryPoint: string, namespace?: string) => Promise<LoadedEmailEntry>;
+  /**
+   * Compile, evaluate and render one input in a single call. `serialize` reaches
+   * the serializer, so a caller that renders for an editor asks for
+   * `instancePaths` here; a render that will be delivered passes nothing.
+   */
+  readonly render: (source: EmailProjectSource, entryPoint: string, input: unknown, serialize?: SerializeEmailOptions) => Promise<RenderedEmailProject>;
+  /** Drop every evaluated module so the next load re-reads changed source. */
+  readonly invalidate: () => void;
+  readonly close: () => Promise<void>;
+}
+/**
+ * One Vite server, many renders. Each project gets its own id namespace so their
+ * modules coexist in one graph — which also means they share one instance of
+ * `@samva/markup`, exactly as a published consumer's install does. That shared
+ * instance holds the stylesheet registry, which is why the compiler's generated
+ * reset module runs first in every project's graph.
+ */
+declare const createEmailRenderer: (options: TransformOptions, ssrExternal?: readonly string[]) => Promise<EmailRenderer>;
+/** Compile and render one project, then release the evaluator. */
+declare const renderEmailProject: (source: EmailProjectSource, entryPoint: string, options: TransformOptions, input: unknown) => Promise<RenderedEmailProject>;
+//#endregion
+export { type CompiledEmailProject, EmailProjectSource, EmailRenderer, LoadedEmailEntry, RenderedEmailProject, compileEmailProject, createEmailRenderer, renderEmailProject };
+//# sourceMappingURL=email.d.ts.map

package/dist/email.js

@@ -0,0 +1,126 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compileEmailProject } from "@samva/markup/compiler";
+//#region src/email.ts
+const VIRTUAL = "/@samva-email/";
+/** This package's own directory: `src` in the repository, `dist` when published. */
+const RESOLUTION_ROOT = dirname(fileURLToPath(import.meta.url));
+const SCRIPT = /\.[cm]?[jt]sx?$/;
+const qualify = (path) => SCRIPT.test(path) ? path : `${path}.js`;
+const unqualify = (id) => id.endsWith(".js") && !SCRIPT.test(id.slice(0, -3)) ? id.slice(0, -3) : id;
+const resolveWithin = (graph, id, importer) => {
+	const own = id.startsWith(graph.prefix) ? unqualify(id.slice(graph.prefix.length)) : id;
+	if (graph.files[own] !== void 0) return `${graph.prefix}${qualify(own)}`;
+	if (!own.startsWith(".")) return void 0;
+	const segments = [...(importer?.startsWith(graph.prefix) === true ? unqualify(importer.slice(graph.prefix.length)) : "").split("/").slice(0, -1), ...own.split("/")];
+	const parts = [];
+	for (const segment of segments) {
+		if (segment === "." || segment === "") continue;
+		if (segment === "..") parts.pop();
+		else parts.push(segment);
+	}
+	const path = parts.join("/");
+	for (const candidate of [
+		path,
+		`${path}.ts`,
+		`${path}.tsx`,
+		`${path}.js`,
+		`${path}/index.ts`
+	]) if (graph.files[candidate] !== void 0) return `${graph.prefix}${qualify(candidate)}`;
+};
+/**
+* One Vite server, many renders. Each project gets its own id namespace so their
+* modules coexist in one graph — which also means they share one instance of
+* `@samva/markup`, exactly as a published consumer's install does. That shared
+* instance holds the stylesheet registry, which is why the compiler's generated
+* reset module runs first in every project's graph.
+*/
+const createEmailRenderer = async (options, ssrExternal = []) => {
+	const vite = await import("vite").catch(() => void 0);
+	if (vite === void 0) throw new Error("`vite` is required to render an email project locally.");
+	const graphs = /* @__PURE__ */ new Map();
+	let anonymous = 0;
+	let evaluating = Promise.resolve();
+	const evaluate = (operation) => {
+		const running = evaluating.then(operation, operation);
+		evaluating = running.catch(() => void 0);
+		return running;
+	};
+	const graphFor = (id) => id === void 0 ? void 0 : [...graphs.values()].find((graph) => id.startsWith(graph.prefix));
+	const server = await vite.createServer({
+		root: RESOLUTION_ROOT,
+		configFile: false,
+		logLevel: "silent",
+		server: {
+			middlewareMode: true,
+			hmr: false
+		},
+		optimizeDeps: {
+			noDiscovery: true,
+			include: []
+		},
+		oxc: { jsx: {
+			runtime: "automatic",
+			importSource: "@samva/markup/email"
+		} },
+		...ssrExternal.length === 0 ? {} : { ssr: { external: [...ssrExternal] } },
+		plugins: [{
+			name: "samva:email-project",
+			enforce: "pre",
+			resolveId: (id, importer) => {
+				const graph = graphFor(id) ?? graphFor(importer);
+				return graph === void 0 ? void 0 : resolveWithin(graph, id, importer);
+			},
+			load: (id) => {
+				const graph = graphFor(id);
+				return graph === void 0 ? void 0 : graph.files[unqualify(id.slice(graph.prefix.length))];
+			}
+		}]
+	});
+	const load = async (source, entryPoint, namespace) => {
+		const key = namespace ?? `#${anonymous += 1}`;
+		const graph = graphs.get(key) ?? {
+			files: {},
+			prefix: `${VIRTUAL}${graphs.size}/`
+		};
+		graphs.set(key, graph);
+		const compiled = await compileEmailProject(source, entryPoint, options);
+		graph.files = compiled.files;
+		const module = await evaluate(async () => {
+			const ssr = server.environments.ssr;
+			for (const node of ssr.moduleGraph.idToModuleMap.values()) if (node.id?.startsWith(graph.prefix) === true) ssr.moduleGraph.invalidateModule(node);
+			return await server.ssrLoadModule(`${graph.prefix}${qualify(compiled.entryPoint)}`);
+		});
+		return {
+			template: module.template,
+			renderEmail: module.renderEmail,
+			compiled
+		};
+	};
+	return {
+		load,
+		render: async (source, entryPoint, input, serialize) => {
+			const entry = await load(source, entryPoint);
+			if (entry.template === void 0) throw new TypeError(`${entryPoint} does not default-export a template definition.`);
+			return {
+				...entry.renderEmail(entry.template, input, serialize),
+				compiled: entry.compiled
+			};
+		},
+		invalidate: () => server.moduleGraph.invalidateAll(),
+		close: () => server.close()
+	};
+};
+/** Compile and render one project, then release the evaluator. */
+const renderEmailProject = async (source, entryPoint, options, input) => {
+	const renderer = await createEmailRenderer(options);
+	try {
+		return await renderer.render(source, entryPoint, input);
+	} finally {
+		await renderer.close();
+	}
+};
+//#endregion
+export { compileEmailProject, createEmailRenderer, renderEmailProject };
+
+//# sourceMappingURL=email.js.map

package/dist/emit.d.ts

@@ -1,19 +1,9 @@
-import { COMPILER_VERSION, CompileBase, CompileOptions } from "@samva/markup/compile";
+import { COMPILER_VERSION } from "@samva/markup/compile";
 import { Diagnostic } from "@samva/markup/diagnostics";
 import { TemplateVariable } from "@samva/markup/render-template";
 //#region src/emit.d.ts
-type PreviewChannel = "email" | "sms" | "whatsapp";
-/** Both email compile bases the preview surfaces and a build materializes. */
-declare const COMPILE_BASES: readonly ["outlook-safe", "modern"];
-/** One email base's compiled artifact, or its compile diagnostics if it failed. */
-interface EmailBaseArtifact {
-  readonly base: CompileBase;
-  readonly ok: boolean;
-  readonly html?: string | undefined;
-  readonly text?: string | undefined;
-  readonly warnings?: readonly Diagnostic[] | undefined;
-  readonly diagnostics?: readonly Diagnostic[] | undefined;
-}
+/** Structured channel preview emission, independent of the email execution runtime. */
+type PreviewChannel = "unknown" | "sms" | "whatsapp";
 type WhatsAppButtonPreview = {
   readonly type: "QUICK_REPLY";
   readonly text: string;
@@ -36,19 +26,13 @@ interface AuthoringValidationSummary {
   readonly repairableDiagnostics: number;
   readonly placeholders: readonly string[];
   readonly darkClassCount: number;
-  readonly emailBases?: readonly {
-    readonly base: CompileBase;
-    readonly ok: boolean;
-    readonly htmlBytes?: number | undefined;
-    readonly warnings: number;
-    readonly diagnostics: number;
-    readonly repairableDiagnostics: number;
-  }[] | undefined;
 }
 /** The compiled payload for one template, discriminated by channel. */
 type CompiledPreview = {
-  readonly channel: "email";
-  readonly bases: readonly EmailBaseArtifact[];
+  readonly channel: "unknown";
+  readonly ok: false;
+  readonly diagnostics: readonly Diagnostic[];
+  readonly warnings?: readonly Diagnostic[];
 } | {
   readonly channel: "sms";
   readonly ok: boolean;
@@ -103,14 +87,13 @@ interface ModulePreview {
  * changes the implementation shape of the default export. Direct callers of
  * `@samva/vite/emit` must pass that file-backed name as the first argument.
  */
-declare const emitModulePreview: (name: string, moduleExports: Record<string, unknown>, options?: CompileOptions) => ModulePreview;
+declare const emitModulePreview: (name: string, moduleExports: Record<string, unknown>) => ModulePreview;
 /**
- * Compiles a raw `.samva` source string directly (no TSX). Used for `.samva`
- * files the plugin discovers alongside `.tsx` templates and for `samva
- * templates pull` round-trips. Wraps the single source in the same preview
- * shape so the client renders `.samva` and `.tsx` templates identically.
+ * Compiles a raw SML source string directly (no TSX). Used by tests and any
+ * caller that already holds emitted SML. Wraps the single source in the same
+ * preview shape so the client renders compiled SML identically to TSX emission.
  */
-declare const compileSourcePreview: (name: string, source: string, options?: CompileOptions) => EmittedTemplatePreview;
+declare const compileSourcePreview: (name: string, source: string) => EmittedTemplatePreview;
 //#endregion
-export { AuthoringValidationSummary, COMPILER_VERSION, COMPILE_BASES, CompiledPreview, EmailBaseArtifact, EmittedTemplatePreview, ModulePreview, PreviewChannel, WhatsAppButtonPreview, compileSourcePreview, emitModulePreview };
+export { AuthoringValidationSummary, COMPILER_VERSION, CompiledPreview, EmittedTemplatePreview, ModulePreview, PreviewChannel, WhatsAppButtonPreview, compileSourcePreview, emitModulePreview };
 //# sourceMappingURL=emit.d.ts.map

package/dist/emit.js

@@ -2,37 +2,10 @@ import { Result } from "effect";
 import { COMPILER_VERSION, compileSource } from "@samva/markup/compile";
 import { emitModule } from "@samva/markup/emit";
 //#region src/emit.ts
-/** Both email compile bases the preview surfaces and a build materializes. */
-const COMPILE_BASES = ["outlook-safe", "modern"];
 const countRepairable = (diagnostics) => diagnostics.filter((diagnostic) => diagnostic.repair !== void 0).length;
 const uniquePlaceholders = (source) => source === void 0 ? [] : [...new Set([...source.matchAll(/{{\s*([A-Za-z_][\w.-]*)\s*}}/g)].map((match) => match[1] ?? ""))].filter(Boolean).sort();
 const darkClassCount = (source) => source === void 0 ? 0 : (source.match(/\bdark:/g) ?? []).length;
 const validationSummary = (source, emitDiagnostics, compiled) => {
-	if (compiled.channel === "email") {
-		const baseSummaries = compiled.bases.map((artifact) => {
-			const warnings = artifact.warnings ?? [];
-			const diagnostics = artifact.diagnostics ?? [];
-			return {
-				base: artifact.base,
-				ok: artifact.ok,
-				htmlBytes: artifact.html === void 0 ? void 0 : new TextEncoder().encode(artifact.html).length,
-				warnings: warnings.length,
-				diagnostics: diagnostics.length,
-				repairableDiagnostics: countRepairable(diagnostics)
-			};
-		});
-		const warnings = baseSummaries.reduce((sum, base) => sum + base.warnings, 0);
-		const diagnostics = emitDiagnostics.length + baseSummaries.reduce((sum, base) => sum + base.diagnostics, 0);
-		return {
-			ok: baseSummaries.length > 0 && baseSummaries.every((base) => base.ok) && emitDiagnostics.length === 0,
-			diagnostics,
-			warnings,
-			repairableDiagnostics: countRepairable(emitDiagnostics) + baseSummaries.reduce((sum, base) => sum + base.repairableDiagnostics, 0),
-			placeholders: uniquePlaceholders(source),
-			darkClassCount: darkClassCount(source),
-			emailBases: baseSummaries
-		};
-	}
 	const warnings = compiled.warnings ?? [];
 	const diagnostics = compiled.diagnostics ?? [];
 	return {
@@ -44,52 +17,16 @@ const validationSummary = (source, emitDiagnostics, compiled) => {
 		darkClassCount: darkClassCount(source)
 	};
 };
-const emailBaseArtifact = (source, base, options) => {
-	const result = compileSource(source, {
-		...options,
-		base
-	});
-	if (Result.isFailure(result)) return {
-		base,
-		ok: false,
-		diagnostics: result.failure.diagnostics
-	};
-	if (result.success.channel !== "email") return {
-		base,
-		ok: false,
-		diagnostics: [{
-			code: "channel-changed",
-			message: "template no longer compiles to email",
-			span: {
-				start: 0,
-				end: 0
-			}
-		}]
-	};
-	return {
-		base,
-		ok: true,
-		html: result.success.html,
-		text: result.success.text,
-		warnings: result.success.warnings
-	};
-};
 /** Compile one source into its channel-polymorphic preview. */
-const compiledPreview = (source, options) => {
-	const probe = compileSource(source, {
-		...options,
-		base: "outlook-safe"
-	});
+const compiledPreview = (source) => {
+	const probe = compileSource(source);
 	if (Result.isFailure(probe)) return {
-		channel: "email",
+		channel: "unknown",
 		compileOk: false,
 		compiled: {
-			channel: "email",
-			bases: [{
-				base: "outlook-safe",
-				ok: false,
-				diagnostics: probe.failure.diagnostics
-			}]
+			channel: "unknown",
+			ok: false,
+			diagnostics: probe.failure.diagnostics
 		}
 	};
 	const compiled = probe.success;
@@ -106,7 +43,7 @@ const compiledPreview = (source, options) => {
 			warnings: compiled.warnings
 		}
 	};
-	if (compiled.channel === "whatsapp") return {
+	return {
 		channel: "whatsapp",
 		compileOk: true,
 		compiled: {
@@ -120,40 +57,27 @@ const compiledPreview = (source, options) => {
 			warnings: compiled.warnings
 		}
 	};
-	const bases = [{
-		base: "outlook-safe",
-		ok: true,
-		html: compiled.html,
-		text: compiled.text,
-		warnings: compiled.warnings
-	}, emailBaseArtifact(source, "modern", options)];
-	return {
-		channel: "email",
-		compileOk: bases.every((artifact) => artifact.ok),
-		compiled: {
-			channel: "email",
-			bases
-		}
-	};
 };
-const previewTemplate = (emitted, options) => {
+const previewTemplate = (emitted) => {
 	if (emitted.source === void 0) return {
 		name: emitted.name,
 		ok: false,
-		channel: "email",
+		channel: "unknown",
 		source: void 0,
 		variables: emitted.variables,
 		diagnostics: emitted.diagnostics,
 		compiled: {
-			channel: "email",
-			bases: []
+			channel: "unknown",
+			ok: false,
+			diagnostics: []
 		},
 		validation: validationSummary(void 0, emitted.diagnostics, {
-			channel: "email",
-			bases: []
+			channel: "unknown",
+			ok: false,
+			diagnostics: []
 		})
 	};
-	const { channel, compileOk, compiled } = compiledPreview(emitted.source, options);
+	const { channel, compileOk, compiled } = compiledPreview(emitted.source);
 	return {
 		name: emitted.name,
 		ok: emitted.ok && compileOk,
@@ -175,35 +99,18 @@ const previewTemplate = (emitted, options) => {
 * changes the implementation shape of the default export. Direct callers of
 * `@samva/vite/emit` must pass that file-backed name as the first argument.
 */
-const emitModulePreview = (name, moduleExports, options) => {
-	if (!Object.hasOwn(moduleExports, "default")) return {
-		ok: false,
-		compilerVersion: COMPILER_VERSION,
-		templates: [],
-		diagnostics: [{
-			code: "missing-default-export",
-			message: "TSX template files must default-export exactly one template; named exports are ignored.",
-			span: {
-				start: 0,
-				end: 0
-			}
-		}]
-	};
-	const emitted = emitModule({ [name]: moduleExports.default });
+const emitModulePreview = (name, moduleExports) => {
+	const emitted = emitModule(moduleExports);
 	if (emitted.templates.length === 0) return {
 		ok: false,
 		compilerVersion: COMPILER_VERSION,
 		templates: [],
-		diagnostics: [{
-			code: "invalid-default-export",
-			message: "The default export is not a Samva template returning <Email>, <Sms>, or <WhatsApp>.",
-			span: {
-				start: 0,
-				end: 0
-			}
-		}]
+		diagnostics: emitted.diagnostics
 	};
-	const templates = emitted.templates.map((template) => previewTemplate(template, options));
+	const templates = emitted.templates.map((template) => previewTemplate({
+		...template,
+		name
+	}));
 	return {
 		ok: emitted.ok && templates.every((template) => template.ok),
 		compilerVersion: COMPILER_VERSION,
@@ -212,13 +119,12 @@ const emitModulePreview = (name, moduleExports, options) => {
 	};
 };
 /**
-* Compiles a raw `.samva` source string directly (no TSX). Used for `.samva`
-* files the plugin discovers alongside `.tsx` templates and for `samva
-* templates pull` round-trips. Wraps the single source in the same preview
-* shape so the client renders `.samva` and `.tsx` templates identically.
+* Compiles a raw SML source string directly (no TSX). Used by tests and any
+* caller that already holds emitted SML. Wraps the single source in the same
+* preview shape so the client renders compiled SML identically to TSX emission.
 */
-const compileSourcePreview = (name, source, options) => {
-	const { channel, compileOk, compiled } = compiledPreview(source, options);
+const compileSourcePreview = (name, source) => {
+	const { channel, compileOk, compiled } = compiledPreview(source);
 	return {
 		name,
 		ok: compileOk,
@@ -231,6 +137,6 @@ const compileSourcePreview = (name, source, options) => {
 	};
 };
 //#endregion
-export { COMPILER_VERSION, COMPILE_BASES, compileSourcePreview, emitModulePreview };
+export { COMPILER_VERSION, compileSourcePreview, emitModulePreview };
 
 //# sourceMappingURL=emit.js.map

package/dist/index.d.ts

@@ -1,13 +1,10 @@
 import { Plugin } from "vite";
-import { CompileOptions } from "@samva/markup/compile";
 //#region src/editor.d.ts
 interface SamvaEditorPluginOptions {
-  /** Directory containing `.samva` / `.tsx` templates, relative to project root. Default `emails`. */
+  /** Directory containing `.tsx` templates, relative to project root. Default `emails`. */
   readonly templatesDir?: string | undefined;
   /** Editor UI route. Default `/`; its API and assets are mounted as siblings below it. */
   readonly route?: string | undefined;
-  /** Compile options applied to catalog validation and browser previews. */
-  readonly compile?: CompileOptions | undefined;
   /** Project theme file relative to root. Default `theme.css`; false disables discovery. */
   readonly theme?: string | false | undefined;
 }