@wildo-ai/saas-website 1.1.1

package/dist/esm/core/factories/define-website-page-manifest.js

@@ -0,0 +1,51 @@
+import { WebsitePageManifestSchema, } from '../../schemas/manifests/website-page-manifest.shared.schemas.js';
+/**
+ * `defineWebsitePageManifest<TProps>` — factory that materializes a
+ * `WebsitePageManifest` from authored input.
+ *
+ * Same two responsibilities as `defineWebsiteSection`: runtime
+ * validation through the schema (incl. the schema's `superRefine`
+ * for unique sectionRefs and meta-key prefixing) plus type
+ * preservation for `pageComponent`.
+ *
+ * **Why a separate factory** (and not a single `defineWebsite*` API):
+ * a section and a page have different validation semantics
+ * (`expectedLabelKeys` discipline vs. `metaLabelKeys` prefix
+ * discipline) and different override paths (sections via L2
+ * import-swap; pages via root-config registration). Conflating them
+ * would force one of the two contracts onto the other's authors.
+ *
+ * @example
+ *   export const LANDING_PAGE_MANIFEST = defineWebsitePageManifest({
+ *     ref: 'landing',
+ *     routePath: '/',
+ *     pageComponent: LandingPage,
+ *     sectionRefs: ['hero', 'social-proof', 'pricing-teaser', 'final-cta'],
+ *     metaLabelKeys: {
+ *       titleKey: WebsiteLabelKeySchema.parse('website.landing.meta.title'),
+ *       descriptionKey: WebsiteLabelKeySchema.parse('website.landing.meta.description'),
+ *     },
+ *   });
+ */
+export function defineWebsitePageManifest(input) {
+    const parsed = WebsitePageManifestSchema.parse({
+        ref: input.ref,
+        routePath: input.routePath,
+        pageComponent: input.pageComponent,
+        sectionRefs: input.sectionRefs,
+        metaLabelKeys: input.metaLabelKeys,
+        hydration: input.hydration,
+        seo: input.seo,
+    });
+    return {
+        ref: parsed.ref,
+        routePath: parsed.routePath,
+        pageComponent: input.pageComponent,
+        sectionRefs: parsed.sectionRefs,
+        metaLabelKeys: parsed.metaLabelKeys,
+        ...(parsed.hydration !== undefined ? { hydration: parsed.hydration } : {}),
+        ...(parsed.seo !== undefined ? { seo: parsed.seo } : {}),
+    };
+}
+/** @wildo_source:part:end saas.website.factories.define-page-manifest */
+//# sourceMappingURL=define-website-page-manifest.js.map

package/dist/esm/core/factories/define-website-page-manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-website-page-manifest.js","sourceRoot":"","sources":["../../../../../src/core/factories/define-website-page-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,yBAAyB,GAM1B,MAAM,8DAA8D,CAAC;AA0CtE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAA6C;IAE7C,MAAM,MAAM,GAAG,yBAAyB,CAAC,KAAK,CAAC;QAC7C,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,GAAG,EAAE,KAAK,CAAC,GAAG;KACf,CAAC,CAAC;IACH,OAAO;QACL,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,aAAa,EAAE,MAAM,CAAC,aAAa;QACnC,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1E,GAAG,CAAC,MAAM,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACzD,CAAC;AACJ,CAAC;AACD,yEAAyE","sourcesContent":["import type { ComponentType } from 'react';\n\nimport {\n  WebsitePageManifestSchema,\n  type WebsitePageManifest,\n  type WebsitePageMetaLabelKeys,\n  type WebsitePageRoutePath,\n  type WebsitePageSeoConfig,\n  WebsitePageHydrationStrategy,\n} from '../../schemas/manifests/website-page-manifest.shared.schemas';\nimport type { WebsitePageRef } from '../../schemas/refs/page-ref.schemas';\nimport type { WebsiteSectionRef } from '../../schemas/refs/section-ref.schemas';\n\n/**\n * @wildo_source:part:start saas.website.factories.define-page-manifest facet:layer:core facet:family:website\n *\n * Input shape consumed by `defineWebsitePageManifest<TProps>`.\n *\n * `TProps` is rarely non-empty for top-level marketing pages (which\n * are usually rendered by Astro with no React-side props), but the\n * generic exists for two legitimate cases:\n *   - templated pages (eg. `/blog/[slug]` whose page component\n *     accepts `{ slug, frontmatter }` from the Astro adapter),\n *   - pages whose host adapter wants to inject server-side resolved\n *     props (eg. an A/B-test variant id) before hydration.\n *\n * **String inputs vs. branded inputs**: `ref`, `routePath`, and\n * `sectionRefs` accept raw strings — the factory parses them through\n * the underlying schemas. Same ergonomic + safety trade-off as\n * `defineWebsiteSection`.\n */\nexport interface DefineWebsitePageManifestInput<TProps> {\n  ref: WebsitePageRef | string;\n  routePath: WebsitePageRoutePath | string;\n  pageComponent: ComponentType<TProps>;\n  sectionRefs: readonly (WebsiteSectionRef | string)[];\n  metaLabelKeys: WebsitePageMetaLabelKeys;\n  hydration?: WebsitePageHydrationStrategy;\n  seo?: WebsitePageSeoConfig;\n}\n\n/**\n * Return shape of `defineWebsitePageManifest<TProps>`. Identical to\n * `WebsitePageManifest` except `pageComponent` retains the\n * caller-supplied generic prop shape.\n */\nexport interface TypedWebsitePageManifest<TProps>\n  extends Omit<WebsitePageManifest, 'pageComponent'> {\n  pageComponent: ComponentType<TProps>;\n}\n\n/**\n * `defineWebsitePageManifest<TProps>` — factory that materializes a\n * `WebsitePageManifest` from authored input.\n *\n * Same two responsibilities as `defineWebsiteSection`: runtime\n * validation through the schema (incl. the schema's `superRefine`\n * for unique sectionRefs and meta-key prefixing) plus type\n * preservation for `pageComponent`.\n *\n * **Why a separate factory** (and not a single `defineWebsite*` API):\n * a section and a page have different validation semantics\n * (`expectedLabelKeys` discipline vs. `metaLabelKeys` prefix\n * discipline) and different override paths (sections via L2\n * import-swap; pages via root-config registration). Conflating them\n * would force one of the two contracts onto the other's authors.\n *\n * @example\n *   export const LANDING_PAGE_MANIFEST = defineWebsitePageManifest({\n *     ref: 'landing',\n *     routePath: '/',\n *     pageComponent: LandingPage,\n *     sectionRefs: ['hero', 'social-proof', 'pricing-teaser', 'final-cta'],\n *     metaLabelKeys: {\n *       titleKey: WebsiteLabelKeySchema.parse('website.landing.meta.title'),\n *       descriptionKey: WebsiteLabelKeySchema.parse('website.landing.meta.description'),\n *     },\n *   });\n */\nexport function defineWebsitePageManifest<TProps = Record<string, never>>(\n  input: DefineWebsitePageManifestInput<TProps>,\n): TypedWebsitePageManifest<TProps> {\n  const parsed = WebsitePageManifestSchema.parse({\n    ref: input.ref,\n    routePath: input.routePath,\n    pageComponent: input.pageComponent,\n    sectionRefs: input.sectionRefs,\n    metaLabelKeys: input.metaLabelKeys,\n    hydration: input.hydration,\n    seo: input.seo,\n  });\n  return {\n    ref: parsed.ref,\n    routePath: parsed.routePath,\n    pageComponent: input.pageComponent,\n    sectionRefs: parsed.sectionRefs,\n    metaLabelKeys: parsed.metaLabelKeys,\n    ...(parsed.hydration !== undefined ? { hydration: parsed.hydration } : {}),\n    ...(parsed.seo !== undefined ? { seo: parsed.seo } : {}),\n  };\n}\n/** @wildo_source:part:end saas.website.factories.define-page-manifest */\n"]}

package/dist/esm/core/factories/define-website-section.d.ts

@@ -0,0 +1,101 @@
+import type { ComponentType } from 'react';
+import type { WebsiteSectionDefinition } from '../../schemas/sections/website-section-definition.shared.schemas';
+import type { WebsiteSectionCategory } from '../../schemas/sections/website-section-category.shared';
+import type { WebsiteSectionRef } from '../../schemas/refs/section-ref.schemas';
+import type { WebsiteLabelKey } from '../../schemas/label-keys/website-label-key.schemas';
+import type { WebsiteStructuredDataReturn } from '../../schemas/structured-data/website-structured-data.shared.schemas';
+/**
+ * @wildo_source:part:start saas.website.factories.define-section facet:layer:core facet:family:website
+ *
+ * Input shape consumed by `defineWebsiteSection<TProps>`. Mirrors
+ * `WebsiteSectionDefinition` but keeps `Component` typed against the
+ * caller-supplied generic so the precise prop shape survives end-to-end
+ * (the consumer's `<HeroSection />` JSX can keep its strongly-typed
+ * props after going through the factory).
+ *
+ * **String inputs vs. branded inputs**: `sectionRef` and
+ * `expectedLabelKeys` accept raw strings as well as already-branded
+ * values. The factory parses them through the underlying schemas, so
+ * either path is safe — accepting strings directly removes the
+ * ergonomic drag of forcing every section author to remember to call
+ * `WebsiteSectionRefSchema.parse(...)` in their definition.
+ */
+export interface DefineWebsiteSectionInput<TProps> {
+    sectionRef: WebsiteSectionRef | string;
+    category: WebsiteSectionCategory;
+    expectedLabelKeys: readonly (WebsiteLabelKey | string)[];
+    Component: ComponentType<TProps>;
+    /**
+     * See `WebsiteSectionDefinition.getStructuredData?` JSDoc for the
+     * full authoring contract. The factory passes the function through
+     * unchanged; the framework invokes it at static-build time and
+     * forwards the return value to `renderPageStructuredData()`.
+     */
+    getStructuredData?: () => WebsiteStructuredDataReturn;
+}
+/**
+ * Return shape of `defineWebsiteSection<TProps>`. Identical to
+ * `WebsiteSectionDefinition` except `Component` retains the
+ * caller-supplied generic prop shape rather than the schema's
+ * lowest-common-denominator `ComponentType<unknown>`.
+ *
+ * **Why this matters**: a consumer's `pageComponent` JSX composes
+ * sections like `<HERO_SECTION.Component {...heroProps} />`. Without
+ * preserving `TProps`, the spread would be untyped and a renamed prop
+ * would silently miss the type system. With `TProps` preserved, the
+ * call site fails to compile the moment the prop contract drifts.
+ */
+export interface TypedWebsiteSectionDefinition<TProps> extends Omit<WebsiteSectionDefinition, 'Component' | 'getStructuredData'> {
+    Component: ComponentType<TProps>;
+    getStructuredData?: () => WebsiteStructuredDataReturn;
+}
+/**
+ * `defineWebsiteSection<TProps>` — factory that materializes a
+ * `WebsiteSectionDefinition` from authored input.
+ *
+ * **Two responsibilities**, one entry point:
+ *   1. Runtime validation — parses the input through
+ *      `WebsiteSectionDefinitionSchema` so brand checks, regex
+ *      validations, and array refinements run at module load time
+ *      (not at render time, not at build-output time).
+ *   2. Type preservation — returns an object whose `Component` field
+ *      keeps the caller-supplied `TProps`, so JSX usage of the
+ *      returned section retains compile-time prop checking.
+ *
+ * **Why a factory instead of constructing the literal directly**:
+ *   - Consumers don't have to remember to parse refs / keys
+ *     themselves before assembling the literal.
+ *   - The schema parse provides a single audited validation chokepoint
+ *     so `wildo website audit` (Phase 7) can re-validate definitions
+ *     without re-entering the React graph.
+ *   - The factory is the documented authoring API the
+ *     `website_factory_authoring` skill targets — keeping the
+ *     authoring surface narrow lets the framework evolve the
+ *     internal schema (add fields, refinements) without churning
+ *     every section definition in every consumer app.
+ *
+ * @param input section authoring input (see `DefineWebsiteSectionInput`).
+ * @returns a `TypedWebsiteSectionDefinition<TProps>` with `Component`
+ *          preserved at the precise prop type.
+ *
+ * @example
+ *   interface HeroProps {
+ *     headlineKey: WebsiteLabelKey;
+ *     subheadlineKey: WebsiteLabelKey;
+ *   }
+ *   function HeroSection({ headlineKey, subheadlineKey }: HeroProps) {
+ *     // …
+ *   }
+ *   export const HERO_SECTION = defineWebsiteSection<HeroProps>({
+ *     sectionRef: 'hero',
+ *     category: WebsiteSectionCategory.HERO,
+ *     expectedLabelKeys: [
+ *       'website.landing.hero.headline',
+ *       'website.landing.hero.subheadline',
+ *     ],
+ *     Component: HeroSection,
+ *   });
+ */
+export declare function defineWebsiteSection<TProps>(input: DefineWebsiteSectionInput<TProps>): TypedWebsiteSectionDefinition<TProps>;
+/** @wildo_source:part:end saas.website.factories.define-section */
+//# sourceMappingURL=define-website-section.d.ts.map

package/dist/esm/core/factories/define-website-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-website-section.d.ts","sourceRoot":"","sources":["../../../../../src/core/factories/define-website-section.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAG3C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kEAAkE,CAAC;AACjH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wDAAwD,CAAC;AACrG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAC1F,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sEAAsE,CAAC;AAExH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,yBAAyB,CAAC,MAAM;IAC/C,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACvC,QAAQ,EAAE,sBAAsB,CAAC;IACjC,iBAAiB,EAAE,SAAS,CAAC,eAAe,GAAG,MAAM,CAAC,EAAE,CAAC;IACzD,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,2BAA2B,CAAC;CACvD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,6BAA6B,CAAC,MAAM,CACnD,SAAQ,IAAI,CAAC,wBAAwB,EAAE,WAAW,GAAG,mBAAmB,CAAC;IACzE,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,2BAA2B,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EACzC,KAAK,EAAE,yBAAyB,CAAC,MAAM,CAAC,GACvC,6BAA6B,CAAC,MAAM,CAAC,CAoBvC;AACD,mEAAmE"}

package/dist/esm/core/factories/define-website-section.js

@@ -0,0 +1,71 @@
+import { WebsiteSectionDefinitionSchema } from '../../schemas/sections/website-section-definition.shared.schemas.js';
+/**
+ * `defineWebsiteSection<TProps>` — factory that materializes a
+ * `WebsiteSectionDefinition` from authored input.
+ *
+ * **Two responsibilities**, one entry point:
+ *   1. Runtime validation — parses the input through
+ *      `WebsiteSectionDefinitionSchema` so brand checks, regex
+ *      validations, and array refinements run at module load time
+ *      (not at render time, not at build-output time).
+ *   2. Type preservation — returns an object whose `Component` field
+ *      keeps the caller-supplied `TProps`, so JSX usage of the
+ *      returned section retains compile-time prop checking.
+ *
+ * **Why a factory instead of constructing the literal directly**:
+ *   - Consumers don't have to remember to parse refs / keys
+ *     themselves before assembling the literal.
+ *   - The schema parse provides a single audited validation chokepoint
+ *     so `wildo website audit` (Phase 7) can re-validate definitions
+ *     without re-entering the React graph.
+ *   - The factory is the documented authoring API the
+ *     `website_factory_authoring` skill targets — keeping the
+ *     authoring surface narrow lets the framework evolve the
+ *     internal schema (add fields, refinements) without churning
+ *     every section definition in every consumer app.
+ *
+ * @param input section authoring input (see `DefineWebsiteSectionInput`).
+ * @returns a `TypedWebsiteSectionDefinition<TProps>` with `Component`
+ *          preserved at the precise prop type.
+ *
+ * @example
+ *   interface HeroProps {
+ *     headlineKey: WebsiteLabelKey;
+ *     subheadlineKey: WebsiteLabelKey;
+ *   }
+ *   function HeroSection({ headlineKey, subheadlineKey }: HeroProps) {
+ *     // …
+ *   }
+ *   export const HERO_SECTION = defineWebsiteSection<HeroProps>({
+ *     sectionRef: 'hero',
+ *     category: WebsiteSectionCategory.HERO,
+ *     expectedLabelKeys: [
+ *       'website.landing.hero.headline',
+ *       'website.landing.hero.subheadline',
+ *     ],
+ *     Component: HeroSection,
+ *   });
+ */
+export function defineWebsiteSection(input) {
+    const parsed = WebsiteSectionDefinitionSchema.parse({
+        sectionRef: input.sectionRef,
+        category: input.category,
+        expectedLabelKeys: input.expectedLabelKeys,
+        Component: input.Component,
+        getStructuredData: input.getStructuredData,
+    });
+    /**
+     * Re-attach `Component` and `getStructuredData` from the original
+     * input so the precise generic types survive — `parsed.Component`
+     * is `unknown` per the schema's `z.unknown()` contract.
+     */
+    return {
+        sectionRef: parsed.sectionRef,
+        category: parsed.category,
+        expectedLabelKeys: parsed.expectedLabelKeys,
+        Component: input.Component,
+        ...(input.getStructuredData ? { getStructuredData: input.getStructuredData } : {}),
+    };
+}
+/** @wildo_source:part:end saas.website.factories.define-section */
+//# sourceMappingURL=define-website-section.js.map

package/dist/esm/core/factories/define-website-section.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-website-section.js","sourceRoot":"","sources":["../../../../../src/core/factories/define-website-section.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,kEAAkE,CAAC;AAuDlH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,UAAU,oBAAoB,CAClC,KAAwC;IAExC,MAAM,MAAM,GAAG,8BAA8B,CAAC,KAAK,CAAC;QAClD,UAAU,EAAE,KAAK,CAAC,UAAU;QAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;QAC1C,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;KAC3C,CAAC,CAAC;IACH;;;;OAIG;IACH,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;QAC3C,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACnF,CAAC;AACJ,CAAC;AACD,mEAAmE","sourcesContent":["import type { ComponentType } from 'react';\n\nimport { WebsiteSectionDefinitionSchema } from '../../schemas/sections/website-section-definition.shared.schemas';\nimport type { WebsiteSectionDefinition } from '../../schemas/sections/website-section-definition.shared.schemas';\nimport type { WebsiteSectionCategory } from '../../schemas/sections/website-section-category.shared';\nimport type { WebsiteSectionRef } from '../../schemas/refs/section-ref.schemas';\nimport type { WebsiteLabelKey } from '../../schemas/label-keys/website-label-key.schemas';\nimport type { WebsiteStructuredDataReturn } from '../../schemas/structured-data/website-structured-data.shared.schemas';\n\n/**\n * @wildo_source:part:start saas.website.factories.define-section facet:layer:core facet:family:website\n *\n * Input shape consumed by `defineWebsiteSection<TProps>`. Mirrors\n * `WebsiteSectionDefinition` but keeps `Component` typed against the\n * caller-supplied generic so the precise prop shape survives end-to-end\n * (the consumer's `<HeroSection />` JSX can keep its strongly-typed\n * props after going through the factory).\n *\n * **String inputs vs. branded inputs**: `sectionRef` and\n * `expectedLabelKeys` accept raw strings as well as already-branded\n * values. The factory parses them through the underlying schemas, so\n * either path is safe — accepting strings directly removes the\n * ergonomic drag of forcing every section author to remember to call\n * `WebsiteSectionRefSchema.parse(...)` in their definition.\n */\nexport interface DefineWebsiteSectionInput<TProps> {\n  sectionRef: WebsiteSectionRef | string;\n  category: WebsiteSectionCategory;\n  expectedLabelKeys: readonly (WebsiteLabelKey | string)[];\n  Component: ComponentType<TProps>;\n  /**\n   * See `WebsiteSectionDefinition.getStructuredData?` JSDoc for the\n   * full authoring contract. The factory passes the function through\n   * unchanged; the framework invokes it at static-build time and\n   * forwards the return value to `renderPageStructuredData()`.\n   */\n  getStructuredData?: () => WebsiteStructuredDataReturn;\n}\n\n/**\n * Return shape of `defineWebsiteSection<TProps>`. Identical to\n * `WebsiteSectionDefinition` except `Component` retains the\n * caller-supplied generic prop shape rather than the schema's\n * lowest-common-denominator `ComponentType<unknown>`.\n *\n * **Why this matters**: a consumer's `pageComponent` JSX composes\n * sections like `<HERO_SECTION.Component {...heroProps} />`. Without\n * preserving `TProps`, the spread would be untyped and a renamed prop\n * would silently miss the type system. With `TProps` preserved, the\n * call site fails to compile the moment the prop contract drifts.\n */\nexport interface TypedWebsiteSectionDefinition<TProps>\n  extends Omit<WebsiteSectionDefinition, 'Component' | 'getStructuredData'> {\n  Component: ComponentType<TProps>;\n  getStructuredData?: () => WebsiteStructuredDataReturn;\n}\n\n/**\n * `defineWebsiteSection<TProps>` — factory that materializes a\n * `WebsiteSectionDefinition` from authored input.\n *\n * **Two responsibilities**, one entry point:\n *   1. Runtime validation — parses the input through\n *      `WebsiteSectionDefinitionSchema` so brand checks, regex\n *      validations, and array refinements run at module load time\n *      (not at render time, not at build-output time).\n *   2. Type preservation — returns an object whose `Component` field\n *      keeps the caller-supplied `TProps`, so JSX usage of the\n *      returned section retains compile-time prop checking.\n *\n * **Why a factory instead of constructing the literal directly**:\n *   - Consumers don't have to remember to parse refs / keys\n *     themselves before assembling the literal.\n *   - The schema parse provides a single audited validation chokepoint\n *     so `wildo website audit` (Phase 7) can re-validate definitions\n *     without re-entering the React graph.\n *   - The factory is the documented authoring API the\n *     `website_factory_authoring` skill targets — keeping the\n *     authoring surface narrow lets the framework evolve the\n *     internal schema (add fields, refinements) without churning\n *     every section definition in every consumer app.\n *\n * @param input section authoring input (see `DefineWebsiteSectionInput`).\n * @returns a `TypedWebsiteSectionDefinition<TProps>` with `Component`\n *          preserved at the precise prop type.\n *\n * @example\n *   interface HeroProps {\n *     headlineKey: WebsiteLabelKey;\n *     subheadlineKey: WebsiteLabelKey;\n *   }\n *   function HeroSection({ headlineKey, subheadlineKey }: HeroProps) {\n *     // …\n *   }\n *   export const HERO_SECTION = defineWebsiteSection<HeroProps>({\n *     sectionRef: 'hero',\n *     category: WebsiteSectionCategory.HERO,\n *     expectedLabelKeys: [\n *       'website.landing.hero.headline',\n *       'website.landing.hero.subheadline',\n *     ],\n *     Component: HeroSection,\n *   });\n */\nexport function defineWebsiteSection<TProps>(\n  input: DefineWebsiteSectionInput<TProps>,\n): TypedWebsiteSectionDefinition<TProps> {\n  const parsed = WebsiteSectionDefinitionSchema.parse({\n    sectionRef: input.sectionRef,\n    category: input.category,\n    expectedLabelKeys: input.expectedLabelKeys,\n    Component: input.Component,\n    getStructuredData: input.getStructuredData,\n  });\n  /**\n   * Re-attach `Component` and `getStructuredData` from the original\n   * input so the precise generic types survive — `parsed.Component`\n   * is `unknown` per the schema's `z.unknown()` contract.\n   */\n  return {\n    sectionRef: parsed.sectionRef,\n    category: parsed.category,\n    expectedLabelKeys: parsed.expectedLabelKeys,\n    Component: input.Component,\n    ...(input.getStructuredData ? { getStructuredData: input.getStructuredData } : {}),\n  };\n}\n/** @wildo_source:part:end saas.website.factories.define-section */\n"]}

package/dist/esm/core/hooks/useWebsiteDesignTokens.d.ts

@@ -0,0 +1,23 @@
+import type { WebsiteDesignTokens } from '../../schemas/design-tokens/website-design-tokens.shared.schemas';
+/**
+ * @wildo_source:part:start saas.website.use-tokens.hook facet:layer:core facet:family:website
+ *
+ * `useWebsiteDesignTokens()` — narrow read of the runtime context's
+ * `designTokens` slice.
+ *
+ * Existence rationale (vs. asking section authors to call
+ * `useWebsiteRuntime().designTokens` directly): hook discoverability
+ * + intent clarity. A section needing tokens has a single hook to
+ * import; refactoring the runtime context to add unrelated fields
+ * (eg. a future `analytics` slice) does NOT broaden the API surface
+ * the section consumes. Keeps the dependency graph between sections
+ * and runtime state explicit and minimal.
+ *
+ * Read-by-reference — the returned object is the same instance held
+ * by the runtime context, so memoization (`useMemo` /
+ * `React.memo` deps) using the returned reference works correctly
+ * across the static build's single render lifecycle.
+ */
+export declare function useWebsiteDesignTokens(): WebsiteDesignTokens;
+/** @wildo_source:part:end saas.website.use-tokens.hook */
+//# sourceMappingURL=useWebsiteDesignTokens.d.ts.map

package/dist/esm/core/hooks/useWebsiteDesignTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWebsiteDesignTokens.d.ts","sourceRoot":"","sources":["../../../../../src/core/hooks/useWebsiteDesignTokens.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kEAAkE,CAAC;AAE5G;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,IAAI,mBAAmB,CAE5D;AACD,0DAA0D"}

package/dist/esm/core/hooks/useWebsiteDesignTokens.js

@@ -0,0 +1,25 @@
+import { useWebsiteRuntime } from '../contexts/useWebsiteRuntime.js';
+/**
+ * @wildo_source:part:start saas.website.use-tokens.hook facet:layer:core facet:family:website
+ *
+ * `useWebsiteDesignTokens()` — narrow read of the runtime context's
+ * `designTokens` slice.
+ *
+ * Existence rationale (vs. asking section authors to call
+ * `useWebsiteRuntime().designTokens` directly): hook discoverability
+ * + intent clarity. A section needing tokens has a single hook to
+ * import; refactoring the runtime context to add unrelated fields
+ * (eg. a future `analytics` slice) does NOT broaden the API surface
+ * the section consumes. Keeps the dependency graph between sections
+ * and runtime state explicit and minimal.
+ *
+ * Read-by-reference — the returned object is the same instance held
+ * by the runtime context, so memoization (`useMemo` /
+ * `React.memo` deps) using the returned reference works correctly
+ * across the static build's single render lifecycle.
+ */
+export function useWebsiteDesignTokens() {
+    return useWebsiteRuntime().designTokens;
+}
+/** @wildo_source:part:end saas.website.use-tokens.hook */
+//# sourceMappingURL=useWebsiteDesignTokens.js.map

package/dist/esm/core/hooks/useWebsiteDesignTokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWebsiteDesignTokens.js","sourceRoot":"","sources":["../../../../../src/core/hooks/useWebsiteDesignTokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO,iBAAiB,EAAE,CAAC,YAAY,CAAC;AAC1C,CAAC;AACD,0DAA0D","sourcesContent":["import { useWebsiteRuntime } from '../contexts/useWebsiteRuntime';\nimport type { WebsiteDesignTokens } from '../../schemas/design-tokens/website-design-tokens.shared.schemas';\n\n/**\n * @wildo_source:part:start saas.website.use-tokens.hook facet:layer:core facet:family:website\n *\n * `useWebsiteDesignTokens()` — narrow read of the runtime context's\n * `designTokens` slice.\n *\n * Existence rationale (vs. asking section authors to call\n * `useWebsiteRuntime().designTokens` directly): hook discoverability\n * + intent clarity. A section needing tokens has a single hook to\n * import; refactoring the runtime context to add unrelated fields\n * (eg. a future `analytics` slice) does NOT broaden the API surface\n * the section consumes. Keeps the dependency graph between sections\n * and runtime state explicit and minimal.\n *\n * Read-by-reference — the returned object is the same instance held\n * by the runtime context, so memoization (`useMemo` /\n * `React.memo` deps) using the returned reference works correctly\n * across the static build's single render lifecycle.\n */\nexport function useWebsiteDesignTokens(): WebsiteDesignTokens {\n  return useWebsiteRuntime().designTokens;\n}\n/** @wildo_source:part:end saas.website.use-tokens.hook */\n"]}

package/dist/esm/core/hooks/useWebsiteLabel.d.ts

@@ -0,0 +1,68 @@
+import { type WebsiteLabelKey } from '../../schemas/label-keys/website-label-key.schemas';
+/**
+ * @wildo_source:part:start saas.website.use-label.hook facet:layer:core facet:family:website
+ *
+ * `useWebsiteLabel(slotPath)` — leaf-relative label resolution.
+ *
+ * Composes the slot leaf with the active page+section context to
+ * derive the full `WebsiteLabelKey` (`website.{pageRef}.{sectionRef}.{slotPath}`),
+ * looks it up in the active locale's label pack, and returns the
+ * resolved string.
+ *
+ * **Author ergonomics**: section authors call
+ * `useWebsiteLabel('headline')` from inside their section component
+ * without ever typing the page or section ref — the hook reads them
+ * from context. This keeps section components portable across pages
+ * (the same `<HeroSection />` can be reused on `landing` and on a
+ * dedicated `/about` page; only the surrounding `<WebsiteSection
+ * sectionRef="hero">` differs, and the label keys re-root accordingly).
+ *
+ * **Fail-loud diagnostics** for missing keys: returns the composed key
+ * itself (visible in the rendered DOM as e.g. `website.landing.hero.headline`)
+ * AND emits a `console.warn`. The visible-key fallback is preferred
+ * over an empty string or a thrown error because:
+ *   - empty string silently breaks layout (zero-height heading) and
+ *     leaks past visual review,
+ *   - throwing would crash the entire page on a single missing label
+ *     while the SEO crawler indexes a 500 page,
+ *   - the rendered key is a clear authoring signal ("ship the missing
+ *     pack entry") that designers and copywriters can spot without
+ *     opening DevTools.
+ *
+ * **Hard guards** (each enforced by the underlying context hooks):
+ *   - MUST be called inside `<WebsiteRuntimeContextProvider>`,
+ *   - MUST be called inside `<WebsitePageLayout>`,
+ *   - MUST be called inside `<WebsiteSection>`.
+ *
+ * @param slotPath leaf identifier (eg. `'headline'`, `'cta.primary'`,
+ *                 `'tiers[0].name'`). Anything that survives the slot
+ *                 portion of `WebsiteLabelKeySchema`'s regex.
+ * @returns the resolved label string, or the composed key itself when
+ *          the pack lacks an entry (with a `console.warn`).
+ */
+export declare function useWebsiteLabel(slotPath: string): string;
+/** @wildo_source:part:end saas.website.use-label.hook */
+/**
+ * @wildo_source:part:start saas.website.use-label-by-key.hook facet:layer:core facet:family:website
+ *
+ * `useWebsiteLabelByKey(key)` — absolute key lookup.
+ *
+ * Use when the consumer already holds a fully-composed label key and
+ * does NOT need page+section composition. Two main call sites:
+ *   - the navigation header/footer rendering page meta titles
+ *     (`useWebsiteLabelByKey(manifest.metaLabelKeys.titleKey)`),
+ *   - section components that accept a `*Key` prop from their parent
+ *     page (`<HeroSection headlineKey="website.landing.hero.headline" />`)
+ *     instead of using the leaf-relative hook.
+ *
+ * Same fail-loud diagnostics as `useWebsiteLabel`: returns the key
+ * string and emits a `console.warn` on miss.
+ *
+ * Defensively re-parses the key through `WebsiteLabelKeySchema` so a
+ * caller that bypassed the type system (eg. an `as WebsiteLabelKey`
+ * cast on a malformed string) gets caught at the hook boundary
+ * instead of silently looking up garbage.
+ */
+export declare function useWebsiteLabelByKey(key: WebsiteLabelKey): string;
+/** @wildo_source:part:end saas.website.use-label-by-key.hook */
+//# sourceMappingURL=useWebsiteLabel.d.ts.map

package/dist/esm/core/hooks/useWebsiteLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWebsiteLabel.d.ts","sourceRoot":"","sources":["../../../../../src/core/hooks/useWebsiteLabel.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,oDAAoD,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CA8BxD;AACD,yDAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAajE;AACD,gEAAgE"}

package/dist/esm/core/hooks/useWebsiteLabel.js

@@ -0,0 +1,103 @@
+import { useMemo } from 'react';
+import { useWebsitePage } from '../contexts/useWebsitePage.js';
+import { useWebsiteRuntime } from '../contexts/useWebsiteRuntime.js';
+import { useWebsiteSection } from '../contexts/useWebsiteSection.js';
+import { WebsiteLabelKeySchema, composeWebsiteLabelKey, } from '../../schemas/label-keys/website-label-key.schemas.js';
+/**
+ * @wildo_source:part:start saas.website.use-label.hook facet:layer:core facet:family:website
+ *
+ * `useWebsiteLabel(slotPath)` — leaf-relative label resolution.
+ *
+ * Composes the slot leaf with the active page+section context to
+ * derive the full `WebsiteLabelKey` (`website.{pageRef}.{sectionRef}.{slotPath}`),
+ * looks it up in the active locale's label pack, and returns the
+ * resolved string.
+ *
+ * **Author ergonomics**: section authors call
+ * `useWebsiteLabel('headline')` from inside their section component
+ * without ever typing the page or section ref — the hook reads them
+ * from context. This keeps section components portable across pages
+ * (the same `<HeroSection />` can be reused on `landing` and on a
+ * dedicated `/about` page; only the surrounding `<WebsiteSection
+ * sectionRef="hero">` differs, and the label keys re-root accordingly).
+ *
+ * **Fail-loud diagnostics** for missing keys: returns the composed key
+ * itself (visible in the rendered DOM as e.g. `website.landing.hero.headline`)
+ * AND emits a `console.warn`. The visible-key fallback is preferred
+ * over an empty string or a thrown error because:
+ *   - empty string silently breaks layout (zero-height heading) and
+ *     leaks past visual review,
+ *   - throwing would crash the entire page on a single missing label
+ *     while the SEO crawler indexes a 500 page,
+ *   - the rendered key is a clear authoring signal ("ship the missing
+ *     pack entry") that designers and copywriters can spot without
+ *     opening DevTools.
+ *
+ * **Hard guards** (each enforced by the underlying context hooks):
+ *   - MUST be called inside `<WebsiteRuntimeContextProvider>`,
+ *   - MUST be called inside `<WebsitePageLayout>`,
+ *   - MUST be called inside `<WebsiteSection>`.
+ *
+ * @param slotPath leaf identifier (eg. `'headline'`, `'cta.primary'`,
+ *                 `'tiers[0].name'`). Anything that survives the slot
+ *                 portion of `WebsiteLabelKeySchema`'s regex.
+ * @returns the resolved label string, or the composed key itself when
+ *          the pack lacks an entry (with a `console.warn`).
+ */
+export function useWebsiteLabel(slotPath) {
+    const { labelPack } = useWebsiteRuntime();
+    const { pageRef } = useWebsitePage();
+    const { sectionRef } = useWebsiteSection();
+    /**
+     * Compose + parse memoized on the three identity inputs. The parse
+     * itself is cheap (regex + brand) but executing it on every render
+     * of every label-bound primitive in a section adds up across a
+     * 12-section landing page.
+     */
+    const fullKey = useMemo(() => composeWebsiteLabelKey({
+        pageRef: pageRef,
+        sectionRef: sectionRef,
+        slotPath,
+    }), [pageRef, sectionRef, slotPath]);
+    const resolved = labelPack[fullKey];
+    if (resolved === undefined) {
+        console.warn(`[useWebsiteLabel] Missing label for key "${fullKey}". ` +
+            `Add it to the active locale's pack (or remove the section's claim on this slot).`);
+        return fullKey;
+    }
+    return resolved;
+}
+/** @wildo_source:part:end saas.website.use-label.hook */
+/**
+ * @wildo_source:part:start saas.website.use-label-by-key.hook facet:layer:core facet:family:website
+ *
+ * `useWebsiteLabelByKey(key)` — absolute key lookup.
+ *
+ * Use when the consumer already holds a fully-composed label key and
+ * does NOT need page+section composition. Two main call sites:
+ *   - the navigation header/footer rendering page meta titles
+ *     (`useWebsiteLabelByKey(manifest.metaLabelKeys.titleKey)`),
+ *   - section components that accept a `*Key` prop from their parent
+ *     page (`<HeroSection headlineKey="website.landing.hero.headline" />`)
+ *     instead of using the leaf-relative hook.
+ *
+ * Same fail-loud diagnostics as `useWebsiteLabel`: returns the key
+ * string and emits a `console.warn` on miss.
+ *
+ * Defensively re-parses the key through `WebsiteLabelKeySchema` so a
+ * caller that bypassed the type system (eg. an `as WebsiteLabelKey`
+ * cast on a malformed string) gets caught at the hook boundary
+ * instead of silently looking up garbage.
+ */
+export function useWebsiteLabelByKey(key) {
+    const { labelPack } = useWebsiteRuntime();
+    const safeKey = useMemo(() => WebsiteLabelKeySchema.parse(key), [key]);
+    const resolved = labelPack[safeKey];
+    if (resolved === undefined) {
+        console.warn(`[useWebsiteLabelByKey] Missing label for key "${safeKey}".`);
+        return safeKey;
+    }
+    return resolved;
+}
+/** @wildo_source:part:end saas.website.use-label-by-key.hook */
+//# sourceMappingURL=useWebsiteLabel.js.map

package/dist/esm/core/hooks/useWebsiteLabel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWebsiteLabel.js","sourceRoot":"","sources":["../../../../../src/core/hooks/useWebsiteLabel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GAEvB,MAAM,oDAAoD,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,MAAM,EAAE,SAAS,EAAE,GAAG,iBAAiB,EAAE,CAAC;IAC1C,MAAM,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,EAAE,UAAU,EAAE,GAAG,iBAAiB,EAAE,CAAC;IAE3C;;;;;OAKG;IACH,MAAM,OAAO,GAAG,OAAO,CACrB,GAAG,EAAE,CACH,sBAAsB,CAAC;QACrB,OAAO,EAAE,OAA4B;QACrC,UAAU,EAAE,UAA+B;QAC3C,QAAQ;KACT,CAAC,EACJ,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,CAChC,CAAC;IAEF,MAAM,QAAQ,GAAG,SAAS,CAAC,OAA4B,CAAC,CAAC;IACzD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,CAAC,IAAI,CACV,4CAA4C,OAA4B,KAAK;YAC3E,kFAAkF,CACrF,CAAC;QACF,OAAO,OAA4B,CAAC;IACtC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AACD,yDAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAoB;IACvD,MAAM,EAAE,SAAS,EAAE,GAAG,iBAAiB,EAAE,CAAC;IAE1C,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,qBAAqB,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAEvE,MAAM,QAAQ,GAAG,SAAS,CAAC,OAA4B,CAAC,CAAC;IACzD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,CAAC,IAAI,CACV,iDAAiD,OAA4B,IAAI,CAClF,CAAC;QACF,OAAO,OAA4B,CAAC;IACtC,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AACD,gEAAgE","sourcesContent":["import { useMemo } from 'react';\n\nimport { useWebsitePage } from '../contexts/useWebsitePage';\nimport { useWebsiteRuntime } from '../contexts/useWebsiteRuntime';\nimport { useWebsiteSection } from '../contexts/useWebsiteSection';\nimport {\n  WebsiteLabelKeySchema,\n  composeWebsiteLabelKey,\n  type WebsiteLabelKey,\n} from '../../schemas/label-keys/website-label-key.schemas';\n\n/**\n * @wildo_source:part:start saas.website.use-label.hook facet:layer:core facet:family:website\n *\n * `useWebsiteLabel(slotPath)` — leaf-relative label resolution.\n *\n * Composes the slot leaf with the active page+section context to\n * derive the full `WebsiteLabelKey` (`website.{pageRef}.{sectionRef}.{slotPath}`),\n * looks it up in the active locale's label pack, and returns the\n * resolved string.\n *\n * **Author ergonomics**: section authors call\n * `useWebsiteLabel('headline')` from inside their section component\n * without ever typing the page or section ref — the hook reads them\n * from context. This keeps section components portable across pages\n * (the same `<HeroSection />` can be reused on `landing` and on a\n * dedicated `/about` page; only the surrounding `<WebsiteSection\n * sectionRef=\"hero\">` differs, and the label keys re-root accordingly).\n *\n * **Fail-loud diagnostics** for missing keys: returns the composed key\n * itself (visible in the rendered DOM as e.g. `website.landing.hero.headline`)\n * AND emits a `console.warn`. The visible-key fallback is preferred\n * over an empty string or a thrown error because:\n *   - empty string silently breaks layout (zero-height heading) and\n *     leaks past visual review,\n *   - throwing would crash the entire page on a single missing label\n *     while the SEO crawler indexes a 500 page,\n *   - the rendered key is a clear authoring signal (\"ship the missing\n *     pack entry\") that designers and copywriters can spot without\n *     opening DevTools.\n *\n * **Hard guards** (each enforced by the underlying context hooks):\n *   - MUST be called inside `<WebsiteRuntimeContextProvider>`,\n *   - MUST be called inside `<WebsitePageLayout>`,\n *   - MUST be called inside `<WebsiteSection>`.\n *\n * @param slotPath leaf identifier (eg. `'headline'`, `'cta.primary'`,\n *                 `'tiers[0].name'`). Anything that survives the slot\n *                 portion of `WebsiteLabelKeySchema`'s regex.\n * @returns the resolved label string, or the composed key itself when\n *          the pack lacks an entry (with a `console.warn`).\n */\nexport function useWebsiteLabel(slotPath: string): string {\n  const { labelPack } = useWebsiteRuntime();\n  const { pageRef } = useWebsitePage();\n  const { sectionRef } = useWebsiteSection();\n\n  /**\n   * Compose + parse memoized on the three identity inputs. The parse\n   * itself is cheap (regex + brand) but executing it on every render\n   * of every label-bound primitive in a section adds up across a\n   * 12-section landing page.\n   */\n  const fullKey = useMemo<WebsiteLabelKey>(\n    () =>\n      composeWebsiteLabelKey({\n        pageRef: pageRef as unknown as string,\n        sectionRef: sectionRef as unknown as string,\n        slotPath,\n      }),\n    [pageRef, sectionRef, slotPath],\n  );\n\n  const resolved = labelPack[fullKey as unknown as string];\n  if (resolved === undefined) {\n    console.warn(\n      `[useWebsiteLabel] Missing label for key \"${fullKey as unknown as string}\". ` +\n        `Add it to the active locale's pack (or remove the section's claim on this slot).`,\n    );\n    return fullKey as unknown as string;\n  }\n  return resolved;\n}\n/** @wildo_source:part:end saas.website.use-label.hook */\n\n/**\n * @wildo_source:part:start saas.website.use-label-by-key.hook facet:layer:core facet:family:website\n *\n * `useWebsiteLabelByKey(key)` — absolute key lookup.\n *\n * Use when the consumer already holds a fully-composed label key and\n * does NOT need page+section composition. Two main call sites:\n *   - the navigation header/footer rendering page meta titles\n *     (`useWebsiteLabelByKey(manifest.metaLabelKeys.titleKey)`),\n *   - section components that accept a `*Key` prop from their parent\n *     page (`<HeroSection headlineKey=\"website.landing.hero.headline\" />`)\n *     instead of using the leaf-relative hook.\n *\n * Same fail-loud diagnostics as `useWebsiteLabel`: returns the key\n * string and emits a `console.warn` on miss.\n *\n * Defensively re-parses the key through `WebsiteLabelKeySchema` so a\n * caller that bypassed the type system (eg. an `as WebsiteLabelKey`\n * cast on a malformed string) gets caught at the hook boundary\n * instead of silently looking up garbage.\n */\nexport function useWebsiteLabelByKey(key: WebsiteLabelKey): string {\n  const { labelPack } = useWebsiteRuntime();\n\n  const safeKey = useMemo(() => WebsiteLabelKeySchema.parse(key), [key]);\n\n  const resolved = labelPack[safeKey as unknown as string];\n  if (resolved === undefined) {\n    console.warn(\n      `[useWebsiteLabelByKey] Missing label for key \"${safeKey as unknown as string}\".`,\n    );\n    return safeKey as unknown as string;\n  }\n  return resolved;\n}\n/** @wildo_source:part:end saas.website.use-label-by-key.hook */\n"]}

package/dist/esm/core/layouts/WebsitePageLayout.d.ts

@@ -0,0 +1,87 @@
+import { type ReactNode } from 'react';
+import { type WebsitePageRef } from '../../schemas/refs/page-ref.schemas';
+/**
+ * @wildo_source:part:start saas.website.page-layout.component facet:layer:core facet:family:website
+ *
+ * `WebsitePageLayout` — the per-page structural primitive.
+ *
+ * **Three responsibilities** (each carrying its own semantic weight):
+ *
+ *   1. **Provides `WebsitePageContext`** — registers the active page
+ *      ref so child sections (`<WebsiteSection>`) and label hooks
+ *      (`useWebsiteLabel`) can derive label keys without re-typing
+ *      the page ref at every leaf.
+ *   2. **Renders the site-wide chrome** — pulls
+ *      `headerComponent` and `footerComponent` from the runtime
+ *      navigation config and wraps the page's main content in the
+ *      site's standard header/main/footer scaffold. Per-page
+ *      overrides (`header={…}` / `footer={…}` props) take precedence
+ *      over the runtime defaults so individual pages can opt into a
+ *      custom chrome (eg. a campaign landing page running with
+ *      header-only minimal chrome).
+ *   3. **Stamps DOM landmarks** — emits `data-website-page-ref` on
+ *      the layout root for analytics / SEO crawlers / overlay
+ *      tooling that needs to identify the active page from the DOM
+ *      without booting React. When the website facet hydrates
+ *      frontend-provider bootstraps, the same root also carries the
+ *      active public provider refs for analytics / browser-monitoring /
+ *      captcha so non-React tooling can detect the configured vendor
+ *      without reverse-engineering app code.
+ *
+ * **Why semantic `<header>` / `<main>` / `<footer>` elements**:
+ * marketing-site SEO scoring penalizes pages that ship a single
+ * unstructured `<div>` tree. Using semantic landmarks costs nothing
+ * and improves crawler accessibility AND screen-reader
+ * navigability — both are first-class concerns for a public
+ * marketing surface.
+ *
+ * **Why this lives in `core/`** (not `components/`): the layout is
+ * structural framework machinery (it owns the page-context
+ * provisioning + the navigation slot resolution), not a styled
+ * primitive. Designers override `header` / `footer` via runtime
+ * config or per-page props, NOT by replacing this component.
+ */
+export interface WebsitePageLayoutProps {
+    /**
+     * The active page's ref. Accepts either an already-branded
+     * `WebsitePageRef` or a raw string — the layout parses through
+     * `WebsitePageRefSchema` so a malformed ref fails loud at render.
+     *
+     * Typically sourced from the page's `WebsitePageManifest.ref`
+     * (eg. `<WebsitePageLayout pageRef={LANDING_PAGE_MANIFEST.ref}>`).
+     */
+    pageRef: WebsitePageRef | string;
+    /**
+     * Per-page header override. When supplied, takes precedence over
+     * `WebsiteRuntimeContext.designTokens` navigation config's
+     * `headerComponent`. Pass `null` explicitly to suppress the header
+     * entirely (campaign landing pages without site-wide nav).
+     */
+    header?: ReactNode | null;
+    /**
+     * Per-page footer override. Same semantics as `header`.
+     */
+    footer?: ReactNode | null;
+    /**
+     * Optional className applied to the root `<div data-website-page-ref="…">`
+     * wrapper. Use for page-level layout tweaks (eg. `min-h-screen` on
+     * landing pages).
+     */
+    className?: string;
+    /**
+     * Optional className applied to the inner `<main>` element. Use for
+     * vertical-rhythm overrides on long-scroll landing pages.
+     */
+    mainClassName?: string;
+    /**
+     * The page's section composition. Typically a sequence of
+     * `<WebsiteSection>` wrappers around concrete section components.
+     */
+    children: ReactNode;
+}
+export declare function WebsitePageLayout({ pageRef, header, footer, className, mainClassName, children, }: WebsitePageLayoutProps): ReactNode;
+export declare namespace WebsitePageLayout {
+    var displayName: string;
+}
+/** @wildo_source:part:end saas.website.page-layout.component */
+//# sourceMappingURL=WebsitePageLayout.d.ts.map

package/dist/esm/core/layouts/WebsitePageLayout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsitePageLayout.d.ts","sourceRoot":"","sources":["../../../../../src/core/layouts/WebsitePageLayout.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAW,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAOvD,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,qCAAqC,CAAC;AA6F7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;;;;OAOG;IACH,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC;IACjC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,iBAAiB,CAAC,EAChC,OAAO,EACP,MAAM,EACN,MAAM,EACN,SAAS,EACT,aAAa,EACb,QAAQ,GACT,EAAE,sBAAsB,GAAG,SAAS,CAsHpC;yBA7He,iBAAiB;;;AA+HjC,gEAAgE"}