@duckpic/content-spec 0.2.0 → 0.2.1

package/dist/components/ComponentSpec.d.ts

@@ -1,6 +1,25 @@
 import type { ZodType } from "zod";
+export interface ComponentUiMetadata {
+    /**
+     * Human-friendly label for menus and UI surfaces.
+     */
+    label?: string;
+    /**
+     * Whether this component can be inserted by users. Defaults to true.
+     */
+    insertable?: boolean;
+    /**
+     * Optional sort order for insertion menus. Lower comes first.
+     */
+    insertMenuOrder?: number;
+    /**
+     * Optional icon identifier the host app can map to an asset set.
+     */
+    iconId?: string;
+}
 export interface ComponentSpec {
     type: string;
     propsSchema: ZodType<any>;
     slots: string[];
+    ui?: ComponentUiMetadata;
 }

package/dist/components/Layout.js

@@ -10,5 +10,10 @@ export const LayoutPropsSchema = z.object({
 export const LayoutComponentSpec = {
     type: "Layout",
     propsSchema: LayoutPropsSchema,
-    slots: ["content"]
+    slots: ["content"],
+    ui: {
+        label: "Layout",
+        insertable: true,
+        insertMenuOrder: 20,
+    }
 };

package/dist/components/Multipage.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import type { ComponentSpec } from "./ComponentSpec";
+export declare const MultipagePropsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const MultipageComponentSpec: ComponentSpec;

package/dist/components/Multipage.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export const MultipagePropsSchema = z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+});
+export const MultipageComponentSpec = {
+    type: "Multipage",
+    propsSchema: MultipagePropsSchema,
+    slots: ["pages"],
+    ui: {
+        label: "Multipage",
+        insertable: true,
+        insertMenuOrder: 40,
+    },
+};

package/dist/components/Page.js

@@ -6,5 +6,10 @@ export const PagePropsSchema = z.object({
 export const PageComponentSpec = {
     type: "Page",
     propsSchema: PagePropsSchema,
-    slots: ["main"]
+    slots: ["main"],
+    ui: {
+        label: "Page",
+        insertable: false,
+        insertMenuOrder: 0,
+    }
 };

package/dist/components/Quiz.js

@@ -11,5 +11,10 @@ export const QuizPropsSchema = z.object({
 export const QuizComponentSpec = {
     type: "Quiz",
     propsSchema: QuizPropsSchema,
-    slots: [] // quizzes don’t have child nodes
+    slots: [], // quizzes don’t have child nodes
+    ui: {
+        label: "Quiz",
+        insertable: false,
+        insertMenuOrder: 30,
+    }
 };

package/dist/components/Text.js

@@ -7,5 +7,10 @@ export const TextPropsSchema = z.object({
 export const TextComponentSpec = {
     type: "Text",
     propsSchema: TextPropsSchema,
-    slots: []
+    slots: [],
+    ui: {
+        label: "Text",
+        insertable: true,
+        insertMenuOrder: 10,
+    }
 };

package/dist/files.txt

@@ -0,0 +1,265 @@
+--components/ComponentSpec.d.ts--
+import type { ZodType } from "zod";
+export interface ComponentSpec {
+    type: string;
+    propsSchema: ZodType<any>;
+    slots: string[];
+}
+
+
+--components/ComponentSpec.js--
+export {};
+
+
+--components/Layout.d.ts--
+import { z } from "zod";
+import type { ComponentSpec } from "./ComponentSpec";
+export declare const LayoutPropsSchema: z.ZodObject<{
+    backgroundColor: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodObject<{
+        backgroundColor: z.ZodOptional<z.ZodString>;
+        padding: z.ZodOptional<z.ZodString>;
+        borderRadius: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const LayoutComponentSpec: ComponentSpec;
+
+
+--components/Layout.js--
+import { z } from "zod";
+export const LayoutPropsSchema = z.object({
+    backgroundColor: z.string().optional(),
+    style: z.object({
+        backgroundColor: z.string().optional(),
+        padding: z.string().optional(),
+        borderRadius: z.string().optional()
+    }).optional()
+});
+export const LayoutComponentSpec = {
+    type: "Layout",
+    propsSchema: LayoutPropsSchema,
+    slots: ["content"]
+};
+
+
+--components/Page.d.ts--
+import { z } from "zod";
+import type { ComponentSpec } from "./ComponentSpec";
+export declare const PagePropsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PageComponentSpec: ComponentSpec;
+
+
+--components/Page.js--
+import { z } from "zod";
+export const PagePropsSchema = z.object({
+    title: z.string().optional(),
+    backgroundColor: z.string().optional()
+});
+export const PageComponentSpec = {
+    type: "Page",
+    propsSchema: PagePropsSchema,
+    slots: ["main"]
+};
+
+
+--components/Quiz.d.ts--
+import { z } from "zod";
+import { ComponentSpec } from "./ComponentSpec";
+export declare const QuizQuestionSchema: z.ZodObject<{
+    q: z.ZodString;
+    a: z.ZodString;
+}, z.core.$strip>;
+export declare const QuizPropsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    questions: z.ZodArray<z.ZodObject<{
+        q: z.ZodString;
+        a: z.ZodString;
+    }, z.core.$strip>>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type QuizProps = z.infer<typeof QuizPropsSchema>;
+export declare const QuizComponentSpec: ComponentSpec;
+
+
+--components/Quiz.js--
+import { z } from "zod";
+export const QuizQuestionSchema = z.object({
+    q: z.string(),
+    a: z.string()
+});
+export const QuizPropsSchema = z.object({
+    title: z.string().optional(),
+    questions: z.array(QuizQuestionSchema).min(1),
+    backgroundColor: z.string().optional()
+});
+export const QuizComponentSpec = {
+    type: "Quiz",
+    propsSchema: QuizPropsSchema,
+    slots: [] // quizzes don’t have child nodes
+};
+
+
+--components/Text.d.ts--
+import { z } from "zod";
+import type { ComponentSpec } from "./ComponentSpec";
+export declare const TextPropsSchema: z.ZodObject<{
+    variant: z.ZodEnum<{
+        body: "body";
+        h1: "h1";
+        h2: "h2";
+        h3: "h3";
+    }>;
+    text: z.ZodString;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TextComponentSpec: ComponentSpec;
+
+
+--components/Text.js--
+import { z } from "zod";
+export const TextPropsSchema = z.object({
+    variant: z.enum(["h1", "h2", "h3", "body"]),
+    text: z.string(),
+    backgroundColor: z.string().optional()
+});
+export const TextComponentSpec = {
+    type: "Text",
+    propsSchema: TextPropsSchema,
+    slots: []
+};
+
+
+--index.d.ts--
+export * from "./components/Text";
+export * from "./components/Quiz";
+export * from "./components/Layout";
+export * from "./components/Page";
+export * from "./schema/PageTree";
+import type { ComponentSpec } from "./components/ComponentSpec.ts";
+export declare const ComponentRegistry: {
+    Text: ComponentSpec;
+    Quiz: ComponentSpec;
+    Layout: ComponentSpec;
+    Page: ComponentSpec;
+};
+export type ComponentType = keyof typeof ComponentRegistry;
+export declare function getPropsSchema(type: ComponentType): import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
+export type { ComponentSpec };
+
+
+--index.js--
+export * from "./components/Text";
+export * from "./components/Quiz";
+export * from "./components/Layout";
+export * from "./components/Page";
+export * from "./schema/PageTree";
+import { TextComponentSpec } from "./components/Text";
+import { QuizComponentSpec } from "./components/Quiz";
+import { LayoutComponentSpec } from "./components/Layout";
+import { PageComponentSpec } from "./components/Page";
+export const ComponentRegistry = {
+    Text: TextComponentSpec,
+    Quiz: QuizComponentSpec,
+    Layout: LayoutComponentSpec,
+    Page: PageComponentSpec
+};
+// Helper to get a schema by type
+export function getPropsSchema(type) {
+    return ComponentRegistry[type].propsSchema;
+}
+
+
+--schema/PageTree.d.ts--
+import { z } from "zod";
+export declare const NodeIdSchema: z.ZodString;
+export declare const ContentNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    props: z.ZodRecord<z.ZodString, z.ZodAny>;
+    slots: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ContentNode = z.infer<typeof ContentNodeSchema>;
+export declare const PageTreeSchema: z.ZodObject<{
+    version: z.ZodString;
+    root: z.ZodString;
+    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        props: z.ZodRecord<z.ZodString, z.ZodAny>;
+        slots: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PageTree = z.infer<typeof PageTreeSchema>;
+
+
+--schema/PageTree.js--
+import { z } from "zod";
+export const NodeIdSchema = z.string().min(1);
+// You can switch to stricter UUID validation later.
+export const ContentNodeSchema = z.object({
+    id: NodeIdSchema,
+    type: z.string(), // we'll refine typing later
+    props: z.record(z.string(), z.any()), // key: string, value: any
+    slots: z.record(z.string(), z.array(NodeIdSchema))
+});
+export const PageTreeSchema = z.object({
+    version: z.string(),
+    root: NodeIdSchema,
+    nodes: z.record(z.string(), ContentNodeSchema)
+});
+
+
+--validators/validateNode.d.ts--
+import { ContentNode } from "..";
+export declare function validateNode(node: ContentNode): void;
+
+
+--validators/validateNode.js--
+import { ComponentRegistry } from "..";
+export function validateNode(node) {
+    const type = node.type;
+    const spec = ComponentRegistry[type];
+    if (!spec) {
+        throw new Error(`Unknown component type: ${node.type}`);
+    }
+    // 1) Validate props
+    spec.propsSchema.parse(node.props);
+    // 2) Validate slots
+    const allowedSlots = (spec.slots ?? []);
+    for (const slotName of Object.keys(node.slots)) {
+        if (!allowedSlots.includes(slotName)) {
+            throw new Error(`Invalid slot '${slotName}' for component type ${node.type}`);
+        }
+    }
+}
+
+
+--validators/validatePageTree.d.ts--
+export declare function validatePageTree(tree: unknown): {
+    version: string;
+    root: string;
+    nodes: Record<string, {
+        id: string;
+        type: string;
+        props: Record<string, any>;
+        slots: Record<string, string[]>;
+    }>;
+};
+
+
+--validators/validatePageTree.js--
+import { PageTreeSchema } from "../schema/PageTree";
+import { validateNode } from "./validateNode";
+export function validatePageTree(tree) {
+    const data = PageTreeSchema.parse(tree); // main shape
+    // Validate nodes individually
+    for (const node of Object.values(data.nodes)) {
+        validateNode(node);
+    }
+    return data;
+}
+
+

package/dist/index.d.ts

@@ -2,14 +2,18 @@ export * from "./components/Text";
 export * from "./components/Quiz";
 export * from "./components/Layout";
 export * from "./components/Page";
+export * from "./components/Multipage";
 export * from "./schema/PageTree";
-import type { ComponentSpec } from "./components/ComponentSpec.ts";
+import type { ComponentSpec, ComponentUiMetadata } from "./components/ComponentSpec.ts";
 export declare const ComponentRegistry: {
     Text: ComponentSpec;
     Quiz: ComponentSpec;
     Layout: ComponentSpec;
     Page: ComponentSpec;
+    Multipage: ComponentSpec;
 };
 export type ComponentType = keyof typeof ComponentRegistry;
 export declare function getPropsSchema(type: ComponentType): import("zod").ZodType<any, unknown, import("zod/v4/core").$ZodTypeInternals<any, unknown>>;
-export type { ComponentSpec };
+export declare function getInsertableComponentEntries(): Array<[ComponentType, ComponentSpec]>;
+export declare function getInsertableComponentTypes(): ComponentType[];
+export type { ComponentSpec, ComponentUiMetadata };

package/dist/index.js

@@ -2,18 +2,46 @@ export * from "./components/Text";
 export * from "./components/Quiz";
 export * from "./components/Layout";
 export * from "./components/Page";
+export * from "./components/Multipage";
 export * from "./schema/PageTree";
 import { TextComponentSpec } from "./components/Text";
 import { QuizComponentSpec } from "./components/Quiz";
 import { LayoutComponentSpec } from "./components/Layout";
 import { PageComponentSpec } from "./components/Page";
+import { MultipageComponentSpec } from "./components/Multipage";
 export const ComponentRegistry = {
     Text: TextComponentSpec,
     Quiz: QuizComponentSpec,
     Layout: LayoutComponentSpec,
-    Page: PageComponentSpec
+    Page: PageComponentSpec,
+    Multipage: MultipageComponentSpec,
 };
 // Helper to get a schema by type
 export function getPropsSchema(type) {
     return ComponentRegistry[type].propsSchema;
 }
+function isInsertable(spec) {
+    return spec.ui?.insertable !== false;
+}
+function getInsertOrder(spec) {
+    if (typeof spec.ui?.insertMenuOrder === "number") {
+        return spec.ui.insertMenuOrder;
+    }
+    return Number.POSITIVE_INFINITY;
+}
+export function getInsertableComponentEntries() {
+    return Object.entries(ComponentRegistry)
+        .filter(([, spec]) => isInsertable(spec))
+        .sort(([, aSpec], [, bSpec]) => {
+        const aOrder = getInsertOrder(aSpec);
+        const bOrder = getInsertOrder(bSpec);
+        if (aOrder !== bOrder)
+            return aOrder - bOrder;
+        const aLabel = aSpec.ui?.label ?? aSpec.type;
+        const bLabel = bSpec.ui?.label ?? bSpec.type;
+        return aLabel.localeCompare(bLabel);
+    });
+}
+export function getInsertableComponentTypes() {
+    return getInsertableComponentEntries().map(([type]) => type);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckpic/content-spec",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/components/ComponentSpec.ts

@@ -1,7 +1,27 @@
 import type { ZodType } from "zod";
 
+export interface ComponentUiMetadata {
+  /**
+   * Human-friendly label for menus and UI surfaces.
+   */
+  label?: string;
+  /**
+   * Whether this component can be inserted by users. Defaults to true.
+   */
+  insertable?: boolean;
+  /**
+   * Optional sort order for insertion menus. Lower comes first.
+   */
+  insertMenuOrder?: number;
+  /**
+   * Optional icon identifier the host app can map to an asset set.
+   */
+  iconId?: string;
+}
+
 export interface ComponentSpec {
   type: string;
   propsSchema: ZodType<any>;
   slots: string[];
+  ui?: ComponentUiMetadata;
 }

package/src/components/Layout.ts

@@ -13,5 +13,10 @@ export const LayoutPropsSchema = z.object({
 export const LayoutComponentSpec: ComponentSpec = {
   type: "Layout",
   propsSchema: LayoutPropsSchema,
-  slots: ["content"]
+  slots: ["content"],
+  ui: {
+    label: "Layout",
+    insertable: true,
+    insertMenuOrder: 20,
+  }
 };

package/src/components/Multipage.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import type { ComponentSpec } from "./ComponentSpec";
+
+export const MultipagePropsSchema = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+});
+
+export const MultipageComponentSpec: ComponentSpec = {
+  type: "Multipage",
+  propsSchema: MultipagePropsSchema,
+  slots: ["pages"],
+  ui: {
+    label: "Multipage",
+    insertable: true,
+    insertMenuOrder: 40,
+  },
+};

package/src/components/Page.ts

@@ -9,5 +9,10 @@ export const PagePropsSchema = z.object({
 export const PageComponentSpec: ComponentSpec = {
   type: "Page",
   propsSchema: PagePropsSchema,
-  slots: ["main"]
+  slots: ["main"],
+  ui: {
+    label: "Page",
+    insertable: false,
+    insertMenuOrder: 0,
+  }
 };

package/src/components/Quiz.ts

@@ -17,5 +17,10 @@ export type QuizProps = z.infer<typeof QuizPropsSchema>;
 export const QuizComponentSpec: ComponentSpec = {
   type: "Quiz",
   propsSchema: QuizPropsSchema,
-  slots: [] // quizzes don’t have child nodes
+  slots: [], // quizzes don’t have child nodes
+  ui: {
+    label: "Quiz",
+    insertable: false,
+    insertMenuOrder: 30,
+  }
 };

package/src/components/Text.ts

@@ -10,5 +10,10 @@ export const TextPropsSchema = z.object({
 export const TextComponentSpec: ComponentSpec = {
   type: "Text",
   propsSchema: TextPropsSchema,
-  slots: []
+  slots: [],
+  ui: {
+    label: "Text",
+    insertable: true,
+    insertMenuOrder: 10,
+  }
 };

package/src/index.ts

@@ -2,6 +2,7 @@ export * from "./components/Text";
 export * from "./components/Quiz";
 export * from "./components/Layout";
 export * from "./components/Page";
+export * from "./components/Multipage";
 export * from "./schema/PageTree";
 
 
@@ -9,13 +10,15 @@ import { TextComponentSpec } from "./components/Text";
 import { QuizComponentSpec } from "./components/Quiz";
 import { LayoutComponentSpec } from "./components/Layout";
 import { PageComponentSpec } from "./components/Page";
-import type { ComponentSpec } from "./components/ComponentSpec.ts";
+import { MultipageComponentSpec } from "./components/Multipage";
+import type { ComponentSpec, ComponentUiMetadata } from "./components/ComponentSpec.ts";
 
 export const ComponentRegistry = {
   Text: TextComponentSpec,
   Quiz: QuizComponentSpec,
   Layout: LayoutComponentSpec,
-  Page: PageComponentSpec
+  Page: PageComponentSpec,
+  Multipage: MultipageComponentSpec,
 };
 
 export type ComponentType = keyof typeof ComponentRegistry;
@@ -24,4 +27,34 @@ export type ComponentType = keyof typeof ComponentRegistry;
 export function getPropsSchema(type: ComponentType) {
   return ComponentRegistry[type].propsSchema;
 }
-export type { ComponentSpec };
+
+function isInsertable(spec: ComponentSpec) {
+  return spec.ui?.insertable !== false;
+}
+
+function getInsertOrder(spec: ComponentSpec) {
+  if (typeof spec.ui?.insertMenuOrder === "number") {
+    return spec.ui.insertMenuOrder;
+  }
+  return Number.POSITIVE_INFINITY;
+}
+
+export function getInsertableComponentEntries(): Array<[ComponentType, ComponentSpec]> {
+  return (Object.entries(ComponentRegistry) as Array<[ComponentType, ComponentSpec]>)
+    .filter(([, spec]) => isInsertable(spec))
+    .sort(([, aSpec], [, bSpec]) => {
+      const aOrder = getInsertOrder(aSpec);
+      const bOrder = getInsertOrder(bSpec);
+      if (aOrder !== bOrder) return aOrder - bOrder;
+
+      const aLabel = aSpec.ui?.label ?? aSpec.type;
+      const bLabel = bSpec.ui?.label ?? bSpec.type;
+      return aLabel.localeCompare(bLabel);
+    });
+}
+
+export function getInsertableComponentTypes(): ComponentType[] {
+  return getInsertableComponentEntries().map(([type]) => type);
+}
+
+export type { ComponentSpec, ComponentUiMetadata };

package/src/files.txt

@@ -1,160 +0,0 @@
---components/ComponentSpec.ts--
-import type { ZodType } from "zod";
-
-export interface ComponentSpec {
-  type: string;
-  propsSchema: ZodType<any>;
-  slots: string[];
-}
-
-
---components/Layout.ts--
-import { z } from "zod";
-import type { ComponentSpec } from "./ComponentSpec";
-
-export const LayoutPropsSchema = z.object({
-  style: z.object({
-    backgroundColor: z.string().optional(),
-    padding: z.string().optional(),
-    borderRadius: z.string().optional()
-  }).optional()
-});
-
-export const LayoutComponentSpec: ComponentSpec = {
-  type: "Layout",
-  propsSchema: LayoutPropsSchema,
-  slots: ["content"]
-};
-
-
---components/Quiz.ts--
-import { z } from "zod";
-import { ComponentSpec } from "./ComponentSpec";
-
-export const QuizQuestionSchema = z.object({
-  q: z.string(),
-  a: z.string()
-});
-
-export const QuizPropsSchema = z.object({
-  title: z.string().optional(),
-  questions: z.array(QuizQuestionSchema).min(1)
-});
-
-export type QuizProps = z.infer<typeof QuizPropsSchema>;
-
-export const QuizComponentSpec: ComponentSpec = {
-  type: "Quiz",
-  propsSchema: QuizPropsSchema,
-  slots: [] // quizzes don’t have child nodes
-};
-
-
---components/Text.ts--
-import { z } from "zod";
-import type { ComponentSpec } from "./ComponentSpec";
-
-export const TextPropsSchema = z.object({
-  variant: z.enum(["h1", "h2", "h3", "body"]),
-  text: z.string()
-});
-
-export const TextComponentSpec: ComponentSpec = {
-  type: "Text",
-  propsSchema: TextPropsSchema,
-  slots: []
-};
-
-
---index.ts--
-export * from "./components/Text";
-export * from "./components/Quiz";
-export * from "./components/Layout";
-export * from "./schema/PageTree";
-
-
-import { TextComponentSpec } from "./components/Text";
-import { QuizComponentSpec } from "./components/Quiz";
-import { LayoutComponentSpec } from "./components/Layout";
-import type { ComponentSpec } from "./components/ComponentSpec.ts";
-
-export const ComponentRegistry = {
-  Text: TextComponentSpec,
-  Quiz: QuizComponentSpec,
-  Layout: LayoutComponentSpec
-};
-
-export type ComponentType = keyof typeof ComponentRegistry;
-
-// Helper to get a schema by type
-export function getPropsSchema(type: ComponentType) {
-  return ComponentRegistry[type].propsSchema;
-}
-export type { ComponentSpec };
-
---schema/PageTree.ts--
-import { z } from "zod";
-
-export const NodeIdSchema = z.string().min(1); 
-// You can switch to stricter UUID validation later.
-
-export const ContentNodeSchema = z.object({
-  id: NodeIdSchema,
-  type: z.string(),                           // we'll refine typing later
-  props: z.record(z.string(), z.any()),       // key: string, value: any
-  slots: z.record(z.string(), z.array(NodeIdSchema))
-});
-
-export type ContentNode = z.infer<typeof ContentNodeSchema>;
-
-export const PageTreeSchema = z.object({
-  version: z.string(),
-  root: NodeIdSchema,
-  nodes: z.record(z.string(), ContentNodeSchema)
-});
-
-export type PageTree = z.infer<typeof PageTreeSchema>;
-
-
---validators/validateNode.ts--
-import { ComponentRegistry, ComponentType, ContentNode } from "..";
-
-export function validateNode(node: ContentNode) {
-  const type = node.type as ComponentType;
-  const spec = ComponentRegistry[type];
-
-  if (!spec) {
-    throw new Error(`Unknown component type: ${node.type}`);
-  }
-
-  // 1) Validate props
-  spec.propsSchema.parse(node.props);
-
-  // 2) Validate slots
-  const allowedSlots = (spec.slots ?? []) as string[];
-  for (const slotName of Object.keys(node.slots)) {
-    if (!allowedSlots.includes(slotName)) {
-      throw new Error(
-        `Invalid slot '${slotName}' for component type ${node.type}`
-      );
-    }
-  }
-}
-
-
---validators/validatePageTree.ts--
-import { PageTreeSchema } from "../schema/PageTree";
-import { validateNode } from "./validateNode";
-
-export function validatePageTree(tree: unknown) {
-  const data = PageTreeSchema.parse(tree); // main shape
-
-  // Validate nodes individually
-  for (const node of Object.values(data.nodes)) {
-    validateNode(node);
-  }
-
-  return data;
-}
-
-