@gradial/aci 0.1.0

package/dist/next/middleware.js

@@ -0,0 +1,132 @@
+import { createClient, get as getEdgeConfigItem } from '@vercel/edge-config';
+import { NextResponse } from 'next/server';
+import { validatePreviewToken } from './preview.js';
+const RELEASE_HEADER = 'x-gradial-release-id';
+const ROUTE_HEADER = 'x-gradial-route';
+const DISPATCH_HEADER = 'x-gradial-dispatch';
+export function createGradialMiddleware(config) {
+    return async function gradialMiddleware(request) {
+        const requestHeaders = gradialHeaders(request.headers);
+        const preview = await releaseFromPreviewToken(request, config);
+        if (preview.invalid) {
+            return new Response('invalid preview token', { status: 403 });
+        }
+        const releaseId = preview.releaseId || await activeReleaseFromEdgeConfig(config);
+        if (!releaseId) {
+            return NextResponse.next({ request: { headers: requestHeaders } });
+        }
+        requestHeaders.set(RELEASE_HEADER, releaseId);
+        requestHeaders.set(ROUTE_HEADER, request.nextUrl.pathname);
+        requestHeaders.set(DISPATCH_HEADER, 'ssr-page');
+        return NextResponse.next({
+            request: {
+                headers: requestHeaders,
+            },
+        });
+    };
+}
+function gradialHeaders(headers) {
+    const next = new Headers(headers);
+    next.delete(RELEASE_HEADER);
+    next.delete(ROUTE_HEADER);
+    next.delete(DISPATCH_HEADER);
+    return next;
+}
+async function activeReleaseFromEdgeConfig(config) {
+    const edgeConfig = config.edgeConfig || process.env.EDGE_CONFIG || '';
+    if (!edgeConfig || !config.siteId)
+        return '';
+    const active = await activeReleasePointer(edgeConfig, config.siteId);
+    if (!active.releaseId)
+        return '';
+    const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
+    if (!deploymentId)
+        return active.releaseId;
+    const compatibility = await getEdgeConfigJSON(edgeConfig, deploymentCompatibilityKey(config.siteId, deploymentId));
+    if (!compatibility)
+        return active.releaseId;
+    return clampRelease(active.releaseId, active.sequence || 0, compatibility);
+}
+async function getEdgeConfigJSON(edgeConfig, key) {
+    const value = await getEdgeConfigValue(edgeConfig, key);
+    if (!value)
+        return null;
+    if (typeof value === 'string') {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return value;
+}
+async function getEdgeConfigValue(edgeConfig, key) {
+    return edgeConfig === process.env.EDGE_CONFIG
+        ? await getEdgeConfigItem(key)
+        : await createClient(edgeConfig).get(key);
+}
+function activeReleaseKey(siteId) {
+    return `activeRelease_${edgeKeySegment(siteId)}`;
+}
+function deploymentCompatibilityKey(siteId, deploymentId) {
+    return `deploymentCompatibility_${edgeKeySegment(siteId)}_${edgeKeySegment(deploymentId)}`;
+}
+async function activeReleasePointer(edgeConfig, siteId) {
+    const value = await getEdgeConfigValue(edgeConfig, activeReleaseKey(siteId));
+    if (!value)
+        return { releaseId: '' };
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (parsed.releaseId)
+                return parsed;
+        }
+        catch {
+            return { releaseId: value };
+        }
+        return { releaseId: value };
+    }
+    const pointer = value;
+    return { releaseId: pointer.releaseId || '', sequence: pointer.sequence };
+}
+function clampRelease(activeReleaseId, activeSequence, compatibility) {
+    if (!activeSequence)
+        return activeReleaseId;
+    if (compatibility.minSequence && activeSequence < compatibility.minSequence && compatibility.minReleaseId) {
+        return compatibility.minReleaseId;
+    }
+    if (compatibility.maxSequence && activeSequence > compatibility.maxSequence && compatibility.maxReleaseId) {
+        return compatibility.maxReleaseId;
+    }
+    return activeReleaseId;
+}
+function edgeKeySegment(value) {
+    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+}
+async function releaseFromPreviewToken(request, config) {
+    const token = previewTokenFromRequest(request);
+    if (!token)
+        return { releaseId: '', invalid: false };
+    const signKey = config.previewSignKey || process.env.GRADIAL_PREVIEW_SIGN_KEY || process.env.HOSTING_PREVIEW_SIGN_KEY || '';
+    if (!signKey)
+        return { releaseId: '', invalid: true };
+    const claims = await validatePreviewToken(token, signKey);
+    if (!claims || claims.scope !== 'preview' || !claims.releaseId)
+        return { releaseId: '', invalid: true };
+    if (claims.siteId && config.siteId && claims.siteId !== config.siteId)
+        return { releaseId: '', invalid: true };
+    if (!claims.expiresAt || Date.parse(claims.expiresAt) <= Date.now())
+        return { releaseId: '', invalid: true };
+    return { releaseId: claims.releaseId, invalid: false };
+}
+function previewTokenFromRequest(request) {
+    const queryToken = request.nextUrl.searchParams.get('preview_token');
+    if (queryToken)
+        return queryToken;
+    const cookieToken = request.cookies.get('bm_preview')?.value || '';
+    if (cookieToken)
+        return cookieToken;
+    const auth = request.headers.get('authorization') || '';
+    return auth.startsWith('Bearer ') ? auth.slice('Bearer '.length) : '';
+}

package/dist/next/preview.d.ts

@@ -0,0 +1,7 @@
+export interface PreviewClaims {
+    releaseId?: string;
+    siteId?: string;
+    expiresAt?: string;
+    scope?: string;
+}
+export declare function validatePreviewToken(token: string, signKey: string): Promise<PreviewClaims | null>;

package/dist/next/preview.js

@@ -0,0 +1,37 @@
+export async function validatePreviewToken(token, signKey) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            return null;
+        const signingInput = `${parts[0]}.${parts[1]}`;
+        const signature = base64URLToBytes(parts[2]);
+        const key = await crypto.subtle.importKey('raw', new TextEncoder().encode(signKey), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const expected = new Uint8Array(await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(signingInput)));
+        if (!constantTimeEqual(signature, expected))
+            return null;
+        const payload = new TextDecoder().decode(base64URLToBytes(parts[1]));
+        return JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+}
+function base64URLToBytes(value) {
+    const base64 = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, '=');
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+function constantTimeEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < left.length; i++) {
+        diff |= left[i] ^ right[i];
+    }
+    return diff === 0;
+}

package/dist/next/server.d.ts

@@ -0,0 +1,58 @@
+export declare class PageNotFoundError extends Error {
+    constructor(route: string, cause?: unknown);
+}
+export declare class FragmentNotFoundError extends Error {
+    constructor(name: string, cause?: unknown);
+}
+export interface GradialFetchConfig {
+    siteId?: string;
+    bucket?: string;
+    keyPrefix?: string;
+    region?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    endpoint?: string;
+    releaseId?: string;
+    edgeConfig?: string;
+    deploymentId?: string;
+}
+export interface RouteManifest {
+    manifestVersion: string;
+    releaseId: string;
+    siteId: string;
+    routes: Record<string, RouteEntry>;
+}
+export interface RouteEntry {
+    path: string;
+    mode: string;
+    bodyArtifact?: string;
+    fragments?: Array<{
+        id: string;
+        artifactRef?: string;
+    }>;
+    cachePolicy?: {
+        cacheControl?: string;
+    };
+}
+export interface GradialRenderInput<TPage, TSite extends GradialSiteConfig = GradialSiteConfig> {
+    route: string;
+    domain: string;
+    locale: string;
+    siteConfig: TSite;
+    page: TPage;
+}
+export interface GradialSiteConfig {
+    domain?: string;
+    defaultLocale?: string;
+}
+export declare function getPage<T = unknown>(route?: string, config?: GradialFetchConfig): Promise<T>;
+export declare function getFragment<T = unknown>(name: string, config?: GradialFetchConfig): Promise<T>;
+export declare function getRoutes(config?: GradialFetchConfig): Promise<string[]>;
+export declare function getRenderInput<TPage, TSite extends GradialSiteConfig = GradialSiteConfig>(route?: string, config?: GradialFetchConfig): Promise<GradialRenderInput<TPage, TSite>>;
+export declare function routeFromNextParams(params?: Promise<{
+    slug?: string[];
+}> | {
+    slug?: string[];
+}): Promise<string>;
+export declare function resolveReleaseId(config?: GradialFetchConfig): Promise<string>;

package/dist/next/server.js

@@ -0,0 +1,269 @@
+import crypto from 'node:crypto';
+import { createClient, get as getEdgeConfigItem } from '@vercel/edge-config';
+import { headers } from 'next/headers';
+const RELEASE_HEADER = 'x-gradial-release-id';
+export class PageNotFoundError extends Error {
+    constructor(route, cause) {
+        super(`Gradial page fragment not found for route ${route}`);
+        this.name = 'PageNotFoundError';
+        this.cause = cause;
+    }
+}
+export class FragmentNotFoundError extends Error {
+    constructor(name, cause) {
+        super(`Gradial fragment not found: ${name}`);
+        this.name = 'FragmentNotFoundError';
+        this.cause = cause;
+    }
+}
+export async function getPage(route = '', config = {}) {
+    const releaseId = await resolveReleaseId(config);
+    const key = releaseKey(config, releaseId, 'fragments', 'page', pageRouteSegment(route), 'index.json');
+    try {
+        return await getS3JSON(key, config);
+    }
+    catch (error) {
+        throw new PageNotFoundError(route, error);
+    }
+}
+export async function getFragment(name, config = {}) {
+    const releaseId = await resolveReleaseId(config);
+    const cleanName = cleanPath(name).replace(/\.[^.]+$/, '');
+    const key = releaseKey(config, releaseId, 'fragments', 'global', `${cleanName}.json`);
+    try {
+        return await getS3JSON(key, config);
+    }
+    catch (error) {
+        throw new FragmentNotFoundError(name, error);
+    }
+}
+export async function getRoutes(config = {}) {
+    const releaseId = await resolveReleaseId(config);
+    const manifest = await getS3JSON(releaseKey(config, releaseId, 'route-manifest.json'), config);
+    return Object.keys(manifest.routes || {}).sort();
+}
+export async function getRenderInput(route = '/', config = {}) {
+    const [page, siteConfig] = await Promise.all([
+        getPage(route, config),
+        getFragment('site', config),
+    ]);
+    return {
+        route,
+        domain: siteConfig.domain || 'www.baremetal.local',
+        locale: siteConfig.defaultLocale || 'en-us',
+        siteConfig,
+        page,
+    };
+}
+export async function routeFromNextParams(params) {
+    if (!params)
+        return '/';
+    const resolved = await params;
+    if (!resolved.slug || resolved.slug.length === 0)
+        return '/';
+    return `/${resolved.slug.join('/')}/`;
+}
+export async function resolveReleaseId(config = {}) {
+    if (config.releaseId)
+        return config.releaseId;
+    const headerReleaseId = await releaseIdFromHeaders();
+    if (headerReleaseId)
+        return headerReleaseId;
+    if (process.env.GRADIAL_RELEASE_ID)
+        return process.env.GRADIAL_RELEASE_ID;
+    const activeReleaseId = await activeReleaseFromEdgeConfig(config);
+    if (activeReleaseId)
+        return activeReleaseId;
+    throw new Error('Gradial release ID is not available from headers, GRADIAL_RELEASE_ID, or Edge Config');
+}
+async function releaseIdFromHeaders() {
+    try {
+        const current = await headers();
+        return current.get(RELEASE_HEADER) || '';
+    }
+    catch {
+        return '';
+    }
+}
+async function activeReleaseFromEdgeConfig(config) {
+    const edgeConfig = config.edgeConfig || process.env.EDGE_CONFIG || '';
+    const siteId = config.siteId || process.env.GRADIAL_SITE_ID || '';
+    if (!edgeConfig || !siteId)
+        return '';
+    const active = await activeReleasePointer(edgeConfig, siteId);
+    if (!active.releaseId)
+        return '';
+    const deploymentId = config.deploymentId || process.env.VERCEL_DEPLOYMENT_ID || '';
+    if (!deploymentId)
+        return active.releaseId;
+    const compatibility = await getEdgeConfigJSON(edgeConfig, deploymentCompatibilityKey(siteId, deploymentId));
+    if (!compatibility)
+        return active.releaseId;
+    return clampRelease(active.releaseId, active.sequence || 0, compatibility);
+}
+async function getEdgeConfigJSON(edgeConfig, key) {
+    const value = await getEdgeConfigValue(edgeConfig, key);
+    if (!value)
+        return null;
+    if (typeof value === 'string') {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return value;
+}
+async function getEdgeConfigValue(edgeConfig, key) {
+    return edgeConfig === process.env.EDGE_CONFIG
+        ? await getEdgeConfigItem(key)
+        : await createClient(edgeConfig).get(key);
+}
+async function getS3JSON(key, config) {
+    const resolved = resolveS3Config(config);
+    const url = s3ObjectURL(resolved, key);
+    const signedHeaders = signedS3Headers('GET', url, resolved);
+    const res = await fetch(url, {
+        method: 'GET',
+        headers: signedHeaders,
+        cache: 'no-store',
+    });
+    if (!res.ok) {
+        throw new Error(`S3 GET ${key} failed with status ${res.status}: ${await res.text()}`);
+    }
+    return (await res.json());
+}
+function resolveS3Config(config) {
+    const resolved = {
+        siteId: config.siteId || process.env.GRADIAL_SITE_ID || '',
+        bucket: config.bucket || process.env.GRADIAL_S3_BUCKET || '',
+        keyPrefix: config.keyPrefix || process.env.GRADIAL_S3_KEY_PREFIX || '',
+        region: config.region || process.env.AWS_REGION || 'us-east-1',
+        accessKeyId: config.accessKeyId || process.env.AWS_ACCESS_KEY_ID || '',
+        secretAccessKey: config.secretAccessKey || process.env.AWS_SECRET_ACCESS_KEY || '',
+        sessionToken: config.sessionToken || process.env.AWS_SESSION_TOKEN || '',
+        endpoint: trimSlash(config.endpoint || process.env.GRADIAL_S3_ENDPOINT || ''),
+    };
+    for (const key of ['bucket', 'accessKeyId', 'secretAccessKey']) {
+        if (!resolved[key])
+            throw new Error(`Gradial S3 config missing ${key}`);
+    }
+    return resolved;
+}
+function releaseKey(config, releaseId, ...parts) {
+    return joinKey(config.keyPrefix || process.env.GRADIAL_S3_KEY_PREFIX || '', 'releases', releaseId, ...parts);
+}
+function s3ObjectURL(config, key) {
+    const encodedKey = encodeKey(key);
+    if (config.endpoint) {
+        return new URL(`${config.endpoint}/${encodeURIComponent(config.bucket)}${encodedKey}`);
+    }
+    return new URL(`https://${config.bucket}.s3.${config.region}.amazonaws.com${encodedKey}`);
+}
+function signedS3Headers(method, url, config) {
+    const now = new Date();
+    const amzDate = amzTimestamp(now);
+    const dateStamp = amzDate.slice(0, 8);
+    const payloadHash = sha256Hex('');
+    const headers = new Headers({
+        host: url.host,
+        'x-amz-content-sha256': payloadHash,
+        'x-amz-date': amzDate,
+    });
+    if (config.sessionToken)
+        headers.set('x-amz-security-token', config.sessionToken);
+    const signedHeaderNames = Array.from(headers.keys()).sort();
+    const canonicalHeaders = signedHeaderNames.map((key) => `${key}:${headers.get(key)?.trim()}\n`).join('');
+    const canonicalRequest = [
+        method,
+        url.pathname,
+        url.searchParams.toString(),
+        canonicalHeaders,
+        signedHeaderNames.join(';'),
+        payloadHash,
+    ].join('\n');
+    const credentialScope = `${dateStamp}/${config.region}/s3/aws4_request`;
+    const stringToSign = [
+        'AWS4-HMAC-SHA256',
+        amzDate,
+        credentialScope,
+        sha256Hex(canonicalRequest),
+    ].join('\n');
+    const signingKey = awsSigningKey(config.secretAccessKey, dateStamp, config.region, 's3');
+    const signature = hmacHex(signingKey, stringToSign);
+    headers.set('authorization', `AWS4-HMAC-SHA256 Credential=${config.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaderNames.join(';')}, Signature=${signature}`);
+    return headers;
+}
+function awsSigningKey(secret, dateStamp, region, service) {
+    const kDate = hmac(Buffer.from(`AWS4${secret}`, 'utf8'), dateStamp);
+    const kRegion = hmac(kDate, region);
+    const kService = hmac(kRegion, service);
+    return hmac(kService, 'aws4_request');
+}
+function amzTimestamp(date) {
+    return date.toISOString().replace(/[:-]|\.\d{3}/g, '');
+}
+function hmac(key, value) {
+    return crypto.createHmac('sha256', key).update(value, 'utf8').digest();
+}
+function hmacHex(key, value) {
+    return crypto.createHmac('sha256', key).update(value, 'utf8').digest('hex');
+}
+function sha256Hex(value) {
+    return crypto.createHash('sha256').update(value, 'utf8').digest('hex');
+}
+function pageRouteSegment(route) {
+    const clean = cleanPath(route);
+    return clean === '' ? 'index' : clean;
+}
+function activeReleaseKey(siteId) {
+    return `activeRelease_${edgeKeySegment(siteId)}`;
+}
+function deploymentCompatibilityKey(siteId, deploymentId) {
+    return `deploymentCompatibility_${edgeKeySegment(siteId)}_${edgeKeySegment(deploymentId)}`;
+}
+async function activeReleasePointer(edgeConfig, siteId) {
+    const value = await getEdgeConfigValue(edgeConfig, activeReleaseKey(siteId));
+    if (!value)
+        return { releaseId: '' };
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (parsed.releaseId)
+                return parsed;
+        }
+        catch {
+            return { releaseId: value };
+        }
+        return { releaseId: value };
+    }
+    const pointer = value;
+    return { releaseId: pointer.releaseId || '', sequence: pointer.sequence };
+}
+function clampRelease(activeReleaseId, activeSequence, compatibility) {
+    if (!activeSequence)
+        return activeReleaseId;
+    if (compatibility.minSequence && activeSequence < compatibility.minSequence && compatibility.minReleaseId) {
+        return compatibility.minReleaseId;
+    }
+    if (compatibility.maxSequence && activeSequence > compatibility.maxSequence && compatibility.maxReleaseId) {
+        return compatibility.maxReleaseId;
+    }
+    return activeReleaseId;
+}
+function edgeKeySegment(value) {
+    return value.replace(/[^A-Za-z0-9_-]/g, '_');
+}
+function cleanPath(value) {
+    return value.replace(/^\/+|\/+$/g, '').replace(/\/+/g, '/');
+}
+function joinKey(...parts) {
+    return parts.map(cleanPath).filter(Boolean).join('/');
+}
+function encodeKey(key) {
+    return `/${key.split('/').map(encodeURIComponent).join('/')}`;
+}
+function trimSlash(value) {
+    return value.replace(/\/+$/, '');
+}

package/dist/providers/file.d.ts

@@ -0,0 +1,18 @@
+import { type ContentPathOptions } from '../content/routes.js';
+import { type ContentProvider, type RenderInputOptions } from '../content/provider.js';
+import type { KernelPage, KernelRouteMetadata, KernelSiteConfig, RenderInput } from '../content/types.js';
+export interface FileContentProviderOptions extends ContentPathOptions {
+    parseSiteConfig?: (value: unknown, source: string) => KernelSiteConfig;
+    parsePage?: (value: unknown, source: string) => KernelPage;
+}
+export declare class FileContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> implements ContentProvider<TPage, TSiteConfig> {
+    readonly options: FileContentProviderOptions;
+    constructor(options?: FileContentProviderOptions);
+    loadSiteConfig(): Promise<TSiteConfig>;
+    loadPage(route?: string): Promise<TPage | null>;
+    listRoutes(): Promise<string[]>;
+    listPublishedRoutes(): Promise<string[]>;
+    resolveRouteMetadata(route?: string): Promise<KernelRouteMetadata>;
+    loadRenderInput(route?: string, options?: RenderInputOptions): Promise<RenderInput<TPage, TSiteConfig>>;
+}
+export declare function createFileContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig>(options?: FileContentProviderOptions): FileContentProvider<TPage, TSiteConfig>;

package/dist/providers/file.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { localeRoot, normalizeRoute, routeFromRelativePagePath, routeToPagePath, siteRoot } from '../content/routes.js';
+import { loadRenderInput, routeMetadataForContent } from '../content/provider.js';
+import { parseKernelPage, parseKernelSiteConfig } from '../content/validation.js';
+export class FileContentProvider {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async loadSiteConfig() {
+        const source = path.join(siteRoot(this.options), 'site.json');
+        const parsed = await readJSON(source);
+        const value = this.options.parseSiteConfig
+            ? this.options.parseSiteConfig(parsed, source)
+            : parseKernelSiteConfig(parsed, source);
+        return value;
+    }
+    async loadPage(route = '/') {
+        const source = routeToPagePath(route, this.options);
+        try {
+            const parsed = await readJSON(source);
+            const value = this.options.parsePage
+                ? this.options.parsePage(parsed, source)
+                : parseKernelPage(parsed, source);
+            return value;
+        }
+        catch (error) {
+            if (isNotFound(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async listRoutes() {
+        const files = await walk(localeRoot(this.options));
+        return files
+            .filter((entry) => entry.endsWith('/_index.json'))
+            .map((entry) => routeFromRelativePagePath(entry))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    async listPublishedRoutes() {
+        const routes = await this.listRoutes();
+        const pages = await Promise.all(routes.map(async (route) => ({
+            route,
+            page: await this.loadPage(route)
+        })));
+        return pages
+            .filter((entry) => entry.page?.status === 'published')
+            .map((entry) => entry.route);
+    }
+    async resolveRouteMetadata(route = '/') {
+        const normalizedRoute = normalizeRoute(route);
+        const [siteConfig, page] = await Promise.all([
+            this.loadSiteConfig(),
+            this.loadPage(normalizedRoute)
+        ]);
+        return routeMetadataForContent(siteConfig, page);
+    }
+    async loadRenderInput(route = '/', options = {}) {
+        return loadRenderInput(this, route, options);
+    }
+}
+export function createFileContentProvider(options = {}) {
+    return new FileContentProvider(options);
+}
+async function readJSON(source) {
+    const raw = await fs.readFile(source, 'utf8');
+    return JSON.parse(raw);
+}
+async function walk(directory, prefix = '') {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const relative = prefix ? path.join(prefix, entry.name) : entry.name;
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await walk(absolute, relative));
+        }
+        else if (entry.isFile()) {
+            files.push(relative);
+        }
+    }
+    return files;
+}
+function isNotFound(error) {
+    return typeof error === 'object'
+        && error !== null
+        && 'code' in error
+        && error.code === 'ENOENT';
+}

package/dist/sveltekit/index.d.ts

@@ -0,0 +1,2 @@
+import { type BareMetalContentWatchOptions, type VitePluginLike } from '../dev/index.js';
+export declare function baremetalSvelteKit(options?: BareMetalContentWatchOptions): VitePluginLike;

package/dist/sveltekit/index.js

@@ -0,0 +1,18 @@
+import { baremetalContentWatchPlugin, devRefreshPort, devRefreshScriptTag, } from '../dev/index.js';
+export function baremetalSvelteKit(options = {}) {
+    const watchPlugin = baremetalContentWatchPlugin(options);
+    return {
+        ...watchPlugin,
+        name: 'baremetal-sveltekit',
+        transformIndexHtml(html) {
+            if (process.env.NODE_ENV === 'production') {
+                return html;
+            }
+            if (devRefreshPort(options) <= 0) {
+                return html;
+            }
+            const script = devRefreshScriptTag(options);
+            return html.includes('</body>') ? html.replace('</body>', `${script}</body>`) : `${html}${script}`;
+        },
+    };
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,20 @@
+import { type ContentProvider, type RenderInputOptions } from '../content/provider.js';
+import type { KernelPage, KernelRouteMetadata, KernelSiteConfig, RenderInput } from '../content/types.js';
+export interface FixtureContentProviderOptions<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> {
+    siteConfig?: TSiteConfig;
+    pages?: Record<string, TPage | null>;
+}
+export declare class FixtureContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> implements ContentProvider<TPage, TSiteConfig> {
+    private siteConfig;
+    private pages;
+    constructor(options?: FixtureContentProviderOptions<TPage, TSiteConfig>);
+    loadSiteConfig(): Promise<TSiteConfig>;
+    loadPage(route?: string): Promise<TPage | null>;
+    listRoutes(): Promise<string[]>;
+    listPublishedRoutes(): Promise<string[]>;
+    resolveRouteMetadata(route?: string): Promise<KernelRouteMetadata>;
+    loadRenderInput(route?: string, options?: RenderInputOptions): Promise<RenderInput<TPage, TSiteConfig>>;
+}
+export declare function createFixtureContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig>(options?: FixtureContentProviderOptions<TPage, TSiteConfig>): FixtureContentProvider<TPage, TSiteConfig>;
+export declare function defaultFixtureSiteConfig(): KernelSiteConfig;
+export declare function defaultFixturePage(): KernelPage;