@samva/markup 0.2.0 → 0.4.0

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

@@ -1,12 +1,19 @@
 import { d as Channel } from "../ast-63I-VLQx.js";
-import { PresetCategory } from "../presets.js";
+import { r as PresetCategory } from "../catalog-Ck1tAGwO.js";
 import { TemplateCollectionId, TemplateUseCase } from "./public-gallery.js";
 import { PublicTemplatePreview } from "./public-preview.js";
+import { PresetProject } from "./sources.js";
 import { Result } from "effect";
 //#region presets/public-handoff.d.ts
+/** The brand a clean-room recreation names, and what its email does. */
+interface TemplateBrandRecreation {
+  readonly brand: string;
+  readonly subject: string;
+}
 /** Where an approved public artifact came from. */
 interface TemplateReferenceProvenance {
-  readonly source: "samva-owned" | "sanitized-synthetic" | "reviewed-public";
+  readonly source: "samva-owned" | "sanitized-synthetic" | "reviewed-public" | "brand-recreation";
+  readonly brandRecreation?: TemplateBrandRecreation;
   /** Stable identifier in the producing system; never a third-party URL. */
   readonly referenceId: string;
   /** Stable ISO-8601 timestamp supplied by the producer. */
@@ -27,6 +34,7 @@ interface ApprovedPublicTemplateArtifact {
     readonly description: string;
     readonly variables: ReadonlyArray<string>;
     readonly source: string;
+    readonly project?: PresetProject;
   };
   readonly gallery: {
     readonly slug: string;
@@ -62,8 +70,9 @@ interface TemplateReferencePacket {
   readonly provenance: TemplateReferenceProvenance;
 }
 interface ValidatedPublicTemplateArtifact {
-  readonly preset: Omit<ApprovedPublicTemplateArtifact["preset"], "source">;
+  readonly preset: Omit<ApprovedPublicTemplateArtifact["preset"], "source" | "project">;
   readonly source: string;
+  readonly project?: PresetProject;
   readonly gallery: ApprovedPublicTemplateArtifact["gallery"] & {
     readonly path: `/templates/${string}`;
   };
@@ -82,6 +91,16 @@ interface PublicHandoffIssue {
 }
 /** Bound authored source before parsing or mounting it. */
 declare const PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS = 512000;
+/** Bounds apply to decoded bytes, before evaluation or disk emission. */
+declare const PUBLIC_TEMPLATE_PROJECT_MAX_BYTES: number;
+declare const PUBLIC_TEMPLATE_PROJECT_FILE_MAX_BYTES: number;
+declare const PUBLIC_TEMPLATE_PROJECT_MAX_FILES = 64;
+declare const isSafePublicTemplateProjectPath: (path: string) => boolean;
+/** Reject traversal, collisions, malformed base64 and oversized authored projects. */
+declare const isSafePublicTemplateProject: (project: PresetProject) => boolean;
+/** Digest the complete authored graph independently of caller file ordering. */
+declare const publicTemplateProjectDigest: (project: Pick<PresetProject, "entryPath" | "files">) => Promise<string>;
+declare const isValidTemplateBrandRecreation: (brandRecreation: TemplateBrandRecreation | undefined, project: PresetProject | undefined) => boolean;
 /** Static syntax inventory; loops, branches and component expansion are not evaluated. */
 interface PublicTemplateAuthoredStructure {
   readonly basis: "authored-jsx";
@@ -117,12 +136,17 @@ type TemplateReferenceProjection = {
   readonly relativePath: "preset.tsx";
   readonly contents: string;
 } | {
-  readonly kind: "catalog" | "gallery" | "preview" | "editorial";
-  readonly relativePath: `${"catalog" | "gallery" | "preview" | "editorial"}.json`;
+  readonly kind: "project-file";
+  readonly relativePath: `project/${string}`;
+  readonly contents: string;
+  readonly encoding: "utf8" | "base64";
+} | {
+  readonly kind: "catalog" | "gallery" | "preview" | "editorial" | "project";
+  readonly relativePath: `${"catalog" | "gallery" | "preview" | "editorial" | "project"}.json`;
   readonly contents: string;
 };
 /**
- * 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.
  */
 declare const emitTemplateReferencePacket: (packet: TemplateReferencePacket) => ReadonlyArray<TemplateReferenceProjection>;
@@ -136,5 +160,5 @@ declare const emitTemplateReferencePacket: (packet: TemplateReferencePacket) =>
  */
 declare const validatePublicTemplateHandoff: (artifacts: ReadonlyArray<ApprovedPublicTemplateArtifact>) => Result.Result<ReadonlyArray<ValidatedPublicTemplateArtifact>, ReadonlyArray<PublicHandoffIssue>>;
 //#endregion
-export { ApprovedPublicTemplateArtifact, PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS, PublicHandoffIssue, PublicHandoffIssueCode, PublicTemplateAuthoredStructure, TemplateReferencePacket, TemplateReferenceProjection, TemplateReferenceProvenance, ValidatedPublicTemplateArtifact, emitTemplateReferencePacket, isSafePublicTemplateAsset, publicTemplateAuthoredStructure, toTemplateReferencePacket, unsupportedPublicTemplateFontTokens, validatePublicTemplateHandoff };
+export { ApprovedPublicTemplateArtifact, PUBLIC_TEMPLATE_PROJECT_FILE_MAX_BYTES, PUBLIC_TEMPLATE_PROJECT_MAX_BYTES, PUBLIC_TEMPLATE_PROJECT_MAX_FILES, PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS, PublicHandoffIssue, PublicHandoffIssueCode, PublicTemplateAuthoredStructure, TemplateBrandRecreation, TemplateReferencePacket, TemplateReferenceProjection, TemplateReferenceProvenance, ValidatedPublicTemplateArtifact, emitTemplateReferencePacket, isSafePublicTemplateAsset, isSafePublicTemplateProject, isSafePublicTemplateProjectPath, isValidTemplateBrandRecreation, publicTemplateAuthoredStructure, publicTemplateProjectDigest, toTemplateReferencePacket, unsupportedPublicTemplateFontTokens, validatePublicTemplateHandoff };
 //# sourceMappingURL=public-handoff.d.ts.map

package/dist/presets/public-handoff.js

@@ -11,9 +11,62 @@ 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";
+/** 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",
@@ -167,37 +220,51 @@ 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.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
-	})
-];
+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.
@@ -223,20 +290,24 @@ const validatePublicTemplateHandoff = (artifacts) => {
 		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 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 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"));
+		const declaredVariables = new Set(artifact.preset.variables);
+		const undeclaredSample = Object.keys(artifact.preview.sampleData).filter((variable) => !declaredVariables.has(variable));
+		if (undeclaredSample.length > 0) issues.push(issue(id, "sample-data", `sample data supplies undeclared variables: ${sortedUnique(undeclaredSample).join(", ")}`));
+		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, /templates/assets, 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 = [
@@ -275,6 +346,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,
@@ -283,6 +355,6 @@ const validatePublicTemplateHandoff = (artifacts) => {
 	}));
 };
 //#endregion
-export { PUBLIC_TEMPLATE_SOURCE_MAX_CHARACTERS, emitTemplateReferencePacket, isSafePublicTemplateAsset, publicTemplateAuthoredStructure, 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,4 +1,4 @@
-import { EmailPresetId } from "../presets.js";
+import { t as EmailPresetId } from "../catalog-Ck1tAGwO.js";
 import { PublicTemplate } from "./public-gallery.js";
 import { PreviewQuality } from "./public-preview.js";
 import { Result } from "effect";

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

@@ -1,7 +1,7 @@
 import { presetCatalog } from "../presets.js";
 import { registerPublicCorpusEntry } from "./corpus.js";
 import { publicTemplates } from "./public-gallery.js";
-import { presetEmailFixtures, presetModuleSource } from "./sources.js";
+import { presetEmailAssets, presetEmailFixtures, presetModuleSource } from "./sources.js";
 import { publicTemplatePreviews } from "./public-preview.js";
 import { Result } from "effect";
 //#region presets/public-preview-artifacts.ts
@@ -63,14 +63,14 @@ const buildPublicTemplatePreviewArtifact = (template) => {
 		message: "canonical preset source is missing"
 	});
 	const sampleData = fixture.input;
-	const assets = [];
+	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,
@@ -80,7 +80,7 @@ const buildPublicTemplatePreviewArtifact = (template) => {
 		quality: preview.quality,
 		source,
 		html: fixture.html,
-		assets,
+		assets: [...assets],
 		renders: renderInputs(template.slug, fixture.html)
 	});
 };

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

@@ -1,10 +1,14 @@
 //#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, string>>;
+  readonly sampleData: Readonly<Record<string, PreviewSampleValue>>;
   readonly assets: ReadonlyArray<{
     readonly variable: string;
     readonly kind: "image" | "logo";
@@ -12,19 +16,21 @@ interface PublicTemplatePreview {
 }
 /** 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;
@@ -36,7 +42,6 @@ declare const publicTemplatePreviews: {
   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;
@@ -52,5 +57,5 @@ declare const publicTemplatePreviews: {
   readonly "season-clearance-promo": PublicTemplatePreview;
 };
 //#endregion
-export { PreviewQuality, PublicTemplatePreview, publicTemplatePreviews };
+export { PreviewQuality, PreviewSampleValue, PublicTemplatePreview, publicTemplatePreviews };
 //# sourceMappingURL=public-preview.d.ts.map