@wildo-ai/saas-website 1.1.1

package/dist/esm/config/define-website-config.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Author helper for `wildo.website.config.ts` files.
+ *
+ * `defineWebsiteConfig({...})` mirrors the `defineSaasConfig` /
+ * `defineInfraEnvConfig` helpers from `@wildo-ai/platform-config-lib`
+ * and `defineTechnicalDocConfig` from `@wildo-ai/saas-technical-doc`:
+ * it wraps `WildoMarketingWebsiteConfigSchema.parse(...)` with full
+ * IDE autocompletion on the input shape, and emits a parse-time
+ * stderr warning for any authored field that has no runtime
+ * consumer yet.
+ *
+ * # `@unimplemented` channel — current state
+ *
+ * The warner has ZERO branches today because every OPTIONAL field that
+ * exists is already wired (`csp?` now flows through the website-local
+ * CSP sync step) and the only unwired field left is `appOrigin`, which
+ * is REQUIRED. After the seam-collapse (`saas-website-seam-collapse.md`
+ * — SHIPPED), the routing/origin fields (`publicOrigin`,
+ * `defaultLocale`, `locales`) are consumed directly by every Astro
+ * engine helper via `WebsiteSiteContext`, so they are no longer
+ * candidates for a "deferred wiring" warning either. The
+ * `@unimplemented` warner is for fields that are parsed-but-unused AND
+ * opt-in — firing on every Astro build for a required field would drown
+ * the dev console.
+ *
+ * Two valid futures will trigger adding warner branches:
+ *   1. A future optional field lands (e.g. `seo?.{title,description}`,
+ *      `structuredData?.organization`) whose runtime wiring ships
+ *      in a later PR — that would get
+ *      `if (config.seo !== undefined) warn('seo', ...)` until the
+ *      renderer reads it.
+ *   2. A required field temporarily loses its consumer (e.g. a
+ *      large refactor splits the SEO renderer into two PRs); the
+ *      branch fires unconditionally for the duration.
+ *
+ * The scaffold is kept (and the no-warning contract is pinned by
+ * the test suite) so the moment either case lands, the warning
+ * channel is one branch addition away — matching the
+ * `defineTechnicalDocConfig` shape exactly so future authors
+ * grepping for `@unimplemented` find a uniform pattern.
+ *
+ * Why we don't reuse `platform-config-lib`'s
+ * `createUnimplementedFieldWarner`:
+ *
+ * `platform-config-lib` is the platform-level boundary; this engine
+ * package is downstream of it for everything else. Importing the
+ * warner from `platform-config-lib` would invert the dependency
+ * direction (engine → platform-config), creating the same architectural
+ * defect Step 7.5 set out to fix. The warning format is small and
+ * stable enough to inline here — kept structurally similar to the
+ * platform-config-lib warner so readers grepping for `@unimplemented`
+ * still find both surfaces.
+ */
+import { WildoMarketingWebsiteConfigSchema, } from './wildo-website-config.schemas.js';
+/**
+ * Define a per-service marketing-website config. Provides full IDE
+ * autocompletion on the input shape, runs Zod validation (fail-closed
+ * on typos / unknown keys / out-of-range values / cross-field
+ * invariants like `defaultLocale ∈ locales`), and emits parse-time
+ * `@unimplemented` warnings for fields that are authored but have no
+ * runtime consumer yet.
+ *
+ * Throws on validation failure — same contract as `defineSaasConfig`
+ * and `defineTechnicalDocConfig`.
+ *
+ * @example
+ * ```ts
+ * import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';
+ * import { defineWebsiteConfig } from '@wildo-ai/saas-website';
+ *
+ * export default defineWebsiteConfig({
+ *   publicOrigin: 'https://wonder-todos.example.com',
+ *   appOrigin: 'https://app.wonder-todos.example.com',
+ *   defaultLocale: AvailableLanguage.EN,
+ *   locales: [
+ *     { locale: AvailableLanguage.EN, path: 'en' },
+ *     { locale: AvailableLanguage.FR, path: 'fr' },
+ *   ],
+ * });
+ * ```
+ */
+export function defineWebsiteConfig(config) {
+    const parsed = WildoMarketingWebsiteConfigSchema.parse(config);
+    emitUnimplementedRuntimeWarnings(parsed);
+    return parsed;
+}
+/**
+ * Emit `@unimplemented` parse-time warnings for every authored
+ * OPTIONAL field on `WildoMarketingWebsiteConfig` that is parsed
+ * but has no runtime consumer yet.
+ *
+ * Branches today: ZERO. The one OPTIONAL field that exists (`csp?`) is
+ * fully wired through the website-local CSP sync/build path, while the
+ * only field that still lacks a runtime consumer (`appOrigin`) is
+ * REQUIRED. After the seam-collapse (`saas-website-seam-collapse.md` —
+ * SHIPPED) the routing/origin fields are consumed directly by every
+ * Astro engine helper via `WebsiteSiteContext`. Required-but-unwired
+ * fields cannot reasonably fire on every parse — that's a
+ * deferred-wiring surface tracked in the schema header, not an
+ * `@unimplemented` warner concern.
+ *
+ * The function exists as a structural mirror of
+ * `defineTechnicalDocConfig.emitUnimplementedRuntimeWarnings` so
+ * readers grepping for `emitUnimplementedRuntimeWarnings` find a
+ * uniform pattern across every `defineXxxConfig` helper.
+ *
+ * # Adding a branch (recipe)
+ *
+ * When the first OPTIONAL `@unimplemented` field lands (most
+ * likely candidate: `seo?.{title,description}`), add the warner
+ * machinery here: a `seen` set + a
+ * `warn(fieldPath, sliceId)` helper that formats as
+ * `[wildo-website-config] @unimplemented field '...'` and writes
+ * to `process.stderr`, then the matching `if (config.<field> !==
+ * undefined)` branch. Copy the exact shape from
+ * `define-tech-doc-config.ts > emitUnimplementedRuntimeWarnings`
+ * to keep the message format identical across helpers. The test
+ * suite pins the zero-warnings contract — flip its expectation in
+ * the same commit.
+ */
+function emitUnimplementedRuntimeWarnings(_config) {
+    // Intentional no-op — see function JSDoc for why a no-op is the
+    // correct shape today (optional fields are either fully wired or
+    // absent) and the recipe for adding the first branch.
+}
+//# sourceMappingURL=define-website-config.js.map

package/dist/esm/config/define-website-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-website-config.js","sourceRoot":"","sources":["../../../../src/config/define-website-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,OAAO,EACL,iCAAiC,GAGlC,MAAM,gCAAgC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAwC;IAExC,MAAM,MAAM,GAAG,iCAAiC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC/D,gCAAgC,CAAC,MAAM,CAAC,CAAC;IACzC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAS,gCAAgC,CAAC,OAAoC;IAC5E,gEAAgE;IAChE,iEAAiE;IACjE,sDAAsD;AACxD,CAAC","sourcesContent":["/**\n * @fileoverview Author helper for `wildo.website.config.ts` files.\n *\n * `defineWebsiteConfig({...})` mirrors the `defineSaasConfig` /\n * `defineInfraEnvConfig` helpers from `@wildo-ai/platform-config-lib`\n * and `defineTechnicalDocConfig` from `@wildo-ai/saas-technical-doc`:\n * it wraps `WildoMarketingWebsiteConfigSchema.parse(...)` with full\n * IDE autocompletion on the input shape, and emits a parse-time\n * stderr warning for any authored field that has no runtime\n * consumer yet.\n *\n * # `@unimplemented` channel — current state\n *\n * The warner has ZERO branches today because every OPTIONAL field that\n * exists is already wired (`csp?` now flows through the website-local\n * CSP sync step) and the only unwired field left is `appOrigin`, which\n * is REQUIRED. After the seam-collapse (`saas-website-seam-collapse.md`\n * — SHIPPED), the routing/origin fields (`publicOrigin`,\n * `defaultLocale`, `locales`) are consumed directly by every Astro\n * engine helper via `WebsiteSiteContext`, so they are no longer\n * candidates for a \"deferred wiring\" warning either. The\n * `@unimplemented` warner is for fields that are parsed-but-unused AND\n * opt-in — firing on every Astro build for a required field would drown\n * the dev console.\n *\n * Two valid futures will trigger adding warner branches:\n *   1. A future optional field lands (e.g. `seo?.{title,description}`,\n *      `structuredData?.organization`) whose runtime wiring ships\n *      in a later PR — that would get\n *      `if (config.seo !== undefined) warn('seo', ...)` until the\n *      renderer reads it.\n *   2. A required field temporarily loses its consumer (e.g. a\n *      large refactor splits the SEO renderer into two PRs); the\n *      branch fires unconditionally for the duration.\n *\n * The scaffold is kept (and the no-warning contract is pinned by\n * the test suite) so the moment either case lands, the warning\n * channel is one branch addition away — matching the\n * `defineTechnicalDocConfig` shape exactly so future authors\n * grepping for `@unimplemented` find a uniform pattern.\n *\n * Why we don't reuse `platform-config-lib`'s\n * `createUnimplementedFieldWarner`:\n *\n * `platform-config-lib` is the platform-level boundary; this engine\n * package is downstream of it for everything else. Importing the\n * warner from `platform-config-lib` would invert the dependency\n * direction (engine → platform-config), creating the same architectural\n * defect Step 7.5 set out to fix. The warning format is small and\n * stable enough to inline here — kept structurally similar to the\n * platform-config-lib warner so readers grepping for `@unimplemented`\n * still find both surfaces.\n */\n\nimport {\n  WildoMarketingWebsiteConfigSchema,\n  type WildoMarketingWebsiteConfig,\n  type WildoMarketingWebsiteConfigInput,\n} from './wildo-website-config.schemas';\n\n/**\n * Define a per-service marketing-website config. Provides full IDE\n * autocompletion on the input shape, runs Zod validation (fail-closed\n * on typos / unknown keys / out-of-range values / cross-field\n * invariants like `defaultLocale ∈ locales`), and emits parse-time\n * `@unimplemented` warnings for fields that are authored but have no\n * runtime consumer yet.\n *\n * Throws on validation failure — same contract as `defineSaasConfig`\n * and `defineTechnicalDocConfig`.\n *\n * @example\n * ```ts\n * import { AvailableLanguage } from '@wildo-ai/saas-models/public-runtime';\n * import { defineWebsiteConfig } from '@wildo-ai/saas-website';\n *\n * export default defineWebsiteConfig({\n *   publicOrigin: 'https://wonder-todos.example.com',\n *   appOrigin: 'https://app.wonder-todos.example.com',\n *   defaultLocale: AvailableLanguage.EN,\n *   locales: [\n *     { locale: AvailableLanguage.EN, path: 'en' },\n *     { locale: AvailableLanguage.FR, path: 'fr' },\n *   ],\n * });\n * ```\n */\nexport function defineWebsiteConfig(\n  config: WildoMarketingWebsiteConfigInput,\n): WildoMarketingWebsiteConfig {\n  const parsed = WildoMarketingWebsiteConfigSchema.parse(config);\n  emitUnimplementedRuntimeWarnings(parsed);\n  return parsed;\n}\n\n/**\n * Emit `@unimplemented` parse-time warnings for every authored\n * OPTIONAL field on `WildoMarketingWebsiteConfig` that is parsed\n * but has no runtime consumer yet.\n *\n * Branches today: ZERO. The one OPTIONAL field that exists (`csp?`) is\n * fully wired through the website-local CSP sync/build path, while the\n * only field that still lacks a runtime consumer (`appOrigin`) is\n * REQUIRED. After the seam-collapse (`saas-website-seam-collapse.md` —\n * SHIPPED) the routing/origin fields are consumed directly by every\n * Astro engine helper via `WebsiteSiteContext`. Required-but-unwired\n * fields cannot reasonably fire on every parse — that's a\n * deferred-wiring surface tracked in the schema header, not an\n * `@unimplemented` warner concern.\n *\n * The function exists as a structural mirror of\n * `defineTechnicalDocConfig.emitUnimplementedRuntimeWarnings` so\n * readers grepping for `emitUnimplementedRuntimeWarnings` find a\n * uniform pattern across every `defineXxxConfig` helper.\n *\n * # Adding a branch (recipe)\n *\n * When the first OPTIONAL `@unimplemented` field lands (most\n * likely candidate: `seo?.{title,description}`), add the warner\n * machinery here: a `seen` set + a\n * `warn(fieldPath, sliceId)` helper that formats as\n * `[wildo-website-config] @unimplemented field '...'` and writes\n * to `process.stderr`, then the matching `if (config.<field> !==\n * undefined)` branch. Copy the exact shape from\n * `define-tech-doc-config.ts > emitUnimplementedRuntimeWarnings`\n * to keep the message format identical across helpers. The test\n * suite pins the zero-warnings contract — flip its expectation in\n * the same commit.\n */\nfunction emitUnimplementedRuntimeWarnings(_config: WildoMarketingWebsiteConfig): void {\n  // Intentional no-op — see function JSDoc for why a no-op is the\n  // correct shape today (optional fields are either fully wired or\n  // absent) and the recipe for adding the first branch.\n}\n"]}

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

@@ -0,0 +1,38 @@
+/**
+ * `@wildo-ai/saas-website` — config surface.
+ *
+ * Per-service `wildo.website.config.ts` schema + `defineWebsiteConfig`
+ * helper. Co-located with the engine package that owns the marketing-
+ * site primitives so a new SEO field / locale-pack id ships in a
+ * single PR with no cross-package allow-list to keep in sync (see
+ * `wildo-website-config.schemas.ts` JSDoc for the architectural
+ * rationale behind moving this out of `platform-config-lib` —
+ * `saas-website-slice.md` Step 7.5 mirrors the
+ * `saas-technical-doc.md` Step 7.5 fix).
+ *
+ * @wildo-boundary
+ *   This sub-tree is split intentionally:
+ *
+ *     - `wildo-website-config.schemas.ts` — Zod-only, no Node-only
+ *       imports, no `process.*` references. Safe to bundle anywhere.
+ *     - `define-website-config.ts` — uses `process.stderr.write` for
+ *       the (currently empty) `@unimplemented` warner. Bundle-safe in
+ *       practice (the global `process` is polyfilled by every modern
+ *       bundler and the warner has no `node:*` bare specifier), so it
+ *       can ship through the root barrel alongside the schema.
+ *     - `load-website-config.ts` — Node-only. Imports `loadConfig` +
+ *       `AppFrontendType` from `@wildo-ai/platform-config-lib` and
+ *       `node:fs` / `node:path`. Re-exported via the dedicated
+ *       package subpath `./config-loader` (NOT from this barrel) so
+ *       the React-island closure stays free of Node-only specifiers
+ *       (enforced by `__tests__/bundle-isolation.test.ts`).
+ *
+ * Consumers:
+ *   - Author per-service config: `import { defineWebsiteConfig }`
+ *     from `'@wildo-ai/saas-website'`.
+ *   - Load per-service config from a Node-side build / dev pipeline:
+ *     `import { loadWebsiteConfig }` from `'@wildo-ai/saas-website/config-loader'`.
+ */
+export * from './define-website-config';
+export * from './wildo-website-config.schemas';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC"}

package/dist/esm/config/index.js

@@ -0,0 +1,38 @@
+/**
+ * `@wildo-ai/saas-website` — config surface.
+ *
+ * Per-service `wildo.website.config.ts` schema + `defineWebsiteConfig`
+ * helper. Co-located with the engine package that owns the marketing-
+ * site primitives so a new SEO field / locale-pack id ships in a
+ * single PR with no cross-package allow-list to keep in sync (see
+ * `wildo-website-config.schemas.ts` JSDoc for the architectural
+ * rationale behind moving this out of `platform-config-lib` —
+ * `saas-website-slice.md` Step 7.5 mirrors the
+ * `saas-technical-doc.md` Step 7.5 fix).
+ *
+ * @wildo-boundary
+ *   This sub-tree is split intentionally:
+ *
+ *     - `wildo-website-config.schemas.ts` — Zod-only, no Node-only
+ *       imports, no `process.*` references. Safe to bundle anywhere.
+ *     - `define-website-config.ts` — uses `process.stderr.write` for
+ *       the (currently empty) `@unimplemented` warner. Bundle-safe in
+ *       practice (the global `process` is polyfilled by every modern
+ *       bundler and the warner has no `node:*` bare specifier), so it
+ *       can ship through the root barrel alongside the schema.
+ *     - `load-website-config.ts` — Node-only. Imports `loadConfig` +
+ *       `AppFrontendType` from `@wildo-ai/platform-config-lib` and
+ *       `node:fs` / `node:path`. Re-exported via the dedicated
+ *       package subpath `./config-loader` (NOT from this barrel) so
+ *       the React-island closure stays free of Node-only specifiers
+ *       (enforced by `__tests__/bundle-isolation.test.ts`).
+ *
+ * Consumers:
+ *   - Author per-service config: `import { defineWebsiteConfig }`
+ *     from `'@wildo-ai/saas-website'`.
+ *   - Load per-service config from a Node-side build / dev pipeline:
+ *     `import { loadWebsiteConfig }` from `'@wildo-ai/saas-website/config-loader'`.
+ */
+export * from './define-website-config.js';
+export * from './wildo-website-config.schemas.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC","sourcesContent":["/**\n * `@wildo-ai/saas-website` — config surface.\n *\n * Per-service `wildo.website.config.ts` schema + `defineWebsiteConfig`\n * helper. Co-located with the engine package that owns the marketing-\n * site primitives so a new SEO field / locale-pack id ships in a\n * single PR with no cross-package allow-list to keep in sync (see\n * `wildo-website-config.schemas.ts` JSDoc for the architectural\n * rationale behind moving this out of `platform-config-lib` —\n * `saas-website-slice.md` Step 7.5 mirrors the\n * `saas-technical-doc.md` Step 7.5 fix).\n *\n * @wildo-boundary\n *   This sub-tree is split intentionally:\n *\n *     - `wildo-website-config.schemas.ts` — Zod-only, no Node-only\n *       imports, no `process.*` references. Safe to bundle anywhere.\n *     - `define-website-config.ts` — uses `process.stderr.write` for\n *       the (currently empty) `@unimplemented` warner. Bundle-safe in\n *       practice (the global `process` is polyfilled by every modern\n *       bundler and the warner has no `node:*` bare specifier), so it\n *       can ship through the root barrel alongside the schema.\n *     - `load-website-config.ts` — Node-only. Imports `loadConfig` +\n *       `AppFrontendType` from `@wildo-ai/platform-config-lib` and\n *       `node:fs` / `node:path`. Re-exported via the dedicated\n *       package subpath `./config-loader` (NOT from this barrel) so\n *       the React-island closure stays free of Node-only specifiers\n *       (enforced by `__tests__/bundle-isolation.test.ts`).\n *\n * Consumers:\n *   - Author per-service config: `import { defineWebsiteConfig }`\n *     from `'@wildo-ai/saas-website'`.\n *   - Load per-service config from a Node-side build / dev pipeline:\n *     `import { loadWebsiteConfig }` from `'@wildo-ai/saas-website/config-loader'`.\n */\n\nexport * from './define-website-config';\nexport * from './wildo-website-config.schemas';\n"]}

package/dist/esm/config/load-website-config.d.ts

@@ -0,0 +1,136 @@
+/**
+ * @fileoverview Per-service `wildo.website.config.ts` loader.
+ *
+ * Mirrors the `loadTechnicalDocConfig()` shape used by
+ * `platform/factory/wildo-dev-companion/src/technical-doc/services/technical-doc.companion.service.ts`
+ * (see `saas-technical-doc.md` Step 7.5). Discovers the unique
+ * `frontendType: STATIC_WEBSITE` service in the SaaS config, joins
+ * `<saasRoot>/<service.path>/wildo.website.config.ts`, and loads it
+ * via the jiti-backed `loadConfig` from `@wildo-ai/platform-config-lib`.
+ *
+ * The actual Zod validation runs INSIDE `defineWebsiteConfig` (which
+ * the per-service config file invokes via
+ * `export default defineWebsiteConfig({...})`), so by the time
+ * `loadConfig` returns we already hold a parsed
+ * `WildoMarketingWebsiteConfig`.
+ *
+ * @wildo-boundary
+ *   This module is **Node-only**. It imports `loadConfig` and
+ *   `AppFrontendType` from `@wildo-ai/platform-config-lib`, which
+ *   transitively pulls `jiti`, `node:fs`, `node:path`, `node:crypto`,
+ *   and other Node-only API surface. It MUST NOT be imported from
+ *   any browser-bundled entry of this engine package — specifically
+ *   NOT from `index.ts`, `companion-exports.ts`, or `astro-island.ts`.
+ *   The dedicated `./config-loader` package subpath exists precisely
+ *   to keep this surface OUT of the React-island bundle (enforced by
+ *   `__tests__/bundle-isolation.test.ts`).
+ *
+ *   The Astro build's `astro.config.ts` (a Node-side file by
+ *   construction) is the canonical caller. A future companion
+ *   subprocess that audits the marketing surface would also call
+ *   from here. Browser bundles MUST NOT.
+ */
+import type { WildoSaasConfig } from '@wildo-ai/platform-config-lib';
+import type { WildoMarketingWebsiteConfig } from './wildo-website-config.schemas';
+/**
+ * Conventional file name for the per-service marketing-website
+ * configuration (Step 7.5 refactor — `saas-website-slice.md` /
+ * `saas-technical-doc.md` Step 7.5 mirror). Authored at the website
+ * service root next to `package.json` / `astro.config.ts`.
+ *
+ * Discovery is "by convention, not by configuration":
+ *
+ *   - The loader locates this file by walking the `services` entry
+ *     whose `frontendType === STATIC_WEBSITE` and joining
+ *     `<saasRoot>/<service.path>/`. The saas-config schema's
+ *     `superRefine` already enforces "at most one STATIC_WEBSITE
+ *     service per app", so the lookup is deterministic — apps can
+ *     name the website service anything (`'website'`, `'marketing'`,
+ *     `'site'`).
+ *
+ *   - File presence is the enable signal — there is NO `enabled`
+ *     field on `WildoMarketingWebsiteConfigSchema`. A STATIC_WEBSITE
+ *     service without this file is treated as a misconfiguration
+ *     and the loader throws (rather than silently shipping an Astro
+ *     build with no `i18n` routing / no canonical origin).
+ */
+export declare const PER_SERVICE_WEBSITE_CONFIG_FILE_NAME = "wildo.website.config.ts";
+/**
+ * Test helper — pre-populate the loader's memoization slot for a
+ * given absolute config path. Mirrors the
+ * `cachedTechnicalDocConfig` pre-population trick used by
+ * `technical-doc.publish-openapi.service.test.ts` so the loader's
+ * downstream consumers can be exercised in tests without writing a
+ * `.ts` file to disk + invoking jiti.
+ *
+ * Production callers MUST NOT use this helper.
+ */
+export declare function primeWebsiteConfigCache(absoluteConfigPath: string, config: WildoMarketingWebsiteConfig): void;
+/**
+ * Test helper — clear every cached entry. Use in `beforeEach`/`afterEach`
+ * to prevent test cross-contamination.
+ */
+export declare function clearWebsiteConfigCache(): void;
+/**
+ * Arguments for {@link loadWebsiteConfig}. Kept as a structured shape
+ * (rather than positional `loadWebsiteConfig(saasRoot, saasConfig)`)
+ * so that future per-call options (e.g. an explicit `serviceKey`
+ * override for multi-website apps the day the singleton invariant
+ * relaxes) slot in without breaking callers.
+ */
+export interface LoadWebsiteConfigArgs {
+    /**
+     * Absolute path to the SaaS app root — the directory holding
+     * `wildo.saas.config.ts`. Used to resolve `<saasRoot>/<service.path>/`
+     * for the website service folder.
+     */
+    saasRoot: string;
+    /**
+     * The already-parsed SaaS config (load once via
+     * `loadConfig<WildoSaasConfig>(...)` upstream and pass it down here
+     * — re-parsing per call would invoke jiti twice for one logical
+     * load).
+     */
+    saasConfig: WildoSaasConfig;
+}
+/**
+ * Discover and load the per-service marketing-website config.
+ *
+ * Resolution algorithm (mirrors
+ * `TechnicalDocCompanionService.loadTechnicalDocConfig`):
+ *
+ *   1. Find the unique service in `saasConfig.services` whose
+ *      `frontendType === STATIC_WEBSITE`. The saas-config
+ *      `superRefine` guarantees there is at most one — if there is
+ *      none, throw with the misconfiguration message.
+ *   2. Resolve `<saasRoot>/<service.path>/wildo.website.config.ts`.
+ *   3. If the file does not exist, throw (file presence IS the
+ *      enable signal — a STATIC_WEBSITE service without this file
+ *      is broken).
+ *   4. Check the memoization slot keyed on the absolute path; return
+ *      the cached value if present.
+ *   5. Call `loadConfig<WildoMarketingWebsiteConfig>(absolutePath)`.
+ *      jiti evaluates the file, which invokes `defineWebsiteConfig`,
+ *      which invokes `WildoMarketingWebsiteConfigSchema.parse` and
+ *      emits any `@unimplemented` warnings. The returned object is
+ *      already-validated — we trust the in-file `defineWebsiteConfig`
+ *      contract here (mirrors the technical-doc loader pattern in
+ *      `TechnicalDocCompanionService.loadTechnicalDocConfig`, which
+ *      also does NOT re-parse). A file that hand-rolls the default
+ *      export without going through `defineWebsiteConfig` would
+ *      surface as a downstream type mismatch — acceptable given the
+ *      authoring contract is explicit and grep-discoverable.
+ *   6. Memoize and return.
+ *
+ * @throws Error with a `[wildo-website-config]` prefix if no
+ *         STATIC_WEBSITE service is declared, the per-service config
+ *         file is missing, or the file's default export does not
+ *         pass `WildoMarketingWebsiteConfigSchema`. The loader
+ *         intentionally throws plain `Error`s rather than building a
+ *         `WildoBackendError` so it stays usable from the Astro
+ *         build pipeline (which has no DI container) — the companion
+ *         can wrap with `errorBuilder` at the call site if needed
+ *         (mirrors how `loadConfig` itself throws plain `Error`).
+ */
+export declare function loadWebsiteConfig(args: LoadWebsiteConfigArgs): Promise<WildoMarketingWebsiteConfig>;
+//# sourceMappingURL=load-website-config.d.ts.map

package/dist/esm/config/load-website-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-website-config.d.ts","sourceRoot":"","sources":["../../../../src/config/load-website-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oCAAoC,4BAA4B,CAAC;AAkB9E;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,2BAA2B,GAClC,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,2BAA2B,CAAC,CA4DtC"}

package/dist/esm/config/load-website-config.js

@@ -0,0 +1,177 @@
+/**
+ * @fileoverview Per-service `wildo.website.config.ts` loader.
+ *
+ * Mirrors the `loadTechnicalDocConfig()` shape used by
+ * `platform/factory/wildo-dev-companion/src/technical-doc/services/technical-doc.companion.service.ts`
+ * (see `saas-technical-doc.md` Step 7.5). Discovers the unique
+ * `frontendType: STATIC_WEBSITE` service in the SaaS config, joins
+ * `<saasRoot>/<service.path>/wildo.website.config.ts`, and loads it
+ * via the jiti-backed `loadConfig` from `@wildo-ai/platform-config-lib`.
+ *
+ * The actual Zod validation runs INSIDE `defineWebsiteConfig` (which
+ * the per-service config file invokes via
+ * `export default defineWebsiteConfig({...})`), so by the time
+ * `loadConfig` returns we already hold a parsed
+ * `WildoMarketingWebsiteConfig`.
+ *
+ * @wildo-boundary
+ *   This module is **Node-only**. It imports `loadConfig` and
+ *   `AppFrontendType` from `@wildo-ai/platform-config-lib`, which
+ *   transitively pulls `jiti`, `node:fs`, `node:path`, `node:crypto`,
+ *   and other Node-only API surface. It MUST NOT be imported from
+ *   any browser-bundled entry of this engine package — specifically
+ *   NOT from `index.ts`, `companion-exports.ts`, or `astro-island.ts`.
+ *   The dedicated `./config-loader` package subpath exists precisely
+ *   to keep this surface OUT of the React-island bundle (enforced by
+ *   `__tests__/bundle-isolation.test.ts`).
+ *
+ *   The Astro build's `astro.config.ts` (a Node-side file by
+ *   construction) is the canonical caller. A future companion
+ *   subprocess that audits the marketing surface would also call
+ *   from here. Browser bundles MUST NOT.
+ */
+import { existsSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { AppFrontendType, loadConfig } from '@wildo-ai/platform-config-lib';
+/**
+ * Conventional file name for the per-service marketing-website
+ * configuration (Step 7.5 refactor — `saas-website-slice.md` /
+ * `saas-technical-doc.md` Step 7.5 mirror). Authored at the website
+ * service root next to `package.json` / `astro.config.ts`.
+ *
+ * Discovery is "by convention, not by configuration":
+ *
+ *   - The loader locates this file by walking the `services` entry
+ *     whose `frontendType === STATIC_WEBSITE` and joining
+ *     `<saasRoot>/<service.path>/`. The saas-config schema's
+ *     `superRefine` already enforces "at most one STATIC_WEBSITE
+ *     service per app", so the lookup is deterministic — apps can
+ *     name the website service anything (`'website'`, `'marketing'`,
+ *     `'site'`).
+ *
+ *   - File presence is the enable signal — there is NO `enabled`
+ *     field on `WildoMarketingWebsiteConfigSchema`. A STATIC_WEBSITE
+ *     service without this file is treated as a misconfiguration
+ *     and the loader throws (rather than silently shipping an Astro
+ *     build with no `i18n` routing / no canonical origin).
+ */
+export const PER_SERVICE_WEBSITE_CONFIG_FILE_NAME = 'wildo.website.config.ts';
+/**
+ * Memoization slot scoped to the loader module. Keyed by absolute
+ * config file path so multiple SaaS configs evaluated in the same
+ * process (rare in production — possible in tests) do not collide.
+ *
+ * Lifetime: the loader is invoked from the Astro build / dev-server
+ * pipeline, both of which restart the Node process on every dev-stack
+ * reload (the watcher that picks up changes to `wildo.website.config.ts`
+ * is the same watcher that reboots the build). A stale entry here
+ * therefore cannot outlive a config edit.
+ *
+ * Tests can pre-populate a known path via {@link primeWebsiteConfigCache}
+ * to skip the jiti round-trip when exercising downstream consumers.
+ */
+const WEBSITE_CONFIG_CACHE = new Map();
+/**
+ * Test helper — pre-populate the loader's memoization slot for a
+ * given absolute config path. Mirrors the
+ * `cachedTechnicalDocConfig` pre-population trick used by
+ * `technical-doc.publish-openapi.service.test.ts` so the loader's
+ * downstream consumers can be exercised in tests without writing a
+ * `.ts` file to disk + invoking jiti.
+ *
+ * Production callers MUST NOT use this helper.
+ */
+export function primeWebsiteConfigCache(absoluteConfigPath, config) {
+    WEBSITE_CONFIG_CACHE.set(resolvePath(absoluteConfigPath), config);
+}
+/**
+ * Test helper — clear every cached entry. Use in `beforeEach`/`afterEach`
+ * to prevent test cross-contamination.
+ */
+export function clearWebsiteConfigCache() {
+    WEBSITE_CONFIG_CACHE.clear();
+}
+/**
+ * Discover and load the per-service marketing-website config.
+ *
+ * Resolution algorithm (mirrors
+ * `TechnicalDocCompanionService.loadTechnicalDocConfig`):
+ *
+ *   1. Find the unique service in `saasConfig.services` whose
+ *      `frontendType === STATIC_WEBSITE`. The saas-config
+ *      `superRefine` guarantees there is at most one — if there is
+ *      none, throw with the misconfiguration message.
+ *   2. Resolve `<saasRoot>/<service.path>/wildo.website.config.ts`.
+ *   3. If the file does not exist, throw (file presence IS the
+ *      enable signal — a STATIC_WEBSITE service without this file
+ *      is broken).
+ *   4. Check the memoization slot keyed on the absolute path; return
+ *      the cached value if present.
+ *   5. Call `loadConfig<WildoMarketingWebsiteConfig>(absolutePath)`.
+ *      jiti evaluates the file, which invokes `defineWebsiteConfig`,
+ *      which invokes `WildoMarketingWebsiteConfigSchema.parse` and
+ *      emits any `@unimplemented` warnings. The returned object is
+ *      already-validated — we trust the in-file `defineWebsiteConfig`
+ *      contract here (mirrors the technical-doc loader pattern in
+ *      `TechnicalDocCompanionService.loadTechnicalDocConfig`, which
+ *      also does NOT re-parse). A file that hand-rolls the default
+ *      export without going through `defineWebsiteConfig` would
+ *      surface as a downstream type mismatch — acceptable given the
+ *      authoring contract is explicit and grep-discoverable.
+ *   6. Memoize and return.
+ *
+ * @throws Error with a `[wildo-website-config]` prefix if no
+ *         STATIC_WEBSITE service is declared, the per-service config
+ *         file is missing, or the file's default export does not
+ *         pass `WildoMarketingWebsiteConfigSchema`. The loader
+ *         intentionally throws plain `Error`s rather than building a
+ *         `WildoBackendError` so it stays usable from the Astro
+ *         build pipeline (which has no DI container) — the companion
+ *         can wrap with `errorBuilder` at the call site if needed
+ *         (mirrors how `loadConfig` itself throws plain `Error`).
+ */
+export async function loadWebsiteConfig(args) {
+    const { saasRoot, saasConfig } = args;
+    const websiteServiceEntry = Object.entries(saasConfig.services).find(([, service]) => service.frontendType === AppFrontendType.STATIC_WEBSITE);
+    if (!websiteServiceEntry) {
+        throw new Error('[wildo-website-config] No frontend service with `frontendType: STATIC_WEBSITE` is declared in '
+            + 'wildo.saas.config.ts. The marketing-website Astro build / loader requires an authored '
+            + 'STATIC_WEBSITE service because that service folder owns the per-service '
+            + '`wildo.website.config.ts` (publicOrigin, appOrigin, defaultLocale, locales). '
+            + 'Add a STATIC_WEBSITE service in wildo.saas.config.ts and ship the per-service '
+            + 'config file under it.');
+    }
+    const [websiteServiceKey, websiteService] = websiteServiceEntry;
+    const websiteConfigPath = resolvePath(saasRoot, websiteService.path, PER_SERVICE_WEBSITE_CONFIG_FILE_NAME);
+    const cached = WEBSITE_CONFIG_CACHE.get(websiteConfigPath);
+    if (cached !== undefined) {
+        return cached;
+    }
+    if (!existsSync(websiteConfigPath)) {
+        throw new Error(`[wildo-website-config] STATIC_WEBSITE service '${websiteServiceKey}' is declared in `
+            + `wildo.saas.config.ts but the required per-service config file `
+            + `'${PER_SERVICE_WEBSITE_CONFIG_FILE_NAME}' is missing under `
+            + `'${websiteService.path}/'. File presence IS the enable signal `
+            + '(saas-website-slice.md / saas-technical-doc.md Step 7.5 — the legacy '
+            + '`marketingWebsite` block on wildo.saas.config.ts was dropped in favor of '
+            + 'a per-service file). Create '
+            + `'${websiteConfigPath}' with `
+            + '`export default defineWebsiteConfig({ ... })` from `@wildo-ai/saas-website`.');
+    }
+    let loaded;
+    try {
+        loaded = await loadConfig(websiteConfigPath);
+    }
+    catch (e) {
+        const cause = e instanceof Error ? e.message : String(e);
+        throw new Error(`[wildo-website-config] Failed to load per-service marketing-website config at `
+            + `${websiteConfigPath}. The file MUST do `
+            + '`export default defineWebsiteConfig({...})` and pass '
+            + 'WildoMarketingWebsiteConfigSchema (`z.strictObject` — unknown keys reject; '
+            + '`defaultLocale` must appear in `locales`). '
+            + `Cause: ${cause}`);
+    }
+    WEBSITE_CONFIG_CACHE.set(websiteConfigPath, loaded);
+    return loaded;
+}
+//# sourceMappingURL=load-website-config.js.map

package/dist/esm/config/load-website-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-website-config.js","sourceRoot":"","sources":["../../../../src/config/load-website-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAI5E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,yBAAyB,CAAC;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,EAAuC,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB,CACrC,kBAA0B,EAC1B,MAAmC;IAEnC,oBAAoB,CAAC,GAAG,CAAC,WAAW,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC;AACpE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACrC,oBAAoB,CAAC,KAAK,EAAE,CAAC;AAC/B,CAAC;AAyBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAA2B;IAE3B,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAEtC,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,IAAI,CAClE,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,YAAY,KAAK,eAAe,CAAC,cAAc,CACzE,CAAC;IACF,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACb,gGAAgG;cAC5F,wFAAwF;cACxF,0EAA0E;cAC1E,+EAA+E;cAC/E,gFAAgF;cAChF,uBAAuB,CAC5B,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,iBAAiB,EAAE,cAAc,CAAC,GAAG,mBAAmB,CAAC;IAChE,MAAM,iBAAiB,GAAG,WAAW,CACnC,QAAQ,EACR,cAAc,CAAC,IAAI,EACnB,oCAAoC,CACrC,CAAC;IAEF,MAAM,MAAM,GAAG,oBAAoB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAC3D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,kDAAkD,iBAAiB,mBAAmB;cAClF,gEAAgE;cAChE,IAAI,oCAAoC,qBAAqB;cAC7D,IAAI,cAAc,CAAC,IAAI,yCAAyC;cAChE,uEAAuE;cACvE,2EAA2E;cAC3E,8BAA8B;cAC9B,IAAI,iBAAiB,SAAS;cAC9B,8EAA8E,CACnF,CAAC;IACJ,CAAC;IAED,IAAI,MAAmC,CAAC;IACxC,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,UAAU,CAA8B,iBAAiB,CAAC,CAAC;IAC5E,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,KAAK,GAAG,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACzD,MAAM,IAAI,KAAK,CACb,gFAAgF;cAC5E,GAAG,iBAAiB,qBAAqB;cACzC,uDAAuD;cACvD,6EAA6E;cAC7E,6CAA6C;cAC7C,UAAU,KAAK,EAAE,CACtB,CAAC;IACJ,CAAC;IAED,oBAAoB,CAAC,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;IACpD,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * @fileoverview Per-service `wildo.website.config.ts` loader.\n *\n * Mirrors the `loadTechnicalDocConfig()` shape used by\n * `platform/factory/wildo-dev-companion/src/technical-doc/services/technical-doc.companion.service.ts`\n * (see `saas-technical-doc.md` Step 7.5). Discovers the unique\n * `frontendType: STATIC_WEBSITE` service in the SaaS config, joins\n * `<saasRoot>/<service.path>/wildo.website.config.ts`, and loads it\n * via the jiti-backed `loadConfig` from `@wildo-ai/platform-config-lib`.\n *\n * The actual Zod validation runs INSIDE `defineWebsiteConfig` (which\n * the per-service config file invokes via\n * `export default defineWebsiteConfig({...})`), so by the time\n * `loadConfig` returns we already hold a parsed\n * `WildoMarketingWebsiteConfig`.\n *\n * @wildo-boundary\n *   This module is **Node-only**. It imports `loadConfig` and\n *   `AppFrontendType` from `@wildo-ai/platform-config-lib`, which\n *   transitively pulls `jiti`, `node:fs`, `node:path`, `node:crypto`,\n *   and other Node-only API surface. It MUST NOT be imported from\n *   any browser-bundled entry of this engine package — specifically\n *   NOT from `index.ts`, `companion-exports.ts`, or `astro-island.ts`.\n *   The dedicated `./config-loader` package subpath exists precisely\n *   to keep this surface OUT of the React-island bundle (enforced by\n *   `__tests__/bundle-isolation.test.ts`).\n *\n *   The Astro build's `astro.config.ts` (a Node-side file by\n *   construction) is the canonical caller. A future companion\n *   subprocess that audits the marketing surface would also call\n *   from here. Browser bundles MUST NOT.\n */\n\nimport { existsSync } from 'node:fs';\nimport { resolve as resolvePath } from 'node:path';\nimport { AppFrontendType, loadConfig } from '@wildo-ai/platform-config-lib';\nimport type { WildoSaasConfig } from '@wildo-ai/platform-config-lib';\nimport type { WildoMarketingWebsiteConfig } from './wildo-website-config.schemas';\n\n/**\n * Conventional file name for the per-service marketing-website\n * configuration (Step 7.5 refactor — `saas-website-slice.md` /\n * `saas-technical-doc.md` Step 7.5 mirror). Authored at the website\n * service root next to `package.json` / `astro.config.ts`.\n *\n * Discovery is \"by convention, not by configuration\":\n *\n *   - The loader locates this file by walking the `services` entry\n *     whose `frontendType === STATIC_WEBSITE` and joining\n *     `<saasRoot>/<service.path>/`. The saas-config schema's\n *     `superRefine` already enforces \"at most one STATIC_WEBSITE\n *     service per app\", so the lookup is deterministic — apps can\n *     name the website service anything (`'website'`, `'marketing'`,\n *     `'site'`).\n *\n *   - File presence is the enable signal — there is NO `enabled`\n *     field on `WildoMarketingWebsiteConfigSchema`. A STATIC_WEBSITE\n *     service without this file is treated as a misconfiguration\n *     and the loader throws (rather than silently shipping an Astro\n *     build with no `i18n` routing / no canonical origin).\n */\nexport const PER_SERVICE_WEBSITE_CONFIG_FILE_NAME = 'wildo.website.config.ts';\n\n/**\n * Memoization slot scoped to the loader module. Keyed by absolute\n * config file path so multiple SaaS configs evaluated in the same\n * process (rare in production — possible in tests) do not collide.\n *\n * Lifetime: the loader is invoked from the Astro build / dev-server\n * pipeline, both of which restart the Node process on every dev-stack\n * reload (the watcher that picks up changes to `wildo.website.config.ts`\n * is the same watcher that reboots the build). A stale entry here\n * therefore cannot outlive a config edit.\n *\n * Tests can pre-populate a known path via {@link primeWebsiteConfigCache}\n * to skip the jiti round-trip when exercising downstream consumers.\n */\nconst WEBSITE_CONFIG_CACHE = new Map<string, WildoMarketingWebsiteConfig>();\n\n/**\n * Test helper — pre-populate the loader's memoization slot for a\n * given absolute config path. Mirrors the\n * `cachedTechnicalDocConfig` pre-population trick used by\n * `technical-doc.publish-openapi.service.test.ts` so the loader's\n * downstream consumers can be exercised in tests without writing a\n * `.ts` file to disk + invoking jiti.\n *\n * Production callers MUST NOT use this helper.\n */\nexport function primeWebsiteConfigCache(\n  absoluteConfigPath: string,\n  config: WildoMarketingWebsiteConfig,\n): void {\n  WEBSITE_CONFIG_CACHE.set(resolvePath(absoluteConfigPath), config);\n}\n\n/**\n * Test helper — clear every cached entry. Use in `beforeEach`/`afterEach`\n * to prevent test cross-contamination.\n */\nexport function clearWebsiteConfigCache(): void {\n  WEBSITE_CONFIG_CACHE.clear();\n}\n\n/**\n * Arguments for {@link loadWebsiteConfig}. Kept as a structured shape\n * (rather than positional `loadWebsiteConfig(saasRoot, saasConfig)`)\n * so that future per-call options (e.g. an explicit `serviceKey`\n * override for multi-website apps the day the singleton invariant\n * relaxes) slot in without breaking callers.\n */\nexport interface LoadWebsiteConfigArgs {\n  /**\n   * Absolute path to the SaaS app root — the directory holding\n   * `wildo.saas.config.ts`. Used to resolve `<saasRoot>/<service.path>/`\n   * for the website service folder.\n   */\n  saasRoot: string;\n  /**\n   * The already-parsed SaaS config (load once via\n   * `loadConfig<WildoSaasConfig>(...)` upstream and pass it down here\n   * — re-parsing per call would invoke jiti twice for one logical\n   * load).\n   */\n  saasConfig: WildoSaasConfig;\n}\n\n/**\n * Discover and load the per-service marketing-website config.\n *\n * Resolution algorithm (mirrors\n * `TechnicalDocCompanionService.loadTechnicalDocConfig`):\n *\n *   1. Find the unique service in `saasConfig.services` whose\n *      `frontendType === STATIC_WEBSITE`. The saas-config\n *      `superRefine` guarantees there is at most one — if there is\n *      none, throw with the misconfiguration message.\n *   2. Resolve `<saasRoot>/<service.path>/wildo.website.config.ts`.\n *   3. If the file does not exist, throw (file presence IS the\n *      enable signal — a STATIC_WEBSITE service without this file\n *      is broken).\n *   4. Check the memoization slot keyed on the absolute path; return\n *      the cached value if present.\n *   5. Call `loadConfig<WildoMarketingWebsiteConfig>(absolutePath)`.\n *      jiti evaluates the file, which invokes `defineWebsiteConfig`,\n *      which invokes `WildoMarketingWebsiteConfigSchema.parse` and\n *      emits any `@unimplemented` warnings. The returned object is\n *      already-validated — we trust the in-file `defineWebsiteConfig`\n *      contract here (mirrors the technical-doc loader pattern in\n *      `TechnicalDocCompanionService.loadTechnicalDocConfig`, which\n *      also does NOT re-parse). A file that hand-rolls the default\n *      export without going through `defineWebsiteConfig` would\n *      surface as a downstream type mismatch — acceptable given the\n *      authoring contract is explicit and grep-discoverable.\n *   6. Memoize and return.\n *\n * @throws Error with a `[wildo-website-config]` prefix if no\n *         STATIC_WEBSITE service is declared, the per-service config\n *         file is missing, or the file's default export does not\n *         pass `WildoMarketingWebsiteConfigSchema`. The loader\n *         intentionally throws plain `Error`s rather than building a\n *         `WildoBackendError` so it stays usable from the Astro\n *         build pipeline (which has no DI container) — the companion\n *         can wrap with `errorBuilder` at the call site if needed\n *         (mirrors how `loadConfig` itself throws plain `Error`).\n */\nexport async function loadWebsiteConfig(\n  args: LoadWebsiteConfigArgs,\n): Promise<WildoMarketingWebsiteConfig> {\n  const { saasRoot, saasConfig } = args;\n\n  const websiteServiceEntry = Object.entries(saasConfig.services).find(\n    ([, service]) => service.frontendType === AppFrontendType.STATIC_WEBSITE,\n  );\n  if (!websiteServiceEntry) {\n    throw new Error(\n      '[wildo-website-config] No frontend service with `frontendType: STATIC_WEBSITE` is declared in '\n        + 'wildo.saas.config.ts. The marketing-website Astro build / loader requires an authored '\n        + 'STATIC_WEBSITE service because that service folder owns the per-service '\n        + '`wildo.website.config.ts` (publicOrigin, appOrigin, defaultLocale, locales). '\n        + 'Add a STATIC_WEBSITE service in wildo.saas.config.ts and ship the per-service '\n        + 'config file under it.',\n    );\n  }\n\n  const [websiteServiceKey, websiteService] = websiteServiceEntry;\n  const websiteConfigPath = resolvePath(\n    saasRoot,\n    websiteService.path,\n    PER_SERVICE_WEBSITE_CONFIG_FILE_NAME,\n  );\n\n  const cached = WEBSITE_CONFIG_CACHE.get(websiteConfigPath);\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  if (!existsSync(websiteConfigPath)) {\n    throw new Error(\n      `[wildo-website-config] STATIC_WEBSITE service '${websiteServiceKey}' is declared in `\n        + `wildo.saas.config.ts but the required per-service config file `\n        + `'${PER_SERVICE_WEBSITE_CONFIG_FILE_NAME}' is missing under `\n        + `'${websiteService.path}/'. File presence IS the enable signal `\n        + '(saas-website-slice.md / saas-technical-doc.md Step 7.5 — the legacy '\n        + '`marketingWebsite` block on wildo.saas.config.ts was dropped in favor of '\n        + 'a per-service file). Create '\n        + `'${websiteConfigPath}' with `\n        + '`export default defineWebsiteConfig({ ... })` from `@wildo-ai/saas-website`.',\n    );\n  }\n\n  let loaded: WildoMarketingWebsiteConfig;\n  try {\n    loaded = await loadConfig<WildoMarketingWebsiteConfig>(websiteConfigPath);\n  } catch (e) {\n    const cause = e instanceof Error ? e.message : String(e);\n    throw new Error(\n      `[wildo-website-config] Failed to load per-service marketing-website config at `\n        + `${websiteConfigPath}. The file MUST do `\n        + '`export default defineWebsiteConfig({...})` and pass '\n        + 'WildoMarketingWebsiteConfigSchema (`z.strictObject` — unknown keys reject; '\n        + '`defaultLocale` must appear in `locales`). '\n        + `Cause: ${cause}`,\n    );\n  }\n\n  WEBSITE_CONFIG_CACHE.set(websiteConfigPath, loaded);\n  return loaded;\n}\n"]}