gazetta 0.7.0 → 0.8.0

package/dist/component-ids.js

@@ -0,0 +1,83 @@
+/**
+ * Component IDs — stable identifiers for InlineComponent entries
+ * within page and fragment manifests.
+ *
+ * # Why this exists
+ *
+ * Inline anchors (per `design-collaboration.md`) need a stable
+ * reference to a specific component within a page/fragment that
+ * survives reorders, edits, and template switches. The component's
+ * `name` field is author-meaningful and not unique site-wide; the
+ * tree path is unstable across reorders. A dedicated `id` field is
+ * the load-bearing primitive for:
+ *
+ *   - Inline comments anchored to a component
+ *   - Per-field overlays in i18n (when #192 lands; per-component
+ *     overrides need a stable component reference)
+ *   - Future use cases that need "this exact component, not a
+ *     name-collision-prone or order-dependent reference"
+ *
+ * # When IDs are assigned
+ *
+ * On save: every InlineComponent without an `id` gets one. Existing
+ * IDs are preserved across saves. Fragment-reference strings
+ * (`"@header"`) don't get IDs — they reference a separate manifest
+ * with its own components.
+ *
+ * # Why NanoID over UUID
+ *
+ * NanoID is 21 chars vs UUID's 36; both have collision-resistance
+ * well past the operating envelope (5000 pages × 50 components =
+ * 250K IDs; NanoID's 21-char alphabet of 64 symbols gives ~10^36
+ * keyspace — birthday-bound nowhere near our scale). Component IDs
+ * appear in audit metadata, comment payloads, and (future) persisted
+ * edits — shorter is friendlier to humans skimming logs.
+ *
+ * # SOLID lenses
+ *
+ *   - SRP: this module owns ID generation + recursive injection
+ *     into a manifest's components tree. Doesn't read or write
+ *     storage; pure transformations.
+ *   - DIP: the ID generator is injectable so tests can pass a
+ *     deterministic stub. Production uses NanoID.
+ */
+import { nanoid } from 'nanoid';
+/** Default generator — 21-char NanoID. */
+export const defaultComponentIdGenerator = () => nanoid();
+/**
+ * Walk a `components` array and inject IDs on any InlineComponent
+ * that lacks one. Existing IDs are preserved; fragment-reference
+ * strings pass through unchanged.
+ *
+ * Returns a new array (functional, never mutates input). Components
+ * with nested `components` recurse; the same generator instance is
+ * threaded so deterministic stubs in tests produce predictable trees.
+ */
+export function ensureComponentIds(components, generate = defaultComponentIdGenerator) {
+    if (!components)
+        return [];
+    return components.map(entry => ensureEntry(entry, generate));
+}
+function ensureEntry(entry, generate) {
+    // Fragment refs pass through — they point at a separate manifest
+    // whose components carry their own IDs.
+    if (typeof entry === 'string')
+        return entry;
+    return ensureInline(entry, generate);
+}
+function ensureInline(component, generate) {
+    const nextChildren = component.components ? component.components.map(c => ensureEntry(c, generate)) : undefined;
+    const id = component.id ?? generate();
+    // Only build a new object when something would actually change —
+    // either a missing id, or recursion changed a nested entry. Keeps
+    // identity-equality stable for callers that compare by reference.
+    const idChanged = component.id === undefined;
+    const childrenChanged = nextChildren !== component.components;
+    if (!idChanged && !childrenChanged)
+        return component;
+    const next = { ...component, id };
+    if (nextChildren !== undefined)
+        next.components = nextChildren;
+    return next;
+}
+//# sourceMappingURL=component-ids.js.map

package/dist/component-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-ids.js","sourceRoot":"","sources":["../src/component-ids.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAgB/B,0CAA0C;AAC1C,MAAM,CAAC,MAAM,2BAA2B,GAAyB,GAAG,EAAE,CAAC,MAAM,EAAE,CAAA;AAE/E;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,UAAiD,EACjD,WAAiC,2BAA2B;IAE5D,IAAI,CAAC,UAAU;QAAE,OAAO,EAAE,CAAA;IAC1B,OAAO,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAA;AAC9D,CAAC;AAED,SAAS,WAAW,CAAC,KAAqB,EAAE,QAA8B;IACxE,iEAAiE;IACjE,wCAAwC;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAC3C,OAAO,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;AACtC,CAAC;AAED,SAAS,YAAY,CAAC,SAA0B,EAAE,QAA8B;IAC9E,MAAM,YAAY,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IAC/G,MAAM,EAAE,GAAG,SAAS,CAAC,EAAE,IAAI,QAAQ,EAAE,CAAA;IACrC,iEAAiE;IACjE,kEAAkE;IAClE,kEAAkE;IAClE,MAAM,SAAS,GAAG,SAAS,CAAC,EAAE,KAAK,SAAS,CAAA;IAC5C,MAAM,eAAe,GAAG,YAAY,KAAK,SAAS,CAAC,UAAU,CAAA;IAC7D,IAAI,CAAC,SAAS,IAAI,CAAC,eAAe;QAAE,OAAO,SAAS,CAAA;IACpD,MAAM,IAAI,GAAoB,EAAE,GAAG,SAAS,EAAE,EAAE,EAAE,CAAA;IAClD,IAAI,YAAY,KAAK,SAAS;QAAE,IAAI,CAAC,UAAU,GAAG,YAAY,CAAA;IAC9D,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/config/define.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Typed identity functions for site.config.ts and gazetta.config.ts.
+ *
+ * Per ADR-0005 + design-config.md: returns the input unchanged but
+ * provides TS inference for IDE autocomplete via generic constraint.
+ *
+ * The `<const T>` modifier (TS 5.0+) preserves literal types so
+ * fields like `environment: 'production'` infer as the literal
+ * `'production'`, not widened to `string`. Without it, downstream
+ * type narrowing (e.g., `if (target.environment === 'production')`)
+ * would fail to discriminate.
+ *
+ * Pattern matches Sanity / Astro / Vite / Vitest's `defineConfig` —
+ * familiar to operators coming from adjacent tooling.
+ *
+ * Constraint widened from the Zod-inferred user-input shape
+ * (`SiteConfig`/`GazettaConfig`, formerly public) to the runtime
+ * manifest shape (`SiteManifest`/`GazettaManifest`) per the Path X
+ * migration. The user-input vs. runtime distinction collapsed when
+ * provider fields became factory-call instances at config-eval time
+ * — there's no longer a separate "loose" input shape worth aliasing.
+ *
+ * Runtime Zod validation runs separately in the loader; identity
+ * functions here are zero-cost at runtime.
+ */
+import type { GazettaManifest, SiteManifest } from '../types.js';
+/**
+ * Define a site's configuration. Returns the input unchanged.
+ *
+ * @example
+ * ```ts
+ * import { defineSite, filesystemStorage, anthropicProvider } from 'gazetta'
+ *
+ * export default defineSite({
+ *   name: 'main',
+ *   locales: { default: 'en', supported: ['en', 'fr'] },
+ *   ai: { provider: anthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY! }) },
+ *   targets: {
+ *     local: { storage: filesystemStorage() },
+ *   },
+ * })
+ * ```
+ */
+export declare function defineSite<const T extends SiteManifest>(config: T): T;
+/**
+ * Define project-level Gazetta configuration. Returns the input unchanged.
+ *
+ * @example
+ * ```ts
+ * import { defineGazetta, memoryCache } from 'gazetta'
+ *
+ * export default defineGazetta({
+ *   logLevel: 'info',
+ *   defaults: {
+ *     cache: memoryCache({ maxEntries: 5000 }),
+ *   },
+ * })
+ * ```
+ */
+export declare function defineGazetta<const T extends GazettaManifest>(config: T): T;
+//# sourceMappingURL=define.d.ts.map

package/dist/config/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/config/define.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,YAAY,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAErE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,CAAC,CAAC,SAAS,eAAe,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAE3E"}

package/dist/config/define.js

@@ -0,0 +1,64 @@
+/**
+ * Typed identity functions for site.config.ts and gazetta.config.ts.
+ *
+ * Per ADR-0005 + design-config.md: returns the input unchanged but
+ * provides TS inference for IDE autocomplete via generic constraint.
+ *
+ * The `<const T>` modifier (TS 5.0+) preserves literal types so
+ * fields like `environment: 'production'` infer as the literal
+ * `'production'`, not widened to `string`. Without it, downstream
+ * type narrowing (e.g., `if (target.environment === 'production')`)
+ * would fail to discriminate.
+ *
+ * Pattern matches Sanity / Astro / Vite / Vitest's `defineConfig` —
+ * familiar to operators coming from adjacent tooling.
+ *
+ * Constraint widened from the Zod-inferred user-input shape
+ * (`SiteConfig`/`GazettaConfig`, formerly public) to the runtime
+ * manifest shape (`SiteManifest`/`GazettaManifest`) per the Path X
+ * migration. The user-input vs. runtime distinction collapsed when
+ * provider fields became factory-call instances at config-eval time
+ * — there's no longer a separate "loose" input shape worth aliasing.
+ *
+ * Runtime Zod validation runs separately in the loader; identity
+ * functions here are zero-cost at runtime.
+ */
+/**
+ * Define a site's configuration. Returns the input unchanged.
+ *
+ * @example
+ * ```ts
+ * import { defineSite, filesystemStorage, anthropicProvider } from 'gazetta'
+ *
+ * export default defineSite({
+ *   name: 'main',
+ *   locales: { default: 'en', supported: ['en', 'fr'] },
+ *   ai: { provider: anthropicProvider({ apiKey: process.env.ANTHROPIC_API_KEY! }) },
+ *   targets: {
+ *     local: { storage: filesystemStorage() },
+ *   },
+ * })
+ * ```
+ */
+export function defineSite(config) {
+    return config;
+}
+/**
+ * Define project-level Gazetta configuration. Returns the input unchanged.
+ *
+ * @example
+ * ```ts
+ * import { defineGazetta, memoryCache } from 'gazetta'
+ *
+ * export default defineGazetta({
+ *   logLevel: 'info',
+ *   defaults: {
+ *     cache: memoryCache({ maxEntries: 5000 }),
+ *   },
+ * })
+ * ```
+ */
+export function defineGazetta(config) {
+    return config;
+}
+//# sourceMappingURL=define.js.map

package/dist/config/define.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.js","sourceRoot":"","sources":["../../src/config/define.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,UAAU,CAA+B,MAAS;IAChE,OAAO,MAAM,CAAA;AACf,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAAkC,MAAS;IACtE,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/config/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Config-loading error types.
+ *
+ * Per design-config.md and Universal Provider Requirements:
+ * - Configuration errors throw at admin boot (admin won't start)
+ * - Errors carry the file path so operators can locate the issue
+ */
+/** Base class for all config-loading errors. */
+export declare class ConfigError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Schema validation failed — config doesn't match the expected shape. */
+export declare class ConfigValidationError extends ConfigError {
+    readonly filePath: string;
+    constructor(message: string, filePath: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Config file couldn't be parsed (syntax error, evaluation throws). */
+export declare class ConfigEvaluationError extends ConfigError {
+    readonly filePath: string;
+    constructor(message: string, filePath: string, options?: {
+        cause?: unknown;
+    });
+}
+/** Layout conflict — both flat (root site.config.ts) and sites/ dir present. */
+export declare class ConfigLayoutError extends ConfigError {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/config/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/config/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,gDAAgD;AAChD,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAI3D;AAED,0EAA0E;AAC1E,qBAAa,qBAAsB,SAAQ,WAAW;aAGlC,QAAQ,EAAE,MAAM;gBADhC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,MAAM,EAChC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAKhC;AAED,wEAAwE;AACxE,qBAAa,qBAAsB,SAAQ,WAAW;aAGlC,QAAQ,EAAE,MAAM;gBADhC,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,MAAM,EAChC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAKhC;AAED,gFAAgF;AAChF,qBAAa,iBAAkB,SAAQ,WAAW;gBACpC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/config/errors.js

@@ -0,0 +1,40 @@
+/**
+ * Config-loading error types.
+ *
+ * Per design-config.md and Universal Provider Requirements:
+ * - Configuration errors throw at admin boot (admin won't start)
+ * - Errors carry the file path so operators can locate the issue
+ */
+/** Base class for all config-loading errors. */
+export class ConfigError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'ConfigError';
+    }
+}
+/** Schema validation failed — config doesn't match the expected shape. */
+export class ConfigValidationError extends ConfigError {
+    filePath;
+    constructor(message, filePath, options) {
+        super(`${message} (in ${filePath})`, options);
+        this.filePath = filePath;
+        this.name = 'ConfigValidationError';
+    }
+}
+/** Config file couldn't be parsed (syntax error, evaluation throws). */
+export class ConfigEvaluationError extends ConfigError {
+    filePath;
+    constructor(message, filePath, options) {
+        super(`${message} (in ${filePath})`, options);
+        this.filePath = filePath;
+        this.name = 'ConfigEvaluationError';
+    }
+}
+/** Layout conflict — both flat (root site.config.ts) and sites/ dir present. */
+export class ConfigLayoutError extends ConfigError {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigLayoutError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/config/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/config/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,gDAAgD;AAChD,MAAM,OAAO,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAe,EAAE,OAA6B;QACxD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;QACvB,IAAI,CAAC,IAAI,GAAG,aAAa,CAAA;IAC3B,CAAC;CACF;AAED,0EAA0E;AAC1E,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAGlC;IAFlB,YACE,OAAe,EACC,QAAgB,EAChC,OAA6B;QAE7B,KAAK,CAAC,GAAG,OAAO,QAAQ,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAA;QAH7B,aAAQ,GAAR,QAAQ,CAAQ;QAIhC,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;IACrC,CAAC;CACF;AAED,wEAAwE;AACxE,MAAM,OAAO,qBAAsB,SAAQ,WAAW;IAGlC;IAFlB,YACE,OAAe,EACC,QAAgB,EAChC,OAA6B;QAE7B,KAAK,CAAC,GAAG,OAAO,QAAQ,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAA;QAH7B,aAAQ,GAAR,QAAQ,CAAQ;QAIhC,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;IACrC,CAAC;CACF;AAED,gFAAgF;AAChF,MAAM,OAAO,iBAAkB,SAAQ,WAAW;IAChD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAA;IACjC,CAAC;CACF"}

package/dist/config/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Site config + Gazetta config public exports.
+ *
+ * Per ADR-0005 and design-config.md: TS config (`gazetta.config.ts` +
+ * `site.config.ts`) replaces YAML; identity functions provide IDE
+ * inference; runtime Zod validation runs at load.
+ */
+export { defineSite, defineGazetta } from './define.js';
+export { SiteConfigSchema, GazettaConfigSchema } from './schemas.js';
+export { ConfigError, ConfigValidationError, ConfigEvaluationError, ConfigLayoutError, } from './errors.js';
+export { loadGazettaConfig, loadSiteConfig, discoverSites, loadProjectConfig, siteConfigToManifest, gazettaConfigToManifest, } from './loader.js';
+export type { DiscoveredSite, LoadedProjectConfig } from './loader.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AASvD,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA"}

package/dist/config/index.js

@@ -0,0 +1,20 @@
+/**
+ * Site config + Gazetta config public exports.
+ *
+ * Per ADR-0005 and design-config.md: TS config (`gazetta.config.ts` +
+ * `site.config.ts`) replaces YAML; identity functions provide IDE
+ * inference; runtime Zod validation runs at load.
+ */
+export { defineSite, defineGazetta } from './define.js';
+// `SiteConfig` / `GazettaConfig` (z.infer-derived input shapes) are no
+// longer publicly exported. Per Path X, the user-input shape and the
+// runtime manifest shape converged when provider fields became factory
+// instances — there's no separate "loose" input type worth aliasing.
+// Operators get types via `defineSite` / `defineGazetta` inference from
+// `SiteManifest` / `GazettaManifest` (runtime shapes from `gazetta`).
+// Internal callers in `packages/gazetta/src/config/` import `SiteConfig`
+// / `GazettaConfig` from `./types.js` directly.
+export { SiteConfigSchema, GazettaConfigSchema } from './schemas.js';
+export { ConfigError, ConfigValidationError, ConfigEvaluationError, ConfigLayoutError, } from './errors.js';
+export { loadGazettaConfig, loadSiteConfig, discoverSites, loadProjectConfig, siteConfigToManifest, gazettaConfigToManifest, } from './loader.js';
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACvD,uEAAuE;AACvE,qEAAqE;AACrE,uEAAuE;AACvE,qEAAqE;AACrE,wEAAwE;AACxE,sEAAsE;AACtE,yEAAyE;AACzE,gDAAgD;AAChD,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,aAAa,CAAA"}

package/dist/config/loader.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Site config + Gazetta config loader.
+ *
+ * Per design-config.md, design-config-implementation.md Cut 2, and
+ * locked Q1-Q4:
+ *
+ * - jiti for TS evaluation (reuses template-loader's pattern)
+ * - dotenv loaded BEFORE config eval (Q4 lock; project-root only;
+ *   CI-skip preserved)
+ * - Discovery rules per Q2 lock:
+ *   - Both root site.config.ts AND sites/ dir present → ConfigLayoutError
+ *   - sites/ dir exists → walk subdirectories with site.config.ts;
+ *     skip + warn for any subdir without it
+ *   - Otherwise → flat layout: site.config.ts at project root
+ * - gazetta.config.ts at project root is optional; absent = built-in defaults
+ * - Zod validation on every load (defense in depth alongside TS types)
+ * - Defaults flow per design-config.md: object-fields inherit from
+ *   gazetta.defaults; arrays (plugins, hooks) are explicit per site
+ */
+import type { GazettaConfig, SiteConfig } from './types.js';
+/** A discovered site within a project. */
+export interface DiscoveredSite {
+    /** Site name — directory name for sites/ layout, config.name for flat layout. */
+    name: string;
+    /** Absolute path to the site directory containing pages/, fragments/, etc. */
+    dir: string;
+    /** Absolute path to the site.config.ts file. */
+    configPath: string;
+    /** Loaded + validated site config. */
+    config: SiteConfig;
+}
+/** Result of project-wide config loading. */
+export interface LoadedProjectConfig {
+    /** Project root (absolute path). */
+    projectRoot: string;
+    /** Loaded gazetta.config.ts, or null if absent (use built-in defaults). */
+    gazetta: GazettaConfig | null;
+    /** All discovered sites, in stable directory-name order. */
+    sites: DiscoveredSite[];
+}
+/**
+ * Load gazetta.config.ts from the project root.
+ *
+ * Returns null if no config file is present (built-in defaults apply).
+ */
+export declare function loadGazettaConfig(projectRoot: string): Promise<GazettaConfig | null>;
+/**
+ * Load a single site.config.ts from a site directory.
+ *
+ * Per Q2 lock: if the site directory exists but has no config file,
+ * returns null (caller decides whether to warn + skip).
+ */
+export declare function loadSiteConfig(siteDir: string): Promise<{
+    config: SiteConfig;
+    configPath: string;
+} | null>;
+/**
+ * Discover and load all sites in a project.
+ *
+ * Implements Q2 layout-resolution rules:
+ * - Both root site.config.ts AND sites/ dir present → ConfigLayoutError
+ * - sites/ dir exists → walk subdirectories; warn + skip any without site.config.ts
+ * - Otherwise → flat layout: single site at project root
+ */
+export declare function discoverSites(projectRoot: string, gazetta: GazettaConfig | null, options?: {
+    logger?: (msg: string) => void;
+}): Promise<DiscoveredSite[]>;
+/**
+ * Load the full project config — gazetta.config.ts (optional) + all
+ * discovered sites.
+ *
+ * This is the top-level entry point that boot flows use. dotenv must
+ * already have been loaded before this is called (per Q4 lock).
+ */
+export declare function loadProjectConfig(projectRoot: string, options?: {
+    logger?: (msg: string) => void;
+}): Promise<LoadedProjectConfig>;
+/**
+ * Adapter: convert the user's SiteConfig (input shape) into the
+ * runtime SiteManifest shape consumed by site-loader.ts and
+ * downstream code.
+ *
+ * The two shapes are equivalent at runtime — SiteManifest types nested
+ * provider blocks (ai, altText, targets, themes.default) more strictly
+ * than SiteConfig (which uses Record<string, unknown> for forward-
+ * compatibility with foundations that haven't shipped yet).
+ *
+ * The conversion is structural: pass the values through; cast nested
+ * provider blocks to their runtime types. Downstream validation (alt
+ * adapter factory, etc.) still runs and rejects malformed nested data.
+ *
+ * Per design-config-implementation.md Cut 4 — wires the new TS-config
+ * loader into existing site-loader.ts without breaking downstream
+ * consumers that read site.manifest.{name, locale, targets, ...}.
+ */
+export declare function siteConfigToManifest(config: SiteConfig): import('../types.js').SiteManifest;
+/**
+ * Convert a `GazettaConfig` (Zod-inferred user input) to a runtime
+ * `GazettaManifest`. Same lossless cast as `siteConfigToManifest` —
+ * the shapes overlap; runtime values flow through. Gazetta-level
+ * `ai.provider` is opaque (`z.unknown()`) in the schema but is the
+ * constructed `AIProvider` instance at runtime.
+ */
+export declare function gazettaConfigToManifest(config: GazettaConfig): import('../types.js').GazettaManifest;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAK3D,0CAA0C;AAC1C,MAAM,WAAW,cAAc;IAC7B,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAA;IAClB,sCAAsC;IACtC,MAAM,EAAE,UAAU,CAAA;CACnB;AAED,6CAA6C;AAC7C,MAAM,WAAW,mBAAmB;IAClC,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,OAAO,EAAE,aAAa,GAAG,IAAI,CAAA;IAC7B,4DAA4D;IAC5D,KAAK,EAAE,cAAc,EAAE,CAAA;CACxB;AA6ED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAK1F;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7D,MAAM,EAAE,UAAU,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,IAAI,CAAC,CAMR;AA6BD;;;;;;;GAOG;AACH,wBAAsB,aAAa,CACjC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,aAAa,GAAG,IAAI,EAC7B,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC3C,OAAO,CAAC,cAAc,EAAE,CAAC,CA6D3B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC3C,OAAO,CAAC,mBAAmB,CAAC,CAS9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,aAAa,EAAE,YAAY,CAO3F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,aAAa,EAAE,eAAe,CAEpG"}