@samva/markup 0.1.2 → 0.2.0

package/dist/presets/public-handoff.js

@@ -1,26 +1,120 @@
-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;
+const isTemplateReferenceProvenanceSource = (value) => value === "samva-owned" || value === "sanitized-synthetic" || value === "reviewed-public";
+/** Bound authored source before parsing or mounting it. */
+const PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS = 512e3;
+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 +124,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 +159,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,
@@ -73,7 +173,7 @@ const jsonProjection = (kind, value) => ({
 const emitTemplateReferencePacket = (packet) => [
 	{
 		kind: "source",
-		relativePath: "preset.samva",
+		relativePath: "preset.tsx",
 		contents: packet.preset.source
 	},
 	jsonProjection("catalog", {
@@ -87,7 +187,7 @@ const emitTemplateReferencePacket = (packet) => [
 	jsonProjection("gallery", {
 		presetId: packet.preset.id,
 		...packet.gallery,
-		...packet.provenance === void 0 ? {} : { provenance: packet.provenance }
+		provenance: packet.provenance
 	}),
 	jsonProjection("preview", packet.preview),
 	jsonProjection("editorial", {
@@ -99,6 +199,8 @@ const emitTemplateReferencePacket = (packet) => [
 	})
 ];
 /**
+* 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,22 +217,17 @@ 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"));
+		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"));
@@ -139,7 +236,7 @@ const validatePublicTemplateHandoff = (artifacts) => {
 		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 (value === void 0 || !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 = [
@@ -186,6 +283,6 @@ const validatePublicTemplateHandoff = (artifacts) => {
 	}));
 };
 //#endregion
-export { emitTemplateReferencePacket, isSafePublicTemplateAsset, toTemplateReferencePacket, unsupportedPublicTemplateFontTokens, validatePublicTemplateHandoff };
+export { PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS, emitTemplateReferencePacket, isSafePublicTemplateAsset, publicTemplateAuthoredStructure, 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 { 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,29 +45,24 @@ 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 sampleData = fixture.input;
 	const assets = [];
 	for (const asset of preview.assets) {
 		const value = sampleData[asset.variable];
@@ -81,13 +75,13 @@ const buildPublicTemplatePreviewArtifact = (template) => {
 	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,
+		html: fixture.html,
 		assets,
-		renders: renderInputs(template.slug, rendered.rendered)
+		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,56 @@
-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";
+interface PublicTemplatePreview {
+  readonly subject: string;
+  readonly preheader: string;
+  readonly quality: PreviewQuality;
+  readonly sampleData: Readonly<Record<string, string>>;
+  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 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, PublicTemplatePreview, publicTemplatePreviews };
+//# sourceMappingURL=public-preview.d.ts.map