@gradial/aci 0.1.48 → 0.1.51-ssr.2

package/dist/next/server.js

@@ -1,79 +1,77 @@
 import { headers } from 'next/headers.js';
 import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '../content/provider.js';
-import { getCachedManifest, getCachedSiteConfig } from '../content/cache.js';
-import { S3ContentProvider } from '../providers/s3.js';
+import { getCachedSiteConfig } from '../content/cache.js';
+import { ObjectContentProvider } from '../providers/object.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 MAX_S3_PROVIDER_CACHE_ENTRIES = 8;
-const s3ProviderCache = [];
-const s3ProviderReleaseIds = new WeakMap();
-export async function getPage(route = '', config = {}) {
-    const runtimeInput = await getPageRuntimeRenderInput();
-    if (runtimeInput)
-        return runtimeInput.page;
-    const provider = await resolveProviderWithFallback(config);
-    return (await selectRenderPage(provider, route)).page;
-}
-export async function getSiteConfig(config = {}) {
-    const runtimeInput = await getPageRuntimeRenderInput();
-    if (runtimeInput)
-        return runtimeInput.siteConfig;
-    const provider = await resolveProviderWithFallback(config);
+const releaseObjectReaderSymbol = Symbol.for('@gradial/aci.release-object-reader');
+let defaultReleaseObjectReader;
+export function setReleaseObjectReader(reader) {
+    const scope = globalThis;
+    if (reader)
+        scope[releaseObjectReaderSymbol] = reader;
+    else
+        delete scope[releaseObjectReaderSymbol];
+}
+export async function getPage(route = '', context = {}) {
+    const compilerInput = await getCompilerRenderInput();
+    if (compilerInput)
+        return compilerInput.page;
+    const provider = await resolveProvider(context);
+    return await provider.getPage(route);
+}
+export async function getSiteConfig(context = {}) {
+    const compilerInput = await getCompilerRenderInput();
+    if (compilerInput)
+        return compilerInput.siteConfig;
+    const provider = await resolveProvider(context);
     return await provider.getSiteConfig();
 }
-export async function getFragment(name, config = {}) {
-    const runtimeInput = await getPageRuntimeRenderInput();
-    if (runtimeInput) {
-        const fragments = runtimeInput.fragments || {};
-        if (name in fragments)
-            return fragments[name];
+export async function getFragment(name, context = {}) {
+    const compilerInput = await getCompilerRenderInput();
+    if (compilerInput && name in (compilerInput.fragments || {})) {
+        return compilerInput.fragments[name];
     }
-    const provider = await resolveProviderWithFallback(config);
+    const provider = await resolveProvider(context);
     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];
+export async function getLayout(name, context = {}) {
+    const compilerInput = await getCompilerRenderInput();
+    if (compilerInput && name in (compilerInput.layouts || {})) {
+        return compilerInput.layouts[name];
     }
-    const provider = await resolveProviderWithFallback(config);
+    const provider = await resolveProvider(context);
     return await provider.getLayout(name);
 }
-export async function getRoutes(config = {}) {
-    const provider = await resolveProviderWithFallback(config);
+export async function getRoutes(context = {}) {
+    const provider = await resolveProvider(context);
     const routes = await provider.listRoutes();
     return routes.map((route) => route.path).sort();
 }
-export async function getRenderInput(route = '/', config = {}) {
-    const runtimeInput = await getPageRuntimeRenderInput();
-    if (runtimeInput) {
-        return runtimeInput;
+export async function getRenderInput(route = '/', context = {}) {
+    const compilerInput = await getCompilerRenderInput();
+    if (compilerInput) {
+        return compilerInput;
     }
-    const provider = await resolveProviderWithFallback(config);
-    // Cache shared resources (manifest, siteConfig) but not per-page content
-    // Page-level caching is handled by CDN
-    const [selection, siteConfig] = await Promise.all([
-        selectRenderPage(provider, route),
+    const provider = await resolveProvider(context);
+    const [page, siteConfig] = await Promise.all([
+        provider.getPage(route),
         getCachedSiteConfig(provider),
     ]);
-    const input = {
+    return {
         route,
         domain: siteConfig.domain || 'www.aci.local',
         locale: siteConfig.defaultLocale || 'en-us',
         siteConfig,
-        page: selection.page,
+        page,
     };
-    if (selection.receipt) {
-        attachRenderProofReceipt(input, selection.receipt);
-    }
-    return input;
 }
-export async function getPageRuntimeRenderInput() {
+// getCompilerRenderInput is the offline page-compiler seam used by the Next
+// capsule harness. The header is only an opaque lookup key into this process's
+// pending-input map; viewer requests cannot supply release or content
+// authority through it, and hosted CMS routes never enter Next.
+async function getCompilerRenderInput() {
     try {
         const current = await headers();
         return getPendingRenderInput(current.get(GRADIAL_RENDER_INPUT_HEADER));
@@ -82,47 +80,6 @@ export async function getPageRuntimeRenderInput() {
         return null;
     }
 }
-// The personalization edge proxies framework-origin requests with
-// X-Aci-Content-Ref naming the exact page payload its decision
-// selected (base or variant). When present, the SSR render must use that
-// payload — otherwise every visitor gets the base page and edge decisioning
-// is cosmetic. The S3 provider only serves refs the release manifest
-// declares.
-const ACI_CONTENT_PATH_HEADER = 'x-aci-content-path';
-const ACI_VARIANT_KEY_HEADER = 'x-aci-variant-key';
-async function selectRenderPage(provider, route) {
-    if (!(provider instanceof S3ContentProvider)) {
-        return { page: await provider.getPage(route) };
-    }
-    const releaseId = s3ProviderReleaseIds.get(provider);
-    if (!releaseId) {
-        throw new Error('ACI S3 page integrity error: provider release is unavailable');
-    }
-    let contentRef = '';
-    let contentRefPresent = false;
-    let variantKey = '';
-    let variantKeyPresent = false;
-    try {
-        const current = await headers();
-        const selectedContentRef = current.get(ACI_CONTENT_PATH_HEADER);
-        contentRefPresent = selectedContentRef !== null;
-        contentRef = selectedContentRef ?? '';
-        const selectedVariantKey = current.get(ACI_VARIANT_KEY_HEADER);
-        variantKeyPresent = selectedVariantKey !== null;
-        variantKey = selectedVariantKey ?? '';
-    }
-    catch {
-        // `headers()` has no request context in static generation and unit tests.
-    }
-    return await provider[selectVerifiedPage]({
-        releaseId,
-        route,
-        contentRef,
-        contentRefPresent,
-        variantKey,
-        variantKeyPresent,
-    });
-}
 export { isPreviewMode } from './preview-mode.js';
 export async function routeFromNextParams(params) {
     const resolved = await params;
@@ -141,207 +98,21 @@ export async function generateStaticParams() {
             : entry.path.replace(/^\/|\/$/g, '').split('/'),
     }));
 }
-export class ReleaseAssetNotFoundError extends Error {
-    constructor(releaseId, assetPath, cause) {
-        super(`ACI release asset not found: ${releaseId}/${assetPath}`);
-        this.name = 'ReleaseAssetNotFoundError';
-        this.cause = cause;
-    }
-}
-export async function getReleaseAssetResponse(releaseId, assetPath, config = {}) {
-    const clean = cleanAssetPath(assetPath);
-    if (!releaseId || !clean) {
-        throw new ReleaseAssetNotFoundError(releaseId, assetPath);
-    }
-    const provider = new S3ContentProvider({
-        bucket: config.bucket,
-        keyPrefix: releaseKey(config, releaseId),
-        region: config.region,
-        accessKeyId: config.accessKeyId,
-        secretAccessKey: config.secretAccessKey,
-        sessionToken: config.sessionToken,
-        roleArn: config.roleArn,
-        endpoint: config.endpoint,
-    });
-    const key = joinKey(provider.config.keyPrefix, 'assets', clean);
-    const res = await provider.fetchRaw(key);
-    if (!res.ok || !res.body) {
-        throw new ReleaseAssetNotFoundError(releaseId, clean, await safeResponseText(res));
-    }
-    const headers = new Headers();
-    copyHeader(res.headers, headers, 'content-type');
-    copyHeader(res.headers, headers, 'content-length');
-    copyHeader(res.headers, headers, 'etag');
-    copyHeader(res.headers, headers, 'last-modified');
-    headers.set('cache-control', 'public, max-age=300, must-revalidate');
-    return new Response(res.body, { status: 200, headers });
-}
-// DAM assets are globally shared and content-addressed: the Go hosting
-// adapter stages them at the bucket ROOT under `.gradial-dam/...`
-// (prefixedKey(damAssetKey(path)) — see internal/domain/hosting/vercel), not
-// under the per-release `releases/{id}/assets/...` prefix. The tenant key
-// prefix (ACI_S3_KEY_PREFIX) still applies.
-const DAM_ASSET_KEY_PREFIX = '.gradial-dam';
-export function isDamAssetPath(assetPath) {
-    const clean = cleanAssetPath(assetPath);
-    return clean === DAM_ASSET_KEY_PREFIX || clean.startsWith(`${DAM_ASSET_KEY_PREFIX}/`);
-}
-export class DamAssetNotFoundError extends Error {
-    constructor(assetPath, cause) {
-        super(`ACI DAM asset not found: ${assetPath}`);
-        this.name = 'DamAssetNotFoundError';
-        this.cause = cause;
-    }
-}
-export async function getDamAssetResponse(assetPath, config = {}) {
-    const clean = cleanAssetPath(assetPath);
-    if (!clean.startsWith(`${DAM_ASSET_KEY_PREFIX}/`)) {
-        throw new DamAssetNotFoundError(assetPath);
-    }
-    const provider = new S3ContentProvider({
-        bucket: config.bucket,
-        keyPrefix: joinKey(config.keyPrefix || process.env.ACI_S3_KEY_PREFIX || ''),
-        region: config.region,
-        accessKeyId: config.accessKeyId,
-        secretAccessKey: config.secretAccessKey,
-        sessionToken: config.sessionToken,
-        roleArn: config.roleArn,
-        endpoint: config.endpoint,
-    });
-    const key = joinKey(provider.config.keyPrefix, clean);
-    const res = await provider.fetchRaw(key);
-    if (!res.ok || !res.body) {
-        throw new DamAssetNotFoundError(clean, await safeResponseText(res));
-    }
-    const headers = new Headers();
-    copyHeader(res.headers, headers, 'content-type');
-    copyHeader(res.headers, headers, 'content-length');
-    copyHeader(res.headers, headers, 'etag');
-    copyHeader(res.headers, headers, 'last-modified');
-    // DAM keys are content-addressed, so the bytes behind a key never change.
-    headers.set('cache-control', 'public, max-age=31536000, immutable');
-    headers.set('cdn-cache-control', 'max-age=31536000');
-    headers.set('vercel-cdn-cache-control', 'max-age=31536000');
-    return new Response(res.body, { status: 200, headers });
-}
-function cleanAssetPath(value) {
-    const clean = value.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
-    if (!clean || clean.split('/').some((s) => s === '..' || s === '.'))
-        return '';
-    return clean;
-}
-function copyHeader(from, to, name) {
-    const value = from.get(name);
-    if (value)
-        to.set(name, value);
-}
-async function safeResponseText(res) {
-    try {
-        return await res.text();
-    }
-    catch {
-        return '';
-    }
-}
-export async function resolveReleaseId(config = {}) {
-    if (config.releaseId)
-        return config.releaseId;
-    if (process.env.ACI_RELEASE_ID)
-        return process.env.ACI_RELEASE_ID;
-    const activeReleaseId = await activeReleaseFromEdgeConfig(config);
-    if (activeReleaseId)
-        return activeReleaseId;
-    throw new Error('ACI release ID is required. Pass releaseId from the release-scoped route or set ACI_RELEASE_ID.');
-}
-async function resolveS3Provider(config) {
-    const releaseId = await resolveReleaseId(config);
-    if (releaseId.length > 128
-        || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(releaseId)) {
-        throw new Error(`ACI release ID is invalid: ${releaseId}`);
-    }
-    const candidate = new S3ContentProvider({
-        bucket: config.bucket,
-        keyPrefix: releaseKey(config, releaseId),
-        region: config.region,
-        accessKeyId: config.accessKeyId,
-        secretAccessKey: config.secretAccessKey,
-        sessionToken: config.sessionToken,
-        roleArn: config.roleArn,
-        endpoint: config.endpoint,
+async function resolveLocalProvider() {
+    const { FileContentProvider } = await import('../providers/file.js');
+    return new FileContentProvider();
+}
+async function resolveProvider(context) {
+    if (!context.releaseId && !context.pageRef)
+        return await resolveLocalProvider();
+    if (!context.releaseId || !context.pageRef) {
+        throw new Error('ACI hosted content requires both releaseId and pageRef');
+    }
+    const reader = globalThis[releaseObjectReaderSymbol]
+        ?? (defaultReleaseObjectReader ??= new VercelReleaseObjectReader());
+    return new ObjectContentProvider({
+        releaseId: context.releaseId,
+        pageRef: context.pageRef,
+        reader,
     });
-    s3ProviderReleaseIds.set(candidate, releaseId);
-    const cachedIndex = s3ProviderCache.findIndex((entry) => sameS3ProviderConfig(entry.config, candidate.config));
-    if (cachedIndex >= 0) {
-        const [cached] = s3ProviderCache.splice(cachedIndex, 1);
-        s3ProviderCache.push(cached);
-        return await cached.provider;
-    }
-    const provider = getCachedManifest(candidate).then(() => candidate);
-    const entry = { config: candidate.config, provider };
-    s3ProviderCache.push(entry);
-    if (s3ProviderCache.length > MAX_S3_PROVIDER_CACHE_ENTRIES) {
-        s3ProviderCache.shift();
-    }
-    try {
-        return await provider;
-    }
-    catch (error) {
-        const rejectedIndex = s3ProviderCache.findIndex((cached) => cached.provider === provider);
-        if (rejectedIndex >= 0) {
-            s3ProviderCache.splice(rejectedIndex, 1);
-        }
-        throw error;
-    }
-}
-async function resolveProviderWithFallback(config) {
-    if (process.env.ACI_CONTENT_PROVIDER === 'file') {
-        const { FileContentProvider } = await import('../providers/file.js');
-        return new FileContentProvider();
-    }
-    return await resolveS3Provider(config);
-}
-function sameS3ProviderConfig(left, right) {
-    return left.bucket === right.bucket
-        && left.keyPrefix === right.keyPrefix
-        && left.region === right.region
-        && left.accessKeyId === right.accessKeyId
-        && left.secretAccessKey === right.secretAccessKey
-        && left.sessionToken === right.sessionToken
-        && left.roleArn === right.roleArn
-        && left.endpoint === right.endpoint;
-}
-async function activeReleaseFromEdgeConfig(config) {
-    const edgeConfig = config.edgeConfig || process.env.EDGE_CONFIG || '';
-    const siteId = config.siteId || process.env.ACI_SITE_ID || '';
-    if (!edgeConfig || !siteId)
-        return '';
-    const active = await activeReleasePointer(edgeConfig, siteId);
-    if (active == null)
-        return '';
-    const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
-    if (!deploymentId)
-        return active.releaseId;
-    const compatibilityValue = await getEdgeConfigValue(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
-    if (compatibilityValue == null)
-        return active.releaseId;
-    return clampDeploymentCompatibleReleaseV1(active, decodeDeploymentCompatibilityV1(compatibilityValue));
-}
-async function getEdgeConfigValue(edgeConfig, key) {
-    return getUncachedEdgeConfigValue(edgeConfig, key);
-}
-function releaseKey(config, releaseId) {
-    return joinKey(config.keyPrefix || process.env.ACI_S3_KEY_PREFIX || '', 'releases', releaseId);
-}
-async function activeReleasePointer(edgeConfig, siteId) {
-    const value = await getEdgeConfigValue(edgeConfig, activeReleaseV1Key(siteId));
-    if (value == null)
-        return null;
-    return decodeActiveReleaseV1(value);
-}
-function joinKey(...parts) {
-    return parts
-        .flatMap((part) => part.split('/'))
-        .map((part) => part.trim())
-        .filter(Boolean)
-        .join('/');
 }

package/dist/providers/object.d.ts

@@ -0,0 +1,24 @@
+import { type CompiledManifest, type ContentProvider, type RouteEntry } from '../content/provider.js';
+export interface ReleaseObjectReader {
+    readReleaseObject(releaseId: string, path: string): Promise<Uint8Array>;
+}
+export interface ObjectContentProviderOptions {
+    releaseId: string;
+    pageRef: string;
+    reader: ReleaseObjectReader;
+}
+/** Reads one immutable compiled release through a host-injected object reader. */
+export declare class ObjectContentProvider implements ContentProvider {
+    #private;
+    readonly releaseId: string;
+    readonly pageRef: string;
+    readonly reader: ReleaseObjectReader;
+    constructor(options: ObjectContentProviderOptions);
+    listRoutes(): Promise<RouteEntry[]>;
+    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>;
+    private readJSON;
+}

package/dist/providers/object.js

@@ -0,0 +1,105 @@
+import { FragmentNotFoundError, LayoutNotFoundError, PageNotFoundError, } from '../content/provider.js';
+import { normalizeRoute } from '../content/routes.js';
+/** Reads one immutable compiled release through a host-injected object reader. */
+export class ObjectContentProvider {
+    releaseId;
+    pageRef;
+    reader;
+    #manifest;
+    constructor(options) {
+        if (!portableReleaseId(options.releaseId))
+            throw new Error('ACI release ID is invalid');
+        if (!cleanObjectPath(options.pageRef))
+            throw new Error('ACI page ref is invalid');
+        this.releaseId = options.releaseId;
+        this.pageRef = options.pageRef;
+        this.reader = options.reader;
+    }
+    async listRoutes() {
+        return Object.values((await this.manifest()).routes)
+            .sort((left, right) => left.path.localeCompare(right.path));
+    }
+    async getSiteConfig() {
+        const manifest = await this.manifest();
+        return await this.readJSON(manifest.siteConfigRef);
+    }
+    async getPage(route) {
+        const normalized = normalizeRoute(route);
+        const entries = Object.values((await this.manifest()).routes)
+            .filter((entry) => normalizeRoute(entry.path) === normalized);
+        if (entries.length !== 1)
+            throw new PageNotFoundError(route);
+        const entry = entries[0];
+        const candidates = [
+            { ref: entry.payloadRef, digest: entry.digest },
+            ...Object.values(entry.variants ?? {}).map((variant) => ({
+                ref: variant.payloadRef,
+                digest: variant.digest,
+            })),
+        ];
+        const exact = candidates.find((candidate) => candidate.ref === this.pageRef);
+        if (!exact)
+            throw new PageNotFoundError(route, new Error(`selected page ref is not declared: ${this.pageRef}`));
+        try {
+            return await this.readJSON(exact.ref, exact.digest);
+        }
+        catch (error) {
+            throw new PageNotFoundError(route, error);
+        }
+    }
+    async getFragment(id) {
+        const entry = (await this.manifest()).fragments[id];
+        if (!entry)
+            throw new FragmentNotFoundError(id);
+        try {
+            return await this.readJSON(entry.payloadRef, entry.digest);
+        }
+        catch (error) {
+            throw new FragmentNotFoundError(id, error);
+        }
+    }
+    async getLayout(name) {
+        const entry = (await this.manifest()).layouts?.[name];
+        if (!entry)
+            throw new LayoutNotFoundError(name);
+        try {
+            return await this.readJSON(`layouts/${name}/index.json`);
+        }
+        catch (error) {
+            throw new LayoutNotFoundError(name, error);
+        }
+    }
+    async manifest() {
+        this.#manifest ??= this.readJSON('manifest.json');
+        return await this.#manifest;
+    }
+    async readJSON(path, digest) {
+        const clean = cleanObjectPath(path);
+        if (!clean || clean !== path)
+            throw new Error(`ACI release object path is invalid: ${path}`);
+        const bytes = await this.reader.readReleaseObject(this.releaseId, clean);
+        if (digest)
+            await verifyDigest(bytes, digest, clean);
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+}
+async function verifyDigest(bytes, expected, path) {
+    const match = /^sha256:([0-9a-f]{64})$/.exec(expected);
+    if (!match)
+        throw new Error(`ACI manifest digest is invalid for ${path}`);
+    const input = Uint8Array.from(bytes).buffer;
+    const actual = Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256', input)))
+        .map((value) => value.toString(16).padStart(2, '0'))
+        .join('');
+    if (actual !== match[1])
+        throw new Error(`ACI release object digest mismatch for ${path}`);
+}
+function portableReleaseId(value) {
+    return value.length > 0 && value.length <= 128 && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value);
+}
+function cleanObjectPath(value) {
+    const clean = value.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
+    if (!clean || clean.split('/').some((part) => part === '.' || part === '..'))
+        return '';
+    return clean;
+}

package/dist/providers/vercel-object-reader.d.ts

@@ -0,0 +1,20 @@
+import type { ReleaseObjectReader } from './object.js';
+export interface VercelReleaseObjectReaderConfig {
+    bucket?: string;
+    keyPrefix?: string;
+    region?: string;
+    roleArn?: string;
+    endpoint?: string;
+}
+export interface S3CommandClient {
+    send(command: {
+        input: unknown;
+    }): Promise<unknown>;
+}
+export declare class VercelReleaseObjectReader implements ReleaseObjectReader {
+    readonly bucket: string;
+    readonly keyPrefix: string;
+    readonly client: S3CommandClient;
+    constructor(config?: VercelReleaseObjectReaderConfig, client?: S3CommandClient);
+    readReleaseObject(releaseId: string, path: string): Promise<Uint8Array>;
+}

package/dist/providers/vercel-object-reader.js

@@ -0,0 +1,45 @@
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { awsCredentialsProvider } from '@vercel/oidc-aws-credentials-provider';
+export class VercelReleaseObjectReader {
+    bucket;
+    keyPrefix;
+    client;
+    constructor(config = {}, client) {
+        this.bucket = value(config.bucket, process.env.ACI_S3_BUCKET || process.env.HOSTING_BUCKET);
+        this.keyPrefix = value(config.keyPrefix, process.env.ACI_S3_KEY_PREFIX || process.env.HOSTING_KEY_PREFIX);
+        const region = value(config.region, process.env.AWS_REGION) || 'us-east-1';
+        const roleArn = value(config.roleArn, process.env.AWS_ROLE_ARN);
+        const endpoint = value(config.endpoint, process.env.ACI_S3_ENDPOINT);
+        if (!this.bucket)
+            throw new Error('ACI release object reader requires an S3 bucket');
+        if (!roleArn && !client)
+            throw new Error('ACI release object reader requires AWS_ROLE_ARN');
+        this.client = client ?? new S3Client({
+            region,
+            ...(endpoint ? { endpoint, forcePathStyle: true } : {}),
+            credentials: awsCredentialsProvider({ roleArn, clientConfig: { region } }),
+        });
+    }
+    async readReleaseObject(releaseId, path) {
+        const key = joinKey(this.keyPrefix, 'releases', releaseId, path);
+        try {
+            const output = await this.client.send(new GetObjectCommand({
+                Bucket: this.bucket,
+                Key: key,
+            }));
+            if (!output.Body?.transformToByteArray) {
+                throw new Error('S3 returned an unsupported object body');
+            }
+            return await output.Body.transformToByteArray();
+        }
+        catch (error) {
+            throw new Error(`ACI release object read failed for ${releaseId}/${path}`, { cause: error });
+        }
+    }
+}
+function value(configured, environment) {
+    return (configured === undefined ? environment : configured)?.trim() || '';
+}
+function joinKey(...parts) {
+    return parts.flatMap((part) => part.split('/')).map((part) => part.trim()).filter(Boolean).join('/');
+}

package/dist/testing/conformance/checks.d.ts

@@ -5,7 +5,7 @@ export declare function checkPageEntry(ctx: ConformanceContext): ConformanceChec
 export declare function checkMiddleware(ctx: ConformanceContext): ConformanceCheckResult[];
 export declare function checkNoFileContentProvider(ctx: ConformanceContext): ConformanceCheckResult[];
 export declare function checkNoCustomContent(ctx: ConformanceContext): ConformanceCheckResult[];
-export declare function checkNoLegacyAssetRoute(ctx: ConformanceContext): ConformanceCheckResult[];
+export declare function checkNoRequestTimeAssetRoute(ctx: ConformanceContext): ConformanceCheckResult[];
 export declare function checkBuildSucceeds(ctx: ConformanceContext): ConformanceCheckResult[];
 export declare function checkContentCompile(ctx: ConformanceContext): ConformanceCheckResult[];
 export declare function checkSdkVersion(ctx: ConformanceContext): ConformanceCheckResult[];