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

package/dist/providers/file.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 export class FileContentProvider {
     root;
@@ -46,12 +46,72 @@ 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,6 +17,7 @@ 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, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 // ---------------------------------------------------------------------------
 // S3 content provider — reads compiled content files from S3
@@ -45,6 +45,19 @@ 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/registry.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentContract, InferComponentProps } from './types/component.js';
+export type AnyComponent = (abstract new (...args: any[]) => any) | ((props: any) => any) | Record<string, any>;
+export interface RegistryEntry {
+    name: string;
+    component: AnyComponent;
+    contract: ComponentContract;
+}
+export type Registry = readonly RegistryEntry[];
+type ValidatedEntry<T> = T extends readonly [infer C extends ComponentContract, infer Comp] ? Comp extends (props: InferComponentProps<C>) => any ? T : Comp extends (props: InferComponentProps<C> & infer _) => any ? T : Comp extends new (props: InferComponentProps<C>, ...args: any[]) => any ? T : Comp extends Record<string, any> ? T : never : never;
+type ValidatedEntries<T extends readonly (readonly [ComponentContract, AnyComponent])[]> = {
+    [K in keyof T]: ValidatedEntry<T[K]>;
+};
+export declare function createRegistry<const T extends readonly (readonly [ComponentContract, AnyComponent])[]>(entries: ValidatedEntries<T> & T): Registry;
+export declare function registryLookup(registry: Registry, name: string): AnyComponent | undefined;
+export {};

package/dist/registry.js

@@ -0,0 +1,10 @@
+export function createRegistry(entries) {
+    return entries.map(([contract, component]) => ({
+        name: contract.name,
+        component,
+        contract,
+    }));
+}
+export function registryLookup(registry, name) {
+    return registry.find((r) => r.name === name)?.component;
+}

package/dist/sveltekit/index.d.ts

@@ -19,5 +19,7 @@ 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,6 +32,10 @@ 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,15 +4,18 @@ 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,13 +1,15 @@
-import { PageNotFoundError, FragmentNotFoundError, loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
+import { PageNotFoundError, FragmentNotFoundError, LayoutNotFoundError, 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));
@@ -17,6 +19,11 @@ 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);
@@ -35,6 +42,13 @@ 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))
@@ -84,7 +98,6 @@ 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,11 +1,6 @@
 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,8 +21,6 @@ export interface ComponentDefinition<TSchema = unknown> {
      */
     component?: CmsComponentFn<any>;
     schema: TSchema;
-    renderModes?: ComponentRenderModes;
-    render?: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];
@@ -37,8 +30,6 @@ 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,7 +11,6 @@ export interface BareMetalConfig {
     componentRegistry: string;
     dataRegistry?: string;
     layoutRegistry: string;
-    rendererEntry: string;
     capabilities: RenderCapabilities;
     routes: RouteConfig;
     dam?: DAMConfig;

package/dist/types/page.d.ts

@@ -1,11 +1,10 @@
-import type { RenderMode, VaryDimension } from './render-mode.js';
+import type { 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,3 +1,2 @@
-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.2",
+  "version": "0.1.20-preview.3",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -43,10 +43,6 @@
       "types": "./dist/content/validation.d.ts",
       "import": "./dist/content/validation.js"
     },
-    "./content/cache": {
-      "types": "./dist/content/cache.d.ts",
-      "import": "./dist/content/cache.js"
-    },
     "./content/tailwind-validator": {
       "types": "./dist/content/tailwind-validator.d.ts",
       "import": "./dist/content/tailwind-validator.js"
@@ -94,6 +90,16 @@
       "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",
@@ -127,19 +133,16 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "build:cli": "cd ../.. && ./scripts/build-cli.sh",
-    "compile-registry": "tsx src/cli/compile-registry.mjs",
-    "prepack": "npm run build"
-  },
-  "overrides": {
-    "postcss": "^8.5.10"
+    "compile-registry": "tsx src/cli/compile-registry.mjs"
   },
   "dependencies": {
     "ws": "^8.18.0"
   },
   "peerDependencies": {
     "@vercel/edge-config": "^1.4.3",
-    "next": "^15.5.0",
-    "react": "^19.0.0",
+    "next": "^15.0.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0",
     "zod": "^4.0.0"
   },
   "peerDependenciesMeta": {
@@ -151,6 +154,9 @@
     },
     "react": {
       "optional": true
+    },
+    "react-dom": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -165,4 +171,4 @@
     "ws": "^8.18.0",
     "zod": "^4.0.0"
   }
-}
+}

package/src/cli/compile-registry.mjs

@@ -52,22 +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);
+    const renderModes = component.renderModes ?? component.render;
     componentEntries.push({
       name: component.name,
       schemaFile,
-      render: {
+      render: renderModes ? {
         static: Boolean(renderModes.canStatic ?? renderModes.static),
         ssr: Boolean(renderModes.canSSR ?? renderModes.ssr),
         clientIsland: Boolean(renderModes.canClientIsland ?? renderModes.clientIsland),
-      },
-      renderModes: {
+      } : { static: true, ssr: true, clientIsland: false },
+      renderModes: renderModes ? {
         canStatic: Boolean(renderModes.canStatic ?? renderModes.static),
         canSSR: Boolean(renderModes.canSSR ?? renderModes.ssr),
         canClientIsland: Boolean(renderModes.canClientIsland ?? renderModes.clientIsland),
-      },
+      } : { canStatic: true, canSSR: true, canClientIsland: false },
       ...(component.defaultIslandMode ? { defaultIslandMode: component.defaultIslandMode } : {}),
       ...(varyDimensions?.length ? { vary: varyDimensions, varyDimensions } : {}),
       ...(Object.keys(imageSlots).length ? { imageSlots } : {}),
@@ -117,6 +117,10 @@ 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 };
 }
 
@@ -150,12 +154,6 @@ 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) {
@@ -349,7 +347,11 @@ function validateLayout(layout, index, seen) {
     seenSlots.add(slot.name);
     slots.push({ name: slot.name, required: Boolean(slot.required) });
   }
-  return { name: layout.name, slots };
+  const entry = { name: layout.name, slots };
+  if (layout.defaults && typeof layout.defaults === 'object') {
+    entry.defaults = layout.defaults;
+  }
+  return entry;
 }
 
 function compileSchema(schema, name) {
@@ -368,6 +370,124 @@ 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/types/component.ts

@@ -2,12 +2,6 @@ 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.
@@ -32,8 +26,6 @@ export interface ComponentDefinition<TSchema = unknown> {
    */
   component?: CmsComponentFn<any>;
   schema: TSchema;
-  renderModes?: ComponentRenderModes;
-  render?: ComponentRenderModes;
   defaultIslandMode?: IslandMode;
   varyDimensions?: VaryDimension[];
   vary?: VaryDimension[];
@@ -44,8 +36,6 @@ 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,7 +12,6 @@ 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 { RenderMode, VaryDimension } from './render-mode.js';
+import type { VaryDimension } from './render-mode.js';
 
 export interface PageDocument {
   path: string;
@@ -6,7 +6,6 @@ export interface PageDocument {
   locale: string;
   metadata: PageMetadata;
   regions: Record<string, RegionNode>;
-  renderMode: RenderMode;
 }
 
 export interface PageMetadata {

package/src/types/render-mode.ts

@@ -1,11 +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 =

package/dist/content/cache.test.d.ts

@@ -1 +0,0 @@
-export {};