@wildo-ai/saas-website 1.1.1

package/dist/esm/core/layouts/WebsitePageLayout.js

@@ -0,0 +1,170 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { BUILTIN_PROVIDER_CAPABILITY } from '@wildo-ai/saas-models/public-runtime';
+import { WebsitePageContextProvider } from '../contexts/WebsitePageContext.js';
+import { useWebsiteRuntime } from '../contexts/useWebsiteRuntime.js';
+import { useWebsiteLabelByKey } from '../hooks/useWebsiteLabel.js';
+import { WebsitePageRefSchema, } from '../../schemas/refs/page-ref.schemas.js';
+/**
+ * Stable DOM id stamped on the `<main>` element so the framework's
+ * skip-link `<a href="#main-content">` can move keyboard focus past
+ * the chrome on every page (Phase 6 audit fix M-α). Co-located here
+ * (rather than exposed as a prop) because:
+ *   - The skip-link target is a framework concern — exposing it as a
+ *     consumer-tunable id would invite drift between the link's href
+ *     and the main element's id.
+ *   - Screen readers announce the heading inside `<main id="...">` on
+ *     focus; a stable, framework-owned id keeps that affordance
+ *     deterministic across every page on every site.
+ */
+const MAIN_CONTENT_DOM_ID = 'main-content';
+/**
+ * Inline style for the skip link's "visually hidden by default,
+ * visible on focus" pattern. Inlined (NOT shipped as a CSS class)
+ * because:
+ *   - The framework intentionally avoids shipping any CSS file the
+ *     consumer must opt in to — the only stylesheet emitted is the
+ *     `:root { --website-*: … }` design-token block, and the rest of
+ *     the styling surface lives in consumer code (see Phase 5
+ *     `renderWebsiteDesignTokensCss`). Inlining keeps the skip link
+ *     self-sufficient and side-effect-free.
+ *   - The "skip-link" pattern is a small, well-known a11y idiom; the
+ *     handful of style declarations here do not benefit from being
+ *     reorganized into a class with a custom-property hook.
+ *
+ * The "focused" variant uses BOTH `:focus` AND `:focus-visible`
+ * pseudo-classes via a scoped `<style>` tag inside the layout output.
+ * We cannot apply pseudo-class styles via a `style` attribute, but
+ * emitting a tiny scoped block once at the layout root is safe (one
+ * block per page render, ~120 bytes) and avoids importing a CSS-in-JS
+ * runtime.
+ *
+ * **Why both selectors and not just `:focus-visible`** (Phase 6 fourth
+ * audit fix M-Η): `:focus-visible` is the modern UA-heuristic-driven
+ * selector that hides focus rings on mouse clicks, and it is the
+ * RIGHT default for buttons / links. For a skip link though we WANT
+ * the affordance to appear on EVERY focus event — the link is
+ * invisible by default and a keyboard-only user (the only intended
+ * audience) is the only one who can reach it. Older browsers that
+ * predate `:focus-visible` (and Safari < 15.4 with the feature
+ * disabled) would skip the rule entirely with a `:focus-visible`-only
+ * declaration, leaving the keyboard user looking at an apparently
+ * empty page when they pressed Tab. Pairing `:focus, :focus-visible`
+ * is the documented WCAG 2.1 fallback pattern.
+ */
+const SKIP_LINK_HIDDEN_STYLE = {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    width: '1px',
+    height: '1px',
+    padding: 0,
+    margin: '-1px',
+    overflow: 'hidden',
+    clip: 'rect(0 0 0 0)',
+    whiteSpace: 'nowrap',
+    border: 0,
+};
+/**
+ * Single scoped style block for the skip link's `:focus-visible`
+ * affordance. Targets the `data-website-skip-link` attribute (NOT a
+ * class) so consumer Tailwind / utility classes cannot accidentally
+ * shadow it. Stays trivially small to keep payload under the
+ * "framework rendering" implicit budget.
+ */
+const SKIP_LINK_FOCUS_CSS = `
+[data-website-skip-link]:focus,
+[data-website-skip-link]:focus-visible {
+  position: fixed !important;
+  top: 0.5rem !important;
+  left: 0.5rem !important;
+  width: auto !important;
+  height: auto !important;
+  padding: 0.75rem 1rem !important;
+  margin: 0 !important;
+  overflow: visible !important;
+  clip: auto !important;
+  white-space: normal !important;
+  background: var(--website-colors-background, #fff) !important;
+  color: var(--website-colors-foreground, #000) !important;
+  border: 2px solid var(--website-colors-primary, #000) !important;
+  border-radius: var(--website-radii-md, 0.375rem) !important;
+  z-index: 9999 !important;
+  text-decoration: none !important;
+}
+`.trim();
+export function WebsitePageLayout({ pageRef, header, footer, className, mainClassName, children, }) {
+    const runtime = useWebsiteRuntime();
+    /**
+     * Defensive parse: callers should pass a `WebsitePageManifest.ref`
+     * (already branded), but accepting raw strings + parsing here means
+     * a hand-typed call site can't smuggle a malformed ref into the
+     * label-key derivation chain.
+     */
+    const safePageRef = useMemo(() => WebsitePageRefSchema.parse(pageRef), [pageRef]);
+    const pageContextValue = useMemo(() => ({ pageRef: safePageRef }), [safePageRef]);
+    /**
+     * Header resolution rules:
+     *   - `header === null`      => explicit suppression
+     *   - `header !== undefined` => per-page override (any ReactNode)
+     *   - `header === undefined` => fall back to the runtime navigation
+     *                                config's `headerComponent`
+     *
+     * The fallback is the common path: every page renders the same
+     * site-wide chrome. The override path is the escape hatch (campaign
+     * landing pages with custom header layouts).
+     */
+    const resolvedHeader = useMemo(() => {
+        if (header === null)
+            return null;
+        if (header !== undefined)
+            return header;
+        const HeaderComponent = runtime.navigation.headerComponent;
+        return _jsx(HeaderComponent, {});
+    }, [header, runtime.navigation.headerComponent]);
+    const resolvedFooter = useMemo(() => {
+        if (footer === null)
+            return null;
+        if (footer !== undefined)
+            return footer;
+        const FooterComponent = runtime.navigation.footerComponent;
+        return _jsx(FooterComponent, {});
+    }, [footer, runtime.navigation.footerComponent]);
+    const providerRootAttributes = useMemo(() => {
+        const attrs = {};
+        const productAnalyticsProviderRef = runtime.frontendProviderRegistry
+            ?.findProviderByProviderCapability(BUILTIN_PROVIDER_CAPABILITY.FRONTEND_PRODUCT_ANALYTICS)
+            ?.metadata.ref;
+        const errorMonitoringProviderRef = runtime.frontendProviderRegistry
+            ?.findProviderByProviderCapability(BUILTIN_PROVIDER_CAPABILITY.FRONTEND_ERROR_MONITORING)
+            ?.metadata.ref;
+        const captchaProviderRef = runtime.frontendProviderRegistry
+            ?.findProviderByProviderCapability(BUILTIN_PROVIDER_CAPABILITY.FRONTEND_CAPTCHA)
+            ?.metadata.ref;
+        if (productAnalyticsProviderRef) {
+            attrs['data-website-product-analytics-provider-ref'] = productAnalyticsProviderRef;
+        }
+        if (errorMonitoringProviderRef) {
+            attrs['data-website-error-monitoring-provider-ref'] = errorMonitoringProviderRef;
+        }
+        if (captchaProviderRef) {
+            attrs['data-website-captcha-provider-ref'] = captchaProviderRef;
+        }
+        return attrs;
+    }, [runtime.frontendProviderRegistry]);
+    /**
+     * Resolved skip-link label. Reads through the runtime label pack
+     * via the standard `useWebsiteLabelByKey` hook so a missing
+     * translation surfaces the same diagnostic shape as any other
+     * missing chrome label. The framework guarantees the key reaches
+     * the bridge (see `pickLabelsForPage`) and the consumer's
+     * label-pack validator (see `composeEffectiveChromeLabelKeys` in
+     * `label-pack-loader.ts`) ensures it is present in every locale
+     * pack — there is therefore no silent-fallback path that would
+     * ship an English skip link to a non-EN visitor.
+     */
+    const skipLinkLabel = useWebsiteLabelByKey(runtime.skipToMainContentLabelKey);
+    return (_jsx(WebsitePageContextProvider, { value: pageContextValue, children: _jsxs("div", { "data-website-page-ref": safePageRef, className: className, ...providerRootAttributes, children: [_jsx("style", { children: SKIP_LINK_FOCUS_CSS }), _jsx("a", { href: `#${MAIN_CONTENT_DOM_ID}`, "data-website-skip-link": "", style: SKIP_LINK_HIDDEN_STYLE, children: skipLinkLabel }), resolvedHeader !== null ? _jsx("header", { children: resolvedHeader }) : null, _jsx("main", { id: MAIN_CONTENT_DOM_ID, className: mainClassName, tabIndex: -1, children: children }), resolvedFooter !== null ? _jsx("footer", { children: resolvedFooter }) : null] }) }));
+}
+WebsitePageLayout.displayName = 'WebsitePageLayout';
+//# sourceMappingURL=WebsitePageLayout.js.map

package/dist/esm/core/layouts/WebsitePageLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsitePageLayout.js","sourceRoot":"","sources":["../../../../../src/core/layouts/WebsitePageLayout.tsx"],"names":[],"mappings":"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","sourcesContent":["import React, { useMemo, type ReactNode } from 'react';\nimport { BUILTIN_PROVIDER_CAPABILITY } from '@wildo-ai/saas-models/public-runtime';\n\nimport { WebsitePageContextProvider } from '../contexts/WebsitePageContext';\nimport type { WebsitePageContextValue } from '../contexts/WebsitePageContext';\nimport { useWebsiteRuntime } from '../contexts/useWebsiteRuntime';\nimport { useWebsiteLabelByKey } from '../hooks/useWebsiteLabel';\nimport {\n  WebsitePageRefSchema,\n  type WebsitePageRef,\n} from '../../schemas/refs/page-ref.schemas';\n\n/**\n * Stable DOM id stamped on the `<main>` element so the framework's\n * skip-link `<a href=\"#main-content\">` can move keyboard focus past\n * the chrome on every page (Phase 6 audit fix M-α). Co-located here\n * (rather than exposed as a prop) because:\n *   - The skip-link target is a framework concern — exposing it as a\n *     consumer-tunable id would invite drift between the link's href\n *     and the main element's id.\n *   - Screen readers announce the heading inside `<main id=\"...\">` on\n *     focus; a stable, framework-owned id keeps that affordance\n *     deterministic across every page on every site.\n */\nconst MAIN_CONTENT_DOM_ID = 'main-content';\n\n/**\n * Inline style for the skip link's \"visually hidden by default,\n * visible on focus\" pattern. Inlined (NOT shipped as a CSS class)\n * because:\n *   - The framework intentionally avoids shipping any CSS file the\n *     consumer must opt in to — the only stylesheet emitted is the\n *     `:root { --website-*: … }` design-token block, and the rest of\n *     the styling surface lives in consumer code (see Phase 5\n *     `renderWebsiteDesignTokensCss`). Inlining keeps the skip link\n *     self-sufficient and side-effect-free.\n *   - The \"skip-link\" pattern is a small, well-known a11y idiom; the\n *     handful of style declarations here do not benefit from being\n *     reorganized into a class with a custom-property hook.\n *\n * The \"focused\" variant uses BOTH `:focus` AND `:focus-visible`\n * pseudo-classes via a scoped `<style>` tag inside the layout output.\n * We cannot apply pseudo-class styles via a `style` attribute, but\n * emitting a tiny scoped block once at the layout root is safe (one\n * block per page render, ~120 bytes) and avoids importing a CSS-in-JS\n * runtime.\n *\n * **Why both selectors and not just `:focus-visible`** (Phase 6 fourth\n * audit fix M-Η): `:focus-visible` is the modern UA-heuristic-driven\n * selector that hides focus rings on mouse clicks, and it is the\n * RIGHT default for buttons / links. For a skip link though we WANT\n * the affordance to appear on EVERY focus event — the link is\n * invisible by default and a keyboard-only user (the only intended\n * audience) is the only one who can reach it. Older browsers that\n * predate `:focus-visible` (and Safari < 15.4 with the feature\n * disabled) would skip the rule entirely with a `:focus-visible`-only\n * declaration, leaving the keyboard user looking at an apparently\n * empty page when they pressed Tab. Pairing `:focus, :focus-visible`\n * is the documented WCAG 2.1 fallback pattern.\n */\nconst SKIP_LINK_HIDDEN_STYLE: React.CSSProperties = {\n  position: 'absolute',\n  top: 0,\n  left: 0,\n  width: '1px',\n  height: '1px',\n  padding: 0,\n  margin: '-1px',\n  overflow: 'hidden',\n  clip: 'rect(0 0 0 0)',\n  whiteSpace: 'nowrap',\n  border: 0,\n};\n\n/**\n * Single scoped style block for the skip link's `:focus-visible`\n * affordance. Targets the `data-website-skip-link` attribute (NOT a\n * class) so consumer Tailwind / utility classes cannot accidentally\n * shadow it. Stays trivially small to keep payload under the\n * \"framework rendering\" implicit budget.\n */\nconst SKIP_LINK_FOCUS_CSS = `\n[data-website-skip-link]:focus,\n[data-website-skip-link]:focus-visible {\n  position: fixed !important;\n  top: 0.5rem !important;\n  left: 0.5rem !important;\n  width: auto !important;\n  height: auto !important;\n  padding: 0.75rem 1rem !important;\n  margin: 0 !important;\n  overflow: visible !important;\n  clip: auto !important;\n  white-space: normal !important;\n  background: var(--website-colors-background, #fff) !important;\n  color: var(--website-colors-foreground, #000) !important;\n  border: 2px solid var(--website-colors-primary, #000) !important;\n  border-radius: var(--website-radii-md, 0.375rem) !important;\n  z-index: 9999 !important;\n  text-decoration: none !important;\n}\n`.trim();\n\n/**\n * @wildo_source:part:start saas.website.page-layout.component facet:layer:core facet:family:website\n *\n * `WebsitePageLayout` — the per-page structural primitive.\n *\n * **Three responsibilities** (each carrying its own semantic weight):\n *\n *   1. **Provides `WebsitePageContext`** — registers the active page\n *      ref so child sections (`<WebsiteSection>`) and label hooks\n *      (`useWebsiteLabel`) can derive label keys without re-typing\n *      the page ref at every leaf.\n *   2. **Renders the site-wide chrome** — pulls\n *      `headerComponent` and `footerComponent` from the runtime\n *      navigation config and wraps the page's main content in the\n *      site's standard header/main/footer scaffold. Per-page\n *      overrides (`header={…}` / `footer={…}` props) take precedence\n *      over the runtime defaults so individual pages can opt into a\n *      custom chrome (eg. a campaign landing page running with\n *      header-only minimal chrome).\n *   3. **Stamps DOM landmarks** — emits `data-website-page-ref` on\n *      the layout root for analytics / SEO crawlers / overlay\n *      tooling that needs to identify the active page from the DOM\n *      without booting React. When the website facet hydrates\n *      frontend-provider bootstraps, the same root also carries the\n *      active public provider refs for analytics / browser-monitoring /\n *      captcha so non-React tooling can detect the configured vendor\n *      without reverse-engineering app code.\n *\n * **Why semantic `<header>` / `<main>` / `<footer>` elements**:\n * marketing-site SEO scoring penalizes pages that ship a single\n * unstructured `<div>` tree. Using semantic landmarks costs nothing\n * and improves crawler accessibility AND screen-reader\n * navigability — both are first-class concerns for a public\n * marketing surface.\n *\n * **Why this lives in `core/`** (not `components/`): the layout is\n * structural framework machinery (it owns the page-context\n * provisioning + the navigation slot resolution), not a styled\n * primitive. Designers override `header` / `footer` via runtime\n * config or per-page props, NOT by replacing this component.\n */\nexport interface WebsitePageLayoutProps {\n  /**\n   * The active page's ref. Accepts either an already-branded\n   * `WebsitePageRef` or a raw string — the layout parses through\n   * `WebsitePageRefSchema` so a malformed ref fails loud at render.\n   *\n   * Typically sourced from the page's `WebsitePageManifest.ref`\n   * (eg. `<WebsitePageLayout pageRef={LANDING_PAGE_MANIFEST.ref}>`).\n   */\n  pageRef: WebsitePageRef | string;\n  /**\n   * Per-page header override. When supplied, takes precedence over\n   * `WebsiteRuntimeContext.designTokens` navigation config's\n   * `headerComponent`. Pass `null` explicitly to suppress the header\n   * entirely (campaign landing pages without site-wide nav).\n   */\n  header?: ReactNode | null;\n  /**\n   * Per-page footer override. Same semantics as `header`.\n   */\n  footer?: ReactNode | null;\n  /**\n   * Optional className applied to the root `<div data-website-page-ref=\"…\">`\n   * wrapper. Use for page-level layout tweaks (eg. `min-h-screen` on\n   * landing pages).\n   */\n  className?: string;\n  /**\n   * Optional className applied to the inner `<main>` element. Use for\n   * vertical-rhythm overrides on long-scroll landing pages.\n   */\n  mainClassName?: string;\n  /**\n   * The page's section composition. Typically a sequence of\n   * `<WebsiteSection>` wrappers around concrete section components.\n   */\n  children: ReactNode;\n}\n\nexport function WebsitePageLayout({\n  pageRef,\n  header,\n  footer,\n  className,\n  mainClassName,\n  children,\n}: WebsitePageLayoutProps): ReactNode {\n  const runtime = useWebsiteRuntime();\n\n  /**\n   * Defensive parse: callers should pass a `WebsitePageManifest.ref`\n   * (already branded), but accepting raw strings + parsing here means\n   * a hand-typed call site can't smuggle a malformed ref into the\n   * label-key derivation chain.\n   */\n  const safePageRef = useMemo<WebsitePageRef>(\n    () => WebsitePageRefSchema.parse(pageRef),\n    [pageRef],\n  );\n\n  const pageContextValue = useMemo<WebsitePageContextValue>(\n    () => ({ pageRef: safePageRef }),\n    [safePageRef],\n  );\n\n  /**\n   * Header resolution rules:\n   *   - `header === null`      => explicit suppression\n   *   - `header !== undefined` => per-page override (any ReactNode)\n   *   - `header === undefined` => fall back to the runtime navigation\n   *                                config's `headerComponent`\n   *\n   * The fallback is the common path: every page renders the same\n   * site-wide chrome. The override path is the escape hatch (campaign\n   * landing pages with custom header layouts).\n   */\n  const resolvedHeader = useMemo<ReactNode>(() => {\n    if (header === null) return null;\n    if (header !== undefined) return header;\n    const HeaderComponent = runtime.navigation.headerComponent;\n    return <HeaderComponent />;\n  }, [header, runtime.navigation.headerComponent]);\n\n  const resolvedFooter = useMemo<ReactNode>(() => {\n    if (footer === null) return null;\n    if (footer !== undefined) return footer;\n    const FooterComponent = runtime.navigation.footerComponent;\n    return <FooterComponent />;\n  }, [footer, runtime.navigation.footerComponent]);\n\n  const providerRootAttributes = useMemo<Record<string, string>>(() => {\n    const attrs: Record<string, string> = {};\n    const productAnalyticsProviderRef = runtime.frontendProviderRegistry\n      ?.findProviderByProviderCapability(\n        BUILTIN_PROVIDER_CAPABILITY.FRONTEND_PRODUCT_ANALYTICS,\n      )\n      ?.metadata.ref;\n    const errorMonitoringProviderRef = runtime.frontendProviderRegistry\n      ?.findProviderByProviderCapability(\n        BUILTIN_PROVIDER_CAPABILITY.FRONTEND_ERROR_MONITORING,\n      )\n      ?.metadata.ref;\n    const captchaProviderRef = runtime.frontendProviderRegistry\n      ?.findProviderByProviderCapability(\n        BUILTIN_PROVIDER_CAPABILITY.FRONTEND_CAPTCHA,\n      )\n      ?.metadata.ref;\n\n    if (productAnalyticsProviderRef) {\n      attrs['data-website-product-analytics-provider-ref'] = productAnalyticsProviderRef;\n    }\n    if (errorMonitoringProviderRef) {\n      attrs['data-website-error-monitoring-provider-ref'] = errorMonitoringProviderRef;\n    }\n    if (captchaProviderRef) {\n      attrs['data-website-captcha-provider-ref'] = captchaProviderRef;\n    }\n\n    return attrs;\n  }, [runtime.frontendProviderRegistry]);\n\n  /**\n   * Resolved skip-link label. Reads through the runtime label pack\n   * via the standard `useWebsiteLabelByKey` hook so a missing\n   * translation surfaces the same diagnostic shape as any other\n   * missing chrome label. The framework guarantees the key reaches\n   * the bridge (see `pickLabelsForPage`) and the consumer's\n   * label-pack validator (see `composeEffectiveChromeLabelKeys` in\n   * `label-pack-loader.ts`) ensures it is present in every locale\n   * pack — there is therefore no silent-fallback path that would\n   * ship an English skip link to a non-EN visitor.\n   */\n  const skipLinkLabel = useWebsiteLabelByKey(runtime.skipToMainContentLabelKey);\n\n  return (\n    <WebsitePageContextProvider value={pageContextValue}>\n      <div\n        data-website-page-ref={safePageRef as unknown as string}\n        className={className}\n        {...providerRootAttributes}\n      >\n        {/*\n         * Skip link rendered as the FIRST focusable element on the\n         * page so a keyboard / AT user can bypass the chrome on every\n         * navigation (WCAG 2.1 §2.4.1 \"Bypass Blocks\", Level A).\n         * Visually hidden by default; revealed on focus via the\n         * scoped `<style>` block below.\n         */}\n        <style>{SKIP_LINK_FOCUS_CSS}</style>\n        <a\n          href={`#${MAIN_CONTENT_DOM_ID}`}\n          data-website-skip-link=\"\"\n          style={SKIP_LINK_HIDDEN_STYLE}\n        >\n          {skipLinkLabel}\n        </a>\n        {resolvedHeader !== null ? <header>{resolvedHeader}</header> : null}\n        <main id={MAIN_CONTENT_DOM_ID} className={mainClassName} tabIndex={-1}>\n          {children}\n        </main>\n        {resolvedFooter !== null ? <footer>{resolvedFooter}</footer> : null}\n      </div>\n    </WebsitePageContextProvider>\n  );\n}\nWebsitePageLayout.displayName = 'WebsitePageLayout';\n/** @wildo_source:part:end saas.website.page-layout.component */\n"]}

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

@@ -0,0 +1,91 @@
+import { type ReactNode } from 'react';
+import { WebsiteSectionCategory } from '../../schemas/sections/website-section-category.shared';
+import { type WebsiteSectionRef } from '../../schemas/refs/section-ref.schemas';
+/**
+ * @wildo_source:part:start saas.website.section.component facet:layer:core facet:family:website
+ *
+ * `WebsiteSection` — the per-section structural primitive.
+ *
+ * **Three responsibilities** (semantic-weight discipline):
+ *
+ *   1. **Provides `WebsiteSectionContext`** — registers the active
+ *      sectionRef + category so leaf primitives (`useWebsiteLabel`,
+ *      analytics overlays, structured-data emitters) can derive
+ *      keys / metadata without re-typing the section's identity.
+ *   2. **Renders a semantic `<section>` landmark** — emits
+ *      `data-section-ref` and `data-section-category` attributes so
+ *      analytics tooling and SEO crawlers can identify and group
+ *      sections without parsing className conventions. Optional
+ *      `id` prop wires up anchor-link navigation
+ *      (`<a href="#pricing">`).
+ *   3. **Provides a styling seam** — `className` is forwarded to the
+ *      `<section>` element so designers can apply utility-class
+ *      decorations (background, padding, max-width container) without
+ *      having to compose multiple wrappers.
+ *
+ * **Why NOT render a `<div>` instead of `<section>`**: marketing
+ * pages benefit from semantic landmarks for SEO scoring and
+ * accessibility (screen-reader section navigation). A `<section>`
+ * with `data-section-category="hero"` is structurally meaningful;
+ * a `<div>` with the same data-attribute carries the same metadata
+ * but loses the landmark benefit.
+ *
+ * **Why expose `as` is NOT a prop**: switching the rendered tag
+ * (`<article>` for blog post bodies, `<aside>` for sidebar widgets)
+ * is legitimate but rare enough to be worth a separate primitive
+ * (Phase 4: `<WebsiteAside>`, `<WebsiteArticle>`). Keeping
+ * `WebsiteSection` rendered as a literal `<section>` removes a
+ * rarely-used prop from the section-author API and keeps the SEO
+ * landmark contract guaranteed at the type level.
+ */
+export interface WebsiteSectionProps {
+    /**
+     * The section's ref. Accepts an already-branded `WebsiteSectionRef`
+     * or a raw string — the layout parses through
+     * `WebsiteSectionRefSchema` so a malformed ref fails loud at
+     * render. Typically sourced from the page manifest's
+     * `sectionRefs[]` (eg. `<WebsiteSection sectionRef="hero" …>`).
+     */
+    sectionRef: WebsiteSectionRef | string;
+    /**
+     * The section's structural intent (see `WebsiteSectionCategory`).
+     * Required at the wrapper level (rather than only on the section
+     * definition) because the wrapper emits `data-section-category`
+     * for analytics, and asking the wrapper to look up the category
+     * on a separate manifest registry would re-introduce the runtime
+     * coupling the per-section context exists to avoid.
+     */
+    category: WebsiteSectionCategory;
+    /**
+     * Optional DOM id. Wires anchor-link navigation
+     * (`<a href="#pricing">`). When omitted, the section has no DOM
+     * id — by design; not every section is an anchor target.
+     */
+    id?: string;
+    /**
+     * Optional className applied to the `<section>` element. Used by
+     * designers for layout / spacing utilities. Section components
+     * themselves should NOT pass className through to this wrapper —
+     * keep the styling responsibility at the page-composition level.
+     */
+    className?: string;
+    /**
+     * The section's body. Typically a single section component
+     * (`<HeroSection {…heroProps} />`). May be plain JSX for one-off
+     * sections that don't justify a `defineWebsiteSection` factory call.
+     */
+    children: ReactNode;
+    /**
+     * Pass-through `aria-*` / `role` attributes for sections that need
+     * to refine their landmark semantics (eg. `aria-label="Featured
+     * customer logos"` on a logo wall).
+     */
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+}
+export declare function WebsiteSection({ sectionRef, category, id, className, children, ariaLabel, ariaLabelledBy, }: WebsiteSectionProps): ReactNode;
+export declare namespace WebsiteSection {
+    var displayName: string;
+}
+/** @wildo_source:part:end saas.website.section.component */
+//# sourceMappingURL=WebsiteSection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebsiteSection.d.ts","sourceRoot":"","sources":["../../../../../src/core/layouts/WebsiteSection.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAgC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAI5E,OAAO,EAAE,sBAAsB,EAAE,MAAM,wDAAwD,CAAC;AAChG,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,wCAAwC,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;OAMG;IACH,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAC;IACvC;;;;;;;OAOG;IACH,QAAQ,EAAE,sBAAsB,CAAC;IACjC;;;;OAIG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,QAAQ,EAAE,SAAS,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,cAAc,CAAC,EAC7B,UAAU,EACV,QAAQ,EACR,EAAE,EACF,SAAS,EACT,QAAQ,EACR,SAAS,EACT,cAAc,GACf,EAAE,mBAAmB,GAAG,SAAS,CAmCjC;yBA3Ce,cAAc;;;AA6C9B,4DAA4D"}

package/dist/esm/core/layouts/WebsiteSection.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { WebsiteSectionContextProvider } from '../contexts/WebsiteSectionContext.js';
+import { WebsiteSectionRefSchema, } from '../../schemas/refs/section-ref.schemas.js';
+export function WebsiteSection({ sectionRef, category, id, className, children, ariaLabel, ariaLabelledBy, }) {
+    const safeSectionRef = useMemo(() => WebsiteSectionRefSchema.parse(sectionRef), [sectionRef]);
+    const sectionContextValue = useMemo(() => ({ sectionRef: safeSectionRef, category }), [safeSectionRef, category]);
+    /**
+     * Build the `<section>` attribute set imperatively to keep
+     * `aria-*` props off the element when omitted (rendering
+     * `aria-label={undefined}` still emits the attribute in some
+     * React versions — explicit absence is cleaner).
+     */
+    const sectionAttrs = {
+        className,
+    };
+    if (id !== undefined)
+        sectionAttrs.id = id;
+    if (ariaLabel !== undefined)
+        sectionAttrs['aria-label'] = ariaLabel;
+    if (ariaLabelledBy !== undefined)
+        sectionAttrs['aria-labelledby'] = ariaLabelledBy;
+    return (_jsx(WebsiteSectionContextProvider, { value: sectionContextValue, children: _jsx("section", { "data-section-ref": safeSectionRef, "data-section-category": category, ...sectionAttrs, children: children }) }));
+}
+WebsiteSection.displayName = 'WebsiteSection';
+//# sourceMappingURL=WebsiteSection.js.map

package/dist/esm/core/layouts/WebsiteSection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsiteSection.js","sourceRoot":"","sources":["../../../../../src/core/layouts/WebsiteSection.tsx"],"names":[],"mappings":";AAAA,OAAc,EAAE,OAAO,EAAuC,MAAM,OAAO,CAAC;AAE5E,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAGlF,OAAO,EACL,uBAAuB,GAExB,MAAM,wCAAwC,CAAC;AAqFhD,MAAM,UAAU,cAAc,CAAC,EAC7B,UAAU,EACV,QAAQ,EACR,EAAE,EACF,SAAS,EACT,QAAQ,EACR,SAAS,EACT,cAAc,GACM;IACpB,MAAM,cAAc,GAAG,OAAO,CAC5B,GAAG,EAAE,CAAC,uBAAuB,CAAC,KAAK,CAAC,UAAU,CAAC,EAC/C,CAAC,UAAU,CAAC,CACb,CAAC;IAEF,MAAM,mBAAmB,GAAG,OAAO,CACjC,GAAG,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,EAChD,CAAC,cAAc,EAAE,QAAQ,CAAC,CAC3B,CAAC;IAEF;;;;;OAKG;IACH,MAAM,YAAY,GAAgC;QAChD,SAAS;KACV,CAAC;IACF,IAAI,EAAE,KAAK,SAAS;QAAE,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;IAC3C,IAAI,SAAS,KAAK,SAAS;QAAE,YAAY,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC;IACpE,IAAI,cAAc,KAAK,SAAS;QAAE,YAAY,CAAC,iBAAiB,CAAC,GAAG,cAAc,CAAC;IAEnF,OAAO,CACL,KAAC,6BAA6B,IAAC,KAAK,EAAE,mBAAmB,YACvD,sCACoB,cAAmC,2BAC9B,QAAQ,KAC3B,YAAY,YAEf,QAAQ,GACD,GACoB,CACjC,CAAC;AACJ,CAAC;AACD,cAAc,CAAC,WAAW,GAAG,gBAAgB,CAAC","sourcesContent":["import React, { useMemo, type HTMLAttributes, type ReactNode } from 'react';\n\nimport { WebsiteSectionContextProvider } from '../contexts/WebsiteSectionContext';\nimport type { WebsiteSectionContextValue } from '../contexts/WebsiteSectionContext';\nimport { WebsiteSectionCategory } from '../../schemas/sections/website-section-category.shared';\nimport {\n  WebsiteSectionRefSchema,\n  type WebsiteSectionRef,\n} from '../../schemas/refs/section-ref.schemas';\n\n/**\n * @wildo_source:part:start saas.website.section.component facet:layer:core facet:family:website\n *\n * `WebsiteSection` — the per-section structural primitive.\n *\n * **Three responsibilities** (semantic-weight discipline):\n *\n *   1. **Provides `WebsiteSectionContext`** — registers the active\n *      sectionRef + category so leaf primitives (`useWebsiteLabel`,\n *      analytics overlays, structured-data emitters) can derive\n *      keys / metadata without re-typing the section's identity.\n *   2. **Renders a semantic `<section>` landmark** — emits\n *      `data-section-ref` and `data-section-category` attributes so\n *      analytics tooling and SEO crawlers can identify and group\n *      sections without parsing className conventions. Optional\n *      `id` prop wires up anchor-link navigation\n *      (`<a href=\"#pricing\">`).\n *   3. **Provides a styling seam** — `className` is forwarded to the\n *      `<section>` element so designers can apply utility-class\n *      decorations (background, padding, max-width container) without\n *      having to compose multiple wrappers.\n *\n * **Why NOT render a `<div>` instead of `<section>`**: marketing\n * pages benefit from semantic landmarks for SEO scoring and\n * accessibility (screen-reader section navigation). A `<section>`\n * with `data-section-category=\"hero\"` is structurally meaningful;\n * a `<div>` with the same data-attribute carries the same metadata\n * but loses the landmark benefit.\n *\n * **Why expose `as` is NOT a prop**: switching the rendered tag\n * (`<article>` for blog post bodies, `<aside>` for sidebar widgets)\n * is legitimate but rare enough to be worth a separate primitive\n * (Phase 4: `<WebsiteAside>`, `<WebsiteArticle>`). Keeping\n * `WebsiteSection` rendered as a literal `<section>` removes a\n * rarely-used prop from the section-author API and keeps the SEO\n * landmark contract guaranteed at the type level.\n */\nexport interface WebsiteSectionProps {\n  /**\n   * The section's ref. Accepts an already-branded `WebsiteSectionRef`\n   * or a raw string — the layout parses through\n   * `WebsiteSectionRefSchema` so a malformed ref fails loud at\n   * render. Typically sourced from the page manifest's\n   * `sectionRefs[]` (eg. `<WebsiteSection sectionRef=\"hero\" …>`).\n   */\n  sectionRef: WebsiteSectionRef | string;\n  /**\n   * The section's structural intent (see `WebsiteSectionCategory`).\n   * Required at the wrapper level (rather than only on the section\n   * definition) because the wrapper emits `data-section-category`\n   * for analytics, and asking the wrapper to look up the category\n   * on a separate manifest registry would re-introduce the runtime\n   * coupling the per-section context exists to avoid.\n   */\n  category: WebsiteSectionCategory;\n  /**\n   * Optional DOM id. Wires anchor-link navigation\n   * (`<a href=\"#pricing\">`). When omitted, the section has no DOM\n   * id — by design; not every section is an anchor target.\n   */\n  id?: string;\n  /**\n   * Optional className applied to the `<section>` element. Used by\n   * designers for layout / spacing utilities. Section components\n   * themselves should NOT pass className through to this wrapper —\n   * keep the styling responsibility at the page-composition level.\n   */\n  className?: string;\n  /**\n   * The section's body. Typically a single section component\n   * (`<HeroSection {…heroProps} />`). May be plain JSX for one-off\n   * sections that don't justify a `defineWebsiteSection` factory call.\n   */\n  children: ReactNode;\n  /**\n   * Pass-through `aria-*` / `role` attributes for sections that need\n   * to refine their landmark semantics (eg. `aria-label=\"Featured\n   * customer logos\"` on a logo wall).\n   */\n  ariaLabel?: string;\n  ariaLabelledBy?: string;\n}\n\nexport function WebsiteSection({\n  sectionRef,\n  category,\n  id,\n  className,\n  children,\n  ariaLabel,\n  ariaLabelledBy,\n}: WebsiteSectionProps): ReactNode {\n  const safeSectionRef = useMemo<WebsiteSectionRef>(\n    () => WebsiteSectionRefSchema.parse(sectionRef),\n    [sectionRef],\n  );\n\n  const sectionContextValue = useMemo<WebsiteSectionContextValue>(\n    () => ({ sectionRef: safeSectionRef, category }),\n    [safeSectionRef, category],\n  );\n\n  /**\n   * Build the `<section>` attribute set imperatively to keep\n   * `aria-*` props off the element when omitted (rendering\n   * `aria-label={undefined}` still emits the attribute in some\n   * React versions — explicit absence is cleaner).\n   */\n  const sectionAttrs: HTMLAttributes<HTMLElement> = {\n    className,\n  };\n  if (id !== undefined) sectionAttrs.id = id;\n  if (ariaLabel !== undefined) sectionAttrs['aria-label'] = ariaLabel;\n  if (ariaLabelledBy !== undefined) sectionAttrs['aria-labelledby'] = ariaLabelledBy;\n\n  return (\n    <WebsiteSectionContextProvider value={sectionContextValue}>\n      <section\n        data-section-ref={safeSectionRef as unknown as string}\n        data-section-category={category}\n        {...sectionAttrs}\n      >\n        {children}\n      </section>\n    </WebsiteSectionContextProvider>\n  );\n}\nWebsiteSection.displayName = 'WebsiteSection';\n/** @wildo_source:part:end saas.website.section.component */\n"]}

package/dist/esm/core/routing/internal-routing.utils.d.ts

@@ -0,0 +1,65 @@
+import type { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+/**
+ * @wildo_source:part:start saas.website.routing.localized-path facet:layer:core facet:family:website
+ *
+ * `buildLocalizedRoutePath(opts)` — pure, isomorphic helper that
+ * returns the locale-prefixed pathname for a given route, honoring the
+ * marketing-site routing convention enforced by `buildAstroI18nConfig`
+ * (`prefixDefaultLocale: false`).
+ *
+ * **The architectural problem this solves**: the marketing site mounts the
+ * default locale at the
+ * un-prefixed path (`/`, `/pricing`, `/contact`) and every other locale
+ * under `/<locale>/…` (`/fr/`, `/fr/pricing`, `/fr/contact`). Internal
+ * links authored as raw `href="/pricing"` therefore work on
+ * default-locale pages and SILENTLY BREAK on non-default-locale pages
+ * (a French visitor on `/fr/index` clicking "Pricing" lands on the
+ * English `/pricing`, falling out of their locale).
+ *
+ * **Why a helper rather than asking authors to construct the path**:
+ * the rule is a framework-level routing convention — every consumer
+ * authors links the same way, every consumer must apply the same
+ * prefix logic, and getting it wrong produces a silent locale-leak
+ * that test suites do not catch (they navigate inside a single
+ * locale). A single helper makes the rule the framework's
+ * responsibility, not the section author's.
+ *
+ * **Routing rule** (matches `buildAstroI18nConfig` and the head
+ * renderer's `buildAbsoluteUrl` helper, which delegates here as the
+ * single source of truth):
+ *   - When `locale === defaultLocale`: return `routePath` verbatim
+ *     (the un-prefixed path).
+ *   - Otherwise: return `/<locale>${routePath}`, with the special
+ *     case that `routePath === '/'` collapses to `/<locale>` (no
+ *     trailing slash) so the locale-prefixed root does not become
+ *     the awkward `/<locale>/`.
+ *
+ * **Inputs are validated by the calling layer**, not here:
+ *   - `locale` is `AvailableLanguage` (branded), so the type system
+ *     prevents an unknown locale from reaching this function.
+ *   - `routePath` is the same `routePath` field validated by the page
+ *     manifest schema (`WebsitePageRoutePathSchema` enforces it
+ *     starts with `/`). We do not re-validate here — duplicate
+ *     validation costs CPU on every link render with no incremental
+ *     safety, and the page-manifest layer fails loud at config-load
+ *     time if a malformed path leaks in.
+ *
+ * **Boundary**: pure function, zero React / DOM / fs dependencies.
+ * Safe to import from both the React-island bundle (consumed by
+ * `WebsiteInternalLink`) and the SSR head renderer (consumed by
+ * `buildAbsoluteUrl`). The package's routing tests pin this behavior.
+ */
+export interface BuildLocalizedRoutePathOptions {
+    /** The currently-active locale (typically from `useWebsiteRuntime().locale`). */
+    locale: AvailableLanguage;
+    /** The site's default locale (typically from `useWebsiteRuntime().defaultLocale`). */
+    defaultLocale: AvailableLanguage;
+    /**
+     * The page's route path, exactly as declared in
+     * `WebsitePageManifest.routePath` (always starts with `/`).
+     */
+    routePath: string;
+}
+export declare function buildLocalizedRoutePath(opts: BuildLocalizedRoutePathOptions): string;
+/** @wildo_source:part:end saas.website.routing.localized-path */
+//# sourceMappingURL=internal-routing.utils.d.ts.map

package/dist/esm/core/routing/internal-routing.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-routing.utils.d.ts","sourceRoot":"","sources":["../../../../../src/core/routing/internal-routing.utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAM,WAAW,8BAA8B;IAC7C,iFAAiF;IACjF,MAAM,EAAE,iBAAiB,CAAC;IAC1B,sFAAsF;IACtF,aAAa,EAAE,iBAAiB,CAAC;IACjC;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,8BAA8B,GAAG,MAAM,CAWpF;AACD,iEAAiE"}

package/dist/esm/core/routing/internal-routing.utils.js

@@ -0,0 +1,14 @@
+export function buildLocalizedRoutePath(opts) {
+    const { locale, defaultLocale, routePath } = opts;
+    const localeStr = String(locale);
+    const defaultLocaleStr = String(defaultLocale);
+    if (localeStr === defaultLocaleStr) {
+        return routePath;
+    }
+    if (routePath === '/') {
+        return `/${localeStr}`;
+    }
+    return `/${localeStr}${routePath}`;
+}
+/** @wildo_source:part:end saas.website.routing.localized-path */
+//# sourceMappingURL=internal-routing.utils.js.map

package/dist/esm/core/routing/internal-routing.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-routing.utils.js","sourceRoot":"","sources":["../../../../../src/core/routing/internal-routing.utils.ts"],"names":[],"mappings":"AAgEA,MAAM,UAAU,uBAAuB,CAAC,IAAoC;IAC1E,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAClD,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACjC,MAAM,gBAAgB,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;IAC/C,IAAI,SAAS,KAAK,gBAAgB,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,SAAS,KAAK,GAAG,EAAE,CAAC;QACtB,OAAO,IAAI,SAAS,EAAE,CAAC;IACzB,CAAC;IACD,OAAO,IAAI,SAAS,GAAG,SAAS,EAAE,CAAC;AACrC,CAAC;AACD,iEAAiE","sourcesContent":["import type { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';\n\n/**\n * @wildo_source:part:start saas.website.routing.localized-path facet:layer:core facet:family:website\n *\n * `buildLocalizedRoutePath(opts)` — pure, isomorphic helper that\n * returns the locale-prefixed pathname for a given route, honoring the\n * marketing-site routing convention enforced by `buildAstroI18nConfig`\n * (`prefixDefaultLocale: false`).\n *\n * **The architectural problem this solves**: the marketing site mounts the\n * default locale at the\n * un-prefixed path (`/`, `/pricing`, `/contact`) and every other locale\n * under `/<locale>/…` (`/fr/`, `/fr/pricing`, `/fr/contact`). Internal\n * links authored as raw `href=\"/pricing\"` therefore work on\n * default-locale pages and SILENTLY BREAK on non-default-locale pages\n * (a French visitor on `/fr/index` clicking \"Pricing\" lands on the\n * English `/pricing`, falling out of their locale).\n *\n * **Why a helper rather than asking authors to construct the path**:\n * the rule is a framework-level routing convention — every consumer\n * authors links the same way, every consumer must apply the same\n * prefix logic, and getting it wrong produces a silent locale-leak\n * that test suites do not catch (they navigate inside a single\n * locale). A single helper makes the rule the framework's\n * responsibility, not the section author's.\n *\n * **Routing rule** (matches `buildAstroI18nConfig` and the head\n * renderer's `buildAbsoluteUrl` helper, which delegates here as the\n * single source of truth):\n *   - When `locale === defaultLocale`: return `routePath` verbatim\n *     (the un-prefixed path).\n *   - Otherwise: return `/<locale>${routePath}`, with the special\n *     case that `routePath === '/'` collapses to `/<locale>` (no\n *     trailing slash) so the locale-prefixed root does not become\n *     the awkward `/<locale>/`.\n *\n * **Inputs are validated by the calling layer**, not here:\n *   - `locale` is `AvailableLanguage` (branded), so the type system\n *     prevents an unknown locale from reaching this function.\n *   - `routePath` is the same `routePath` field validated by the page\n *     manifest schema (`WebsitePageRoutePathSchema` enforces it\n *     starts with `/`). We do not re-validate here — duplicate\n *     validation costs CPU on every link render with no incremental\n *     safety, and the page-manifest layer fails loud at config-load\n *     time if a malformed path leaks in.\n *\n * **Boundary**: pure function, zero React / DOM / fs dependencies.\n * Safe to import from both the React-island bundle (consumed by\n * `WebsiteInternalLink`) and the SSR head renderer (consumed by\n * `buildAbsoluteUrl`). The package's routing tests pin this behavior.\n */\nexport interface BuildLocalizedRoutePathOptions {\n  /** The currently-active locale (typically from `useWebsiteRuntime().locale`). */\n  locale: AvailableLanguage;\n  /** The site's default locale (typically from `useWebsiteRuntime().defaultLocale`). */\n  defaultLocale: AvailableLanguage;\n  /**\n   * The page's route path, exactly as declared in\n   * `WebsitePageManifest.routePath` (always starts with `/`).\n   */\n  routePath: string;\n}\n\nexport function buildLocalizedRoutePath(opts: BuildLocalizedRoutePathOptions): string {\n  const { locale, defaultLocale, routePath } = opts;\n  const localeStr = String(locale);\n  const defaultLocaleStr = String(defaultLocale);\n  if (localeStr === defaultLocaleStr) {\n    return routePath;\n  }\n  if (routePath === '/') {\n    return `/${localeStr}`;\n  }\n  return `/${localeStr}${routePath}`;\n}\n/** @wildo_source:part:end saas.website.routing.localized-path */\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @wildo-package @wildo-ai/saas-website
+ *
+ * SaaS marketing/landing website engine — schemas + helpers + layout
+ * placeholders + Astro/MDX adapters + SEO/AEO/GEO builder library.
+ *
+ * Per `saas-website-slice.md` D6/D15: this engine ships **NO concrete
+ * business sections** (no Hero, no CTA, no Pricing). It ships the
+ * structural and helper machinery; consumers author every business
+ * section themselves via the `defineWebsiteSection` factory and the
+ * accompanying SKILLs in `framework-knowledge`.
+ *
+ * @wildo-boundary
+ *   - This barrel MAY re-export from any subdirectory of `src/`.
+ *   - Subdirectories MUST observe their own boundary contracts (see
+ *     each subdirectory's own `index.ts` `@wildo-boundary` block):
+ *       - `schemas/`            : NO React, NO Astro, NO `~wildo-frontend-lib/**`
+ *       - `seo/`                : NO React, NO Astro
+ *       - `core/`               : MAY use React; NO `~wildo-frontend-lib/**` (Q17=B)
+ *       - `astro/`              : MAY use Astro; NO React component runtime imports
+ *       - `mdx/`                : MAY use `@mdx-js/*`
+ *       - `integration/`        : MAY use React; MAY import the
+ *                                 `@wildo-ai/saas-models/public-runtime` SUBPATH,
+ *                                 the `@wildo-ai/presets-components-models/public-runtime`
+ *                                 SUBPATH, `@wildo-ai/zod-decorators`,
+ *                                 plus the SSR / Astro-middleware tier
+ *                                 (`axios`, `jsonwebtoken`, `socket.io-client`,
+ *                                 `reflect-metadata`) — D12 revised
+ *                                 2026-04-19 (second same-day loosening);
+ *                                 the ROOT barrels of `@wildo-ai/saas-models`
+ *                                 and `@wildo-ai/presets-components-models`
+ *                                 are FORBIDDEN (they boot the decorator
+ *                                 framework / pull the heavy registry);
+ *                                 the saas-app DI / backend stack
+ *                                 (`inversify`, `mongoose`, `express`,
+ *                                 `pino`, `helmet`, `argon2`, `bcrypt`,
+ *                                 the `@wildo-ai/saas-frontend-lib` /
+ *                                 `@wildo-ai/saas-backend-lib` /
+ *                                 `@wildo-ai/external-connectors-models`
+ *                                 root + subpath surfaces) is FORBIDDEN;
+ *                                 MUST NOT import `~wildo-frontend-lib/**`
+ *                                 (Q17=B / D16)
+ *
+ *   D12 (client-bundle import discipline, all `core/`/`schemas/`/`integration/`
+ *   files): the entire saas-website source tree ships into a browser bundle
+ *   (Astro SSG + React islands). Every shared model atom MUST come from a
+ *   side-effect-free `/public-runtime` subpath:
+ *     - `@wildo-ai/saas-models/public-runtime` is the primary door
+ *       (saas-models-public-runtime.md K-6 — consumers see one path).
+ *     - `@wildo-ai/presets-components-models/public-runtime` is the
+ *       internal seam for symbols not (yet) re-exported by saas-models.
+ *     - `@wildo-ai/zod-decorators` is allowed to import (first revision
+ *       2026-04-19). The package itself is side-effect-free; only an
+ *       explicit `initZodDecorators()` call mutates `z.ZodType.prototype`,
+ *       which neither saas-website nor the saas-models /public-runtime
+ *       barrel does.
+ *     - `axios`, `jsonwebtoken`, `socket.io-client`, `reflect-metadata` are
+ *       allowed for SSR / Astro-middleware code paths (second same-day
+ *       revision 2026-04-19). The website engine needs them to provide
+ *       middleware utilities (HTTP proxying to the SaaS backend, JWT
+ *       verification of cross-frontend handoff codes, real-time push,
+ *       decorator-metadata reads). They are SSR-tier — discipline
+ *       (and a future strict/loose entry split for React islands vs
+ *       middleware) keeps them out of the React-island bundle.
+ *
+ *   The ROOT barrel of `@wildo-ai/saas-models` is forbidden everywhere in
+ *   this package — it calls `initZodDecorators()` at module load and pulls
+ *   `@wildo-ai/external-connectors-models` + the full schema graph into
+ *   the bundle. Same forbid applies to the root barrel of
+ *   `@wildo-ai/presets-components-models`, the saas-app DI runtime
+ *   (`inversify`, `@wildo-ai/saas-frontend-lib`, `@wildo-ai/saas-backend-lib`),
+ *   and pure-backend libs (`mongoose`, `express`, `pino`, `helmet`,
+ *   `argon2`, `bcrypt`). Enforced by `src/__tests__/bundle-isolation.test.ts`.
+ *
+ *   These boundaries are enforced by review + the bundle-isolation test
+ *   above until Phase 8 promotes them to a programmatic ESLint check
+ *   (cf. `saas-website-slice.md`
+ *   §"DEFERRED to Phase 8 — boundary lint mechanism design").
+ *
+ * Phase 1+2 status: schemas + runtime contexts/hooks + layout
+ * primitives + L1 placeholders + factories are all exported. Phase 5
+ * adds the Astro adapter; Phase 5.7 the `integration/` layer.
+ *
+ * D18 (L1 boundary, Phase 2): the L1 primitives (`WebsiteHeading`,
+ * `WebsiteText`, `WebsiteButton`, `WebsiteLink`, `WebsiteImage`) are
+ * self-contained placeholders — they do NOT consume
+ * `ComponentRegistryService` from `saas-frontend-lib` and do NOT
+ * re-export `saas-frontend-lib` primitives. Consumers override at the
+ * L1 boundary by barrel-re-exporting their preferred styled variant
+ * from their app's `app/website/primitives/<Primitive>.tsx`. Phase 6
+ * dogfood will revisit and decide whether to promote a registry-based
+ * override mechanism.
+ */
+export * from './schemas/refs/page-ref.schemas';
+export * from './schemas/refs/section-ref.schemas';
+export * from './schemas/label-keys/website-label-key.schemas';
+export * from './schemas/sections/website-section-category.shared';
+export * from './schemas/sections/website-section-definition.shared.schemas';
+export * from './schemas/structured-data/website-structured-data.shared.schemas';
+export * from './schemas/structured-data/structured-data-reconciliation.shared';
+export * from './schemas/design-tokens/website-design-tokens.shared.schemas';
+export * from './schemas/manifests/website-page-manifest.shared.schemas';
+export * from './schemas/manifests/website-root-config.shared.schemas';
+export * from './schemas/blog/blog-post-frontmatter.shared.schemas';
+export * from './schemas/validators/label-pack.validator';
+export * from './core/contexts/WebsiteRuntimeContext';
+export * from './core/contexts/useWebsiteRuntime';
+export * from './core/contexts/WebsitePageContext';
+export * from './core/contexts/useWebsitePage';
+export * from './core/contexts/WebsiteSectionContext';
+export * from './core/contexts/useWebsiteSection';
+export * from './core/hooks/useWebsiteLabel';
+export * from './core/hooks/useWebsiteDesignTokens';
+export * from './core/factories/define-website-section';
+export * from './core/factories/define-website-page-manifest';
+export * from './core/layouts/WebsitePageLayout';
+export * from './core/layouts/WebsiteSection';
+export * from './core/anonymous-session/website-anonymous-session-client';
+export * from './core/anonymous-session/inbound-contact-form.schema';
+export * from './core/anonymous-session/InboundContactForm';
+export * from './components/low-level/WebsiteHeading';
+export * from './components/low-level/WebsiteText';
+export * from './components/low-level/WebsiteLink';
+export * from './components/low-level/WebsiteInternalLink';
+export * from './core/routing/internal-routing.utils';
+export * from './components/low-level/WebsiteButton';
+export * from './components/low-level/WebsiteInternalButton';
+export * from './components/low-level/WebsiteImage';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4FG;AAEH,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,oDAAoD,CAAC;AACnE,cAAc,8DAA8D,CAAC;AAC7E,cAAc,kEAAkE,CAAC;AACjF,cAAc,iEAAiE,CAAC;AAChF,cAAc,8DAA8D,CAAC;AAC7E,cAAc,0DAA0D,CAAC;AACzE,cAAc,wDAAwD,CAAC;AACvE,cAAc,qDAAqD,CAAC;AACpE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,2DAA2D,CAAC;AAC1E,cAAc,sDAAsD,CAAC;AACrE,cAAc,6CAA6C,CAAC;AAE5D,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uCAAuC,CAAC;AACtD,cAAc,sCAAsC,CAAC;AACrD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,qCAAqC,CAAC"}