@gradial/aci 0.1.20-preview.2 → 0.1.20

package/README.md

@@ -1,149 +1,87 @@
 # Agentic Content Infrastructure SDK
 
-Agentic Content Infrastructure (ACI) sites implement the frontend contract by
-installing `@gradial/aci`, Zod 4, and TypeScript tooling. The
-SDK exposes component and layout helpers, renderer types, compiler tooling,
-content provider helpers, and framework-specific subpaths from one package.
+`@gradial/aci` `0.1.20` is a pre-1.0 public-surface reset for the ACI
+client SDK. Breaking changes from the old `0.1.x` accidental surface are
+intentional: the root import is framework-neutral, framework runtime behavior is
+behind explicit subpaths, and the first required customer path is React/Next.
 
-## Getting Started
-
-The fastest way to create a new ACI site is via the scaffolding script:
+## Install
 
 ```bash
-npx tsx scripts/create-site.ts --framework astro --name my-site --dir ./my-site
-cd my-site
-npm run dev
+npm install @gradial/aci@0.1.20 zod@^4
 ```
 
-Available frameworks: `astro`, `nextjs`, `sveltekit`.
-
-Generated starters include:
-- `.aci/docs/` — Understanding ACI, running, and testing guides
-- `.aci/guides/` — Component development, design system, content authoring
-- `.aci/migration/` — Migrating existing sites to ACI
-- Design system tokens, ESLint rules, and demo content
-
-See the [templates directory](templates/) for the canonical starter source.
-
-## Installation
-
-```bash
-npm install @gradial/aci zod@^4
-npm install -D typescript tsx
-```
+## Root Import
 
-Common imports:
+The root import is for framework-neutral contracts and value types only:
 
 ```ts
-import { defineComponentContract, defineLayoutContract, slot } from '@gradial/aci';
-import type { GradialRenderer } from '@gradial/aci';
-import type { KernelPage, KernelSiteConfig } from '@gradial/aci/content';
-import { createContentSchemas, stringField } from '@gradial/aci/content';
-import { FileContentProvider } from '@gradial/aci/providers/file';
+import {
+  ImageSchema,
+  HeadingSchema,
+  LinkSchema,
+  RichTextValueSchema,
+  defineComponentContract,
+  type Image,
+  type Heading,
+  type Link,
+  type RichTextValue,
+} from '@gradial/aci';
 ```
 
-Content contract helpers are also available through focused subpaths:
-`@gradial/aci/content/contract`, `@gradial/aci/content/validation`, and
-`@gradial/aci/content/tailwind-validator`.
-
-Framework helpers live under `@gradial/aci/astro`,
-`@gradial/aci/next/server`, `@gradial/aci/next/middleware`,
-`@gradial/aci/next/dev-refresh`, and `@gradial/aci/sveltekit`.
-
-## Component Contracts vs Runtime Components
+The root import does not load React, Next, Vite, Webpack, browser-only code, or
+server providers.
 
-Keep compile-time CMS contracts separate from runtime component implementation.
-The ACI compiler imports only contract files, so those files must not import
-React, framework components, CSS, or browser-only code.
+## React/Next
 
-Recommended shape:
+React renderers and bindings live under `@gradial/aci/react`:
 
-```txt
-src/cms/contracts/components/hero.contract.ts
-src/cms/contracts/components/index.ts
-src/cms/contracts/layouts/index.ts
-src/components/Hero.tsx
-src/cms/renderBlock.tsx
+```tsx
+import { Image, Link, Heading, RichText, bindReactComponent } from '@gradial/aci/react';
 ```
 
-Contract files own names, schemas, render modes, image slots, and other metadata:
+Next integration helpers live under explicit Next subpaths:
 
 ```ts
-import { defineComponentContract, GradialImageSchema } from '@gradial/aci';
-import { z } from 'zod';
-
-export const heroContract = defineComponentContract({
-  name: 'hero',
-  schema: z.object({
-    headline: z.string(),
-    image: GradialImageSchema,
-  }),
-  renderModes: { canStatic: true, canSSR: true, canClientIsland: false },
-});
-
-export type HeroProps = z.infer<typeof heroContract.schema>;
+import { createPage, withAci } from '@gradial/aci/next';
+import { createMiddleware } from '@gradial/aci/next/middleware';
+import { DevRefresh } from '@gradial/aci/next/dev-refresh';
 ```
 
-Runtime components may import the contract for types, but contract files should
-never import runtime components:
+Astro public subpath is `@gradial/aci/astro`.
 
-```tsx
-import type { HeroProps } from '../cms/contracts/components/hero.contract';
+## Server-Side Content Providers
 
-export function Hero(props: HeroProps) {
-  return <section>{props.headline}</section>;
-}
-```
-
-Testing helpers live under `@gradial/aci/testing`:
+File and S3 providers are public server-only APIs for custom server composition,
+such as blogs, events, product detail pages, and route-specific loaders:
 
 ```ts
-import { FixtureContentProvider } from '@gradial/aci/testing';
-
-const content = new FixtureContentProvider({
-  pages: {
-    '/': {
-      id: 'home',
-      $type: 'page',
-      status: 'published',
-      layout: 'marketing',
-      renderMode: 'static',
-      metadata: { title: 'Test Home' },
-      regions: { main: [] }
-    }
-  }
-});
-
-const input = await content.loadRenderInput('/');
+import { FileContentProvider } from '@gradial/aci/providers/file';
+import { S3ContentProvider } from '@gradial/aci/providers/s3';
 ```
 
-Use this in unit tests when you want the same provider API as
-`FileContentProvider` without creating `.content` fixture files.
+These providers are not browser/client-side fetch APIs. Client-side fetch should
+go through an app-owned HTTP endpoint backed server-side by a `ContentProvider`.
 
-Publish from this package directory:
+## Scaffold
+
+The first RC scaffold path is Next:
 
 ```bash
-npm publish --access public
+npx @gradial/aci@0.1.20 init my-site --template next-starter
 ```
 
-The package includes a `prepack` script that builds `dist` before packing or
-publishing.
+List available templates:
 
-## Verify the Published Shape Locally
+```bash
+npx @gradial/aci@0.1.20 init --list
+```
 
-Before publishing, inspect the exact tarball npm will upload. This catches
-package `files` mistakes where local source imports work from the repo but fail
-after npm filters the packed files.
+## Verify Locally
 
 From `packages/sdk`:
 
 ```bash
-tmpdir="$(mktemp -d /tmp/gradial-aci-pack.XXXXXX)"
-filename="$(npm pack --pack-destination "$tmpdir" | tail -n 1)"
-tar -tzf "$tmpdir/$filename" | sort | rg '^(package/src/cli/|package/src/types/|package/dist/types/)'
-echo "tarball=$tmpdir/$filename"
+pnpm run build
+pnpm run generate-starters
 ```
-
-If a shipped source CLI imports another source file, make sure both paths appear
-in the tarball. For example, `src/cli/compile-registry.mjs` imports
-`src/types/image.ts`, so both files must be included by `package.json#files`.

package/bin/aci.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { cp, mkdir, readdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
@@ -14,6 +15,7 @@ const platformPackages = {
   'darwin-x64': '@gradial/aci-cli-darwin-x64',
   'linux-arm64': '@gradial/aci-cli-linux-arm64',
   'linux-x64': '@gradial/aci-cli-linux-x64',
+  'win32-arm64': '@gradial/aci-cli-win32-arm64',
   'win32-x64': '@gradial/aci-cli-win32-x64',
 };
 
@@ -21,7 +23,7 @@ const platformKey = `${process.platform}-${process.arch}`;
 const packageName = platformPackages[platformKey];
 
 if (!packageName) {
-  console.error(`Unsupported platform for aci: ${platformKey}`);
+  console.error(`Unsupported platform for gradial-aci: ${platformKey}`);
   process.exit(1);
 }
 
@@ -29,9 +31,17 @@ const binName = process.platform === 'win32' ? 'aci.exe' : 'aci';
 const shimDir = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(shimDir, '../../..');
 
+if (argv[0] === 'init') {
+  await runInit(argv.slice(1));
+  process.exit(0);
+}
+
 function resolveBundledBinary() {
-  const binaryPath = join(shimDir, binName);
-  return existsSync(binaryPath) ? binaryPath : null;
+  const binaryPath = join(shimDir, `aci-${platformKey}${process.platform === 'win32' ? '.exe' : ''}`);
+  if (existsSync(binaryPath)) return binaryPath;
+  // Local development fallback for packages built before platform-suffixed bins.
+  const legacyPath = join(shimDir, binName);
+  return existsSync(legacyPath) ? legacyPath : null;
 }
 
 function resolvePackagedBinary() {
@@ -65,14 +75,24 @@ if (!binaryPath && !fallback) {
 }
 
 const child = binaryPath
-  ? spawn(binaryPath, argv, { stdio: 'inherit' })
+  ? spawn(binaryPath, argv, {
+      env: {
+        ...process.env,
+        ACI_PACKAGE_ROOT: resolve(shimDir, '..'),
+      },
+      stdio: 'inherit',
+    })
   : spawn(fallback.command, fallback.args, {
       cwd: fallback.cwd,
+      env: {
+        ...process.env,
+        ACI_PACKAGE_ROOT: resolve(shimDir, '..'),
+      },
       stdio: 'inherit',
     });
 
 child.on('error', (error) => {
-  console.error(`Failed to run aci: ${error.message}`);
+  console.error(`Failed to run gradial-aci: ${error.message}`);
   process.exit(1);
 });
 
@@ -155,3 +175,76 @@ function normalizePathArg(value) {
 function isAbsolutePath(value) {
   return value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
 }
+
+async function runInit(args) {
+  if (args.includes('--list')) {
+    console.log('next-starter');
+    return;
+  }
+
+  const target = args.find((arg) => !arg.startsWith('-'));
+  const template = optionValue(args, '--template') || 'next-starter';
+  if (!target) {
+    throw new Error('usage: aci init <target> --template next-starter');
+  }
+  if (template !== 'next-starter') {
+    throw new Error(`unknown template "${template}". Available templates: next-starter`);
+  }
+
+  const targetDir = resolve(callerCwd, target);
+  await assertEmptyTarget(targetDir);
+  await mkdir(targetDir, { recursive: true });
+
+  const packageRoot = resolve(shimDir, '..');
+  await cp(join(packageRoot, 'templates', 'common'), targetDir, { recursive: true });
+  await cp(join(packageRoot, 'templates', 'nextjs', 'template'), targetDir, { recursive: true });
+  await renderTemplates(targetDir, {
+    siteName: basename(targetDir),
+    version: '0.1.0',
+  });
+  console.log(`Created ${relative(callerCwd, targetDir) || '.'} from next-starter`);
+}
+
+function optionValue(args, name) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === name) return args[index + 1] || '';
+    if (arg.startsWith(`${name}=`)) return arg.slice(name.length + 1);
+  }
+  return '';
+}
+
+async function assertEmptyTarget(targetDir) {
+  try {
+    const info = await stat(targetDir);
+    if (!info.isDirectory()) {
+      throw new Error(`target exists and is not a directory: ${targetDir}`);
+    }
+    const entries = await readdir(targetDir);
+    if (entries.length > 0) {
+      throw new Error(`target directory is not empty: ${targetDir}`);
+    }
+  } catch (error) {
+    if (error?.code === 'ENOENT') return;
+    throw error;
+  }
+}
+
+async function renderTemplates(root, values) {
+  const entries = await readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(root, entry.name);
+    if (entry.isDirectory()) {
+      await renderTemplates(fullPath, values);
+      continue;
+    }
+    if (!entry.name.endsWith('.tmpl')) {
+      continue;
+    }
+    const raw = await readFile(fullPath, 'utf-8');
+    const rendered = raw.replace(/\{\{\s*([A-Za-z0-9_]+)\s*\}\}/g, (_match, key) => values[key] ?? '');
+    const nextPath = fullPath.slice(0, -'.tmpl'.length);
+    await writeFile(fullPath, rendered);
+    await rename(fullPath, nextPath);
+  }
+}

package/dist/assets/index.d.ts

@@ -1,3 +1,3 @@
-export { type GradialImage, type ImageSource, type PictureSource, type ImageSlotContract, type SlotOutput, type ImageHTMLAttributes, GradialImageSchema, renderImageHTML, } from '../types/image.js';
-export { type GradialVideo, type VideoSource, GradialVideoSchema, VideoSourceSchema, } from '../types/video.js';
-export { type GradialAsset, GradialAssetSchema, isGradialImage, isGradialVideo, isGradialAsset, renderVideoHTML, renderAssetHTML, } from '../types/media.js';
+export { type Image, type ImageSource, type ImageAttrs, ImageSchema, imageAttrs, primaryImageSource, } from '../types/image.js';
+export { type Video, type VideoSource, VideoSchema, VideoSourceSchema, } from '../types/video.js';
+export { type Asset, AssetSchema, isImage, isVideo, isAsset, } from '../types/media.js';

package/dist/assets/index.js

@@ -1,3 +1,3 @@
-export { GradialImageSchema, renderImageHTML, } from '../types/image.js';
-export { GradialVideoSchema, VideoSourceSchema, } from '../types/video.js';
-export { GradialAssetSchema, isGradialImage, isGradialVideo, isGradialAsset, renderVideoHTML, renderAssetHTML, } from '../types/media.js';
+export { ImageSchema, imageAttrs, primaryImageSource, } from '../types/image.js';
+export { VideoSchema, VideoSourceSchema, } from '../types/video.js';
+export { AssetSchema, isImage, isVideo, isAsset, } from '../types/media.js';

package/dist/astro/index.d.ts

@@ -1,5 +1,7 @@
 import type { RenderInput } from '../content/types.js';
-import { type GradialContentWatchOptions } from '../dev/index.js';
+import { type ContentWatchOptions } from '../dev/content-watch.js';
+import type { Registry, AnyComponent } from '../registry.js';
+import type { BlockRef } from '../types/block-ref.js';
 interface AstroConfigSetupParams {
     injectScript(stage: 'head-inline' | 'page' | 'page-ssr', content: string): void;
     updateConfig(config: {
@@ -33,9 +35,18 @@ export declare function getGradialStaticPaths(): Promise<Array<{
     };
 }>>;
 export declare function getPageRuntimeRenderInput(request: Request): RenderInput | null;
+export { createRegistry, registryLookup } from '../registry.js';
+export type { Registry, RegistryEntry, AnyComponent } from '../registry.js';
+export type { BlockRef } from '../types/block-ref.js';
+export interface RenderableBlock {
+    Component: AnyComponent | undefined;
+    props: Record<string, unknown>;
+}
+export type RenderChildren = (blocks: readonly BlockRef[]) => RenderableBlock[];
+export declare function createRenderChildren(registry: Registry): RenderChildren;
 export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, type PreviewContext, type PreviewCookie, } from './preview.js';
-export interface GradialAstroOptions extends GradialContentWatchOptions {
+export interface AstroOptions extends ContentWatchOptions {
     /** Path to compiled content root. Defaults to ACI_CONTENT_ROOT env or '.aci/compiled' */
     compiledRoot?: string;
 }
-export declare function withGradialAci(options?: GradialAstroOptions): AstroIntegrationLike;
+export declare function withAci(options?: AstroOptions): AstroIntegrationLike;

package/dist/astro/index.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { getPendingRenderInputFromHeaders } from '../runtime/page.js';
-import { gradialContentWatchPlugin, gradialDamAssetPlugin, devRefreshPort, devRefreshScript, } from '../dev/index.js';
+import { contentWatchPlugin, damAssetPlugin, devRefreshPort, } from '../dev/content-watch.js';
+import { createDevRefreshBrowserScript } from '../dev/index.js';
 // ---------------------------------------------------------------------------
 // Static paths helper — for Astro SSG
 // ---------------------------------------------------------------------------
@@ -32,23 +33,41 @@ export function getPageRuntimeRenderInput(request) {
     return getPendingRenderInputFromHeaders(request.headers);
 }
 // ---------------------------------------------------------------------------
+// Registry helpers
+// ---------------------------------------------------------------------------
+export { createRegistry, registryLookup } from '../registry.js';
+export function createRenderChildren(registry) {
+    function renderChildren(blocks) {
+        return blocks.map((block) => {
+            const entry = registry.find((r) => r.id === block.component);
+            const hasBlockSlots = !!entry?.contract.blockSlots;
+            const props = { ...block.props };
+            if (hasBlockSlots) {
+                props.renderChildren = renderChildren;
+            }
+            return { Component: entry?.component, props };
+        });
+    }
+    return renderChildren;
+}
+// ---------------------------------------------------------------------------
 // Preview support
 // ---------------------------------------------------------------------------
 export { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, } from './preview.js';
-export function withGradialAci(options = {}) {
+export function withAci(options = {}) {
     return {
-        name: 'gradial-astro',
+        name: 'aci-astro',
         hooks: {
             'astro:config:setup'({ injectScript, updateConfig }) {
                 if (process.env.NODE_ENV === 'production') {
                     return;
                 }
                 if (devRefreshPort(options) > 0) {
-                    injectScript('page', devRefreshScript(options));
+                    injectScript('page', createDevRefreshBrowserScript(options));
                 }
                 updateConfig({
                     vite: {
-                        plugins: [gradialDamAssetPlugin(options), gradialContentWatchPlugin(options)],
+                        plugins: [damAssetPlugin(options), contentWatchPlugin(options)],
                     },
                 });
             },

package/dist/content/assets.d.ts

@@ -0,0 +1,17 @@
+export interface ReleaseAssetConfig {
+    bucket?: string;
+    keyPrefix?: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    endpoint?: string;
+}
+export declare class ReleaseAssetNotFoundError extends Error {
+    constructor(releaseId: string, assetPath: string, cause?: unknown);
+}
+export declare function getReleaseAssetResponse(input: {
+    releaseId: string;
+    assetPath: string;
+    config?: ReleaseAssetConfig;
+}): Promise<Response>;

package/dist/content/assets.js

@@ -0,0 +1,65 @@
+import { S3ContentProvider } from '../providers/s3.js';
+export class ReleaseAssetNotFoundError extends Error {
+    constructor(releaseId, assetPath, cause) {
+        super(`ACI release asset not found: ${releaseId}/${assetPath}`);
+        this.name = 'ReleaseAssetNotFoundError';
+        this.cause = cause;
+    }
+}
+export async function getReleaseAssetResponse(input) {
+    const clean = cleanAssetPath(input.assetPath);
+    if (!input.releaseId || !clean) {
+        throw new ReleaseAssetNotFoundError(input.releaseId, input.assetPath);
+    }
+    const config = input.config ?? {};
+    const provider = new S3ContentProvider({
+        bucket: config.bucket,
+        keyPrefix: releaseKey(config, input.releaseId),
+        region: config.region,
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        sessionToken: config.sessionToken,
+        endpoint: config.endpoint,
+    });
+    const key = joinKey(provider.config.keyPrefix, 'assets', clean);
+    const res = await provider.fetchRaw(key);
+    if (!res.ok || !res.body) {
+        throw new ReleaseAssetNotFoundError(input.releaseId, clean, await safeResponseText(res));
+    }
+    const headers = new Headers();
+    copyHeader(res.headers, headers, 'content-type');
+    copyHeader(res.headers, headers, 'content-length');
+    copyHeader(res.headers, headers, 'etag');
+    copyHeader(res.headers, headers, 'last-modified');
+    headers.set('cache-control', 'public, max-age=31536000, immutable');
+    return new Response(res.body, { status: 200, headers });
+}
+function cleanAssetPath(value) {
+    const clean = value.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
+    if (!clean || clean.split('/').some((segment) => segment === '..' || segment === '.'))
+        return '';
+    return clean;
+}
+function copyHeader(from, to, name) {
+    const value = from.get(name);
+    if (value)
+        to.set(name, value);
+}
+async function safeResponseText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}
+function releaseKey(config, releaseId) {
+    return joinKey(config.keyPrefix || process.env.ACI_S3_KEY_PREFIX || '', 'releases', releaseId);
+}
+function joinKey(...parts) {
+    return parts
+        .filter(Boolean)
+        .map((part) => part.replace(/^\/+|\/+$/g, ''))
+        .filter(Boolean)
+        .join('/');
+}

package/dist/content/index.d.ts

@@ -2,3 +2,5 @@ export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
 export * from './cache.js';
+export * from './resolve-slots.js';
+export * from './assets.js';

package/dist/content/index.js

@@ -2,3 +2,5 @@ export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
 export * from './cache.js';
+export * from './resolve-slots.js';
+export * from './assets.js';

package/dist/content/provider.d.ts

@@ -12,17 +12,33 @@ export interface FragmentEntry {
     digest: string;
     fragmentRefs?: string[];
 }
+export interface LayoutEntry {
+    name: string;
+    slots: LayoutSlot[];
+    defaults?: Record<string, FragmentRef[]>;
+}
+export interface LayoutSlot {
+    name: string;
+    required: boolean;
+}
+export interface FragmentRef {
+    kind: string;
+    fragmentId: string;
+    inline: boolean;
+}
 export interface CompiledManifest {
     manifestVersion: string;
     buildDigest: string;
     siteConfigRef: string;
     routes: Record<string, RouteEntry>;
     fragments: Record<string, FragmentEntry>;
+    layouts?: Record<string, LayoutEntry>;
 }
 export interface 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>;
     listRoutes(): Promise<RouteEntry[]>;
 }
 export declare class PageNotFoundError extends Error {
@@ -31,6 +47,9 @@ export declare class PageNotFoundError extends Error {
 export declare class FragmentNotFoundError extends Error {
     constructor(id: string, cause?: unknown);
 }
+export declare class LayoutNotFoundError extends Error {
+    constructor(name: string, cause?: unknown);
+}
 export interface RenderInputOptions {
     domain?: string;
     locale?: string;

package/dist/content/provider.js

@@ -16,6 +16,13 @@ export class FragmentNotFoundError extends Error {
         this.cause = cause;
     }
 }
+export class LayoutNotFoundError extends Error {
+    constructor(name, cause) {
+        super(`Layout not found: ${name}`);
+        this.name = 'LayoutNotFoundError';
+        this.cause = cause;
+    }
+}
 import { getCachedSiteConfig } from './cache.js';
 export async function loadRenderInput(provider, route = '/', options = {}) {
     const normalized = normalizeRoute(route);

package/dist/content/resolve-slots.d.ts

@@ -0,0 +1,9 @@
+import type { LayoutEntry } from './provider.js';
+import type { KernelPageBlock } from './types.js';
+export interface FragmentData {
+    id: string;
+    component: string;
+    props?: Record<string, unknown>;
+}
+export type FragmentLoader = (id: string) => Promise<FragmentData>;
+export declare function resolveSlots(layout: LayoutEntry, pageRegions: Record<string, KernelPageBlock[]>, getFragment: FragmentLoader): Promise<Record<string, KernelPageBlock[]>>;

package/dist/content/resolve-slots.js

@@ -0,0 +1,24 @@
+export async function resolveSlots(layout, pageRegions, getFragment) {
+    const resolved = {};
+    for (const slot of layout.slots) {
+        const pageBlocks = pageRegions[slot.name];
+        if (pageBlocks && pageBlocks.length > 0) {
+            resolved[slot.name] = pageBlocks;
+            continue;
+        }
+        const defaults = layout.defaults?.[slot.name];
+        if (defaults?.length) {
+            const blocks = [];
+            for (const ref of defaults) {
+                const fragment = await getFragment(ref.fragmentId);
+                blocks.push({
+                    id: fragment.id,
+                    component: fragment.component,
+                    props: fragment.props || {},
+                });
+            }
+            resolved[slot.name] = blocks;
+        }
+    }
+    return resolved;
+}

package/dist/content/types.d.ts

@@ -55,7 +55,6 @@ export interface KernelPage {
     $type: 'page';
     status: string;
     layout: string;
-    renderMode: string;
     metadata: KernelPageSeo;
     regions: Record<string, KernelPageBlock[]>;
 }
@@ -93,6 +92,7 @@ export interface RenderInput<TPage extends KernelPage = KernelPage, TSiteConfig
     siteConfig: TSiteConfig;
     page: TPage | null;
     fragments?: Record<string, unknown>;
+    layouts?: Record<string, unknown>;
 }
 export interface RenderOutput {
     route: string;