@gradial/aci 0.1.0 → 0.1.1

package/dist/providers/s3.js

@@ -0,0 +1,162 @@
+import crypto from 'node:crypto';
+import { FragmentNotFoundError, PageNotFoundError } from '../content/provider.js';
+import { normalizeRoute } from '../content/routes.js';
+// ---------------------------------------------------------------------------
+// S3 content provider — reads compiled manifest + payloads from S3
+// ---------------------------------------------------------------------------
+export class S3ContentProvider {
+    config;
+    #manifest;
+    constructor(config = {}) {
+        this.config = resolveS3Config(config);
+    }
+    async listRoutes() {
+        const manifest = await this.manifest();
+        return Object.values(manifest.routes).sort((a, b) => a.path.localeCompare(b.path));
+    }
+    async getSiteConfig() {
+        const manifest = await this.manifest();
+        return await this.getJSON(manifest.siteConfigRef);
+    }
+    async getPage(route) {
+        const manifest = await this.manifest();
+        const normalized = normalizeRoute(route);
+        const entry = Object.values(manifest.routes).find((candidate) => normalizeRoute(candidate.path) === normalized);
+        if (!entry) {
+            throw new PageNotFoundError(route);
+        }
+        try {
+            return await this.getJSON(entry.payloadRef);
+        }
+        catch (error) {
+            throw new PageNotFoundError(route, error);
+        }
+    }
+    async getFragment(id) {
+        const manifest = await this.manifest();
+        const entry = manifest.fragments[id];
+        if (!entry) {
+            throw new FragmentNotFoundError(id);
+        }
+        try {
+            return await this.getJSON(entry.payloadRef);
+        }
+        catch (error) {
+            throw new FragmentNotFoundError(id, error);
+        }
+    }
+    async manifest() {
+        this.#manifest ??= this.getJSON('manifest.json');
+        return await this.#manifest;
+    }
+    async getJSON(key) {
+        return await getS3JSON(joinKey(this.config.keyPrefix, key), this.config);
+    }
+}
+// ---------------------------------------------------------------------------
+// S3 fetch with AWS SigV4 signing
+// ---------------------------------------------------------------------------
+export async function getS3JSON(key, config) {
+    const url = s3ObjectURL(config, key);
+    const signedHeaders = signedS3Headers('GET', url, config);
+    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());
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function resolveS3Config(config) {
+    const resolved = {
+        bucket: config.bucket || process.env.ACI_S3_BUCKET || '',
+        keyPrefix: config.keyPrefix || process.env.ACI_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.ACI_S3_ENDPOINT || '')
+    };
+    for (const key of ['bucket', 'accessKeyId', 'secretAccessKey']) {
+        if (!resolved[key])
+            throw new Error(`S3 config missing ${key}`);
+    }
+    return resolved;
+}
+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((k) => `${k}:${headers.get(k)?.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 trimSlash(value) {
+    return value.replace(/\/+$/, '');
+}
+function encodeKey(key) {
+    return `/${key.split('/').map(encodeURIComponent).join('/')}`;
+}
+function joinKey(...parts) {
+    return parts
+        .flatMap((part) => part.split('/'))
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join('/');
+}

package/dist/sveltekit/index.d.ts

@@ -1,2 +1,18 @@
-import { type BareMetalContentWatchOptions, type VitePluginLike } from '../dev/index.js';
-export declare function baremetalSvelteKit(options?: BareMetalContentWatchOptions): VitePluginLike;
+import { type GradialContentWatchOptions, type VitePluginLike } from '../dev/index.js';
+/**
+ * Generates prerender entries from the compiled content manifest for SvelteKit.
+ *
+ * Usage in svelte.config.js:
+ * ```js
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export default { kit: { prerender: { entries: await gradialEntries() } } };
+ * ```
+ *
+ * Or in a catch-all `+page.server.ts`:
+ * ```ts
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export const entries = gradialEntries;
+ * ```
+ */
+export declare function gradialEntries(): Promise<string[]>;
+export declare function gradialSvelteKit(options?: GradialContentWatchOptions): VitePluginLike;

package/dist/sveltekit/index.js

@@ -1,9 +1,40 @@
-import { baremetalContentWatchPlugin, devRefreshPort, devRefreshScriptTag, } from '../dev/index.js';
-export function baremetalSvelteKit(options = {}) {
-    const watchPlugin = baremetalContentWatchPlugin(options);
+import { gradialContentWatchPlugin, devRefreshPort, devRefreshScriptTag, } from '../dev/index.js';
+// ---------------------------------------------------------------------------
+// Entries helper — for SvelteKit SSG prerendering
+// ---------------------------------------------------------------------------
+/**
+ * Generates prerender entries from the compiled content manifest for SvelteKit.
+ *
+ * Usage in svelte.config.js:
+ * ```js
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export default { kit: { prerender: { entries: await gradialEntries() } } };
+ * ```
+ *
+ * Or in a catch-all `+page.server.ts`:
+ * ```ts
+ * import { gradialEntries } from '@gradial/aci/sveltekit';
+ * export const entries = gradialEntries;
+ * ```
+ */
+export async function gradialEntries() {
+    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 normalized === '/' ? '/' : `/${normalized.replace(/^\/|\/$/g, '')}/`;
+    });
+}
+// ---------------------------------------------------------------------------
+// SvelteKit Vite plugin
+// ---------------------------------------------------------------------------
+export function gradialSvelteKit(options = {}) {
+    const watchPlugin = gradialContentWatchPlugin(options);
     return {
         ...watchPlugin,
-        name: 'baremetal-sveltekit',
+        name: 'gradial-sveltekit',
         transformIndexHtml(html) {
             if (process.env.NODE_ENV === 'production') {
                 return html;

package/dist/testing/index.d.ts

@@ -1,20 +1,22 @@
-import { type ContentProvider, type RenderInputOptions } from '../content/provider.js';
+import { type ContentProvider, type RouteEntry, 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 interface FixtureContentProviderOptions {
+    siteConfig?: KernelSiteConfig;
+    pages?: Record<string, KernelPage>;
+    fragments?: Record<string, unknown>;
 }
-export declare class FixtureContentProvider<TPage extends KernelPage = KernelPage, TSiteConfig extends KernelSiteConfig = KernelSiteConfig> implements ContentProvider<TPage, TSiteConfig> {
+export declare class FixtureContentProvider implements ContentProvider {
     private siteConfig;
     private pages;
-    constructor(options?: FixtureContentProviderOptions<TPage, TSiteConfig>);
-    loadSiteConfig(): Promise<TSiteConfig>;
-    loadPage(route?: string): Promise<TPage | null>;
-    listRoutes(): Promise<string[]>;
-    listPublishedRoutes(): Promise<string[]>;
+    private fragments;
+    constructor(options?: FixtureContentProviderOptions);
+    getSiteConfig<T = unknown>(): Promise<T>;
+    getPage<T = unknown>(route: string): Promise<T>;
+    getFragment<T = unknown>(id: string): Promise<T>;
+    listRoutes(): Promise<RouteEntry[]>;
+    loadRenderInput(route?: string, options?: RenderInputOptions): Promise<RenderInput>;
     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 createFixtureContentProvider(options?: FixtureContentProviderOptions): FixtureContentProvider;
 export declare function defaultFixtureSiteConfig(): KernelSiteConfig;
 export declare function defaultFixturePage(): KernelPage;

package/dist/testing/index.js

@@ -1,51 +1,64 @@
-import { loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
+import { PageNotFoundError, FragmentNotFoundError, loadRenderInput, routeMetadataForContent, } from '../content/provider.js';
 import { normalizeRoute } from '../content/routes.js';
 export class FixtureContentProvider {
     siteConfig;
     pages;
+    fragments;
     constructor(options = {}) {
         this.siteConfig = cloneFixture(options.siteConfig ?? defaultFixtureSiteConfig());
         this.pages = new Map();
-        const inputPages = options.pages ?? {
-            '/': defaultFixturePage(),
-        };
+        this.fragments = new Map();
+        const inputPages = options.pages ?? { '/': defaultFixturePage() };
         for (const [route, page] of Object.entries(inputPages)) {
-            if (page) {
-                this.pages.set(normalizeRoute(route), cloneFixture(page));
+            this.pages.set(normalizeRoute(route), cloneFixture(page));
+        }
+        if (options.fragments) {
+            for (const [id, fragment] of Object.entries(options.fragments)) {
+                this.fragments.set(id, cloneFixture(fragment));
             }
         }
     }
-    async loadSiteConfig() {
+    async getSiteConfig() {
         return cloneFixture(this.siteConfig);
     }
-    async loadPage(route = '/') {
+    async getPage(route) {
         const page = this.pages.get(normalizeRoute(route));
-        return page ? cloneFixture(page) : null;
-    }
-    async listRoutes() {
-        return [...this.pages.keys()].sort((left, right) => left.localeCompare(right));
+        if (!page) {
+            throw new PageNotFoundError(route);
+        }
+        return cloneFixture(page);
     }
-    async listPublishedRoutes() {
-        const routes = await this.listRoutes();
-        const published = [];
-        for (const route of routes) {
-            const page = await this.loadPage(route);
-            if (page?.status === 'published') {
-                published.push(route);
-            }
+    async getFragment(id) {
+        const fragment = this.fragments.get(id);
+        if (fragment === undefined) {
+            throw new FragmentNotFoundError(id);
         }
-        return published;
+        return cloneFixture(fragment);
     }
-    async resolveRouteMetadata(route = '/') {
-        const [siteConfig, page] = await Promise.all([
-            this.loadSiteConfig(),
-            this.loadPage(route),
-        ]);
-        return routeMetadataForContent(siteConfig, page);
+    async listRoutes() {
+        return [...this.pages.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([routePath, page]) => ({
+            slug: routePath === '/' ? 'home' : routePath.replace(/^\//, ''),
+            path: routePath,
+            payloadRef: `routes/${routePath === '/' ? 'home' : routePath.replace(/^\//, '')}.json`,
+            digest: '',
+        }));
     }
     async loadRenderInput(route = '/', options = {}) {
         return loadRenderInput(this, route, options);
     }
+    async resolveRouteMetadata(route = '/') {
+        const siteConfig = await this.getSiteConfig();
+        let page;
+        try {
+            page = await this.getPage(route);
+        }
+        catch {
+            page = null;
+        }
+        return routeMetadataForContent(siteConfig, page);
+    }
 }
 export function createFixtureContentProvider(options = {}) {
     return new FixtureContentProvider(options);
@@ -56,7 +69,7 @@ export function defaultFixtureSiteConfig() {
         $type: 'site',
         status: 'published',
         title: 'Fixture Site',
-        domain: 'www.baremetal.local',
+        domain: 'www.aci.local',
         defaultLocale: 'en-us',
         seo: {
             title: 'Fixture Site',

package/dist/types/component.d.ts

@@ -1,26 +1,43 @@
 import type { IslandMode, VaryDimension } from './render-mode.js';
+import type { ImageSlotContract } from './image.js';
+import type { z } from 'zod';
 export interface ComponentRenderModes {
     canStatic: boolean;
     canSSR: boolean;
     canClientIsland: boolean;
 }
+/**
+ * A CMS-registered component — sync or async (server components).
+ * Accepts content props derived from the Zod schema.
+ */
+type CmsComponentFn<TProps = any> = ((props: TProps) => import('react').ReactElement | null) | ((props: TProps) => Promise<import('react').ReactElement | null>);
+/**
+ * Infers the props type from a schema.
+ * If TSchema is a Zod type, returns z.infer<TSchema>.
+ * Otherwise returns Record<string, unknown>.
+ */
+type InferContentProps<TSchema> = TSchema extends z.ZodType<infer T> ? T : Record<string, unknown>;
 export interface ComponentDefinition<TSchema = unknown> {
     name: string;
-    component?: unknown;
+    /** The React component that renders this CMS block. Typed against the schema. */
+    component?: CmsComponentFn<InferContentProps<TSchema>>;
     schema: TSchema;
     renderModes?: ComponentRenderModes;
     render?: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];
+    imageSlots?: Record<string, ImageSlotContract>;
 }
 export interface ComponentContract<TSchema = unknown> {
     name: string;
-    component?: unknown;
+    component?: CmsComponentFn<InferContentProps<TSchema>>;
     schema: TSchema;
     renderModes: ComponentRenderModes;
     render: ComponentRenderModes;
     defaultIslandMode?: IslandMode;
     varyDimensions?: VaryDimension[];
     vary?: VaryDimension[];
+    imageSlots?: Record<string, ImageSlotContract>;
 }
+export type { CmsComponentFn, InferContentProps };

package/dist/types/config.d.ts

@@ -12,6 +12,7 @@ export interface BareMetalConfig {
     rendererEntry: string;
     capabilities: RenderCapabilities;
     routes: RouteConfig;
+    dam?: DAMConfig;
     externalDependencies?: ExternalDependency[];
     rendererProtocol: 'http' | 'stdio-json';
 }
@@ -26,3 +27,6 @@ export interface ExternalDependency {
     description?: string;
     cacheTTL?: number;
 }
+export interface DAMConfig {
+    autoApproveUploads?: boolean;
+}

package/dist/types/image.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export interface ImageSource {
+    src: string;
+    width: number;
+    height: number;
+    type: string;
+}
+export interface PictureSource {
+    media?: string;
+    type: string;
+    srcset: string;
+    sizes?: string;
+}
+export interface GradialImage {
+    $type: 'gradial.image';
+    assetId: string;
+    versionId: string;
+    alt: string;
+    fallback: ImageSource;
+    sources: PictureSource[];
+}
+export interface ImageSlotContract {
+    outputs: SlotOutput[];
+    formats: string[];
+    sizes: string;
+}
+export interface SlotOutput {
+    aspectRatio: string;
+    widths: number[];
+    media?: string;
+}
+export declare const GradialImageSchema: z.ZodObject<{
+    $type: z.ZodLiteral<"gradial.image">;
+    assetId: z.ZodString;
+    versionId: z.ZodString;
+    alt: z.ZodString;
+    fallback: z.ZodObject<{
+        src: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        type: z.ZodString;
+    }, z.core.$strip>;
+    sources: z.ZodArray<z.ZodObject<{
+        media: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+        srcset: z.ZodString;
+        sizes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ImageHTMLAttributes = Record<string, string | number | boolean | undefined | null>;
+export declare function renderImageHTML(image: GradialImage, attrs?: ImageHTMLAttributes): string;

package/dist/types/image.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export const GradialImageSchema = z.object({
+    $type: z.literal('gradial.image'),
+    assetId: z.string().min(1),
+    versionId: z.string().min(1),
+    alt: z.string(),
+    fallback: z.object({
+        src: z.string().min(1),
+        width: z.number().int().nonnegative(),
+        height: z.number().int().nonnegative(),
+        type: z.string().min(1),
+    }),
+    sources: z.array(z.object({
+        media: z.string().optional(),
+        type: z.string().min(1),
+        srcset: z.string().min(1),
+        sizes: z.string().optional(),
+    })),
+});
+export function renderImageHTML(image, attrs = {}) {
+    const imgAttrs = renderAttrs({
+        ...attrs,
+        src: image.fallback.src,
+        alt: image.alt,
+        width: image.fallback.width > 0 ? image.fallback.width : undefined,
+        height: image.fallback.height > 0 ? image.fallback.height : undefined,
+    });
+    const img = `<img${imgAttrs}>`;
+    if (!image.sources.length) {
+        return img;
+    }
+    const sources = image.sources.map((source) => `<source${renderAttrs({
+        media: source.media,
+        type: source.type,
+        srcset: source.srcset,
+        sizes: source.sizes,
+    })}>`).join('');
+    return `<picture>${sources}${img}</picture>`;
+}
+function renderAttrs(attrs) {
+    const rendered = Object.entries(attrs)
+        .filter(([, value]) => value !== undefined && value !== null && value !== false)
+        .map(([name, value]) => value === true ? escapeName(name) : `${escapeName(name)}="${escapeAttr(String(value))}"`);
+    if (!rendered.length) {
+        return '';
+    }
+    return ' ' + rendered.join(' ');
+}
+function escapeName(name) {
+    return name.replace(/[^A-Za-z0-9_:-]/g, '');
+}
+function escapeAttr(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/"/g, '&quot;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}

package/dist/types/index.d.ts

@@ -4,3 +4,4 @@ export * from './layout.js';
 export * from './page.js';
 export * from './renderer.js';
 export * from './render-mode.js';
+export * from './image.js';

package/dist/types/index.js

@@ -4,3 +4,4 @@ export * from './layout.js';
 export * from './page.js';
 export * from './renderer.js';
 export * from './render-mode.js';
+export * from './image.js';

package/dist/types/layout.d.ts

@@ -1,12 +1,24 @@
+import type { FragmentRefNode } from './page.js';
 export interface LayoutSlot {
     name: string;
     required: boolean;
 }
+/** Default content for non-required layout slots, keyed by slot name. */
+export type LayoutDefaults = Record<string, FragmentRefNode[]>;
 export interface LayoutDefinition {
     name: string;
     slots: LayoutSlot[];
+    /** Default fragment references for slots not provided by the page. */
+    defaults?: LayoutDefaults;
 }
 export interface LayoutContract {
     name: string;
     slots: LayoutSlot[];
+    defaults?: LayoutDefaults;
+}
+/** A compiled layout file as stored on disk. */
+export interface CompiledLayout {
+    name: string;
+    slots: LayoutSlot[];
+    defaults: LayoutDefaults;
 }

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@gradial/aci",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
+    "bin/aci.js",
     "src/cli/*.mjs",
     "README.md"
   ],
+  "bin": {
+    "aci": "./bin/aci.js"
+  },
   "publishConfig": {
-    "access": "restricted"
+    "access": "public"
   },
   "exports": {
     ".": {
@@ -41,14 +45,26 @@
       "types": "./dist/providers/file.d.ts",
       "import": "./dist/providers/file.js"
     },
+    "./providers/s3": {
+      "types": "./dist/providers/s3.d.ts",
+      "import": "./dist/providers/s3.js"
+    },
     "./dev": {
       "types": "./dist/dev/index.d.ts",
       "import": "./dist/dev/index.js"
     },
+    "./assets": {
+      "types": "./dist/assets/index.d.ts",
+      "import": "./dist/assets/index.js"
+    },
     "./astro": {
       "types": "./dist/astro/index.d.ts",
       "import": "./dist/astro/index.js"
     },
+    "./next": {
+      "types": "./dist/next/index.d.ts",
+      "import": "./dist/next/index.js"
+    },
     "./next/server": {
       "types": "./dist/next/server.d.ts",
       "import": "./dist/next/server.js",
@@ -72,6 +88,7 @@
       "import": "./dist/testing/index.js"
     },
     "./cli/compile-registry": "./src/cli/compile-registry.mjs",
+    "./cli/validate-content": "./src/cli/validate-content.mjs",
     "./cli/verify-renderer": "./src/cli/verify-renderer.mjs"
   },
   "scripts": {
@@ -99,6 +116,13 @@
       "optional": true
     }
   },
+  "optionalDependencies": {
+    "@gradial/cli-darwin-arm64": "0.1.0",
+    "@gradial/cli-darwin-x64": "0.1.0",
+    "@gradial/cli-linux-x64": "0.1.0",
+    "@gradial/cli-linux-arm64": "0.1.0",
+    "@gradial/cli-win32-x64": "0.1.0"
+  },
   "devDependencies": {
     "@vercel/edge-config": "^1.4.3",
     "@types/node": "^24.10.1",