@gradial/aci 0.1.48 → 0.1.51-ssr.2

package/dist/internal/platform/collectionstore/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class IdentityErasureFencedError extends Error {
+    readonly name = "IdentityErasureFencedError";
+    readonly code = "IDENTITY_ERASURE_FENCED";
+    constructor();
+}

package/dist/internal/platform/collectionstore/errors.js

@@ -0,0 +1,7 @@
+export class IdentityErasureFencedError extends Error {
+    name = 'IdentityErasureFencedError';
+    code = 'IDENTITY_ERASURE_FENCED';
+    constructor() {
+        super('identity collection is fenced by erasure');
+    }
+}

package/dist/next/config.d.ts

@@ -8,13 +8,5 @@ export interface WithAciOptions {
     assetOrigin?: string;
     /** Asset rewrite prefix. Defaults to '/.gradial-dam' */
     assetPrefix?: string;
-    /**
-     * Customer-owned routes that ACI middleware should leave to Next.
-     *
-     * Use exact paths such as '/healthz' or simple Next-style catch-alls such as
-     * '/checkout/:path*'. CMS document routes such as '/robots.txt' and
-     * '/sitemap.xml' should be omitted so they stay release-scoped.
-     */
-    passthroughRoutes?: string[];
 }
 export declare function withAci(nextConfig?: NextConfig, options?: WithAciOptions): NextConfig;

package/dist/next/config.js

@@ -1,5 +1,3 @@
-import { readdirSync, existsSync } from 'fs';
-import { join, relative } from 'path';
 import { createRequire } from 'module';
 import { createContentWatchWebpackPlugin } from './content-watch.js';
 import { buildErrorSeatPayload } from './error-seat-payload.js';
@@ -7,11 +5,10 @@ const require = createRequire(import.meta.url);
 export function withAci(nextConfig = {}, options = {}) {
     if (process.env.TURBOPACK) {
         throw new Error('withAci does not support Turbopack yet: ACI dev-mode content ' +
-            'compilation and the middleware route constants are wired through ' +
-            'the webpack() callback, which Turbopack never invokes. Run ' +
+            'compilation and build-time error-page payload are wired through the ' +
+            'webpack() callback, which Turbopack never invokes. Run ' +
             '`next dev` / `next build` without --turbopack.');
     }
-    const publicPaths = collectPublicPaths(join(process.cwd(), 'public'));
     // Authorable error pages (D-9): the Next error seat is client-only, so the
     // bound catchAll page's content is serialized here — while next.config is
     // evaluated — and injected into the bundle via DefinePlugin below. The D-5
@@ -27,32 +24,15 @@ export function withAci(nextConfig = {}, options = {}) {
     for (const warning of errorSeat.warnings) {
         console.warn(`\n[aci error-pages] WARNING: ${warning}\n`);
     }
-    const passthroughRoutes = normalizePassthroughRoutes(options.passthroughRoutes ?? []);
     const assetPrefix = options.assetPrefix || '/.gradial-dam';
     const assetOrigin = options.assetOrigin || '';
     const userRewrites = nextConfig.rewrites;
-    const userHeaders = nextConfig.headers;
     const userWebpack = nextConfig.webpack;
     return {
         ...nextConfig,
         output: 'standalone',
         outputFileTracingRoot: nextConfig.outputFileTracingRoot ?? process.cwd(),
-        headers: async () => {
-            const gradialHeaders = [
-                {
-                    source: '/__r/:releaseId/:path*',
-                    headers: [
-                        { key: 'Cache-Control', value: 'public, max-age=0, must-revalidate' },
-                        { key: 'CDN-Cache-Control', value: 'max-age=31536000' },
-                        { key: 'Vercel-CDN-Cache-Control', value: 'max-age=31536000' },
-                    ],
-                },
-            ];
-            if (!userHeaders)
-                return gradialHeaders;
-            const userResult = await (typeof userHeaders === 'function' ? userHeaders() : userHeaders);
-            return [...gradialHeaders, ...userResult];
-        },
+        headers: nextConfig.headers,
         rewrites: async () => {
             const rewrites = [];
             if (assetOrigin) {
@@ -61,21 +41,6 @@ export function withAci(nextConfig = {}, options = {}) {
                     destination: `${assetOrigin}${assetPrefix}/:path*`,
                 });
             }
-            else {
-                // Without an external asset origin (the deliberate CDN override),
-                // DAM requests must be served by the app itself: on Vercel nothing
-                // else maps `/.gradial-dam/*` to the hosting bucket. Route them to
-                // the asset handler, which serves DAM keys from the bucket root.
-                rewrites.push({
-                    source: `${assetPrefix}/:path*`,
-                    destination: `/gradial/assets/${assetPrefix.replace(/^\/+/, '')}/:path*`,
-                });
-            }
-            // CMS document rewrites: robots.txt and sitemap.xml are release-scoped
-            // artifacts served via the asset route handler (#40). The middleware
-            // passes them through (CMS_DOCUMENT_PATHS) so these rewrites fire and
-            // route to the asset handler which resolves the active release.
-            rewrites.push({ source: '/robots.txt', destination: '/gradial/assets/robots.txt' }, { source: '/sitemap.xml', destination: '/gradial/assets/sitemap.xml' });
             if (!userRewrites)
                 return rewrites;
             const userResult = await (typeof userRewrites === 'function' ? userRewrites() : userRewrites);
@@ -95,9 +60,6 @@ export function withAci(nextConfig = {}, options = {}) {
             }
             const webpack = require('webpack');
             config.plugins.push(new webpack.DefinePlugin({
-                '__ACI_PUBLIC_PATHS__': JSON.stringify(publicPaths),
-                '__ACI_PASSTHROUGH_ROUTES__': JSON.stringify(passthroughRoutes),
-                '__ACI_ASSET_PREFIX__': JSON.stringify(assetPrefix),
                 '__ACI_ERROR_PAGE__': JSON.stringify(errorSeat.payload),
             }));
             return typeof userWebpack === 'function'
@@ -106,40 +68,3 @@ export function withAci(nextConfig = {}, options = {}) {
         },
     };
 }
-function normalizePassthroughRoutes(routes) {
-    const out = [];
-    const seen = new Set();
-    for (const route of routes) {
-        const clean = normalizeRoutePattern(route);
-        if (!clean || seen.has(clean))
-            continue;
-        seen.add(clean);
-        out.push(clean);
-    }
-    return out;
-}
-function normalizeRoutePattern(route) {
-    const trimmed = route.trim();
-    if (!trimmed)
-        return '';
-    const withSlash = trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
-    return withSlash.replace(/\/{2,}/g, '/').replace(/\/$/, '') || '/';
-}
-function collectPublicPaths(publicDir) {
-    if (!existsSync(publicDir))
-        return [];
-    const paths = [];
-    const walk = (dir) => {
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-            }
-            else {
-                paths.push('/' + relative(publicDir, full).split('\\').join('/'));
-            }
-        }
-    };
-    walk(publicDir);
-    return paths;
-}

package/dist/next/error-pages.d.ts

@@ -1,5 +1,4 @@
 import type { ReactElement } from 'react';
-import { type FetchConfig } from './server.js';
 import { type ErrorPageKind, type ErrorPagePush, type ResolvedErrorPage } from '../content/error-pages.js';
 import type { KernelSiteConfig } from '../content/types.js';
 import type { Registry } from '../registry.js';
@@ -18,7 +17,7 @@ export interface NextResolvedErrorPage extends ResolvedErrorPage {
  * the shipped default — an error surface must not re-enter the failing
  * system (ANTI-2).
  */
-export declare function resolveErrorPage(kind: ErrorPageKind, config?: FetchConfig): Promise<NextResolvedErrorPage>;
+export declare function resolveErrorPage(kind: ErrorPageKind): Promise<NextResolvedErrorPage>;
 /**
  * Renders the content page bound to `route` through the normal page
  * pipeline (createPage: layout slots, fragments, registry blocks, collect/
@@ -47,6 +46,6 @@ export declare function DefaultErrorPageContent(): import("react").JSX.Element;
  * `pushErrorPageView` (D-15): the tenant-owned policy module's push,
  * forwarded to ErrorPageInstrumentation; omitted → the SDK default.
  */
-export declare function createNotFound(registry: Registry, config?: FetchConfig & {
+export declare function createNotFound(registry: Registry, options?: {
     pushErrorPageView?: ErrorPagePush;
 }): () => Promise<ReactElement>;

package/dist/next/error-pages.js

@@ -12,11 +12,11 @@ import { ErrorPageMarker } from './error-page-marker.js';
  * the shipped default — an error surface must not re-enter the failing
  * system (ANTI-2).
  */
-export async function resolveErrorPage(kind, config = {}) {
+export async function resolveErrorPage(kind) {
     let siteConfig = null;
     const warnings = [];
     try {
-        siteConfig = await getSiteConfig(config);
+        siteConfig = await getSiteConfig();
     }
     catch (error) {
         warnings.push(`site config unavailable at the error seat: ${String(error)}`);
@@ -58,7 +58,7 @@ export function DefaultErrorPageContent() {
  * `pushErrorPageView` (D-15): the tenant-owned policy module's push,
  * forwarded to ErrorPageInstrumentation; omitted → the SDK default.
  */
-export function createNotFound(registry, config = {}) {
+export function createNotFound(registry, options = {}) {
     return async function NotFound() {
         // Force dynamic rendering: Next prerenders /_not-found at build time,
         // where no content provider is reachable. The DYNAMIC_SERVER_USAGE
@@ -73,7 +73,7 @@ export function createNotFound(registry, config = {}) {
             if (typeof digest === 'string' && digest.startsWith('DYNAMIC_SERVER_USAGE'))
                 throw error;
         }
-        const resolved = await resolveErrorPage('notFound', config);
+        const resolved = await resolveErrorPage('notFound');
         for (const warning of resolved.warnings) {
             console.warn(`[aci error-pages] ${warning}`);
         }
@@ -89,6 +89,6 @@ export function createNotFound(registry, config = {}) {
                 content = null;
             }
         }
-        return (_jsxs(_Fragment, { children: [content ?? _jsx(DefaultErrorPageContent, {}), _jsx(ErrorPageMarker, { kind: "notFound" }), _jsx(ErrorPageInstrumentation, { kind: "notFound", push: config.pushErrorPageView })] }));
+        return (_jsxs(_Fragment, { children: [content ?? _jsx(DefaultErrorPageContent, {}), _jsx(ErrorPageMarker, { kind: "notFound" }), _jsx(ErrorPageInstrumentation, { kind: "notFound", push: options.pushErrorPageView })] }));
     };
 }

package/dist/next/error-seat.d.ts

@@ -6,9 +6,8 @@ import type { Registry } from '../registry.js';
  * D-9): Next's error seat is client-only and cannot reach the server content
  * provider, so withAci() resolves `site.json#errorPages.catchAll` while
  * next.config is evaluated and injects the page's resolved slots into the
- * bundle as the `__ACI_ERROR_PAGE__` webpack define (same mechanism as the
- * middleware's `__ACI_PUBLIC_PATHS__`). Content edits to the bound page
- * therefore require a code build — accepted by D-4.
+ * bundle as the `__ACI_ERROR_PAGE__` webpack define. Content edits to the
+ * bound page therefore require a code build — accepted by D-4.
  */
 export interface ErrorSeatPayload {
     /** True when no binding is authored: render the shipped default (REQ-4). */

package/dist/next/index.d.ts

@@ -2,10 +2,10 @@ export { DevRefresh, type DevRefreshProps } from './dev-refresh.js';
 export { withAci, type WithAciOptions } from './config.js';
 export { isPreviewMode } from './preview-mode.js';
 export { createPage, type CreatePageOptions, type SlotPropsFn } from './page.js';
-export { getSiteConfig, getFragment, getLayout, getPage, getRenderInput, routeFromNextParams } from './server.js';
+export { getSiteConfig, getFragment, getLayout, getPage, getRenderInput, routeFromNextParams, setReleaseObjectReader } from './server.js';
+export type { HostedContentContext } 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

@@ -2,10 +2,9 @@ export { DevRefresh } from './dev-refresh.js';
 export { withAci } from './config.js';
 export { isPreviewMode } from './preview-mode.js';
 export { createPage } from './page.js';
-export { getSiteConfig, getFragment, getLayout, getPage, getRenderInput, routeFromNextParams } from './server.js';
+export { getSiteConfig, getFragment, getLayout, getPage, getRenderInput, routeFromNextParams, setReleaseObjectReader } 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

@@ -30,19 +30,9 @@ export interface CreatePageOptions {
  * When the site config enables personalization, the page tree also carries
  * 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/*`).
- *
- * Dev pass-through (ACI_CONTENT_PROVIDER=file): the middleware passes
- * requests through unrewritten, so `/` arrives with an empty/undefined
- * slug and `/about` arrives as `['about']`. The optional catch-all
- * `[[...slug]]` handles both cases. No releaseId is present; the file
- * provider serves content directly from disk.
+ * In SSR delivery the provider edge rewrites to an immutable release/page
+ * path. The SDK derives the exact JSON ref from that path and renders it with
+ * the same registry used by static publishing.
  *
  * 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

package/dist/next/page.js

@@ -6,7 +6,6 @@ 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';
 /**
  * Creates the catch-all route handler for a Next.js ACI site.
  *
@@ -27,19 +26,9 @@ import { renderProofContentFor } from '../internal/render-proof.js';
  * When the site config enables personalization, the page tree also carries
  * 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/*`).
- *
- * Dev pass-through (ACI_CONTENT_PROVIDER=file): the middleware passes
- * requests through unrewritten, so `/` arrives with an empty/undefined
- * slug and `/about` arrives as `['about']`. The optional catch-all
- * `[[...slug]]` handles both cases. No releaseId is present; the file
- * provider serves content directly from disk.
+ * In SSR delivery the provider edge rewrites to an immutable release/page
+ * path. The SDK derives the exact JSON ref from that path and renders it with
+ * the same registry used by static publishing.
  *
  * 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
@@ -47,10 +36,14 @@ import { renderProofContentFor } from '../internal/render-proof.js';
  * be CMS-managed fragments instead of hardcoded component imports.
  */
 export function createPage(registry, options) {
+    // The compiler invokes this route repeatedly against isolated content
+    // snapshots while producing immutable HTML. It must not let Next cache the
+    // first snapshot. Deployed CMS traffic is intercepted by the provider
+    // gateway and never reaches this framework route.
     const dynamic = 'force-dynamic';
     async function generateMetadata({ params }) {
-        const { route, releaseId } = await resolveRouteAndRelease(params);
-        const input = await getRenderInput(route, { releaseId });
+        const resolved = await resolveRoute(params);
+        const input = await getRenderInput(resolved.route, resolved.context);
         const meta = routeMetadataForContent(input.siteConfig, input.page);
         return {
             title: meta.title,
@@ -64,15 +57,14 @@ export function createPage(registry, options) {
         };
     }
     async function CatchAllPage({ params }) {
-        const { route, releaseId } = await resolveRouteAndRelease(params);
-        const fetchConfig = { releaseId };
+        const resolved = await resolveRoute(params);
+        const context = resolved.context;
         try {
-            const input = await getRenderInput(route, fetchConfig);
+            const input = await getRenderInput(resolved.route, context);
             if (!input.page)
                 notFound();
-            const renderProofContent = renderProofContentFor(input);
-            const layout = await getLayout(input.page.layout, fetchConfig);
-            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id, fetchConfig));
+            const layout = await getLayout(input.page.layout, context);
+            const resolvedSlots = await resolveSlots(layout, input.page.regions || {}, (id) => getFragment(id, context));
             const renderedSlots = await Promise.all(layout.slots.map(async (slot) => {
                 const blocks = resolvedSlots[slot.name];
                 if (!blocks?.length)
@@ -84,9 +76,7 @@ export function createPage(registry, options) {
                 }
                 return (_jsx(Fragment, { children: renderedBlocks }, slot.name));
             }));
-            return (_jsxs(_Fragment, { children: [renderProofContent
-                        ? _jsx("meta", { name: "aci-render-proof", content: renderProofContent })
-                        : null, renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
+            return (_jsxs(_Fragment, { children: [renderedSlots.filter(Boolean), _jsx(AssignmentsScript, { page: input.page }), _jsx(CollectScript, { siteConfig: input.siteConfig })] }));
         }
         catch (error) {
             if (error instanceof PageNotFoundError)
@@ -101,43 +91,41 @@ export function createPage(registry, options) {
     };
 }
 /**
- * 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
- *    `/__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).
- *
- * 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.
+ * Resolves the logical source route used while building static output.
  */
-async function resolveRouteAndRelease(params) {
+async function resolveRoute(params) {
     const resolved = await params;
     const slug = resolved.slug ?? [];
     if (slug.length >= 2 && slug[0] === '__r') {
-        const releaseId = decodeURIComponent(slug[1]);
-        if (!releaseId || releaseId.includes('/') || releaseId === '.' || releaseId === '..') {
+        const releaseId = slug[1];
+        const selected = slug.slice(2);
+        if (!portableReleaseId(releaseId) || selected.some((part) => !portablePathPart(part))) {
             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 variantAt = selected.indexOf('__variant');
+        if (variantAt >= 0 && (variantAt !== selected.length - 2 || !selected[variantAt + 1])) {
             return { route: '/' };
-        return { route: `/${rest.join('/')}/`, releaseId };
+        }
+        const routeParts = variantAt < 0 ? selected : selected.slice(0, variantAt);
+        const route = routeFromSlug(routeParts);
+        const pageRef = [
+            'routes',
+            ...routeParts,
+            ...(variantAt < 0 ? [] : ['__variant', selected[variantAt + 1]]),
+            'index.json',
+        ].join('/');
+        return { route, context: { releaseId, pageRef } };
     }
-    const route = routeFromSlug(slug);
-    return { route };
+    return { route: routeFromSlug(slug) };
 }
 function routeFromSlug(slug) {
     if (slug.length === 0)
         return '/';
     return `/${slug.join('/')}/`;
 }
+function portableReleaseId(value) {
+    return value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value);
+}
+function portablePathPart(value) {
+    return value.length > 0 && value !== '.' && value !== '..' && !value.includes('/');
+}

package/dist/next/server.d.ts

@@ -1,20 +1,6 @@
 import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError } from '../content/provider.js';
-import type { RenderInput } from '../content/types.js';
+import { type ReleaseObjectReader } from '../providers/object.js';
 export { FragmentNotFoundError, PageNotFoundError, LayoutNotFoundError };
-export interface FetchConfig {
-    siteId?: string;
-    bucket?: string;
-    keyPrefix?: string;
-    region?: string;
-    accessKeyId?: string;
-    secretAccessKey?: string;
-    sessionToken?: string;
-    roleArn?: string;
-    endpoint?: string;
-    releaseId?: string;
-    edgeConfig?: string;
-    deploymentId?: string;
-}
 export interface ServerRenderInput<TPage, TSite extends SiteConfig = SiteConfig> {
     route: string;
     domain: string;
@@ -27,13 +13,17 @@ export interface SiteConfig {
     domain?: string;
     defaultLocale?: string;
 }
-export declare function getPage<T = unknown>(route?: string, config?: FetchConfig): Promise<T>;
-export declare function getSiteConfig<T extends SiteConfig = SiteConfig>(config?: FetchConfig): Promise<T>;
-export declare function getFragment<T = unknown>(name: string, config?: FetchConfig): Promise<T>;
-export declare function getLayout<T = unknown>(name: string, config?: FetchConfig): Promise<T>;
-export declare function getRoutes(config?: FetchConfig): Promise<string[]>;
-export declare function getRenderInput<TPage, TSite extends SiteConfig = SiteConfig>(route?: string, config?: FetchConfig): Promise<ServerRenderInput<TPage, TSite>>;
-export declare function getPageRuntimeRenderInput(): Promise<RenderInput | null>;
+export interface HostedContentContext {
+    releaseId?: string;
+    pageRef?: string;
+}
+export declare function setReleaseObjectReader(reader: ReleaseObjectReader | undefined): void;
+export declare function getPage<T = unknown>(route?: string, context?: HostedContentContext): Promise<T>;
+export declare function getSiteConfig<T extends SiteConfig = SiteConfig>(context?: HostedContentContext): Promise<T>;
+export declare function getFragment<T = unknown>(name: string, context?: HostedContentContext): Promise<T>;
+export declare function getLayout<T = unknown>(name: string, context?: HostedContentContext): Promise<T>;
+export declare function getRoutes(context?: HostedContentContext): Promise<string[]>;
+export declare function getRenderInput<TPage, TSite extends SiteConfig = SiteConfig>(route?: string, context?: HostedContentContext): Promise<ServerRenderInput<TPage, TSite>>;
 export { isPreviewMode } from './preview-mode.js';
 export declare function routeFromNextParams(params: Promise<{
     slug?: string[];
@@ -43,13 +33,3 @@ export declare function routeFromNextParams(params: Promise<{
 export declare function generateStaticParams(): Promise<Array<{
     slug?: string[];
 }>>;
-export declare class ReleaseAssetNotFoundError extends Error {
-    constructor(releaseId: string, assetPath: string, cause?: unknown);
-}
-export declare function getReleaseAssetResponse(releaseId: string, assetPath: string, config?: FetchConfig): Promise<Response>;
-export declare function isDamAssetPath(assetPath: string): boolean;
-export declare class DamAssetNotFoundError extends Error {
-    constructor(assetPath: string, cause?: unknown);
-}
-export declare function getDamAssetResponse(assetPath: string, config?: FetchConfig): Promise<Response>;
-export declare function resolveReleaseId(config?: FetchConfig): Promise<string>;