@warpgogol/werkstatt-shared 0.2.0

package/src/ontology/schemas/system/text.ts

@@ -0,0 +1,58 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Text and semantic page type schemas for the system manifest: defines page type enums and text-related configuration.</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-0303 Phase 3: extracted from schemas/system.ts as part of the domain split.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+/**
+ * The `text.normalize` block in system.yaml (RFC-0235). Controls the egress
+ * adapter that strips AI-authorship typographic signals from public output
+ * (rendered HTML, llms.txt, Markdown twins, feed.xml, sitemap*.xml, JSON-LD,
+ * OG preview text). It is an adapter, not a source rewrite — authored content
+ * is never modified.
+ *
+ * Default-all-on: an absent block, an absent `enabled`, or an absent signal key
+ * all resolve to ON. A site owner disables any single signal here.
+ * CLIENT-WRITABLE.
+ */
+export const systemTextNormalizeSignalsSchema = z
+  .object({
+    /** Special dashes (figure/en/em/horizontal-bar/non-breaking-hyphen/minus) → '-'. */
+    dashes: z.boolean().optional(),
+    /** Curly + guillemet quotes (U+00AB/U+00BB, U+2018–U+201F) → straight " / '. */
+    quotes: z.boolean().optional(),
+    /** Special spaces (nbsp, en/em/thin/hair, narrow-nbsp, ideographic…) → regular space. */
+    spaces: z.boolean().optional(),
+    /** Zero-width / invisible characters (ZWSP, ZWNJ, word-joiner, BOM, soft-hyphen…) → removed. */
+    zeroWidth: z.boolean().optional(),
+    /** Typographic HTML entities (&nbsp; &mdash; &hellip; …) → decoded then char-normalized. */
+    htmlEntities: z.boolean().optional(),
+    /** Single-character ellipsis U+2026 … → three dots '...'. */
+    ellipsis: z.boolean().optional(),
+  })
+  .strict();
+
+export const systemTextNormalizeSchema = z
+  .object({
+    /** Master switch. Absent ⇒ true. */
+    enabled: z.boolean().optional(),
+    /** Per-signal toggles. Each absent key ⇒ true (everything on by default). */
+    signals: systemTextNormalizeSignalsSchema.optional(),
+  })
+  .strict();
+
+export const systemTextSchema = z
+  .object({
+    normalize: systemTextNormalizeSchema.optional(),
+  })
+  .strict();
+
+export type SystemText = z.infer<typeof systemTextSchema>;

package/src/ontology/schemas/system.ts

@@ -0,0 +1,53 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+Zod schema for per-app system.yaml — the top-level manifest that binds a client
+application to a cosmic identity, a single Biome, and an optional set of
+Constellations (DNA-23, RFC-0025). Also declares the growth block (RFC-0027).
+Stored at apps/<app-slug>/system.yaml.
+</purpose>
+<non-goals>
+  <item>Do not parse YAML here; the caller is responsible for parsing.</item>
+  <item>Do not reference app business logic or client-specific content.</item>
+  <item>Do not add rendering logic.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>Wave 1 (RFC-0025): Initial creation.</item>
+  <item>Wave 1 (RFC-0027): Added growth block — vendor adapter binding, active funnels, active experiments.</item>
+  <item>RFC-0328: Added "legal" to semanticPageTypeSchema.</item>
+  <item>RFC-0303 Phase 3: split the flat 822-line file into sub-modules under system/; this file is now the re-export shim.</item>
+</CHANGE_SUMMARY>
+*/
+
+export {
+  systemSharedContextSchema,
+  systemGrowthSchema,
+  growthVendorSchema,
+} from "./system/growth.ts";
+export type { SystemGrowth, GrowthVendor } from "./system/growth.ts";
+
+export { systemPassportSchema, systemReleaseSchema } from "./system/release.ts";
+export type { SystemPassport, SystemRelease } from "./system/release.ts";
+
+export {
+  systemTextNormalizeSignalsSchema,
+  systemTextNormalizeSchema,
+  systemTextSchema,
+} from "./system/text.ts";
+export type { SystemText } from "./system/text.ts";
+
+export { systemIntegrationsSchema } from "./system/integrations.ts";
+export type { SystemIntegrations } from "./system/integrations.ts";
+
+export {
+  semanticPageTypeSchema,
+  articleMetadataSchema,
+  llmsPolicySchema,
+  sitemapProjectionSchema,
+  robotsProjectionSchema,
+  pageOutputSchema,
+} from "./system/page-output.ts";
+
+export { systemManifestSchema } from "./system/manifest.ts";
+export type { SystemManifest, SystemPagePin, SystemPlanetPin } from "./system/manifest.ts";

package/src/ontology/shared-section-props/body-fragments.ts

@@ -0,0 +1,182 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Body kind JSON Schema fragments for RFC-0103: one fragment per body kind (list, split-list, stats, cards, paragraphs, comparison, rich) that adds the entire body object at section root.</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-0303 Phase 3: extracted from shared-section-props/index.ts as part of the domain split.</item>
+</CHANGE_SUMMARY>
+*/
+
+import {
+  STANDARD_LIST_ITEM_SCHEMA,
+  STANDARD_CARD_SCHEMA,
+  STAT_ITEM_SCHEMA,
+  ALIGN_ENUM,
+  ICON_COLOR_ENUM,
+  EFFECTS_ARRAY_SCHEMA,
+  type JsonSchemaFragment,
+} from "./common.ts";
+
+/** RFC-0103 — body.kind: "list". */
+export const BODY_LIST_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "items"],
+      properties: {
+        kind: { const: "list" },
+        items: { type: "array", minItems: 1, items: STANDARD_LIST_ITEM_SCHEMA },
+        note: { type: "string" },
+        iconColor: ICON_COLOR_ENUM,
+        align: ALIGN_ENUM,
+        effects: EFFECTS_ARRAY_SCHEMA,
+      },
+    },
+  },
+};
+
+/** RFC-0103 — body.kind: "split-list". */
+export const BODY_SPLIT_LIST_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "primaryItems"],
+      properties: {
+        kind: { const: "split-list" },
+        primaryItems: { type: "array", minItems: 1, items: STANDARD_LIST_ITEM_SCHEMA },
+        secondaryItems: { type: "array", items: STANDARD_LIST_ITEM_SCHEMA },
+        labels: {
+          type: "object",
+          additionalProperties: false,
+          required: ["primary", "secondary"],
+          properties: {
+            primary: { type: "string", minLength: 1 },
+            secondary: { type: "string", minLength: 1 },
+          },
+        },
+        iconColors: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            primary: ICON_COLOR_ENUM,
+            secondary: ICON_COLOR_ENUM,
+          },
+        },
+        align: ALIGN_ENUM,
+        effects: EFFECTS_ARRAY_SCHEMA,
+      },
+    },
+  },
+};
+
+/** RFC-0103 — body.kind: "stats". */
+export const BODY_STATS_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "stats"],
+      properties: {
+        kind: { const: "stats" },
+        stats: { type: "array", minItems: 1, items: STAT_ITEM_SCHEMA },
+        animated: { type: "boolean" },
+        align: ALIGN_ENUM,
+      },
+    },
+  },
+};
+
+/** RFC-0103 — body.kind: "cards". */
+export const BODY_CARDS_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "cards"],
+      properties: {
+        kind: { const: "cards" },
+        cards: { type: "array", minItems: 1, items: STANDARD_CARD_SCHEMA },
+        layout: { enum: ["grid", "list"] },
+        columns: { enum: [2, 3, 4] },
+        align: ALIGN_ENUM,
+        effects: EFFECTS_ARRAY_SCHEMA,
+      },
+    },
+  },
+};
+
+/** RFC-0103 — body.kind: "paragraphs". */
+export const BODY_PARAGRAPHS_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "paragraphs"],
+      properties: {
+        kind: { const: "paragraphs" },
+        paragraphs: { type: "array", minItems: 1, items: { type: "string", minLength: 1 } },
+        align: ALIGN_ENUM,
+      },
+    },
+  },
+};
+
+/** RFC-0103 — body.kind: "comparison". */
+export const BODY_COMPARISON_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "rows"],
+      properties: {
+        kind: { const: "comparison" },
+        rows: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["left", "right"],
+            properties: {
+              left: { type: "string", minLength: 1 },
+              right: { type: "string", minLength: 1 },
+            },
+          },
+        },
+        labels: {
+          type: "object",
+          additionalProperties: false,
+          required: ["left", "right"],
+          properties: {
+            left: { type: "string", minLength: 1 },
+            right: { type: "string", minLength: 1 },
+          },
+        },
+        align: ALIGN_ENUM,
+        effects: EFFECTS_ARRAY_SCHEMA,
+      },
+    },
+  },
+};
+
+/** RFC-0103 — body.kind: "rich". */
+export const BODY_RICH_FRAGMENT: JsonSchemaFragment = {
+  properties: {
+    body: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "contentRef"],
+      properties: {
+        kind: { const: "rich" },
+        contentRef: { type: "string", minLength: 1 },
+        animateNumbers: { type: "boolean" },
+        align: ALIGN_ENUM,
+      },
+    },
+  },
+};

package/src/ontology/shared-section-props/catalog.ts

@@ -0,0 +1,195 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Catalog and composition helpers for shared section prop fragments: defines SHARED_SECTION_PROPS catalog with versioned fragments and provides resolution/changelog/composition functions.</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-0303 Phase 3: extracted from shared-section-props/index.ts as part of the domain split.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { JsonSchemaFragment } from "./common.ts";
+import { SECTION_VISUAL_FRAGMENT, SECTION_HEADER_FRAGMENT } from "./visual-header.ts";
+import {
+  BODY_LIST_FRAGMENT,
+  BODY_SPLIT_LIST_FRAGMENT,
+  BODY_STATS_FRAGMENT,
+  BODY_CARDS_FRAGMENT,
+  BODY_PARAGRAPHS_FRAGMENT,
+  BODY_COMPARISON_FRAGMENT,
+  BODY_RICH_FRAGMENT,
+} from "./body-fragments.ts";
+
+// RFC-0119: every fragment carries `schemaVersion: number` (starts at 1) and
+// optional `changelog`. The catalog stores versions under `latest` and
+// optionally `prior` so consumers can pin to the prior shape during a
+// migration window. Bare ids (without `@version`) resolve to `latest`.
+
+type FragmentVersion = JsonSchemaFragment & {
+  schemaVersion: number;
+  changelog?: string;
+};
+
+type FragmentEntry = {
+  latest: FragmentVersion;
+  prior?: FragmentVersion;
+};
+
+function v1(fragment: JsonSchemaFragment, changelog: string): FragmentVersion {
+  return { schemaVersion: 1, ...fragment, changelog };
+}
+
+export const SHARED_SECTION_PROPS: Record<string, FragmentEntry> = {
+  "section-visual": {
+    latest: v1(
+      SECTION_VISUAL_FRAGMENT,
+      "Initial release with background, effects, density, tone, containerVariant, motion.",
+    ),
+  },
+  "section-header": {
+    latest: v1(
+      SECTION_HEADER_FRAGMENT,
+      "Heading (string or tone-segmented array), eyebrow, subheading, align, level, hideSectionNumber. RFC-0567 added eyebrow.",
+    ),
+  },
+  "body-list": {
+    latest: v1(
+      BODY_LIST_FRAGMENT,
+      "Initial release of body.kind: list with items + note + iconColor + align + effects.",
+    ),
+  },
+  "body-split-list": {
+    latest: v1(
+      BODY_SPLIT_LIST_FRAGMENT,
+      "Initial release of body.kind: split-list with primary/secondary items, labels, iconColors + effects.",
+    ),
+  },
+  "body-stats": {
+    latest: v1(
+      BODY_STATS_FRAGMENT,
+      "Initial release of body.kind: stats with stats[] + animated + align.",
+    ),
+  },
+  "body-cards": {
+    latest: v1(
+      BODY_CARDS_FRAGMENT,
+      "Initial release of body.kind: cards with cards[] + layout + columns + align + effects. Added optional number field to cards for numbered lists.",
+    ),
+  },
+  "body-paragraphs": {
+    latest: v1(
+      BODY_PARAGRAPHS_FRAGMENT,
+      "Initial release of body.kind: paragraphs with paragraphs[] + align.",
+    ),
+  },
+  "body-comparison": {
+    latest: v1(
+      BODY_COMPARISON_FRAGMENT,
+      "Initial release of body.kind: comparison with rows + labels + align + effects.",
+    ),
+  },
+  "body-rich": {
+    latest: v1(
+      BODY_RICH_FRAGMENT,
+      "Initial release of body.kind: rich with contentRef + animateNumbers + align.",
+    ),
+  },
+};
+
+export type SharedSectionPropsId = keyof typeof SHARED_SECTION_PROPS;
+
+/** RFC-0119: pinned reference syntax `<id>@<version>` or bare `<id>` (latest). */
+export type SharedSectionPropsRef = string;
+
+export function isSharedSectionPropsId(id: string): id is SharedSectionPropsId {
+  const baseId = id.split("@")[0];
+  return Object.prototype.hasOwnProperty.call(SHARED_SECTION_PROPS, baseId);
+}
+
+/**
+ * RFC-0119: resolve a fragment reference (`<id>` or `<id>@<version>`) to the
+ * matching fragment payload. Unknown ids or pinned versions raise with the
+ * catalog of valid ids in the message.
+ */
+function resolveFragment(ref: string): FragmentVersion {
+  const [baseId, pinned] = ref.split("@");
+  const entry = SHARED_SECTION_PROPS[baseId];
+  if (!entry) {
+    throw new Error(
+      `[shared-section-props] Unknown fragment id "${baseId}". ` +
+        `Valid ids: ${Object.keys(SHARED_SECTION_PROPS).join(", ")}`,
+    );
+  }
+  if (!pinned) return entry.latest;
+  const pinnedVersion = Number.parseInt(pinned, 10);
+  if (Number.isNaN(pinnedVersion)) {
+    throw new Error(`[shared-section-props] Invalid pinned version "${pinned}" on "${baseId}".`);
+  }
+  if (entry.latest.schemaVersion === pinnedVersion) return entry.latest;
+  if (entry.prior?.schemaVersion === pinnedVersion) return entry.prior;
+  throw new Error(
+    `[shared-section-props] Fragment "${baseId}" version ${pinnedVersion} not available ` +
+      `(latest: ${entry.latest.schemaVersion}${entry.prior ? `, prior: ${entry.prior.schemaVersion}` : ""}).`,
+  );
+}
+
+/**
+ * RFC-0119: machine-readable changelog snapshot. Used by
+ * shared.section-props.changelog.report.
+ */
+export function sharedSectionPropsChangelog(): Array<{
+  id: string;
+  schemaVersion: number;
+  changelog?: string;
+}> {
+  return Object.entries(SHARED_SECTION_PROPS).map(([id, entry]) => ({
+    id,
+    schemaVersion: entry.latest.schemaVersion,
+    changelog: entry.latest.changelog,
+  }));
+}
+
+/**
+ * Compose fragments + the manifest's local propsSchema into one draft-07
+ * JSON Schema object. Properties of later inputs override earlier ones;
+ * `additionalProperties: false` is enforced unless the manifest explicitly
+ * opts out. Fragment ids accept both `<id>` and `<id>@<version>` forms
+ * (RFC-0119).
+ */
+export function composeManifestPropsSchema(input: {
+  compose?: readonly string[];
+  local?: Record<string, unknown>;
+}): Record<string, unknown> {
+  const properties: Record<string, unknown> = {};
+  const required = new Set<string>();
+
+  for (const ref of input.compose ?? []) {
+    const frag = resolveFragment(ref);
+    Object.assign(properties, frag.properties);
+    for (const r of frag.required ?? []) required.add(r);
+  }
+
+  if (input.local) {
+    const localProps = (input.local.properties as Record<string, unknown> | undefined) ?? {};
+    Object.assign(properties, localProps);
+    const localRequired = Array.isArray(input.local.required)
+      ? (input.local.required as string[])
+      : [];
+    for (const r of localRequired) required.add(r);
+  }
+
+  const additionalProperties =
+    input.local && Object.prototype.hasOwnProperty.call(input.local, "additionalProperties")
+      ? input.local.additionalProperties
+      : false;
+
+  const result: Record<string, unknown> = {
+    type: "object",
+    additionalProperties,
+    properties,
+  };
+  if (required.size > 0) result.required = Array.from(required);
+  return result;
+}

package/src/ontology/shared-section-props/common.ts

@@ -0,0 +1,178 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Shared types and reusable JSON Schema building blocks for section prop fragments: standard list items, cards, stats, enums, and effect stack items.</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-0303 Phase 3: extracted from shared-section-props/index.ts as part of the domain split.</item>
+</CHANGE_SUMMARY>
+*/
+
+export type JsonSchemaFragment = {
+  properties: Record<string, unknown>;
+  required?: string[];
+};
+
+export const STANDARD_LIST_ITEM_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["text"],
+  properties: {
+    text: { type: "string", minLength: 1 },
+    icon: {
+      type: "object",
+      additionalProperties: false,
+      required: ["vendor", "collection", "name"],
+      properties: {
+        vendor: { type: "string" },
+        collection: { type: "string" },
+        name: { type: "string" },
+        size: { type: "number" },
+      },
+    },
+  },
+};
+
+export const STANDARD_CARD_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["title"],
+  properties: {
+    title: { type: "string", minLength: 1 },
+    description: { type: "string" },
+    image: { type: "string" },
+    imageAlt: { type: "string" },
+    icon: {
+      type: "object",
+      additionalProperties: false,
+      required: ["vendor", "collection", "name"],
+      properties: {
+        vendor: { type: "string" },
+        collection: { type: "string" },
+        name: { type: "string" },
+        size: { type: "number" },
+      },
+    },
+    href: { type: "string" },
+    badge: { type: "string" },
+    number: { type: "string" },
+  },
+};
+
+export const STAT_ITEM_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["value", "label"],
+  properties: {
+    value: { type: "string", minLength: 1 },
+    label: { type: "string", minLength: 1 },
+    numericValue: { type: "number" },
+    prefix: { type: "string" },
+    suffix: { type: "string" },
+    decimals: { type: "number", minimum: 0 },
+    duration: { type: "number", minimum: 0.1 },
+  },
+};
+
+export const ALIGN_ENUM = { type: "string", enum: ["left", "center", "right"] };
+export const ICON_COLOR_ENUM = {
+  type: "string",
+  enum: ["primary", "accent", "success", "warning", "error", "muted"],
+};
+
+export const EFFECT_COLOR_SCHEMA = { type: "string", minLength: 1 };
+
+/**
+ * RFC-0134 + RFC-0151 — one effect stack item is a discriminated union over
+ * every supported effect kind. Target × kind admissibility (e.g. glass only on
+ * surfaces, text kinds only on `heading`) is enforced by effects.contract.validate,
+ * not by this shape schema. Mirrors packages/share/src/schemas/effects.ts.
+ */
+export const EFFECT_STACK_ITEM_SCHEMA = {
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "enabled"],
+      properties: {
+        kind: { const: "glass" },
+        enabled: { type: "boolean" },
+        blur: { type: "number", minimum: 0, maximum: 64 },
+        saturate: { type: "number", minimum: 0, maximum: 400 },
+        tint: { type: "string", minLength: 1 },
+        tintOpacity: { type: "number", minimum: 0, maximum: 1 },
+        border: { enum: ["hairline", "none"] },
+      },
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "enabled"],
+      properties: {
+        kind: { const: "shadow" },
+        enabled: { type: "boolean" },
+        offsetX: { type: "number", minimum: -64, maximum: 64 },
+        offsetY: { type: "number", minimum: -64, maximum: 64 },
+        blur: { type: "number", minimum: 0, maximum: 64 },
+        color: EFFECT_COLOR_SCHEMA,
+        opacity: { type: "number", minimum: 0, maximum: 1 },
+      },
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "enabled"],
+      properties: {
+        kind: { const: "glow" },
+        enabled: { type: "boolean" },
+        blur: { type: "number", minimum: 0, maximum: 96 },
+        color: EFFECT_COLOR_SCHEMA,
+        opacity: { type: "number", minimum: 0, maximum: 1 },
+      },
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "enabled"],
+      properties: {
+        kind: { const: "bulge" },
+        enabled: { type: "boolean" },
+        depth: { type: "number", minimum: 0, maximum: 16 },
+        highlight: { type: "number", minimum: 0, maximum: 1 },
+        shade: { type: "number", minimum: 0, maximum: 1 },
+      },
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "enabled"],
+      properties: {
+        kind: { const: "tilt" },
+        enabled: { type: "boolean" },
+        rotate: { type: "number", minimum: -15, maximum: 15 },
+        skewX: { type: "number", minimum: -15, maximum: 15 },
+      },
+    },
+  ],
+};
+
+/** Shared effects array schema used by multiple body fragments. */
+export const EFFECTS_ARRAY_SCHEMA = {
+  type: "array",
+  minItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["target", "stack"],
+    properties: {
+      target: { type: "string", minLength: 1 },
+      stack: {
+        type: "array",
+        minItems: 1,
+        items: EFFECT_STACK_ITEM_SCHEMA,
+      },
+    },
+  },
+};

package/src/ontology/shared-section-props/index.ts

@@ -0,0 +1,34 @@
+/*
+<MODULE_CONTRACT>
+<purpose>
+[RFC-0101 + RFC-0102 + RFC-0103] Canonical catalog of JSON Schema fragments
+that section manifests compose via the `propsSchemaCompose: [...]` field.
+
+Two families of fragments:
+  - section-visual / section-header — visual + header sub-schemas applied
+    at section root.
+  - body-{kind} — one fragment per RFC-0103 body kind that adds the entire
+    `body: { kind: ..., ... }` object at section root.
+
+Section manifests reference these by id instead of duplicating the same 60+
+lines of JSON Schema in every file.
+</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>
+  <item>RFC-0303 Phase 3: split the flat 719-line file into sub-modules; this file is now the re-export shim.</item>
+</CHANGE_SUMMARY>
+*/
+
+export type { JsonSchemaFragment } from "./common.ts";
+
+export {
+  SHARED_SECTION_PROPS,
+  isSharedSectionPropsId,
+  sharedSectionPropsChangelog,
+  composeManifestPropsSchema,
+} from "./catalog.ts";
+export type { SharedSectionPropsId, SharedSectionPropsRef } from "./catalog.ts";