@elytracms/core 0.0.6

package/dist/studio-core/workspace-config.d.ts

@@ -0,0 +1,587 @@
+import { z } from 'zod';
+import type { CollectionDef, RedirectRecord, RouteRecord } from '@elytracms/core/cms-core';
+import type { ComponentManifest } from '@elytracms/core/component-registry';
+import type { ExportTarget, Project, ProjectSettings } from './metadata';
+import type { SectionAvailabilityMap } from './sections';
+/**
+ * Code-first workspace config — `elytra.config.ts` (EC-154, vision AD-8).
+ *
+ * A repo declares its projects as code: the config file default-exports
+ * `defineElytraConfig({...})` with an array of project configs, optionally
+ * composed over a shared `base`. The studio's project switcher and the CLI
+ * (`builder init --project <slug>`) both consume the same schema and the same
+ * structured validation, so an invalid config fails identically everywhere —
+ * never silently.
+ *
+ * Composition semantics (deliberately simple and deterministic): each project
+ * entry is merged over `base` **per field** — a field set on the entry replaces
+ * the base field entirely (arrays and objects are not deep-merged). Fields set
+ * on neither fall back to documented defaults.
+ *
+ * Validation follows the EC-028/EC-029 split: Zod checks field *shapes*;
+ * cross-field and cross-project rules (duplicate slugs, default locale ∈
+ * locales, empty projects) surface as structured, path-located
+ * {@link WorkspaceConfigIssue}s — never throws. The settings-shaped parts reuse
+ * the EC-028 `validateProjectSettings` rules verbatim.
+ */
+/** Where a project's collection schema lives: a host-repo module, or managed in the studio. */
+export declare const workspaceSchemaRefSchema: z.ZodUnion<readonly [z.ZodLiteral<"inline">, z.ZodObject<{
+    module: z.ZodString;
+}, z.core.$strip>]>;
+export type WorkspaceSchemaRef = z.infer<typeof workspaceSchemaRefSchema>;
+/**
+ * A project's components, config-as-code (EC-223 mount contract): the live
+ * (manifest + implementation) pairs the studio registry and host runtime
+ * register. Replaces the old `{ dir }`/`{ package }` string pointer — components
+ * are code, injected directly into the config, not located by a path the studio
+ * must import through an alias (the `@site` trap). The implementation is opaque to
+ * studio-core (a host React component); the serializable projection derives the
+ * manifests. Validated opaquely, like the `routes`/`redirects` derive functions.
+ */
+export interface HostComponentEntry {
+    manifest: ComponentManifest;
+    implementation: unknown;
+}
+export declare const componentsInputSchema: z.ZodCustom<readonly HostComponentEntry[], readonly HostComponentEntry[]>;
+/** Which Convex deployment/dataset backs a project (or one of its environments). */
+export declare const workspaceConvexRefSchema: z.ZodObject<{
+    deployment: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkspaceConvexRef = z.infer<typeof workspaceConvexRefSchema>;
+/**
+ * A deployment environment in config. Extends the backend `{ key, label }` shape
+ * with an optional per-environment `convex` ref so a project can target a
+ * different deployment/dataset per environment (Sanity project↔dataset style,
+ * e.g. prod vs staging). The project-level `convex` ref is the default.
+ *
+ * `frontendUrl` (EC-215) is the public base URL of the live site for this
+ * environment (e.g. `https://staging.acme.com`); the project-level `frontendUrl`
+ * is the fallback. The studio uses it to show/link a document's live URL
+ * (EC-216) and the host's sitemap uses it as its `baseUrl`.
+ */
+export declare const workspaceEnvironmentSchema: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    convex: z.ZodOptional<z.ZodObject<{
+        deployment: z.ZodOptional<z.ZodString>;
+        dataset: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    frontendUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkspaceEnvironment = z.infer<typeof workspaceEnvironmentSchema>;
+/**
+ * A `routes` / `redirects` derive function: `(collections) => RouteRecord[]`,
+ * modelled on `next.config`'s `redirects()`/`rewrites()` (Oli, 2026-06-16). The
+ * resolver runs it once against the project's resolved collections (EC-207). May
+ * also be a static `RouteRecord[]` — the function is the general form.
+ */
+export type RoutesDerive = (collections: CollectionDef[]) => RouteRecord[];
+export type RedirectsDerive = (collections: CollectionDef[]) => RedirectRecord[];
+/** The shared, overridable fields — usable as `base` and per project. */
+export declare const workspaceProjectBaseSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"inline">, z.ZodObject<{
+        module: z.ZodString;
+    }, z.core.$strip>]>>;
+    locales: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultLocale: z.ZodOptional<z.ZodString>;
+    components: z.ZodOptional<z.ZodCustom<readonly HostComponentEntry[], readonly HostComponentEntry[]>>;
+    convex: z.ZodOptional<z.ZodObject<{
+        deployment: z.ZodOptional<z.ZodString>;
+        dataset: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    frontendUrl: z.ZodOptional<z.ZodString>;
+    environments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        convex: z.ZodOptional<z.ZodObject<{
+            deployment: z.ZodOptional<z.ZodString>;
+            dataset: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        frontendUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    collections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            asset: "asset";
+            document: "document";
+        }>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodType<import("@elytracms/core/cms-core").FieldDef, unknown, z.core.$ZodTypeInternals<import("@elytracms/core/cms-core").FieldDef, unknown>>>>;
+        form: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            labelSingular: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tabs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        localized: z.ZodOptional<z.ZodBoolean>;
+        titleField: z.ZodOptional<z.ZodString>;
+        singleton: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    routes: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        pattern: z.ZodString;
+        locale: z.ZodOptional<z.ZodString>;
+        document: z.ZodOptional<z.ZodObject<{
+            collection: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodCustom<RoutesDerive, RoutesDerive>]>>;
+    redirects: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        permanent: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>, z.ZodCustom<RedirectsDerive, RedirectsDerive>]>>;
+    exportTarget: z.ZodOptional<z.ZodEnum<{
+        "next-app-router": "next-app-router";
+    }>>;
+    sectionAvailability: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        components: "components";
+        assets: "assets";
+        cms: "cms";
+        extensions: "extensions";
+        settings: "settings";
+    }>, z.ZodEnum<{
+        available: "available";
+        planned: "planned";
+        unavailable: "unavailable";
+    }>>>;
+}, z.core.$strip>;
+export type WorkspaceProjectBase = z.infer<typeof workspaceProjectBaseSchema>;
+/** One project entry: identity is required, everything else may come from `base`. */
+export declare const workspaceProjectEntrySchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"inline">, z.ZodObject<{
+        module: z.ZodString;
+    }, z.core.$strip>]>>;
+    locales: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultLocale: z.ZodOptional<z.ZodString>;
+    components: z.ZodOptional<z.ZodCustom<readonly HostComponentEntry[], readonly HostComponentEntry[]>>;
+    convex: z.ZodOptional<z.ZodObject<{
+        deployment: z.ZodOptional<z.ZodString>;
+        dataset: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    frontendUrl: z.ZodOptional<z.ZodString>;
+    environments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        convex: z.ZodOptional<z.ZodObject<{
+            deployment: z.ZodOptional<z.ZodString>;
+            dataset: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        frontendUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    collections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            asset: "asset";
+            document: "document";
+        }>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodType<import("@elytracms/core/cms-core").FieldDef, unknown, z.core.$ZodTypeInternals<import("@elytracms/core/cms-core").FieldDef, unknown>>>>;
+        form: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            labelSingular: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tabs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        localized: z.ZodOptional<z.ZodBoolean>;
+        titleField: z.ZodOptional<z.ZodString>;
+        singleton: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    routes: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        pattern: z.ZodString;
+        locale: z.ZodOptional<z.ZodString>;
+        document: z.ZodOptional<z.ZodObject<{
+            collection: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodCustom<RoutesDerive, RoutesDerive>]>>;
+    redirects: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        permanent: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>, z.ZodCustom<RedirectsDerive, RedirectsDerive>]>>;
+    exportTarget: z.ZodOptional<z.ZodEnum<{
+        "next-app-router": "next-app-router";
+    }>>;
+    sectionAvailability: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        components: "components";
+        assets: "assets";
+        cms: "cms";
+        extensions: "extensions";
+        settings: "settings";
+    }>, z.ZodEnum<{
+        available: "available";
+        planned: "planned";
+        unavailable: "unavailable";
+    }>>>;
+    name: z.ZodString;
+    slug: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceProjectEntry = z.infer<typeof workspaceProjectEntrySchema>;
+/** The full `elytra.config.ts` value: shared base + an array of project configs. */
+export declare const elytraConfigInputSchema: z.ZodObject<{
+    base: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"inline">, z.ZodObject<{
+            module: z.ZodString;
+        }, z.core.$strip>]>>;
+        locales: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaultLocale: z.ZodOptional<z.ZodString>;
+        components: z.ZodOptional<z.ZodCustom<readonly HostComponentEntry[], readonly HostComponentEntry[]>>;
+        convex: z.ZodOptional<z.ZodObject<{
+            deployment: z.ZodOptional<z.ZodString>;
+            dataset: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        frontendUrl: z.ZodOptional<z.ZodString>;
+        environments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            convex: z.ZodOptional<z.ZodObject<{
+                deployment: z.ZodOptional<z.ZodString>;
+                dataset: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            frontendUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        collections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<{
+                asset: "asset";
+                document: "document";
+            }>>;
+            fields: z.ZodDefault<z.ZodArray<z.ZodType<import("@elytracms/core/cms-core").FieldDef, unknown, z.core.$ZodTypeInternals<import("@elytracms/core/cms-core").FieldDef, unknown>>>>;
+            form: z.ZodOptional<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                labelSingular: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tabs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            localized: z.ZodOptional<z.ZodBoolean>;
+            titleField: z.ZodOptional<z.ZodString>;
+            singleton: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        routes: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            pattern: z.ZodString;
+            locale: z.ZodOptional<z.ZodString>;
+            document: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, z.ZodCustom<RoutesDerive, RoutesDerive>]>>;
+        redirects: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            permanent: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>, z.ZodCustom<RedirectsDerive, RedirectsDerive>]>>;
+        exportTarget: z.ZodOptional<z.ZodEnum<{
+            "next-app-router": "next-app-router";
+        }>>;
+        sectionAvailability: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            components: "components";
+            assets: "assets";
+            cms: "cms";
+            extensions: "extensions";
+            settings: "settings";
+        }>, z.ZodEnum<{
+            available: "available";
+            planned: "planned";
+            unavailable: "unavailable";
+        }>>>;
+    }, z.core.$strip>>;
+    projects: z.ZodArray<z.ZodObject<{
+        schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"inline">, z.ZodObject<{
+            module: z.ZodString;
+        }, z.core.$strip>]>>;
+        locales: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        defaultLocale: z.ZodOptional<z.ZodString>;
+        components: z.ZodOptional<z.ZodCustom<readonly HostComponentEntry[], readonly HostComponentEntry[]>>;
+        convex: z.ZodOptional<z.ZodObject<{
+            deployment: z.ZodOptional<z.ZodString>;
+            dataset: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        frontendUrl: z.ZodOptional<z.ZodString>;
+        environments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            label: z.ZodString;
+            convex: z.ZodOptional<z.ZodObject<{
+                deployment: z.ZodOptional<z.ZodString>;
+                dataset: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            frontendUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        collections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<{
+                asset: "asset";
+                document: "document";
+            }>>;
+            fields: z.ZodDefault<z.ZodArray<z.ZodType<import("@elytracms/core/cms-core").FieldDef, unknown, z.core.$ZodTypeInternals<import("@elytracms/core/cms-core").FieldDef, unknown>>>>;
+            form: z.ZodOptional<z.ZodObject<{
+                label: z.ZodOptional<z.ZodString>;
+                labelSingular: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tabs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            localized: z.ZodOptional<z.ZodBoolean>;
+            titleField: z.ZodOptional<z.ZodString>;
+            singleton: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        routes: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            pattern: z.ZodString;
+            locale: z.ZodOptional<z.ZodString>;
+            document: z.ZodOptional<z.ZodObject<{
+                collection: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, z.ZodCustom<RoutesDerive, RoutesDerive>]>>;
+        redirects: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodString;
+            permanent: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>, z.ZodCustom<RedirectsDerive, RedirectsDerive>]>>;
+        exportTarget: z.ZodOptional<z.ZodEnum<{
+            "next-app-router": "next-app-router";
+        }>>;
+        sectionAvailability: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+            components: "components";
+            assets: "assets";
+            cms: "cms";
+            extensions: "extensions";
+            settings: "settings";
+        }>, z.ZodEnum<{
+            available: "available";
+            planned: "planned";
+            unavailable: "unavailable";
+        }>>>;
+        name: z.ZodString;
+        slug: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ElytraConfigInput = z.infer<typeof elytraConfigInputSchema>;
+/**
+ * Typed identity helper for `elytra.config.ts` — keeps the config file
+ * declarative (like Vite's `defineConfig`). Validation happens on load via
+ * {@link resolveWorkspaceConfig}, not here, so a config file never throws.
+ *
+ * @example
+ * ```ts
+ * // elytra.config.ts
+ * import { defineElytraConfig } from '@elytracms/core/export-sync'
+ *
+ * export default defineElytraConfig({
+ *   base: {
+ *     locales: ['en', 'de'],
+ *     defaultLocale: 'en',
+ *     components: { package: '@acme/site-components' },
+ *     schema: { module: './src/schema/collections' },
+ *   },
+ *   projects: [
+ *     { name: 'Acme Marketing', slug: 'acme-marketing' },
+ *     {
+ *       name: 'Acme Store',
+ *       slug: 'acme-store',
+ *       convex: { deployment: 'https://store.convex.cloud' },
+ *       locales: ['en'],
+ *       defaultLocale: 'en',
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+export declare function defineElytraConfig(config: ElytraConfigInput): ElytraConfigInput;
+/** Stable codes for workspace-config validation issues (EC-154). */
+export declare const workspaceConfigIssueCodeSchema: z.ZodEnum<{
+    "invalid-name": "invalid-name";
+    "invalid-slug": "invalid-slug";
+    "empty-locales": "empty-locales";
+    "duplicate-locale": "duplicate-locale";
+    "invalid-locale": "invalid-locale";
+    "default-locale-not-in-locales": "default-locale-not-in-locales";
+    "no-environments": "no-environments";
+    "duplicate-environment": "duplicate-environment";
+    "invalid-environment": "invalid-environment";
+    "invalid-config-shape": "invalid-config-shape";
+    "missing-default-export": "missing-default-export";
+    "empty-projects": "empty-projects";
+    "duplicate-project-slug": "duplicate-project-slug";
+    "missing-default-locale": "missing-default-locale";
+}>;
+export type WorkspaceConfigIssueCode = z.infer<typeof workspaceConfigIssueCodeSchema>;
+/**
+ * A structured, file-located workspace-config issue. `path` addresses the
+ * config object (e.g. `['projects', 1, 'defaultLocale']`); `file` is attached
+ * by the loader when the config came from a file.
+ */
+export interface WorkspaceConfigIssue {
+    code: WorkspaceConfigIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+    path: ReadonlyArray<string | number>;
+    /** Source file, when the config was loaded from one (e.g. `elytra.config.ts`). */
+    file?: string;
+}
+/** A project config after base + override composition and defaulting. */
+export interface ResolvedWorkspaceProject {
+    name: string;
+    slug: string;
+    schema: WorkspaceSchemaRef;
+    locales: string[];
+    defaultLocale: string;
+    components?: readonly HostComponentEntry[];
+    convex?: WorkspaceConvexRef;
+    /** Public base URL of the live site (EC-215); the project-level fallback an
+     *  environment's own `frontendUrl` overrides. `undefined` when unconfigured. */
+    frontendUrl?: string;
+    environments: WorkspaceEnvironment[];
+    /** CMS collections declared in config (AD-11, EC-183); `[]` when none. */
+    collections: CollectionDef[];
+    /** Routes materialized from config (EC-207); `[]` when none declared. */
+    routes: RouteRecord[];
+    /** Redirects materialized from config (EC-207); `[]` when none declared. */
+    redirects: RedirectRecord[];
+    /** Code-generation target (EC-179 item 5). */
+    exportTarget: ExportTarget;
+    /** Per-section availability (EC-179 item 5). */
+    sectionAvailability: SectionAvailabilityMap;
+}
+export interface WorkspaceConfigResult {
+    /** True when no error-severity issues are present. */
+    ok: boolean;
+    /** Resolved projects in config order. Empty when `ok` is false. */
+    projects: ResolvedWorkspaceProject[];
+    issues: WorkspaceConfigIssue[];
+}
+export interface ResolveWorkspaceConfigOptions {
+    /** Attached to every issue as its `file` (e.g. `elytra.config.ts`). */
+    file?: string;
+}
+/**
+ * Resolve a project's public site URL for a given environment (EC-215): the
+ * environment's own `frontendUrl` when it declares one, else the project-level
+ * fallback. `undefined` when neither is configured. The trailing slash (if any)
+ * is preserved as authored — callers that build paths should normalize.
+ */
+export declare function frontendUrlForEnvironment(project: ResolvedWorkspaceProject, environmentKey?: string): string | undefined;
+/**
+ * Build the studio's `Project` from a resolved config entry (vision AD-8). The
+ * slug is the canonical id; identity is config-owned, so there are no backend
+ * timestamps. This is how the studio sources project identity at runtime.
+ */
+export declare function configProject(project: ResolvedWorkspaceProject): Project;
+/** Map a resolved project onto the EC-028 settings shape (export target + sections defaulted). */
+export declare function toProjectSettings(project: ResolvedWorkspaceProject): ProjectSettings;
+/**
+ * **The RSC-boundary convention.** A code-first config is config-AS-CODE: it holds
+ * live code — component `implementation`s (host React components) and `routes`/
+ * `redirects` derive functions — none of it serializable. That live config is
+ * **server/build-only**. It may be *referenced* server-side (rendered to HTML in an
+ * RSC, or held in an in-process registry that the client bundle also imports as a
+ * normal ESM module) — a shared module import is not a wire boundary. But it must
+ * NEVER be passed across a true server→client serialization boundary:
+ *
+ *   - a React Server Component → Client Component (`'use client'`) props boundary
+ *     (the `@elytracms/next` delivery runtime),
+ *   - a TanStack Start SSR → client-hydration boundary (a router `loader`/`context`
+ *     that dehydrates, `useLoaderData`),
+ *   - any `JSON.stringify` channel (`unstable_cache` values, the
+ *     `VITE_ELYTRA_WORKSPACE` env channel, fixtures, codegen output).
+ *
+ * Only DERIVED DATA crosses: {@link toSerializableSchema} (this module) for the full
+ * structural schema, or {@link configProject} for the studio's data-only `Project`
+ * shape — both strip every implementation/function. Passing the live config (or a
+ * {@link ResolvedWorkspaceProject} still carrying `components`) across such a boundary
+ * would throw “Functions cannot be passed to Client Components” under RSC, or silently
+ * drop the implementations under SSR hydration. Audited 2026-06-20 (EC-223): every
+ * boundary in the studio, the delivery runtime, and codegen honours this — live
+ * implementations stay in-process; what crosses is always a data projection.
+ */
+/**
+ * One project's structure as a **serializable projection** — the data subset of a
+ * resolved config project with all CODE stripped out. Every field is
+ * JSON-serializable: no live React component, no derive function, nothing that
+ * cannot survive `JSON.stringify` or a server→client RSC props boundary.
+ *
+ * Mirrors {@link ResolvedWorkspaceProject} with exactly one substitution:
+ * `components` drops from the live `HostComponentEntry[]` ({@link HostComponentEntry})
+ * to the serializable `ComponentManifest[]` — the implementations are removed, the
+ * manifests kept (this is the derivation the `HostComponentEntry` doc names). The
+ * `routes`/`redirects` derive functions are already materialized to data by the
+ * resolver, and `collections` is the canonical cms-core `CollectionDef` data shape.
+ */
+export interface SerializableProject {
+    name: string;
+    slug: string;
+    schema: WorkspaceSchemaRef;
+    locales: string[];
+    defaultLocale: string;
+    /** Component MANIFESTS only — the live implementations are dropped (code). `[]` when none. */
+    components: ComponentManifest[];
+    convex?: WorkspaceConvexRef;
+    frontendUrl?: string;
+    environments: WorkspaceEnvironment[];
+    collections: CollectionDef[];
+    routes: RouteRecord[];
+    redirects: RedirectRecord[];
+    exportTarget: ExportTarget;
+    sectionAvailability: SectionAvailabilityMap;
+}
+/**
+ * The serializable schema for a whole workspace: the {@link WorkspaceConfigResult}
+ * shape with every project projected to its code-free {@link SerializableProject}.
+ * `ok`/`issues` pass through unchanged so portable validation keeps the structured
+ * boot-error story; `projects` is empty when `ok` is false (resolution failed).
+ */
+export interface SerializableSchema {
+    ok: boolean;
+    projects: SerializableProject[];
+    issues: WorkspaceConfigIssue[];
+}
+/**
+ * Project one resolved config project to its serializable form (EC-223 mount
+ * contract). The single code→data step is `components`: each live
+ * `{ manifest, implementation }` collapses to its `manifest`, dropping the opaque
+ * host React component. Arrays are copied so the projection is an owned snapshot;
+ * deterministic — the same resolved project always yields the same value.
+ */
+export declare function toSerializableProject(project: ResolvedWorkspaceProject): SerializableProject;
+/**
+ * **`toSerializableSchema(config)`** — the EC-223 serializable-schema projection.
+ * Resolve a code-first config (running base+override composition and the
+ * `routes`/`redirects` derives), then strip code from every project. The result
+ * is a pure-data snapshot of the workspace's structure — the portable-validation
+ * artifact, the AI/CLI codegen target (EC-209), the fixtures source, and the only
+ * thing that may cross a server→client RSC boundary (never the live config).
+ *
+ * Never throws: an invalid config returns `{ ok: false, projects: [], issues }`,
+ * exactly as {@link resolveWorkspaceConfig} reports it. Deterministic.
+ */
+export declare function toSerializableSchema(config: ElytraConfigInput, options?: ResolveWorkspaceConfigOptions): SerializableSchema;
+/**
+ * Validate + resolve a raw config value (the default export of
+ * `elytra.config.ts`, or env-injected JSON). Never throws: every failure mode
+ * is a structured, path-located {@link WorkspaceConfigIssue}. Deterministic —
+ * the same input always yields byte-identical results.
+ */
+export declare function resolveWorkspaceConfig(value: unknown, options?: ResolveWorkspaceConfigOptions): WorkspaceConfigResult;
+/** Conventional config file name (the CLI also accepts compiled variants). */
+export declare const WORKSPACE_CONFIG_FILE = "elytra.config.ts";
+/** File names the loaders probe for, in priority order. */
+export declare const WORKSPACE_CONFIG_FILES: readonly ["elytra.config.ts", "elytra.config.mts", "elytra.config.js", "elytra.config.mjs"];
+/**
+ * Pull the config value out of a loaded module namespace. The convention is a
+ * default export (`export default defineElytraConfig({...})`); a missing one
+ * is a structured issue, not a throw.
+ */
+export declare function extractWorkspaceConfigExport(moduleExports: unknown, file?: string): {
+    value: unknown;
+} | {
+    issue: WorkspaceConfigIssue;
+};