@wildo-ai/saas-website 1.1.1

package/dist/esm/astro/collect-expected-label-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-expected-label-keys.js","sourceRoot":"","sources":["../../../../src/astro/collect-expected-label-keys.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,UAAU,oCAAoC,CAClD,QAA6C;IAE7C,MAAM,GAAG,GAAG,IAAI,GAAG,EAAiD,CAAC;IAErE,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,QAAQ,GAAG,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC7C,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;YACvD,SAAS;QACX,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACjE,MAAM,IAAI,KAAK,CACb,8DAA8D;gBAC5D,IAAI,OAAO,CAAC,UAA+B,oBAAoB;gBAC/D,kCAAkC;gBAClC,wBAAyB,QAA8B,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;gBACvE,yBAA0B,OAAO,CAAC,iBAAuC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK;gBACzF,gFAAgF,CACnF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,sBAAsB,CAC7B,CAA6B,EAC7B,CAA6B;IAE7B,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IACxC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,CAAsB,CAAC,CAAC;IAC7C,KAAK,MAAM,GAAG,IAAI,CAAsB,EAAE,CAAC;QACzC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;IACnC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AACD,oEAAoE","sourcesContent":["import type { WebsiteSectionDefinition } from '../schemas/sections/website-section-definition.shared.schemas';\nimport type { WebsiteSectionRef } from '../schemas/refs/section-ref.schemas';\nimport type { WebsiteLabelKey } from '../schemas/label-keys/website-label-key.schemas';\nimport type { ExpectedLabelKeysBySectionRef } from '../schemas/validators/label-pack.validator';\n\n/**\n * @wildo_source:part:start saas.website.astro.label-key-collector facet:layer:astro facet:family:website\n *\n * `collectExpectedLabelKeysFromSections(sections)` — pure, no-I/O\n * collector that materializes the\n * `ExpectedLabelKeysBySectionRef` map the label-pack validator\n * (`validateLabelPackAgainstManifest`) consumes.\n *\n * **Why an explicit-list collector and not a JSX walker**\n * (Phase 5 plan originally proposed walking each manifest's\n * `pageComponent` to discover its `defineWebsiteSection` calls —\n * we deliberately rejected that approach):\n *\n *   - **No runtime React introspection.** A JSX walker would either\n *     (a) require booting React + a virtual DOM at build time just to\n *     render every page once and observe its section composition, or\n *     (b) require static AST analysis of the `pageComponent` source\n *     file to discover `<HeroSection/>`-style imports. Both add a\n *     non-trivial dependency surface (jsdom or a TS AST walker) and\n *     both fail silently on dynamic composition (a section rendered\n *     conditionally by a feature flag is invisible to the static\n *     walker but visible to the renderer, and vice versa).\n *   - **The consumer already has the list.** Each page-impl module\n *     already imports its sections (that's how JSX renders them);\n *     `WebsiteRootConfig` already lists every page manifest; the\n *     consumer's `website-root.config.ts` is therefore one line away\n *     from also exporting a flat `[HeroSection, PricingSection, …]`\n *     array. Asking for that array trades a frame of build-time magic\n *     for a single hand-authored line and turns \"did the build see\n *     this section?\" into a TypeScript-checked import — a far better\n *     trade than a JSX walker.\n *   - **Section reuse across pages is naturally handled.** Two pages\n *     reusing the same `HeroSection` definition (with the same\n *     `sectionRef`) collide silently in a JSX walker (which would\n *     register the section twice with identical expected keys).\n *     Here, the array deduplicates per `sectionRef` (a same-ref\n *     duplicate with NON-matching `expectedLabelKeys` is a hard\n *     authoring bug — see refinement below).\n *\n * **Refinement — duplicate `sectionRef` with non-matching keys**:\n * if the same `sectionRef` appears twice with different\n * `expectedLabelKeys`, the collector throws. This catches the\n * \"two distinct sections accidentally using the same ref\" bug\n * (typically a copy-paste during section authoring) at build time\n * with an actionable message rather than letting the second\n * `Map.set` silently overwrite the first.\n *\n * **Pure / no I/O**: the collector is invoked at build start by\n * the Astro adapter and at audit time by `wildo website audit`;\n * it does not read files and does not boot React.\n *\n * @param sections Every `WebsiteSectionDefinition` registered on the\n *                 site. Order does not matter — the result is an\n *                 unordered map keyed by `sectionRef`.\n * @returns A `Map<WebsiteSectionRef, readonly WebsiteLabelKey[]>`\n *          ready to feed into `validateLabelPackAgainstManifest`.\n * @throws  When two distinct sections share a `sectionRef` but\n *          declare different `expectedLabelKeys` arrays (length or\n *          membership) — the collector's hard-error path.\n */\nexport function collectExpectedLabelKeysFromSections(\n  sections: readonly WebsiteSectionDefinition[],\n): ExpectedLabelKeysBySectionRef {\n  const map = new Map<WebsiteSectionRef, readonly WebsiteLabelKey[]>();\n\n  for (const section of sections) {\n    const existing = map.get(section.sectionRef);\n    if (existing === undefined) {\n      map.set(section.sectionRef, section.expectedLabelKeys);\n      continue;\n    }\n    if (!areLabelKeyArraysEqual(existing, section.expectedLabelKeys)) {\n      throw new Error(\n        `[collectExpectedLabelKeysFromSections] Duplicate sectionRef ` +\n          `\"${section.sectionRef as unknown as string}\" registered with ` +\n          `non-matching expectedLabelKeys. ` +\n          `First registration: [${(existing as readonly string[]).join(', ')}]. ` +\n          `Second registration: [${(section.expectedLabelKeys as readonly string[]).join(', ')}]. ` +\n          `Either rename one section's sectionRef or align both expectedLabelKeys arrays.`,\n      );\n    }\n  }\n\n  return map;\n}\n\n/**\n * Order-insensitive equality for two `readonly WebsiteLabelKey[]`.\n * Used by the collector to validate that a duplicate-ref registration\n * is intentional (same keys) vs. a copy-paste bug (different keys).\n *\n * Quadratic in the array length, but `expectedLabelKeys` is bounded by\n * the number of slots a single section consumes (typically <20), so\n * the cost is negligible compared to surface readability of the\n * comparison.\n */\nfunction areLabelKeyArraysEqual(\n  a: readonly WebsiteLabelKey[],\n  b: readonly WebsiteLabelKey[],\n): boolean {\n  if (a.length !== b.length) return false;\n  const aSet = new Set(a as readonly string[]);\n  for (const key of b as readonly string[]) {\n    if (!aSet.has(key)) return false;\n  }\n  return true;\n}\n/** @wildo_source:part:end saas.website.astro.label-key-collector */\n"]}

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

@@ -0,0 +1,32 @@
+import type { WebsiteSiteContext } from './website-site-context';
+/**
+ * @wildo_source:part:start saas.website.astro.headers-renderer facet:layer:astro facet:family:website
+ *
+ * Render a static-host-compatible `_headers` body for every page
+ * manifest whose `seo.noaiOptOut === true`.
+ *
+ * The output format matches Cloudflare Pages / Netlify / Vercel's
+ * path-scoped `_headers` conventions:
+ *
+ * ```txt
+ * /pricing
+ *   X-Robots-Tag: noai, noimageai
+ *
+ * /fr/pricing
+ *   X-Robots-Tag: noai, noimageai
+ * ```
+ */
+export declare function renderWebsitePageNoaiHeaders(siteContext: WebsiteSiteContext): string;
+/** @wildo_source:part:end saas.website.astro.headers-renderer */
+/**
+ * Future blog-post companion for the same header channel. Kept small
+ * and pure so a consumer's `[slug].astro` route or `_headers`
+ * generation script can opt blog posts out of AI training without
+ * re-implementing the locale-path logic.
+ */
+export declare function renderBlogPostNoaiHeaders(params: {
+    siteContext: WebsiteSiteContext;
+    routePath: string;
+    noaiOptOut?: boolean;
+}): string;
+//# sourceMappingURL=headers-renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headers-renderer.d.ts","sourceRoot":"","sources":["../../../../src/astro/headers-renderer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAIjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,kBAAkB,GAAG,MAAM,CAapF;AACD,iEAAiE;AAEjE;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAChD,WAAW,EAAE,kBAAkB,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,GAAG,MAAM,CAgBT"}

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

@@ -0,0 +1,64 @@
+import { buildLocalizedRoutePath } from '../core/routing/internal-routing.utils.js';
+const NOAI_ROBOTS_HEADER_VALUE = 'noai, noimageai';
+/**
+ * @wildo_source:part:start saas.website.astro.headers-renderer facet:layer:astro facet:family:website
+ *
+ * Render a static-host-compatible `_headers` body for every page
+ * manifest whose `seo.noaiOptOut === true`.
+ *
+ * The output format matches Cloudflare Pages / Netlify / Vercel's
+ * path-scoped `_headers` conventions:
+ *
+ * ```txt
+ * /pricing
+ *   X-Robots-Tag: noai, noimageai
+ *
+ * /fr/pricing
+ *   X-Robots-Tag: noai, noimageai
+ * ```
+ */
+export function renderWebsitePageNoaiHeaders(siteContext) {
+    const flaggedPages = siteContext.rootConfig.pageManifests.filter((manifest) => manifest.seo?.noaiOptOut === true);
+    if (flaggedPages.length === 0) {
+        return '';
+    }
+    const lines = [];
+    for (const manifest of flaggedPages) {
+        appendManifestHeaders(lines, manifest, siteContext);
+    }
+    return lines.slice(0, -1).join('\n');
+}
+/** @wildo_source:part:end saas.website.astro.headers-renderer */
+/**
+ * Future blog-post companion for the same header channel. Kept small
+ * and pure so a consumer's `[slug].astro` route or `_headers`
+ * generation script can opt blog posts out of AI training without
+ * re-implementing the locale-path logic.
+ */
+export function renderBlogPostNoaiHeaders(params) {
+    const { siteContext, routePath, noaiOptOut } = params;
+    if (noaiOptOut !== true) {
+        return '';
+    }
+    const lines = [];
+    for (const { locale } of siteContext.websiteConfig.locales) {
+        const localizedPath = buildLocalizedRoutePath({
+            locale,
+            defaultLocale: siteContext.websiteConfig.defaultLocale,
+            routePath,
+        });
+        lines.push(localizedPath, `  X-Robots-Tag: ${NOAI_ROBOTS_HEADER_VALUE}`, '');
+    }
+    return lines.slice(0, -1).join('\n');
+}
+function appendManifestHeaders(lines, manifest, siteContext) {
+    for (const { locale } of siteContext.websiteConfig.locales) {
+        const localizedPath = buildLocalizedRoutePath({
+            locale,
+            defaultLocale: siteContext.websiteConfig.defaultLocale,
+            routePath: String(manifest.routePath),
+        });
+        lines.push(localizedPath, `  X-Robots-Tag: ${NOAI_ROBOTS_HEADER_VALUE}`, '');
+    }
+}
+//# sourceMappingURL=headers-renderer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headers-renderer.js","sourceRoot":"","sources":["../../../../src/astro/headers-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAKjF,MAAM,wBAAwB,GAAG,iBAA0B,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,4BAA4B,CAAC,WAA+B;IAC1E,MAAM,YAAY,GAAG,WAAW,CAAC,UAAU,CAAC,aAAa,CAAC,MAAM,CAC9D,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,CAChD,CAAC;IACF,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,QAAQ,IAAI,YAAY,EAAE,CAAC;QACpC,qBAAqB,CAAC,KAAK,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AACD,iEAAiE;AAEjE;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CAAC,MAIzC;IACC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IACtD,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,WAAW,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;QAC3D,MAAM,aAAa,GAAG,uBAAuB,CAAC;YAC5C,MAAM;YACN,aAAa,EAAE,WAAW,CAAC,aAAa,CAAC,aAAa;YACtD,SAAS;SACV,CAAC,CAAC;QACH,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,mBAAmB,wBAAwB,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/E,CAAC;IACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,SAAS,qBAAqB,CAC5B,KAAe,EACf,QAA6B,EAC7B,WAA+B;IAE/B,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,WAAW,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;QAC3D,MAAM,aAAa,GAAG,uBAAuB,CAAC;YAC5C,MAAM;YACN,aAAa,EAAE,WAAW,CAAC,aAAa,CAAC,aAAa;YACtD,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;SACtC,CAAC,CAAC;QACH,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,mBAAmB,wBAAwB,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/E,CAAC;AACH,CAAC","sourcesContent":["import { 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\nconst NOAI_ROBOTS_HEADER_VALUE = 'noai, noimageai' as const;\n\n/**\n * @wildo_source:part:start saas.website.astro.headers-renderer facet:layer:astro facet:family:website\n *\n * Render a static-host-compatible `_headers` body for every page\n * manifest whose `seo.noaiOptOut === true`.\n *\n * The output format matches Cloudflare Pages / Netlify / Vercel's\n * path-scoped `_headers` conventions:\n *\n * ```txt\n * /pricing\n *   X-Robots-Tag: noai, noimageai\n *\n * /fr/pricing\n *   X-Robots-Tag: noai, noimageai\n * ```\n */\nexport function renderWebsitePageNoaiHeaders(siteContext: WebsiteSiteContext): string {\n  const flaggedPages = siteContext.rootConfig.pageManifests.filter(\n    (manifest) => manifest.seo?.noaiOptOut === true,\n  );\n  if (flaggedPages.length === 0) {\n    return '';\n  }\n\n  const lines: string[] = [];\n  for (const manifest of flaggedPages) {\n    appendManifestHeaders(lines, manifest, siteContext);\n  }\n  return lines.slice(0, -1).join('\\n');\n}\n/** @wildo_source:part:end saas.website.astro.headers-renderer */\n\n/**\n * Future blog-post companion for the same header channel. Kept small\n * and pure so a consumer's `[slug].astro` route or `_headers`\n * generation script can opt blog posts out of AI training without\n * re-implementing the locale-path logic.\n */\nexport function renderBlogPostNoaiHeaders(params: {\n  siteContext: WebsiteSiteContext;\n  routePath: string;\n  noaiOptOut?: boolean;\n}): string {\n  const { siteContext, routePath, noaiOptOut } = params;\n  if (noaiOptOut !== true) {\n    return '';\n  }\n\n  const lines: string[] = [];\n  for (const { locale } of siteContext.websiteConfig.locales) {\n    const localizedPath = buildLocalizedRoutePath({\n      locale,\n      defaultLocale: siteContext.websiteConfig.defaultLocale,\n      routePath,\n    });\n    lines.push(localizedPath, `  X-Robots-Tag: ${NOAI_ROBOTS_HEADER_VALUE}`, '');\n  }\n  return lines.slice(0, -1).join('\\n');\n}\n\nfunction appendManifestHeaders(\n  lines: string[],\n  manifest: WebsitePageManifest,\n  siteContext: WebsiteSiteContext,\n): void {\n  for (const { locale } of siteContext.websiteConfig.locales) {\n    const localizedPath = buildLocalizedRoutePath({\n      locale,\n      defaultLocale: siteContext.websiteConfig.defaultLocale,\n      routePath: String(manifest.routePath),\n    });\n    lines.push(localizedPath, `  X-Robots-Tag: ${NOAI_ROBOTS_HEADER_VALUE}`, '');\n  }\n}\n"]}

package/dist/esm/astro/i18n-routing.helper.d.ts

@@ -0,0 +1,91 @@
+import type { WebsiteSiteContext } from './website-site-context';
+/**
+ * @wildo_source:part:start saas.website.astro.i18n-helper facet:layer:astro facet:family:website
+ *
+ * `buildAstroI18nConfig(siteContext)` — derives the `i18n` block consumed
+ * by `astro/config`'s `defineConfig({ i18n })` from the shared
+ * `WebsiteSiteContext`.
+ *
+ * **Why a helper and not hand-authored in `astro.config.mjs`**: a
+ * marketing site has TWO sources of truth for "which locales does this
+ * site ship?" — the `WildoMarketingWebsiteConfig.locales` array
+ * (consumed by every Astro build helper) AND the Astro routing config
+ * (consumed by the file-based router and the dev server). Letting the
+ * consumer hand-author both creates a silent-drift surface: a locale
+ * added to one but not the other ships a working dev server with a
+ * missing label pack (or vice versa). This helper makes
+ * `WildoMarketingWebsiteConfig` (the per-service `wildo.website.config.ts`)
+ * the single source of truth.
+ *
+ * **Design decisions** (each carrying its own semantic weight):
+ *
+ * - **`prefixDefaultLocale = false`**. Astro's default routing strategy
+ *   is the marketing-site convention: the default locale mounts at the
+ *   un-prefixed path (`/`, `/pricing`, `/contact`) and other locales
+ *   live under `/<locale>/…`. Forcing prefixes for the default locale
+ *   would surface a `/en/` URL alongside `/` — duplicate content from
+ *   an SEO standpoint and a UX wart. Marketing teams overwhelmingly
+ *   ship the default at the root.
+ *
+ * - **`redirectToDefaultLocale = false`**. The default value Astro
+ *   would otherwise infer (`true`) issues a redirect from `/` to
+ *   `/<defaultLocale>/`, which directly contradicts the
+ *   `prefixDefaultLocale = false` convention above. Setting both
+ *   explicitly makes the contract loud at the call site (and in the
+ *   compiled config) instead of relying on Astro's defaults staying
+ *   stable across versions.
+ *
+ * - **`fallbackType = 'redirect'` is INTENTIONALLY OMITTED**.
+ *   Marketing sites typically prefer one of two strategies: ship a
+ *   page in every advertised locale OR hide the un-shipped locale
+ *   entirely (no entry in `locales`). The `fallback` machinery (which
+ *   would redirect `/de/pricing` to `/en/pricing` when the German
+ *   page is missing) creates SEO duplicate-content risk that's hard
+ *   to undo once Google indexes the redirected URL. Consumers who
+ *   genuinely need fallback can spread this helper's output and
+ *   add `fallback: { … }` themselves.
+ *
+ * **Type rationale**: the return type uses Astro's published `i18n`
+ * shape but we declare it as a structural literal type rather than
+ * importing from `astro` so this module stays in the saas-website
+ * source closure without forcing `astro` into the React-island side of the
+ * bundle. The package's bundle-boundary checks enforce that separation.
+ * The structural type is straightforward and matches Astro 4+ — see
+ * https://docs.astro.build/en/reference/configuration-reference/#i18n.
+ *
+ * @example
+ *   // astro.config.mjs
+ *   import { defineConfig } from 'astro/config';
+ *   import { buildAstroI18nConfig } from '@wildo-ai/saas-website/astro';
+ *   import { WEBSITE_SITE_CONTEXT } from './src/website-site-context';
+ *
+ *   export default defineConfig({
+ *     i18n: buildAstroI18nConfig(WEBSITE_SITE_CONTEXT),
+ *   });
+ */
+export interface AstroI18nConfig {
+    /** ISO locale string Astro mounts at the un-prefixed path. */
+    defaultLocale: string;
+    /** Every locale the site ships in (default included). */
+    locales: readonly string[];
+    routing: {
+        /**
+         * `false` means the default locale is served at the root path
+         * (`/`); other locales sit under `/<locale>/`. Typed as a
+         * widened `boolean` (not a literal `false`) so consumers who
+         * spread the config and override the field downstream do not
+         * fight literal-type narrowing — the runtime still emits
+         * `false` here, the type system just allows the override.
+         */
+        prefixDefaultLocale: boolean;
+        /**
+         * `false` means a request for `/` is served as the default-locale
+         * landing page (no implicit redirect to `/<defaultLocale>/`). Same
+         * literal-vs-widened rationale as `prefixDefaultLocale` above.
+         */
+        redirectToDefaultLocale: boolean;
+    };
+}
+export declare function buildAstroI18nConfig(siteContext: WebsiteSiteContext): AstroI18nConfig;
+/** @wildo_source:part:end saas.website.astro.i18n-helper */
+//# sourceMappingURL=i18n-routing.helper.d.ts.map

package/dist/esm/astro/i18n-routing.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-routing.helper.d.ts","sourceRoot":"","sources":["../../../../src/astro/i18n-routing.helper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,OAAO,EAAE;QACP;;;;;;;WAOG;QACH,mBAAmB,EAAE,OAAO,CAAC;QAC7B;;;;WAIG;QACH,uBAAuB,EAAE,OAAO,CAAC;KAClC,CAAC;CACH;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,kBAAkB,GAAG,eAAe,CAsBrF;AACD,4DAA4D"}

package/dist/esm/astro/i18n-routing.helper.js

@@ -0,0 +1,23 @@
+export function buildAstroI18nConfig(siteContext) {
+    const { websiteConfig } = siteContext;
+    /**
+     * Defensive copy: `WildoMarketingWebsiteConfig.locales` is an array
+     * of `{ locale, path }` entries; Astro's i18n config wants raw
+     * locale strings in declaration order. We extract `locale` and map
+     * through `String()` so the `AvailableLanguage` brand layer does
+     * not leak into the Astro public API surface, and we freeze the
+     * result so an Astro plugin authored against this shape cannot
+     * mutate the source-of-truth array indirectly.
+     */
+    const locales = Object.freeze(websiteConfig.locales.map((entry) => String(entry.locale)));
+    return {
+        defaultLocale: String(websiteConfig.defaultLocale),
+        locales,
+        routing: {
+            prefixDefaultLocale: false,
+            redirectToDefaultLocale: false,
+        },
+    };
+}
+/** @wildo_source:part:end saas.website.astro.i18n-helper */
+//# sourceMappingURL=i18n-routing.helper.js.map

package/dist/esm/astro/i18n-routing.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-routing.helper.js","sourceRoot":"","sources":["../../../../src/astro/i18n-routing.helper.ts"],"names":[],"mappings":"AA4FA,MAAM,UAAU,oBAAoB,CAAC,WAA+B;IAClE,MAAM,EAAE,aAAa,EAAE,GAAG,WAAW,CAAC;IACtC;;;;;;;;OAQG;IACH,MAAM,OAAO,GAAsB,MAAM,CAAC,MAAM,CAC9C,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAoC,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAC1F,CAAC;IACF,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC;QAClD,OAAO;QACP,OAAO,EAAE;YACP,mBAAmB,EAAE,KAAK;YAC1B,uBAAuB,EAAE,KAAK;SAC/B;KACF,CAAC;AACJ,CAAC;AACD,4DAA4D","sourcesContent":["import type { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';\n\nimport type { WebsiteSiteContext } from './website-site-context';\n\n/**\n * @wildo_source:part:start saas.website.astro.i18n-helper facet:layer:astro facet:family:website\n *\n * `buildAstroI18nConfig(siteContext)` — derives the `i18n` block consumed\n * by `astro/config`'s `defineConfig({ i18n })` from the shared\n * `WebsiteSiteContext`.\n *\n * **Why a helper and not hand-authored in `astro.config.mjs`**: a\n * marketing site has TWO sources of truth for \"which locales does this\n * site ship?\" — the `WildoMarketingWebsiteConfig.locales` array\n * (consumed by every Astro build helper) AND the Astro routing config\n * (consumed by the file-based router and the dev server). Letting the\n * consumer hand-author both creates a silent-drift surface: a locale\n * added to one but not the other ships a working dev server with a\n * missing label pack (or vice versa). This helper makes\n * `WildoMarketingWebsiteConfig` (the per-service `wildo.website.config.ts`)\n * the single source of truth.\n *\n * **Design decisions** (each carrying its own semantic weight):\n *\n * - **`prefixDefaultLocale = false`**. Astro's default routing strategy\n *   is the marketing-site convention: the default locale mounts at the\n *   un-prefixed path (`/`, `/pricing`, `/contact`) and other locales\n *   live under `/<locale>/…`. Forcing prefixes for the default locale\n *   would surface a `/en/` URL alongside `/` — duplicate content from\n *   an SEO standpoint and a UX wart. Marketing teams overwhelmingly\n *   ship the default at the root.\n *\n * - **`redirectToDefaultLocale = false`**. The default value Astro\n *   would otherwise infer (`true`) issues a redirect from `/` to\n *   `/<defaultLocale>/`, which directly contradicts the\n *   `prefixDefaultLocale = false` convention above. Setting both\n *   explicitly makes the contract loud at the call site (and in the\n *   compiled config) instead of relying on Astro's defaults staying\n *   stable across versions.\n *\n * - **`fallbackType = 'redirect'` is INTENTIONALLY OMITTED**.\n *   Marketing sites typically prefer one of two strategies: ship a\n *   page in every advertised locale OR hide the un-shipped locale\n *   entirely (no entry in `locales`). The `fallback` machinery (which\n *   would redirect `/de/pricing` to `/en/pricing` when the German\n *   page is missing) creates SEO duplicate-content risk that's hard\n *   to undo once Google indexes the redirected URL. Consumers who\n *   genuinely need fallback can spread this helper's output and\n *   add `fallback: { … }` themselves.\n *\n * **Type rationale**: the return type uses Astro's published `i18n`\n * shape but we declare it as a structural literal type rather than\n * importing from `astro` so this module stays in the saas-website\n * source closure without forcing `astro` into the React-island side of the\n * bundle. The package's bundle-boundary checks enforce that separation.\n * The structural type is straightforward and matches Astro 4+ — see\n * https://docs.astro.build/en/reference/configuration-reference/#i18n.\n *\n * @example\n *   // astro.config.mjs\n *   import { defineConfig } from 'astro/config';\n *   import { buildAstroI18nConfig } from '@wildo-ai/saas-website/astro';\n *   import { WEBSITE_SITE_CONTEXT } from './src/website-site-context';\n *\n *   export default defineConfig({\n *     i18n: buildAstroI18nConfig(WEBSITE_SITE_CONTEXT),\n *   });\n */\nexport interface AstroI18nConfig {\n  /** ISO locale string Astro mounts at the un-prefixed path. */\n  defaultLocale: string;\n  /** Every locale the site ships in (default included). */\n  locales: readonly string[];\n  routing: {\n    /**\n     * `false` means the default locale is served at the root path\n     * (`/`); other locales sit under `/<locale>/`. Typed as a\n     * widened `boolean` (not a literal `false`) so consumers who\n     * spread the config and override the field downstream do not\n     * fight literal-type narrowing — the runtime still emits\n     * `false` here, the type system just allows the override.\n     */\n    prefixDefaultLocale: boolean;\n    /**\n     * `false` means a request for `/` is served as the default-locale\n     * landing page (no implicit redirect to `/<defaultLocale>/`). Same\n     * literal-vs-widened rationale as `prefixDefaultLocale` above.\n     */\n    redirectToDefaultLocale: boolean;\n  };\n}\n\nexport function buildAstroI18nConfig(siteContext: WebsiteSiteContext): AstroI18nConfig {\n  const { websiteConfig } = siteContext;\n  /**\n   * Defensive copy: `WildoMarketingWebsiteConfig.locales` is an array\n   * of `{ locale, path }` entries; Astro's i18n config wants raw\n   * locale strings in declaration order. We extract `locale` and map\n   * through `String()` so the `AvailableLanguage` brand layer does\n   * not leak into the Astro public API surface, and we freeze the\n   * result so an Astro plugin authored against this shape cannot\n   * mutate the source-of-truth array indirectly.\n   */\n  const locales: readonly string[] = Object.freeze(\n    websiteConfig.locales.map((entry: { locale: AvailableLanguage }) => String(entry.locale)),\n  );\n  return {\n    defaultLocale: String(websiteConfig.defaultLocale),\n    locales,\n    routing: {\n      prefixDefaultLocale: false,\n      redirectToDefaultLocale: false,\n    },\n  };\n}\n/** @wildo_source:part:end saas.website.astro.i18n-helper */\n"]}

package/dist/esm/astro/internal/html-escape.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared HTML-escape helpers used by every Astro head-block string
+ * builder in the saas-website engine (page-head + blog-post-head, and
+ * any future per-route renderer that interpolates consumer-supplied
+ * copy into a string-output `<head>` template).
+ *
+ * # Why a shared module rather than duplicating per-renderer
+ *
+ * Marketing copy frequently contains characters (quotes, ampersands,
+ * the rare `<`) that would break the surrounding tag if interpolated
+ * raw. Two renderers escaping with two slightly-different character
+ * sets is exactly the kind of silent-drift surface this codebase
+ * forbids — one renderer might forget the `'` → `&#39;` substitution
+ * and produce attribute breakouts in JSON-LD copy, while the other
+ * does it correctly. Centralizing both helpers here gives every
+ * renderer ONE escape contract to audit.
+ *
+ * # Why both `Attribute` and `Text` variants exist (currently identical)
+ *
+ * Conceptually distinct (an attribute escape needs `"`/`'` covered;
+ * a text-content escape technically only needs `<`/`>`/`&`). Today
+ * they share a body for convenience — the cost of over-escaping `"`
+ * inside text content is negligible (browsers render the entity
+ * correctly) and the win is one fewer code path to audit. Splitting
+ * the implementations later (when a real divergence shows up — e.g. a
+ * JSON-LD emitter that legitimately wants raw `<script type="application/ld+json">`
+ * inner-content escaping rules) is a one-file change.
+ */
+export declare function escapeHtmlAttribute(value: string): string;
+export declare function escapeHtmlText(value: string): string;
+//# sourceMappingURL=html-escape.d.ts.map

package/dist/esm/astro/internal/html-escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-escape.d.ts","sourceRoot":"","sources":["../../../../../src/astro/internal/html-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/esm/astro/internal/html-escape.js

@@ -0,0 +1,40 @@
+/**
+ * Shared HTML-escape helpers used by every Astro head-block string
+ * builder in the saas-website engine (page-head + blog-post-head, and
+ * any future per-route renderer that interpolates consumer-supplied
+ * copy into a string-output `<head>` template).
+ *
+ * # Why a shared module rather than duplicating per-renderer
+ *
+ * Marketing copy frequently contains characters (quotes, ampersands,
+ * the rare `<`) that would break the surrounding tag if interpolated
+ * raw. Two renderers escaping with two slightly-different character
+ * sets is exactly the kind of silent-drift surface this codebase
+ * forbids — one renderer might forget the `'` → `&#39;` substitution
+ * and produce attribute breakouts in JSON-LD copy, while the other
+ * does it correctly. Centralizing both helpers here gives every
+ * renderer ONE escape contract to audit.
+ *
+ * # Why both `Attribute` and `Text` variants exist (currently identical)
+ *
+ * Conceptually distinct (an attribute escape needs `"`/`'` covered;
+ * a text-content escape technically only needs `<`/`>`/`&`). Today
+ * they share a body for convenience — the cost of over-escaping `"`
+ * inside text content is negligible (browsers render the entity
+ * correctly) and the win is one fewer code path to audit. Splitting
+ * the implementations later (when a real divergence shows up — e.g. a
+ * JSON-LD emitter that legitimately wants raw `<script type="application/ld+json">`
+ * inner-content escaping rules) is a one-file change.
+ */
+export function escapeHtmlAttribute(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+export function escapeHtmlText(value) {
+    return escapeHtmlAttribute(value);
+}
+//# sourceMappingURL=html-escape.js.map

package/dist/esm/astro/internal/html-escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-escape.js","sourceRoot":"","sources":["../../../../../src/astro/internal/html-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,OAAO,KAAK;SACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;SACvB,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC;AACpC,CAAC","sourcesContent":["/**\n * Shared HTML-escape helpers used by every Astro head-block string\n * builder in the saas-website engine (page-head + blog-post-head, and\n * any future per-route renderer that interpolates consumer-supplied\n * copy into a string-output `<head>` template).\n *\n * # Why a shared module rather than duplicating per-renderer\n *\n * Marketing copy frequently contains characters (quotes, ampersands,\n * the rare `<`) that would break the surrounding tag if interpolated\n * raw. Two renderers escaping with two slightly-different character\n * sets is exactly the kind of silent-drift surface this codebase\n * forbids — one renderer might forget the `'` → `&#39;` substitution\n * and produce attribute breakouts in JSON-LD copy, while the other\n * does it correctly. Centralizing both helpers here gives every\n * renderer ONE escape contract to audit.\n *\n * # Why both `Attribute` and `Text` variants exist (currently identical)\n *\n * Conceptually distinct (an attribute escape needs `\"`/`'` covered;\n * a text-content escape technically only needs `<`/`>`/`&`). Today\n * they share a body for convenience — the cost of over-escaping `\"`\n * inside text content is negligible (browsers render the entity\n * correctly) and the win is one fewer code path to audit. Splitting\n * the implementations later (when a real divergence shows up — e.g. a\n * JSON-LD emitter that legitimately wants raw `<script type=\"application/ld+json\">`\n * inner-content escaping rules) is a one-file change.\n */\n\nexport function escapeHtmlAttribute(value: string): string {\n  return value\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n    .replace(/'/g, '&#39;');\n}\n\nexport function escapeHtmlText(value: string): string {\n  return escapeHtmlAttribute(value);\n}\n"]}

package/dist/esm/astro/label-pack-loader.d.ts

@@ -0,0 +1,134 @@
+import type { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+import { type ExpectedLabelKeysBySectionRef, type LabelPack, type LabelPackValidationResult } from '../schemas/validators/label-pack.validator';
+import type { WebsiteSiteContext } from './website-site-context';
+/**
+ * @wildo_source:part:start saas.website.astro.label-loader facet:layer:astro facet:family:website
+ *
+ * `label-pack-loader.ts` — synchronous, fs-backed loader for
+ * marketing-site label packs. Consumed by:
+ *   - the Astro adapter (`WebsitePageBridge.astro` reads the active
+ *     locale's pack at request time during SSR / pre-render),
+ *   - the `wildo website audit` CLI (Phase 7) to validate every
+ *     locale pack against every manifest at CI time,
+ *   - any build-time hook that wants to fail fast on a missing or
+ *     malformed pack.
+ *
+ * **Convention** (matches the slice plan + the validator's contract):
+ *
+ *   - One file per locale: `<packsDir>/<locale>.json`
+ *   - JSON object: flat key-value map, `Record<string, string>`
+ *   - Keys are fully-composed `WebsiteLabelKey`s (`website.<page>.<section>.<slot>`)
+ *   - Values are the localized strings
+ *
+ * **Why synchronous I/O**:
+ *   - The Astro frontmatter executes at build / SSR time in a Node
+ *     process (no event loop pressure to relieve), and the bridge
+ *     wants the pack resolved before it emits any HTML — async would
+ *     force the consumer to `await` inside an Astro frontmatter,
+ *     which is supported but adds a needless yield-point on a single
+ *     small JSON file.
+ *   - The validator is pure and synchronous; making the loader async
+ *     would add a coloring boundary for no benefit.
+ *
+ * **Failure modes — all surfaced as thrown errors with actionable
+ * messages**:
+ *   - File missing — wrapped in a `[label-pack-loader] Could not read
+ *     pack at <path>` error so a typo in the dir / locale is obvious.
+ *   - JSON parse failure — error includes the file path and the
+ *     parser's own message.
+ *   - Top-level shape is not an object, or a value is not a string —
+ *     error names the offending key + observed type.
+ *
+ * **Why three exports** (loader, multi-loader, validator-runner):
+ *   - `loadLabelPack(packsDir, locale)` is the atomic primitive
+ *     (one file → one validated `LabelPack`). Used by the bridge at
+ *     request time.
+ *   - `loadAllLabelPacks(packsDir, siteContext)` is the build-time
+ *     batch — every locale pack at once. Used by the CLI auditor
+ *     and by the build-start hook.
+ *   - `validateAllLabelPacks(packsDir, siteContext, expectedKeysBySectionRef)`
+ *     is the highest-level entry point: load every pack, run the
+ *     validator on each, and either return the diagnostic results
+ *     or throw on the first hard error. The returned shape carries
+ *     per-locale diagnostics so the caller can format a CLI report.
+ *
+ * **`siteContext` parameter** — the consumer's composed
+ * `WebsiteSiteContext` (see `website-site-context.ts`). The loader
+ * reads `siteContext.websiteConfig.locales` for "which locales does
+ * the site ship?" and `siteContext.rootConfig.{pageManifests,
+ * chromeLabelKeys, skipToMainContentLabelKey}` for the manifest
+ * registry / chrome-key set the validator runs against.
+ */
+/**
+ * Load and validate a single locale's label pack. Synchronous —
+ * suitable for Astro frontmatter execution.
+ *
+ * @param packsDir Absolute or cwd-relative path to the directory
+ *                 containing per-locale `<locale>.json` files.
+ * @param locale   The locale to load. Must be a member of
+ *                 `WildoMarketingWebsiteConfig.locales`.
+ * @returns A flat `LabelPack` (`Record<string, string>`) ready to
+ *          feed into `WebsiteRuntimeContextValue.labelPack`.
+ * @throws  When the file is missing, malformed JSON, not an object,
+ *          or contains a non-string value.
+ */
+export declare function loadLabelPack(packsDir: string, locale: AvailableLanguage): LabelPack;
+/**
+ * Batch loader — every locale declared on the site at once. The map
+ * iteration order matches the declaration order of
+ * `siteContext.websiteConfig.locales` so CLI reports come out in a
+ * deterministic, authored sequence.
+ */
+export declare function loadAllLabelPacks(packsDir: string, siteContext: WebsiteSiteContext): Map<AvailableLanguage, LabelPack>;
+/**
+ * Per-locale validation result — the validator's flat output extended
+ * with the locale tag so a multi-locale report can flatten + group.
+ */
+export interface LocaleLabelPackValidation {
+    locale: AvailableLanguage;
+    result: LabelPackValidationResult;
+}
+/**
+ * Highest-level entry point: load every locale's pack and run the
+ * label-pack validator against the manifest registry.
+ *
+ * **Return shape decision** — this function does NOT throw on
+ * `missing` keys; it returns the per-locale results so the caller
+ * (the build-start hook OR the CLI auditor OR a debugging
+ * subprocess) can decide how to surface the failure (process exit
+ * code, formatted CLI output, JSON report, …). A thin `throwIfAny…`
+ * helper sits next to it for the common "fail the build on first
+ * missing key" path.
+ */
+export declare function loadAndValidateAllLabelPacks(packsDir: string, siteContext: WebsiteSiteContext, expectedKeysBySectionRef: ExpectedLabelKeysBySectionRef): readonly LocaleLabelPackValidation[];
+/**
+ * Convenience wrapper for the build-start hook: validates every
+ * declared locale's pack and throws a SINGLE aggregated error if any
+ * locale has a hard failure (`missing` keys or `unmappedSectionRefs`).
+ * Orphaned keys are logged via `console.warn` (soft warning per the
+ * validator's contract) but do NOT throw.
+ *
+ * **Why aggregate (not first-fail)**: a multi-locale marketing site
+ * with `en` and `fr` packs both missing keys would, under a
+ * first-fail policy, force the author to fix `en`, re-run the build,
+ * THEN see `fr`'s problem. Aggregating means one build run surfaces
+ * every locale's hard errors together — material UX win for the
+ * authoring loop. The aggregated message keeps each locale's failure
+ * in its own block so the diagnostic stays scannable.
+ *
+ * **Why throw vs. return**: the build-start hook lives in
+ * `astro.config.mjs` (or a `vite-plugin`-style integration) and
+ * benefits from the shortest possible code path — a thrown error
+ * naturally aborts `astro build` with a non-zero exit code and
+ * surfaces the message in the build log. The richer
+ * `loadAndValidateAllLabelPacks` is what `wildo website audit` calls
+ * when it wants programmatic access to the per-locale results.
+ *
+ * **Key-origin annotation**: every `missing` key is tagged with the
+ * page (and, if section-scoped, the section) that declared it, so the
+ * author can grep + open the right `defineWebsiteSection` /
+ * `defineWebsitePageManifest` call site without leaving the build log.
+ */
+export declare function assertLabelPacksValid(packsDir: string, siteContext: WebsiteSiteContext, expectedKeysBySectionRef: ExpectedLabelKeysBySectionRef): void;
+/** @wildo_source:part:end saas.website.astro.label-loader */
+//# sourceMappingURL=label-pack-loader.d.ts.map

package/dist/esm/astro/label-pack-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-pack-loader.d.ts","sourceRoot":"","sources":["../../../../src/astro/label-pack-loader.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAK9E,OAAO,EAEL,KAAK,6BAA6B,EAClC,KAAK,SAAS,EACd,KAAK,yBAAyB,EAC/B,MAAM,4CAA4C,CAAC;AAEpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,SAAS,CA4BpF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,kBAAkB,GAC9B,GAAG,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAMnC;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,yBAAyB,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,kBAAkB,EAC/B,wBAAwB,EAAE,6BAA6B,GACtD,SAAS,yBAAyB,EAAE,CAmBtC;AAgCD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,kBAAkB,EAC/B,wBAAwB,EAAE,6BAA6B,GACtD,IAAI,CA6DN;AA+ED,6DAA6D"}