@gradial/aci 0.1.20-preview.1 → 0.1.20-preview.2

package/dist/next/server.js

@@ -1,12 +1,12 @@
 import { headers } from 'next/headers.js';
-import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '../content/provider.js';
+import { FragmentNotFoundError, PageNotFoundError, } from '../content/provider.js';
 import { getCachedManifest, getCachedSiteConfig } from '../content/cache.js';
 import { S3ContentProvider } from '../providers/s3.js';
 import { GRADIAL_RENDER_INPUT_HEADER, getPendingRenderInput } from '../runtime/page.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
 const RELEASE_HEADER = 'x-gradial-release-id';
 const PREVIEW_HEADER = 'x-gradial-preview';
-export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
+export { FragmentNotFoundError, PageNotFoundError };
 export async function getPage(route = '', config = {}) {
     const runtimeInput = await getPageRuntimeRenderInput();
     if (runtimeInput)
@@ -31,16 +31,6 @@ export async function getFragment(name, config = {}) {
     const provider = await resolveProviderWithFallback(config);
     return await provider.getFragment(name);
 }
-export async function getLayout(name, config = {}) {
-    const runtimeInput = await getPageRuntimeRenderInput();
-    if (runtimeInput) {
-        const layouts = runtimeInput.layouts || {};
-        if (name in layouts)
-            return layouts[name];
-    }
-    const provider = await resolveProviderWithFallback(config);
-    return await provider.getLayout(name);
-}
 export async function getRoutes(config = {}) {
     const provider = await resolveProviderWithFallback(config);
     const routes = await provider.listRoutes();

package/dist/providers/file.d.ts

@@ -7,8 +7,6 @@ export declare class FileContentProvider implements ContentProvider {
     getSiteConfig<T = unknown>(): Promise<T>;
     getPage<T = unknown>(route: string): Promise<T>;
     getFragment<T = unknown>(id: string): Promise<T>;
-    getLayout<T = unknown>(name: string): Promise<T>;
     manifest(): Promise<CompiledManifest>;
-    fetchRaw(key: string): Promise<Response>;
     private readJSON;
 }

package/dist/providers/file.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 export class FileContentProvider {
     root;
@@ -46,72 +46,12 @@ export class FileContentProvider {
             throw new FragmentNotFoundError(id, error);
         }
     }
-    async getLayout(name) {
-        const manifest = await this.manifest();
-        const layouts = manifest.layouts;
-        if (!layouts || !layouts[name]) {
-            throw new LayoutNotFoundError(name);
-        }
-        try {
-            return await this.readJSON(`layouts/${name}.json`);
-        }
-        catch (error) {
-            throw new LayoutNotFoundError(name, error);
-        }
-    }
     async manifest() {
         this.#manifest ??= this.readJSON('manifest.json');
         return await this.#manifest;
     }
-    async fetchRaw(key) {
-        const relativeKey = key.replace(/^\/+/, '');
-        const filePath = path.resolve(this.root, relativeKey);
-        const rel = path.relative(this.root, filePath);
-        if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) {
-            return new Response('not found', { status: 404 });
-        }
-        let body;
-        try {
-            body = await fs.readFile(filePath);
-        }
-        catch {
-            return new Response('not found', { status: 404 });
-        }
-        return new Response(new Uint8Array(body), {
-            status: 200,
-            headers: {
-                'content-type': contentType(filePath),
-                'cache-control': 'public, max-age=31536000, immutable',
-            },
-        });
-    }
     async readJSON(key) {
         const raw = await fs.readFile(path.join(this.root, key), 'utf8');
         return JSON.parse(raw);
     }
 }
-function contentType(filePath) {
-    switch (path.extname(filePath).toLowerCase()) {
-        case '.webp':
-            return 'image/webp';
-        case '.svg':
-            return 'image/svg+xml';
-        case '.jpg':
-        case '.jpeg':
-            return 'image/jpeg';
-        case '.png':
-            return 'image/png';
-        case '.avif':
-            return 'image/avif';
-        case '.gif':
-            return 'image/gif';
-        case '.css':
-            return 'text/css';
-        case '.js':
-            return 'application/javascript';
-        case '.json':
-            return 'application/json';
-        default:
-            return 'application/octet-stream';
-    }
-}

package/dist/providers/s3.d.ts

@@ -17,7 +17,6 @@ export declare class S3ContentProvider implements ContentProvider {
     getSiteConfig<T = unknown>(): Promise<T>;
     getPage<T = unknown>(route: string): Promise<T>;
     getFragment<T = unknown>(id: string): Promise<T>;
-    getLayout<T = unknown>(name: string): Promise<T>;
     manifest(): Promise<CompiledManifest>;
     fetchRaw(key: string): Promise<Response>;
     private getJSON;

package/dist/providers/s3.js

@@ -1,5 +1,5 @@
 import crypto from 'node:crypto';
-import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 // ---------------------------------------------------------------------------
 // S3 content provider — reads compiled content files from S3
@@ -45,19 +45,6 @@ export class S3ContentProvider {
             throw new FragmentNotFoundError(id, error);
         }
     }
-    async getLayout(name) {
-        const manifest = await this.manifest();
-        const layouts = manifest.layouts;
-        if (!layouts || !layouts[name]) {
-            throw new LayoutNotFoundError(name);
-        }
-        try {
-            return await this.getJSON(`layouts/${name}.json`);
-        }
-        catch (error) {
-            throw new LayoutNotFoundError(name, error);
-        }
-    }
     async manifest() {
         this.#manifest ??= this.getJSON('manifest.json');
         return await this.#manifest;

package/dist/sveltekit/index.d.ts

@@ -19,7 +19,5 @@ export declare function gradialEntries(): Promise<string[]>;
 export declare function getPageRuntimeRenderInput(event: {
     request: Request;
 }): RenderInput | null;
-export { createRegistry, registryLookup } from '../registry.js';
-export type { Registry, RegistryEntry, AnyComponent } from '../registry.js';
 export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, type PreviewContext, type PreviewCookie, } from './preview.js';
 export declare function withGradialAci(options?: GradialContentWatchOptions): VitePluginLike;

package/dist/sveltekit/index.js

@@ -32,10 +32,6 @@ export function getPageRuntimeRenderInput(event) {
     return getPendingRenderInputFromHeaders(event.request.headers);
 }
 // ---------------------------------------------------------------------------
-// Registry helpers
-// ---------------------------------------------------------------------------
-export { createRegistry, registryLookup } from '../registry.js';
-// ---------------------------------------------------------------------------
 // Preview support
 // ---------------------------------------------------------------------------
 export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, } from './preview.js';

package/dist/testing/index.d.ts

@@ -4,18 +4,15 @@ export interface FixtureContentProviderOptions {
     siteConfig?: KernelSiteConfig;
     pages?: Record<string, KernelPage>;
     fragments?: Record<string, unknown>;
-    layouts?: Record<string, unknown>;
 }
 export declare class FixtureContentProvider implements ContentProvider {
     private siteConfig;
     private pages;
     private fragments;
-    private layouts;
     constructor(options?: FixtureContentProviderOptions);
     getSiteConfig<T = unknown>(): Promise<T>;
     getPage<T = unknown>(route: string): Promise<T>;
     getFragment<T = unknown>(id: string): Promise<T>;
-    getLayout<T = unknown>(name: string): Promise<T>;
     listRoutes(): Promise<RouteEntry[]>;
     loadRenderInput(route?: string, options?: RenderInputOptions): Promise<RenderInput>;
     resolveRouteMetadata(route?: string): Promise<KernelRouteMetadata>;

package/dist/testing/index.js

@@ -1,15 +1,13 @@
-import { PageNotFoundError, FragmentNotFoundError, LayoutNotFoundError, loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
+import { PageNotFoundError, FragmentNotFoundError, loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 export class FixtureContentProvider {
     siteConfig;
     pages;
     fragments;
-    layouts;
     constructor(options = {}) {
         this.siteConfig = cloneFixture(options.siteConfig ?? defaultFixtureSiteConfig());
         this.pages = new Map();
         this.fragments = new Map();
-        this.layouts = new Map();
         const inputPages = options.pages ?? { '/': defaultFixturePage() };
         for (const [route, page] of Object.entries(inputPages)) {
             this.pages.set(normalizeRoute(route), cloneFixture(page));
@@ -19,11 +17,6 @@ export class FixtureContentProvider {
                 this.fragments.set(id, cloneFixture(fragment));
             }
         }
-        if (options.layouts) {
-            for (const [name, layout] of Object.entries(options.layouts)) {
-                this.layouts.set(name, cloneFixture(layout));
-            }
-        }
     }
     async getSiteConfig() {
         return cloneFixture(this.siteConfig);
@@ -42,13 +35,6 @@ export class FixtureContentProvider {
         }
         return cloneFixture(fragment);
     }
-    async getLayout(name) {
-        const layout = this.layouts.get(name);
-        if (layout === undefined) {
-            throw new LayoutNotFoundError(name);
-        }
-        return cloneFixture(layout);
-    }
     async listRoutes() {
         return [...this.pages.entries()]
             .sort(([a], [b]) => a.localeCompare(b))
@@ -98,6 +84,7 @@ export function defaultFixturePage() {
         $type: 'page',
         status: 'published',
         layout: 'marketing',
+        renderMode: 'static',
         metadata: {
             title: 'Fixture Home',
             description: 'Fixture home page.',

package/dist/types/component.d.ts

@@ -1,6 +1,11 @@
 import type { IslandMode, VaryDimension } from './render-mode.js';
 import type { ImageSlotContract } from './image.js';
 import type { z } from 'zod';
+export interface ComponentRenderModes {
+    canStatic: boolean;
+    canSSR: boolean;
+    canClientIsland: boolean;
+}
 /**
  * A CMS-registered component — sync or async (server components).
  * Accepts content props derived from the Zod schema.
@@ -21,6 +26,8 @@ export interface ComponentDefinition<TSchema = unknown> {
      */
     component?: CmsComponentFn<any>;
     schema: TSchema;
+    renderModes?: ComponentRenderModes;
+    render?: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];
@@ -30,6 +37,8 @@ export interface ComponentContract<TSchema = unknown> {
     name: string;
     component?: CmsComponentFn<any>;
     schema: TSchema;
+    renderModes: ComponentRenderModes;
+    render: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];

package/dist/types/config.d.ts

@@ -11,6 +11,7 @@ export interface BareMetalConfig {
     componentRegistry: string;
     dataRegistry?: string;
     layoutRegistry: string;
+    rendererEntry: string;
     capabilities: RenderCapabilities;
     routes: RouteConfig;
     dam?: DAMConfig;

package/dist/types/page.d.ts

@@ -1,10 +1,11 @@
-import type { VaryDimension } from './render-mode.js';
+import type { RenderMode, VaryDimension } from './render-mode.js';
 export interface PageDocument {
     path: string;
     layout: string;
     locale: string;
     metadata: PageMetadata;
     regions: Record<string, RegionNode>;
+    renderMode: RenderMode;
 }
 export interface PageMetadata {
     title: string;

package/dist/types/render-mode.d.ts

@@ -1,2 +1,3 @@
+export type RenderMode = 'static' | 'static-with-fragments' | 'prerender-on-demand' | 'ssr-page' | 'ssr-island' | 'client-island';
 export type IslandMode = 'ssr' | 'client';
 export type VaryDimension = 'geo:country' | 'geo:region' | 'geo:city' | `cookie:${string}` | `header:${string}` | 'locale' | `query:${string}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradial/aci",
-  "version": "0.1.20-preview.1",
+  "version": "0.1.20-preview.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -94,16 +94,6 @@
       "import": "./dist/next/page.js",
       "default": "./dist/next/page.js"
     },
-    "./next/root-layout": {
-      "types": "./dist/next/root-layout.d.ts",
-      "import": "./dist/next/root-layout.js",
-      "default": "./dist/next/root-layout.js"
-    },
-    "./next/render": {
-      "types": "./dist/next/render.d.ts",
-      "import": "./dist/next/render.js",
-      "default": "./dist/next/render.js"
-    },
     "./next/server": {
       "types": "./dist/next/server.d.ts",
       "import": "./dist/next/server.js",
@@ -138,16 +128,18 @@
     "build": "tsc -p tsconfig.json",
     "build:cli": "cd ../.. && ./scripts/build-cli.sh",
     "compile-registry": "tsx src/cli/compile-registry.mjs",
-    "prepack": "pnpm run build && pnpm run build:cli"
+    "prepack": "npm run build"
+  },
+  "overrides": {
+    "postcss": "^8.5.10"
   },
   "dependencies": {
     "ws": "^8.18.0"
   },
   "peerDependencies": {
     "@vercel/edge-config": "^1.4.3",
-    "next": "^15.0.0",
-    "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0",
+    "next": "^15.5.0",
+    "react": "^19.0.0",
     "zod": "^4.0.0"
   },
   "peerDependenciesMeta": {
@@ -159,9 +151,6 @@
     },
     "react": {
       "optional": true
-    },
-    "react-dom": {
-      "optional": true
     }
   },
   "devDependencies": {

package/src/cli/compile-registry.mjs

@@ -52,11 +52,22 @@ async function compileRegistry(options) {
     const schemaPath = path.join(outDir, schemaFile);
     await writeFile(schemaPath, JSON.stringify(schema, null, 2) + '\n');
     schemaFiles.push(schemaPath);
+    const renderModes = component.renderModes ?? component.render;
     const varyDimensions = component.varyDimensions ?? component.vary;
     const imageSlots = normalizeImageSlots(component.imageSlots);
     componentEntries.push({
       name: component.name,
       schemaFile,
+      render: {
+        static: Boolean(renderModes.canStatic ?? renderModes.static),
+        ssr: Boolean(renderModes.canSSR ?? renderModes.ssr),
+        clientIsland: Boolean(renderModes.canClientIsland ?? renderModes.clientIsland),
+      },
+      renderModes: {
+        canStatic: Boolean(renderModes.canStatic ?? renderModes.static),
+        canSSR: Boolean(renderModes.canSSR ?? renderModes.ssr),
+        canClientIsland: Boolean(renderModes.canClientIsland ?? renderModes.clientIsland),
+      },
       ...(component.defaultIslandMode ? { defaultIslandMode: component.defaultIslandMode } : {}),
       ...(varyDimensions?.length ? { vary: varyDimensions, varyDimensions } : {}),
       ...(Object.keys(imageSlots).length ? { imageSlots } : {}),
@@ -106,10 +117,6 @@ async function compileRegistry(options) {
   };
   const registryPath = path.join(outDir, 'registry.json');
   await writeFile(registryPath, JSON.stringify(registry, null, 2) + '\n');
-
-  const pageSchemaPath = await generatePageSchema(schemaDir, componentEntries, outDir);
-  schemaFiles.push(pageSchemaPath);
-
   return { registry: registryPath, schemas: schemaFiles };
 }
 
@@ -143,6 +150,12 @@ function validateComponent(component, index, seen) {
   if (!component.schema) throw new Error(`components[${index}].schema is required`);
   validateZodSubset(component.schema, `components[${index}].schema`);
   validateImageSlotSchemaMatch(component, index);
+  const renderModes = component.renderModes ?? component.render;
+  if (!renderModes) throw new Error(`components[${index}].renderModes is required`);
+  const enabled = Boolean(renderModes.canStatic ?? renderModes.static)
+    || Boolean(renderModes.canSSR ?? renderModes.ssr)
+    || Boolean(renderModes.canClientIsland ?? renderModes.clientIsland);
+  if (!enabled) throw new Error(`components[${index}].renderModes must enable at least one mode`);
 }
 
 function validateImageSlotSchemaMatch(component, index) {
@@ -336,11 +349,7 @@ function validateLayout(layout, index, seen) {
     seenSlots.add(slot.name);
     slots.push({ name: slot.name, required: Boolean(slot.required) });
   }
-  const entry = { name: layout.name, slots };
-  if (layout.defaults && typeof layout.defaults === 'object') {
-    entry.defaults = layout.defaults;
-  }
-  return entry;
+  return { name: layout.name, slots };
 }
 
 function compileSchema(schema, name) {
@@ -359,124 +368,6 @@ function compileSchema(schema, name) {
   };
 }
 
-async function generatePageSchema(schemaDir, componentEntries, outDir) {
-  const { readFile } = await import('node:fs/promises');
-  const defs = {
-    baseBlock: {
-      type: 'object',
-      required: ['id', 'component', 'props'],
-      additionalProperties: true,
-      properties: {
-        id: { type: 'string', minLength: 1 },
-        component: { type: 'string' },
-        props: { type: 'object' },
-      },
-    },
-    damAssetRef: {
-      type: 'object',
-      required: ['$type', 'assetId'],
-      additionalProperties: true,
-      properties: {
-        $type: { const: 'dam.assetRef' },
-        assetId: { type: 'string', minLength: 1 },
-        version: { type: 'string', minLength: 1 },
-        alt: { type: 'string' },
-      },
-    },
-  };
-  const oneOf = [];
-  for (const entry of componentEntries) {
-    const schemaPath = path.join(outDir, entry.schemaFile);
-    const raw = await readFile(schemaPath, 'utf-8');
-    const componentSchema = JSON.parse(raw);
-    const { $schema: _s, title: _t, ...propsSchema } = componentSchema;
-    replaceGradialImagesWithDamAssetRef(propsSchema, defs.damAssetRef);
-    const defName = `${entry.name}Block`;
-    defs[defName] = {
-      allOf: [
-        { $ref: '#/$defs/baseBlock' },
-        {
-          properties: {
-            component: { const: entry.name },
-            props: propsSchema,
-          },
-        },
-      ],
-    };
-    oneOf.push({ $ref: `#/$defs/${defName}` });
-  }
-  const pageSchema = {
-    $schema: 'https://json-schema.org/draft/2020-12/schema',
-    $id: 'https://baremetal.local/schemas/page.schema.json',
-    title: 'bare-metal Page',
-    type: 'object',
-    required: ['$type', 'id', 'status', 'layout', 'metadata', 'regions'],
-    additionalProperties: true,
-    properties: {
-      $type: { const: 'page' },
-      id: { type: 'string', minLength: 1 },
-      status: { type: 'string', minLength: 1 },
-      layout: { type: 'string', minLength: 1 },
-      metadata: {
-        type: 'object',
-        required: ['title'],
-        additionalProperties: true,
-        properties: {
-          title: { type: 'string', minLength: 1 },
-          description: { type: 'string' },
-          canonical: { type: 'string' },
-        },
-      },
-      regions: {
-        type: 'object',
-        additionalProperties: {
-          type: 'array',
-          items: { oneOf },
-        },
-      },
-    },
-    $defs: defs,
-  };
-  const pageSchemaPath = path.join(schemaDir, 'page.schema.json');
-  await writeFile(pageSchemaPath, JSON.stringify(pageSchema, null, 2) + '\n');
-  return pageSchemaPath;
-}
-
-function replaceGradialImagesWithDamAssetRef(schema, damAssetRef) {
-  if (!schema || typeof schema !== 'object') return schema;
-  if (schema.$ref) return;
-  if (Array.isArray(schema.anyOf)) {
-    for (const s of schema.anyOf) replaceGradialImagesWithDamAssetRef(s, damAssetRef);
-  }
-  if (Array.isArray(schema.allOf)) {
-    for (const s of schema.allOf) replaceGradialImagesWithDamAssetRef(s, damAssetRef);
-  }
-  if (Array.isArray(schema.oneOf)) {
-    for (const s of schema.oneOf) replaceGradialImagesWithDamAssetRef(s, damAssetRef);
-  }
-  if (schema.properties) {
-    for (const [key, value] of Object.entries(schema.properties)) {
-      if (isJsonGradialImage(value)) {
-        schema.properties[key] = { $ref: '#/$defs/damAssetRef' };
-      } else {
-        replaceGradialImagesWithDamAssetRef(value, damAssetRef);
-      }
-    }
-  }
-  if (schema.items) {
-    if (isJsonGradialImage(schema.items)) {
-      schema.items = { $ref: '#/$defs/damAssetRef' };
-    } else {
-      replaceGradialImagesWithDamAssetRef(schema.items, damAssetRef);
-    }
-  }
-}
-
-function isJsonGradialImage(node) {
-  return node?.type === 'object'
-    && node?.properties?.$type?.const === 'gradial.image';
-}
-
 function validateZodSubset(schema, pathLabel, seen = new Set()) {
   if (seen.has(schema)) return;
   seen.add(schema);

package/src/cli/verify-renderer.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const args = parseArgs(process.argv.slice(2));
+
+try {
+  if (!args.renderer) throw new Error('missing --renderer');
+  await verifyRenderer(path.resolve(args.renderer));
+  console.log(JSON.stringify({ success: true, errors: [] }, null, 2));
+} catch (error) {
+  console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
+  process.exitCode = 1;
+}
+
+async function verifyRenderer(rendererPath) {
+  try {
+    const mod = await import(pathToFileURL(rendererPath).href);
+    const renderer = mod.default ?? mod.renderer;
+    if (!renderer || typeof renderer.renderPage !== 'function') {
+      throw new Error('renderer must export a GradialRenderer with renderPage');
+    }
+    return;
+  } catch (error) {
+    if (!shouldUseStaticFallback(error)) {
+      throw error;
+    }
+  }
+
+  const source = fs.readFileSync(rendererPath, 'utf8');
+  if (!staticallyExportsRenderPage(source)) {
+    throw new Error('renderer must export a GradialRenderer with renderPage');
+  }
+}
+
+function shouldUseStaticFallback(error) {
+  const message = String(error?.message ?? error);
+  return message.includes('Unknown file extension ".astro"');
+}
+
+function staticallyExportsRenderPage(source) {
+  if (!/\brenderPage\s*[:=]\s*(async\s*)?(\([^)]*\)|[A-Za-z_$][\w$]*)?\s*=>|\brenderPage\s*[:=]\s*(async\s*)?function\b|\basync\s+renderPage\s*\(|\brenderPage\s*\(/m.test(source)) {
+    return false;
+  }
+  if (/export\s+default\s+{[\s\S]*\brenderPage\b[\s\S]*}/m.test(source)) {
+    return true;
+  }
+  const defaultName = source.match(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/m)?.[1];
+  const namedExport = source.match(/export\s*{\s*([A-Za-z_$][\w$]*)\s+as\s+renderer\s*}/m)?.[1] ?? source.match(/export\s*{\s*([A-Za-z_$][\w$]*)\s*}/m)?.[1];
+  const rendererName = defaultName ?? namedExport;
+  if (!rendererName) {
+    return false;
+  }
+  const declaration = new RegExp(`(?:const|let|var)\\s+${rendererName}\\b[\\s\\S]*?\\{[\\s\\S]*?\\brenderPage\\b`, 'm');
+  return declaration.test(source);
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+    const body = arg.slice(2);
+    const equals = body.indexOf('=');
+    if (equals >= 0) {
+      out[body.slice(0, equals)] = body.slice(equals + 1);
+      continue;
+    }
+    out[body] = argv[++i];
+  }
+  return out;
+}

package/src/types/component.ts

@@ -2,6 +2,12 @@ import type { IslandMode, VaryDimension } from './render-mode.js';
 import type { ImageSlotContract } from './image.js';
 import type { z } from 'zod';
 
+export interface ComponentRenderModes {
+  canStatic: boolean;
+  canSSR: boolean;
+  canClientIsland: boolean;
+}
+
 /**
  * A CMS-registered component — sync or async (server components).
  * Accepts content props derived from the Zod schema.
@@ -26,6 +32,8 @@ export interface ComponentDefinition<TSchema = unknown> {
    */
   component?: CmsComponentFn<any>;
   schema: TSchema;
+  renderModes?: ComponentRenderModes;
+  render?: ComponentRenderModes;
   defaultIslandMode?: IslandMode;
   varyDimensions?: VaryDimension[];
   vary?: VaryDimension[];
@@ -36,6 +44,8 @@ export interface ComponentContract<TSchema = unknown> {
   name: string;
   component?: CmsComponentFn<any>;
   schema: TSchema;
+  renderModes: ComponentRenderModes;
+  render: ComponentRenderModes;
   defaultIslandMode?: IslandMode;
   varyDimensions?: VaryDimension[];
   vary?: VaryDimension[];

package/src/types/config.ts

@@ -12,6 +12,7 @@ export interface BareMetalConfig {
   componentRegistry: string;
   dataRegistry?: string;
   layoutRegistry: string;
+  rendererEntry: string;
   capabilities: RenderCapabilities;
   routes: RouteConfig;
   dam?: DAMConfig;

package/src/types/page.ts

@@ -1,4 +1,4 @@
-import type { VaryDimension } from './render-mode.js';
+import type { RenderMode, VaryDimension } from './render-mode.js';
 
 export interface PageDocument {
   path: string;
@@ -6,6 +6,7 @@ export interface PageDocument {
   locale: string;
   metadata: PageMetadata;
   regions: Record<string, RegionNode>;
+  renderMode: RenderMode;
 }
 
 export interface PageMetadata {