@gradial/aci 0.1.0 → 0.1.1

package/README.md

@@ -56,7 +56,7 @@ Use this in unit tests when you want the same provider API as
 Publish from this package directory:
 
 ```bash
-npm publish --access restricted
+npm publish --access public
 ```
 
 The package includes a `prepack` script that builds `dist` before packing or

package/bin/aci.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+
+const PLATFORMS = {
+  'darwin-arm64': '@gradial/cli-darwin-arm64',
+  'darwin-x64': '@gradial/cli-darwin-x64',
+  'linux-x64': '@gradial/cli-linux-x64',
+  'linux-arm64': '@gradial/cli-linux-arm64',
+  'win32-x64': '@gradial/cli-win32-x64',
+};
+
+const key = `${process.platform}-${process.arch}`;
+const pkg = PLATFORMS[key];
+if (!pkg) {
+  console.error(`ACI: unsupported platform ${key}`);
+  process.exit(1);
+}
+
+const ext = process.platform === 'win32' ? '.exe' : '';
+let bin;
+const localBin = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'bin', `aci${ext}`);
+if (process.env.ACI_BIN) {
+  bin = process.env.ACI_BIN;
+} else if (existsSync(localBin)) {
+  bin = localBin;
+}
+
+try {
+  bin ||= require.resolve(`${pkg}/bin/aci${ext}`);
+} catch {
+  console.error('ACI: binary not installed. Run: npm install');
+  process.exit(1);
+}
+
+try {
+  execFileSync(bin, process.argv.slice(2), { stdio: 'inherit' });
+} catch (error) {
+  process.exit(error.status ?? 1);
+}

package/dist/assets/index.d.ts

@@ -0,0 +1 @@
+export { type GradialImage, type ImageSource, type PictureSource, type ImageSlotContract, type SlotOutput, type ImageHTMLAttributes, GradialImageSchema, renderImageHTML, } from '../types/image.js';

package/dist/assets/index.js

@@ -0,0 +1 @@
+export { GradialImageSchema, renderImageHTML, } from '../types/image.js';

package/dist/astro/index.d.ts

@@ -1,4 +1,4 @@
-import { type BareMetalContentWatchOptions } from '../dev/index.js';
+import { type GradialContentWatchOptions } from '../dev/index.js';
 interface AstroConfigSetupParams {
     injectScript(stage: 'head-inline' | 'page' | 'page-ssr', content: string): void;
     updateConfig(config: {
@@ -7,11 +7,33 @@ interface AstroConfigSetupParams {
         };
     }): void;
 }
+interface AstroBuildDoneParams {
+    dir: URL;
+}
 export interface AstroIntegrationLike {
     name: string;
     hooks: {
         'astro:config:setup'(params: AstroConfigSetupParams): void;
+        'astro:build:done'?(params: AstroBuildDoneParams): void;
+    };
+}
+/**
+ * Generates static paths from the compiled content manifest for Astro.
+ *
+ * Usage in a catch-all page (e.g. `pages/[...slug].astro`):
+ * ```ts
+ * import { getGradialStaticPaths } from '@gradial/aci/astro';
+ * export const getStaticPaths = getGradialStaticPaths;
+ * ```
+ */
+export declare function getGradialStaticPaths(): Promise<Array<{
+    params: {
+        slug?: string;
     };
+}>>;
+export interface GradialAstroOptions extends GradialContentWatchOptions {
+    /** Path to compiled content root. Defaults to ACI_CONTENT_ROOT env or '.aci/compiled' */
+    compiledRoot?: string;
 }
-export declare function baremetalAstro(options?: BareMetalContentWatchOptions): AstroIntegrationLike;
+export declare function gradialAstro(options?: GradialAstroOptions): AstroIntegrationLike;
 export {};

package/dist/astro/index.js

@@ -1,7 +1,35 @@
-import { baremetalContentWatchPlugin, devRefreshPort, devRefreshScript, } from '../dev/index.js';
-export function baremetalAstro(options = {}) {
+import fs from 'node:fs';
+import path from 'node:path';
+import { gradialContentWatchPlugin, devRefreshPort, devRefreshScript, } from '../dev/index.js';
+// ---------------------------------------------------------------------------
+// Static paths helper — for Astro SSG
+// ---------------------------------------------------------------------------
+/**
+ * Generates static paths from the compiled content manifest for Astro.
+ *
+ * Usage in a catch-all page (e.g. `pages/[...slug].astro`):
+ * ```ts
+ * import { getGradialStaticPaths } from '@gradial/aci/astro';
+ * export const getStaticPaths = getGradialStaticPaths;
+ * ```
+ */
+export async function getGradialStaticPaths() {
+    const { FileContentProvider } = await import('../providers/file.js');
+    const { normalizeRoute } = await import('../content/routes.js');
+    const provider = new FileContentProvider();
+    const routes = await provider.listRoutes();
+    return routes.map((entry) => {
+        const normalized = normalizeRoute(entry.path);
+        return {
+            params: {
+                slug: normalized === '/' ? undefined : normalized.replace(/^\/|\/$/g, '')
+            }
+        };
+    });
+}
+export function gradialAstro(options = {}) {
     return {
-        name: 'baremetal-astro',
+        name: 'gradial-astro',
         hooks: {
             'astro:config:setup'({ injectScript, updateConfig }) {
                 if (process.env.NODE_ENV === 'production') {
@@ -12,10 +40,20 @@ export function baremetalAstro(options = {}) {
                 }
                 updateConfig({
                     vite: {
-                        plugins: [baremetalContentWatchPlugin(options)],
+                        plugins: [gradialContentWatchPlugin(options)],
                     },
                 });
             },
+            'astro:build:done'({ dir }) {
+                const siteDir = process.cwd();
+                const compiledRoot = path.resolve(siteDir, options.compiledRoot || process.env.ACI_CONTENT_ROOT || '.aci/compiled');
+                const source = path.join(compiledRoot, '.aci-dam');
+                if (!fs.existsSync(source))
+                    return;
+                const target = path.join(dir.pathname, '.aci-dam');
+                fs.rmSync(target, { recursive: true, force: true });
+                fs.cpSync(source, target, { recursive: true });
+            },
         },
     };
 }

package/dist/content/index.d.ts

@@ -1,6 +1,3 @@
-export * from './contract.js';
 export * from './provider.js';
 export * from './routes.js';
-export * from './tailwind-validator.js';
 export * from './types.js';
-export * from './validation.js';

package/dist/content/index.js

@@ -1,6 +1,3 @@
-export * from './contract.js';
 export * from './provider.js';
 export * from './routes.js';
-export * from './tailwind-validator.js';
 export * from './types.js';
-export * from './validation.js';

package/dist/content/provider.d.ts

@@ -1,15 +1,39 @@
 import type { KernelPage, KernelRouteMetadata, KernelSiteConfig, RenderInput } from './types.js';
-export interface ContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> {
-    loadSiteConfig(): Promise<TSiteConfig>;
-    loadPage(route?: string): Promise<TPage | null>;
-    listRoutes(): Promise<string[]>;
-    listPublishedRoutes?(): Promise<string[]>;
-    resolveRouteMetadata?(route?: string): Promise<KernelRouteMetadata>;
+export interface RouteEntry {
+    slug: string;
+    path: string;
+    payloadRef: string;
+    digest: string;
+    fragmentRefs?: string[];
+}
+export interface FragmentEntry {
+    id: string;
+    payloadRef: string;
+    digest: string;
+    fragmentRefs?: string[];
+}
+export interface CompiledManifest {
+    manifestVersion: string;
+    buildDigest: string;
+    siteConfigRef: string;
+    routes: Record<string, RouteEntry>;
+    fragments: Record<string, FragmentEntry>;
+}
+export interface ContentProvider {
+    getSiteConfig<T = unknown>(): Promise<T>;
+    getPage<T = unknown>(route: string): Promise<T>;
+    getFragment<T = unknown>(id: string): Promise<T>;
+    listRoutes(): Promise<RouteEntry[]>;
+}
+export declare class PageNotFoundError extends Error {
+    constructor(route: string, cause?: unknown);
+}
+export declare class FragmentNotFoundError extends Error {
+    constructor(id: string, cause?: unknown);
 }
 export interface RenderInputOptions {
     domain?: string;
     locale?: string;
 }
-export declare function loadRenderInput<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig>(provider: ContentProvider<TPage, TSiteConfig>, route?: string, options?: RenderInputOptions): Promise<RenderInput<TPage, TSiteConfig>>;
+export declare function loadRenderInput(provider: ContentProvider, route?: string, options?: RenderInputOptions): Promise<RenderInput>;
 export declare function routeMetadataForContent(siteConfig: KernelSiteConfig, page: KernelPage | null): KernelRouteMetadata;
-export declare function resolveRouteMetadata(provider: ContentProvider, route?: string): Promise<KernelRouteMetadata>;

package/dist/content/provider.js

@@ -1,14 +1,35 @@
 import { normalizeRoute } from './routes.js';
+// ---------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------
+export class PageNotFoundError extends Error {
+    constructor(route, cause) {
+        super(`Page not found for route ${route}`);
+        this.name = 'PageNotFoundError';
+        this.cause = cause;
+    }
+}
+export class FragmentNotFoundError extends Error {
+    constructor(id, cause) {
+        super(`Fragment not found: ${id}`);
+        this.name = 'FragmentNotFoundError';
+        this.cause = cause;
+    }
+}
 export async function loadRenderInput(provider, route = '/', options = {}) {
-    const normalizedRoute = normalizeRoute(route);
+    const normalized = normalizeRoute(route);
     const [siteConfig, page] = await Promise.all([
-        provider.loadSiteConfig(),
-        provider.loadPage(normalizedRoute)
+        provider.getSiteConfig(),
+        provider.getPage(normalized).catch((error) => {
+            if (error instanceof PageNotFoundError)
+                return null;
+            throw error;
+        })
     ]);
     return {
-        route: normalizedRoute,
+        route: normalized,
         domain: options.domain || siteConfig.domain,
-        locale: (options.locale || siteConfig.defaultLocale).toLowerCase(),
+        locale: (options.locale || siteConfig.defaultLocale || 'en-us').toLowerCase(),
         siteConfig,
         page
     };
@@ -23,14 +44,3 @@ export function routeMetadataForContent(siteConfig, page) {
         siteName: siteConfig.seo?.siteName || siteConfig.title
     };
 }
-export async function resolveRouteMetadata(provider, route = '/') {
-    if (provider.resolveRouteMetadata) {
-        return provider.resolveRouteMetadata(route);
-    }
-    const normalizedRoute = normalizeRoute(route);
-    const [siteConfig, page] = await Promise.all([
-        provider.loadSiteConfig(),
-        provider.loadPage(normalizedRoute)
-    ]);
-    return routeMetadataForContent(siteConfig, page);
-}

package/dist/content/routes.d.ts

@@ -1,16 +1,10 @@
-export declare const DEFAULT_DOMAIN = "www.baremetal.local";
+export declare const DEFAULT_DOMAIN = "www.aci.local";
 export declare const DEFAULT_LOCALE = "en-us";
-export interface ContentPathOptions {
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    maxWorkspaceDepth?: number;
-}
 export declare function activeDomain(env?: NodeJS.ProcessEnv): string;
 export declare function activeLocale(env?: NodeJS.ProcessEnv): string;
 export declare function normalizeRoute(route: string): string;
-export declare function workspaceRoot(options?: ContentPathOptions): string;
-export declare function contentRoot(options?: ContentPathOptions): string;
-export declare function siteRoot(options?: ContentPathOptions): string;
-export declare function localeRoot(options?: ContentPathOptions): string;
-export declare function routeToPagePath(route: string, options?: ContentPathOptions): string;
-export declare function routeFromRelativePagePath(relativePath: string): string;
+/**
+ * Returns the root directory for compiled content output.
+ * Reads from ACI_CONTENT_ROOT or defaults to `.aci/compiled` relative to cwd.
+ */
+export declare function compiledContentRoot(env?: NodeJS.ProcessEnv): string;

package/dist/content/routes.js

@@ -1,15 +1,11 @@
-import fs from 'node:fs';
 import path from 'node:path';
-export const DEFAULT_DOMAIN = 'www.baremetal.local';
+export const DEFAULT_DOMAIN = 'www.aci.local';
 export const DEFAULT_LOCALE = 'en-us';
-function resolveFrom(cwd, value) {
-    return path.isAbsolute(value) ? value : path.resolve(cwd, value);
-}
 export function activeDomain(env = process.env) {
-    return env.BARE_METAL_DOMAIN || DEFAULT_DOMAIN;
+    return env.ACI_DOMAIN || DEFAULT_DOMAIN;
 }
 export function activeLocale(env = process.env) {
-    return (env.BARE_METAL_LOCALE || DEFAULT_LOCALE).toLowerCase();
+    return (env.ACI_LOCALE || DEFAULT_LOCALE).toLowerCase();
 }
 export function normalizeRoute(route) {
     const trimmed = String(route || '').trim();
@@ -18,52 +14,10 @@ export function normalizeRoute(route) {
     }
     return `/${trimmed.replace(/^\/+/, '').replace(/\/+$/, '')}`;
 }
-export function workspaceRoot(options = {}) {
-    const cwd = options.cwd || process.cwd();
-    const env = options.env || process.env;
-    if (env.BARE_METAL_WORKSPACE_ROOT) {
-        return resolveFrom(cwd, env.BARE_METAL_WORKSPACE_ROOT);
-    }
-    let current = cwd;
-    const maxDepth = options.maxWorkspaceDepth ?? 6;
-    for (let depth = 0; depth < maxDepth; depth += 1) {
-        if (fs.existsSync(path.join(current, '.content', 'config', 'site.json'))) {
-            return current;
-        }
-        const parent = path.dirname(current);
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    return cwd;
-}
-export function contentRoot(options = {}) {
-    const cwd = options.cwd || process.cwd();
-    const env = options.env || process.env;
-    if (env.BARE_METAL_CONTENT_ROOT) {
-        return resolveFrom(cwd, env.BARE_METAL_CONTENT_ROOT);
-    }
-    return path.join(workspaceRoot(options), '.content');
-}
-export function siteRoot(options = {}) {
-    return path.join(contentRoot(options), 'config');
-}
-export function localeRoot(options = {}) {
-    return path.join(contentRoot(options), 'pages');
-}
-export function routeToPagePath(route, options = {}) {
-    const normalized = normalizeRoute(route);
-    if (normalized === '/') {
-        return path.join(localeRoot(options), 'home', '_index.json');
-    }
-    return path.join(localeRoot(options), normalized.slice(1), '_index.json');
-}
-export function routeFromRelativePagePath(relativePath) {
-    const normalized = relativePath.split(/[\\/]+/).join('/');
-    const slug = normalized.replace(/\/_index\.json$/, '');
-    if (slug === 'home') {
-        return '/';
-    }
-    return normalizeRoute(slug);
+/**
+ * Returns the root directory for compiled content output.
+ * Reads from ACI_CONTENT_ROOT or defaults to `.aci/compiled` relative to cwd.
+ */
+export function compiledContentRoot(env = process.env) {
+    return env.ACI_CONTENT_ROOT || path.resolve(process.cwd(), '.aci/compiled');
 }

package/dist/content/validation.js

@@ -165,7 +165,7 @@ export function formatZodError(source, error) {
         return `- ${path}: ${issue.message}`;
     })
         .join('\n');
-    return `Invalid bare-metal content in ${source}:\n${issues}`;
+    return `Invalid Gradial content in ${source}:\n${issues}`;
 }
 export function parseWithSchema(schema, value, source) {
     const parsed = schema.safeParse(value);

package/dist/define-layout.js

@@ -1,5 +1,9 @@
 export function defineLayout(definition) {
-    return definition;
+    return {
+        name: definition.name,
+        slots: definition.slots,
+        defaults: definition.defaults,
+    };
 }
 export function slot(name, required = false) {
     return { name, required };

package/dist/dev/browser.d.ts

@@ -1,5 +1,5 @@
 export declare const DEFAULT_DEV_REFRESH_PORT = 24680;
-export declare const DEFAULT_DEV_REFRESH_PATH = "/baremetal-dev";
+export declare const DEFAULT_DEV_REFRESH_PATH = "/aci-dev";
 export interface DevRefreshOptions {
     wsPort?: number | string;
     path?: string;

package/dist/dev/browser.js

@@ -1,2 +1,2 @@
 export const DEFAULT_DEV_REFRESH_PORT = 24680;
-export const DEFAULT_DEV_REFRESH_PATH = '/baremetal-dev';
+export const DEFAULT_DEV_REFRESH_PATH = '/aci-dev';

package/dist/dev/index.d.ts

@@ -2,10 +2,10 @@ import { type DevRefreshOptions } from './browser.js';
 export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, type DevRefreshOptions } from './browser.js';
 declare global {
     interface Window {
-        __bareMetalDevRefresh?: boolean;
+        __gradialDevRefresh?: boolean;
     }
 }
-export interface BareMetalContentWatchOptions extends DevRefreshOptions {
+export interface GradialContentWatchOptions extends DevRefreshOptions {
     contentRoot?: string;
     enabled?: boolean;
 }
@@ -27,4 +27,4 @@ export interface VitePluginLike {
 export declare function devRefreshPort(options?: DevRefreshOptions): number;
 export declare function devRefreshScript(options?: DevRefreshOptions): string;
 export declare function devRefreshScriptTag(options?: DevRefreshOptions): string;
-export declare function baremetalContentWatchPlugin(options?: BareMetalContentWatchOptions): VitePluginLike;
+export declare function gradialContentWatchPlugin(options?: GradialContentWatchOptions): VitePluginLike;

package/dist/dev/index.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { contentRoot } from '../content/routes.js';
+import { compiledContentRoot } from '../content/routes.js';
 import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from './browser.js';
 export { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT } from './browser.js';
 function numberOption(value, fallback) {
@@ -10,7 +10,7 @@ function numberOption(value, fallback) {
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 export function devRefreshPort(options = {}) {
-    const value = options.wsPort ?? process.env.BARE_METAL_DEV_WS_PORT;
+    const value = options.wsPort ?? process.env.ACI_DEV_WS_PORT;
     if (value === 0 || value === '0') {
         return 0;
     }
@@ -24,8 +24,8 @@ export function devRefreshScript(options = {}) {
     const wsPath = options.path || DEFAULT_DEV_REFRESH_PATH;
     const reconnectMs = numberOption(options.reconnectMs, 1000);
     return `(() => {
-  if (typeof window === 'undefined' || window.__bareMetalDevRefresh) return;
-  window.__bareMetalDevRefresh = true;
+  if (typeof window === 'undefined' || window.__gradialDevRefresh) return;
+  window.__gradialDevRefresh = true;
   const port = ${JSON.stringify(wsPort)};
   const path = ${JSON.stringify(wsPath)};
   const reconnectMs = ${JSON.stringify(reconnectMs)};
@@ -47,16 +47,16 @@ export function devRefreshScript(options = {}) {
 export function devRefreshScriptTag(options = {}) {
     return `<script>${devRefreshScript(options)}</script>`;
 }
-export function baremetalContentWatchPlugin(options = {}) {
-    const enabled = options.enabled ?? process.env.BARE_METAL_DISABLE_CONTENT_WATCH !== '1';
+export function gradialContentWatchPlugin(options = {}) {
+    const enabled = options.enabled ?? process.env.ACI_DISABLE_CONTENT_WATCH !== '1';
     return {
-        name: 'baremetal-content-watch',
+        name: 'gradial-content-watch',
         apply: 'serve',
         configureServer(server) {
             if (!enabled) {
                 return;
             }
-            const root = path.resolve(options.contentRoot || contentRoot());
+            const root = path.resolve(options.contentRoot || compiledContentRoot());
             server.watcher.add(root);
             server.watcher.on('all', (_eventName, filePath) => {
                 const changed = path.resolve(filePath);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './define-component.js';
 export * from './define-layout.js';
+export * from './content/index.js';
 export * from './types/index.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './define-component.js';
 export * from './define-layout.js';
+export * from './content/index.js';
 export * from './types/index.js';

package/dist/next/config.d.ts

@@ -0,0 +1,14 @@
+interface NextRewrite {
+    source: string;
+    destination: string;
+}
+interface NextConfig {
+    rewrites?: () => Promise<NextRewrite[]> | NextRewrite[];
+    [key: string]: unknown;
+}
+export interface WithGradialOptions {
+    /** Asset rewrite prefix. Defaults to '/.aci-dam' */
+    assetPrefix?: string;
+}
+export declare function withGradial(nextConfig?: NextConfig, options?: WithGradialOptions): NextConfig;
+export {};

package/dist/next/config.js

@@ -0,0 +1,22 @@
+export function withGradial(nextConfig = {}, options = {}) {
+    const assetPrefix = options.assetPrefix || '/.aci-dam';
+    const userRewrites = nextConfig.rewrites;
+    return {
+        ...nextConfig,
+        rewrites: async () => {
+            const gradialRewrites = [
+                {
+                    source: `${assetPrefix}/:path*`,
+                    destination: `/api/aci-assets${assetPrefix}/:path*`,
+                },
+            ];
+            if (!userRewrites)
+                return gradialRewrites;
+            const userResult = await (typeof userRewrites === 'function' ? userRewrites() : userRewrites);
+            if (Array.isArray(userResult)) {
+                return [...gradialRewrites, ...userResult];
+            }
+            return gradialRewrites;
+        },
+    };
+}

package/dist/next/dev-refresh.js

@@ -3,10 +3,10 @@ import { useEffect } from 'react';
 import { DEFAULT_DEV_REFRESH_PATH, DEFAULT_DEV_REFRESH_PORT, } from '../dev/browser.js';
 export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', wsPort = DEFAULT_DEV_REFRESH_PORT, path = DEFAULT_DEV_REFRESH_PATH, reconnectMs = 1000, }) {
     useEffect(() => {
-        if (!enabled || Number(wsPort) <= 0 || typeof window === 'undefined' || window.__bareMetalDevRefresh) {
+        if (!enabled || Number(wsPort) <= 0 || typeof window === 'undefined' || window.__gradialDevRefresh) {
             return undefined;
         }
-        window.__bareMetalDevRefresh = true;
+        window.__gradialDevRefresh = true;
         let reconnectTimer;
         let socket;
         let active = true;
@@ -21,7 +21,7 @@ export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', ws
                     }
                 }
                 catch {
-                    // Ignore non-Bare Metal dev server frames.
+                    // Ignore non-Gradial dev server frames.
                 }
             });
             socket.addEventListener('close', () => {
@@ -33,7 +33,7 @@ export function DevRefresh({ enabled = process.env.NODE_ENV !== 'production', ws
         connect();
         return () => {
             active = false;
-            window.__bareMetalDevRefresh = false;
+            window.__gradialDevRefresh = false;
             if (reconnectTimer) {
                 clearTimeout(reconnectTimer);
             }

package/dist/next/edge-config.d.ts

@@ -0,0 +1 @@
+export declare function getUncachedEdgeConfigValue(edgeConfig: string, key: string): Promise<unknown>;