@gradial/aci 0.1.0 → 0.1.2

package/README.md

@@ -13,7 +13,7 @@ npm install -D typescript tsx
 Common imports:
 
 ```ts
-import { defineComponent, defineLayout, slot } from '@gradial/aci';
+import { defineComponentContract, defineLayoutContract, slot } from '@gradial/aci';
 import type { GradialRenderer } from '@gradial/aci';
 import type { KernelPage, KernelSiteConfig } from '@gradial/aci/content';
 import { createContentSchemas, stringField } from '@gradial/aci/content';
@@ -28,6 +28,51 @@ Framework helpers live under `@gradial/aci/astro`,
 `@gradial/aci/next/server`, `@gradial/aci/next/middleware`,
 `@gradial/aci/next/dev-refresh`, and `@gradial/aci/sveltekit`.
 
+## Component Contracts vs Runtime Components
+
+Keep compile-time CMS contracts separate from runtime component implementation.
+The ACI compiler imports only contract files, so those files must not import
+React, framework components, CSS, or browser-only code.
+
+Recommended shape:
+
+```txt
+src/cms/contracts/components/hero.contract.ts
+src/cms/contracts/components/index.ts
+src/cms/contracts/layouts/index.ts
+src/components/Hero.tsx
+src/cms/renderBlock.tsx
+```
+
+Contract files own names, schemas, render modes, image slots, and other metadata:
+
+```ts
+import { defineComponentContract, GradialImageSchema } from '@gradial/aci';
+import { z } from 'zod';
+
+export const heroContract = defineComponentContract({
+  name: 'hero',
+  schema: z.object({
+    headline: z.string(),
+    image: GradialImageSchema,
+  }),
+  renderModes: { canStatic: true, canSSR: true, canClientIsland: false },
+});
+
+export type HeroProps = z.infer<typeof heroContract.schema>;
+```
+
+Runtime components may import the contract for types, but contract files should
+never import runtime components:
+
+```tsx
+import type { HeroProps } from '../cms/contracts/components/hero.contract';
+
+export function Hero(props: HeroProps) {
+  return <section>{props.headline}</section>;
+}
+```
+
 Testing helpers live under `@gradial/aci/testing`:
 
 ```ts
@@ -56,7 +101,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,157 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const argv = process.argv.slice(2);
+const callerCwd = process.cwd();
+
+const platformPackages = {
+  'darwin-arm64': '@gradial/aci-cli-darwin-arm64',
+  'darwin-x64': '@gradial/aci-cli-darwin-x64',
+  'linux-arm64': '@gradial/aci-cli-linux-arm64',
+  'linux-x64': '@gradial/aci-cli-linux-x64',
+  'win32-x64': '@gradial/aci-cli-win32-x64',
+};
+
+const platformKey = `${process.platform}-${process.arch}`;
+const packageName = platformPackages[platformKey];
+
+if (!packageName) {
+  console.error(`Unsupported platform for aci: ${platformKey}`);
+  process.exit(1);
+}
+
+const binName = process.platform === 'win32' ? 'aci.exe' : 'aci';
+const shimDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(shimDir, '../../..');
+
+function resolveBundledBinary() {
+  const binaryPath = join(shimDir, binName);
+  return existsSync(binaryPath) ? binaryPath : null;
+}
+
+function resolvePackagedBinary() {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const binaryPath = join(dirname(packageJsonPath), 'bin', binName);
+
+    return existsSync(binaryPath) ? binaryPath : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveWorkspaceBinary() {
+  const binaryPath = resolve(shimDir, '..', '..', 'packages', `cli-${platformKey}`, 'bin', binName);
+
+  return existsSync(binaryPath) ? binaryPath : null;
+}
+
+const binaryPath = resolveBundledBinary() ?? resolvePackagedBinary() ?? resolveWorkspaceBinary();
+const fallback = binaryPath ? null : resolveGoFallback();
+
+if (!binaryPath && !fallback) {
+  console.error(
+    [
+      `Could not find the aci binary for ${platformKey}.`,
+      `Install ${packageName} or build the local CLI package with ./scripts/build-cli.sh.`,
+    ].join(' '),
+  );
+  process.exit(1);
+}
+
+const child = binaryPath
+  ? spawn(binaryPath, argv, { stdio: 'inherit' })
+  : spawn(fallback.command, fallback.args, {
+      cwd: fallback.cwd,
+      stdio: 'inherit',
+    });
+
+child.on('error', (error) => {
+  console.error(`Failed to run aci: ${error.message}`);
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+
+  process.exit(code ?? 1);
+});
+
+function resolveGoFallback() {
+  const goModPath = join(repoRoot, 'go.mod');
+  const commandDir = join(repoRoot, 'cmd', 'aci');
+
+  if (!existsSync(goModPath) || !existsSync(commandDir)) {
+    return null;
+  }
+
+  return {
+    command: 'go',
+    args: ['run', './cmd/aci', ...normalizeArgsForGoFallback(argv)],
+    cwd: repoRoot,
+  };
+}
+
+function normalizeArgsForGoFallback(args) {
+  const pathFlags = new Set(['-s', '--site-dir', '--content', '--out']);
+  const normalized = [];
+  let hasSiteDir = false;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (pathFlags.has(arg)) {
+      normalized.push(arg);
+      if (arg === '-s' || arg === '--site-dir') {
+        hasSiteDir = true;
+      }
+
+      const value = args[index + 1];
+      if (value !== undefined) {
+        normalized.push(normalizePathArg(value));
+        index += 1;
+      }
+      continue;
+    }
+
+    if (arg.startsWith('--site-dir=')) {
+      hasSiteDir = true;
+      normalized.push(normalizePathFlagValue(arg));
+      continue;
+    }
+
+    if (arg.startsWith('--content=') || arg.startsWith('--out=')) {
+      normalized.push(normalizePathFlagValue(arg));
+      continue;
+    }
+
+    normalized.push(arg);
+  }
+
+  return hasSiteDir ? normalized : ['--site-dir', callerCwd, ...normalized];
+}
+
+function normalizePathFlagValue(arg) {
+  const separator = arg.indexOf('=');
+  return `${arg.slice(0, separator + 1)}${normalizePathArg(arg.slice(separator + 1))}`;
+}
+
+function normalizePathArg(value) {
+  if (!value || value.startsWith('-') || isAbsolutePath(value)) {
+    return value;
+  }
+
+  return resolve(callerCwd, value);
+}
+
+function isAbsolutePath(value) {
+  return value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
+}

package/dist/assets/index.d.ts

@@ -0,0 +1,3 @@
+export { type GradialImage, type ImageSource, type PictureSource, type ImageSlotContract, type SlotOutput, type ImageHTMLAttributes, GradialImageSchema, renderImageHTML, } from '../types/image.js';
+export { type GradialVideo, type VideoSource, GradialVideoSchema, VideoSourceSchema, } from '../types/video.js';
+export { type GradialAsset, GradialAssetSchema, isGradialImage, isGradialVideo, isGradialAsset, renderVideoHTML, renderAssetHTML, } from '../types/media.js';

package/dist/assets/index.js

@@ -0,0 +1,3 @@
+export { GradialImageSchema, renderImageHTML, } from '../types/image.js';
+export { GradialVideoSchema, VideoSourceSchema, } from '../types/video.js';
+export { GradialAssetSchema, isGradialImage, isGradialVideo, isGradialAsset, renderVideoHTML, renderAssetHTML, } from '../types/media.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, gradialDamAssetPlugin, 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: [gradialDamAssetPlugin(options), 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, '.gradial-dam');
+                if (!fs.existsSync(source))
+                    return;
+                const target = path.join(dir.pathname, '.gradial-dam');
+                fs.rmSync(target, { recursive: true, force: true });
+                fs.cpSync(source, target, { recursive: true });
+            },
         },
     };
 }

package/dist/block-ref.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export interface BlockRefOptions {
+    /** Component names allowed in this slot. Omit to allow any registered component. */
+    allow?: string[];
+}
+/**
+ * Schema helper for nested component references within a parent component.
+ *
+ * Produces a Zod schema for a block entry: `{ id, component, props }`.
+ * When `allow` is provided, `component` is constrained to an enum of the
+ * listed names. This flows into the generated JSON schema, so the content
+ * validator enforces the allowlist at build time.
+ *
+ * @example
+ * ```ts
+ * defineComponent({
+ *   name: 'tabbed_panels',
+ *   schema: z.object({
+ *     tabs: z.array(z.object({
+ *       id: z.string().min(1),
+ *       label: z.string().min(1),
+ *       blocks: z.array(blockRef({ allow: ['checklist', 'text_media'] })).min(1),
+ *     })),
+ *   }),
+ * })
+ * ```
+ */
+export declare function blockRef(options?: BlockRefOptions): z.ZodObject<{
+    id: z.ZodString;
+    component: z.ZodEnum<{
+        [x: string]: string;
+    }> | z.ZodString;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;

package/dist/block-ref.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+/**
+ * Schema helper for nested component references within a parent component.
+ *
+ * Produces a Zod schema for a block entry: `{ id, component, props }`.
+ * When `allow` is provided, `component` is constrained to an enum of the
+ * listed names. This flows into the generated JSON schema, so the content
+ * validator enforces the allowlist at build time.
+ *
+ * @example
+ * ```ts
+ * defineComponent({
+ *   name: 'tabbed_panels',
+ *   schema: z.object({
+ *     tabs: z.array(z.object({
+ *       id: z.string().min(1),
+ *       label: z.string().min(1),
+ *       blocks: z.array(blockRef({ allow: ['checklist', 'text_media'] })).min(1),
+ *     })),
+ *   }),
+ * })
+ * ```
+ */
+export function blockRef(options) {
+    const allow = options?.allow;
+    const componentSchema = allow && allow.length > 0
+        ? z.enum(allow)
+        : z.string().min(1);
+    return z.object({
+        id: z.string().min(1),
+        component: componentSchema,
+        props: z.record(z.string(), z.unknown()),
+    });
+}

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-component.d.ts

@@ -1,2 +1,3 @@
 import type { ComponentContract, ComponentDefinition } from './types/component.js';
 export declare function defineComponent<TSchema = unknown>(definition: ComponentDefinition<TSchema>): ComponentContract<TSchema>;
+export declare const defineComponentContract: typeof defineComponent;

package/dist/define-component.js

@@ -11,3 +11,4 @@ export function defineComponent(definition) {
         vary: definition.vary ?? definition.varyDimensions,
     };
 }
+export const defineComponentContract = defineComponent;

package/dist/define-layout.d.ts

@@ -1,3 +1,4 @@
 import type { LayoutContract, LayoutDefinition, LayoutSlot } from './types/layout.js';
 export declare function defineLayout(definition: LayoutDefinition): LayoutContract;
+export declare const defineLayoutContract: typeof defineLayout;
 export declare function slot(name: string, required?: boolean): LayoutSlot;

package/dist/define-layout.js

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