@warpgogol/werkstatt-shared 0.2.0

package/src/share/schemas/claim-records.ts

@@ -0,0 +1,69 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0505: the ratgeber claim record schema. A structured claim record at
+`surface/claims/{lang}/*.md` with claimId, articleId, claimText, claimType,
+sourceRefs, calculationInputs, limitations, verifiedAt, expiresAt, and
+reviewStatus. This is the ratgeber-specific claim registry that replaces
+the RFC-0502 claim sidecars for ratgeber articles.
+</purpose>
+<non-goals>
+  <item>Do not validate claim records — the kernel validators (ratgeber.claim.validate) do that.</item>
+  <item>Do not resolve sourceRefs or calculationInputs — the validators resolve them against source descriptors and PBP data.</item>
+  <item>Do not confuse with recordClaimsSchema (RFC-0212) — that is the CKL claim sidecar for business records; this is the ratgeber claim record.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0505: initial claim record schema + type.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+/** ISO 8601 calendar date, e.g. 2026-07-23. */
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+const isoDate = z.string().regex(ISO_DATE, "must be an ISO 8601 date (YYYY-MM-DD)");
+
+/** A source reference within a claim record. */
+export const claimSourceRefSchema = z
+  .object({
+    sourceId: z.string().min(1),
+    url: z.string().url(),
+    title: z.string().min(1),
+    retrievedAt: isoDate,
+  })
+  .strict();
+
+export type ClaimSourceRef = z.infer<typeof claimSourceRefSchema>;
+
+/** A calculation input reference within a claim record (for `calculation` type). */
+export const calculationInputSchema = z
+  .object({
+    ref: z.string().min(1),
+    value: z.string(),
+  })
+  .strict();
+
+export type CalculationInput = z.infer<typeof calculationInputSchema>;
+
+/**
+ * A structured ratgeber claim record (RFC-0505). Lives at
+ * `surface/claims/{lang}/{claimId}.md` as frontmatter-only content.
+ */
+export const claimRecordSchema = z
+  .object({
+    claimId: z.string().min(1),
+    articleId: z.string().min(1),
+    claimText: z.string(),
+    claimType: z.enum(["factual", "calculation", "methodological", "regulatory"]),
+    sourceRefs: z.array(claimSourceRefSchema),
+    calculationInputs: z.array(calculationInputSchema).optional().default([]),
+    limitations: z.array(z.string()).optional().default([]),
+    verifiedAt: isoDate,
+    expiresAt: isoDate.optional(),
+    reviewStatus: z.enum(["verified", "unverified", "disputed"]),
+  })
+  .strict();
+
+export type ClaimRecord = z.infer<typeof claimRecordSchema>;

package/src/share/schemas/claims.ts

@@ -0,0 +1,150 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0212: the claim annotation surface. A per-record provenance sidecar
+`<record>.claims.yaml` is a map of field path → annotation, turning a bare field
+into a CKL claim (RFC-0211) without touching the editable record body. Closed Zod
+schema so `content.claim.validate` can shape-check every sidecar.
+
+Moved from @warpgogol/business/schemas to @warpgogol/werkstatt-shared/share/schemas as part of RFC-0470
+(legacy business layer deletion). This is Content Knowledge Lifecycle (CKL)
+infrastructure, not business-layer code.
+</purpose>
+<non-goals>
+  <item>Do not resolve field paths, evaluate freshness, hash derivations, or read the filesystem — the kernel validators do that.</item>
+  <item>Do not wrap or validate the record value itself; a claim only annotates.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0212: initial claim annotation + record-claims schemas.</item>
+  <item>RFC-0470: moved from @warpgogol/business/schemas/claims.ts to @warpgogol/werkstatt-shared/share/schemas/claims.ts.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+/** ISO 8601 calendar date, e.g. 2026-06-20. */
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/** ISO 8601 duration with at least one component, e.g. P3M, P1Y, P2W, PT12H. */
+const ISO8601_DURATION = /^P(?:\d+Y)?(?:\d+M)?(?:\d+W)?(?:\d+D)?(?:T(?:\d+H)?(?:\d+M)?(?:\d+S)?)?$/;
+
+const isoDate = z.string().regex(ISO_DATE, "must be an ISO 8601 date (YYYY-MM-DD)");
+
+/**
+ * One field's claim annotation (RFC-0211 claim, minus the value which stays in the
+ * record body). `.strict()` so a typo'd key is caught as a schema violation
+ * (CKL-CLAIM-01) instead of silently ignored.
+ */
+export const claimAnnotationSchema = z
+  .object({
+    claimClass: z
+      .enum(["general", "legal", "price", "comparative-commercial"])
+      .optional()
+      .default("general"),
+    provenance: z.enum(["external", "derived", "asserted", "generated"]),
+    /** ISO date the value was last verified / asserted. */
+    asOf: isoDate,
+    /** ISO date after which the claim is stale. */
+    validUntil: isoDate.optional(),
+    /** ISO 8601 recurring review cadence, e.g. "P3M". */
+    reviewEvery: z
+      .string()
+      .regex(ISO8601_DURATION, "must be an ISO 8601 duration (e.g. P3M)")
+      .refine((v) => v !== "P" && v !== "PT", "duration must have at least one component")
+      .optional(),
+    /** → source descriptor id (RFC-0214) when provenance = external. */
+    sourceRef: z.string().min(1).optional(),
+    /** Canonical source subject string (RFC-0215) when provenance = derived. */
+    derivedFrom: z.string().min(1).optional(),
+    /** Normalized hash of the source value at derivation time (RFC-0215). */
+    sourceHash: z.string().min(1).optional(),
+    comparedEntity: z
+      .object({
+        name: z.string().min(1),
+        kind: z.enum(["vendor", "marketplace", "platform", "competitor-category"]),
+        url: z.string().url().optional(),
+      })
+      .optional(),
+    claimKind: z
+      .enum(["third-party-price", "capability", "ownership", "export", "support", "risk", "other"])
+      .optional(),
+    statement: z.string().min(1).optional(),
+    value: z
+      .object({
+        amount: z.number().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+        currency: z.string().min(1).optional(),
+        unit: z.string().min(1).optional(),
+      })
+      .optional(),
+    publicDisclosure: z
+      .object({
+        label: z.string().min(1),
+        showStandDate: z.literal(true),
+        showSourceLabel: z.boolean(),
+      })
+      .optional(),
+    criticality: z.enum(["advisory", "important", "blocking"]).optional(),
+    /** Responsible agent/human handle — routing (RFC-0216). */
+    owner: z.string().min(1).optional(),
+    confidence: z.enum(["high", "medium", "low"]).optional(),
+  })
+  .strict()
+  .superRefine((claim, ctx) => {
+    if (claim.claimClass !== "comparative-commercial") return;
+    const required: Array<keyof typeof claim> = [
+      "comparedEntity",
+      "claimKind",
+      "statement",
+      "sourceRef",
+      "reviewEvery",
+      "publicDisclosure",
+      "criticality",
+    ];
+    for (const key of required) {
+      if (claim[key] === undefined) {
+        ctx.addIssue({
+          code: "custom",
+          path: [key],
+          message: "required for comparative-commercial claims",
+        });
+      }
+    }
+    if (claim.provenance !== "external") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["provenance"],
+        message: "comparative-commercial claims must use external provenance",
+      });
+    }
+    if (claim.criticality !== "blocking") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["criticality"],
+        message: "comparative-commercial claims must be blocking",
+      });
+    }
+    if (claim.claimKind === "third-party-price") {
+      if (!claim.value?.currency)
+        ctx.addIssue({
+          code: "custom",
+          path: ["value", "currency"],
+          message: "third-party-price claims require value.currency",
+        });
+      if (!claim.value?.unit)
+        ctx.addIssue({
+          code: "custom",
+          path: ["value", "unit"],
+          message: "third-party-price claims require value.unit",
+        });
+    }
+  });
+
+export type ClaimAnnotation = z.infer<typeof claimAnnotationSchema>;
+
+/** The full `<record>.claims.yaml` sidecar: fieldPath → annotation. */
+export const recordClaimsSchema = z.record(z.string().min(1), claimAnnotationSchema);
+
+export type RecordClaims = z.infer<typeof recordClaimsSchema>;

package/src/share/schemas/effects.ts

@@ -0,0 +1,212 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+Canonical composable UI effects contract for shared sections and components.
+Owns effect targets, discriminated effect kinds, assignment arrays, and
+schema validation for the RFC-0134 glass-first effects model.
+</purpose>
+<non-goals>
+  <item>Do not render effects — rendering belongs to @warpgogol/werkstatt-site/ui.</item>
+  <item>Do not implement future effect kinds beyond glass in the initial wave.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>Introduces RFC-0134 composable effects contracts with glass as the first supported effect kind.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+const NAMED_EFFECT_TARGETS = [
+  "section",
+  "body",
+  "panel",
+  "item",
+  "card",
+  "row",
+  "column",
+  "media",
+  "cta",
+  "heading", // RFC-0151 — typographic effects on the section heading
+  "subheading", // typographic effects on the section subheading/tagline
+] as const;
+
+export const namedEffectTargetSchema = z.enum(NAMED_EFFECT_TARGETS);
+const slotEffectTargetSchema = z.string().regex(/^slot:[a-z0-9-]+$/);
+export const effectTargetSchema = z.union([namedEffectTargetSchema, slotEffectTargetSchema]);
+export type EffectTarget = z.infer<typeof effectTargetSchema>;
+
+export const glassEffectSchema = z
+  .object({
+    kind: z.literal("glass"),
+    enabled: z.boolean(),
+    blur: z.number().min(0).max(64).optional(),
+    saturate: z.number().min(0).max(400).optional(),
+    tint: z.string().min(1).optional(),
+    tintOpacity: z.number().min(0).max(1).optional(),
+    border: z.enum(["hairline", "none"]).optional(),
+  })
+  .strict();
+export type GlassEffect = z.infer<typeof glassEffectSchema>;
+
+/**
+ * RFC-0151 — shared color alias for typographic effects. Either a biome token
+ * alias resolved by the renderer, or a raw passthrough value (e.g. "#0af").
+ */
+export const effectColorSchema = z.union([
+  z.enum(["text", "primary", "accent", "shadow", "surface", "inverse"]),
+  z.string().min(1),
+]);
+export type EffectColor = z.infer<typeof effectColorSchema>;
+
+export const shadowEffectSchema = z
+  .object({
+    kind: z.literal("shadow"),
+    enabled: z.boolean(),
+    offsetX: z.number().min(-64).max(64).optional(),
+    offsetY: z.number().min(-64).max(64).optional(),
+    blur: z.number().min(0).max(64).optional(),
+    color: effectColorSchema.optional(),
+    opacity: z.number().min(0).max(1).optional(),
+  })
+  .strict();
+export type ShadowEffect = z.infer<typeof shadowEffectSchema>;
+
+export const glowEffectSchema = z
+  .object({
+    kind: z.literal("glow"),
+    enabled: z.boolean(),
+    blur: z.number().min(0).max(96).optional(),
+    color: effectColorSchema.optional(),
+    opacity: z.number().min(0).max(1).optional(),
+  })
+  .strict();
+export type GlowEffect = z.infer<typeof glowEffectSchema>;
+
+export const bulgeEffectSchema = z
+  .object({
+    kind: z.literal("bulge"),
+    enabled: z.boolean(),
+    depth: z.number().min(0).max(16).optional(),
+    highlight: z.number().min(0).max(1).optional(),
+    shade: z.number().min(0).max(1).optional(),
+    shadowColor: effectColorSchema.optional(),
+    highlightColor: effectColorSchema.optional(),
+  })
+  .strict();
+export type BulgeEffect = z.infer<typeof bulgeEffectSchema>;
+
+export const tiltEffectSchema = z
+  .object({
+    kind: z.literal("tilt"),
+    enabled: z.boolean(),
+    rotate: z.number().min(-15).max(15).optional(),
+    skewX: z.number().min(-15).max(15).optional(),
+  })
+  .strict();
+export type TiltEffect = z.infer<typeof tiltEffectSchema>;
+
+export const effectSchema = z.discriminatedUnion("kind", [
+  glassEffectSchema,
+  shadowEffectSchema,
+  glowEffectSchema,
+  bulgeEffectSchema,
+  tiltEffectSchema,
+]);
+export type Effect = z.infer<typeof effectSchema>;
+
+export type EffectKind = Effect["kind"];
+export type EffectRenderStrategy = "surface" | "text";
+
+/**
+ * RFC-0151 — per-kind metadata. Single source of truth shared by the stack
+ * validator (maxPerStack) and the @warpgogol/werkstatt-site/ui renderer (strategy).
+ */
+export const EFFECT_KIND_META = {
+  glass: { strategy: "surface", maxPerStack: 1 },
+  shadow: { strategy: "text", maxPerStack: 1 },
+  glow: { strategy: "text", maxPerStack: 1 },
+  bulge: { strategy: "text", maxPerStack: 1 },
+  tilt: { strategy: "text", maxPerStack: 1 },
+} as const satisfies Record<EffectKind, { strategy: EffectRenderStrategy; maxPerStack: number }>;
+
+/**
+ * RFC-0151 — which effect kinds each target accepts. Targets absent from this
+ * map default to glass-only (the RFC-0134 surface behavior). The `heading`
+ * target accepts only the typographic (text-strategy) kinds.
+ */
+export const TARGET_ALLOWED_KINDS: Record<string, readonly EffectKind[]> = {
+  heading: ["shadow", "glow", "bulge", "tilt"],
+  subheading: ["shadow", "glow", "bulge", "tilt"],
+};
+
+const DEFAULT_ALLOWED_KINDS: readonly EffectKind[] = ["glass"];
+
+/** RFC-0151 — kinds accepted by a target, falling back to the glass-only default. */
+export function allowedKindsForTarget(target: EffectTarget): readonly EffectKind[] {
+  return TARGET_ALLOWED_KINDS[target] ?? DEFAULT_ALLOWED_KINDS;
+}
+
+export const effectStackSchema = z
+  .array(effectSchema)
+  .min(1)
+  .superRefine((stack, ctx) => {
+    const counts = new Map<EffectKind, number>();
+    for (const effect of stack) {
+      counts.set(effect.kind, (counts.get(effect.kind) ?? 0) + 1);
+    }
+    for (const [kind, count] of counts) {
+      const max = EFFECT_KIND_META[kind].maxPerStack;
+      if (count > max) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Only ${max} ${kind} effect(s) allowed per effect stack.`,
+        });
+      }
+    }
+  });
+
+export const effectAssignmentSchema = z
+  .object({
+    target: effectTargetSchema,
+    stack: effectStackSchema,
+  })
+  .strict()
+  .superRefine((assignment, ctx) => {
+    // RFC-0151 — target × kind admissibility. A heading accepts only the
+    // typographic kinds; surface targets accept only glass. This is the
+    // contract guard the RFC describes, enforced wherever content is validated.
+    const allowed = allowedKindsForTarget(assignment.target);
+    for (const effect of assignment.stack) {
+      if (!allowed.includes(effect.kind)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["stack"],
+          message: `Target '${assignment.target}' supports kinds [${allowed.join(", ")}], not '${effect.kind}'.`,
+        });
+      }
+    }
+  });
+export type EffectAssignment = z.infer<typeof effectAssignmentSchema>;
+
+export const effectsSchema = z.array(effectAssignmentSchema).min(1);
+export type Effects = z.infer<typeof effectsSchema>;
+
+export function resolveEffectsForTarget(
+  assignments: readonly EffectAssignment[] | undefined,
+  target: EffectTarget,
+): Effect[] {
+  return assignments?.find((assignment) => assignment.target === target)?.stack ?? [];
+}
+
+export function hasEnabledGlassEffect(effects: readonly Effect[] | undefined): effects is Effect[] {
+  return Boolean(effects?.some((effect) => effect.kind === "glass" && effect.enabled));
+}
+
+export function resolveGlassEffect(
+  effects: readonly Effect[] | undefined,
+): GlassEffect | undefined {
+  return effects?.find(
+    (effect): effect is GlassEffect => effect.kind === "glass" && effect.enabled,
+  );
+}

package/src/share/schemas/features.ts

@@ -0,0 +1,147 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+Shared Zod schemas for the content-declared feature graph (RFC-0018).
+App-agnostic — every app that adopts RFC-0018 imports from here instead of
+copy-pasting. Canonical home per RFC-0033.
+</purpose>
+<non-goals>
+  <item>Do not import from astro:content or apps/*.</item>
+  <item>Do not handle runtime resolution or navigation logic.</item>
+  <item>Do not manage state or side effects.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0033: Moved from app content schemas/features to @warpgogol/werkstatt-shared/share. Import switched from "astro/zod" to "zod" for framework neutrality.</item>
+  <item>RFC-0183: Added Feature Policy schema for policy embedded in existing RFC-0047 content domains.</item>
+</CHANGE_SUMMARY>
+*/
+
+// [RFC-0018] Feature graph schemas — canonical implementation in packages/share.
+// Import z from "zod" — not "astro/zod" — so this package stays framework-neutral.
+import { z } from "zod";
+
+const featureVisibilitySchema = z.enum(["enabled", "disabled"]);
+
+export const featurePolicyVisibilitySchema = z.enum(["enabled", "disabled", "hidden", "draft"]);
+
+export const featurePolicyBehaviorValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+]);
+
+export const featurePolicySchema = z.object({
+  visibility: featurePolicyVisibilitySchema.optional(),
+  behavior: z.record(z.string(), featurePolicyBehaviorValueSchema).optional(),
+  reason: z.string().optional(),
+  expiresAt: z.string().optional(),
+  audience: z.string().optional(),
+});
+
+export const featurePolicyTargetKindSchema = z.enum(["page", "section", "component", "item"]);
+
+export const featurePolicyTargetRefSchema = z.object({
+  kind: featurePolicyTargetKindSchema,
+  pageId: z.string().optional(),
+  blockId: z.string().optional(),
+  componentId: z.string().optional(),
+  itemId: z.string().optional(),
+  lang: z.string().optional(),
+});
+
+export const resolvedFeaturePolicySchema = z.object({
+  target: featurePolicyTargetRefSchema,
+  visibility: featurePolicyVisibilitySchema,
+  behavior: z.record(z.string(), featurePolicyBehaviorValueSchema),
+  sourcePath: z.string(),
+  inheritedFrom: featurePolicyTargetRefSchema.optional(),
+});
+
+const behaviorOverrideSchema = z.record(z.string(), z.any());
+
+export const featureItemSchema = z.object({
+  id: z.string(),
+  visibility: featureVisibilitySchema,
+  behavior: behaviorOverrideSchema.optional(),
+});
+
+export const featureComponentSchema = z.object({
+  id: z.string(),
+  componentPath: z.string(),
+  anchor: z.string(),
+  visibility: featureVisibilitySchema,
+  items: z.array(featureItemSchema).optional(),
+});
+
+/**
+ * Broad feature-graph category for a section node (RFC-0018).
+ *
+ * This is a FEATURE-GRAPH concept — it determines how the visibility engine
+ * classifies and processes a section. It is NOT the per-section SemanticRole
+ * from @warpgogol/werkstatt-shared/ontology (DNA-17, RFC-0023), which identifies each section
+ * individually (hero, dna, final-cta, …) and lives in manifest.yaml.
+ *
+ * SectionKind values:
+ *   navigation — anchored nav / in-page links
+ *   hero       — primary above-the-fold section
+ *   content    — main informational section
+ *   supporting — supplementary / secondary section
+ *   cta        — conversion / call-to-action section
+ *   custom     — does not fit the above categories
+ */
+export const sectionKindSchema = z.enum([
+  "navigation",
+  "hero",
+  "content",
+  "supporting",
+  "cta",
+  "custom",
+]);
+
+export const featureSectionSchema = z.object({
+  id: z.string(),
+  role: sectionKindSchema,
+  anchor: z.string(),
+  visibility: featureVisibilitySchema,
+  components: z.array(featureComponentSchema),
+});
+
+export const featurePageSchema = z.object({
+  id: z.string(),
+  routeSlug: z.string(),
+  visibility: featureVisibilitySchema,
+  sections: z.array(featureSectionSchema),
+});
+
+export const sharedComponentFeatureSchema = z.object({
+  id: z.string(),
+  componentPath: z.string(),
+  anchor: z.string(),
+  visibility: featureVisibilitySchema,
+  items: z.array(featureItemSchema).optional(),
+});
+
+export const siteFeaturesSchema = z
+  .object({
+    kind: z.enum(["page", "sharedComponent"]),
+  })
+  .loose();
+
+export type FeatureVisibility = z.infer<typeof featureVisibilitySchema>;
+export type FeaturePolicyVisibility = z.infer<typeof featurePolicyVisibilitySchema>;
+export type FeaturePolicyBehaviorValue = z.infer<typeof featurePolicyBehaviorValueSchema>;
+export type FeaturePolicy = z.infer<typeof featurePolicySchema>;
+export type FeaturePolicyTargetKind = z.infer<typeof featurePolicyTargetKindSchema>;
+export type FeaturePolicyTargetRef = z.infer<typeof featurePolicyTargetRefSchema>;
+export type ResolvedFeaturePolicy = z.infer<typeof resolvedFeaturePolicySchema>;
+export type BehaviorOverride = z.infer<typeof behaviorOverrideSchema>;
+/** @see sectionKindSchema for the distinction between SectionKind and SemanticRole */
+export type SectionKind = z.infer<typeof sectionKindSchema>;
+export type FeatureItem = z.infer<typeof featureItemSchema>;
+export type FeatureComponent = z.infer<typeof featureComponentSchema>;
+export type FeatureSection = z.infer<typeof featureSectionSchema>;
+export type FeaturePage = z.infer<typeof featurePageSchema>;
+export type SharedComponentFeature = z.infer<typeof sharedComponentFeatureSchema>;
+export type SiteFeature = z.infer<typeof siteFeaturesSchema>;

package/src/share/schemas/horizontal-align.ts

@@ -0,0 +1,22 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+[RFC-0101][RFC-0102][RFC-0103][RFC-0104] Canonical horizontal alignment enum
+shared by SectionHeader, SectionBody, SectionCtaGroup and any future section
+primitive that needs left | center | right.
+</purpose>
+<non-goals>
+  <item>Do not add vertical alignment or alignment for shell-level layouts.</item>
+  <item>Do not couple alignment to section content shape.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0133: backfilled MODULE_MAP and CHANGE_SUMMARY markers for compass.validate compliance.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+export const horizontalAlignSchema = z.enum(["left", "center", "right"]);
+
+export type HorizontalAlign = z.infer<typeof horizontalAlignSchema>;

package/src/share/schemas/icon-color.ts

@@ -0,0 +1,27 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+[RFC-0103] Canonical IconColor enum consumed by body components (<SectionList>,
+<SectionSplitList>, <SectionCardGrid>, ...) for per-row icon tinting.
+</purpose>
+<non-goals>
+  <item>Do not introduce app-specific runtime composition or deployment behavior into this reusable package source file.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0133: backfilled MODULE_MAP and CHANGE_SUMMARY markers for compass.validate compliance.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+export const iconColorSchema = z.enum([
+  "primary",
+  "accent",
+  "success",
+  "warning",
+  "error",
+  "muted",
+]);
+
+export type IconColor = z.infer<typeof iconColorSchema>;

package/src/share/schemas/index.ts

@@ -0,0 +1,43 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+RFC-0264: barrel for the entire @warpgogol/werkstatt-shared/share schemas domain — base page schema,
+navigation, feature policy, and the RFC-0101..0106/0202/0210/0220/0231/0257
+canonical section-visual / section-content / media / material-credit / print
+contracts. Consumers should prefer `@warpgogol/werkstatt-shared/share/schemas` over the deprecated
+root barrel.
+</purpose>
+<non-goals>
+  <item>Do not contain schema definitions — pure re-export barrel.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0264: initial creation — aggregates the schemas/ domain for the @warpgogol/werkstatt-shared/share/schemas subpath.</item>
+</CHANGE_SUMMARY>
+*/
+
+export * from "./page-base.ts";
+export * from "./navigation.ts";
+export * from "./features.ts";
+export * from "./horizontal-align.ts";
+export * from "./section-background.ts";
+export * from "./effects.ts";
+export * from "./section-shell.ts";
+export * from "./section-header.ts";
+export * from "./icon-color.ts";
+export * from "./standard-list-item.ts";
+export * from "./section-cards.ts";
+export * from "./section-stats.ts";
+export * from "./section-body.ts";
+export * from "./section-cta.ts";
+export * from "./section-image.ts";
+export * from "./live-photo.ts";
+export * from "./media.ts";
+export * from "./material-credit.ts";
+export * from "./site-background.ts";
+export * from "./section-motion.ts";
+export * from "./print.ts";
+export * from "./claims.ts";
+export * from "./claim-records.ts";
+export * from "./person.ts";
+export * from "./participant.ts";