@samva/markup 0.1.1 → 0.2.0

package/dist/presets/public-handoff.js

@@ -1,12 +1,120 @@
-import { collectVariableReferences } from "../ast.js";
-import { parseSml } from "../parser.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 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;
@@ -16,6 +124,83 @@ const issue = (artifactId, code, message) => ({
 	message
 });
 /**
+* 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(/\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 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;
+};
+/** Normalizes one approved handoff for gallery and future agent consumers. */
+const toTemplateReferencePacket = (artifact) => ({
+	version: 1,
+	preset: artifact.preset,
+	gallery: {
+		...artifact.gallery,
+		path: `/templates/${artifact.gallery.slug}`
+	},
+	preview: artifact.preview,
+	publicMetadata: artifact.publicMetadata,
+	provenance: artifact.provenance
+});
+const jsonProjection = (kind, value) => ({
+	kind,
+	relativePath: `${kind}.json`,
+	contents: `${JSON.stringify(value, null, 2)}\n`
+});
+/**
+* Emits the five destination projections as deterministic bytes. The importer
+* owns no checked-in destination files; callers choose an explicit output dir.
+*/
+const emitTemplateReferencePacket = (packet) => [
+	{
+		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
@@ -32,19 +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 (!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 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"));
-		}
+		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 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"));
@@ -52,9 +235,8 @@ const validatePublicTemplateHandoff = (artifacts) => {
 		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];
-			const url = value === void 0 ? null : URL.parse(value);
 			if (!artifact.preset.variables.includes(asset.variable)) issues.push(issue(id, "assets", `asset "${asset.variable}" is not a declared preset variable`));
-			if (url === null || url.protocol !== "https:") issues.push(issue(id, "assets", `asset "${asset.variable}" must reference a valid HTTPS 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 = [
@@ -77,29 +259,30 @@ const validatePublicTemplateHandoff = (artifacts) => {
 		for (const relatedId of artifact.gallery.relatedTemplates) if (relatedId === id || !allKnownIds.has(relatedId)) issues.push(issue(id, "reference", `related template "${relatedId}" is invalid`));
 	}
 	if (issues.length > 0) return Result.fail(issues);
-	return Result.succeed(artifacts.map((artifact) => ({
-		approval: {
-			...artifact.approval,
-			state: "approved"
-		},
-		preset: {
-			id: artifact.preset.id,
-			channel: artifact.preset.channel,
-			category: artifact.preset.category,
-			name: artifact.preset.name,
-			description: artifact.preset.description,
-			variables: artifact.preset.variables
-		},
-		source: artifact.preset.source,
-		gallery: {
-			...artifact.gallery,
-			path: `/templates/${artifact.gallery.slug}`
-		},
-		preview: artifact.preview,
-		publicMetadata: artifact.publicMetadata
-	})));
+	return Result.succeed(artifacts.map((artifact) => {
+		const reference = toTemplateReferencePacket(artifact);
+		return {
+			approval: {
+				...artifact.approval,
+				state: "approved"
+			},
+			preset: {
+				id: artifact.preset.id,
+				channel: artifact.preset.channel,
+				category: artifact.preset.category,
+				name: artifact.preset.name,
+				description: artifact.preset.description,
+				variables: artifact.preset.variables
+			},
+			source: artifact.preset.source,
+			gallery: reference.gallery,
+			preview: artifact.preview,
+			publicMetadata: artifact.publicMetadata,
+			reference
+		};
+	}));
 };
 //#endregion
-export { validatePublicTemplateHandoff };
+export { PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS, emitTemplateReferencePacket, isSafePublicTemplateAsset, publicTemplateAuthoredStructure, toTemplateReferencePacket, unsupportedPublicTemplateFontTokens, validatePublicTemplateHandoff };
 
 //# sourceMappingURL=public-handoff.js.map

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. */