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

package/README.md

@@ -10,9 +10,9 @@ content provider helpers, and framework-specific subpaths from one package.
 The fastest way to create a new ACI site is via the scaffolding script:
 
 ```bash
-npx tsx scripts/create-site.ts --framework astro --name my-site --dir ./my-site
+pnpm exec tsx scripts/create-site.ts --framework astro --name my-site --dir ./my-site
 cd my-site
-npm run dev
+pnpm run dev
 ```
 
 Available frameworks: `astro`, `nextjs`, `sveltekit`.
@@ -28,8 +28,8 @@ See the [templates directory](templates/) for the canonical starter source.
 ## Installation
 
 ```bash
-npm install @gradial/aci zod@^4
-npm install -D typescript tsx
+pnpm add @gradial/aci zod@^4
+pnpm add -D typescript tsx
 ```
 
 Common imports:
@@ -78,7 +78,6 @@ export const heroContract = defineComponentContract({
     headline: z.string(),
     image: GradialImageSchema,
   }),
-  renderModes: { canStatic: true, canSSR: true, canClientIsland: false },
 });
 
 export type HeroProps = z.infer<typeof heroContract.schema>;
@@ -107,7 +106,6 @@ const content = new FixtureContentProvider({
       $type: 'page',
       status: 'published',
       layout: 'marketing',
-      renderMode: 'static',
       metadata: { title: 'Test Home' },
       regions: { main: [] }
     }
@@ -123,7 +121,7 @@ Use this in unit tests when you want the same provider API as
 Publish from this package directory:
 
 ```bash
-npm publish --access public
+pnpm publish --access public
 ```
 
 The package includes a `prepack` script that builds `dist` before packing or
@@ -131,15 +129,15 @@ publishing.
 
 ## Verify the Published Shape Locally
 
-Before publishing, inspect the exact tarball npm will upload. This catches
+Before publishing, inspect the exact tarball pnpm will upload. This catches
 package `files` mistakes where local source imports work from the repo but fail
-after npm filters the packed files.
+after pnpm filters the packed files.
 
 From `packages/sdk`:
 
 ```bash
 tmpdir="$(mktemp -d /tmp/gradial-aci-pack.XXXXXX)"
-filename="$(npm pack --pack-destination "$tmpdir" | tail -n 1)"
+filename="$(pnpm 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"
 ```

package/dist/astro/index.d.ts

@@ -33,6 +33,8 @@ 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 { getPreviewMode, createPreviewBannerHTML, createPreviewCookies, type PreviewContext, type PreviewCookie, } from './preview.js';
 export interface GradialAstroOptions extends GradialContentWatchOptions {
     /** Path to compiled content root. Defaults to ACI_CONTENT_ROOT env or '.aci/compiled' */

package/dist/astro/index.js

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

package/dist/content/index.d.ts

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

package/dist/content/index.js

@@ -2,3 +2,4 @@ export * from './provider.js';
 export * from './routes.js';
 export * from './types.js';
 export * from './cache.js';
+export * from './resolve-slots.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;

package/dist/content/validation.js

@@ -121,7 +121,6 @@ export function createContentSchemas(contracts = {}) {
         $type: z.literal('page'),
         status: z.string().min(1),
         layout: z.string().min(1),
-        renderMode: z.string().min(1),
         metadata: z.looseObject({
             title: z.string().optional(),
             description: z.string().optional(),

package/dist/define-component.js

@@ -1,12 +1,6 @@
 export function defineComponent(definition) {
-    const renderModes = definition.renderModes ?? definition.render;
-    if (!renderModes) {
-        throw new Error(`component ${definition.name} must define renderModes`);
-    }
     return {
         ...definition,
-        renderModes,
-        render: renderModes,
         varyDimensions: definition.varyDimensions ?? definition.vary,
         vary: definition.vary ?? definition.varyDimensions,
     };

package/dist/define-layout.d.ts

@@ -1,4 +1,6 @@
 import type { LayoutContract, LayoutDefinition, LayoutSlot } from './types/layout.js';
+import type { FragmentRefNode } from './types/page.js';
 export declare function defineLayout(definition: LayoutDefinition): LayoutContract;
 export declare const defineLayoutContract: typeof defineLayout;
 export declare function slot(name: string, required?: boolean): LayoutSlot;
+export declare function fragmentDefault(fragmentId: string): FragmentRefNode;

package/dist/define-layout.js

@@ -9,3 +9,6 @@ export const defineLayoutContract = defineLayout;
 export function slot(name, required = false) {
     return { name, required };
 }
+export function fragmentDefault(fragmentId) {
+    return { kind: 'fragment-ref', fragmentId, inline: true };
+}

package/dist/index.d.ts

@@ -2,4 +2,5 @@ export * from './block-ref.js';
 export * from './define-component.js';
 export * from './define-data-model.js';
 export * from './define-layout.js';
+export * from './registry.js';
 export * from './types/index.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export * from './block-ref.js';
 export * from './define-component.js';
 export * from './define-data-model.js';
 export * from './define-layout.js';
+export * from './registry.js';
 export * from './types/index.js';
 // Note: content/ is NOT re-exported here because it imports node:path,
 // making it incompatible with client-side bundlers. Import server-only

package/dist/next/asset-route.d.ts

@@ -5,5 +5,7 @@ type AssetRouteParams = {
     releaseId?: string;
     path?: string[];
 };
+export declare const runtime = "nodejs";
+export declare const dynamic = "force-dynamic";
 export declare function GET(_request: Request, { params }: AssetRouteContext): Promise<Response>;
 export {};

package/dist/next/asset-route.js

@@ -1,11 +1,19 @@
+import { FileContentProvider } from '../providers/file.js';
 import { getReleaseAssetResponse } from './server.js';
+const LOCAL_RELEASE_ID = 'local';
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
 export async function GET(_request, { params }) {
     const resolvedParams = await params;
     const releaseId = resolvedParams.releaseId || '';
-    const assetPath = (resolvedParams.path || []).join('/');
-    if (!releaseId || !assetPath) {
+    const assetPath = '/' + (resolvedParams.path || []).join('/');
+    if (!releaseId || assetPath === '/') {
         return new Response('asset not found', { status: 404 });
     }
+    if (releaseId === LOCAL_RELEASE_ID) {
+        const provider = new FileContentProvider();
+        return provider.fetchRaw(assetPath);
+    }
     try {
         return await getReleaseAssetResponse(releaseId, assetPath);
     }

package/dist/next/config.js

@@ -9,7 +9,7 @@ export function withGradialAci(nextConfig = {}, options = {}) {
             const gradialRewrites = [
                 {
                     source: `${assetPrefix}/:path*`,
-                    destination: `/api/aci-assets${assetPrefix}/:path*`,
+                    destination: `/gradial/assets/local${assetPrefix}/:path*`,
                 },
             ];
             if (!userRewrites)

package/dist/next/middleware.d.ts

@@ -1,7 +1,11 @@
 import { NextResponse, type NextRequest } from 'next/server.js';
 export interface GradialMiddlewareConfig {
-    siteId: string;
+    siteId?: string;
     edgeConfig?: string;
+    previewSignKey?: string;
     deploymentId?: string;
 }
-export declare function createGradialMiddleware(config: GradialMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;
+export declare function createGradialMiddleware(config?: GradialMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;
+export declare const config: {
+    matcher: string[];
+};

package/dist/next/middleware.js

@@ -3,7 +3,7 @@ import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { PREVIEW_TOKEN_COOKIE, PREVIEW_RELEASE_COOKIE, PREVIEW_HEADER, RELEASE_HEADER, extractPreviewToken, resolvePreviewContext, createPreviewCookies, previewSignKey, } from '../preview/core.js';
 const ROUTE_HEADER = 'x-gradial-route';
 const DISPATCH_HEADER = 'x-gradial-dispatch';
-export function createGradialMiddleware(config) {
+export function createGradialMiddleware(config = {}) {
     return async function gradialMiddleware(request) {
         const url = request.nextUrl;
         // ?leave_preview=1 → clear cookies, redirect to clean URL
@@ -38,6 +38,11 @@ export function createGradialMiddleware(config) {
         return response;
     };
 }
+export const config = {
+    matcher: [
+        '/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)',
+    ],
+};
 function gradialHeaders(headers) {
     const next = new Headers(headers);
     next.delete(RELEASE_HEADER);
@@ -59,7 +64,7 @@ async function resolvePreviewFromRequest(request, config) {
         console.warn('[gradial/mw] GRADIAL_PREVIEW_SIGN_KEY not set — preview tokens will be ignored');
         return null;
     }
-    return await resolvePreviewContext({ token, siteId: config.siteId, signKey });
+    return await resolvePreviewContext({ token, siteId: config.siteId || '', signKey });
 }
 function cookieMap(cookies) {
     const map = new Map();

package/dist/next/page.d.ts

@@ -1,38 +1,39 @@
-import type { ComponentType } from 'react';
 import type { Metadata } from 'next';
-import { type KernelPage, type KernelSiteConfig } from '../content/index.js';
-export interface AciPageProps {
-    page: KernelPage;
-    siteConfig: KernelSiteConfig;
-}
-export interface CreateAciPageOptions {
-    /** The site's CmsPage component that renders chrome + content blocks. */
-    CmsPage: ComponentType<AciPageProps>;
-}
+import { type KernelPage } from '../content/index.js';
+import type { Registry } from '../registry.js';
 type NextPageProps = {
     params: Promise<{
         slug?: string[];
     }>;
 };
+export type SlotPropsFn = (slotName: string, page: KernelPage) => Record<string, unknown> | undefined;
+export interface CreatePageOptions {
+    slotProps?: SlotPropsFn;
+}
 /**
  * Creates the catch-all route handler for a Next.js ACI site.
  *
  * Usage in `src/app/[[...slug]]/page.tsx`:
  *
  * ```tsx
- * import { createAciPage } from '@gradial/aci/next/page';
- * import { CmsPage } from '@/components/CmsPage';
+ * import { createPage } from '@gradial/aci/next/page';
+ * import { registry } from '@/cms/registry';
  *
- * const page = createAciPage({ CmsPage });
+ * const page = createPage(registry);
  * export const dynamic = page.dynamic;
  * export const generateMetadata = page.generateMetadata;
  * export default page.default;
  * ```
  *
  * The SDK owns param normalization, content loading, metadata generation,
- * and notFound handling. The site only provides its CmsPage component.
+ * notFound handling, layout resolution, and block rendering via the registry.
+ *
+ * Layout slots: createPage loads the page's layout, iterates all slots, and
+ * fills each from the page's regions. If a slot is empty, it falls back to
+ * the layout's fragment defaults (loaded via getFragment). This lets chrome
+ * be CMS-managed fragments instead of hardcoded component imports.
  */
-export declare function createAciPage({ CmsPage }: CreateAciPageOptions): {
+export declare function createPage(registry: Registry, options?: CreatePageOptions): {
     dynamic: "force-dynamic";
     generateMetadata: ({ params }: NextPageProps) => Promise<Metadata>;
     default: ({ params }: NextPageProps) => Promise<import("react").JSX.Element>;

package/dist/next/page.js

@@ -1,26 +1,33 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { notFound } from 'next/navigation.js';
-import { PageNotFoundError, routeFromNextParams, getRenderInput, } from './server.js';
-import { routeMetadataForContent, } from '../content/index.js';
+import { Fragment } from 'react';
+import { PageNotFoundError, routeFromNextParams, getRenderInput, getLayout, getFragment, } from './server.js';
+import { routeMetadataForContent, resolveSlots, } from '../content/index.js';
+import { renderBlocks } from './render.js';
 /**
  * Creates the catch-all route handler for a Next.js ACI site.
  *
  * Usage in `src/app/[[...slug]]/page.tsx`:
  *
  * ```tsx
- * import { createAciPage } from '@gradial/aci/next/page';
- * import { CmsPage } from '@/components/CmsPage';
+ * import { createPage } from '@gradial/aci/next/page';
+ * import { registry } from '@/cms/registry';
  *
- * const page = createAciPage({ CmsPage });
+ * const page = createPage(registry);
  * export const dynamic = page.dynamic;
  * export const generateMetadata = page.generateMetadata;
  * export default page.default;
  * ```
  *
  * The SDK owns param normalization, content loading, metadata generation,
- * and notFound handling. The site only provides its CmsPage component.
+ * notFound handling, layout resolution, and block rendering via the registry.
+ *
+ * Layout slots: createPage loads the page's layout, iterates all slots, and
+ * fills each from the page's regions. If a slot is empty, it falls back to
+ * the layout's fragment defaults (loaded via getFragment). This lets chrome
+ * be CMS-managed fragments instead of hardcoded component imports.
  */
-export function createAciPage({ CmsPage }) {
+export function createPage(registry, options) {
     const dynamic = 'force-dynamic';
     async function generateMetadata({ params }) {
         const route = await routeFromNextParams(params);
@@ -43,7 +50,18 @@ export function createAciPage({ CmsPage }) {
             const input = await getRenderInput(route);
             if (!input.page || input.page.status !== 'published')
                 notFound();
-            return _jsx(CmsPage, { page: input.page, siteConfig: input.siteConfig });
+            const layout = await getLayout(input.page.layout);
+            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id));
+            return (_jsx(_Fragment, { children: layout.slots.map((slot) => {
+                    const blocks = resolvedSlots[slot.name];
+                    if (!blocks?.length)
+                        return null;
+                    const extraProps = options?.slotProps?.(slot.name, input.page);
+                    if (slot.name === 'main') {
+                        return (_jsx("main", { id: "content-main", children: renderBlocks(blocks, registry, extraProps) }, "main"));
+                    }
+                    return (_jsx(Fragment, { children: renderBlocks(blocks, registry, extraProps) }, slot.name));
+                }) }));
         }
         catch (error) {
             if (error instanceof PageNotFoundError)

package/dist/next/render.d.ts

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { Registry } from '../registry.js';
+import type { KernelPageBlock } from '../content/types.js';
+export declare function renderBlock(block: KernelPageBlock, registry: Registry, extraProps?: Record<string, unknown>): ReactElement | null;
+export declare function renderBlocks(blocks: readonly KernelPageBlock[], registry: Registry, extraProps?: Record<string, unknown>): (ReactElement | null)[];

package/dist/next/render.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function renderBlock(block, registry, extraProps) {
+    const entry = registry.find((r) => r.name === block.component);
+    if (!entry) {
+        if (process.env.NODE_ENV !== 'production') {
+            return (_jsxs("div", { className: "mx-auto my-4 max-w-[var(--max-width-container)] rounded-card border-2 border-red-600 bg-red-50 px-5 py-4 font-mono text-sm leading-relaxed text-red-900", children: [_jsx("strong", { children: "Unknown block:" }), " ", _jsx("code", { children: block.component }), _jsx("br", {}), _jsxs("span", { className: "text-red-800 opacity-70", children: ["id: ", block.id] })] }, block.id));
+        }
+        return null;
+    }
+    const Component = entry.component;
+    return _jsx(Component, { ...block.props, ...extraProps }, block.id);
+}
+export function renderBlocks(blocks, registry, extraProps) {
+    return blocks.map((block) => renderBlock(block, registry, extraProps));
+}

package/dist/next/root-layout.d.ts

@@ -0,0 +1,4 @@
+import type { ReactNode } from 'react';
+export declare function RootLayout({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/next/root-layout.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DevRefresh } from './dev-refresh.js';
+export function RootLayout({ children }) {
+    return (_jsx("html", { lang: "en", children: _jsxs("body", { children: [children, _jsx(DevRefresh, {})] }) }));
+}

package/dist/next/server.d.ts

@@ -1,6 +1,6 @@
-import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
 import type { RenderInput } from '../content/types.js';
-export { FragmentNotFoundError, PageNotFoundError };
+export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
 export interface GradialFetchConfig {
     siteId?: string;
     bucket?: string;
@@ -29,6 +29,7 @@ export interface GradialSiteConfig {
 export declare function getPage<T = unknown>(route?: string, config?: GradialFetchConfig): Promise<T>;
 export declare function getSiteConfig<T extends GradialSiteConfig = GradialSiteConfig>(config?: GradialFetchConfig): Promise<T>;
 export declare function getFragment<T = unknown>(name: string, config?: GradialFetchConfig): Promise<T>;
+export declare function getLayout<T = unknown>(name: string, config?: GradialFetchConfig): Promise<T>;
 export declare function getRoutes(config?: GradialFetchConfig): Promise<string[]>;
 export declare function getRenderInput<TPage, TSite extends GradialSiteConfig = GradialSiteConfig>(route?: string, config?: GradialFetchConfig): Promise<GradialRenderInput<TPage, TSite>>;
 export declare function getPageRuntimeRenderInput(): Promise<RenderInput | null>;

package/dist/next/server.js

@@ -1,12 +1,12 @@
 import { headers } from 'next/headers.js';
-import { FragmentNotFoundError, PageNotFoundError, } from '../content/provider.js';
+import { FragmentNotFoundError, LayoutNotFoundError, 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 };
+export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
 export async function getPage(route = '', config = {}) {
     const runtimeInput = await getPageRuntimeRenderInput();
     if (runtimeInput)
@@ -31,6 +31,16 @@ 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,6 +7,8 @@ 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;
 }