@gradial/aci 0.1.20-preview.2 → 0.1.20

package/dist/define-component.d.ts

@@ -1,3 +1,2 @@
 import type { ComponentContract, ComponentDefinition } from './types/component.js';
-export declare function defineComponent<TSchema = unknown>(definition: ComponentDefinition<TSchema>): ComponentContract<TSchema>;
-export declare const defineComponentContract: typeof defineComponent;
+export declare function defineComponentContract<const TId extends string, TSchema = unknown>(definition: ComponentDefinition<TId, TSchema>): ComponentContract<TId, TSchema>;

package/dist/define-component.js

@@ -1,14 +1,76 @@
-export function defineComponent(definition) {
-    const renderModes = definition.renderModes ?? definition.render;
-    if (!renderModes) {
-        throw new Error(`component ${definition.name} must define renderModes`);
-    }
+import { getBlockRefMeta } from './types/block-ref.js';
+export function defineComponentContract(definition) {
     return {
-        ...definition,
-        renderModes,
-        render: renderModes,
-        varyDimensions: definition.varyDimensions ?? definition.vary,
-        vary: definition.vary ?? definition.varyDimensions,
+        id: definition.id,
+        ...(definition.displayName ? { displayName: definition.displayName } : {}),
+        props: definition.props,
+        ...scanBlockSlots(definition.props),
+        ...(definition.imageSlots ? { imageSlots: definition.imageSlots } : {}),
+        validate: definition.validate ?? [],
     };
 }
-export const defineComponentContract = defineComponent;
+function scanBlockSlots(schema) {
+    const slots = {};
+    const shape = getSchemaShape(schema);
+    if (!shape)
+        return {};
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+        const unwrapped = unwrapOptional(fieldSchema);
+        const meta = getBlockRefMeta(unwrapped) ?? getBlockRefMeta(unwrapArray(unwrapped));
+        if (meta) {
+            slots[key] = meta;
+        }
+    }
+    return Object.keys(slots).length ? { blockSlots: slots } : {};
+}
+function unwrapOptional(schema) {
+    let current = schema;
+    const seen = new Set();
+    while (current && typeof current === 'object' && !seen.has(current)) {
+        seen.add(current);
+        const def = current._def;
+        if (!def || typeof def !== 'object')
+            break;
+        const type = def.type;
+        const typeName = def.typeName;
+        if (type === 'optional' || type === 'nullable' || type === 'default' ||
+            typeName === 'ZodOptional' || typeName === 'ZodNullable' || typeName === 'ZodDefault') {
+            const inner = def.innerType ?? def.schema;
+            if (inner) {
+                current = inner;
+                continue;
+            }
+        }
+        break;
+    }
+    return current;
+}
+function getSchemaShape(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def || typeof def !== 'object')
+        return null;
+    const shape = def.shape;
+    if (typeof shape === 'function') {
+        return shape.call(def);
+    }
+    if (shape && typeof shape === 'object') {
+        return shape;
+    }
+    return null;
+}
+function unwrapArray(schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const def = schema._def;
+    if (!def || typeof def !== 'object')
+        return null;
+    const type = def.type;
+    const typeName = def.typeName;
+    if (type === 'array' && def.element)
+        return def.element;
+    if (typeName === 'ZodArray' && def.type)
+        return def.type;
+    return null;
+}

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/dev/content-watch.d.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type DevRefreshOptions } from './browser.js';
+export interface ContentWatchOptions extends DevRefreshOptions {
+    contentRoot?: string;
+    compiledRoot?: string;
+    bin?: string;
+    enabled?: boolean;
+}
+interface ViteModuleGraph {
+    idToModuleMap: Map<unknown, {
+        id: string | null;
+    }>;
+    invalidateModule(mod: unknown): void;
+}
+interface ViteDevServerLike {
+    middlewares?: {
+        use(path: string, handler: (req: IncomingMessage, res: ServerResponse, next: () => void) => void): void;
+    };
+    watcher: {
+        add(path: string): void;
+        on(event: string, callback: (eventName: string, filePath: string) => void): void;
+    };
+    ws: {
+        send(payload: unknown): void;
+    };
+    moduleGraph?: ViteModuleGraph;
+}
+export interface VitePluginLike {
+    name: string;
+    apply?: 'serve' | 'build';
+    configureServer?(server: ViteDevServerLike): void;
+    transformIndexHtml?(html: string): string;
+}
+export declare function devRefreshPort(options?: DevRefreshOptions): number;
+export declare function contentWatchPlugin(options?: ContentWatchOptions): VitePluginLike;
+export declare function damAssetPlugin(options?: ContentWatchOptions): VitePluginLike;
+export {};

package/dist/dev/content-watch.js

@@ -0,0 +1,154 @@
+import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { compiledContentRoot } from '../content/routes.js';
+import { DEFAULT_DEV_REFRESH_PORT } from './browser.js';
+export function devRefreshPort(options = {}) {
+    const value = options.wsPort ?? process.env.ACI_DEV_WS_PORT;
+    if (value === 0 || value === '0') {
+        return 0;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_DEV_REFRESH_PORT;
+}
+function sourceContentRoot(options) {
+    return path.resolve(options.contentRoot || process.env.ACI_CONTENT_SOURCE || './.content');
+}
+function resolveBin(options) {
+    return options.bin || process.env.ACI_BIN || 'aci';
+}
+function recompileContent(options, reason) {
+    const siteDir = process.cwd();
+    const src = sourceContentRoot(options);
+    const out = path.resolve(options.compiledRoot || process.env.ACI_CONTENT_ROOT || '.aci/compiled');
+    const bin = resolveBin(options);
+    console.log(`[aci] compiling content (${reason})`);
+    const result = spawnSync(bin, ['-s', siteDir, 'build', '--content', src, '--out', out, '--skip-code'], {
+        cwd: siteDir,
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        console.error(`[aci] content compile failed with exit code ${result.status ?? 'unknown'}`);
+        return false;
+    }
+    return true;
+}
+export function contentWatchPlugin(options = {}) {
+    const enabled = options.enabled ?? process.env.ACI_DISABLE_CONTENT_WATCH !== '1';
+    if (!enabled) {
+        return { name: 'content-watch-disabled', apply: 'serve' };
+    }
+    let timer;
+    let running = false;
+    let queued = false;
+    function rebuild(server, reason) {
+        if (running) {
+            queued = true;
+            return;
+        }
+        running = true;
+        const success = recompileContent(options, reason);
+        running = false;
+        if (success) {
+            if (server.moduleGraph) {
+                for (const mod of server.moduleGraph.idToModuleMap.values()) {
+                    server.moduleGraph.invalidateModule(mod);
+                }
+            }
+            server.ws.send({ type: 'full-reload' });
+        }
+        if (queued) {
+            queued = false;
+            rebuild(server, 'queued change');
+        }
+    }
+    return {
+        name: 'content-watch',
+        apply: 'serve',
+        configureServer(server) {
+            const src = sourceContentRoot(options);
+            const compiled = path.resolve(options.compiledRoot || process.env.ACI_CONTENT_ROOT || compiledContentRoot());
+            server.watcher.add(src);
+            server.watcher.add(compiled);
+            rebuild(server, 'startup');
+            server.watcher.on('all', (_event, filePath) => {
+                const changed = path.resolve(filePath);
+                const isSource = changed.startsWith(src + path.sep);
+                const isCompiled = changed.startsWith(compiled + path.sep);
+                if (!isSource && !isCompiled)
+                    return;
+                if (isCompiled) {
+                    server.ws.send({ type: 'full-reload' });
+                    return;
+                }
+                clearTimeout(timer);
+                timer = setTimeout(() => rebuild(server, path.relative(src, changed)), 100);
+            });
+        },
+    };
+}
+export function damAssetPlugin(options = {}) {
+    return {
+        name: 'dam-assets',
+        apply: 'serve',
+        configureServer(server) {
+            if (!server.middlewares)
+                return;
+            server.middlewares.use('/.gradial-dam', async (req, res, next) => {
+                const root = path.resolve(options.compiledRoot || compiledContentRoot());
+                const requestPath = safeRequestPath(req.url || '');
+                if (!requestPath) {
+                    res.statusCode = 404;
+                    res.end('asset not found');
+                    return;
+                }
+                const filePath = path.resolve(root, '.gradial-dam', requestPath.replace(/^\/+/, ''));
+                if (!isInside(root, filePath)) {
+                    res.statusCode = 404;
+                    res.end('asset not found');
+                    return;
+                }
+                try {
+                    const body = await fs.readFile(filePath);
+                    res.statusCode = 200;
+                    res.setHeader('Content-Type', contentType(filePath));
+                    res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+                    res.end(body);
+                }
+                catch {
+                    next();
+                }
+            });
+        },
+    };
+}
+function safeRequestPath(url) {
+    const rawPath = url.split('?')[0] || '';
+    try {
+        const decoded = decodeURIComponent(rawPath);
+        return decoded.startsWith('/.gradial-dam/') ? decoded.slice('/.gradial-dam/'.length) : decoded;
+    }
+    catch {
+        return '';
+    }
+}
+function isInside(root, filePath) {
+    const rel = path.relative(root, filePath);
+    return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+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';
+        default:
+            return 'application/octet-stream';
+    }
+}

package/dist/dev/index.d.ts

@@ -1,48 +1,29 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { type DevRefreshOptions } from './browser.js';
-export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, type DevRefreshOptions } from './browser.js';
+export type DevRefreshMessage = {
+    type: 'connected';
+    siteId?: string;
+} | {
+    type: 'compile-started';
+    reason?: string;
+} | {
+    type: 'compile-succeeded';
+    releaseId?: string;
+} | {
+    type: 'compile-failed';
+    errors?: string[];
+} | {
+    type: 'content-updated';
+    releaseId?: string;
+};
+interface DevRefreshScriptOptions {
+    wsPort?: number | string;
+    path?: string;
+    reconnectMs?: number;
+}
 declare global {
     interface Window {
         __gradialDevRefresh?: boolean;
     }
 }
-export interface GradialContentWatchOptions extends DevRefreshOptions {
-    /** Source content root to watch. Defaults to ACI_CONTENT_SOURCE env or '.content' */
-    contentRoot?: string;
-    /** Compiled content output root. Defaults to ACI_CONTENT_ROOT env or '.aci/compiled' */
-    compiledRoot?: string;
-    /** Path to the ACI CLI binary. Defaults to ACI_BIN env or 'aci' */
-    aciBin?: string;
-    /** Disable content watching entirely. Defaults to ACI_DISABLE_CONTENT_WATCH env */
-    enabled?: boolean;
-}
-interface ViteModuleGraph {
-    idToModuleMap: Map<unknown, {
-        id: string | null;
-    }>;
-    invalidateModule(mod: unknown): void;
-}
-interface ViteDevServerLike {
-    middlewares?: {
-        use(path: string, handler: (req: IncomingMessage, res: ServerResponse, next: () => void) => void): void;
-    };
-    watcher: {
-        add(path: string): void;
-        on(event: string, callback: (eventName: string, filePath: string) => void): void;
-    };
-    ws: {
-        send(payload: unknown): void;
-    };
-    moduleGraph?: ViteModuleGraph;
-}
-export interface VitePluginLike {
-    name: string;
-    apply?: 'serve' | 'build';
-    configureServer?(server: ViteDevServerLike): void;
-    transformIndexHtml?(html: string): string;
-}
-export declare function devRefreshPort(options?: DevRefreshOptions): number;
-export declare function devRefreshScript(options?: DevRefreshOptions): string;
-export declare function devRefreshScriptTag(options?: DevRefreshOptions): string;
-export declare function gradialContentWatchPlugin(options?: GradialContentWatchOptions): VitePluginLike;
-export declare function gradialDamAssetPlugin(options?: GradialContentWatchOptions): VitePluginLike;
+export declare function createDevRefreshBrowserScript(options?: DevRefreshScriptOptions): string;
+export declare function createDevRefreshScriptTag(options?: DevRefreshScriptOptions): string;
+export {};

package/dist/dev/index.js

@@ -1,9 +1,4 @@
-import fs from 'node:fs/promises';
-import { spawnSync } from 'node:child_process';
-import path from 'node:path';
-import { compiledContentRoot } from '../content/routes.js';
 import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from './browser.js';
-export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT } from './browser.js';
 function numberOption(value, fallback) {
     if (value === undefined || value === '') {
         return fallback;
@@ -11,14 +6,14 @@ function numberOption(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
-export function devRefreshPort(options = {}) {
+function devRefreshPort(options = {}) {
     const value = options.wsPort ?? process.env.ACI_DEV_WS_PORT;
     if (value === 0 || value === '0') {
         return 0;
     }
     return numberOption(value, DEFAULT_DEV_REFRESH_PORT);
 }
-export function devRefreshScript(options = {}) {
+export function createDevRefreshBrowserScript(options = {}) {
     const wsPort = devRefreshPort(options);
     if (wsPort <= 0) {
         return '';
@@ -46,166 +41,6 @@ export function devRefreshScript(options = {}) {
   connect();
 })();`;
 }
-export function devRefreshScriptTag(options = {}) {
-    return `<script>${devRefreshScript(options)}</script>`;
-}
-function sourceContentRoot(options) {
-    return path.resolve(options.contentRoot ||
-        process.env.ACI_CONTENT_SOURCE ||
-        './.content');
-}
-function resolveAciBin(options) {
-    return options.aciBin || process.env.ACI_BIN || 'aci';
-}
-function recompileContent(options, reason) {
-    const siteDir = process.cwd();
-    const src = sourceContentRoot(options);
-    const out = path.resolve(options.compiledRoot ||
-        process.env.ACI_CONTENT_ROOT ||
-        '.aci/compiled');
-    const bin = resolveAciBin(options);
-    console.log(`[aci] compiling content (${reason})`);
-    const result = spawnSync(bin, [
-        '-s', siteDir,
-        'build',
-        '--content', src,
-        '--out', out,
-        '--skip-code',
-    ], {
-        cwd: siteDir,
-        stdio: 'inherit',
-        env: process.env,
-    });
-    if (result.status !== 0) {
-        console.error(`[aci] content compile failed with exit code ${result.status ?? 'unknown'}`);
-        return false;
-    }
-    return true;
-}
-export function gradialContentWatchPlugin(options = {}) {
-    const enabled = options.enabled ?? process.env.ACI_DISABLE_CONTENT_WATCH !== '1';
-    if (!enabled) {
-        return {
-            name: 'gradial-content-watch-disabled',
-            apply: 'serve',
-        };
-    }
-    let timer;
-    let running = false;
-    let queued = false;
-    function rebuild(server, reason) {
-        if (running) {
-            queued = true;
-            return;
-        }
-        running = true;
-        const success = recompileContent(options, reason);
-        running = false;
-        if (success) {
-            if (server.moduleGraph) {
-                for (const mod of server.moduleGraph.idToModuleMap.values()) {
-                    server.moduleGraph.invalidateModule(mod);
-                }
-            }
-            server.ws.send({ type: 'full-reload' });
-        }
-        if (queued) {
-            queued = false;
-            rebuild(server, 'queued change');
-        }
-    }
-    return {
-        name: 'gradial-content-watch',
-        apply: 'serve',
-        configureServer(server) {
-            const src = sourceContentRoot(options);
-            const compiled = path.resolve(options.compiledRoot ||
-                process.env.ACI_CONTENT_ROOT ||
-                compiledContentRoot());
-            server.watcher.add(src);
-            server.watcher.add(compiled);
-            rebuild(server, 'startup');
-            server.watcher.on('all', (_event, filePath) => {
-                const changed = path.resolve(filePath);
-                const isSource = changed.startsWith(src + path.sep);
-                const isCompiled = changed.startsWith(compiled + path.sep);
-                if (!isSource && !isCompiled)
-                    return;
-                if (isCompiled) {
-                    server.ws.send({ type: 'full-reload' });
-                    return;
-                }
-                clearTimeout(timer);
-                timer = setTimeout(() => {
-                    const relative = path.relative(src, changed);
-                    rebuild(server, relative);
-                }, 100);
-            });
-        },
-    };
-}
-export function gradialDamAssetPlugin(options = {}) {
-    return {
-        name: 'gradial-dam-assets',
-        apply: 'serve',
-        configureServer(server) {
-            if (!server.middlewares) {
-                return;
-            }
-            server.middlewares.use('/.gradial-dam', async (req, res, next) => {
-                const root = path.resolve(options.compiledRoot || compiledContentRoot());
-                const requestPath = safeRequestPath(req.url || '');
-                if (!requestPath) {
-                    res.statusCode = 404;
-                    res.end('asset not found');
-                    return;
-                }
-                const filePath = path.resolve(root, '.gradial-dam', requestPath.replace(/^\/+/, ''));
-                if (!isInside(root, filePath)) {
-                    res.statusCode = 404;
-                    res.end('asset not found');
-                    return;
-                }
-                try {
-                    const body = await fs.readFile(filePath);
-                    res.statusCode = 200;
-                    res.setHeader('Content-Type', contentType(filePath));
-                    res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
-                    res.end(body);
-                }
-                catch {
-                    next();
-                }
-            });
-        },
-    };
-}
-function safeRequestPath(url) {
-    const rawPath = url.split('?')[0] || '';
-    try {
-        const decoded = decodeURIComponent(rawPath);
-        return decoded.startsWith('/.gradial-dam/') ? decoded.slice('/.gradial-dam/'.length) : decoded;
-    }
-    catch {
-        return '';
-    }
-}
-function isInside(root, filePath) {
-    const rel = path.relative(root, filePath);
-    return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
-}
-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';
-        default:
-            return 'application/octet-stream';
-    }
+export function createDevRefreshScriptTag(options = {}) {
+    return `<script>${createDevRefreshBrowserScript(options)}</script>`;
 }

package/dist/index.d.ts

@@ -1,5 +1,14 @@
-export * from './block-ref.js';
-export * from './define-component.js';
-export * from './define-data-model.js';
-export * from './define-layout.js';
-export * from './types/index.js';
+export { defineComponentContract } from './define-component.js';
+export { defineLayoutContract, slot, fragmentDefault } from './define-layout.js';
+export { createRegistry, registryLookup } from './registry.js';
+export type { Registry, RegistryEntry, AnyComponent } from './registry.js';
+export { blockRef, blockRefArray } from './types/block-ref.js';
+export type { BlockRef, BlockRefEntry, BlockRefMeta, BlockRefUnion } from './types/block-ref.js';
+export type { ComponentContract, ComponentContractID, ComponentContractValidator, ComponentRegistry, ComponentValidationContext, ComponentValidationIssue, InferComponentProps, } from './types/component.js';
+export { ImageSchema, imageAttrs, primaryImageSource, type Image, type ImageSource, type ImageAttrs, type ImageSlotContract, type SlotOutput, } from './types/image.js';
+export { LinkSchema, type Link, type LinkTarget, type LinkResolverContext, resolveLink, resolveHref, assertSafeHref, normalizeLinkRel, } from './types/link.js';
+export { HeadingSchema, InlineContentSchema, RichTextValueSchema, type Heading, type InlineContent, type RichTextValue, } from './types/rich-text.js';
+export type { Config, RouteConfig, ExternalDependency, DAMConfig, } from './types/config.js';
+export type { Renderer, RenderCapabilities, RenderPageRequest, RenderPageResult, RequestContext, ReleaseContext, RenderFragmentRequest, RenderIslandRequest, RenderResult, IslandDescriptor, CachePolicy, GeoContext, } from './types/renderer.js';
+export type { Asset, } from './types/media.js';
+export { AssetSchema, isImage, isAsset, } from './types/media.js';

package/dist/index.js

@@ -1,8 +1,8 @@
-export * from './block-ref.js';
-export * from './define-component.js';
-export * from './define-data-model.js';
-export * from './define-layout.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
-// content utilities from '@gradial/aci/content' explicitly.
+export { defineComponentContract } from './define-component.js';
+export { defineLayoutContract, slot, fragmentDefault } from './define-layout.js';
+export { createRegistry, registryLookup } from './registry.js';
+export { blockRef, blockRefArray } from './types/block-ref.js';
+export { ImageSchema, imageAttrs, primaryImageSource, } from './types/image.js';
+export { LinkSchema, resolveLink, resolveHref, assertSafeHref, normalizeLinkRel, } from './types/link.js';
+export { HeadingSchema, InlineContentSchema, RichTextValueSchema, } from './types/rich-text.js';
+export { AssetSchema, isImage, isAsset, } from './types/media.js';

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,13 +1,21 @@
-import { getReleaseAssetResponse } from './server.js';
+import { FileContentProvider } from '../providers/file.js';
+import { getReleaseAssetResponse } from '../content/assets.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);
+        return await getReleaseAssetResponse({ releaseId, assetPath });
     }
     catch {
         return new Response('asset not found', { status: 404 });

package/dist/next/config.d.ts

@@ -1,6 +1,6 @@
 import type { NextConfig } from 'next';
-export interface WithGradialOptions {
+export interface WithAciOptions {
     /** Asset rewrite prefix. Defaults to '/.gradial-dam' */
     assetPrefix?: string;
 }
-export declare function withGradialAci(nextConfig?: NextConfig, options?: WithGradialOptions): NextConfig;
+export declare function withAci(nextConfig?: NextConfig, options?: WithAciOptions): NextConfig;