meno-core 1.0.53 → 1.1.0

package/lib/shared/validation/schemas.ts

@@ -15,12 +15,31 @@ import { NODE_TYPE } from '../constants';
 /**
  * Prop type schema - validates PropType values (excluding list for base definition)
  */
-export const BasePropTypeSchema = z.enum(['string', 'select', 'boolean', 'number', 'link', 'file', 'rich-text', 'embed']);
+export const BasePropTypeSchema = z.enum([
+  'string',
+  'select',
+  'boolean',
+  'number',
+  'link',
+  'file',
+  'rich-text',
+  'embed',
+]);
 
 /**
  * Full prop type schema including list
  */
-export const PropTypeSchema = z.enum(['string', 'select', 'boolean', 'number', 'link', 'file', 'rich-text', 'embed', 'list']);
+export const PropTypeSchema = z.enum([
+  'string',
+  'select',
+  'boolean',
+  'number',
+  'link',
+  'file',
+  'rich-text',
+  'embed',
+  'list',
+]);
 
 /**
  * `_i18n` value object schema. Used wherever a localizable string can appear:
@@ -34,9 +53,11 @@ export const PropTypeSchema = z.enum(['string', 'select', 'boolean', 'number', '
  * client builder (`ComponentBuilder.buildComponent`). The schema accepts the
  * shape so the editor's load path doesn't reject files that contain it.
  */
-export const I18nValueObjectSchema = z.object({
-  _i18n: z.literal(true),
-}).passthrough();
+export const I18nValueObjectSchema = z
+  .object({
+    _i18n: z.literal(true),
+  })
+  .passthrough();
 
 /**
  * Base prop definition schema (for non-list props).
@@ -47,20 +68,24 @@ export const I18nValueObjectSchema = z.object({
  * in this file; we inline the matching shape here to keep the validator
  * tolerant of localized defaults.
  */
-export const BasePropDefinitionSchema = z.object({
-  type: BasePropTypeSchema,
-  default: z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.object({ href: z.string(), target: z.string().optional() }),
-    I18nValueObjectSchema,
-  ]).optional(),
-  options: z.array(z.string()).readonly().optional(),
-  enumName: z.string().optional(), // For 'select' type: reference to project-level enum
-  accept: z.string().optional(), // For 'file' type: MIME pattern like "image/*", "video/*"
-  editor: z.enum(['basic', 'extended']).optional(), // For 'rich-text' type: which editor to use
-}).passthrough();
+export const BasePropDefinitionSchema = z
+  .object({
+    type: BasePropTypeSchema,
+    default: z
+      .union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.object({ href: z.string(), target: z.string().optional() }),
+        I18nValueObjectSchema,
+      ])
+      .optional(),
+    options: z.array(z.string()).readonly().optional(),
+    enumName: z.string().optional(), // For 'select' type: reference to project-level enum
+    accept: z.string().optional(), // For 'file' type: MIME pattern like "image/*", "video/*"
+    editor: z.enum(['basic', 'extended']).optional(), // For 'rich-text' type: which editor to use
+  })
+  .passthrough();
 
 /**
  * Project-level enums configuration schema
@@ -76,109 +101,129 @@ export const ListItemSchemaSchema = z.record(z.string(), BasePropDefinitionSchem
 /**
  * List prop definition schema
  */
-export const ListPropDefinitionSchema = z.object({
-  type: z.literal('list'),
-  itemSchema: ListItemSchemaSchema,
-  // List-item field values can be any primitive, a link object, an `_i18n`
-  // object (resolved by the SSR pipeline), or null.
-  default: z.array(z.record(z.string(), z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.object({ href: z.string(), target: z.string().optional() }),
-    I18nValueObjectSchema,
-    z.null(),
-  ]))).optional(),
-}).passthrough();
+export const ListPropDefinitionSchema = z
+  .object({
+    type: z.literal('list'),
+    itemSchema: ListItemSchemaSchema,
+    // List-item field values can be any primitive, a link object, an `_i18n`
+    // object (resolved by the SSR pipeline), or null.
+    default: z
+      .array(
+        z.record(
+          z.string(),
+          z.union([
+            z.string(),
+            z.number(),
+            z.boolean(),
+            z.object({ href: z.string(), target: z.string().optional() }),
+            I18nValueObjectSchema,
+            z.null(),
+          ]),
+        ),
+      )
+      .optional(),
+  })
+  .passthrough();
 
 /**
  * Prop definition schema (union of base and list)
  * Validates prop definitions from component interfaces
  */
-export const PropDefinitionSchema = z.union([
-  ListPropDefinitionSchema,
-  BasePropDefinitionSchema,
-]);
+export const PropDefinitionSchema = z.union([ListPropDefinitionSchema, BasePropDefinitionSchema]);
 
 /**
  * Style mapping schema
  */
-export const StyleMappingSchema: z.ZodType<StyleMapping> = z.object({
-  _mapping: z.literal(true),
-  prop: z.string(),
-  values: z.record(z.string(), z.union([z.string(), z.number()])),
-}).passthrough();
+export const StyleMappingSchema: z.ZodType<StyleMapping> = z
+  .object({
+    _mapping: z.literal(true),
+    prop: z.string(),
+    values: z.record(z.string(), z.union([z.string(), z.number()])),
+  })
+  .passthrough();
 
 /**
  * Boolean mapping schema - for conditional rendering (if property)
  * Maps component prop values to boolean results
  */
-export const BooleanMappingSchema = z.object({
-  _mapping: z.literal(true),
-  prop: z.string(),
-  values: z.record(z.string(), z.boolean()),
-}).passthrough();
+export const BooleanMappingSchema = z
+  .object({
+    _mapping: z.literal(true),
+    prop: z.string(),
+    values: z.record(z.string(), z.boolean()),
+  })
+  .passthrough();
 
 /**
- * If condition schema - can be boolean, string template, or mapping
+ * Verbatim-code marker (`{ _code: true, expr }`) — arbitrary JS the meno-astro dialect can't
+ * model as a binding (a function/method call, optional chaining, `??`, …). It is a legitimate
+ * value anywhere a child node, an `if` condition, or an attribute value can appear: it renders
+ * natively in the Astro build, and the editor preview renders nothing for it (see
+ * ComponentBuilder's `_code` guard). The editor is meno-astro-only, so its model routinely
+ * carries these — they must validate or a component with any verbatim expression won't open.
  */
-export const IfConditionSchema = z.union([
-  z.boolean(),
-  z.string(),
-  BooleanMappingSchema,
-]);
+export const VerbatimCodeSchema = z.object({ _code: z.literal(true), expr: z.string() }).passthrough();
+
+/**
+ * If condition schema - can be boolean, string template, mapping, or a verbatim-code marker
+ */
+export const IfConditionSchema = z.union([z.boolean(), z.string(), BooleanMappingSchema, VerbatimCodeSchema]);
 
 /**
  * Link mapping schema - for link node href mappings
  * values is optional - when missing, acts as passthrough for link-type props
  */
-export const LinkMappingSchema: z.ZodType<LinkMapping> = z.object({
-  _mapping: z.literal(true),
-  prop: z.string(),
-  values: z.record(z.string(), z.object({
-    href: z.string(),
-    target: z.string().optional(),
-  })).optional(),
-}).passthrough();
+export const LinkMappingSchema: z.ZodType<LinkMapping> = z
+  .object({
+    _mapping: z.literal(true),
+    prop: z.string(),
+    values: z
+      .record(
+        z.string(),
+        z.object({
+          href: z.string(),
+          target: z.string().optional(),
+        }),
+      )
+      .optional(),
+  })
+  .passthrough();
 
 /**
  * HTML mapping schema - for embed node html content mappings
  * values is optional - when missing, acts as passthrough for string-type props
  */
-export const HtmlMappingSchema: z.ZodType<HtmlMapping> = z.object({
-  _mapping: z.literal(true),
-  prop: z.string(),
-  values: z.record(z.string(), z.string()).optional(),
-}).passthrough();
+export const HtmlMappingSchema: z.ZodType<HtmlMapping> = z
+  .object({
+    _mapping: z.literal(true),
+    prop: z.string(),
+    values: z.record(z.string(), z.string()).optional(),
+  })
+  .passthrough();
 
 /**
  * Style object schema - flat style object
  */
 export const StyleObjectSchema: z.ZodType<StyleObject> = z.record(
   z.string(),
-  z.union([
-    z.string(),
-    z.number(),
-    StyleMappingSchema,
-  ])
+  z.union([z.string(), z.number(), StyleMappingSchema]),
 );
 
 /**
  * Responsive style object schema
  */
-export const ResponsiveStyleObjectSchema = z.object({
-  base: StyleObjectSchema.optional(),
-  tablet: StyleObjectSchema.optional(),
-  mobile: StyleObjectSchema.optional(),
-}).passthrough();
+export const ResponsiveStyleObjectSchema = z
+  .object({
+    base: StyleObjectSchema.optional(),
+    tablet: StyleObjectSchema.optional(),
+    mobile: StyleObjectSchema.optional(),
+  })
+  .passthrough();
 
 /**
  * Style value schema - can be either flat or responsive
  */
-export const StyleValueSchema = z.union([
-  StyleObjectSchema,
-  ResponsiveStyleObjectSchema,
-]);
+export const StyleValueSchema = z.union([StyleObjectSchema, ResponsiveStyleObjectSchema]);
 
 /**
  * Interactive style rule schema
@@ -209,14 +254,20 @@ export const InteractiveStylesSchema = z.array(InteractiveStyleRuleSchema);
  * default: Optional default content when instance has no children
  * Can be an array of ComponentNodes or a string
  */
-export const SlotMarkerSchema: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.literal(NODE_TYPE.SLOT),
-  default: z.union([
-    z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
-    z.string(),
-    I18nValueObjectSchema,
-  ]).optional(),
-}).passthrough());
+export const SlotMarkerSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.SLOT),
+      default: z
+        .union([
+          z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+          z.string(),
+          I18nValueObjectSchema,
+        ])
+        .optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * Component node schema - discriminated union (forward declaration)
@@ -227,95 +278,131 @@ let ComponentNodeSchema: z.ZodType<any>;
 /**
  * HTML node schema - recursive definition
  */
-export const HtmlNodeSchema: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.literal(NODE_TYPE.NODE),
-  tag: z.string(),
-  label: z.string().optional(),
-  if: IfConditionSchema.optional(),
-  style: StyleValueSchema.optional(),
-  interactiveStyles: InteractiveStylesSchema.optional(),
-  generateElementClass: z.boolean().optional(),
-  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
-  props: z.record(z.string(), z.any()).optional(), // Allow props for backward compatibility
-  children: z.union([
-    z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
-    z.string(),
-    I18nValueObjectSchema,
-  ]).optional(),
-}).passthrough());
+export const HtmlNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.NODE),
+      tag: z.string(),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema, VerbatimCodeSchema]))
+        .optional(),
+      props: z.record(z.string(), z.any()).optional(), // Allow props for backward compatibility
+      children: z
+        .union([
+          z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+          z.string(),
+          I18nValueObjectSchema,
+        ])
+        .optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * Component instance node schema - recursive definition
  */
-export const ComponentInstanceNodeSchema: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.literal(NODE_TYPE.COMPONENT),
-  component: z.string(),
-  label: z.string().optional(),
-  if: IfConditionSchema.optional(),
-  props: z.record(z.string(), z.any()).optional(),
-  style: StyleValueSchema.optional(),
-  interactiveStyles: InteractiveStylesSchema.optional(),
-  generateElementClass: z.boolean().optional(),
-  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
-  children: z.union([
-    z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
-    z.string(),
-    I18nValueObjectSchema,
-  ]).optional(),
-}).passthrough());
+export const ComponentInstanceNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.COMPONENT),
+      component: z.string(),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      props: z.record(z.string(), z.any()).optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema, VerbatimCodeSchema]))
+        .optional(),
+      children: z
+        .union([
+          z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+          z.string(),
+          I18nValueObjectSchema,
+        ])
+        .optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * Embed node schema - for rendering custom HTML/SVG content
  */
-export const EmbedNodeSchema: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.literal(NODE_TYPE.EMBED),
-  html: z.union([z.string(), HtmlMappingSchema, I18nValueObjectSchema]),
-  label: z.string().optional(),
-  if: IfConditionSchema.optional(),
-  style: StyleValueSchema.optional(),
-  interactiveStyles: InteractiveStylesSchema.optional(),
-  generateElementClass: z.boolean().optional(),
-  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
-}).passthrough());
+export const EmbedNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.EMBED),
+      html: z.union([z.string(), HtmlMappingSchema, I18nValueObjectSchema]),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema, VerbatimCodeSchema]))
+        .optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * Link node schema - renders as div in editor, <a> in SSR
  */
-export const LinkNodeSchema: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.literal(NODE_TYPE.LINK),
-  href: z.union([z.string(), LinkMappingSchema, I18nValueObjectSchema]),
-  label: z.string().optional(),
-  if: IfConditionSchema.optional(),
-  style: StyleValueSchema.optional(),
-  interactiveStyles: InteractiveStylesSchema.optional(),
-  generateElementClass: z.boolean().optional(),
-  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
-  children: z.union([
-    z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
-    z.string(),
-    I18nValueObjectSchema,
-  ]).optional(),
-}).passthrough());
+export const LinkNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.LINK),
+      href: z.union([z.string(), LinkMappingSchema, I18nValueObjectSchema]),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema, VerbatimCodeSchema]))
+        .optional(),
+      children: z
+        .union([
+          z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+          z.string(),
+          I18nValueObjectSchema,
+        ])
+        .optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * Locale list node schema - renders locale switcher links
  */
-export const LocaleListNodeSchema: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.literal(NODE_TYPE.LOCALE_LIST),
-  label: z.string().optional(),
-  if: IfConditionSchema.optional(),
-  style: StyleValueSchema.optional(),
-  interactiveStyles: InteractiveStylesSchema.optional(),
-  generateElementClass: z.boolean().optional(),
-  itemStyle: StyleValueSchema.optional(),
-  activeItemStyle: StyleValueSchema.optional(),
-  separatorStyle: StyleValueSchema.optional(),
-  showCurrent: z.boolean().optional(),
-  showSeparator: z.boolean().optional(),
-  showFlag: z.boolean().optional(),
-  flagStyle: StyleValueSchema.optional(),
-  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema])).optional(),
-}).passthrough());
+export const LocaleListNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.LOCALE_LIST),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      itemStyle: StyleValueSchema.optional(),
+      activeItemStyle: StyleValueSchema.optional(),
+      separatorStyle: StyleValueSchema.optional(),
+      showCurrent: z.boolean().optional(),
+      showSeparator: z.boolean().optional(),
+      showFlag: z.boolean().optional(),
+      flagStyle: StyleValueSchema.optional(),
+      attributes: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema, VerbatimCodeSchema]))
+        .optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * Unified List node schema (basic version for ComponentNodeSchema union)
@@ -323,24 +410,34 @@ export const LocaleListNodeSchema: z.ZodType<any> = z.lazy(() => z.object({
  * Uses sourceType to distinguish: 'prop' (default) or 'collection'.
  * Also supports legacy 'cms-list' type for backward compatibility.
  */
-export const ListNodeSchemaBasic: z.ZodType<any> = z.lazy(() => z.object({
-  type: z.union([z.literal(NODE_TYPE.LIST), z.literal('cms-list')]), // Support both for migration
-  sourceType: z.enum(['prop', 'collection']).optional(), // defaults to 'prop'
-  source: z.string().optional(), // Source prop name or collection name
-  collection: z.string().optional(), // Legacy field for cms-list migration
-  label: z.string().optional(),
-  if: IfConditionSchema.optional(),
-  itemAs: z.string().optional(),
-  // Collection-specific options
-  items: z.union([z.string(), z.array(z.string())]).optional(),
-  filter: z.unknown().optional(),
-  sort: z.unknown().optional(),
-  limit: z.number().optional(),
-  offset: z.number().optional(),
-  excludeCurrentItem: z.boolean().optional(),
-  emitTemplate: z.boolean().optional(),
-  children: z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])).optional(),
-}).passthrough());
+export const ListNodeSchemaBasic: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.union([z.literal(NODE_TYPE.LIST), z.literal('cms-list')]), // Support both for migration
+      sourceType: z.enum(['prop', 'collection', 'remote', 'sanity', 'expression']).optional(), // defaults to 'prop'
+      source: z.string().optional(), // Source prop name or collection name
+      collection: z.string().optional(), // Legacy field for cms-list migration
+      // Remote-source options (sourceType: 'remote')
+      url: z.string().optional(), // HTTP/JSON endpoint
+      path: z.string().optional(), // dot-path into the response to the items array
+      // Sanity-source options (sourceType: 'sanity')
+      documentType: z.string().optional(), // Sanity document `_type`
+      slugField: z.string().optional(), // field used as the URL slug
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      itemAs: z.string().optional(),
+      // Collection-specific options
+      items: z.union([z.string(), z.array(z.string())]).optional(),
+      filter: z.unknown().optional(),
+      sort: z.unknown().optional(),
+      limit: z.number().optional(),
+      offset: z.number().optional(),
+      excludeCurrentItem: z.boolean().optional(),
+      emitTemplate: z.boolean().optional(),
+      children: z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])).optional(),
+    })
+    .passthrough(),
+);
 
 /**
  * @deprecated Use ListNodeSchemaBasic instead.
@@ -348,6 +445,79 @@ export const ListNodeSchemaBasic: z.ZodType<any> = z.lazy(() => z.object({
  */
 export const CMSListNodeSchemaBasic = ListNodeSchemaBasic;
 
+/**
+ * Island node schema - a BYO framework component rendered as an Astro island.
+ * `src` is the file relative to `src/islands/` (extension derives the framework);
+ * `client` carries the `client:*` hydration directive (omitted = server-only).
+ */
+export const IslandNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.ISLAND),
+      src: z.string(),
+      client: z
+        .object({
+          directive: z.enum(['load', 'idle', 'visible', 'media', 'only']),
+          value: z.string().optional(),
+        })
+        .passthrough()
+        .optional(),
+      props: z.record(z.string(), z.any()).optional(),
+      if: IfConditionSchema.optional(),
+      children: z
+        .union([
+          z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+          z.string(),
+          I18nValueObjectSchema,
+        ])
+        .optional(),
+    })
+    .passthrough(),
+);
+
+/**
+ * Markdown node schema - renders a verbatim Markdown source string as HTML.
+ */
+export const MarkdownNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.MARKDOWN),
+      source: z.string(),
+      label: z.string().optional(),
+      if: IfConditionSchema.optional(),
+      style: StyleValueSchema.optional(),
+      interactiveStyles: InteractiveStylesSchema.optional(),
+      generateElementClass: z.boolean().optional(),
+      attributes: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), I18nValueObjectSchema, VerbatimCodeSchema]))
+        .optional(),
+    })
+    .passthrough(),
+);
+
+/**
+ * Custom node schema - an opaque, hand-authored `.astro` component under `src/custom/`.
+ * `src` is the file relative to `src/custom/`; Meno renders it via Astro but doesn't model
+ * its internals (server-only, no client directive — the native-Astro sibling of an island).
+ */
+export const CustomNodeSchema: z.ZodType<any> = z.lazy(() =>
+  z
+    .object({
+      type: z.literal(NODE_TYPE.CUSTOM),
+      src: z.string(),
+      props: z.record(z.string(), z.any()).optional(),
+      if: IfConditionSchema.optional(),
+      children: z
+        .union([
+          z.array(z.union([ComponentNodeSchema, z.string(), I18nValueObjectSchema])),
+          z.string(),
+          I18nValueObjectSchema,
+        ])
+        .optional(),
+    })
+    .passthrough(),
+);
+
 /**
  * Component node schema - discriminated union (now defined after dependencies)
  */
@@ -359,6 +529,12 @@ ComponentNodeSchema = z.union([
   LinkNodeSchema,
   LocaleListNodeSchema,
   ListNodeSchemaBasic,
+  IslandNodeSchema,
+  MarkdownNodeSchema,
+  CustomNodeSchema,
+  // A verbatim-code marker is a valid child node (renders natively at build; nothing in the
+  // editor preview) — a meno-astro component with any `{_code}` child must validate to open.
+  VerbatimCodeSchema,
 ]);
 
 // Export ComponentNodeSchema
@@ -386,42 +562,50 @@ export const ScriptTypeSchema = z.enum(['classic', 'module']);
 /**
  * JavaScript library schema
  */
-export const JSLibraryConfigSchema = z.object({
-  url: z.string().min(1),
-  mode: ScriptLoadModeSchema.optional(),
-  position: LibraryPositionSchema.optional(),
-  type: ScriptTypeSchema.optional(),
-}).passthrough();
+export const JSLibraryConfigSchema = z
+  .object({
+    url: z.string().min(1),
+    mode: ScriptLoadModeSchema.optional(),
+    position: LibraryPositionSchema.optional(),
+    type: ScriptTypeSchema.optional(),
+  })
+  .passthrough();
 
 /**
  * CSS library schema
  */
-export const CSSLibraryConfigSchema = z.object({
-  url: z.string().min(1),
-  media: z.string().optional(),
-  inline: z.boolean().optional(),
-}).passthrough();
+export const CSSLibraryConfigSchema = z
+  .object({
+    url: z.string().min(1),
+    media: z.string().optional(),
+    inline: z.boolean().optional(),
+  })
+  .passthrough();
 
 /**
  * Libraries config schema
  */
-export const LibrariesConfigSchema = z.object({
-  js: z.array(JSLibraryConfigSchema).optional(),
-  css: z.array(CSSLibraryConfigSchema).optional(),
-}).passthrough();
+export const LibrariesConfigSchema = z
+  .object({
+    js: z.array(JSLibraryConfigSchema).optional(),
+    css: z.array(CSSLibraryConfigSchema).optional(),
+  })
+  .passthrough();
 
 /**
  * Structured component definition schema
  */
-export const StructuredComponentDefinitionSchema = z.object({
-  interface: z.record(z.string(), PropDefinitionSchema).optional(),
-  structure: ComponentNodeSchema.optional(),
-  javascript: z.string().optional(),
-  css: z.string().optional(),
-  category: z.string().optional(),
-  libraries: LibrariesConfigSchema.optional(),
-  acceptsStyles: z.boolean().optional(),
-}).passthrough();
+export const StructuredComponentDefinitionSchema = z
+  .object({
+    interface: z.record(z.string(), PropDefinitionSchema).optional(),
+    structure: ComponentNodeSchema.optional(),
+    javascript: z.string().optional(),
+    css: z.string().optional(),
+    category: z.string().optional(),
+    libraries: LibrariesConfigSchema.optional(),
+    acceptsStyles: z.boolean().optional(),
+  })
+  .passthrough();
 
 /**
  * Component definition schema
@@ -430,16 +614,20 @@ export const StructuredComponentDefinitionSchema = z.object({
  */
 export const ComponentDefinitionSchema = z.union([
   // New format: { component: {...} }
-  z.object({
-    component: StructuredComponentDefinitionSchema,
-  }).passthrough(),
+  z
+    .object({
+      component: StructuredComponentDefinitionSchema,
+    })
+    .passthrough(),
   // Legacy format: { type, props?, children?, component }
-  z.object({
-    type: z.string(),
-    props: z.record(z.string(), z.any()).optional(),
-    children: z.array(z.any()).optional(),
-    component: StructuredComponentDefinitionSchema,
-  }).passthrough(),
+  z
+    .object({
+      type: z.string(),
+      props: z.record(z.string(), z.any()).optional(),
+      children: z.array(z.any()).optional(),
+      component: StructuredComponentDefinitionSchema,
+    })
+    .passthrough(),
 ]);
 
 /**
@@ -447,9 +635,11 @@ export const ComponentDefinitionSchema = z.union([
  */
 const I18nOrStringSchema = z.union([
   z.string(),
-  z.object({
-    _i18n: z.literal(true),
-  }).passthrough(),
+  z
+    .object({
+      _i18n: z.literal(true),
+    })
+    .passthrough(),
 ]);
 
 /**
@@ -460,35 +650,53 @@ export const LibraryMergeModeSchema = z.enum(['extend', 'replace']);
 /**
  * Page libraries config schema (with merge mode)
  */
-export const PageLibrariesConfigSchema = z.object({
-  js: z.array(JSLibraryConfigSchema).optional(),
-  css: z.array(CSSLibraryConfigSchema).optional(),
-  mode: LibraryMergeModeSchema.optional(),
-}).passthrough();
+export const PageLibrariesConfigSchema = z
+  .object({
+    js: z.array(JSLibraryConfigSchema).optional(),
+    css: z.array(CSSLibraryConfigSchema).optional(),
+    mode: LibraryMergeModeSchema.optional(),
+  })
+  .passthrough();
 
 /**
  * Page metadata schema (base version without CMS - used internally)
  * Note: CMS fields added via PageMetaDataWithCMSSchema after CMS schemas are defined
  */
-const CustomCodeConfigSchema = z.object({
-  head: z.string().optional(),
-  bodyStart: z.string().optional(),
-  bodyEnd: z.string().optional(),
-}).passthrough();
-
-const PageMetaDataBaseSchema = z.object({
-  title: I18nOrStringSchema.optional(),
-  description: I18nOrStringSchema.optional(),
-  keywords: I18nOrStringSchema.optional(),
-  ogTitle: I18nOrStringSchema.optional(),
-  ogDescription: I18nOrStringSchema.optional(),
-  ogImage: z.string().optional(),
-  ogType: z.string().optional(),
-  slugs: z.record(z.string(), z.string()).optional(),
-  draft: z.boolean().optional(),
-  libraries: PageLibrariesConfigSchema.optional(),
-  customCode: CustomCodeConfigSchema.optional(),
-}).passthrough();
+const CustomCodeConfigSchema = z
+  .object({
+    head: z.string().optional(),
+    bodyStart: z.string().optional(),
+    bodyEnd: z.string().optional(),
+  })
+  .passthrough();
+
+const SitemapPageConfigSchema = z
+  .object({
+    priority: z.number().optional(),
+    changefreq: z.enum(['always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', 'never']).optional(),
+    exclude: z.boolean().optional(),
+  })
+  .passthrough();
+
+const PageMetaDataBaseSchema = z
+  .object({
+    title: I18nOrStringSchema.optional(),
+    description: I18nOrStringSchema.optional(),
+    keywords: I18nOrStringSchema.optional(),
+    ogTitle: I18nOrStringSchema.optional(),
+    ogDescription: I18nOrStringSchema.optional(),
+    ogImage: z.string().optional(),
+    ogType: z.string().optional(),
+    slugs: z.record(z.string(), z.string()).optional(),
+    draft: z.boolean().optional(),
+    libraries: PageLibrariesConfigSchema.optional(),
+    customCode: CustomCodeConfigSchema.optional(),
+    viewTransitions: z.boolean().optional(),
+    noindex: z.boolean().optional(),
+    prerender: z.boolean().optional(),
+    sitemap: SitemapPageConfigSchema.optional(),
+  })
+  .passthrough();
 
 // Temporary export for backward compatibility - will be replaced with full schema below
 export const PageMetaDataSchema = PageMetaDataBaseSchema;
@@ -505,39 +713,49 @@ export const LineRangeSchema = z.object({
  * JSON page schema
  * Requires at least one field to prevent empty objects from matching
  */
-export const JSONPageSchema = z.object({
-  components: z.record(z.string(), ComponentDefinitionSchema).optional(),
-  root: ComponentNodeSchema.optional(),
-  meta: PageMetaDataSchema.optional(),
-  _lineMap: z.record(z.string(), LineRangeSchema).optional(),
-}).passthrough().refine((data) => {
-  // Require at least one field to be present
-  return data.meta !== undefined || data.components !== undefined || data.root !== undefined;
-}, {
-  message: "JSONPage must have at least one of: meta, components, or root"
-});
+export const JSONPageSchema = z
+  .object({
+    components: z.record(z.string(), ComponentDefinitionSchema).optional(),
+    root: ComponentNodeSchema.optional(),
+    meta: PageMetaDataSchema.optional(),
+    _lineMap: z.record(z.string(), LineRangeSchema).optional(),
+    // Marks a page whose source is outside the meno-astro dialect (read-only in the editor).
+    // Explicit (not just .passthrough()) so it survives a future tightening of this schema.
+    _unsupported: z.object({ reason: z.string() }).passthrough().optional(),
+  })
+  .passthrough()
+  .refine(
+    (data) => {
+      // Require at least one field to be present
+      return data.meta !== undefined || data.components !== undefined || data.root !== undefined;
+    },
+    {
+      message: 'JSONPage must have at least one of: meta, components, or root',
+    },
+  );
 
 /**
  * Page data with component schema
  */
-export const PageDataWithComponentSchema = z.object({
-  component: z.object({
-    structure: ComponentNodeSchema.optional(),
-    interface: z.record(z.string(), PropDefinitionSchema).optional(),
-    javascript: z.string().optional(),
-    css: z.string().optional(),
-    acceptsStyles: z.boolean().optional(),
-  }).passthrough(),
-}).passthrough();
+export const PageDataWithComponentSchema = z
+  .object({
+    component: z
+      .object({
+        structure: ComponentNodeSchema.optional(),
+        interface: z.record(z.string(), PropDefinitionSchema).optional(),
+        javascript: z.string().optional(),
+        css: z.string().optional(),
+        acceptsStyles: z.boolean().optional(),
+      })
+      .passthrough(),
+  })
+  .passthrough();
 
 /**
  * Page data schema - union of JSONPage and PageDataWithComponent
  * PageDataWithComponent checked first because it's more specific
  */
-export const PageDataSchema = z.union([
-  PageDataWithComponentSchema,
-  JSONPageSchema,
-]);
+export const PageDataSchema = z.union([PageDataWithComponentSchema, JSONPageSchema]);
 
 // ============================================================================
 // CMS Schemas
@@ -547,23 +765,34 @@ export const PageDataSchema = z.union([
  * CMS field type schema
  */
 export const CMSFieldTypeSchema = z.enum([
-  'string', 'text', 'rich-text', 'number', 'boolean', 'image', 'file', 'date', 'select', 'reference'
+  'string',
+  'text',
+  'rich-text',
+  'number',
+  'boolean',
+  'image',
+  'file',
+  'date',
+  'select',
+  'reference',
 ]);
 
 /**
  * CMS field definition schema
  */
-export const CMSFieldDefinitionSchema = z.object({
-  type: CMSFieldTypeSchema,
-  required: z.boolean().optional(),
-  default: z.unknown().optional(),
-  label: z.string().optional(),
-  description: z.string().optional(),
-  options: z.array(z.string()).optional(),
-  accept: z.string().optional(),
-  collection: z.string().optional(),
-  multiple: z.boolean().optional(),
-}).passthrough();
+export const CMSFieldDefinitionSchema = z
+  .object({
+    type: CMSFieldTypeSchema,
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    label: z.string().optional(),
+    description: z.string().optional(),
+    options: z.array(z.string()).optional(),
+    accept: z.string().optional(),
+    collection: z.string().optional(),
+    multiple: z.boolean().optional(),
+  })
+  .passthrough();
 
 /**
  * CMS client data strategy schema
@@ -574,34 +803,42 @@ export const CMSClientDataStrategySchema = z.enum(['auto', 'inline', 'static']);
  * CMS client data config schema
  * Configures client-side data exposure for dynamic filtering
  */
-export const CMSClientDataConfigSchema = z.object({
-  enabled: z.boolean(),
-  strategy: CMSClientDataStrategySchema,
-  threshold: z.number().positive().optional(),
-  fields: z.array(z.string()).optional(),
-}).passthrough();
+export const CMSClientDataConfigSchema = z
+  .object({
+    enabled: z.boolean(),
+    strategy: CMSClientDataStrategySchema,
+    threshold: z.number().positive().optional(),
+    fields: z.array(z.string()).optional(),
+  })
+  .passthrough();
 
 /**
  * CMS schema schema (defines collection structure)
  */
-export const CMSSchemaSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  slugField: z.string(),
-  urlPattern: z.string(),
-  fields: z.record(CMSFieldDefinitionSchema),
-  clientData: CMSClientDataConfigSchema.optional(),
-}).passthrough();
+export const CMSSchemaSchema = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    // Optional: a data-only collection (no per-item route) omits both.
+    slugField: z.string().optional(),
+    urlPattern: z.string().optional(),
+    fields: z.record(CMSFieldDefinitionSchema),
+    clientData: CMSClientDataConfigSchema.optional(),
+    rss: z.boolean().optional(),
+  })
+  .passthrough();
 
 /**
  * CMS item schema (content entry, strict — used at publish/save time).
  */
-export const CMSItemSchema = z.object({
-  _id: z.string(),
-  _slug: z.string().optional(),
-  _filename: z.string().optional(),
-  _createdAt: z.string().optional(),
-}).passthrough();
+export const CMSItemSchema = z
+  .object({
+    _id: z.string(),
+    _slug: z.string().optional(),
+    _filename: z.string().optional(),
+    _createdAt: z.string().optional(),
+  })
+  .passthrough();
 
 /**
  * CMS draft item schema (loose — used at draft-write time).
@@ -610,12 +847,14 @@ export const CMSItemSchema = z.object({
  * are optional at this stage. Strict validation runs when promoting the draft
  * to published (see `publishDraft` in `FileSystemCMSProvider`).
  */
-export const CMSDraftItemSchema = z.object({
-  _id: z.string().optional(),
-  _slug: z.string().optional(),
-  _filename: z.string().optional(),
-  _createdAt: z.string().optional(),
-}).passthrough();
+export const CMSDraftItemSchema = z
+  .object({
+    _id: z.string().optional(),
+    _slug: z.string().optional(),
+    _filename: z.string().optional(),
+    _createdAt: z.string().optional(),
+  })
+  .passthrough();
 
 /**
  * CMS filter condition schema
@@ -639,11 +878,7 @@ export const CMSSortConfigSchema = z.object({
  */
 export const CMSListQuerySchema = z.object({
   collection: z.string(),
-  filter: z.union([
-    CMSFilterConditionSchema,
-    z.array(CMSFilterConditionSchema),
-    z.record(z.unknown()),
-  ]).optional(),
+  filter: z.union([CMSFilterConditionSchema, z.array(CMSFilterConditionSchema), z.record(z.unknown())]).optional(),
   sort: z.union([CMSSortConfigSchema, z.array(CMSSortConfigSchema)]).optional(),
   limit: z.number().positive().optional(),
   offset: z.number().nonnegative().optional(),
@@ -656,51 +891,87 @@ export const CMSListQuerySchema = z.object({
  * - {{<itemAs>Index}}, {{<itemAs>First}}, {{<itemAs>Last}} - Position info
  * Legacy {{item.field}}, {{itemIndex}}, etc. still supported
  */
-export const CMSListNodeSchema = z.object({
-  type: z.literal('cms-list'),
-  collection: z.string(),
-  if: IfConditionSchema.optional(),
-  itemAs: z.string().optional(),
-  items: z.union([z.string(), z.array(z.string())]).optional(),
-  filter: z.union([
-    CMSFilterConditionSchema,
-    z.array(CMSFilterConditionSchema),
-    z.record(z.unknown()),
-  ]).optional(),
-  sort: z.union([CMSSortConfigSchema, z.array(CMSSortConfigSchema)]).optional(),
-  limit: z.number().positive().optional(),
-  offset: z.number().nonnegative().optional(),
-  excludeCurrentItem: z.boolean().optional(),
-  children: z.array(z.unknown()).optional(),
-}).passthrough();
+export const CMSListNodeSchema = z
+  .object({
+    type: z.literal('cms-list'),
+    collection: z.string(),
+    if: IfConditionSchema.optional(),
+    itemAs: z.string().optional(),
+    items: z.union([z.string(), z.array(z.string())]).optional(),
+    filter: z.union([CMSFilterConditionSchema, z.array(CMSFilterConditionSchema), z.record(z.unknown())]).optional(),
+    sort: z.union([CMSSortConfigSchema, z.array(CMSSortConfigSchema)]).optional(),
+    limit: z.number().positive().optional(),
+    offset: z.number().nonnegative().optional(),
+    excludeCurrentItem: z.boolean().optional(),
+    children: z.array(z.unknown()).optional(),
+  })
+  .passthrough();
 
 /**
  * Page CMS config schema (embedded in page meta)
  */
-export const PageCmsConfigSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  slugField: z.string(),
-  urlPattern: z.string(),
-  fields: z.record(CMSFieldDefinitionSchema),
-}).passthrough();
+export const PageCmsConfigSchema = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    // Optional: a data-only collection (no per-item route) omits both.
+    slugField: z.string().optional(),
+    urlPattern: z.string().optional(),
+    fields: z.record(CMSFieldDefinitionSchema),
+    rss: z.boolean().optional(),
+  })
+  .passthrough();
+
+/**
+ * SSR page data-source schema (one entry of `meta.data.sources`).
+ */
+export const PageDataSourceSchema = z
+  .object({
+    type: z.literal('fetch'),
+    url: z.string(),
+    method: z.literal('GET').optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+    path: z.string().optional(),
+    fields: z.record(z.enum(['string', 'number', 'boolean', 'date', 'image', 'object'])).optional(),
+    cardinality: z.enum(['object', 'list']).optional(),
+  })
+  .passthrough();
+
+/**
+ * SSR page data config schema (embedded in page meta as `meta.data`, required when
+ * `meta.source === 'ssr'`).
+ */
+export const PageDataConfigSchema = z
+  .object({
+    sources: z.record(z.string(), PageDataSourceSchema),
+  })
+  .passthrough();
 
 /**
  * Page metadata schema with CMS support
  * Extends base schema with source and cms fields
  */
-export const PageMetaDataWithCMSSchema = z.object({
-  title: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
-  description: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
-  keywords: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
-  ogTitle: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
-  ogDescription: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
-  ogImage: z.string().optional(),
-  ogType: z.string().optional(),
-  slugs: z.record(z.string(), z.string()).optional(),
-  source: z.enum(['static', 'cms']).optional(),
-  cms: PageCmsConfigSchema.optional(),
-  draft: z.boolean().optional(),
-  libraries: PageLibrariesConfigSchema.optional(),
-  customCode: CustomCodeConfigSchema.optional(),
-}).passthrough();
+export const PageMetaDataWithCMSSchema = z
+  .object({
+    title: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+    description: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+    keywords: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+    ogTitle: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+    ogDescription: z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()]).optional(),
+    ogImage: z.string().optional(),
+    ogType: z.string().optional(),
+    slugs: z.record(z.string(), z.string()).optional(),
+    source: z.enum(['static', 'cms', 'ssr']).optional(),
+    cms: PageCmsConfigSchema.optional(),
+    data: PageDataConfigSchema.optional(),
+    routeParams: z.array(z.string()).optional(),
+    routePreview: z.record(z.string(), z.string()).optional(),
+    draft: z.boolean().optional(),
+    libraries: PageLibrariesConfigSchema.optional(),
+    customCode: CustomCodeConfigSchema.optional(),
+    viewTransitions: z.boolean().optional(),
+    noindex: z.boolean().optional(),
+    prerender: z.boolean().optional(),
+    sitemap: SitemapPageConfigSchema.optional(),
+  })
+  .passthrough();