@wildo-ai/saas-website 1.1.1

package/dist/esm/schemas/refs/section-ref.schemas.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+/**
+ * @wildo_source:part:start saas.website.refs.section facet:layer:shared facet:family:website
+ *
+ * `WebsiteSectionRef` — branded kebab-case identifier for one section on a
+ * page (e.g. `'hero'`, `'social-proof'`, `'pricing-teaser'`, `'final-cta'`).
+ *
+ * The section ref is the **section-level structural identity**:
+ *
+ * 1. **Label-key root**: every label leaf consumed inside a section is
+ *    rooted at `website.<pageRef>.<sectionRef>.<slot>`. The hook
+ *    `useWebsiteLabel('headline')` (Phase 2) reads `WebsiteSectionContext`
+ *    to derive the full key; the section author never types the page or
+ *    section ref into a label call.
+ * 2. **Page manifest contract**: `WebsitePageManifest.sectionRefs[]`
+ *    declares the refs the page commits to. The label-pack validator
+ *    cross-references the manifest's declared refs against the actual
+ *    sections rendered, surfacing mismatches at build start.
+ * 3. **DOM landmark**: `<WebsiteSection ref="…">` (Phase 2) emits
+ *    `<section data-section-ref="…">` so analytics, scroll-tracking, and
+ *    automated audits can identify sections without parsing class names.
+ *
+ * **Format**: lowercase ASCII letters, digits and `-`. Must start with a
+ * letter. 1–64 characters. Same shape as `WebsitePageRef` for consistency
+ * across both ref scopes.
+ *
+ * **Why a brand**: same reasoning as `WebsitePageRef`. The two refs are
+ * structurally identical strings but semantically distinct — branding
+ * prevents accidental swaps between page-level and section-level APIs at
+ * compile time.
+ *
+ * @example
+ *   const heroRef = WebsiteSectionRefSchema.parse('hero');
+ *   const ctaRef = WebsiteSectionRefSchema.parse('final-cta');
+ */
+const _WebsiteSectionRefSchema = z
+    .string()
+    .min(1, { error: 'WebsiteSectionRef must be at least 1 character' })
+    .max(64, { error: 'WebsiteSectionRef must be at most 64 characters' })
+    .regex(/^[a-z][a-z0-9-]*$/, { error: 'WebsiteSectionRef must be lowercase kebab-case starting with a letter (e.g. "hero", "social-proof")' })
+    .brand();
+export const WebsiteSectionRefSchema = _WebsiteSectionRefSchema;
+/** @wildo_source:part:end saas.website.refs.section */
+//# sourceMappingURL=section-ref.schemas.js.map

package/dist/esm/schemas/refs/section-ref.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"section-ref.schemas.js","sourceRoot":"","sources":["../../../../../src/schemas/refs/section-ref.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,wBAAwB,GAAG,CAAC;KAC/B,MAAM,EAAE;KACR,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,gDAAgD,EAAE,CAAC;KACnE,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,iDAAiD,EAAE,CAAC;KACrE,KAAK,CACJ,mBAAmB,EACnB,EAAE,KAAK,EAAE,qGAAqG,EAAE,CACjH;KACA,KAAK,EAAuB,CAAC;AAEhC,MAAM,CAAC,MAAM,uBAAuB,GAAoC,wBAAwB,CAAC;AAGjG,uDAAuD","sourcesContent":["import { z } from 'zod';\n\n/**\n * @wildo_source:part:start saas.website.refs.section facet:layer:shared facet:family:website\n *\n * `WebsiteSectionRef` — branded kebab-case identifier for one section on a\n * page (e.g. `'hero'`, `'social-proof'`, `'pricing-teaser'`, `'final-cta'`).\n *\n * The section ref is the **section-level structural identity**:\n *\n * 1. **Label-key root**: every label leaf consumed inside a section is\n *    rooted at `website.<pageRef>.<sectionRef>.<slot>`. The hook\n *    `useWebsiteLabel('headline')` (Phase 2) reads `WebsiteSectionContext`\n *    to derive the full key; the section author never types the page or\n *    section ref into a label call.\n * 2. **Page manifest contract**: `WebsitePageManifest.sectionRefs[]`\n *    declares the refs the page commits to. The label-pack validator\n *    cross-references the manifest's declared refs against the actual\n *    sections rendered, surfacing mismatches at build start.\n * 3. **DOM landmark**: `<WebsiteSection ref=\"…\">` (Phase 2) emits\n *    `<section data-section-ref=\"…\">` so analytics, scroll-tracking, and\n *    automated audits can identify sections without parsing class names.\n *\n * **Format**: lowercase ASCII letters, digits and `-`. Must start with a\n * letter. 1–64 characters. Same shape as `WebsitePageRef` for consistency\n * across both ref scopes.\n *\n * **Why a brand**: same reasoning as `WebsitePageRef`. The two refs are\n * structurally identical strings but semantically distinct — branding\n * prevents accidental swaps between page-level and section-level APIs at\n * compile time.\n *\n * @example\n *   const heroRef = WebsiteSectionRefSchema.parse('hero');\n *   const ctaRef = WebsiteSectionRefSchema.parse('final-cta');\n */\nconst _WebsiteSectionRefSchema = z\n  .string()\n  .min(1, { error: 'WebsiteSectionRef must be at least 1 character' })\n  .max(64, { error: 'WebsiteSectionRef must be at most 64 characters' })\n  .regex(\n    /^[a-z][a-z0-9-]*$/,\n    { error: 'WebsiteSectionRef must be lowercase kebab-case starting with a letter (e.g. \"hero\", \"social-proof\")' },\n  )\n  .brand<'WebsiteSectionRef'>();\n\nexport const WebsiteSectionRefSchema: typeof _WebsiteSectionRefSchema = _WebsiteSectionRefSchema;\n\nexport type WebsiteSectionRef = z.infer<typeof _WebsiteSectionRefSchema>;\n/** @wildo_source:part:end saas.website.refs.section */\n"]}

package/dist/esm/schemas/sections/website-section-category.shared.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+/**
+ * @wildo_source:part:start saas.website.sections.category-enum facet:layer:shared facet:family:website
+ *
+ * `WebsiteSectionCategory` — closed vocabulary tagging the **structural
+ * intent** of a section.
+ *
+ * The category is NOT a layout-shape constraint and NOT a CSS class; the
+ * framework ships zero concrete sections and never inspects
+ * the category at render time. The category exists for three orthogonal
+ * non-render concerns:
+ *
+ * 1. **Structured-data dispatch**: the
+ *    SEO library reads `WebsiteSectionDefinition.category` to decide
+ *    which JSON-LD vocabulary the section's `getStructuredData()` hook
+ *    is allowed to emit. e.g. `PRICING` may emit `Product` /
+ *    `AggregateOffer`; `FAQ` may emit `FAQPage`; `HERO` may emit
+ *    `Organization` / `WebSite`. Mismatches are surfaced as build-time
+ *    warnings.
+ * 2. **Authoring guidance**: each value has matching application-builder
+ *    guidance. When introducing a new category, provide its public authoring
+ *    method before asking an application to use it.
+ * 3. **Analytics labelling**: the runtime emits
+ *    `data-section-category="…"` on the `<WebsiteSection>` wrapper so
+ *    analytics tooling can group section impressions
+ *    without parsing className conventions.
+ *
+ * **Closed vocabulary on purpose**: a free-string `category` would
+ * defeat the skill-mapping and SEO-dispatch contracts. Consumers who
+ * need a wholly-novel section shape use the `RAW` advanced path
+ * (`website-factory-advanced` skill) which bypasses the category
+ * vocabulary entirely.
+ *
+ * **Adding a value**: requires (a) a new entry here, (b) a matching
+ * `website_section_<value>` skill stub, (c) (optionally) a
+ * structured-data dispatch entry in the SEO library. Removing a value
+ * is a labelled rename — every consumer's
+ * `defineWebsiteSection({ category: … })` declaration breaks at compile
+ * time, which is the desired loud failure.
+ */
+export declare enum WebsiteSectionCategory {
+    HERO = "hero",
+    CTA = "cta",
+    FEATURE_BENEFIT_SUMMARY = "feature-benefit-summary",
+    FEATURE_DETAIL = "feature-detail",
+    PRICING = "pricing",
+    CONTACT = "contact",
+    SOCIAL_PROOF = "social-proof",
+    FAQ = "faq",
+    FOOTER_CTA = "footer-cta",
+    /**
+     * Escape hatch for sections that don't fit any standard category
+     * (third-party widgets, custom one-off marketing pieces). Skips the
+     * SEO-dispatch contract — the section's `getStructuredData()` may
+     * return any vocabulary, no validation. Authors should prefer a
+     * concrete category whenever possible; using `RAW` opts the section
+     * out of the framework's structured-data safety net.
+     */
+    RAW = "raw"
+}
+export declare const WebsiteSectionCategorySchema: z.ZodEnum<typeof WebsiteSectionCategory>;
+/** @wildo_source:part:end saas.website.sections.category-enum */
+//# sourceMappingURL=website-section-category.shared.d.ts.map

package/dist/esm/schemas/sections/website-section-category.shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-section-category.shared.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/sections/website-section-category.shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,oBAAY,sBAAsB;IAChC,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,uBAAuB,4BAA4B;IACnD,cAAc,mBAAmB;IACjC,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,GAAG,QAAQ;IACX,UAAU,eAAe;IACzB;;;;;;;OAOG;IACH,GAAG,QAAQ;CACZ;AAED,eAAO,MAAM,4BAA4B,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,sBAAsB,CAClD,CAAC;AACjC,iEAAiE"}

package/dist/esm/schemas/sections/website-section-category.shared.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+/**
+ * @wildo_source:part:start saas.website.sections.category-enum facet:layer:shared facet:family:website
+ *
+ * `WebsiteSectionCategory` — closed vocabulary tagging the **structural
+ * intent** of a section.
+ *
+ * The category is NOT a layout-shape constraint and NOT a CSS class; the
+ * framework ships zero concrete sections and never inspects
+ * the category at render time. The category exists for three orthogonal
+ * non-render concerns:
+ *
+ * 1. **Structured-data dispatch**: the
+ *    SEO library reads `WebsiteSectionDefinition.category` to decide
+ *    which JSON-LD vocabulary the section's `getStructuredData()` hook
+ *    is allowed to emit. e.g. `PRICING` may emit `Product` /
+ *    `AggregateOffer`; `FAQ` may emit `FAQPage`; `HERO` may emit
+ *    `Organization` / `WebSite`. Mismatches are surfaced as build-time
+ *    warnings.
+ * 2. **Authoring guidance**: each value has matching application-builder
+ *    guidance. When introducing a new category, provide its public authoring
+ *    method before asking an application to use it.
+ * 3. **Analytics labelling**: the runtime emits
+ *    `data-section-category="…"` on the `<WebsiteSection>` wrapper so
+ *    analytics tooling can group section impressions
+ *    without parsing className conventions.
+ *
+ * **Closed vocabulary on purpose**: a free-string `category` would
+ * defeat the skill-mapping and SEO-dispatch contracts. Consumers who
+ * need a wholly-novel section shape use the `RAW` advanced path
+ * (`website-factory-advanced` skill) which bypasses the category
+ * vocabulary entirely.
+ *
+ * **Adding a value**: requires (a) a new entry here, (b) a matching
+ * `website_section_<value>` skill stub, (c) (optionally) a
+ * structured-data dispatch entry in the SEO library. Removing a value
+ * is a labelled rename — every consumer's
+ * `defineWebsiteSection({ category: … })` declaration breaks at compile
+ * time, which is the desired loud failure.
+ */
+export var WebsiteSectionCategory;
+(function (WebsiteSectionCategory) {
+    WebsiteSectionCategory["HERO"] = "hero";
+    WebsiteSectionCategory["CTA"] = "cta";
+    WebsiteSectionCategory["FEATURE_BENEFIT_SUMMARY"] = "feature-benefit-summary";
+    WebsiteSectionCategory["FEATURE_DETAIL"] = "feature-detail";
+    WebsiteSectionCategory["PRICING"] = "pricing";
+    WebsiteSectionCategory["CONTACT"] = "contact";
+    WebsiteSectionCategory["SOCIAL_PROOF"] = "social-proof";
+    WebsiteSectionCategory["FAQ"] = "faq";
+    WebsiteSectionCategory["FOOTER_CTA"] = "footer-cta";
+    /**
+     * Escape hatch for sections that don't fit any standard category
+     * (third-party widgets, custom one-off marketing pieces). Skips the
+     * SEO-dispatch contract — the section's `getStructuredData()` may
+     * return any vocabulary, no validation. Authors should prefer a
+     * concrete category whenever possible; using `RAW` opts the section
+     * out of the framework's structured-data safety net.
+     */
+    WebsiteSectionCategory["RAW"] = "raw";
+})(WebsiteSectionCategory || (WebsiteSectionCategory = {}));
+export const WebsiteSectionCategorySchema = z.enum(WebsiteSectionCategory);
+/** @wildo_source:part:end saas.website.sections.category-enum */
+//# sourceMappingURL=website-section-category.shared.js.map

package/dist/esm/schemas/sections/website-section-category.shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-section-category.shared.js","sourceRoot":"","sources":["../../../../../src/schemas/sections/website-section-category.shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAN,IAAY,sBAmBX;AAnBD,WAAY,sBAAsB;IAChC,uCAAa,CAAA;IACb,qCAAW,CAAA;IACX,6EAAmD,CAAA;IACnD,2DAAiC,CAAA;IACjC,6CAAmB,CAAA;IACnB,6CAAmB,CAAA;IACnB,uDAA6B,CAAA;IAC7B,qCAAW,CAAA;IACX,mDAAyB,CAAA;IACzB;;;;;;;OAOG;IACH,qCAAW,CAAA;AACb,CAAC,EAnBW,sBAAsB,KAAtB,sBAAsB,QAmBjC;AAED,MAAM,CAAC,MAAM,4BAA4B,GACvC,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;AACjC,iEAAiE","sourcesContent":["import { z } from 'zod';\n\n/**\n * @wildo_source:part:start saas.website.sections.category-enum facet:layer:shared facet:family:website\n *\n * `WebsiteSectionCategory` — closed vocabulary tagging the **structural\n * intent** of a section.\n *\n * The category is NOT a layout-shape constraint and NOT a CSS class; the\n * framework ships zero concrete sections and never inspects\n * the category at render time. The category exists for three orthogonal\n * non-render concerns:\n *\n * 1. **Structured-data dispatch**: the\n *    SEO library reads `WebsiteSectionDefinition.category` to decide\n *    which JSON-LD vocabulary the section's `getStructuredData()` hook\n *    is allowed to emit. e.g. `PRICING` may emit `Product` /\n *    `AggregateOffer`; `FAQ` may emit `FAQPage`; `HERO` may emit\n *    `Organization` / `WebSite`. Mismatches are surfaced as build-time\n *    warnings.\n * 2. **Authoring guidance**: each value has matching application-builder\n *    guidance. When introducing a new category, provide its public authoring\n *    method before asking an application to use it.\n * 3. **Analytics labelling**: the runtime emits\n *    `data-section-category=\"…\"` on the `<WebsiteSection>` wrapper so\n *    analytics tooling can group section impressions\n *    without parsing className conventions.\n *\n * **Closed vocabulary on purpose**: a free-string `category` would\n * defeat the skill-mapping and SEO-dispatch contracts. Consumers who\n * need a wholly-novel section shape use the `RAW` advanced path\n * (`website-factory-advanced` skill) which bypasses the category\n * vocabulary entirely.\n *\n * **Adding a value**: requires (a) a new entry here, (b) a matching\n * `website_section_<value>` skill stub, (c) (optionally) a\n * structured-data dispatch entry in the SEO library. Removing a value\n * is a labelled rename — every consumer's\n * `defineWebsiteSection({ category: … })` declaration breaks at compile\n * time, which is the desired loud failure.\n */\nexport enum WebsiteSectionCategory {\n  HERO = 'hero',\n  CTA = 'cta',\n  FEATURE_BENEFIT_SUMMARY = 'feature-benefit-summary',\n  FEATURE_DETAIL = 'feature-detail',\n  PRICING = 'pricing',\n  CONTACT = 'contact',\n  SOCIAL_PROOF = 'social-proof',\n  FAQ = 'faq',\n  FOOTER_CTA = 'footer-cta',\n  /**\n   * Escape hatch for sections that don't fit any standard category\n   * (third-party widgets, custom one-off marketing pieces). Skips the\n   * SEO-dispatch contract — the section's `getStructuredData()` may\n   * return any vocabulary, no validation. Authors should prefer a\n   * concrete category whenever possible; using `RAW` opts the section\n   * out of the framework's structured-data safety net.\n   */\n  RAW = 'raw',\n}\n\nexport const WebsiteSectionCategorySchema: z.ZodEnum<typeof WebsiteSectionCategory> =\n  z.enum(WebsiteSectionCategory);\n/** @wildo_source:part:end saas.website.sections.category-enum */\n"]}

package/dist/esm/schemas/sections/website-section-definition.shared.schemas.d.ts

@@ -0,0 +1,114 @@
+import type { ComponentType } from 'react';
+import { z } from 'zod';
+import type { WebsiteStructuredDataReturn } from '../structured-data/website-structured-data.shared.schemas';
+/**
+ * @wildo_source:part:start saas.website.sections.definition-schema facet:layer:shared facet:family:website
+ *
+ * `WebsiteSectionDefinition` — the runtime contract returned by the
+ * `defineWebsiteSection({ … })` factory (authored as a separate
+ * `core/define-website-section.tsx` module in Phase 2 because it carries
+ * React types in its inputs). The shape is declared in `schemas/`
+ * because it is the **observable contract** the page-manifest
+ * registration, label-pack validator, and SEO dispatcher depend on.
+ *
+ * **Shape rationale** (each field carries semantic weight — see
+ * `design-philosophy.mdc`):
+ *
+ * - `sectionRef` — the section's identity inside its hosting page.
+ *   Uniqueness is enforced **per page** at manifest registration time
+ *   (a section can be reused with the same `sectionRef` across pages
+ *   when its label-key root is intentionally shared).
+ * - `category` — see `WebsiteSectionCategory` JSDoc; tags the section
+ *   for SEO-dispatch, skill-mapping, and analytics labelling.
+ * - `expectedLabelKeys` — the **fully-composed** label keys the section
+ *   commits to consuming. The plan originally proposed leaf-relative
+ *   keys (`'headline'`) resolved at runtime against the
+ *   page+section context, but storing the fully-composed key on the
+ *   definition has three concrete benefits:
+ *     1. The label-pack validator (`validateLabelPackAgainstManifest`)
+ *        runs as a pure function with no need to walk the JSX tree at
+ *        build time to discover the leaf-to-key resolution.
+ *     2. The contract is auditable from outside the React render
+ *        graph — `wildo website audit` can list a page's required keys
+ *        without booting React.
+ *     3. The leaf-relative ergonomics (`useWebsiteLabel('headline')`)
+ *        survive in Phase 2 — the hook composes the leaf with the
+ *        page+section context and validates the result against
+ *        `expectedLabelKeys`.
+ * - `Component` — the React component that renders the section. Typed
+ *   as `ComponentType<unknown>` here because schema-layer cannot lock
+ *   the component's prop shape (props vary per section). The factory
+ *   function (`defineWebsiteSection<TProps>(…)`) preserves the precise
+ *   prop type at the consumer call site via generics; this schema only
+ *   guards the runtime shape of "is callable as a React component".
+ * - `getStructuredData?` — optional pure function the SEO/AEO/GEO
+ *   builder library invokes at static-build time to materialize JSON-LD
+ *   for the section. The return type is intentionally `unknown` here;
+ *   the SEO library narrows by `category` (e.g. `PRICING` →
+ *   `Product | AggregateOffer`).
+ *
+ * **Why not `z.custom<ComponentType>(…)`**: a `z.custom` predicate
+ * cannot meaningfully validate "is a React component" beyond
+ * `typeof === 'function'`, and the false-positive cost (any function
+ * passes) is too high for the value (none — the consumer either
+ * imports a real component or fails at JSX render time with a clearer
+ * error). Using `z.unknown()` + a TS-side type cast keeps the runtime
+ * cost zero and the type-safety contract entirely on the TS side
+ * (where it actually has teeth via the factory's generic).
+ */
+declare const _WebsiteSectionDefinitionSchema: z.ZodObject<{
+    sectionRef: z.core.$ZodBranded<z.ZodString, "WebsiteSectionRef", "out">;
+    category: z.ZodEnum<typeof import("./website-section-category.shared").WebsiteSectionCategory>;
+    expectedLabelKeys: z.ZodReadonly<z.ZodArray<z.core.$ZodBranded<z.ZodString, "WebsiteLabelKey", "out">>>;
+    Component: z.ZodUnknown;
+    getStructuredData: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const WebsiteSectionDefinitionSchema: typeof _WebsiteSectionDefinitionSchema;
+/**
+ * Runtime shape of `WebsiteSectionDefinition`. Note: `Component` and
+ * `getStructuredData` are typed precisely on the factory return type
+ * (`defineWebsiteSection<TProps>` in Phase 2); the schema-inferred
+ * type is the lowest common denominator used at the persistence /
+ * validation boundary only.
+ *
+ * **Why `ComponentType<any>` and NOT `ComponentType<unknown>`**:
+ * React component props are CONTRAVARIANT in `ComponentType<T>` —
+ * a narrower `ComponentType<{ foo: string }>` is NOT assignable to
+ * `ComponentType<unknown>` (because a caller could pass an `unknown`
+ * the narrower component cannot accept). This made every consumer
+ * who built sections via `defineWebsiteSection<TProps>(…)` unable
+ * to feed the resulting `TypedWebsiteSectionDefinition<TProps>` to
+ * helpers typed against the bare `WebsiteSectionDefinition` —
+ * collectors, validators, and registries. Using `any` here is the
+ * exact escape hatch the React typings themselves use for
+ * heterogeneous component containers (`React.forwardRef`,
+ * `React.lazy`'s internal component slot, etc.) and matches the
+ * runtime contract: the framework NEVER instantiates these
+ * components directly with arbitrary props — the consumer's JSX
+ * supplies the right props at the call site.
+ */
+export interface WebsiteSectionDefinition extends z.infer<typeof _WebsiteSectionDefinitionSchema> {
+    Component: ComponentType<any>;
+    /**
+     * Optional pure function the SEO/AEO/GEO renderer invokes at
+     * static-build time to materialize JSON-LD for the section.
+     *
+     * **Why typed as `WebsiteStructuredDataReturn` (not `unknown`)** —
+     * a typed return shape gives section authors autocomplete on
+     * `@type` / `@id` / `@context` (the framework-owned fields) while
+     * keeping all other fields free-form (Schema.org has hundreds of
+     * optional fields per entity; locking them in TS would be both
+     * impractical and brittle as Schema.org evolves). The companion
+     * catalog reconciliation surface catches missing-required and
+     * deprecated-field-used at the SEMANTIC layer (warning-only per
+     * D-AG4), so the runtime type stays loose.
+     *
+     * Returns `null`, `undefined`, or `[]` when the section has no
+     * structured-data contribution for the current state — the
+     * renderer short-circuits all three.
+     */
+    getStructuredData?: () => WebsiteStructuredDataReturn;
+}
+export {};
+/** @wildo_source:part:end saas.website.sections.definition-schema */
+//# sourceMappingURL=website-section-definition.shared.schemas.d.ts.map

package/dist/esm/schemas/sections/website-section-definition.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-section-definition.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/sections/website-section-definition.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,2DAA2D,CAAC;AAG7G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,QAAA,MAAM,+BAA+B;;;;;;iBAMnC,CAAC;AAEH,eAAO,MAAM,8BAA8B,EAAE,OAAO,+BACnB,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,wBAAyB,SAAQ,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC;IAC/F,SAAS,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC;IAC9B;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAAiB,CAAC,EAAE,MAAM,2BAA2B,CAAC;CACvD;;AACD,qEAAqE"}

package/dist/esm/schemas/sections/website-section-definition.shared.schemas.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { WebsiteLabelKeySchema } from '../label-keys/website-label-key.schemas.js';
+import { WebsiteSectionRefSchema } from '../refs/section-ref.schemas.js';
+import { WebsiteSectionCategorySchema } from './website-section-category.shared.js';
+/**
+ * @wildo_source:part:start saas.website.sections.definition-schema facet:layer:shared facet:family:website
+ *
+ * `WebsiteSectionDefinition` — the runtime contract returned by the
+ * `defineWebsiteSection({ … })` factory (authored as a separate
+ * `core/define-website-section.tsx` module in Phase 2 because it carries
+ * React types in its inputs). The shape is declared in `schemas/`
+ * because it is the **observable contract** the page-manifest
+ * registration, label-pack validator, and SEO dispatcher depend on.
+ *
+ * **Shape rationale** (each field carries semantic weight — see
+ * `design-philosophy.mdc`):
+ *
+ * - `sectionRef` — the section's identity inside its hosting page.
+ *   Uniqueness is enforced **per page** at manifest registration time
+ *   (a section can be reused with the same `sectionRef` across pages
+ *   when its label-key root is intentionally shared).
+ * - `category` — see `WebsiteSectionCategory` JSDoc; tags the section
+ *   for SEO-dispatch, skill-mapping, and analytics labelling.
+ * - `expectedLabelKeys` — the **fully-composed** label keys the section
+ *   commits to consuming. The plan originally proposed leaf-relative
+ *   keys (`'headline'`) resolved at runtime against the
+ *   page+section context, but storing the fully-composed key on the
+ *   definition has three concrete benefits:
+ *     1. The label-pack validator (`validateLabelPackAgainstManifest`)
+ *        runs as a pure function with no need to walk the JSX tree at
+ *        build time to discover the leaf-to-key resolution.
+ *     2. The contract is auditable from outside the React render
+ *        graph — `wildo website audit` can list a page's required keys
+ *        without booting React.
+ *     3. The leaf-relative ergonomics (`useWebsiteLabel('headline')`)
+ *        survive in Phase 2 — the hook composes the leaf with the
+ *        page+section context and validates the result against
+ *        `expectedLabelKeys`.
+ * - `Component` — the React component that renders the section. Typed
+ *   as `ComponentType<unknown>` here because schema-layer cannot lock
+ *   the component's prop shape (props vary per section). The factory
+ *   function (`defineWebsiteSection<TProps>(…)`) preserves the precise
+ *   prop type at the consumer call site via generics; this schema only
+ *   guards the runtime shape of "is callable as a React component".
+ * - `getStructuredData?` — optional pure function the SEO/AEO/GEO
+ *   builder library invokes at static-build time to materialize JSON-LD
+ *   for the section. The return type is intentionally `unknown` here;
+ *   the SEO library narrows by `category` (e.g. `PRICING` →
+ *   `Product | AggregateOffer`).
+ *
+ * **Why not `z.custom<ComponentType>(…)`**: a `z.custom` predicate
+ * cannot meaningfully validate "is a React component" beyond
+ * `typeof === 'function'`, and the false-positive cost (any function
+ * passes) is too high for the value (none — the consumer either
+ * imports a real component or fails at JSX render time with a clearer
+ * error). Using `z.unknown()` + a TS-side type cast keeps the runtime
+ * cost zero and the type-safety contract entirely on the TS side
+ * (where it actually has teeth via the factory's generic).
+ */
+const _WebsiteSectionDefinitionSchema = z.object({
+    sectionRef: WebsiteSectionRefSchema,
+    category: WebsiteSectionCategorySchema,
+    expectedLabelKeys: z.array(WebsiteLabelKeySchema).readonly(),
+    Component: z.unknown(),
+    getStructuredData: z.unknown().optional(),
+});
+export const WebsiteSectionDefinitionSchema = _WebsiteSectionDefinitionSchema;
+/** @wildo_source:part:end saas.website.sections.definition-schema */
+//# sourceMappingURL=website-section-definition.shared.schemas.js.map

package/dist/esm/schemas/sections/website-section-definition.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"website-section-definition.shared.schemas.js","sourceRoot":"","sources":["../../../../../src/schemas/sections/website-section-definition.shared.schemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,+BAA+B,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,UAAU,EAAE,uBAAuB;IACnC,QAAQ,EAAE,4BAA4B;IACtC,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,QAAQ,EAAE;IAC5D,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE;IACtB,iBAAiB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAC1C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,8BAA8B,GACzC,+BAA+B,CAAC;AA+ClC,qEAAqE","sourcesContent":["import type { ComponentType } from 'react';\nimport { z } from 'zod';\n\nimport { WebsiteLabelKeySchema } from '../label-keys/website-label-key.schemas';\nimport { WebsiteSectionRefSchema } from '../refs/section-ref.schemas';\nimport type { WebsiteStructuredDataReturn } from '../structured-data/website-structured-data.shared.schemas';\nimport { WebsiteSectionCategorySchema } from './website-section-category.shared';\n\n/**\n * @wildo_source:part:start saas.website.sections.definition-schema facet:layer:shared facet:family:website\n *\n * `WebsiteSectionDefinition` — the runtime contract returned by the\n * `defineWebsiteSection({ … })` factory (authored as a separate\n * `core/define-website-section.tsx` module in Phase 2 because it carries\n * React types in its inputs). The shape is declared in `schemas/`\n * because it is the **observable contract** the page-manifest\n * registration, label-pack validator, and SEO dispatcher depend on.\n *\n * **Shape rationale** (each field carries semantic weight — see\n * `design-philosophy.mdc`):\n *\n * - `sectionRef` — the section's identity inside its hosting page.\n *   Uniqueness is enforced **per page** at manifest registration time\n *   (a section can be reused with the same `sectionRef` across pages\n *   when its label-key root is intentionally shared).\n * - `category` — see `WebsiteSectionCategory` JSDoc; tags the section\n *   for SEO-dispatch, skill-mapping, and analytics labelling.\n * - `expectedLabelKeys` — the **fully-composed** label keys the section\n *   commits to consuming. The plan originally proposed leaf-relative\n *   keys (`'headline'`) resolved at runtime against the\n *   page+section context, but storing the fully-composed key on the\n *   definition has three concrete benefits:\n *     1. The label-pack validator (`validateLabelPackAgainstManifest`)\n *        runs as a pure function with no need to walk the JSX tree at\n *        build time to discover the leaf-to-key resolution.\n *     2. The contract is auditable from outside the React render\n *        graph — `wildo website audit` can list a page's required keys\n *        without booting React.\n *     3. The leaf-relative ergonomics (`useWebsiteLabel('headline')`)\n *        survive in Phase 2 — the hook composes the leaf with the\n *        page+section context and validates the result against\n *        `expectedLabelKeys`.\n * - `Component` — the React component that renders the section. Typed\n *   as `ComponentType<unknown>` here because schema-layer cannot lock\n *   the component's prop shape (props vary per section). The factory\n *   function (`defineWebsiteSection<TProps>(…)`) preserves the precise\n *   prop type at the consumer call site via generics; this schema only\n *   guards the runtime shape of \"is callable as a React component\".\n * - `getStructuredData?` — optional pure function the SEO/AEO/GEO\n *   builder library invokes at static-build time to materialize JSON-LD\n *   for the section. The return type is intentionally `unknown` here;\n *   the SEO library narrows by `category` (e.g. `PRICING` →\n *   `Product | AggregateOffer`).\n *\n * **Why not `z.custom<ComponentType>(…)`**: a `z.custom` predicate\n * cannot meaningfully validate \"is a React component\" beyond\n * `typeof === 'function'`, and the false-positive cost (any function\n * passes) is too high for the value (none — the consumer either\n * imports a real component or fails at JSX render time with a clearer\n * error). Using `z.unknown()` + a TS-side type cast keeps the runtime\n * cost zero and the type-safety contract entirely on the TS side\n * (where it actually has teeth via the factory's generic).\n */\nconst _WebsiteSectionDefinitionSchema = z.object({\n  sectionRef: WebsiteSectionRefSchema,\n  category: WebsiteSectionCategorySchema,\n  expectedLabelKeys: z.array(WebsiteLabelKeySchema).readonly(),\n  Component: z.unknown(),\n  getStructuredData: z.unknown().optional(),\n});\n\nexport const WebsiteSectionDefinitionSchema: typeof _WebsiteSectionDefinitionSchema =\n  _WebsiteSectionDefinitionSchema;\n\n/**\n * Runtime shape of `WebsiteSectionDefinition`. Note: `Component` and\n * `getStructuredData` are typed precisely on the factory return type\n * (`defineWebsiteSection<TProps>` in Phase 2); the schema-inferred\n * type is the lowest common denominator used at the persistence /\n * validation boundary only.\n *\n * **Why `ComponentType<any>` and NOT `ComponentType<unknown>`**:\n * React component props are CONTRAVARIANT in `ComponentType<T>` —\n * a narrower `ComponentType<{ foo: string }>` is NOT assignable to\n * `ComponentType<unknown>` (because a caller could pass an `unknown`\n * the narrower component cannot accept). This made every consumer\n * who built sections via `defineWebsiteSection<TProps>(…)` unable\n * to feed the resulting `TypedWebsiteSectionDefinition<TProps>` to\n * helpers typed against the bare `WebsiteSectionDefinition` —\n * collectors, validators, and registries. Using `any` here is the\n * exact escape hatch the React typings themselves use for\n * heterogeneous component containers (`React.forwardRef`,\n * `React.lazy`'s internal component slot, etc.) and matches the\n * runtime contract: the framework NEVER instantiates these\n * components directly with arbitrary props — the consumer's JSX\n * supplies the right props at the call site.\n */\nexport interface WebsiteSectionDefinition extends z.infer<typeof _WebsiteSectionDefinitionSchema> {\n  Component: ComponentType<any>;\n  /**\n   * Optional pure function the SEO/AEO/GEO renderer invokes at\n   * static-build time to materialize JSON-LD for the section.\n   *\n   * **Why typed as `WebsiteStructuredDataReturn` (not `unknown`)** —\n   * a typed return shape gives section authors autocomplete on\n   * `@type` / `@id` / `@context` (the framework-owned fields) while\n   * keeping all other fields free-form (Schema.org has hundreds of\n   * optional fields per entity; locking them in TS would be both\n   * impractical and brittle as Schema.org evolves). The companion\n   * catalog reconciliation surface catches missing-required and\n   * deprecated-field-used at the SEMANTIC layer (warning-only per\n   * D-AG4), so the runtime type stays loose.\n   *\n   * Returns `null`, `undefined`, or `[]` when the section has no\n   * structured-data contribution for the current state — the\n   * renderer short-circuits all three.\n   */\n  getStructuredData?: () => WebsiteStructuredDataReturn;\n}\n/** @wildo_source:part:end saas.website.sections.definition-schema */\n"]}

package/dist/esm/schemas/structured-data/structured-data-reconciliation.shared.d.ts

@@ -0,0 +1,100 @@
+export interface StructuredDataDeprecatedField {
+    field: string;
+    replacedBy: string | null;
+    deprecatedSince: string;
+}
+export interface StructuredDataCatalogEntry {
+    '@type': string;
+    requiredFields: readonly string[];
+    optionalFields?: readonly string[];
+    deprecatedFields?: readonly StructuredDataDeprecatedField[];
+    recommendOptionals?: boolean;
+}
+export interface StructuredDataPayload {
+    '@type': string;
+    '@id'?: string;
+    [key: string]: unknown;
+}
+export interface StructuredDataSectionDefinitionLike {
+    sectionRef: string;
+    getStructuredData?: () => unknown;
+}
+export interface StructuredDataPageManifestLike {
+    ref: string;
+    routePath: string;
+    sectionRefs: readonly string[];
+}
+export interface StructuredDataPagePayloadLike {
+    pageRef: string;
+    routePath?: string;
+    sourceRef?: string;
+    payloads: unknown;
+}
+export type StructuredDataSpecViolationCode = 'invalid-payload-shape' | 'missing-entity-type' | 'missing-required-field' | 'missing-section-definition' | 'orphan-page-payload';
+export interface StructuredDataCatalogOverrideFinding {
+    kind: 'catalog-override';
+    entityType: string;
+    count: number;
+    message: string;
+}
+export interface StructuredDataCatalogMissFinding {
+    kind: 'catalog-miss';
+    pageRef: string;
+    routePath: string;
+    sectionRef: string;
+    entityType: string;
+    entityId?: string;
+    message: string;
+}
+export interface StructuredDataSpecViolationFinding {
+    kind: 'spec-violation';
+    code: StructuredDataSpecViolationCode;
+    pageRef: string;
+    routePath: string;
+    sectionRef: string;
+    entityType?: string;
+    entityId?: string;
+    field?: string;
+    message: string;
+}
+export interface StructuredDataDeprecatedFieldFinding {
+    kind: 'deprecated-field';
+    pageRef: string;
+    routePath: string;
+    sectionRef: string;
+    entityType: string;
+    entityId?: string;
+    field: string;
+    replacedBy: string | null;
+    deprecatedSince: string;
+    message: string;
+}
+export interface StructuredDataCrossEntityReferenceDriftFinding {
+    kind: 'cross-entity-reference-drift';
+    pageRef: string;
+    routePath: string;
+    sectionRef: string;
+    entityType: string;
+    entityId?: string;
+    missingReferenceId: string;
+    message: string;
+}
+export type StructuredDataReconciliationFinding = StructuredDataCatalogOverrideFinding | StructuredDataCatalogMissFinding | StructuredDataSpecViolationFinding | StructuredDataDeprecatedFieldFinding | StructuredDataCrossEntityReferenceDriftFinding;
+export interface StructuredDataReconciliationPageResult {
+    pageRef: string;
+    routePath: string;
+    payloadCount: number;
+    findingCount: number;
+}
+export interface StructuredDataReconciliationResult {
+    findings: StructuredDataReconciliationFinding[];
+    pages: StructuredDataReconciliationPageResult[];
+}
+export interface ReconcileStructuredDataOptions {
+    catalog: readonly StructuredDataCatalogEntry[];
+    pages: readonly StructuredDataPageManifestLike[];
+    sections: readonly StructuredDataSectionDefinitionLike[];
+    pagePayloads?: readonly StructuredDataPagePayloadLike[];
+}
+export declare function reconcileStructuredDataAgainstCatalog(options: ReconcileStructuredDataOptions): StructuredDataReconciliationResult;
+//# sourceMappingURL=structured-data-reconciliation.shared.d.ts.map

package/dist/esm/schemas/structured-data/structured-data-reconciliation.shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-data-reconciliation.shared.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/structured-data/structured-data-reconciliation.shared.ts"],"names":[],"mappings":"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"}