@wildo-ai/saas-website 1.1.1

package/dist/esm/astro/robots-renderer.d.ts

@@ -0,0 +1,85 @@
+import type { WebsiteSiteContext } from './website-site-context';
+/**
+ * @wildo_source:part:start saas.website.astro.robots-renderer facet:layer:astro facet:family:website
+ *
+ * `renderRobotsTxt(siteContext)` — pure string builder for the
+ * marketing site's `robots.txt` body. The consumer wires a thin
+ * `src/pages/robots.txt.ts` Astro endpoint that imports this helper
+ * + `WEBSITE_SITE_CONTEXT` and returns its output as a `Response`
+ * with `Content-Type: text/plain` (see `website-seo-aeo-geo` SKILL).
+ *
+ * # Why a pure string builder (not an Astro component)
+ *
+ * Same rationale as `renderWebsitePageHeadHtml`:
+ *   1. Pure TypeScript ships through the `@wildo-ai/saas-website/astro`
+ *      subpath barrel (Astro components do not).
+ *   2. Vitest-friendly — every policy permutation is asserted
+ *      against the returned string without an Astro test harness.
+ *   3. The Astro endpoint stays a 3-line shim the consumer can
+ *      audit at a glance.
+ *
+ * # Output shape
+ *
+ * The emitted text follows the de-facto `robots.txt` ordering
+ * (RFC 9309 §2 + Google's published guidance):
+ *
+ *   1. Per-bot blocks for `allowedCrawlers` (deny-by-default
+ *      direction) — each named bot gets its own `User-agent: <bot>`
+ *      + `Allow: /` block.
+ *   2. Per-bot blocks for `disallowedCrawlers` (allow-by-default
+ *      direction) — each named bot gets its own `User-agent: <bot>`
+ *      + `Disallow: /` block.
+ *   3. Catch-all `User-agent: *` block carrying the site-wide
+ *      `policy` (`Disallow: /` if `policy === 'noindex'` OR if
+ *      `allowedCrawlers` is set, otherwise nothing) and any
+ *      `disallow[]` path-prefix entries.
+ *   4. `Sitemap: <publicOrigin>/sitemap-index.xml` footer when
+ *      `seo.sitemap?.enabled !== false` (defaults to `true`).
+ *      `@astrojs/sitemap` emits `sitemap-index.xml` regardless of
+ *      whether the site has one or many sitemap files (the index
+ *      is always-present per the plugin's contract), so this is
+ *      the stable URL to advertise.
+ *
+ * # Mutual-exclusion invariant
+ *
+ * `WebsiteRobotsConfigSchema.superRefine` already guarantees
+ * `allowedCrawlers` and `disallowedCrawlers` are NOT both set, so
+ * step 1 and step 2 above are mutually exclusive at the input
+ * layer. The string builder is defensive (handles both being unset)
+ * but does NOT re-validate the invariant.
+ *
+ * # Why we always emit `Sitemap:` footer when `enabled !== false`
+ *
+ * The `Sitemap:` directive is independent from any `User-agent`
+ * block — it is a top-level signal to any crawler that the site
+ * publishes a sitemap. Even when the catch-all policy is
+ * `Disallow: /` (e.g. `policy === 'noindex'`), the `Sitemap:` line
+ * stays useful: a crawler that ignores `noindex` (Bing was famous
+ * for this) at least has a single canonical URL list to consult,
+ * and human readers of `robots.txt` see the publication contract
+ * intact.
+ *
+ * # Failure modes
+ *
+ * - `siteContext.websiteConfig.publicOrigin` undefined → throws.
+ *   The marketing-site origin is the SINGLE source of truth for
+ *   absolute URL composition (see `WildoMarketingWebsiteConfig`
+ *   JSDoc); a missing origin is a configuration error, not a
+ *   silent fallback opportunity.
+ *
+ * @example
+ * ```ts
+ * // examples/<app>/website/src/pages/robots.txt.ts
+ * import type { APIRoute } from 'astro';
+ * import { renderRobotsTxt } from '@wildo-ai/saas-website/astro';
+ * import { WEBSITE_SITE_CONTEXT } from '@/website-site-context';
+ *
+ * export const GET: APIRoute = () =>
+ *   new Response(renderRobotsTxt(WEBSITE_SITE_CONTEXT), {
+ *     headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+ *   });
+ * ```
+ */
+export declare function renderRobotsTxt(siteContext: WebsiteSiteContext): string;
+/** @wildo_source:part:end saas.website.astro.robots-renderer */
+//# sourceMappingURL=robots-renderer.d.ts.map

package/dist/esm/astro/robots-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"robots-renderer.d.ts","sourceRoot":"","sources":["../../../../src/astro/robots-renderer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,kBAAkB,GAAG,MAAM,CAkFvE;AACD,gEAAgE"}

package/dist/esm/astro/robots-renderer.js

@@ -0,0 +1,157 @@
+/**
+ * @wildo_source:part:start saas.website.astro.robots-renderer facet:layer:astro facet:family:website
+ *
+ * `renderRobotsTxt(siteContext)` — pure string builder for the
+ * marketing site's `robots.txt` body. The consumer wires a thin
+ * `src/pages/robots.txt.ts` Astro endpoint that imports this helper
+ * + `WEBSITE_SITE_CONTEXT` and returns its output as a `Response`
+ * with `Content-Type: text/plain` (see `website-seo-aeo-geo` SKILL).
+ *
+ * # Why a pure string builder (not an Astro component)
+ *
+ * Same rationale as `renderWebsitePageHeadHtml`:
+ *   1. Pure TypeScript ships through the `@wildo-ai/saas-website/astro`
+ *      subpath barrel (Astro components do not).
+ *   2. Vitest-friendly — every policy permutation is asserted
+ *      against the returned string without an Astro test harness.
+ *   3. The Astro endpoint stays a 3-line shim the consumer can
+ *      audit at a glance.
+ *
+ * # Output shape
+ *
+ * The emitted text follows the de-facto `robots.txt` ordering
+ * (RFC 9309 §2 + Google's published guidance):
+ *
+ *   1. Per-bot blocks for `allowedCrawlers` (deny-by-default
+ *      direction) — each named bot gets its own `User-agent: <bot>`
+ *      + `Allow: /` block.
+ *   2. Per-bot blocks for `disallowedCrawlers` (allow-by-default
+ *      direction) — each named bot gets its own `User-agent: <bot>`
+ *      + `Disallow: /` block.
+ *   3. Catch-all `User-agent: *` block carrying the site-wide
+ *      `policy` (`Disallow: /` if `policy === 'noindex'` OR if
+ *      `allowedCrawlers` is set, otherwise nothing) and any
+ *      `disallow[]` path-prefix entries.
+ *   4. `Sitemap: <publicOrigin>/sitemap-index.xml` footer when
+ *      `seo.sitemap?.enabled !== false` (defaults to `true`).
+ *      `@astrojs/sitemap` emits `sitemap-index.xml` regardless of
+ *      whether the site has one or many sitemap files (the index
+ *      is always-present per the plugin's contract), so this is
+ *      the stable URL to advertise.
+ *
+ * # Mutual-exclusion invariant
+ *
+ * `WebsiteRobotsConfigSchema.superRefine` already guarantees
+ * `allowedCrawlers` and `disallowedCrawlers` are NOT both set, so
+ * step 1 and step 2 above are mutually exclusive at the input
+ * layer. The string builder is defensive (handles both being unset)
+ * but does NOT re-validate the invariant.
+ *
+ * # Why we always emit `Sitemap:` footer when `enabled !== false`
+ *
+ * The `Sitemap:` directive is independent from any `User-agent`
+ * block — it is a top-level signal to any crawler that the site
+ * publishes a sitemap. Even when the catch-all policy is
+ * `Disallow: /` (e.g. `policy === 'noindex'`), the `Sitemap:` line
+ * stays useful: a crawler that ignores `noindex` (Bing was famous
+ * for this) at least has a single canonical URL list to consult,
+ * and human readers of `robots.txt` see the publication contract
+ * intact.
+ *
+ * # Failure modes
+ *
+ * - `siteContext.websiteConfig.publicOrigin` undefined → throws.
+ *   The marketing-site origin is the SINGLE source of truth for
+ *   absolute URL composition (see `WildoMarketingWebsiteConfig`
+ *   JSDoc); a missing origin is a configuration error, not a
+ *   silent fallback opportunity.
+ *
+ * @example
+ * ```ts
+ * // examples/<app>/website/src/pages/robots.txt.ts
+ * import type { APIRoute } from 'astro';
+ * import { renderRobotsTxt } from '@wildo-ai/saas-website/astro';
+ * import { WEBSITE_SITE_CONTEXT } from '@/website-site-context';
+ *
+ * export const GET: APIRoute = () =>
+ *   new Response(renderRobotsTxt(WEBSITE_SITE_CONTEXT), {
+ *     headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+ *   });
+ * ```
+ */
+export function renderRobotsTxt(siteContext) {
+    const { rootConfig, websiteConfig } = siteContext;
+    if (!websiteConfig.publicOrigin) {
+        throw new Error('renderRobotsTxt: WildoMarketingWebsiteConfig.publicOrigin is required to compose the absolute Sitemap: URL. Author it in your service\'s `wildo.website.config.ts`.');
+    }
+    const robots = rootConfig.seo.robots;
+    const policy = robots?.policy ?? 'index';
+    const allowedCrawlers = robots?.allowedCrawlers ?? [];
+    const disallowedCrawlers = robots?.disallowedCrawlers ?? [];
+    const disallow = robots?.disallow ?? [];
+    const blocks = [];
+    /**
+     * Block 1 — per-bot `Allow: /` for the deny-by-default direction.
+     * Empty when `allowedCrawlers` is unset (the dominant case).
+     */
+    for (const bot of allowedCrawlers) {
+        blocks.push(`User-agent: ${bot}\nAllow: /`);
+    }
+    /**
+     * Block 2 — per-bot `Disallow: /` for the allow-by-default
+     * direction. Empty when `disallowedCrawlers` is unset (the
+     * dominant case for a public marketing site).
+     */
+    for (const bot of disallowedCrawlers) {
+        blocks.push(`User-agent: ${bot}\nDisallow: /`);
+    }
+    /**
+     * Block 3 — catch-all `User-agent: *`. Two policy-driven shapes:
+     *   - `noindex` → `Disallow: /` (the site-wide closure).
+     *   - `index` (default) → `Disallow:` is the spec-canonical "allow
+     *     everything" line; combined with any per-path `Disallow: <path>`
+     *     entries from `disallow[]`. When `allowedCrawlers` is set, the
+     *     catch-all also closes the rest of the crawler universe with
+     *     `Disallow: /` so the named bots are the ONLY ones permitted.
+     */
+    const catchAllLines = ['User-agent: *'];
+    if (policy === 'noindex' || allowedCrawlers.length > 0) {
+        catchAllLines.push('Disallow: /');
+    }
+    else if (disallow.length === 0) {
+        /**
+         * Spec-canonical "allow everything" — `Disallow:` with no path.
+         * Some crawlers treat the absence of any `Disallow:` line as
+         * undefined behavior; an explicit empty Disallow is the safe
+         * shape.
+         */
+        catchAllLines.push('Disallow:');
+    }
+    for (const path of disallow) {
+        catchAllLines.push(`Disallow: ${path}`);
+    }
+    blocks.push(catchAllLines.join('\n'));
+    /**
+     * Block 4 — `Sitemap:` footer, advertised whenever sitemap
+     * emission is enabled (the marketing-site default). See file
+     * preamble for why we always advertise `sitemap-index.xml` as
+     * the stable URL.
+     */
+    const sitemapEnabled = rootConfig.seo.sitemap?.enabled ?? true;
+    if (sitemapEnabled) {
+        /**
+         * Trim trailing slash on the origin to avoid emitting
+         * `https://example.com//sitemap-index.xml`. `URL` constructor
+         * is overkill for a single concat; the regex is enough.
+         */
+        const origin = websiteConfig.publicOrigin.replace(/\/+$/, '');
+        blocks.push(`Sitemap: ${origin}/sitemap-index.xml`);
+    }
+    /**
+     * Spec-conformant trailing newline. Some crawler parsers tolerate
+     * its absence; emitting it is universally safe.
+     */
+    return `${blocks.join('\n\n')}\n`;
+}
+/** @wildo_source:part:end saas.website.astro.robots-renderer */
+//# sourceMappingURL=robots-renderer.js.map

package/dist/esm/astro/robots-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"robots-renderer.js","sourceRoot":"","sources":["../../../../src/astro/robots-renderer.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,MAAM,UAAU,eAAe,CAAC,WAA+B;IAC7D,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,WAAW,CAAC;IAElD,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,qKAAqK,CACtK,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAoC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;IACtE,MAAM,MAAM,GAAwB,MAAM,EAAE,MAAM,IAAI,OAAO,CAAC;IAC9D,MAAM,eAAe,GAAG,MAAM,EAAE,eAAe,IAAI,EAAE,CAAC;IACtD,MAAM,kBAAkB,GAAG,MAAM,EAAE,kBAAkB,IAAI,EAAE,CAAC;IAC5D,MAAM,QAAQ,GAAG,MAAM,EAAE,QAAQ,IAAI,EAAE,CAAC;IAExC,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B;;;OAGG;IACH,KAAK,MAAM,GAAG,IAAI,eAAe,EAAE,CAAC;QAClC,MAAM,CAAC,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,KAAK,MAAM,GAAG,IAAI,kBAAkB,EAAE,CAAC;QACrC,MAAM,CAAC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC,CAAC;IACjD,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,aAAa,GAAa,CAAC,eAAe,CAAC,CAAC;IAClD,IAAI,MAAM,KAAK,SAAS,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvD,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IACpC,CAAC;SAAM,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC;;;;;WAKG;QACH,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,aAAa,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAEtC;;;;;OAKG;IACH,MAAM,cAAc,GAAG,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,CAAC;IAC/D,IAAI,cAAc,EAAE,CAAC;QACnB;;;;WAIG;QACH,MAAM,MAAM,GAAG,aAAa,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,YAAY,MAAM,oBAAoB,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;AACpC,CAAC;AACD,gEAAgE","sourcesContent":["import type {\n  WebsiteRobotsConfig,\n} from '../schemas/manifests/website-root-config.shared.schemas';\n\nimport type { WebsiteSiteContext } from './website-site-context';\n\n/**\n * @wildo_source:part:start saas.website.astro.robots-renderer facet:layer:astro facet:family:website\n *\n * `renderRobotsTxt(siteContext)` — pure string builder for the\n * marketing site's `robots.txt` body. The consumer wires a thin\n * `src/pages/robots.txt.ts` Astro endpoint that imports this helper\n * + `WEBSITE_SITE_CONTEXT` and returns its output as a `Response`\n * with `Content-Type: text/plain` (see `website-seo-aeo-geo` SKILL).\n *\n * # Why a pure string builder (not an Astro component)\n *\n * Same rationale as `renderWebsitePageHeadHtml`:\n *   1. Pure TypeScript ships through the `@wildo-ai/saas-website/astro`\n *      subpath barrel (Astro components do not).\n *   2. Vitest-friendly — every policy permutation is asserted\n *      against the returned string without an Astro test harness.\n *   3. The Astro endpoint stays a 3-line shim the consumer can\n *      audit at a glance.\n *\n * # Output shape\n *\n * The emitted text follows the de-facto `robots.txt` ordering\n * (RFC 9309 §2 + Google's published guidance):\n *\n *   1. Per-bot blocks for `allowedCrawlers` (deny-by-default\n *      direction) — each named bot gets its own `User-agent: <bot>`\n *      + `Allow: /` block.\n *   2. Per-bot blocks for `disallowedCrawlers` (allow-by-default\n *      direction) — each named bot gets its own `User-agent: <bot>`\n *      + `Disallow: /` block.\n *   3. Catch-all `User-agent: *` block carrying the site-wide\n *      `policy` (`Disallow: /` if `policy === 'noindex'` OR if\n *      `allowedCrawlers` is set, otherwise nothing) and any\n *      `disallow[]` path-prefix entries.\n *   4. `Sitemap: <publicOrigin>/sitemap-index.xml` footer when\n *      `seo.sitemap?.enabled !== false` (defaults to `true`).\n *      `@astrojs/sitemap` emits `sitemap-index.xml` regardless of\n *      whether the site has one or many sitemap files (the index\n *      is always-present per the plugin's contract), so this is\n *      the stable URL to advertise.\n *\n * # Mutual-exclusion invariant\n *\n * `WebsiteRobotsConfigSchema.superRefine` already guarantees\n * `allowedCrawlers` and `disallowedCrawlers` are NOT both set, so\n * step 1 and step 2 above are mutually exclusive at the input\n * layer. The string builder is defensive (handles both being unset)\n * but does NOT re-validate the invariant.\n *\n * # Why we always emit `Sitemap:` footer when `enabled !== false`\n *\n * The `Sitemap:` directive is independent from any `User-agent`\n * block — it is a top-level signal to any crawler that the site\n * publishes a sitemap. Even when the catch-all policy is\n * `Disallow: /` (e.g. `policy === 'noindex'`), the `Sitemap:` line\n * stays useful: a crawler that ignores `noindex` (Bing was famous\n * for this) at least has a single canonical URL list to consult,\n * and human readers of `robots.txt` see the publication contract\n * intact.\n *\n * # Failure modes\n *\n * - `siteContext.websiteConfig.publicOrigin` undefined → throws.\n *   The marketing-site origin is the SINGLE source of truth for\n *   absolute URL composition (see `WildoMarketingWebsiteConfig`\n *   JSDoc); a missing origin is a configuration error, not a\n *   silent fallback opportunity.\n *\n * @example\n * ```ts\n * // examples/<app>/website/src/pages/robots.txt.ts\n * import type { APIRoute } from 'astro';\n * import { renderRobotsTxt } from '@wildo-ai/saas-website/astro';\n * import { WEBSITE_SITE_CONTEXT } from '@/website-site-context';\n *\n * export const GET: APIRoute = () =>\n *   new Response(renderRobotsTxt(WEBSITE_SITE_CONTEXT), {\n *     headers: { 'Content-Type': 'text/plain; charset=utf-8' },\n *   });\n * ```\n */\nexport function renderRobotsTxt(siteContext: WebsiteSiteContext): string {\n  const { rootConfig, websiteConfig } = siteContext;\n\n  if (!websiteConfig.publicOrigin) {\n    throw new Error(\n      'renderRobotsTxt: WildoMarketingWebsiteConfig.publicOrigin is required to compose the absolute Sitemap: URL. Author it in your service\\'s `wildo.website.config.ts`.',\n    );\n  }\n\n  const robots: WebsiteRobotsConfig | undefined = rootConfig.seo.robots;\n  const policy: 'index' | 'noindex' = robots?.policy ?? 'index';\n  const allowedCrawlers = robots?.allowedCrawlers ?? [];\n  const disallowedCrawlers = robots?.disallowedCrawlers ?? [];\n  const disallow = robots?.disallow ?? [];\n\n  const blocks: string[] = [];\n\n  /**\n   * Block 1 — per-bot `Allow: /` for the deny-by-default direction.\n   * Empty when `allowedCrawlers` is unset (the dominant case).\n   */\n  for (const bot of allowedCrawlers) {\n    blocks.push(`User-agent: ${bot}\\nAllow: /`);\n  }\n\n  /**\n   * Block 2 — per-bot `Disallow: /` for the allow-by-default\n   * direction. Empty when `disallowedCrawlers` is unset (the\n   * dominant case for a public marketing site).\n   */\n  for (const bot of disallowedCrawlers) {\n    blocks.push(`User-agent: ${bot}\\nDisallow: /`);\n  }\n\n  /**\n   * Block 3 — catch-all `User-agent: *`. Two policy-driven shapes:\n   *   - `noindex` → `Disallow: /` (the site-wide closure).\n   *   - `index` (default) → `Disallow:` is the spec-canonical \"allow\n   *     everything\" line; combined with any per-path `Disallow: <path>`\n   *     entries from `disallow[]`. When `allowedCrawlers` is set, the\n   *     catch-all also closes the rest of the crawler universe with\n   *     `Disallow: /` so the named bots are the ONLY ones permitted.\n   */\n  const catchAllLines: string[] = ['User-agent: *'];\n  if (policy === 'noindex' || allowedCrawlers.length > 0) {\n    catchAllLines.push('Disallow: /');\n  } else if (disallow.length === 0) {\n    /**\n     * Spec-canonical \"allow everything\" — `Disallow:` with no path.\n     * Some crawlers treat the absence of any `Disallow:` line as\n     * undefined behavior; an explicit empty Disallow is the safe\n     * shape.\n     */\n    catchAllLines.push('Disallow:');\n  }\n  for (const path of disallow) {\n    catchAllLines.push(`Disallow: ${path}`);\n  }\n  blocks.push(catchAllLines.join('\\n'));\n\n  /**\n   * Block 4 — `Sitemap:` footer, advertised whenever sitemap\n   * emission is enabled (the marketing-site default). See file\n   * preamble for why we always advertise `sitemap-index.xml` as\n   * the stable URL.\n   */\n  const sitemapEnabled = rootConfig.seo.sitemap?.enabled ?? true;\n  if (sitemapEnabled) {\n    /**\n     * Trim trailing slash on the origin to avoid emitting\n     * `https://example.com//sitemap-index.xml`. `URL` constructor\n     * is overkill for a single concat; the regex is enough.\n     */\n    const origin = websiteConfig.publicOrigin.replace(/\\/+$/, '');\n    blocks.push(`Sitemap: ${origin}/sitemap-index.xml`);\n  }\n\n  /**\n   * Spec-conformant trailing newline. Some crawler parsers tolerate\n   * its absence; emitting it is universally safe.\n   */\n  return `${blocks.join('\\n\\n')}\\n`;\n}\n/** @wildo_source:part:end saas.website.astro.robots-renderer */\n"]}

package/dist/esm/astro/sitemap-coverage.d.ts

@@ -0,0 +1,101 @@
+import type { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+import type { WebsiteSiteContext } from './website-site-context';
+/**
+ * @wildo_source:part:start saas.website.astro.sitemap-coverage facet:layer:astro facet:family:website
+ *
+ * `enumerateMarketingPageSitemapUrls(siteContext)` — pure helper that
+ * returns every (page-manifest × locale) absolute URL the marketing
+ * site's `sitemap.xml` MUST advertise, paired with its hreflang
+ * alternates.
+ *
+ * # Why this helper exists (vs leaning entirely on `@astrojs/sitemap`)
+ *
+ * `@astrojs/sitemap` (the official Astro plugin) auto-discovers every
+ * page Astro emits and emits a `sitemap-index.xml` + sub-sitemaps at
+ * build time. That covers the dominant case (every page in
+ * `src/pages/**` ships in the sitemap). What it does NOT cover by
+ * itself:
+ *
+ *   1. **Coverage enforcement at unit-test time.** The plugin runs
+ *      during `astro build`; vitest cannot exercise it without
+ *      booting the full Astro pipeline. This helper is the testable
+ *      surface — a regression that drops a manifest-registered route
+ *      from the expected URL set fails fast in vitest, well before
+ *      the `astro build` step would surface it (and even then only
+ *      via end-to-end inspection of the emitted XML).
+ *   2. **Programmatic page registration.** Future framework-owned
+ *      features that synthesize routes outside Astro's
+ *      file-based router (e.g. data-driven landing variants) need an
+ *      explicit URL list to pass into `@astrojs/sitemap`'s
+ *      `customPages` config. This helper is the canonical place to
+ *      compute that list — consumers spread the result into the
+ *      plugin config without re-deriving the locale × route logic.
+ *   3. **Cross-check.** The same site context that drives the head
+ *      renderer drives this enumeration; a divergence between
+ *      "what the head renderer thinks the canonical URL set is" and
+ *      "what the sitemap publishes" is a silent drift surface this
+ *      helper makes auditable.
+ *
+ * # Output shape
+ *
+ * Each entry carries:
+ *   - `url` — the absolute canonical URL (no trailing slash, matches
+ *     `<link rel="canonical">` output of `renderWebsitePageHeadHtml`).
+ *   - `pageRef` — the page-manifest `ref` (debug + grouping aid).
+ *   - `routePath` — the manifest-declared `routePath` (debug + grouping aid).
+ *   - `locale` — the URL's language.
+ *   - `alternates` — every other locale's URL for the SAME page,
+ *     emitted as `xhtml:link rel="alternate" hreflang` entries inside
+ *     the sitemap (single-sitemap-with-hreflang shape, per Google's
+ *     recommended sitemap format).
+ *
+ * # Routing convention (matches `buildLocalizedRoutePath`)
+ *
+ * Default locale mounts at the un-prefixed path (`/`, `/pricing`);
+ * other locales sit under `/<locale>/…`. The helper delegates to
+ * `buildLocalizedRoutePath` so a future change to the routing
+ * convention lands in one file rather than two.
+ *
+ * # What this helper does NOT enumerate
+ *
+ * - **Blog post slugs.** Blog posts share ONE page-manifest ref
+ *   (`BLOG_POST_PAGE_REF`) but materialize as N URLs — one per
+ *   `(slug, locale)` MDX file. The MDX file system is the
+ *   source-of-truth for blog URLs, NOT the page manifest. Astro's
+ *   file-based router auto-discovers each blog `[slug].astro` route
+ *   and `@astrojs/sitemap` auto-publishes them. A future helper
+ *   (`enumerateBlogPostSitemapUrls(...)`) can address the same
+ *   coverage-enforcement gap for the blog surface specifically.
+ * - **Static `.astro` pages without a page manifest.** If a consumer
+ *   authors a page directly in `src/pages/` without registering a
+ *   manifest in `WebsiteRootConfig.pageManifests`, this helper will
+ *   not list it (and `renderWebsitePageHeadHtml` cannot render its
+ *   `<head>` either). The framework convention is "every public
+ *   page has a manifest" — pages without manifests are a label-pack
+ *   discipline regression and surface separately via
+ *   `assertLabelPacksValid`.
+ */
+export interface MarketingPageSitemapEntry {
+    /** Absolute canonical URL, no trailing slash. */
+    readonly url: string;
+    /** The page-manifest `ref` (branded string in the source schema). */
+    readonly pageRef: string;
+    /** The manifest-declared `routePath` (always starts with `/`). */
+    readonly routePath: string;
+    /** The URL's language. */
+    readonly locale: AvailableLanguage;
+    /**
+     * Every OTHER locale's URL for the same page, suitable for emitting
+     * `xhtml:link rel="alternate" hreflang` entries inside the sitemap.
+     * Includes an `x-default` synthesized from the default-locale URL
+     * (Google's i18n discoverability convention; matches the head
+     * renderer's hreflang output).
+     */
+    readonly alternates: readonly {
+        readonly hreflang: string;
+        readonly url: string;
+    }[];
+}
+export declare function enumerateMarketingPageSitemapUrls(siteContext: WebsiteSiteContext): readonly MarketingPageSitemapEntry[];
+/** @wildo_source:part:end saas.website.astro.sitemap-coverage */
+//# sourceMappingURL=sitemap-coverage.d.ts.map

package/dist/esm/astro/sitemap-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap-coverage.d.ts","sourceRoot":"","sources":["../../../../src/astro/sitemap-coverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAK9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,MAAM,WAAW,yBAAyB;IACxC,iDAAiD;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0BAA0B;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS;QAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACrF;AAED,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,kBAAkB,GAC9B,SAAS,yBAAyB,EAAE,CAiFtC;AACD,iEAAiE"}

package/dist/esm/astro/sitemap-coverage.js

@@ -0,0 +1,67 @@
+import { buildLocalizedRoutePath } from '../core/routing/internal-routing.utils.js';
+export function enumerateMarketingPageSitemapUrls(siteContext) {
+    const { rootConfig, websiteConfig } = siteContext;
+    if (!websiteConfig.publicOrigin) {
+        throw new Error('enumerateMarketingPageSitemapUrls: WildoMarketingWebsiteConfig.publicOrigin is required to compose absolute sitemap URLs. Author it in your service\'s `wildo.website.config.ts`.');
+    }
+    /**
+     * Trim trailing slash defensively (the schema-level refinement
+     * already rejects them, but the helper is consumed in synthetic
+     * test contexts that bypass the parser).
+     */
+    const origin = websiteConfig.publicOrigin.replace(/\/+$/, '');
+    const defaultLocale = websiteConfig.defaultLocale;
+    const locales = websiteConfig.locales.map((entry) => entry.locale);
+    const entries = [];
+    for (const manifest of rootConfig.pageManifests) {
+        const routePath = manifest.routePath;
+        const pageRef = manifest.ref;
+        /**
+         * Pre-compute every locale's URL for this page once — each entry
+         * needs the full set as its `alternates` (with itself excluded
+         * later if/when the consumer wants the strict
+         * "alternates-don't-include-self" shape; today we keep the full
+         * set + add `x-default` for parity with the head renderer's
+         * hreflang output).
+         */
+        const urlsByLocale = new Map();
+        for (const locale of locales) {
+            const localizedPath = buildLocalizedRoutePath({ locale, defaultLocale, routePath });
+            urlsByLocale.set(locale, `${origin}${localizedPath}`);
+        }
+        const defaultLocaleUrl = urlsByLocale.get(defaultLocale);
+        if (defaultLocaleUrl === undefined) {
+            throw new Error(`enumerateMarketingPageSitemapUrls: defaultLocale "${String(defaultLocale)}" is missing from WildoMarketingWebsiteConfig.locales (page "${pageRef}"). This is a configuration invariant — locales[] must include the default locale.`);
+        }
+        for (const locale of locales) {
+            const url = urlsByLocale.get(locale);
+            if (url === undefined) {
+                throw new Error(`enumerateMarketingPageSitemapUrls: missing computed URL for locale "${String(locale)}" on page "${pageRef}" (internal invariant violation).`);
+            }
+            const alternates = [];
+            for (const altLocale of locales) {
+                const altUrl = urlsByLocale.get(altLocale);
+                if (altUrl !== undefined) {
+                    alternates.push({ hreflang: String(altLocale), url: altUrl });
+                }
+            }
+            /**
+             * `x-default` — Google's hreflang convention for "the URL to
+             * serve when no locale signal is available". The marketing-site
+             * convention (default locale at the un-prefixed path) makes the
+             * default-locale URL the right `x-default` target.
+             */
+            alternates.push({ hreflang: 'x-default', url: defaultLocaleUrl });
+            entries.push({
+                url,
+                pageRef,
+                routePath,
+                locale,
+                alternates,
+            });
+        }
+    }
+    return entries;
+}
+/** @wildo_source:part:end saas.website.astro.sitemap-coverage */
+//# sourceMappingURL=sitemap-coverage.js.map

package/dist/esm/astro/sitemap-coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap-coverage.js","sourceRoot":"","sources":["../../../../src/astro/sitemap-coverage.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAmGjF,MAAM,UAAU,iCAAiC,CAC/C,WAA+B;IAE/B,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,WAAW,CAAC;IAElD,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,mLAAmL,CACpL,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,MAAM,MAAM,GAAG,aAAa,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC9D,MAAM,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC;IAClD,MAAM,OAAO,GAAiC,aAAa,CAAC,OAAO,CAAC,GAAG,CACrE,CAAC,KAAoC,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CACvD,CAAC;IAEF,MAAM,OAAO,GAAgC,EAAE,CAAC;IAEhD,KAAK,MAAM,QAAQ,IAAI,UAAU,CAAC,aAA+C,EAAE,CAAC;QAClF,MAAM,SAAS,GAAG,QAAQ,CAAC,SAA8B,CAAC;QAC1D,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAwB,CAAC;QAElD;;;;;;;WAOG;QACH,MAAM,YAAY,GAAG,IAAI,GAAG,EAA6B,CAAC;QAC1D,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,aAAa,GAAG,uBAAuB,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC,CAAC;YACpF,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,MAAM,GAAG,aAAa,EAAE,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,gBAAgB,GAAG,YAAY,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACzD,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CACb,qDAAqD,MAAM,CAAC,aAAa,CAAC,gEAAgE,OAAO,oFAAoF,CACtO,CAAC;QACJ,CAAC;QAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACrC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CACb,uEAAuE,MAAM,CAAC,MAAM,CAAC,cAAc,OAAO,mCAAmC,CAC9I,CAAC;YACJ,CAAC;YAED,MAAM,UAAU,GAAwC,EAAE,CAAC;YAC3D,KAAK,MAAM,SAAS,IAAI,OAAO,EAAE,CAAC;gBAChC,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;gBAC3C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,UAAU,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;gBAChE,CAAC;YACH,CAAC;YACD;;;;;eAKG;YACH,UAAU,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,EAAE,gBAAgB,EAAE,CAAC,CAAC;YAElE,OAAO,CAAC,IAAI,CAAC;gBACX,GAAG;gBACH,OAAO;gBACP,SAAS;gBACT,MAAM;gBACN,UAAU;aACX,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AACD,iEAAiE","sourcesContent":["import type { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';\n\nimport { buildLocalizedRoutePath } from '../core/routing/internal-routing.utils';\nimport type { WebsitePageManifest } from '../schemas/manifests/website-page-manifest.shared.schemas';\n\nimport type { WebsiteSiteContext } from './website-site-context';\n\n/**\n * @wildo_source:part:start saas.website.astro.sitemap-coverage facet:layer:astro facet:family:website\n *\n * `enumerateMarketingPageSitemapUrls(siteContext)` — pure helper that\n * returns every (page-manifest × locale) absolute URL the marketing\n * site's `sitemap.xml` MUST advertise, paired with its hreflang\n * alternates.\n *\n * # Why this helper exists (vs leaning entirely on `@astrojs/sitemap`)\n *\n * `@astrojs/sitemap` (the official Astro plugin) auto-discovers every\n * page Astro emits and emits a `sitemap-index.xml` + sub-sitemaps at\n * build time. That covers the dominant case (every page in\n * `src/pages/**` ships in the sitemap). What it does NOT cover by\n * itself:\n *\n *   1. **Coverage enforcement at unit-test time.** The plugin runs\n *      during `astro build`; vitest cannot exercise it without\n *      booting the full Astro pipeline. This helper is the testable\n *      surface — a regression that drops a manifest-registered route\n *      from the expected URL set fails fast in vitest, well before\n *      the `astro build` step would surface it (and even then only\n *      via end-to-end inspection of the emitted XML).\n *   2. **Programmatic page registration.** Future framework-owned\n *      features that synthesize routes outside Astro's\n *      file-based router (e.g. data-driven landing variants) need an\n *      explicit URL list to pass into `@astrojs/sitemap`'s\n *      `customPages` config. This helper is the canonical place to\n *      compute that list — consumers spread the result into the\n *      plugin config without re-deriving the locale × route logic.\n *   3. **Cross-check.** The same site context that drives the head\n *      renderer drives this enumeration; a divergence between\n *      \"what the head renderer thinks the canonical URL set is\" and\n *      \"what the sitemap publishes\" is a silent drift surface this\n *      helper makes auditable.\n *\n * # Output shape\n *\n * Each entry carries:\n *   - `url` — the absolute canonical URL (no trailing slash, matches\n *     `<link rel=\"canonical\">` output of `renderWebsitePageHeadHtml`).\n *   - `pageRef` — the page-manifest `ref` (debug + grouping aid).\n *   - `routePath` — the manifest-declared `routePath` (debug + grouping aid).\n *   - `locale` — the URL's language.\n *   - `alternates` — every other locale's URL for the SAME page,\n *     emitted as `xhtml:link rel=\"alternate\" hreflang` entries inside\n *     the sitemap (single-sitemap-with-hreflang shape, per Google's\n *     recommended sitemap format).\n *\n * # Routing convention (matches `buildLocalizedRoutePath`)\n *\n * Default locale mounts at the un-prefixed path (`/`, `/pricing`);\n * other locales sit under `/<locale>/…`. The helper delegates to\n * `buildLocalizedRoutePath` so a future change to the routing\n * convention lands in one file rather than two.\n *\n * # What this helper does NOT enumerate\n *\n * - **Blog post slugs.** Blog posts share ONE page-manifest ref\n *   (`BLOG_POST_PAGE_REF`) but materialize as N URLs — one per\n *   `(slug, locale)` MDX file. The MDX file system is the\n *   source-of-truth for blog URLs, NOT the page manifest. Astro's\n *   file-based router auto-discovers each blog `[slug].astro` route\n *   and `@astrojs/sitemap` auto-publishes them. A future helper\n *   (`enumerateBlogPostSitemapUrls(...)`) can address the same\n *   coverage-enforcement gap for the blog surface specifically.\n * - **Static `.astro` pages without a page manifest.** If a consumer\n *   authors a page directly in `src/pages/` without registering a\n *   manifest in `WebsiteRootConfig.pageManifests`, this helper will\n *   not list it (and `renderWebsitePageHeadHtml` cannot render its\n *   `<head>` either). The framework convention is \"every public\n *   page has a manifest\" — pages without manifests are a label-pack\n *   discipline regression and surface separately via\n *   `assertLabelPacksValid`.\n */\nexport interface MarketingPageSitemapEntry {\n  /** Absolute canonical URL, no trailing slash. */\n  readonly url: string;\n  /** The page-manifest `ref` (branded string in the source schema). */\n  readonly pageRef: string;\n  /** The manifest-declared `routePath` (always starts with `/`). */\n  readonly routePath: string;\n  /** The URL's language. */\n  readonly locale: AvailableLanguage;\n  /**\n   * Every OTHER locale's URL for the same page, suitable for emitting\n   * `xhtml:link rel=\"alternate\" hreflang` entries inside the sitemap.\n   * Includes an `x-default` synthesized from the default-locale URL\n   * (Google's i18n discoverability convention; matches the head\n   * renderer's hreflang output).\n   */\n  readonly alternates: readonly { readonly hreflang: string; readonly url: string }[];\n}\n\nexport function enumerateMarketingPageSitemapUrls(\n  siteContext: WebsiteSiteContext,\n): readonly MarketingPageSitemapEntry[] {\n  const { rootConfig, websiteConfig } = siteContext;\n\n  if (!websiteConfig.publicOrigin) {\n    throw new Error(\n      'enumerateMarketingPageSitemapUrls: WildoMarketingWebsiteConfig.publicOrigin is required to compose absolute sitemap URLs. Author it in your service\\'s `wildo.website.config.ts`.',\n    );\n  }\n\n  /**\n   * Trim trailing slash defensively (the schema-level refinement\n   * already rejects them, but the helper is consumed in synthetic\n   * test contexts that bypass the parser).\n   */\n  const origin = websiteConfig.publicOrigin.replace(/\\/+$/, '');\n  const defaultLocale = websiteConfig.defaultLocale;\n  const locales: readonly AvailableLanguage[] = websiteConfig.locales.map(\n    (entry: { locale: AvailableLanguage }) => entry.locale,\n  );\n\n  const entries: MarketingPageSitemapEntry[] = [];\n\n  for (const manifest of rootConfig.pageManifests as readonly WebsitePageManifest[]) {\n    const routePath = manifest.routePath as unknown as string;\n    const pageRef = manifest.ref as unknown as string;\n\n    /**\n     * Pre-compute every locale's URL for this page once — each entry\n     * needs the full set as its `alternates` (with itself excluded\n     * later if/when the consumer wants the strict\n     * \"alternates-don't-include-self\" shape; today we keep the full\n     * set + add `x-default` for parity with the head renderer's\n     * hreflang output).\n     */\n    const urlsByLocale = new Map<AvailableLanguage, string>();\n    for (const locale of locales) {\n      const localizedPath = buildLocalizedRoutePath({ locale, defaultLocale, routePath });\n      urlsByLocale.set(locale, `${origin}${localizedPath}`);\n    }\n\n    const defaultLocaleUrl = urlsByLocale.get(defaultLocale);\n    if (defaultLocaleUrl === undefined) {\n      throw new Error(\n        `enumerateMarketingPageSitemapUrls: defaultLocale \"${String(defaultLocale)}\" is missing from WildoMarketingWebsiteConfig.locales (page \"${pageRef}\"). This is a configuration invariant — locales[] must include the default locale.`,\n      );\n    }\n\n    for (const locale of locales) {\n      const url = urlsByLocale.get(locale);\n      if (url === undefined) {\n        throw new Error(\n          `enumerateMarketingPageSitemapUrls: missing computed URL for locale \"${String(locale)}\" on page \"${pageRef}\" (internal invariant violation).`,\n        );\n      }\n\n      const alternates: { hreflang: string; url: string }[] = [];\n      for (const altLocale of locales) {\n        const altUrl = urlsByLocale.get(altLocale);\n        if (altUrl !== undefined) {\n          alternates.push({ hreflang: String(altLocale), url: altUrl });\n        }\n      }\n      /**\n       * `x-default` — Google's hreflang convention for \"the URL to\n       * serve when no locale signal is available\". The marketing-site\n       * convention (default locale at the un-prefixed path) makes the\n       * default-locale URL the right `x-default` target.\n       */\n      alternates.push({ hreflang: 'x-default', url: defaultLocaleUrl });\n\n      entries.push({\n        url,\n        pageRef,\n        routePath,\n        locale,\n        alternates,\n      });\n    }\n  }\n\n  return entries;\n}\n/** @wildo_source:part:end saas.website.astro.sitemap-coverage */\n"]}

package/dist/esm/astro/structured-data.renderer.d.ts

@@ -0,0 +1,21 @@
+import type { WebsiteStructuredDataPayload } from '../schemas/structured-data/website-structured-data.shared.schemas';
+import type { WebsiteSectionDefinition } from '../schemas/sections/website-section-definition.shared.schemas';
+export interface RenderPageStructuredDataOptions {
+    /**
+     * Section definitions whose `getStructuredData()` (when present)
+     * contributes payloads to the page. Sections without
+     * `getStructuredData` are skipped silently.
+     */
+    sections?: readonly Pick<WebsiteSectionDefinition, 'sectionRef' | 'getStructuredData'>[];
+    /**
+     * Optional page-level payloads contributed by the page-shell
+     * itself (typical: `BreadcrumbList`, `Organization`, `WebSite`).
+     * Composed AFTER section payloads in the emission order so a
+     * section's `@id`-keyed payload wins over a page-level one with
+     * the same `@id` (last-wins; see preamble).
+     */
+    pagePayloads?: readonly WebsiteStructuredDataPayload[];
+}
+export declare function renderPageStructuredData(opts: RenderPageStructuredDataOptions): string;
+/** @wildo_source:part:end saas.website.astro.structured-data-renderer */
+//# sourceMappingURL=structured-data.renderer.d.ts.map

package/dist/esm/astro/structured-data.renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-data.renderer.d.ts","sourceRoot":"","sources":["../../../../src/astro/structured-data.renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAE7B,MAAM,mEAAmE,CAAC;AAC3E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+DAA+D,CAAC;AAgD9G,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,IAAI,CAAC,wBAAwB,EAAE,YAAY,GAAG,mBAAmB,CAAC,EAAE,CAAC;IACzF;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,SAAS,4BAA4B,EAAE,CAAC;CACxD;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,+BAA+B,GAAG,MAAM,CAiDtF;AAoDD,yEAAyE"}

package/dist/esm/astro/structured-data.renderer.js

@@ -0,0 +1,142 @@
+/**
+ * @wildo_source:part:start saas.website.astro.structured-data-renderer facet:layer:astro facet:family:website
+ *
+ * `renderPageStructuredData()` — collects every section's
+ * `getStructuredData()` return + any explicit page-level payloads,
+ * normalizes them, dedupes by `@id`, and emits one
+ * `<script type="application/ld+json">` block per surviving payload.
+ *
+ * **Why one `<script>` per payload (NOT a single `@graph` array)**:
+ *
+ * - Google's structured-data testing tool, Bing webmaster tools, and
+ *   the Schema.org reference parser all accept multiple sibling
+ *   `<script type="application/ld+json">` blocks. Emitting them as
+ *   separate blocks lets each payload be diff-friendly in the
+ *   page source AND lets per-payload removal happen on a future
+ *   AEO opt-out without churning the whole graph.
+ * - `@graph` is technically valid but harder to author — every
+ *   payload would need to share `@context` with the wrapper, and
+ *   per-section authors would have to coordinate to merge their
+ *   payloads into one shared graph. The "one script per payload"
+ *   pattern keeps section authoring fully local.
+ *
+ * **Why dedupe by `@id` (last-wins)**: a page may have a section
+ * emit a `Product` payload AND another section emit a `Review`
+ * referencing the same `Product` via `@id`. Without dedupe, the
+ * `Product` would emit twice (once standalone, once referenced).
+ * Last-wins because the section's own emission is closer to the
+ * truth than a reference; the dedupe is best-effort and harmless
+ * if `@id` is absent (the payload always emits).
+ *
+ * **`@context` injection**: when a payload omits `@context`, the
+ * renderer injects `'https://schema.org'`. Consumers wanting a
+ * custom vocabulary supply `@context` themselves and the renderer
+ * passes it through unchanged.
+ *
+ * **HTML-safe serialization**: JSON-LD payloads are serialized via
+ * `JSON.stringify` with the closing `</` escaped to `<\/` (and the
+ * `<!` opener escaped to `<\!`) to prevent the payload from
+ * accidentally closing the surrounding `<script>` tag if the
+ * payload contains the string `</script>` (e.g. a blog post about
+ * structured data). This is the canonical safe-serialization
+ * pattern (see https://html.spec.whatwg.org/#restrictions-for-contents-of-script-elements).
+ */
+const SCHEMA_ORG_DEFAULT_CONTEXT = 'https://schema.org';
+export function renderPageStructuredData(opts) {
+    const collected = [];
+    if (opts.sections) {
+        for (const section of opts.sections) {
+            if (!section.getStructuredData)
+                continue;
+            const value = section.getStructuredData();
+            collectInto(collected, value);
+        }
+    }
+    if (opts.pagePayloads) {
+        for (const payload of opts.pagePayloads) {
+            collected.push(payload);
+        }
+    }
+    if (collected.length === 0)
+        return '';
+    /**
+     * Dedupe by `@id` (last-wins). Payloads without `@id` always
+     * survive. We walk LAST-to-FIRST so the LAST occurrence of an
+     * `@id` is the kept one (later writes overwrite earlier ones
+     * naturally with this loop direction + reverse at the end).
+     */
+    const seen = new Set();
+    const deduped = [];
+    for (let i = collected.length - 1; i >= 0; i -= 1) {
+        const payload = collected[i];
+        if (payload === undefined)
+            continue;
+        const id = payload['@id'];
+        if (typeof id === 'string') {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+        }
+        deduped.push(payload);
+    }
+    deduped.reverse();
+    const lines = [];
+    for (const payload of deduped) {
+        const withContext = payload['@context'] === undefined
+            ? { '@context': SCHEMA_ORG_DEFAULT_CONTEXT, ...payload }
+            : { ...payload };
+        const json = serializeForScriptTag(withContext);
+        lines.push(`<script type="application/ld+json">${json}</script>`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Normalize a `getStructuredData()` return value into a flat array
+ * the renderer iterates. Handles the four legal shapes
+ * (`null` / `undefined` / single payload / readonly array).
+ *
+ * Mutates the `into` array in place — the function is private to
+ * this module and the in-place mutation avoids one allocation per
+ * section (sections compose linearly, the cost adds up on long
+ * pages).
+ */
+function collectInto(into, value) {
+    if (value === null || value === undefined)
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (item !== null && item !== undefined)
+                into.push(item);
+        }
+        return;
+    }
+    /**
+     * Single-payload shape — narrow the readonly-array branch above
+     * by elimination. `Array.isArray` returns `false` for readonly
+     * arrays in some TS configs but TRUE at runtime; this branch
+     * runs only for non-array `WebsiteStructuredDataPayload`.
+     */
+    into.push(value);
+}
+/**
+ * Serialize a payload for emission inside a `<script>` tag.
+ *
+ * `JSON.stringify` alone is NOT safe inside `<script>` tags:
+ *
+ *   - A payload field containing the literal string `</script>`
+ *     (rare but possible on a blog post about HTML / structured
+ *     data) would close the script tag prematurely and inject the
+ *     remainder as page HTML.
+ *   - A payload field containing `<!--` similarly opens an HTML
+ *     comment that breaks the surrounding parsing context.
+ *
+ * Both are mitigated by escaping `<` to `\u003c` inside the JSON
+ * payload — the JSON parser treats `\u003c` as identical to `<`,
+ * so the consumed payload is unchanged, but the HTML parser sees
+ * no `<` characters and never gets confused.
+ */
+function serializeForScriptTag(payload) {
+    return JSON.stringify(payload).replace(/</g, '\\u003c');
+}
+/** @wildo_source:part:end saas.website.astro.structured-data-renderer */
+//# sourceMappingURL=structured-data.renderer.js.map