@samva/markup 0.3.0 → 0.5.0

package/dist/presets/corpus.js

@@ -1,11 +1,8 @@
+import { n as isObject } from "../guards-eV1qLbf2.js";
 import { presetCatalog } from "../presets.js";
-import { Result, Schema } from "effect";
+import { showcaseProject, showcaseProjects, showcaseSourcePath } from "./showcase.js";
+import { Result } from "better-result";
 //#region presets/corpus.ts
-const TemplateCorpusKind = Schema.Literals([
-	"owned-editable-sml",
-	"brand-recreation-sml",
-	"inspiration-reference"
-]);
 const templateFacetOptions = {
 	jobType: [
 		"account-access",
@@ -46,121 +43,24 @@ const templateFacetOptions = {
 	],
 	brandProvenance: ["samva-original", "third-party-reference"]
 };
-const JobTypeFacet = Schema.Literals(templateFacetOptions.jobType);
-const LifecycleFacet = Schema.Literals(templateFacetOptions.lifecycle);
-const IndustryFacet = Schema.Literals(templateFacetOptions.industry);
-const SeasonFacet = Schema.Literals(templateFacetOptions.season);
-const AudienceFacet = Schema.Literals(templateFacetOptions.audience);
-const DesignFacet = Schema.Literals(templateFacetOptions.design);
-const BrandProvenanceFacet = Schema.Literals(templateFacetOptions.brandProvenance);
-const TemplateFacetSet = Schema.Struct({
-	jobType: Schema.Array(JobTypeFacet),
-	lifecycle: Schema.Array(LifecycleFacet),
-	industry: Schema.Array(IndustryFacet),
-	season: Schema.Array(SeasonFacet),
-	audience: Schema.Array(AudienceFacet),
-	design: Schema.Array(DesignFacet),
-	brandProvenance: Schema.Array(BrandProvenanceFacet)
-});
-const CorpusReview = Schema.Struct({
-	state: Schema.Literals([
-		"draft",
-		"approved",
-		"rejected"
-	]),
-	reviewedBy: Schema.String,
-	reviewedAt: Schema.String,
-	notes: Schema.String
-});
-const CorpusDisplay = Schema.Struct({
-	state: Schema.Literals(["hidden", "public"]),
-	attributionLabel: Schema.String
-});
-const CorpusRetention = Schema.Struct({
-	policy: Schema.Literals(["retain-until-withdrawn", "retain-while-linked"]),
-	reviewedAt: Schema.String
-});
-const CorpusTakedown = Schema.Struct({
-	state: Schema.Literals(["active", "removed"]),
-	contact: Schema.String,
-	procedureUrl: Schema.String
-});
-const OwnedEditablePreset = Schema.TaggedStruct("OwnedEditablePreset", {
-	corpusKind: Schema.Literal("owned-editable-sml"),
-	provenance: Schema.Struct({
-		owner: Schema.Literal("Samva"),
-		sourcePath: Schema.String,
-		recordedAt: Schema.String
-	}),
-	review: CorpusReview,
-	display: CorpusDisplay,
-	retention: CorpusRetention,
-	takedown: CorpusTakedown
-});
-const BrandRecreationPreset = Schema.TaggedStruct("BrandRecreationPreset", {
-	corpusKind: Schema.Literal("brand-recreation-sml"),
-	provenance: Schema.Struct({
-		owner: Schema.Literal("Samva"),
-		sourcePath: Schema.String,
-		recordedAt: Schema.String,
-		/** The brand whose own email is recreated, named on every public surface. */
-		brand: Schema.String,
-		/** What that brand's email does, in the customer's words. */
-		subject: Schema.String,
-		reviewedNote: Schema.String
-	}),
-	review: CorpusReview,
-	display: CorpusDisplay,
-	retention: CorpusRetention,
-	takedown: CorpusTakedown
-});
 /** Clean-room recreations of a named brand's own email, authored as editable Samva projects. */
-const brandRecreationProvenance = {
-	"linear-login-code": {
-		owner: "Samva",
-		sourcePath: "examples/email-showcase/emails/linear-login-code.tsx",
-		recordedAt: "2026-09-08T00:00:00.000Z",
-		brand: "Linear",
-		subject: "login code",
-		reviewedNote: "Reviewed recreation of Linear's login code email, its canonical project assets, and its brand attribution."
-	},
-	"vercel-invitation": {
-		owner: "Samva",
-		sourcePath: "examples/email-showcase/emails/vercel-invitation.tsx",
-		recordedAt: "2026-09-08T00:00:00.000Z",
-		brand: "Vercel",
-		subject: "team invitation",
-		reviewedNote: "Reviewed recreation of Vercel's team invitation email, its canonical project assets, and its brand attribution."
-	}
-};
+const brandRecreationProvenance = Object.fromEntries(showcaseProjects.flatMap((project) => project.provenance.kind === "brand-recreation" ? [[project.id, {
+	owner: "Samva",
+	sourcePath: showcaseSourcePath(project),
+	recordedAt: project.recordedAt,
+	brand: project.provenance.brand,
+	subject: project.provenance.subject,
+	reviewedNote: project.provenance.reviewedNote
+}]] : []));
 /**
 * Owned presets authored as complete showcase projects with their own stylesheet and assets.
 * Every other owned preset is the single module `packages/markup/presets/<id>.tsx`.
 */
-const ownedShowcasePresetSources = {
-	"order-receipt": "examples/email-showcase/emails/order-receipt.tsx",
-	"product-launch-promo": "examples/email-showcase/emails/product-launch-promo.tsx",
-	"product-newsletter": "examples/email-showcase/emails/product-newsletter.tsx"
+const ownedShowcasePresetSources = Object.fromEntries(showcaseProjects.flatMap((project) => project.provenance.kind === "owned" ? [[project.id, showcaseSourcePath(project)]] : []));
+const ownedPresetSourcePath = (id) => {
+	const project = showcaseProject(id);
+	return project === void 0 || project.provenance.kind !== "owned" ? `packages/markup/presets/${id}.tsx` : showcaseSourcePath(project);
 };
-const ownedPresetSourcePath = (id) => Object.hasOwn(ownedShowcasePresetSources, id) ? ownedShowcasePresetSources[id] : `packages/markup/presets/${id}.tsx`;
-const InspirationReference = Schema.TaggedStruct("InspirationReference", {
-	corpusKind: Schema.Literal("inspiration-reference"),
-	provenance: Schema.Struct({
-		publisher: Schema.String,
-		sourceUrl: Schema.String,
-		capturedAt: Schema.String,
-		rightsBasis: Schema.Literals(["display-link-and-commentary", "permission"])
-	}),
-	review: CorpusReview,
-	display: CorpusDisplay,
-	retention: CorpusRetention,
-	takedown: CorpusTakedown
-});
-const TemplateCorpusRecord = Schema.Union([
-	OwnedEditablePreset,
-	BrandRecreationPreset,
-	InspirationReference
-]);
 const ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 const nonEmpty = (value) => value.trim().length > 0;
 const isHttpsUrl = (value) => {
@@ -176,65 +76,112 @@ const requiredFacetDimensions = [
 	"design",
 	"brandProvenance"
 ];
+/** Exact key sets: a record carrying anything else is not the shape this gate admits. */
+const exactKeys = (value, keys) => isObject(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+const isStringIn = (value, values) => typeof value === "string" && values.includes(value);
+const isStringArrayIn = (value, values) => Array.isArray(value) && value.every((entry) => isStringIn(entry, values));
+const isReview = (value) => exactKeys(value, [
+	"state",
+	"reviewedBy",
+	"reviewedAt",
+	"notes"
+]) && isStringIn(value.state, [
+	"draft",
+	"approved",
+	"rejected"
+]) && typeof value.reviewedBy === "string" && typeof value.reviewedAt === "string" && typeof value.notes === "string";
+const isDisplay = (value) => exactKeys(value, ["state", "attributionLabel"]) && isStringIn(value.state, ["hidden", "public"]) && typeof value.attributionLabel === "string";
+const isRetention = (value) => exactKeys(value, ["policy", "reviewedAt"]) && isStringIn(value.policy, ["retain-until-withdrawn", "retain-while-linked"]) && typeof value.reviewedAt === "string";
+const isTakedown = (value) => exactKeys(value, [
+	"state",
+	"contact",
+	"procedureUrl"
+]) && isStringIn(value.state, ["active", "removed"]) && typeof value.contact === "string" && typeof value.procedureUrl === "string";
+/** The four governance blocks every corpus record carries, whatever its kind. */
+const hasGovernance = (value) => isReview(value.review) && isDisplay(value.display) && isRetention(value.retention) && isTakedown(value.takedown);
+const CORPUS_KEYS = [
+	"type",
+	"corpusKind",
+	"provenance",
+	"review",
+	"display",
+	"retention",
+	"takedown"
+];
+const isCorpusRecord = (value) => {
+	if (!exactKeys(value, CORPUS_KEYS) || !hasGovernance(value)) return false;
+	const provenance = value.provenance;
+	if (value.type === "OwnedEditablePreset") return value.corpusKind === "owned-editable-sml" && exactKeys(provenance, [
+		"owner",
+		"sourcePath",
+		"recordedAt"
+	]) && provenance.owner === "Samva" && typeof provenance.sourcePath === "string" && typeof provenance.recordedAt === "string";
+	if (value.type === "BrandRecreationPreset") return value.corpusKind === "brand-recreation-sml" && exactKeys(provenance, [
+		"owner",
+		"sourcePath",
+		"recordedAt",
+		"brand",
+		"subject",
+		"reviewedNote"
+	]) && provenance.owner === "Samva" && typeof provenance.sourcePath === "string" && typeof provenance.recordedAt === "string" && typeof provenance.brand === "string" && typeof provenance.subject === "string" && typeof provenance.reviewedNote === "string";
+	return value.type === "InspirationReference" && value.corpusKind === "inspiration-reference" && exactKeys(provenance, [
+		"publisher",
+		"sourceUrl",
+		"capturedAt",
+		"rightsBasis"
+	]) && typeof provenance.publisher === "string" && typeof provenance.sourceUrl === "string" && typeof provenance.capturedAt === "string" && isStringIn(provenance.rightsBasis, ["display-link-and-commentary", "permission"]);
+};
+const isFacetSet = (value) => exactKeys(value, requiredFacetDimensions) && requiredFacetDimensions.every((dimension) => isStringArrayIn(value[dimension], templateFacetOptions[dimension]));
+const isCorpusEntry = (value) => exactKeys(value, [
+	"id",
+	"corpus",
+	"facets"
+]) && typeof value.id === "string" && isCorpusRecord(value.corpus) && isFacetSet(value.facets);
 const canonicalOwnedPresetSources = new Map(presetCatalog.filter((preset) => preset.channel === "email" && !Object.hasOwn(brandRecreationProvenance, preset.id)).map((preset) => [preset.id, ownedPresetSourcePath(preset.id)]));
 /** Decode and gate a record before it can enter any public projection. */
 const registerPublicCorpusEntry = (input) => {
-	const decoded = Schema.decodeUnknownResult(Schema.Struct({
-		id: Schema.String,
-		corpus: TemplateCorpusRecord,
-		facets: TemplateFacetSet
-	}), { onExcessProperty: "error" })(input);
-	if (Result.isFailure(decoded)) return Result.fail({
+	if (!isCorpusEntry(input)) return Result.err({
 		id: "unknown",
 		message: "record does not match a corpus schema"
 	});
-	const { id, corpus, facets } = decoded.success;
+	const { id, corpus, facets } = input;
 	const timestamps = [
 		corpus.review.reviewedAt,
 		corpus.retention.reviewedAt,
-		corpus._tag === "InspirationReference" ? corpus.provenance.capturedAt : corpus.provenance.recordedAt
+		corpus.type === "InspirationReference" ? corpus.provenance.capturedAt : corpus.provenance.recordedAt
 	];
-	if (!nonEmpty(id) || corpus.review.state !== "approved" || !nonEmpty(corpus.review.reviewedBy) || !nonEmpty(corpus.review.notes) || corpus.display.state !== "public" || !nonEmpty(corpus.display.attributionLabel) || corpus.takedown.state !== "active" || !nonEmpty(corpus.takedown.contact) || !isHttpsUrl(corpus.takedown.procedureUrl) || timestamps.some((timestamp) => !ISO_TIMESTAMP.test(timestamp))) return Result.fail({
+	if (!nonEmpty(id) || corpus.review.state !== "approved" || !nonEmpty(corpus.review.reviewedBy) || !nonEmpty(corpus.review.notes) || corpus.display.state !== "public" || !nonEmpty(corpus.display.attributionLabel) || corpus.takedown.state !== "active" || !nonEmpty(corpus.takedown.contact) || !isHttpsUrl(corpus.takedown.procedureUrl) || timestamps.some((timestamp) => !ISO_TIMESTAMP.test(timestamp))) return Result.err({
 		id,
 		message: "public corpus records require approved review, display, retention, and takedown metadata"
 	});
-	if (corpus._tag === "OwnedEditablePreset" && (canonicalOwnedPresetSources.get(id) !== corpus.provenance.sourcePath || corpus.retention.policy !== "retain-until-withdrawn" || facets.brandProvenance.some((value) => value !== "samva-original"))) return Result.fail({
+	if (corpus.type === "OwnedEditablePreset" && (canonicalOwnedPresetSources.get(id) !== corpus.provenance.sourcePath || corpus.retention.policy !== "retain-until-withdrawn" || facets.brandProvenance.some((value) => value !== "samva-original"))) return Result.err({
 		id,
 		message: "owned presets require a canonical editable TSX source"
 	});
-	if (corpus._tag === "BrandRecreationPreset") {
+	if (corpus.type === "BrandRecreationPreset") {
 		const canonical = Object.entries(brandRecreationProvenance).find(([presetId]) => presetId === id)?.[1];
-		if (canonical === void 0 || Object.entries(canonical).some(([key, value]) => corpus.provenance[key] !== value) || !nonEmpty(corpus.provenance.brand) || !nonEmpty(corpus.provenance.subject) || corpus.retention.policy !== "retain-until-withdrawn" || facets.brandProvenance.some((value) => value !== "third-party-reference")) return Result.fail({
+		if (canonical === void 0 || Object.entries(canonical).some(([key, value]) => corpus.provenance[key] !== value) || !nonEmpty(corpus.provenance.brand) || !nonEmpty(corpus.provenance.subject) || corpus.retention.policy !== "retain-until-withdrawn" || facets.brandProvenance.some((value) => value !== "third-party-reference")) return Result.err({
 			id,
 			message: "brand recreations require a canonical source, a referenced brand and subject, and third-party provenance"
 		});
 	}
-	if (corpus._tag === "InspirationReference" && (!isHttpsUrl(corpus.provenance.sourceUrl) || corpus.retention.policy !== "retain-while-linked" || facets.brandProvenance.some((value) => value !== "third-party-reference"))) return Result.fail({
+	if (corpus.type === "InspirationReference" && (!isHttpsUrl(corpus.provenance.sourceUrl) || corpus.retention.policy !== "retain-while-linked" || facets.brandProvenance.some((value) => value !== "third-party-reference"))) return Result.err({
 		id,
 		message: "inspiration references require an HTTPS source and third-party provenance facet"
 	});
 	for (const dimension of requiredFacetDimensions) {
 		const values = facets[dimension];
-		if (values.length === 0 || new Set(values).size !== values.length) return Result.fail({
+		if (values.length === 0 || new Set(values).size !== values.length) return Result.err({
 			id,
 			message: `facet ${dimension} must be populated without duplicates`
 		});
 	}
-	return Result.succeed({
+	return Result.ok({
 		id,
 		corpus,
 		facets
 	});
 };
-const TemplateFacetQuery = Schema.Struct({
-	jobType: Schema.optionalKey(Schema.Array(JobTypeFacet)),
-	lifecycle: Schema.optionalKey(Schema.Array(LifecycleFacet)),
-	industry: Schema.optionalKey(Schema.Array(IndustryFacet)),
-	season: Schema.optionalKey(Schema.Array(SeasonFacet)),
-	audience: Schema.optionalKey(Schema.Array(AudienceFacet)),
-	design: Schema.optionalKey(Schema.Array(DesignFacet)),
-	brandProvenance: Schema.optionalKey(Schema.Array(BrandProvenanceFacet))
-});
 /** Strict intersection: every selected value in every selected dimension must match. */
 const matchesTemplateFacets = (facets, query) => requiredFacetDimensions.every((dimension) => {
 	const selected = query[dimension];
@@ -242,6 +189,6 @@ const matchesTemplateFacets = (facets, query) => requiredFacetDimensions.every((
 	return selected === void 0 || selected.every((value) => available.has(value));
 });
 //#endregion
-export { BrandRecreationPreset, InspirationReference, OwnedEditablePreset, TemplateCorpusKind, TemplateCorpusRecord, TemplateFacetQuery, TemplateFacetSet, brandRecreationProvenance, matchesTemplateFacets, ownedPresetSourcePath, ownedShowcasePresetSources, registerPublicCorpusEntry, templateFacetOptions };
+export { brandRecreationProvenance, matchesTemplateFacets, ownedPresetSourcePath, ownedShowcasePresetSources, registerPublicCorpusEntry, templateFacetOptions };
 
 //# sourceMappingURL=corpus.js.map