@gradial/aci 0.1.52-rc.2 → 0.1.52-rc.22

package/dist/mintlify/validate.js

@@ -0,0 +1,252 @@
+import { validateBlock, validateSnippetReferences } from './blocks.js';
+import { cleanDocumentPath, cleanFilePath, isExternalReference, isMintlifyJSONValue, isObject, nonEmptyString, } from './json.js';
+const CONFIG_FRAGMENT_SCHEMA_VERSION = 1;
+const API_SPEC_SCHEMA_VERSION = 1;
+export function validateSource(site, documents, snippets, apiSpecs) {
+    const paths = new Set();
+    for (const document of documents) {
+        if (paths.has(document.path))
+            throw new Error(`ACI Mintlify document path is duplicated: ${document.path}`);
+        paths.add(document.path);
+    }
+    const navigated = new Set();
+    const navigation = isObject(site) ? site.navigation : undefined;
+    validateNavigationPartitions(navigation);
+    for (const page of navigationPages(navigation)) {
+        // Links are valid Mintlify navigation items but are not ACI documents.
+        if (isExternalReference(page))
+            continue;
+        const normalized = cleanDocumentPath(page);
+        if (!normalized || normalized !== page)
+            throw new Error(`ACI Mintlify navigation page is invalid: ${page}`);
+        if (!paths.has(page))
+            throw new Error(`ACI Mintlify navigation references missing document: ${page}`);
+        if (navigated.has(page))
+            throw new Error(`ACI Mintlify navigation references document more than once: ${page}`);
+        navigated.add(page);
+    }
+    validateRedirects(isObject(site) ? site.redirects : undefined, paths);
+    validateSnippetReferences(documents, snippets);
+    validateAPISpecReferences(site, apiSpecs);
+}
+export function validateSite(value, label) {
+    if (!isObject(value) || !isMintlifyJSONValue(value)) {
+        throw new Error(`ACI Mintlify site is invalid: ${label}`);
+    }
+    if ('$schema' in value && value.$schema !== 'https://mintlify.com/docs.json') {
+        throw new Error(`ACI Mintlify site has an unsupported docs schema: ${label}`);
+    }
+    return value;
+}
+export function validateDocument(value, label, sourcePath) {
+    const metadata = isObject(value) && isObject(value.metadata) ? value.metadata : undefined;
+    const regions = isObject(value) && isObject(value.regions) ? value.regions : undefined;
+    if (!isObject(value) || value.$type !== 'page' || !nonEmptyString(value.id) || !nonEmptyString(value.status) || !nonEmptyString(value.layout) || !nonEmptyString(sourcePath) || !metadata || !nonEmptyString(metadata.title) || !regions || !Array.isArray(regions.main)) {
+        throw new Error(`ACI Mintlify document is invalid: ${label}`);
+    }
+    const documentPath = cleanDocumentPath(sourcePath);
+    if (!documentPath || documentPath !== sourcePath)
+        throw new Error(`ACI Mintlify document path is invalid: ${sourcePath}`);
+    const ids = new Set();
+    const blocks = regions.main.map((block, index) => validateBlock(block, `${label}.regions.main[${index}]`, ids));
+    const renderer = isObject(metadata.mintlify) ? metadata.mintlify : {};
+    return {
+        $type: 'page', id: value.id, status: value.status, layout: value.layout, path: documentPath,
+        metadata: { title: metadata.title,
+            ...(nonEmptyString(metadata.description) ? { description: metadata.description } : {}),
+            mintlify: {
+                ...(nonEmptyString(renderer.sidebarTitle) ? { sidebarTitle: renderer.sidebarTitle } : {}),
+                ...(nonEmptyString(renderer.icon) ? { icon: renderer.icon } : {}),
+                ...(validFrontmatter(renderer.frontmatter) ? { frontmatter: renderer.frontmatter } : {}),
+            },
+        }, regions: { main: blocks },
+    };
+}
+export function validateSnippet(value, label, sourcePath) {
+    if (!isObject(value) || value.$type !== 'fragment' || !nonEmptyString(value.id) || !nonEmptyString(sourcePath) || !isObject(value.block)) {
+        throw new Error(`ACI Mintlify snippet is invalid: ${label}`);
+    }
+    const snippetPath = cleanFilePath(sourcePath, '.mdx');
+    if (!snippetPath || snippetPath !== sourcePath)
+        throw new Error(`ACI Mintlify snippet path is invalid: ${sourcePath}`);
+    const ids = new Set();
+    return {
+        $type: 'fragment', id: value.id,
+        path: snippetPath, block: validateBlock(value.block, `${label}.block`, ids),
+    };
+}
+export function validateConfigFragment(value, label) {
+    if (!isObject(value) || value.$type !== 'mintlify.config-fragment' || value.schemaVersion !== CONFIG_FRAGMENT_SCHEMA_VERSION || !nonEmptyString(value.path) || !isMintlifyJSONValue(value.value)) {
+        throw new Error(`ACI Mintlify config fragment is invalid: ${label}`);
+    }
+    const fragmentPath = cleanFilePath(value.path, '.json');
+    if (!fragmentPath || fragmentPath !== value.path || fragmentPath === 'docs.json')
+        throw new Error(`ACI Mintlify config fragment path is invalid: ${value.path}`);
+    return { $type: 'mintlify.config-fragment', schemaVersion: CONFIG_FRAGMENT_SCHEMA_VERSION, path: fragmentPath, value: value.value };
+}
+export function validateAPISpec(value, label) {
+    if (!isObject(value) || value.$type !== 'mintlify.api-spec' || value.schemaVersion !== API_SPEC_SCHEMA_VERSION || !nonEmptyString(value.path) || !['openapi', 'asyncapi', 'graphql'].includes(String(value.format)) || !nonEmptyString(value.source)) {
+        throw new Error(`ACI Mintlify API specification is invalid: ${label}`);
+    }
+    const sourcePath = value.path;
+    const extensions = value.format === 'graphql' ? ['.graphql', '.gql', '.json'] : ['.json', '.yaml', '.yml'];
+    const specPath = extensions.map((extension) => cleanFilePath(sourcePath, extension)).find(Boolean) ?? '';
+    if (!specPath || specPath !== sourcePath)
+        throw new Error(`ACI Mintlify API specification path is invalid: ${sourcePath}`);
+    return {
+        $type: 'mintlify.api-spec',
+        schemaVersion: API_SPEC_SCHEMA_VERSION,
+        path: specPath,
+        format: value.format,
+        source: value.source,
+    };
+}
+function validFrontmatter(value) {
+    if (value === undefined)
+        return false;
+    if (!isObject(value))
+        throw new Error('ACI Mintlify document frontmatter is invalid');
+    for (const [key, entry] of Object.entries(value)) {
+        if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(key) || !isMintlifyJSONValue(entry)) {
+            throw new Error('ACI Mintlify document frontmatter is invalid');
+        }
+        if (['title', 'description', 'sidebarTitle', 'icon'].includes(key))
+            throw new Error(`ACI Mintlify document frontmatter key is reserved: ${key}`);
+    }
+    return true;
+}
+function validateRedirects(value, documentPaths) {
+    if (value === undefined)
+        return;
+    if (!Array.isArray(value))
+        throw new Error('ACI Mintlify redirects are invalid');
+    const redirects = new Map();
+    const routes = new Set([...documentPaths].map((documentPath) => `/${documentPath}`));
+    for (const entry of value) {
+        if (!isObject(entry) || !nonEmptyString(entry.source) || !nonEmptyString(entry.destination) || (entry.permanent !== undefined && typeof entry.permanent !== 'boolean')) {
+            throw new Error('ACI Mintlify redirect is invalid');
+        }
+        if (!entry.source.startsWith('/') || entry.source.includes('?') || entry.source.includes('#')) {
+            throw new Error(`ACI Mintlify redirect source is invalid: ${entry.source}`);
+        }
+        if (!entry.destination.startsWith('/') && !isExternalReference(entry.destination)) {
+            throw new Error(`ACI Mintlify redirect destination is invalid: ${entry.destination}`);
+        }
+        if (redirects.has(entry.source))
+            throw new Error(`ACI Mintlify redirect source is duplicated: ${entry.source}`);
+        if (!entry.source.includes('*') && !entry.source.includes(':') && routes.has(trimRouteSlash(entry.source))) {
+            throw new Error(`ACI Mintlify redirect source collides with a document: ${entry.source}`);
+        }
+        redirects.set(entry.source, entry.destination);
+    }
+    for (const [source, destination] of redirects) {
+        if (isExternalReference(destination) || destination.includes('*') || destination.includes(':'))
+            continue;
+        const destinationPath = trimRouteSlash(destination.split(/[?#]/, 1)[0]);
+        if (!routes.has(destinationPath) && !redirects.has(destinationPath)) {
+            throw new Error(`ACI Mintlify redirect destination is missing: ${destination}`);
+        }
+        const seen = new Set([source]);
+        let next = destinationPath;
+        while (redirects.has(next)) {
+            if (seen.has(next))
+                throw new Error(`ACI Mintlify redirect cycle includes: ${next}`);
+            seen.add(next);
+            const target = redirects.get(next);
+            if (isExternalReference(target) || target.includes('*') || target.includes(':'))
+                break;
+            next = trimRouteSlash(target.split(/[?#]/, 1)[0]);
+        }
+    }
+}
+function trimRouteSlash(value) {
+    return value.length > 1 ? value.replace(/\/+$/, '') : value;
+}
+function validateAPISpecReferences(site, specs) {
+    const byPath = new Map();
+    for (const spec of specs) {
+        if (byPath.has(spec.path))
+            throw new Error(`ACI Mintlify API specification path is duplicated: ${spec.path}`);
+        byPath.set(spec.path, spec);
+    }
+    const visit = (value) => {
+        if (Array.isArray(value)) {
+            for (const child of value)
+                visit(child);
+            return;
+        }
+        if (!isObject(value))
+            return;
+        for (const [key, child] of Object.entries(value)) {
+            if (['openapi', 'asyncapi', 'graphql'].includes(key)) {
+                const references = typeof child === 'string' ? [child] : Array.isArray(child) ? child.filter((entry) => typeof entry === 'string') : [];
+                for (const reference of references) {
+                    if (isExternalReference(reference))
+                        continue;
+                    const spec = byPath.get(reference);
+                    if (!spec || spec.format !== key)
+                        throw new Error(`ACI Mintlify API specification reference is missing or has the wrong format: ${reference}`);
+                }
+            }
+            visit(child);
+        }
+    };
+    visit(site);
+}
+function navigationPages(value) {
+    if (!isObject(value))
+        return [];
+    const pages = [];
+    visitNavigation(value, pages);
+    return pages;
+}
+function visitNavigation(value, pages) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            visitNavigation(item, pages);
+        return;
+    }
+    if (!isObject(value))
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === 'pages' && Array.isArray(child)) {
+            for (const item of child) {
+                if (typeof item === 'string')
+                    pages.push(item);
+                else
+                    visitNavigation(item, pages);
+            }
+            continue;
+        }
+        visitNavigation(child, pages);
+    }
+}
+function validateNavigationPartitions(value) {
+    if (Array.isArray(value)) {
+        for (const child of value)
+            validateNavigationPartitions(child);
+        return;
+    }
+    if (!isObject(value))
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if ((key === 'languages' || key === 'versions') && Array.isArray(child)) {
+            const identityKey = key === 'languages' ? 'language' : 'version';
+            const identities = new Set();
+            let defaults = 0;
+            for (const entry of child) {
+                if (!isObject(entry) || !nonEmptyString(entry[identityKey]))
+                    throw new Error(`ACI Mintlify ${key} navigation is invalid`);
+                const identity = entry[identityKey];
+                if (identities.has(identity))
+                    throw new Error(`ACI Mintlify ${key} navigation is duplicated: ${identity}`);
+                identities.add(identity);
+                if (entry.default === true)
+                    defaults += 1;
+            }
+            if (defaults > 1)
+                throw new Error(`ACI Mintlify navigation has multiple default ${key}`);
+        }
+        validateNavigationPartitions(child);
+    }
+}

package/dist/next/error-seat-payload.js

@@ -104,7 +104,7 @@ export function buildErrorSeatPayload(contentRoot, posture) {
                 if (!fragmentRef)
                     continue;
                 const fragment = readJSON(root, fragmentRef);
-                blocks.push({ id: fragment.id, component: fragment.component, props: fragment.props || {} });
+                blocks.push({ $type: 'component', id: fragment.id, component: fragment.component, props: fragment.props || {} });
             }
             if (blocks.length)
                 slots[slot.name] = blocks;

package/dist/next/hosted-page-target.d.ts

@@ -0,0 +1,7 @@
+export type HostedPageTarget = Readonly<{
+    kind: 'base' | 'variant';
+    route: string;
+    pageRef: string;
+    variantKey?: string;
+}>;
+export declare function parseHostedPageTarget(rawSegments: readonly string[]): HostedPageTarget | null;

package/dist/next/hosted-page-target.js

@@ -0,0 +1,39 @@
+const VARIANT_NAMESPACE = '__variant';
+export function parseHostedPageTarget(rawSegments) {
+    const segments = decodeSegments(rawSegments);
+    if (!segments)
+        return null;
+    const variantAt = segments.indexOf(VARIANT_NAMESPACE);
+    if (variantAt < 0)
+        return target('base', segments, segments);
+    if (variantAt !== segments.lastIndexOf(VARIANT_NAMESPACE) || variantAt !== segments.length - 2) {
+        return null;
+    }
+    return {
+        ...target('variant', segments.slice(0, variantAt), segments),
+        variantKey: segments[variantAt + 1],
+    };
+}
+function target(kind, routeSegments, targetSegments) {
+    return {
+        kind,
+        route: routeSegments.length === 0 ? '/' : `/${routeSegments.join('/')}/`,
+        pageRef: ['routes', ...targetSegments, 'index.json'].join('/'),
+    };
+}
+function decodeSegments(rawSegments) {
+    const segments = [];
+    for (const raw of rawSegments) {
+        let segment;
+        try {
+            segment = decodeURIComponent(raw);
+        }
+        catch {
+            return null;
+        }
+        if (!segment || segment === '.' || segment === '..' || segment.includes('/'))
+            return null;
+        segments.push(segment);
+    }
+    return segments;
+}

package/dist/next/index.d.ts

@@ -5,7 +5,6 @@ export { createPage, type CreatePageOptions, type SlotPropsFn } from './page.js'
 export { getSiteConfig, getFragment, getLayout, getPage, getRenderInput, routeFromNextParams } from './server.js';
 export { PageNotFoundError, FragmentNotFoundError, LayoutNotFoundError } from './server.js';
 export { CollectScript, type CollectScriptProps } from './collect-script.js';
-export { aciMiddlewareMatcher } from './middleware.js';
 export { AssignmentsScript, type AssignmentsScriptProps } from './assignments-script.js';
 export { createNotFound, renderPageForRoute, resolveErrorPage, type NextResolvedErrorPage, } from './error-pages.js';
 export { ErrorPageInstrumentation } from './error-page-instrumentation.js';

package/dist/next/index.js

@@ -5,7 +5,6 @@ export { createPage } from './page.js';
 export { getSiteConfig, getFragment, getLayout, getPage, getRenderInput, routeFromNextParams } from './server.js';
 export { PageNotFoundError, FragmentNotFoundError, LayoutNotFoundError } from './server.js';
 export { CollectScript } from './collect-script.js';
-export { aciMiddlewareMatcher } from './middleware.js';
 export { AssignmentsScript } from './assignments-script.js';
 export { createNotFound, renderPageForRoute, resolveErrorPage, } from './error-pages.js';
 export { ErrorPageInstrumentation } from './error-page-instrumentation.js';

package/dist/next/page.d.ts

@@ -31,12 +31,10 @@ export interface CreatePageOptions {
  * the collect script tag exactly once per page (design/04 contract tag).
  *
  * Release-scoped routes (production): the middleware rewrites a public URL
- * to `/__r/{releaseId}/routes/{path}`. The optional catch-all `[[...slug]]`
- * receives `['__r', releaseId, 'routes', ...pathSegments]`. createPage
- * extracts the releaseId and passes it to the content loader, giving
- * each release a unique CDN cache key without a separate route folder.
- * The `routes` namespace segment leaves room for future siblings under
- * the release prefix (e.g. `/__r/{releaseId}/assets/*`).
+ * to `/__r/{releaseId}/{targetRef}`. The target ref selects the exact immutable
+ * base or variant page while its prefix identifies the logical public route.
+ * createPage passes both identities to the content loader, giving each target
+ * a distinct CDN cache key without sending selection headers into Next.
  *
  * Dev pass-through (ACI_CONTENT_PROVIDER=file): the middleware passes
  * requests through unrewritten, so `/` arrives with an empty/undefined
@@ -54,4 +52,29 @@ export declare function createPage(registry: Registry, options?: CreatePageOptio
     generateMetadata: ({ params }: NextPageProps) => Promise<Metadata>;
     default: ({ params }: NextPageProps) => Promise<import("react").JSX.Element>;
 };
+/**
+ * Resolves the logical route and releaseId from Next.js catch-all params.
+ *
+ * Two shapes are supported:
+ *
+ * 1. **Rewritten (production):** middleware rewrites a public URL to the exact
+ *    selected target under `/__r/{releaseId}`. A root variant therefore has
+ *    `['__r', releaseId, '__variant', variantKey]`. The full suffix selects the
+ *    immutable page object; the segments before the reserved `__variant`
+ *    namespace form the logical public route.
+ *
+ * 2. **Dev pass-through (ACI_CONTENT_PROVIDER=file):** middleware passes
+ *    requests through unrewritten, so the slug is the raw public path
+ *    segments (possibly empty/undefined for `/`). No releaseId is present;
+ *    the file provider serves content from disk.
+ */
+export declare function resolveRouteAndRelease(params: Promise<{
+    slug?: string[];
+}> | {
+    slug?: string[];
+}): Promise<{
+    route: string;
+    releaseId?: string;
+    pageRef?: string;
+}>;
 export {};

package/dist/next/page.js

@@ -1,12 +1,15 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { notFound } from 'next/navigation.js';
+import { headers } from 'next/headers.js';
 import { Fragment } from 'react';
 import { PageNotFoundError, getRenderInput, getLayout, getFragment, } from './server.js';
+import { MIMIC_BANNER_HEADER, decodeMimicBanner } from '../mimic/core.js';
 import { routeMetadataForContent, resolveSlots, } from '../content/index.js';
 import { renderBlocks } from './render.js';
 import { AssignmentsScript } from './assignments-script.js';
 import { CollectScript } from './collect-script.js';
 import { renderProofContentFor } from '../internal/render-proof.js';
+import { parseHostedPageTarget } from './hosted-page-target.js';
 /**
  * Creates the catch-all route handler for a Next.js ACI site.
  *
@@ -28,12 +31,10 @@ import { renderProofContentFor } from '../internal/render-proof.js';
  * the collect script tag exactly once per page (design/04 contract tag).
  *
  * Release-scoped routes (production): the middleware rewrites a public URL
- * to `/__r/{releaseId}/routes/{path}`. The optional catch-all `[[...slug]]`
- * receives `['__r', releaseId, 'routes', ...pathSegments]`. createPage
- * extracts the releaseId and passes it to the content loader, giving
- * each release a unique CDN cache key without a separate route folder.
- * The `routes` namespace segment leaves room for future siblings under
- * the release prefix (e.g. `/__r/{releaseId}/assets/*`).
+ * to `/__r/{releaseId}/{targetRef}`. The target ref selects the exact immutable
+ * base or variant page while its prefix identifies the logical public route.
+ * createPage passes both identities to the content loader, giving each target
+ * a distinct CDN cache key without sending selection headers into Next.
  *
  * Dev pass-through (ACI_CONTENT_PROVIDER=file): the middleware passes
  * requests through unrewritten, so `/` arrives with an empty/undefined
@@ -49,8 +50,9 @@ import { renderProofContentFor } from '../internal/render-proof.js';
 export function createPage(registry, options) {
     const dynamic = 'force-dynamic';
     async function generateMetadata({ params }) {
-        const { route, releaseId } = await resolveRouteAndRelease(params);
-        const input = await getRenderInput(route, { releaseId });
+        const { route, releaseId, pageRef } = await resolveRouteAndRelease(params);
+        const fetchConfig = { releaseId, pageRef };
+        const input = await getRenderInput(route, fetchConfig);
         const meta = routeMetadataForContent(input.siteConfig, input.page);
         return {
             title: meta.title,
@@ -64,8 +66,8 @@ export function createPage(registry, options) {
         };
     }
     async function CatchAllPage({ params }) {
-        const { route, releaseId } = await resolveRouteAndRelease(params);
-        const fetchConfig = { releaseId };
+        const { route, releaseId, pageRef } = await resolveRouteAndRelease(params);
+        const fetchConfig = { releaseId, pageRef };
         try {
             const input = await getRenderInput(route, fetchConfig);
             if (!input.page)
@@ -84,9 +86,9 @@ export function createPage(registry, options) {
                 }
                 return (_jsx(Fragment, { children: renderedBlocks }, slot.name));
             }));
-            return (_jsxs(_Fragment, { children: [renderProofContent
+            return (_jsxs(_Fragment, { children: [renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig }), _jsx(MimicBanner, { html: await readMimicBannerHTML() }), renderProofContent
                         ? _jsx("meta", { name: "aci-render-proof", content: renderProofContent })
-                        : null, renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
+                        : null] }));
         }
         catch (error) {
             if (error instanceof PageNotFoundError)
@@ -105,19 +107,18 @@ export function createPage(registry, options) {
  *
  * Two shapes are supported:
  *
- * 1. **Rewritten (production):** middleware rewrites a public URL to
- *    `/__r/{releaseId}/routes/{path}`, so slug is
- *    `['__r', releaseId, 'routes', ...pathSegments]`. The releaseId is
- *    extracted; the remaining segments form the content route. The `routes`
- *    segment is the namespace for page routes (siblings like `assets/` live
- *    under the same release prefix).
+ * 1. **Rewritten (production):** middleware rewrites a public URL to the exact
+ *    selected target under `/__r/{releaseId}`. A root variant therefore has
+ *    `['__r', releaseId, '__variant', variantKey]`. The full suffix selects the
+ *    immutable page object; the segments before the reserved `__variant`
+ *    namespace form the logical public route.
  *
  * 2. **Dev pass-through (ACI_CONTENT_PROVIDER=file):** middleware passes
  *    requests through unrewritten, so the slug is the raw public path
  *    segments (possibly empty/undefined for `/`). No releaseId is present;
  *    the file provider serves content from disk.
  */
-async function resolveRouteAndRelease(params) {
+export async function resolveRouteAndRelease(params) {
     const resolved = await params;
     const slug = resolved.slug ?? [];
     if (slug.length >= 2 && slug[0] === '__r') {
@@ -125,13 +126,14 @@ async function resolveRouteAndRelease(params) {
         if (!releaseId || releaseId.includes('/') || releaseId === '.' || releaseId === '..') {
             return { route: '/' };
         }
-        // Skip the 'routes' namespace segment when present.
-        const rest = slug.length >= 3 && slug[2] === 'routes' ? slug.slice(3) : slug.slice(2);
-        if (rest.length === 0)
-            return { route: '/', releaseId };
-        if (rest.some((s) => s === '' || s === '.' || s === '..'))
+        const target = parseHostedPageTarget(slug.slice(2));
+        if (!target)
             return { route: '/' };
-        return { route: `/${rest.join('/')}/`, releaseId };
+        return {
+            route: target.route,
+            releaseId,
+            pageRef: target.pageRef,
+        };
     }
     const route = routeFromSlug(slug);
     return { route };
@@ -141,3 +143,23 @@ function routeFromSlug(slug) {
         return '/';
     return `/${slug.join('/')}/`;
 }
+// The middleware emits the banner HTML in a reserved request header only
+// after validating a signed mimic token; viewer-forged copies are stripped at
+// the dispatch gate (specs/features/audience-mimic REQ-4). The header read
+// happens here (the page already awaits request-scoped data) so the banner
+// itself stays a synchronous leaf.
+async function readMimicBannerHTML() {
+    try {
+        const current = await headers();
+        return decodeMimicBanner(current.get(MIMIC_BANNER_HEADER) || '');
+    }
+    catch {
+        // headers() has no request context in static generation and unit tests.
+        return '';
+    }
+}
+function MimicBanner({ html }) {
+    if (!html)
+        return null;
+    return _jsx("div", { dangerouslySetInnerHTML: { __html: html } });
+}

package/dist/next/server.js

@@ -1,14 +1,18 @@
 import { headers } from 'next/headers.js';
 import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '../content/provider.js';
+import { ObjectContentProvider } from '../providers/object.js';
 import { normalizeRoute } from '../content/routes.js';
 import { getCachedManifest, getCachedSiteConfig } from '../content/cache.js';
 import { S3ContentProvider } from '../providers/s3.js';
+import { VercelReleaseObjectReader } from '../providers/vercel-object-reader.js';
 import { GRADIAL_RENDER_INPUT_HEADER, getPendingRenderInput } from '../runtime/page.js';
 import { attachRenderProofReceipt, selectVerifiedPage, } from '../internal/render-proof.js';
 import { getUncachedEdgeConfigValue } from './edge-config.js';
 import { activeReleaseV1Key, clampDeploymentCompatibleReleaseV1, decodeActiveReleaseV1, decodeDeploymentCompatibilityV1, deploymentCompatibilityKey, } from './vercel-edge-projection-v1.js';
 export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
-const releaseObjectReaderSymbol = Symbol.for('aci.releaseObjectReader');
+const releaseObjectReaderSymbol = Symbol.for('@gradial/aci.release-object-reader');
+const objectProviders = new WeakMap();
+let vercelReleaseObjectReader;
 export function setReleaseObjectReader(reader) {
     const scope = globalThis;
     if (reader)
@@ -339,6 +343,29 @@ async function resolveS3Provider(config) {
 }
 async function resolveProviderWithFallback(config) {
     const injected = getInjectedReader();
+    const pageRef = config.pageRef;
+    const hostedReaderConfigured = injected || config.roleArn || process.env.AWS_ROLE_ARN;
+    if (pageRef && hostedReaderConfigured) {
+        const releaseId = config.releaseId || process.env.ACI_RELEASE_ID || 'test';
+        let provider = objectProviders.get(config);
+        if (!provider) {
+            if (!injected && !vercelReleaseObjectReader) {
+                vercelReleaseObjectReader = new VercelReleaseObjectReader({
+                    bucket: config.bucket,
+                    keyPrefix: config.keyPrefix,
+                    region: config.region,
+                    roleArn: config.roleArn,
+                    endpoint: config.endpoint,
+                });
+            }
+            const reader = injected || vercelReleaseObjectReader;
+            if (!reader)
+                throw new Error('ACI hosted page reader is unavailable');
+            provider = new ObjectContentProvider({ releaseId, pageRef, reader });
+            objectProviders.set(config, provider);
+        }
+        return provider;
+    }
     if (injected) {
         const releaseId = config.releaseId || process.env.ACI_RELEASE_ID || 'test';
         return new InjectedReaderProvider(releaseId, injected);

package/dist/next/vercel-edge-projection-v1.d.ts

@@ -1,7 +1,3 @@
-import type { EdgeRouteManifest } from './personalization-host.js';
-export declare const VERCEL_EDGE_PROJECTION_SCHEMA_V1 = "gradial.vercel.edgeRoutes.v1";
-export declare const VERCEL_EDGE_PROJECTION_ENCODING_V1 = "gzip+base64";
-export declare const MAX_VERCEL_EDGE_MANIFEST_BYTES_V1: number;
 export interface ActiveReleasePointerV1 {
     releaseId: string;
     sequence: bigint;
@@ -13,12 +9,7 @@ export interface DeploymentCompatibilityV1 {
     maxSequence?: bigint;
 }
 export declare function activeReleaseV1Key(siteId: string): string;
-export declare function edgeRoutesV1Key(siteId: string, releaseId: string): string;
 export declare function deploymentCompatibilityKey(siteId: string, deploymentId: string): string;
 export declare function decodeActiveReleaseV1(value: unknown): ActiveReleasePointerV1;
 export declare function decodeDeploymentCompatibilityV1(value: unknown): DeploymentCompatibilityV1;
 export declare function clampDeploymentCompatibleReleaseV1(active: ActiveReleasePointerV1, compatibility: DeploymentCompatibilityV1): string;
-export declare function decodeEdgeRouteProjectionV1(value: unknown, expected: {
-    siteId: string;
-    releaseId: string;
-}): EdgeRouteManifest;