@samva/markup 0.1.2 → 0.3.0

package/dist/presets/public-handoff.js

@@ -1,26 +1,173 @@
-import { collectVariableReferences } from "../ast.js";
-import { parseSml } from "../parser.js";
-import { resolveTokenTable } from "../theme.js";
-import { baseTokens } from "../tokens.js";
-import { compileSource } from "../compile.js";
-import { RECOMMENDED_THEME, presetCatalog } from "../presets.js";
+import { EMAIL_ELEMENTS } from "../email/elements.js";
+import { presetCatalog } from "../presets.js";
 import { publicTemplates, templateCollections } from "./public-gallery.js";
-import { Result } from "effect";
+import { Predicate, Result } from "effect";
+import { parse } from "@babel/parser";
 //#region presets/public-handoff.ts
 const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 const MAX_HTTPS_ASSET_LENGTH = 2048;
 const MAX_DATA_IMAGE_ASSET_LENGTH = 32768;
 const DATA_IMAGE = /^data:image\/(?:avif|gif|jpeg|png|svg\+xml|webp)(?:;charset=[a-z0-9-]+)?(?:;base64)?,[^\r\n]+$/i;
-const isTemplateReferenceProvenanceSource = (value) => value === "sanitized-synthetic" || value === "reviewed-public";
-const PUBLIC_TEMPLATE_FONT_TOKENS = new Set(Object.keys(resolveTokenTable({
-	base: baseTokens,
-	overrides: [RECOMMENDED_THEME]
-}).fontFamilies));
-const FONT_WEIGHT_TOKENS = new Set(Object.keys(resolveTokenTable({
-	base: baseTokens,
-	overrides: [RECOMMENDED_THEME]
-}).fontWeights));
+const PUBLIC_TEMPLATE_ASSET_PATH = /^\/templates\/assets\/[A-Za-z0-9][A-Za-z0-9._-]*\.(?:jpe?g|png|webp)$/;
+const BLOCKED_PUBLIC_ASSET = /(?:unsplash|placehold|assets\.example)/i;
+/** A sample value is non-empty when every string in it is, and no list or object is empty. */
+const nonEmptySample = (value) => {
+	if (typeof value === "string") return nonEmpty(value);
+	if (Array.isArray(value)) return value.length > 0 && value.every(nonEmptySample);
+	if (Predicate.isObject(value)) {
+		const values = Object.values(value);
+		return values.length > 0 && values.every(nonEmptySample);
+	}
+	return true;
+};
+const isTemplateReferenceProvenanceSource = (value) => value === "samva-owned" || value === "sanitized-synthetic" || value === "reviewed-public" || value === "brand-recreation";
+/** Bound authored source before parsing or mounting it. */
+const PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS = 512e3;
+/** Bounds apply to decoded bytes, before evaluation or disk emission. */
+const PUBLIC_TEMPLATE_PROJECT_MAX_BYTES = 8388608;
+const PUBLIC_TEMPLATE_PROJECT_FILE_MAX_BYTES = 2097152;
+const PUBLIC_TEMPLATE_PROJECT_MAX_FILES = 64;
+const isSafePublicTemplateProjectPath = (path) => path.length <= 240 && path.split("/").every((part) => /^[A-Za-z0-9_][A-Za-z0-9._-]*$/.test(part) && part !== "." && part !== ".." && part !== "node_modules");
+/** Reject traversal, collisions, malformed base64 and oversized authored projects. */
+const isSafePublicTemplateProject = (project) => {
+	if (!isSafePublicTemplateProjectPath(project.entryPath) || !project.entryPath.endsWith(".tsx") || !/^[a-f0-9]{64}$/.test(project.digest) || project.files.length === 0 || project.files.length > 64) return false;
+	const paths = /* @__PURE__ */ new Set();
+	let total = 0;
+	for (const file of project.files) {
+		if (!isSafePublicTemplateProjectPath(file.path) || paths.has(file.path.toLowerCase())) return false;
+		paths.add(file.path.toLowerCase());
+		let bytes;
+		if (file.encoding === "utf8") {
+			if (file.content.length > 512e3) return false;
+			bytes = new TextEncoder().encode(file.content).length;
+		} else if (file.encoding === "base64") {
+			if (file.content.length > Math.ceil(2097152 / 3) * 4 || file.content.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(file.content)) return false;
+			if (btoa(atob(file.content)) !== file.content) return false;
+			bytes = file.content.length / 4 * 3 - (file.content.endsWith("==") ? 2 : file.content.endsWith("=") ? 1 : 0);
+		} else return false;
+		if (bytes > 2097152) return false;
+		total += bytes;
+		if (total > 8388608) return false;
+	}
+	for (const path of paths) if (path.split("/").slice(0, -1).some((_, index, parts) => paths.has(parts.slice(0, index + 1).join("/")))) return false;
+	return project.files.some((file) => file.path === project.entryPath && file.encoding === "utf8");
+};
+/** Digest the complete authored graph independently of caller file ordering. */
+const publicTemplateProjectDigest = async (project) => {
+	const serialized = JSON.stringify({
+		entryPath: project.entryPath,
+		files: [...project.files].sort((a, b) => a.path.localeCompare(b.path)).map(({ path, content, encoding }) => ({
+			path,
+			content,
+			encoding
+		}))
+	});
+	const bytes = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(serialized)));
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const isValidTemplateBrandRecreation = (brandRecreation, project) => brandRecreation !== void 0 && project !== void 0 && brandRecreation.brand.trim().length > 0 && brandRecreation.subject.trim().length > 0;
+const PUBLIC_TEMPLATE_FONT_TOKENS = /* @__PURE__ */ new Set([
+	"sans",
+	"serif",
+	"mono"
+]);
+const FONT_WEIGHT_TOKENS = /* @__PURE__ */ new Set([
+	"thin",
+	"extralight",
+	"light",
+	"normal",
+	"medium",
+	"semibold",
+	"bold",
+	"extrabold",
+	"black"
+]);
+const parsePublicTemplateSource = (source) => {
+	if (source.length === 0 || source.length > 512e3) return void 0;
+	try {
+		const parsed = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		return parsed.program.body.some((node) => node.type === "ExportDefaultDeclaration") ? parsed : void 0;
+	} catch {
+		return;
+	}
+};
+const PUBLIC_COMPONENT_TAGS = /* @__PURE__ */ new Set([
+	...Object.keys(EMAIL_ELEMENTS),
+	"Email",
+	"Section",
+	"Columns",
+	"Column",
+	"Button",
+	"Spacer",
+	"Divider",
+	"Image",
+	"Link"
+]);
+/** Only generic element names and literal class colors survive deidentification. */
+const publicTemplateAuthoredStructure = (source) => {
+	const parsed = parsePublicTemplateSource(source);
+	if (parsed === void 0) return void 0;
+	const nodes = [];
+	const counts = /* @__PURE__ */ new Map();
+	const palette = /* @__PURE__ */ new Set();
+	const siblings = /* @__PURE__ */ new Map();
+	const walk = (value, depth) => {
+		if (Array.isArray(value)) {
+			for (const item of value) walk(item, depth);
+			return;
+		}
+		if (!Predicate.isObject(value)) return;
+		let childDepth = depth;
+		if (value.type === "JSXElement") {
+			const opening = value.openingElement;
+			if (!Predicate.isObject(opening)) return;
+			const name = opening.name;
+			const tag = Predicate.isObject(name) && typeof name.name === "string" && PUBLIC_COMPONENT_TAGS.has(name.name) ? name.name : "Component";
+			const childIndex = siblings.get(depth) ?? 0;
+			siblings.set(depth, childIndex + 1);
+			siblings.set(depth + 1, 0);
+			if (nodes.length < 200) nodes.push({
+				tag,
+				depth,
+				childIndex
+			});
+			counts.set(tag, (counts.get(tag) ?? 0) + 1);
+			if (Array.isArray(opening.attributes)) for (const attribute of opening.attributes) {
+				if (!Predicate.isObject(attribute) || !Predicate.isObject(attribute.name) || attribute.name.name !== "className") continue;
+				const literal = attribute.value;
+				if (!Predicate.isObject(literal) || literal.type !== "StringLiteral" || typeof literal.value !== "string") continue;
+				for (const match of literal.value.matchAll(/#([a-f0-9]{8}|[a-f0-9]{6}|[a-f0-9]{3})(?=[^a-f0-9]|$)/gi)) if (palette.size < 24) palette.add(`#${match[1].toLowerCase()}`);
+			}
+			childDepth += 1;
+		}
+		for (const [key, child] of Object.entries(value)) {
+			if ([
+				"loc",
+				"comments",
+				"leadingComments",
+				"trailingComments",
+				"innerComments",
+				"extra",
+				"tokens"
+			].includes(key)) continue;
+			walk(child, childDepth);
+		}
+	};
+	walk(parsed.program, 0);
+	return {
+		basis: "authored-jsx",
+		nodes,
+		components: [...counts].sort(([a], [b]) => a.localeCompare(b)).slice(0, 64).map(([tag, count]) => ({
+			tag,
+			count
+		})),
+		palette: [...palette].sort()
+	};
+};
 const sortedUnique = (values) => [...new Set(values)].sort();
 const sameStrings = (left, right) => JSON.stringify(sortedUnique(left)) === JSON.stringify(sortedUnique(right));
 const nonEmpty = (value) => value.trim().length > 0;
@@ -30,22 +177,28 @@ const issue = (artifactId, code, message) => ({
 	message
 });
 /**
-* Public imports may only refer to existing font-family tokens. A source may
+* Public imports may only refer to the default email Tailwind font-family tokens. A source may
 * still use the supported `font-*` weight utilities; this check deliberately
 * rejects a new family token instead of creating a corpus font-hosting path.
 */
 const unsupportedPublicTemplateFontTokens = (source) => {
 	const unsupported = /* @__PURE__ */ new Set();
-	for (const match of source.matchAll(/\bclass\s*=\s*(["'])(.*?)\1/gs)) for (const className of (match[2] ?? "").split(/\s+/)) {
+	for (const match of source.matchAll(/\bclassName\s*=\s*(["'])(.*?)\1/gs)) for (const className of (match[2] ?? "").split(/\s+/)) {
 		if (!className.startsWith("font-")) continue;
 		const token = className.slice(5);
 		if (!PUBLIC_TEMPLATE_FONT_TOKENS.has(token) && !FONT_WEIGHT_TOKENS.has(token)) unsupported.add(token);
 	}
 	return [...unsupported].sort();
 };
-/** Accept only bounded HTTPS URLs or the preview's self-contained image data. */
+/**
+* Accept bounded HTTPS URLs, same-origin gallery files under `/templates/assets/`,
+* or the preview's self-contained image data. Live Unsplash, placehold, and
+* assets.example hosts are never safe for public sample data.
+*/
 const isSafePublicTemplateAsset = (value) => {
+	if (value.includes("..") || BLOCKED_PUBLIC_ASSET.test(value)) return false;
 	if (value.startsWith("data:")) return value.length <= MAX_DATA_IMAGE_ASSET_LENGTH && DATA_IMAGE.test(value);
+	if (PUBLIC_TEMPLATE_ASSET_PATH.test(value)) return value.length <= MAX_HTTPS_ASSET_LENGTH;
 	const url = URL.parse(value);
 	return value.length <= MAX_HTTPS_ASSET_LENGTH && url?.protocol === "https:" && url.hostname.length > 0 && url.username.length === 0 && url.password.length === 0;
 };
@@ -59,7 +212,7 @@ const toTemplateReferencePacket = (artifact) => ({
 	},
 	preview: artifact.preview,
 	publicMetadata: artifact.publicMetadata,
-	...artifact.provenance === void 0 ? {} : { provenance: artifact.provenance }
+	provenance: artifact.provenance
 });
 const jsonProjection = (kind, value) => ({
 	kind,
@@ -67,38 +220,54 @@ const jsonProjection = (kind, value) => ({
 	contents: `${JSON.stringify(value, null, 2)}\n`
 });
 /**
-* Emits the five destination projections as deterministic bytes. The importer
+* Emits legacy projections plus the complete project as deterministic bytes. The importer
 * owns no checked-in destination files; callers choose an explicit output dir.
 */
-const emitTemplateReferencePacket = (packet) => [
-	{
-		kind: "source",
-		relativePath: "preset.samva",
-		contents: packet.preset.source
-	},
-	jsonProjection("catalog", {
-		id: packet.preset.id,
-		channel: packet.preset.channel,
-		category: packet.preset.category,
-		name: packet.preset.name,
-		description: packet.preset.description,
-		variables: packet.preset.variables
-	}),
-	jsonProjection("gallery", {
-		presetId: packet.preset.id,
-		...packet.gallery,
-		...packet.provenance === void 0 ? {} : { provenance: packet.provenance }
-	}),
-	jsonProjection("preview", packet.preview),
-	jsonProjection("editorial", {
-		cardTitle: packet.publicMetadata.cardTitle,
-		cardDescription: packet.publicMetadata.cardDescription,
-		guidance: packet.publicMetadata.guidance,
-		variables: packet.publicMetadata.variableDescriptions,
-		seo: packet.publicMetadata.seo
-	})
-];
+const emitTemplateReferencePacket = (packet) => {
+	const project = packet.preset.project;
+	if (project !== void 0 && (!isSafePublicTemplateProject(project) || project.files.find((file) => file.path === project.entryPath)?.content !== packet.preset.source)) throw new Error("Invalid public template project");
+	if (packet.provenance.source === "brand-recreation" && !isValidTemplateBrandRecreation(packet.provenance.brandRecreation, project)) throw new Error("Invalid public template brand recreation attribution");
+	return [
+		...project === void 0 ? [] : [jsonProjection("project", {
+			...project,
+			files: [...project.files].sort((a, b) => a.path.localeCompare(b.path))
+		}), ...[...project.files].sort((a, b) => a.path.localeCompare(b.path)).map((file) => ({
+			kind: "project-file",
+			relativePath: `project/${file.path}`,
+			contents: file.content,
+			encoding: file.encoding
+		}))],
+		{
+			kind: "source",
+			relativePath: "preset.tsx",
+			contents: packet.preset.source
+		},
+		jsonProjection("catalog", {
+			id: packet.preset.id,
+			channel: packet.preset.channel,
+			category: packet.preset.category,
+			name: packet.preset.name,
+			description: packet.preset.description,
+			variables: packet.preset.variables
+		}),
+		jsonProjection("gallery", {
+			presetId: packet.preset.id,
+			...packet.gallery,
+			provenance: packet.provenance
+		}),
+		jsonProjection("preview", packet.preview),
+		jsonProjection("editorial", {
+			cardTitle: packet.publicMetadata.cardTitle,
+			cardDescription: packet.publicMetadata.cardDescription,
+			guidance: packet.publicMetadata.guidance,
+			variables: packet.publicMetadata.variableDescriptions,
+			seo: packet.publicMetadata.seo
+		})
+	];
+};
 /**
+* Validates metadata and TSX syntax, never executing the template. The Vite importer
+* verifies schema, fixtures and rendered content before writing projections.
 * Validates explicitly supplied, owner-approved artifacts without filesystem,
 * network, persistence, or discovery. Successful output is a projection for
 * the existing preset, public-gallery, preview, and editorial contracts; this
@@ -115,31 +284,29 @@ const validatePublicTemplateHandoff = (artifacts) => {
 	for (const artifact of artifacts) {
 		const id = artifact.preset.id;
 		if (artifact.approval.state !== "approved" || !nonEmpty(artifact.approval.approvedBy) || !ISO_TIMESTAMP.test(artifact.approval.approvedAt)) issues.push(issue(id, "approval", "owner approval and an ISO-8601 approval timestamp are required"));
-		if (artifact.provenance !== void 0 && (!isTemplateReferenceProvenanceSource(artifact.provenance.source) || !nonEmpty(artifact.provenance.referenceId) || !ISO_TIMESTAMP.test(artifact.provenance.recordedAt))) issues.push(issue(id, "provenance", "provenance requires a supported source, identifier, and ISO-8601 timestamp"));
+		if (artifact.provenance === void 0 || !isTemplateReferenceProvenanceSource(artifact.provenance.source) || !nonEmpty(artifact.provenance.referenceId) || !ISO_TIMESTAMP.test(artifact.provenance.recordedAt)) issues.push(issue(id, "provenance", "provenance requires a supported source, identifier, and ISO-8601 timestamp"));
 		if (!SLUG.test(id) || !SLUG.test(artifact.gallery.slug)) issues.push(issue(id, "identity", "preset id and canonical slug must be lowercase kebab-case"));
 		if (existingIds.has(id) || suppliedIds.has(id)) issues.push(issue(id, "duplicate-id", `preset id "${id}" is already present`));
 		if (existingSlugs.has(artifact.gallery.slug) || suppliedSlugs.has(artifact.gallery.slug)) issues.push(issue(id, "duplicate-slug", `canonical slug "${artifact.gallery.slug}" is already present`));
 		suppliedIds.add(id);
 		suppliedSlugs.add(artifact.gallery.slug);
-		const compiled = compileSource(artifact.preset.source, { theme: { overrides: [RECOMMENDED_THEME] } });
-		if (Result.isFailure(compiled)) issues.push(issue(id, "source", compiled.failure.message));
-		else if (artifact.preset.channel !== "email" || compiled.success.channel !== "email") issues.push(issue(id, "channel", "public template source must compile as email"));
+		const project = artifact.preset.project;
+		if (project !== void 0 && (!isSafePublicTemplateProject(project) || project.files.find((file) => file.path === project.entryPath)?.content !== artifact.preset.source)) issues.push(issue(id, "source", "project must contain safe bounded unique files and the matching UTF-8 entry source"));
+		if (artifact.provenance?.source === "brand-recreation" && !isValidTemplateBrandRecreation(artifact.provenance.brandRecreation, project)) issues.push(issue(id, "provenance", "brand recreations require a complete project, a referenced brand, and its email subject"));
+		if (parsePublicTemplateSource(artifact.preset.source) === void 0) issues.push(issue(id, "source", "source must be a bounded TSX module with a default export; execution is verified by the importer"));
+		if (artifact.preset.channel !== "email") issues.push(issue(id, "channel", "public template source must be an executable email"));
+		if (new Set(artifact.preset.variables).size !== artifact.preset.variables.length || artifact.preset.variables.some((value) => !nonEmpty(value))) issues.push(issue(id, "variables", "declared input fields must be non-empty and unique"));
 		const unsupportedFontTokens = unsupportedPublicTemplateFontTokens(artifact.preset.source);
 		if (unsupportedFontTokens.length > 0) issues.push(issue(id, "font-token", `unsupported public font token: ${unsupportedFontTokens.join(", ")}`));
-		const parsed = parseSml(artifact.preset.source);
-		if (Result.isSuccess(parsed)) {
-			const sourceVariables = [...collectVariableReferences(parsed.success)];
-			if (!sameStrings(artifact.preset.variables, sourceVariables)) issues.push(issue(id, "variables", "declared variables must exactly match source references"));
-		}
 		const sampleVariables = Object.keys(artifact.preview.sampleData);
 		if (!sameStrings(sampleVariables, artifact.preset.variables)) issues.push(issue(id, "sample-data", "sample data must cover every declared variable exactly"));
-		if (Object.values(artifact.preview.sampleData).some((value) => !nonEmpty(value))) issues.push(issue(id, "sample-data", "sample data values must be non-empty"));
+		if (Object.values(artifact.preview.sampleData).some((value) => !nonEmptySample(value))) issues.push(issue(id, "sample-data", "sample data values must be non-empty"));
 		const assetVariables = artifact.preview.assets.map((asset) => asset.variable);
 		if (new Set(assetVariables).size !== assetVariables.length) issues.push(issue(id, "assets", "asset variable references must be unique"));
 		for (const asset of artifact.preview.assets) {
 			const value = artifact.preview.sampleData[asset.variable];
 			if (!artifact.preset.variables.includes(asset.variable)) issues.push(issue(id, "assets", `asset "${asset.variable}" is not a declared preset variable`));
-			if (value === void 0 || !isSafePublicTemplateAsset(value)) issues.push(issue(id, "assets", `asset "${asset.variable}" must reference a bounded HTTPS or data:image sample URL`));
+			if (typeof value !== "string" || !isSafePublicTemplateAsset(value)) issues.push(issue(id, "assets", `asset "${asset.variable}" must reference a bounded HTTPS, /templates/assets, or data:image sample URL`));
 		}
 		const metadata = artifact.publicMetadata;
 		const metadataStrings = [
@@ -178,6 +345,7 @@ const validatePublicTemplateHandoff = (artifacts) => {
 				variables: artifact.preset.variables
 			},
 			source: artifact.preset.source,
+			...artifact.preset.project === void 0 ? {} : { project: artifact.preset.project },
 			gallery: reference.gallery,
 			preview: artifact.preview,
 			publicMetadata: artifact.publicMetadata,
@@ -186,6 +354,6 @@ const validatePublicTemplateHandoff = (artifacts) => {
 	}));
 };
 //#endregion
-export { emitTemplateReferencePacket, isSafePublicTemplateAsset, toTemplateReferencePacket, unsupportedPublicTemplateFontTokens, validatePublicTemplateHandoff };
+export { PUBLIC_TEMPLATE_PROJECT_FILE_MAX_BYTES, PUBLIC_TEMPLATE_PROJECT_MAX_BYTES, PUBLIC_TEMPLATE_PROJECT_MAX_FILES, PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS, emitTemplateReferencePacket, isSafePublicTemplateAsset, isSafePublicTemplateProject, isSafePublicTemplateProjectPath, isValidTemplateBrandRecreation, publicTemplateAuthoredStructure, publicTemplateProjectDigest, toTemplateReferencePacket, unsupportedPublicTemplateFontTokens, validatePublicTemplateHandoff };
 
 //# sourceMappingURL=public-handoff.js.map

package/dist/presets/public-preview-artifacts.d.ts

@@ -1,6 +1,6 @@
 import { EmailPresetId } from "../presets.js";
-import { n as PreviewQuality } from "../public-preview-u1Z9aaGq.js";
-import { t as PublicTemplate } from "../public-gallery-D0Zv0pZE.js";
+import { PublicTemplate } from "./public-gallery.js";
+import { PreviewQuality } from "./public-preview.js";
 import { Result } from "effect";
 //#region presets/public-preview-artifacts.d.ts
 type PreviewSurface = "card" | "detail" | "og";

package/dist/presets/public-preview-artifacts.js

@@ -1,9 +1,8 @@
-import { interpolate } from "../interpolate.js";
-import { compileSource } from "../compile.js";
-import { RECOMMENDED_THEME, presetCatalog } from "../presets.js";
+import { presetCatalog } from "../presets.js";
+import { registerPublicCorpusEntry } from "./corpus.js";
 import { publicTemplates } from "./public-gallery.js";
+import { presetEmailAssets, presetEmailFixtures, presetModuleSource } from "./sources.js";
 import { publicTemplatePreviews } from "./public-preview.js";
-import { presetSource } from "./sources.js";
 import { Result } from "effect";
 //#region presets/public-preview-artifacts.ts
 const renderFrames = [
@@ -46,48 +45,43 @@ const renderInputs = (slug, html) => renderFrames.flatMap((frame) => ["light", "
 })));
 /** Build one static preview artifact without loading the editor runtime or performing I/O. */
 const buildPublicTemplatePreviewArtifact = (template) => {
-	const source = presetSource(template.presetId);
-	const preset = presetCatalog.find((entry) => entry.id === template.presetId);
-	const preview = publicTemplatePreviews[template.presetId];
-	if (source === void 0 || preset === void 0) return Result.fail({
-		presetId: template.presetId,
-		message: "canonical preset source is missing"
+	const registration = registerPublicCorpusEntry({
+		id: template.presetId,
+		corpus: template.corpus,
+		facets: template.facets
 	});
-	const compiled = compileSource(source, { theme: { overrides: [RECOMMENDED_THEME] } });
-	if (Result.isFailure(compiled) || compiled.success.channel !== "email") return Result.fail({
+	if (Result.isFailure(registration)) return Result.fail({
 		presetId: template.presetId,
-		message: "canonical preset did not compile as email"
+		message: `public corpus registration failed: ${registration.failure.message}`
 	});
-	const variableSchema = preset.variables.map((name) => ({
-		name,
-		type: "string",
-		required: true
-	}));
-	const rendered = interpolate(compiled.success.html, preview.sampleData, variableSchema);
-	if (rendered.missing.size > 0) return Result.fail({
+	const source = presetModuleSource(template.presetId);
+	const fixture = presetEmailFixtures[template.presetId]?.default;
+	const preset = presetCatalog.find((entry) => entry.id === template.presetId);
+	const preview = publicTemplatePreviews[template.presetId];
+	if (source === void 0 || preset === void 0 || fixture === void 0) return Result.fail({
 		presetId: template.presetId,
-		message: `sample data is missing: ${[...rendered.missing].sort().join(", ")}`
+		message: "canonical preset source is missing"
 	});
-	const sampleData = preview.sampleData;
-	const assets = [];
+	const sampleData = fixture.input;
+	const assets = new Set(presetEmailAssets[template.presetId]);
 	for (const asset of preview.assets) {
 		const value = sampleData[asset.variable];
-		if (value === void 0) return Result.fail({
+		if (typeof value !== "string") return Result.fail({
 			presetId: template.presetId,
-			message: `sample data is missing asset: ${asset.variable}`
+			message: `sample data is missing a string asset: ${asset.variable}`
 		});
-		assets.push(value);
+		assets.add(value);
 	}
 	return Result.succeed({
 		presetId: template.presetId,
 		slug: template.slug,
-		subject: preview.subject,
-		preheader: preview.preheader,
+		subject: fixture.subject,
+		preheader: fixture.preheader,
 		quality: preview.quality,
 		source,
-		html: rendered.rendered,
-		assets,
-		renders: renderInputs(template.slug, rendered.rendered)
+		html: fixture.html,
+		assets: [...assets],
+		renders: renderInputs(template.slug, fixture.html)
 	});
 };
 /** Build only the requested canonical subset, preserving manifest order and aggregated failures. */

package/dist/presets/public-preview.d.ts

@@ -1,2 +1,65 @@
-import { i as publicTemplatePreviews, n as PreviewQuality, r as PublicTemplatePreview, t as PUBLIC_PREVIEW_LOGO_DATA_URI } from "../public-preview-u1Z9aaGq.js";
-export { PUBLIC_PREVIEW_LOGO_DATA_URI, PreviewQuality, PublicTemplatePreview, publicTemplatePreviews };
+//#region presets/public-preview.d.ts
+type PreviewQuality = "ready" | "asset-free";
+/** A declared fixture value: JSON, so a template can take a list of stories as well as a string. */
+type PreviewSampleValue = string | number | boolean | null | ReadonlyArray<PreviewSampleValue> | {
+  readonly [key: string]: PreviewSampleValue;
+};
+interface PublicTemplatePreview {
+  readonly subject: string;
+  readonly preheader: string;
+  readonly quality: PreviewQuality;
+  readonly sampleData: Readonly<Record<string, PreviewSampleValue>>;
+  readonly assets: ReadonlyArray<{
+    readonly variable: string;
+    readonly kind: "image" | "logo";
+  }>;
+}
+/** Gallery metadata augments the actual default fixture; it does not supply render input. */
+declare const publicTemplatePreviews: {
+  readonly "linear-login-code": PublicTemplatePreview;
+  readonly "product-newsletter": PublicTemplatePreview;
+  readonly "order-receipt": PublicTemplatePreview;
+  readonly "vercel-invitation": PublicTemplatePreview;
+  readonly "product-launch-promo": PublicTemplatePreview;
+  readonly welcome: PublicTemplatePreview;
+  readonly "email-verification": PublicTemplatePreview;
+  readonly otp: PublicTemplatePreview;
+  readonly "password-reset": PublicTemplatePreview;
+  readonly receipt: PublicTemplatePreview;
+  readonly "payment-failed": PublicTemplatePreview;
+  readonly "shipping-update": PublicTemplatePreview;
+  readonly notification: PublicTemplatePreview;
+  readonly "team-invite": PublicTemplatePreview;
+  readonly "product-digest": PublicTemplatePreview;
+  readonly newsletter: PublicTemplatePreview;
+  readonly announcement: PublicTemplatePreview;
+  readonly promo: PublicTemplatePreview;
+  readonly "event-invite": PublicTemplatePreview;
+  readonly "membership-promo": PublicTemplatePreview;
+  readonly "onboarding-step": PublicTemplatePreview;
+  readonly "trial-ending": PublicTemplatePreview;
+  readonly "win-back": PublicTemplatePreview;
+  readonly "feedback-request": PublicTemplatePreview;
+  readonly "editorial-newsletter": PublicTemplatePreview;
+  readonly "member-referral-offer": PublicTemplatePreview;
+  readonly "catalog-sale-newsletter": PublicTemplatePreview;
+  readonly "limited-time-savings": PublicTemplatePreview;
+  readonly "rewards-milestone": PublicTemplatePreview;
+  readonly "order-delivered": PublicTemplatePreview;
+  readonly "travel-rewards-promo": PublicTemplatePreview;
+  readonly "events-roundup": PublicTemplatePreview;
+  readonly "product-onboarding-tour": PublicTemplatePreview;
+  readonly "product-updates-roundup": PublicTemplatePreview;
+  readonly "flash-getaway-offer": PublicTemplatePreview;
+  readonly "membership-benefits-promo": PublicTemplatePreview;
+  readonly "industry-news-digest": PublicTemplatePreview;
+  readonly "weekly-deals-circular": PublicTemplatePreview;
+  readonly "data-sharing-review": PublicTemplatePreview;
+  readonly "seasonal-sale-flyer": PublicTemplatePreview;
+  readonly "setup-checklist": PublicTemplatePreview;
+  readonly "feature-release-roundup": PublicTemplatePreview;
+  readonly "season-clearance-promo": PublicTemplatePreview;
+};
+//#endregion
+export { PreviewQuality, PreviewSampleValue, PublicTemplatePreview, publicTemplatePreviews };
+//# sourceMappingURL=public-preview.d.ts.map