@gradial/aci 0.1.19 → 0.1.20-preview.1

package/src/cli/compile-registry.mjs

@@ -5,6 +5,8 @@ import { pathToFileURL } from 'node:url';
 import { z } from 'zod';
 import { GradialImageSchema } from '../types/image.ts';
 
+const DATA_TYPE_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+
 // Shim React global so JSX-containing component files can be loaded.
 // The compile-registry only extracts contract metadata (schemas, imageSlots)
 // and never renders components, but importing .tsx files requires the JSX
@@ -33,6 +35,9 @@ async function compileRegistry(options) {
 
   const components = await loadDefaultArray(options.components, 'component registry');
   const layouts = await loadDefaultArray(options.layouts, 'layout registry');
+  const dataModels = options.data
+    ? await loadDefaultArray(options.data, 'data model registry')
+    : [];
   const outDir = path.resolve(options.output);
   const schemaDir = path.join(outDir, 'schemas');
   await mkdir(schemaDir, { recursive: true });
@@ -47,22 +52,11 @@ async function compileRegistry(options) {
     const schemaPath = path.join(outDir, schemaFile);
     await writeFile(schemaPath, JSON.stringify(schema, null, 2) + '\n');
     schemaFiles.push(schemaPath);
-    const renderModes = component.renderModes ?? component.render;
     const varyDimensions = component.varyDimensions ?? component.vary;
     const imageSlots = normalizeImageSlots(component.imageSlots);
     componentEntries.push({
       name: component.name,
       schemaFile,
-      render: {
-        static: Boolean(renderModes.canStatic ?? renderModes.static),
-        ssr: Boolean(renderModes.canSSR ?? renderModes.ssr),
-        clientIsland: Boolean(renderModes.canClientIsland ?? renderModes.clientIsland),
-      },
-      renderModes: {
-        canStatic: Boolean(renderModes.canStatic ?? renderModes.static),
-        canSSR: Boolean(renderModes.canSSR ?? renderModes.ssr),
-        canClientIsland: Boolean(renderModes.canClientIsland ?? renderModes.clientIsland),
-      },
       ...(component.defaultIslandMode ? { defaultIslandMode: component.defaultIslandMode } : {}),
       ...(varyDimensions?.length ? { vary: varyDimensions, varyDimensions } : {}),
       ...(Object.keys(imageSlots).length ? { imageSlots } : {}),
@@ -72,6 +66,24 @@ async function compileRegistry(options) {
   const seenLayouts = new Set();
   const layoutEntries = layouts.map((layout, index) => validateLayout(layout, index, seenLayouts));
 
+  const seenDataModels = new Set();
+  const dataModelEntries = [];
+  if (dataModels.length > 0) {
+    await mkdir(path.join(schemaDir, 'data'), { recursive: true });
+  }
+  for (const [index, dataModel] of dataModels.entries()) {
+    validateDataModel(dataModel, index, seenDataModels);
+    const schema = compileSchema(dataModel.schema, dataModel.type);
+    const schemaFile = `schemas/data/${dataModel.type}.schema.json`;
+    const schemaPath = path.join(outDir, schemaFile);
+    await writeFile(schemaPath, JSON.stringify(schema, null, 2) + '\n');
+    schemaFiles.push(schemaPath);
+    dataModelEntries.push({
+      type: dataModel.type,
+      schemaFile,
+    });
+  }
+
   // Post-compilation: detect nested block patterns in JSON schemas and
   // validate that referenced component names exist in the registry.
   const knownNames = new Set(componentEntries.map((c) => c.name));
@@ -90,19 +102,39 @@ async function compileRegistry(options) {
     generatedAt: new Date().toISOString(),
     components: componentEntries,
     layouts: layoutEntries,
+    dataModels: dataModelEntries,
   };
   const registryPath = path.join(outDir, 'registry.json');
   await writeFile(registryPath, JSON.stringify(registry, null, 2) + '\n');
+
+  const pageSchemaPath = await generatePageSchema(schemaDir, componentEntries, outDir);
+  schemaFiles.push(pageSchemaPath);
+
   return { registry: registryPath, schemas: schemaFiles };
 }
 
 async function loadDefaultArray(modulePath, label) {
   const mod = await import(pathToFileURL(path.resolve(modulePath)).href);
-  const value = mod.default ?? mod.registry ?? mod.components ?? mod.layouts;
+  const value = mod.default ?? mod.registry ?? mod.components ?? mod.layouts ?? mod.dataModels;
   if (!Array.isArray(value)) throw new Error(`${label} must export an array`);
   return value;
 }
 
+function validateDataModel(dataModel, index, seen) {
+  if (!dataModel || typeof dataModel !== 'object') {
+    throw new Error(`dataModels[${index}] must be an object`);
+  }
+  if (typeof dataModel.type !== 'string' || !DATA_TYPE_PATTERN.test(dataModel.type)) {
+    throw new Error(`dataModels[${index}].type must match ${DATA_TYPE_PATTERN}`);
+  }
+  if (seen.has(dataModel.type)) {
+    throw new Error(`duplicate data model type ${dataModel.type}`);
+  }
+  seen.add(dataModel.type);
+  if (!dataModel.schema) throw new Error(`dataModels[${index}].schema is required`);
+  validateZodSubset(dataModel.schema, `dataModels[${index}].schema`);
+}
+
 function validateComponent(component, index, seen) {
   if (!component || typeof component !== 'object') throw new Error(`components[${index}] must be an object`);
   if (!component.name) throw new Error(`components[${index}].name is required`);
@@ -111,12 +143,6 @@ function validateComponent(component, index, seen) {
   if (!component.schema) throw new Error(`components[${index}].schema is required`);
   validateZodSubset(component.schema, `components[${index}].schema`);
   validateImageSlotSchemaMatch(component, index);
-  const renderModes = component.renderModes ?? component.render;
-  if (!renderModes) throw new Error(`components[${index}].renderModes is required`);
-  const enabled = Boolean(renderModes.canStatic ?? renderModes.static)
-    || Boolean(renderModes.canSSR ?? renderModes.ssr)
-    || Boolean(renderModes.canClientIsland ?? renderModes.clientIsland);
-  if (!enabled) throw new Error(`components[${index}].renderModes must enable at least one mode`);
 }
 
 function validateImageSlotSchemaMatch(component, index) {
@@ -310,7 +336,11 @@ function validateLayout(layout, index, seen) {
     seenSlots.add(slot.name);
     slots.push({ name: slot.name, required: Boolean(slot.required) });
   }
-  return { name: layout.name, slots };
+  const entry = { name: layout.name, slots };
+  if (layout.defaults && typeof layout.defaults === 'object') {
+    entry.defaults = layout.defaults;
+  }
+  return entry;
 }
 
 function compileSchema(schema, name) {
@@ -329,6 +359,124 @@ function compileSchema(schema, name) {
   };
 }
 
+async function generatePageSchema(schemaDir, componentEntries, outDir) {
+  const { readFile } = await import('node:fs/promises');
+  const defs = {
+    baseBlock: {
+      type: 'object',
+      required: ['id', 'component', 'props'],
+      additionalProperties: true,
+      properties: {
+        id: { type: 'string', minLength: 1 },
+        component: { type: 'string' },
+        props: { type: 'object' },
+      },
+    },
+    damAssetRef: {
+      type: 'object',
+      required: ['$type', 'assetId'],
+      additionalProperties: true,
+      properties: {
+        $type: { const: 'dam.assetRef' },
+        assetId: { type: 'string', minLength: 1 },
+        version: { type: 'string', minLength: 1 },
+        alt: { type: 'string' },
+      },
+    },
+  };
+  const oneOf = [];
+  for (const entry of componentEntries) {
+    const schemaPath = path.join(outDir, entry.schemaFile);
+    const raw = await readFile(schemaPath, 'utf-8');
+    const componentSchema = JSON.parse(raw);
+    const { $schema: _s, title: _t, ...propsSchema } = componentSchema;
+    replaceGradialImagesWithDamAssetRef(propsSchema, defs.damAssetRef);
+    const defName = `${entry.name}Block`;
+    defs[defName] = {
+      allOf: [
+        { $ref: '#/$defs/baseBlock' },
+        {
+          properties: {
+            component: { const: entry.name },
+            props: propsSchema,
+          },
+        },
+      ],
+    };
+    oneOf.push({ $ref: `#/$defs/${defName}` });
+  }
+  const pageSchema = {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://baremetal.local/schemas/page.schema.json',
+    title: 'bare-metal Page',
+    type: 'object',
+    required: ['$type', 'id', 'status', 'layout', 'metadata', 'regions'],
+    additionalProperties: true,
+    properties: {
+      $type: { const: 'page' },
+      id: { type: 'string', minLength: 1 },
+      status: { type: 'string', minLength: 1 },
+      layout: { type: 'string', minLength: 1 },
+      metadata: {
+        type: 'object',
+        required: ['title'],
+        additionalProperties: true,
+        properties: {
+          title: { type: 'string', minLength: 1 },
+          description: { type: 'string' },
+          canonical: { type: 'string' },
+        },
+      },
+      regions: {
+        type: 'object',
+        additionalProperties: {
+          type: 'array',
+          items: { oneOf },
+        },
+      },
+    },
+    $defs: defs,
+  };
+  const pageSchemaPath = path.join(schemaDir, 'page.schema.json');
+  await writeFile(pageSchemaPath, JSON.stringify(pageSchema, null, 2) + '\n');
+  return pageSchemaPath;
+}
+
+function replaceGradialImagesWithDamAssetRef(schema, damAssetRef) {
+  if (!schema || typeof schema !== 'object') return schema;
+  if (schema.$ref) return;
+  if (Array.isArray(schema.anyOf)) {
+    for (const s of schema.anyOf) replaceGradialImagesWithDamAssetRef(s, damAssetRef);
+  }
+  if (Array.isArray(schema.allOf)) {
+    for (const s of schema.allOf) replaceGradialImagesWithDamAssetRef(s, damAssetRef);
+  }
+  if (Array.isArray(schema.oneOf)) {
+    for (const s of schema.oneOf) replaceGradialImagesWithDamAssetRef(s, damAssetRef);
+  }
+  if (schema.properties) {
+    for (const [key, value] of Object.entries(schema.properties)) {
+      if (isJsonGradialImage(value)) {
+        schema.properties[key] = { $ref: '#/$defs/damAssetRef' };
+      } else {
+        replaceGradialImagesWithDamAssetRef(value, damAssetRef);
+      }
+    }
+  }
+  if (schema.items) {
+    if (isJsonGradialImage(schema.items)) {
+      schema.items = { $ref: '#/$defs/damAssetRef' };
+    } else {
+      replaceGradialImagesWithDamAssetRef(schema.items, damAssetRef);
+    }
+  }
+}
+
+function isJsonGradialImage(node) {
+  return node?.type === 'object'
+    && node?.properties?.$type?.const === 'gradial.image';
+}
+
 function validateZodSubset(schema, pathLabel, seen = new Set()) {
   if (seen.has(schema)) return;
   seen.add(schema);

package/src/types/component.ts

@@ -2,12 +2,6 @@ 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.
@@ -32,8 +26,6 @@ export interface ComponentDefinition<TSchema = unknown> {
    */
   component?: CmsComponentFn<any>;
   schema: TSchema;
-  renderModes?: ComponentRenderModes;
-  render?: ComponentRenderModes;
   defaultIslandMode?: IslandMode;
   varyDimensions?: VaryDimension[];
   vary?: VaryDimension[];
@@ -44,8 +36,6 @@ export interface ComponentContract<TSchema = unknown> {
   name: string;
   component?: CmsComponentFn<any>;
   schema: TSchema;
-  renderModes: ComponentRenderModes;
-  render: ComponentRenderModes;
   defaultIslandMode?: IslandMode;
   varyDimensions?: VaryDimension[];
   vary?: VaryDimension[];

package/src/types/config.ts

@@ -10,8 +10,8 @@ export interface BareMetalConfig {
     publicDir?: string;
   };
   componentRegistry: string;
+  dataRegistry?: string;
   layoutRegistry: string;
-  rendererEntry: string;
   capabilities: RenderCapabilities;
   routes: RouteConfig;
   dam?: DAMConfig;

package/src/types/data.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+
+type InferDataProps<TSchema> = TSchema extends z.ZodType<infer T>
+  ? T
+  : Record<string, unknown>;
+
+const dataRefPattern = /^\$ref:data\/[A-Za-z0-9][A-Za-z0-9_./-]*$/;
+
+export interface DataModelDefinition<TSchema = unknown, TType extends string = string> {
+  type: TType;
+  schema: TSchema;
+}
+
+export interface DataModelContract<TSchema = unknown, TType extends string = string> {
+  type: TType;
+  schema: TSchema;
+}
+
+export interface DataEntry<TProps = Record<string, unknown>, TType extends string = string> {
+  $type: TType;
+  props: TProps;
+}
+
+export type InferDataModelProps<TContract> = TContract extends DataModelContract<infer TSchema, string>
+  ? InferDataProps<TSchema>
+  : Record<string, unknown>;
+
+export type InferDataModelType<TContract> = TContract extends DataModelContract<unknown, infer TType>
+  ? TType
+  : string;
+
+export type DataModelRef<TContract extends DataModelContract> = DataEntry<
+  InferDataModelProps<TContract>,
+  InferDataModelType<TContract>
+>;
+
+export function dataModelRef<TContract extends DataModelContract<z.ZodTypeAny>>(
+  contract: TContract,
+): z.ZodType<DataModelRef<TContract>> {
+  return z.union([
+    z.string().regex(dataRefPattern, `expected a $ref:data/... pointer for ${contract.type}`),
+    z.object({
+      $type: z.literal(contract.type),
+      props: contract.schema,
+    }),
+  ]).describe(`data model reference: ${contract.type}`) as unknown as z.ZodType<DataModelRef<TContract>>;
+}

package/src/types/image.ts

@@ -20,7 +20,7 @@ export interface GradialImage {
   versionId: string;
   alt: string;
   fallback: ImageSource;
-  sources: PictureSource[];
+  sources: PictureSource[] | null;
 }
 
 export interface ImageSlotContract {
@@ -65,7 +65,7 @@ export function renderImageHTML(image: GradialImage, attrs: ImageHTMLAttributes
     height: image.fallback.height > 0 ? image.fallback.height : undefined,
   });
   const img = `<img${imgAttrs}>`;
-  if (!image.sources.length) {
+  if (!image.sources?.length) {
     return img;
   }
   const sources = image.sources.map((source) => `<source${renderAttrs({

package/src/types/index.ts

@@ -1,5 +1,6 @@
 export * from './config.js';
 export * from './component.js';
+export * from './data.js';
 export * from './layout.js';
 export * from './page.js';
 export * from './renderer.js';

package/src/types/page.ts

@@ -1,4 +1,4 @@
-import type { RenderMode, VaryDimension } from './render-mode.js';
+import type { VaryDimension } from './render-mode.js';
 
 export interface PageDocument {
   path: string;
@@ -6,7 +6,6 @@ export interface PageDocument {
   locale: string;
   metadata: PageMetadata;
   regions: Record<string, RegionNode>;
-  renderMode: RenderMode;
 }
 
 export interface PageMetadata {

package/src/types/render-mode.ts

@@ -1,11 +1,3 @@
-export type RenderMode =
-  | 'static'
-  | 'static-with-fragments'
-  | 'prerender-on-demand'
-  | 'ssr-page'
-  | 'ssr-island'
-  | 'client-island';
-
 export type IslandMode = 'ssr' | 'client';
 
 export type VaryDimension =

package/dist/next/preview-banner.d.ts

@@ -1,4 +0,0 @@
-export interface PreviewBannerProps {
-    releaseId?: string;
-}
-export declare function PreviewBanner({ releaseId }: PreviewBannerProps): import("react").JSX.Element | null;

package/dist/next/preview-banner.js

@@ -1,51 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-export function PreviewBanner({ releaseId }) {
-    if (!releaseId)
-        return null;
-    const shortId = releaseId.length > 20
-        ? `${releaseId.slice(0, 8)}\u2026${releaseId.slice(-6)}`
-        : releaseId;
-    return (_jsxs("div", { role: "alert", style: {
-            position: 'fixed',
-            top: 0,
-            left: 0,
-            right: 0,
-            zIndex: 9999,
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-            gap: '12px',
-            padding: '8px 16px',
-            backgroundColor: '#1a1a2e',
-            color: '#fff',
-            fontSize: '13px',
-            fontFamily: 'system-ui, -apple-system, sans-serif',
-            boxShadow: '0 2px 8px rgba(0,0,0,0.3)',
-        }, children: [_jsx("span", { "aria-hidden": "true", style: {
-                    display: 'inline-flex',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    width: '18px',
-                    height: '18px',
-                    borderRadius: '50%',
-                    backgroundColor: '#f59e0b',
-                    color: '#1a1a2e',
-                    fontWeight: 700,
-                    fontSize: '11px',
-                    flexShrink: 0,
-                }, children: "P" }), _jsx("span", { style: { fontWeight: 500 }, children: "Release Preview" }), _jsx("span", { style: {
-                    fontFamily: 'monospace',
-                    opacity: 0.7,
-                    fontSize: '12px',
-                }, title: releaseId, children: shortId }), _jsx("a", { href: "?leave_preview=1", style: {
-                    marginLeft: 'auto',
-                    padding: '4px 12px',
-                    borderRadius: '6px',
-                    backgroundColor: '#dc2626',
-                    color: '#fff',
-                    textDecoration: 'none',
-                    fontSize: '12px',
-                    fontWeight: 600,
-                    whiteSpace: 'nowrap',
-                }, children: "Exit Preview" })] }));
-}

package/dist/next/preview.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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/render.d.ts

@@ -1,14 +0,0 @@
-import type { ComponentType, ReactNode } from 'react';
-export interface BlockData {
-    id: string;
-    component: string;
-    props: Record<string, unknown>;
-}
-export type ComponentRegistry = Record<string, ComponentType<any>>;
-export interface RenderBlocksOptions {
-    registry: ComponentRegistry;
-    compositionParams?: Record<string, unknown>;
-    slot?: string;
-}
-export declare function renderBlock(block: BlockData, registry: ComponentRegistry, compositionParams?: Record<string, unknown>): ReactNode;
-export declare function renderBlocks(blocks: readonly BlockData[], opts: RenderBlocksOptions): ReactNode[];

package/dist/render.js

@@ -1,33 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { PreviewBanner } from './next/preview-banner.js';
-function BlockError({ component, id }) {
-    return (_jsxs("div", { style: {
-            padding: '1rem 1.25rem',
-            margin: '1rem 0',
-            background: '#fef2f2',
-            border: '2px solid #dc2626',
-            borderRadius: '6px',
-            fontFamily: 'ui-monospace, monospace',
-            fontSize: '13px',
-            lineHeight: 1.5,
-            color: '#991b1b',
-        }, children: [_jsx("strong", { children: "Unknown block:" }), " ", _jsx("code", { children: component }), _jsx("br", {}), _jsxs("span", { style: { color: '#b91c1c', opacity: 0.7 }, children: ["id: ", id] })] }));
-}
-export function renderBlock(block, registry, compositionParams) {
-    const Component = registry[block.component];
-    if (!Component) {
-        if (process.env.NODE_ENV !== 'production') {
-            return _jsx(BlockError, { component: block.component, id: block.id }, block.id);
-        }
-        return null;
-    }
-    return _jsx(Component, { ...block.props, ...compositionParams }, block.id);
-}
-export function renderBlocks(blocks, opts) {
-    const { registry, compositionParams, slot } = opts;
-    const rendered = blocks.map((block) => renderBlock(block, registry, compositionParams));
-    if (slot === 'main') {
-        return [_jsx(PreviewBanner, {}, "__gradial_preview"), ...rendered];
-    }
-    return rendered;
-}

package/src/cli/verify-renderer.mjs

@@ -1,73 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-const args = parseArgs(process.argv.slice(2));
-
-try {
-  if (!args.renderer) throw new Error('missing --renderer');
-  await verifyRenderer(path.resolve(args.renderer));
-  console.log(JSON.stringify({ success: true, errors: [] }, null, 2));
-} catch (error) {
-  console.error(JSON.stringify({ success: false, errors: [String(error?.message ?? error)] }, null, 2));
-  process.exitCode = 1;
-}
-
-async function verifyRenderer(rendererPath) {
-  try {
-    const mod = await import(pathToFileURL(rendererPath).href);
-    const renderer = mod.default ?? mod.renderer;
-    if (!renderer || typeof renderer.renderPage !== 'function') {
-      throw new Error('renderer must export a GradialRenderer with renderPage');
-    }
-    return;
-  } catch (error) {
-    if (!shouldUseStaticFallback(error)) {
-      throw error;
-    }
-  }
-
-  const source = fs.readFileSync(rendererPath, 'utf8');
-  if (!staticallyExportsRenderPage(source)) {
-    throw new Error('renderer must export a GradialRenderer with renderPage');
-  }
-}
-
-function shouldUseStaticFallback(error) {
-  const message = String(error?.message ?? error);
-  return message.includes('Unknown file extension ".astro"');
-}
-
-function staticallyExportsRenderPage(source) {
-  if (!/\brenderPage\s*[:=]\s*(async\s*)?(\([^)]*\)|[A-Za-z_$][\w$]*)?\s*=>|\brenderPage\s*[:=]\s*(async\s*)?function\b|\basync\s+renderPage\s*\(|\brenderPage\s*\(/m.test(source)) {
-    return false;
-  }
-  if (/export\s+default\s+{[\s\S]*\brenderPage\b[\s\S]*}/m.test(source)) {
-    return true;
-  }
-  const defaultName = source.match(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/m)?.[1];
-  const namedExport = source.match(/export\s*{\s*([A-Za-z_$][\w$]*)\s+as\s+renderer\s*}/m)?.[1] ?? source.match(/export\s*{\s*([A-Za-z_$][\w$]*)\s*}/m)?.[1];
-  const rendererName = defaultName ?? namedExport;
-  if (!rendererName) {
-    return false;
-  }
-  const declaration = new RegExp(`(?:const|let|var)\\s+${rendererName}\\b[\\s\\S]*?\\{[\\s\\S]*?\\brenderPage\\b`, 'm');
-  return declaration.test(source);
-}
-
-function parseArgs(argv) {
-  const out = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (!arg.startsWith('--')) continue;
-    const body = arg.slice(2);
-    const equals = body.indexOf('=');
-    if (equals >= 0) {
-      out[body.slice(0, equals)] = body.slice(equals + 1);
-      continue;
-    }
-    out[body] = argv[++i];
-  }
-  return out;
-}