@constela/core 0.3.3 → 0.5.0

package/dist/index.d.ts

@@ -10,6 +10,14 @@ declare const UPDATE_OPERATIONS: readonly ["increment", "decrement", "push", "po
 type UpdateOperation = (typeof UPDATE_OPERATIONS)[number];
 declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE"];
 type HttpMethod = (typeof HTTP_METHODS)[number];
+declare const STORAGE_OPERATIONS: readonly ["get", "set", "remove"];
+type StorageOperation = (typeof STORAGE_OPERATIONS)[number];
+declare const STORAGE_TYPES: readonly ["local", "session"];
+type StorageType = (typeof STORAGE_TYPES)[number];
+declare const CLIPBOARD_OPERATIONS: readonly ["write", "read"];
+type ClipboardOperation = (typeof CLIPBOARD_OPERATIONS)[number];
+declare const NAVIGATE_TARGETS: readonly ["_self", "_blank"];
+type NavigateTarget = (typeof NAVIGATE_TARGETS)[number];
 declare const PARAM_TYPES: readonly ["string", "number", "boolean", "json"];
 type ParamType = (typeof PARAM_TYPES)[number];
 interface ParamDef {
@@ -79,7 +87,31 @@ interface GetExpr {
     base: Expression;
     path: string;
 }
-type Expression = LitExpr | StateExpr | VarExpr | BinExpr | NotExpr | ParamExpr | CondExpr | GetExpr;
+/**
+ * Route expression - references route parameters
+ */
+interface RouteExpr {
+    expr: 'route';
+    name: string;
+    source?: 'param' | 'query' | 'path';
+}
+/**
+ * Import expression - references imported external data
+ */
+interface ImportExpr {
+    expr: 'import';
+    name: string;
+    path?: string;
+}
+/**
+ * Data expression - references loaded data from data sources
+ */
+interface DataExpr {
+    expr: 'data';
+    name: string;
+    path?: string;
+}
+type Expression = LitExpr | StateExpr | VarExpr | BinExpr | NotExpr | ParamExpr | CondExpr | GetExpr | RouteExpr | ImportExpr | DataExpr;
 /**
  * Number state field
  */
@@ -164,7 +196,40 @@ interface FetchStep {
     onSuccess?: ActionStep[];
     onError?: ActionStep[];
 }
-type ActionStep = SetStep | UpdateStep | FetchStep;
+/**
+ * Storage step - localStorage/sessionStorage operations
+ */
+interface StorageStep {
+    do: 'storage';
+    operation: StorageOperation;
+    key: Expression;
+    value?: Expression;
+    storage: StorageType;
+    result?: string;
+    onSuccess?: ActionStep[];
+    onError?: ActionStep[];
+}
+/**
+ * Clipboard step - clipboard API operations
+ */
+interface ClipboardStep {
+    do: 'clipboard';
+    operation: ClipboardOperation;
+    value?: Expression;
+    result?: string;
+    onSuccess?: ActionStep[];
+    onError?: ActionStep[];
+}
+/**
+ * Navigate step - page navigation
+ */
+interface NavigateStep {
+    do: 'navigate';
+    url: Expression;
+    target?: NavigateTarget;
+    replace?: boolean;
+}
+type ActionStep = SetStep | UpdateStep | FetchStep | StorageStep | ClipboardStep | NavigateStep;
 /**
  * Event handler - binds an event to an action
  */
@@ -227,26 +292,109 @@ interface ComponentNode {
 }
 /**
  * Slot node - placeholder for children in component definition
+ * For layouts, can have an optional name for named slots
  */
 interface SlotNode {
     kind: 'slot';
+    name?: string;
+}
+/**
+ * Markdown node - renders markdown content
+ */
+interface MarkdownNode {
+    kind: 'markdown';
+    content: Expression;
 }
-type ViewNode = ElementNode | TextNode | IfNode | EachNode | ComponentNode | SlotNode;
+/**
+ * Code node - renders syntax-highlighted code
+ */
+interface CodeNode {
+    kind: 'code';
+    language: Expression;
+    content: Expression;
+}
+type ViewNode = ElementNode | TextNode | IfNode | EachNode | ComponentNode | SlotNode | MarkdownNode | CodeNode;
 interface ComponentDef {
     params?: Record<string, ParamDef>;
     view: ViewNode;
 }
+/**
+ * Data transform types for build-time content loading
+ */
+declare const DATA_TRANSFORMS: readonly ["mdx", "yaml", "csv"];
+type DataTransform = (typeof DATA_TRANSFORMS)[number];
+/**
+ * Data source types
+ */
+declare const DATA_SOURCE_TYPES: readonly ["glob", "file", "api"];
+type DataSourceType = (typeof DATA_SOURCE_TYPES)[number];
+/**
+ * Data source for build-time content loading
+ */
+interface DataSource {
+    type: DataSourceType;
+    pattern?: string;
+    path?: string;
+    url?: string;
+    transform?: DataTransform;
+}
+/**
+ * Static paths definition for SSG
+ */
+interface StaticPathsDefinition {
+    source: string;
+    params: Record<string, Expression>;
+}
+/**
+ * Route definition for a page
+ */
+interface RouteDefinition {
+    path: string;
+    title?: Expression;
+    layout?: string;
+    meta?: Record<string, Expression>;
+    getStaticPaths?: StaticPathsDefinition;
+}
+/**
+ * Lifecycle hooks for component/page lifecycle events
+ */
+interface LifecycleHooks {
+    onMount?: string;
+    onUnmount?: string;
+    onRouteEnter?: string;
+    onRouteLeave?: string;
+}
 /**
  * Program - the root of a Constela AST
  */
 interface Program {
     version: '1.0';
+    route?: RouteDefinition;
+    imports?: Record<string, string>;
+    data?: Record<string, DataSource>;
+    lifecycle?: LifecycleHooks;
     state: Record<string, StateField>;
     actions: ActionDefinition[];
     view: ViewNode;
     components?: Record<string, ComponentDef>;
 }
 type ConstelaAst = Program;
+/**
+ * Layout program - a special type of program that wraps page content
+ * Must contain at least one SlotNode in the view tree
+ */
+interface LayoutProgram {
+    version: '1.0';
+    type: 'layout';
+    state?: Record<string, StateField>;
+    actions?: ActionDefinition[];
+    view: ViewNode;
+    components?: Record<string, ComponentDef>;
+}
+/**
+ * Union type for both regular Program and LayoutProgram
+ */
+type ConstelaProgram = Program | LayoutProgram;
 
 /**
  * Type Guards for Constela AST Types
@@ -310,6 +458,30 @@ declare function isCondExpr(value: unknown): value is CondExpr;
  * Use the AST validator for full recursive validation instead.
  */
 declare function isGetExpr(value: unknown): value is GetExpr;
+/**
+ * Checks if value is a route expression
+ */
+declare function isRouteExpr(value: unknown): value is RouteExpr;
+/**
+ * Checks if value is an import expression
+ */
+declare function isImportExpr(value: unknown): value is ImportExpr;
+/**
+ * Checks if value is a data expression
+ */
+declare function isDataExpr(value: unknown): value is DataExpr;
+/**
+ * Checks if value is a data source
+ */
+declare function isDataSource(value: unknown): value is DataSource;
+/**
+ * Checks if value is a static paths definition
+ */
+declare function isStaticPathsDefinition(value: unknown): value is StaticPathsDefinition;
+/**
+ * Checks if value is a route definition
+ */
+declare function isRouteDefinition(value: unknown): value is RouteDefinition;
 /**
  * Checks if value is any valid expression
  */
@@ -338,6 +510,14 @@ declare function isComponentNode(value: unknown): value is ComponentNode;
  * Checks if value is a slot node
  */
 declare function isSlotNode(value: unknown): value is SlotNode;
+/**
+ * Checks if value is a markdown node
+ */
+declare function isMarkdownNode(value: unknown): value is MarkdownNode;
+/**
+ * Checks if value is a code node
+ */
+declare function isCodeNode(value: unknown): value is CodeNode;
 /**
  * Checks if value is any valid view node
  */
@@ -354,6 +534,18 @@ declare function isUpdateStep(value: unknown): value is UpdateStep;
  * Checks if value is a fetch step
  */
 declare function isFetchStep(value: unknown): value is FetchStep;
+/**
+ * Checks if value is a storage step
+ */
+declare function isStorageStep(value: unknown): value is StorageStep;
+/**
+ * Checks if value is a clipboard step
+ */
+declare function isClipboardStep(value: unknown): value is ClipboardStep;
+/**
+ * Checks if value is a navigate step
+ */
+declare function isNavigateStep(value: unknown): value is NavigateStep;
 /**
  * Checks if value is any valid action step
  */
@@ -386,6 +578,23 @@ declare function isStateField(value: unknown): value is StateField;
  * Checks if value is an event handler
  */
 declare function isEventHandler(value: unknown): value is EventHandler;
+/**
+ * Checks if value is a layout program
+ */
+declare function isLayoutProgram(value: unknown): value is LayoutProgram;
+/**
+ * Checks if value is a named slot node (slot with a name property)
+ */
+declare function isNamedSlotNode(value: unknown): value is SlotNode & {
+    name: string;
+};
+/**
+ * Checks if value is a lifecycle hooks object
+ *
+ * Lifecycle hooks are permissive - they allow unknown properties for extensibility.
+ * Only known properties are validated to be strings.
+ */
+declare function isLifecycleHooks(value: unknown): value is LifecycleHooks;
 
 /**
  * Error Types for Constela
@@ -393,7 +602,7 @@ declare function isEventHandler(value: unknown): value is EventHandler;
  * This module defines error types, the ConstelaError class,
  * and factory functions for creating specific errors.
  */
-type ErrorCode = 'SCHEMA_INVALID' | 'UNDEFINED_STATE' | 'UNDEFINED_ACTION' | 'VAR_UNDEFINED' | 'DUPLICATE_ACTION' | 'UNSUPPORTED_VERSION' | 'COMPONENT_NOT_FOUND' | 'COMPONENT_PROP_MISSING' | 'COMPONENT_CYCLE' | 'COMPONENT_PROP_TYPE' | 'PARAM_UNDEFINED' | 'OPERATION_INVALID_FOR_TYPE' | 'OPERATION_MISSING_FIELD' | 'OPERATION_UNKNOWN' | 'EXPR_INVALID_BASE' | 'EXPR_INVALID_CONDITION' | 'EXPR_COND_ELSE_REQUIRED';
+type ErrorCode = 'SCHEMA_INVALID' | 'UNDEFINED_STATE' | 'UNDEFINED_ACTION' | 'VAR_UNDEFINED' | 'DUPLICATE_ACTION' | 'UNSUPPORTED_VERSION' | 'COMPONENT_NOT_FOUND' | 'COMPONENT_PROP_MISSING' | 'COMPONENT_CYCLE' | 'COMPONENT_PROP_TYPE' | 'PARAM_UNDEFINED' | 'OPERATION_INVALID_FOR_TYPE' | 'OPERATION_MISSING_FIELD' | 'OPERATION_UNKNOWN' | 'EXPR_INVALID_BASE' | 'EXPR_INVALID_CONDITION' | 'EXPR_COND_ELSE_REQUIRED' | 'UNDEFINED_ROUTE_PARAM' | 'ROUTE_NOT_DEFINED' | 'UNDEFINED_IMPORT' | 'IMPORTS_NOT_DEFINED' | 'LAYOUT_MISSING_SLOT' | 'LAYOUT_NOT_FOUND' | 'INVALID_SLOT_NAME' | 'DUPLICATE_SLOT_NAME' | 'DUPLICATE_DEFAULT_SLOT' | 'SLOT_IN_LOOP' | 'INVALID_DATA_SOURCE' | 'UNDEFINED_DATA_SOURCE' | 'DATA_NOT_DEFINED' | 'UNDEFINED_DATA' | 'INVALID_STORAGE_OPERATION' | 'INVALID_STORAGE_TYPE' | 'STORAGE_SET_MISSING_VALUE' | 'INVALID_CLIPBOARD_OPERATION' | 'CLIPBOARD_WRITE_MISSING_VALUE' | 'INVALID_NAVIGATE_TARGET';
 /**
  * Custom error class for Constela validation errors
  */
@@ -474,6 +683,86 @@ declare function createOperationUnknownError(operation: string, path?: string):
  * Creates a cond else required error
  */
 declare function createCondElseRequiredError(path?: string): ConstelaError;
+/**
+ * Creates an undefined route param error
+ */
+declare function createUndefinedRouteParamError(paramName: string, path?: string): ConstelaError;
+/**
+ * Creates a route not defined error
+ */
+declare function createRouteNotDefinedError(path?: string): ConstelaError;
+/**
+ * Creates an undefined import reference error
+ */
+declare function createUndefinedImportError(importName: string, path?: string): ConstelaError;
+/**
+ * Creates an imports not defined error
+ */
+declare function createImportsNotDefinedError(path?: string): ConstelaError;
+/**
+ * Creates a layout missing slot error
+ */
+declare function createLayoutMissingSlotError(path?: string): ConstelaError;
+/**
+ * Creates a layout not found error
+ */
+declare function createLayoutNotFoundError(layoutName: string, path?: string): ConstelaError;
+/**
+ * Creates an invalid slot name error
+ */
+declare function createInvalidSlotNameError(slotName: string, layoutName: string, path?: string): ConstelaError;
+/**
+ * Creates a duplicate slot name error
+ */
+declare function createDuplicateSlotNameError(slotName: string, path?: string): ConstelaError;
+/**
+ * Creates a duplicate default slot error
+ */
+declare function createDuplicateDefaultSlotError(path?: string): ConstelaError;
+/**
+ * Creates a slot in loop error
+ */
+declare function createSlotInLoopError(path?: string): ConstelaError;
+/**
+ * Creates an invalid data source error
+ */
+declare function createInvalidDataSourceError(dataName: string, reason: string, path?: string): ConstelaError;
+/**
+ * Creates an undefined data source error (for getStaticPaths)
+ */
+declare function createUndefinedDataSourceError(sourceName: string, path?: string): ConstelaError;
+/**
+ * Creates a data not defined error (for data or getStaticPaths used without data field)
+ */
+declare function createDataNotDefinedError(path?: string): ConstelaError;
+/**
+ * Creates an undefined data error (for DataExpr references)
+ */
+declare function createUndefinedDataError(dataName: string, path?: string): ConstelaError;
+/**
+ * Creates an invalid storage operation error
+ */
+declare function createInvalidStorageOperationError(operation: string, path?: string): ConstelaError;
+/**
+ * Creates an invalid storage type error
+ */
+declare function createInvalidStorageTypeError(storageType: string, path?: string): ConstelaError;
+/**
+ * Creates a storage set missing value error
+ */
+declare function createStorageSetMissingValueError(path?: string): ConstelaError;
+/**
+ * Creates an invalid clipboard operation error
+ */
+declare function createInvalidClipboardOperationError(operation: string, path?: string): ConstelaError;
+/**
+ * Creates a clipboard write missing value error
+ */
+declare function createClipboardWriteMissingValueError(path?: string): ConstelaError;
+/**
+ * Creates an invalid navigate target error
+ */
+declare function createInvalidNavigateTargetError(target: string, path?: string): ConstelaError;
 
 /**
  * AST Validator for Constela
@@ -921,6 +1210,10 @@ declare const astSchema: {
                 readonly $ref: "#/$defs/ComponentNode";
             }, {
                 readonly $ref: "#/$defs/SlotNode";
+            }, {
+                readonly $ref: "#/$defs/MarkdownNode";
+            }, {
+                readonly $ref: "#/$defs/CodeNode";
             }];
         };
         readonly ElementNode: {
@@ -1050,6 +1343,37 @@ declare const astSchema: {
                 };
             };
         };
+        readonly MarkdownNode: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "content"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly const: "markdown";
+                };
+                readonly content: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+            };
+        };
+        readonly CodeNode: {
+            readonly type: "object";
+            readonly required: readonly ["kind", "language", "content"];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly const: "code";
+                };
+                readonly language: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+                readonly content: {
+                    readonly $ref: "#/$defs/Expression";
+                };
+            };
+        };
         readonly ParamDef: {
             readonly type: "object";
             readonly required: readonly ["type"];
@@ -1083,4 +1407,4 @@ declare const astSchema: {
     };
 };
 
-export { type ActionDefinition, type ActionStep, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type BooleanField, type ComponentDef, type ComponentNode, type CondExpr, type ConstelaAst, ConstelaError, type EachNode, type ElementNode, type ErrorCode, type EventHandler, type Expression, type FetchStep, type GetExpr, HTTP_METHODS, type HttpMethod, type IfNode, type ListField, type LitExpr, type NotExpr, type NumberField, type ObjectField, PARAM_TYPES, type ParamDef, type ParamExpr, type ParamType, type Program, type SetStep, type SlotNode, type StateExpr, type StateField, type StringField, type TextNode, UPDATE_OPERATIONS, type UpdateOperation, type UpdateStep, type ValidationFailure, type ValidationResult, type ValidationSuccess, type VarExpr, type ViewNode, astSchema, createComponentCycleError, createComponentNotFoundError, createComponentPropMissingError, createComponentPropTypeError, createCondElseRequiredError, createDuplicateActionError, createOperationInvalidForTypeError, createOperationMissingFieldError, createOperationUnknownError, createSchemaError, createUndefinedActionError, createUndefinedParamError, createUndefinedStateError, createUndefinedVarError, createUnsupportedVersionError, isActionStep, isBinExpr, isBooleanField, isComponentNode, isCondExpr, isConstelaError, isEachNode, isElementNode, isEventHandler, isExpression, isFetchStep, isGetExpr, isIfNode, isListField, isLitExpr, isNotExpr, isNumberField, isObjectField, isParamExpr, isSetStep, isSlotNode, isStateExpr, isStateField, isStringField, isTextNode, isUpdateStep, isVarExpr, isViewNode, validateAst };
+export { type ActionDefinition, type ActionStep, BINARY_OPERATORS, type BinExpr, type BinaryOperator, type BooleanField, CLIPBOARD_OPERATIONS, type ClipboardOperation, type ClipboardStep, type CodeNode, type ComponentDef, type ComponentNode, type CondExpr, type ConstelaAst, ConstelaError, type ConstelaProgram, DATA_SOURCE_TYPES, DATA_TRANSFORMS, type DataExpr, type DataSource, type DataSourceType, type DataTransform, type EachNode, type ElementNode, type ErrorCode, type EventHandler, type Expression, type FetchStep, type GetExpr, HTTP_METHODS, type HttpMethod, type IfNode, type ImportExpr, type LayoutProgram, type LifecycleHooks, type ListField, type LitExpr, type MarkdownNode, NAVIGATE_TARGETS, type NavigateStep, type NavigateTarget, type NotExpr, type NumberField, type ObjectField, PARAM_TYPES, type ParamDef, type ParamExpr, type ParamType, type Program, type RouteDefinition, type RouteExpr, STORAGE_OPERATIONS, STORAGE_TYPES, type SetStep, type SlotNode, type StateExpr, type StateField, type StaticPathsDefinition, type StorageOperation, type StorageStep, type StorageType, type StringField, type TextNode, UPDATE_OPERATIONS, type UpdateOperation, type UpdateStep, type ValidationFailure, type ValidationResult, type ValidationSuccess, type VarExpr, type ViewNode, astSchema, createClipboardWriteMissingValueError, createComponentCycleError, createComponentNotFoundError, createComponentPropMissingError, createComponentPropTypeError, createCondElseRequiredError, createDataNotDefinedError, createDuplicateActionError, createDuplicateDefaultSlotError, createDuplicateSlotNameError, createImportsNotDefinedError, createInvalidClipboardOperationError, createInvalidDataSourceError, createInvalidNavigateTargetError, createInvalidSlotNameError, createInvalidStorageOperationError, createInvalidStorageTypeError, createLayoutMissingSlotError, createLayoutNotFoundError, createOperationInvalidForTypeError, createOperationMissingFieldError, createOperationUnknownError, createRouteNotDefinedError, createSchemaError, createSlotInLoopError, createStorageSetMissingValueError, createUndefinedActionError, createUndefinedDataError, createUndefinedDataSourceError, createUndefinedImportError, createUndefinedParamError, createUndefinedRouteParamError, createUndefinedStateError, createUndefinedVarError, createUnsupportedVersionError, isActionStep, isBinExpr, isBooleanField, isClipboardStep, isCodeNode, isComponentNode, isCondExpr, isConstelaError, isDataExpr, isDataSource, isEachNode, isElementNode, isEventHandler, isExpression, isFetchStep, isGetExpr, isIfNode, isImportExpr, isLayoutProgram, isLifecycleHooks, isListField, isLitExpr, isMarkdownNode, isNamedSlotNode, isNavigateStep, isNotExpr, isNumberField, isObjectField, isParamExpr, isRouteDefinition, isRouteExpr, isSetStep, isSlotNode, isStateExpr, isStateField, isStaticPathsDefinition, isStorageStep, isStringField, isTextNode, isUpdateStep, isVarExpr, isViewNode, validateAst };

package/dist/index.js

@@ -26,7 +26,13 @@ var UPDATE_OPERATIONS = [
   "splice"
 ];
 var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE"];
+var STORAGE_OPERATIONS = ["get", "set", "remove"];
+var STORAGE_TYPES = ["local", "session"];
+var CLIPBOARD_OPERATIONS = ["write", "read"];
+var NAVIGATE_TARGETS = ["_self", "_blank"];
 var PARAM_TYPES = ["string", "number", "boolean", "json"];
+var DATA_TRANSFORMS = ["mdx", "yaml", "csv"];
+var DATA_SOURCE_TYPES = ["glob", "file", "api"];
 
 // src/types/guards.ts
 function isObject(value) {
@@ -84,8 +90,71 @@ function isGetExpr(value) {
   if (typeof value["path"] !== "string") return false;
   return true;
 }
+function isRouteExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "route") return false;
+  if (typeof value["name"] !== "string") return false;
+  if ("source" in value && value["source"] !== void 0) {
+    const validSources = ["param", "query", "path"];
+    if (!validSources.includes(value["source"])) return false;
+  }
+  return true;
+}
+function isImportExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "import") return false;
+  if (typeof value["name"] !== "string") return false;
+  if ("path" in value && value["path"] !== void 0) {
+    if (typeof value["path"] !== "string") return false;
+  }
+  return true;
+}
+function isDataExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "data") return false;
+  if (typeof value["name"] !== "string") return false;
+  if ("path" in value && value["path"] !== void 0) {
+    if (typeof value["path"] !== "string") return false;
+  }
+  return true;
+}
+function isDataSource(value) {
+  if (!isObject(value)) return false;
+  const type = value["type"];
+  if (!DATA_SOURCE_TYPES.includes(type)) {
+    return false;
+  }
+  if ("transform" in value && value["transform"] !== void 0) {
+    if (!DATA_TRANSFORMS.includes(value["transform"])) {
+      return false;
+    }
+  }
+  switch (type) {
+    case "glob":
+      if (typeof value["pattern"] !== "string") return false;
+      break;
+    case "file":
+      if (typeof value["path"] !== "string") return false;
+      break;
+    case "api":
+      if (typeof value["url"] !== "string") return false;
+      break;
+  }
+  return true;
+}
+function isStaticPathsDefinition(value) {
+  if (!isObject(value)) return false;
+  if (typeof value["source"] !== "string") return false;
+  if (!("params" in value) || !isObject(value["params"])) return false;
+  return true;
+}
+function isRouteDefinition(value) {
+  if (!isObject(value)) return false;
+  if (typeof value["path"] !== "string") return false;
+  return true;
+}
 function isExpression(value) {
-  return isLitExpr(value) || isStateExpr(value) || isVarExpr(value) || isBinExpr(value) || isNotExpr(value) || isParamExpr(value) || isCondExpr(value) || isGetExpr(value);
+  return isLitExpr(value) || isStateExpr(value) || isVarExpr(value) || isBinExpr(value) || isNotExpr(value) || isParamExpr(value) || isCondExpr(value) || isGetExpr(value) || isRouteExpr(value) || isImportExpr(value) || isDataExpr(value);
 }
 function isElementNode(value) {
   if (!isObject(value)) return false;
@@ -128,8 +197,20 @@ function isSlotNode(value) {
   if (!isObject(value)) return false;
   return value["kind"] === "slot";
 }
+function isMarkdownNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "markdown") return false;
+  return "content" in value && isObject(value["content"]);
+}
+function isCodeNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "code") return false;
+  if (!("language" in value) || !isObject(value["language"])) return false;
+  if (!("content" in value) || !isObject(value["content"])) return false;
+  return true;
+}
 function isViewNode(value) {
-  return isElementNode(value) || isTextNode(value) || isIfNode(value) || isEachNode(value) || isComponentNode(value) || isSlotNode(value);
+  return isElementNode(value) || isTextNode(value) || isIfNode(value) || isEachNode(value) || isComponentNode(value) || isSlotNode(value) || isMarkdownNode(value) || isCodeNode(value);
 }
 function isSetStep(value) {
   if (!isObject(value)) return false;
@@ -158,8 +239,39 @@ function isFetchStep(value) {
   }
   return true;
 }
+function isStorageStep(value) {
+  if (!isObject(value)) return false;
+  if (value["do"] !== "storage") return false;
+  if (!STORAGE_OPERATIONS.includes(value["operation"])) {
+    return false;
+  }
+  if (!STORAGE_TYPES.includes(value["storage"])) {
+    return false;
+  }
+  if (!("key" in value)) return false;
+  return true;
+}
+function isClipboardStep(value) {
+  if (!isObject(value)) return false;
+  if (value["do"] !== "clipboard") return false;
+  if (!CLIPBOARD_OPERATIONS.includes(value["operation"])) {
+    return false;
+  }
+  return true;
+}
+function isNavigateStep(value) {
+  if (!isObject(value)) return false;
+  if (value["do"] !== "navigate") return false;
+  if (!("url" in value)) return false;
+  if ("target" in value && value["target"] !== void 0) {
+    if (!NAVIGATE_TARGETS.includes(value["target"])) {
+      return false;
+    }
+  }
+  return true;
+}
 function isActionStep(value) {
-  return isSetStep(value) || isUpdateStep(value) || isFetchStep(value);
+  return isSetStep(value) || isUpdateStep(value) || isFetchStep(value) || isStorageStep(value) || isClipboardStep(value) || isNavigateStep(value);
 }
 function isNumberField(value) {
   if (!isObject(value)) return false;
@@ -195,6 +307,37 @@ function isEventHandler(value) {
   if (!("action" in value) || typeof value["action"] !== "string") return false;
   return true;
 }
+function isLayoutProgram(value) {
+  if (!isObject(value)) return false;
+  if (value["version"] !== "1.0") return false;
+  if (value["type"] !== "layout") return false;
+  if (!("view" in value)) return false;
+  return true;
+}
+function isNamedSlotNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "slot") return false;
+  if (typeof value["name"] !== "string") return false;
+  return true;
+}
+function isLifecycleHooks(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const obj = value;
+  const knownFields = ["onMount", "onUnmount", "onRouteEnter", "onRouteLeave"];
+  for (const key of knownFields) {
+    if (key in obj && obj[key] !== void 0) {
+      if (typeof obj[key] !== "string") return false;
+    }
+  }
+  for (const key of Object.keys(obj)) {
+    if (!knownFields.includes(key)) {
+      if (typeof obj[key] !== "string") return false;
+    }
+  }
+  return true;
+}
 
 // src/types/error.ts
 var ConstelaError = class _ConstelaError extends Error {
@@ -322,12 +465,152 @@ function createCondElseRequiredError(path) {
     path
   );
 }
+function createUndefinedRouteParamError(paramName, path) {
+  return new ConstelaError(
+    "UNDEFINED_ROUTE_PARAM",
+    `Undefined route param reference: '${paramName}' is not defined in route path`,
+    path
+  );
+}
+function createRouteNotDefinedError(path) {
+  return new ConstelaError(
+    "ROUTE_NOT_DEFINED",
+    `Route expression used but no route is defined in the program`,
+    path
+  );
+}
+function createUndefinedImportError(importName, path) {
+  return new ConstelaError(
+    "UNDEFINED_IMPORT",
+    `Undefined import reference: '${importName}' is not defined in imports`,
+    path
+  );
+}
+function createImportsNotDefinedError(path) {
+  return new ConstelaError(
+    "IMPORTS_NOT_DEFINED",
+    `Import expression used but no imports are defined in the program`,
+    path
+  );
+}
+function createLayoutMissingSlotError(path) {
+  return new ConstelaError(
+    "LAYOUT_MISSING_SLOT",
+    `Layout must contain at least one slot node for page content`,
+    path
+  );
+}
+function createLayoutNotFoundError(layoutName, path) {
+  return new ConstelaError(
+    "LAYOUT_NOT_FOUND",
+    `Layout '${layoutName}' is not found`,
+    path
+  );
+}
+function createInvalidSlotNameError(slotName, layoutName, path) {
+  return new ConstelaError(
+    "INVALID_SLOT_NAME",
+    `Named slot '${slotName}' does not exist in layout '${layoutName}'`,
+    path
+  );
+}
+function createDuplicateSlotNameError(slotName, path) {
+  return new ConstelaError(
+    "DUPLICATE_SLOT_NAME",
+    `Duplicate named slot '${slotName}' found in layout`,
+    path
+  );
+}
+function createDuplicateDefaultSlotError(path) {
+  return new ConstelaError(
+    "DUPLICATE_DEFAULT_SLOT",
+    `Layout contains multiple default (unnamed) slots`,
+    path
+  );
+}
+function createSlotInLoopError(path) {
+  return new ConstelaError(
+    "SLOT_IN_LOOP",
+    `Slot cannot be placed inside a loop (each node) as it would render multiple times`,
+    path
+  );
+}
+function createInvalidDataSourceError(dataName, reason, path) {
+  return new ConstelaError(
+    "INVALID_DATA_SOURCE",
+    `Invalid data source '${dataName}': ${reason}`,
+    path
+  );
+}
+function createUndefinedDataSourceError(sourceName, path) {
+  return new ConstelaError(
+    "UNDEFINED_DATA_SOURCE",
+    `Undefined data source reference: '${sourceName}' is not defined in data`,
+    path
+  );
+}
+function createDataNotDefinedError(path) {
+  return new ConstelaError(
+    "DATA_NOT_DEFINED",
+    `Data expression or getStaticPaths used but no data is defined in the program`,
+    path
+  );
+}
+function createUndefinedDataError(dataName, path) {
+  return new ConstelaError(
+    "UNDEFINED_DATA",
+    `Undefined data reference: '${dataName}' is not defined in data`,
+    path
+  );
+}
+function createInvalidStorageOperationError(operation, path) {
+  return new ConstelaError(
+    "INVALID_STORAGE_OPERATION",
+    `Invalid storage operation: '${operation}'. Valid operations are: get, set, remove`,
+    path
+  );
+}
+function createInvalidStorageTypeError(storageType, path) {
+  return new ConstelaError(
+    "INVALID_STORAGE_TYPE",
+    `Invalid storage type: '${storageType}'. Valid types are: local, session`,
+    path
+  );
+}
+function createStorageSetMissingValueError(path) {
+  return new ConstelaError(
+    "STORAGE_SET_MISSING_VALUE",
+    `Storage 'set' operation requires a 'value' field`,
+    path
+  );
+}
+function createInvalidClipboardOperationError(operation, path) {
+  return new ConstelaError(
+    "INVALID_CLIPBOARD_OPERATION",
+    `Invalid clipboard operation: '${operation}'. Valid operations are: write, read`,
+    path
+  );
+}
+function createClipboardWriteMissingValueError(path) {
+  return new ConstelaError(
+    "CLIPBOARD_WRITE_MISSING_VALUE",
+    `Clipboard 'write' operation requires a 'value' field`,
+    path
+  );
+}
+function createInvalidNavigateTargetError(target, path) {
+  return new ConstelaError(
+    "INVALID_NAVIGATE_TARGET",
+    `Invalid navigate target: '${target}'. Valid targets are: _self, _blank`,
+    path
+  );
+}
 
 // src/schema/validator.ts
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var VALID_VIEW_KINDS = ["element", "text", "if", "each", "component", "slot"];
+var VALID_VIEW_KINDS = ["element", "text", "if", "each", "component", "slot", "markdown", "code"];
 var VALID_EXPR_TYPES = ["lit", "state", "var", "bin", "not", "param", "cond", "get"];
 var VALID_PARAM_TYPES = ["string", "number", "boolean", "json"];
 var VALID_ACTION_TYPES = ["set", "update", "fetch"];
@@ -344,7 +627,7 @@ function validateViewNode(node, path) {
     return { path: path + "/kind", message: "kind is required" };
   }
   if (!VALID_VIEW_KINDS.includes(kind)) {
-    return { path: path + "/kind", message: "must be one of: element, text, if, each, component, slot" };
+    return { path: path + "/kind", message: "must be one of: element, text, if, each, component, slot, markdown, code" };
   }
   switch (kind) {
     case "element":
@@ -426,6 +709,23 @@ function validateViewNode(node, path) {
       break;
     case "slot":
       break;
+    case "markdown":
+      if (!("content" in node)) {
+        return { path: path + "/content", message: "content is required" };
+      }
+      return validateExpression(node["content"], path + "/content");
+    case "code":
+      if (!("language" in node)) {
+        return { path: path + "/language", message: "language is required" };
+      }
+      if (!("content" in node)) {
+        return { path: path + "/content", message: "content is required" };
+      }
+      {
+        const langError = validateExpression(node["language"], path + "/language");
+        if (langError) return langError;
+        return validateExpression(node["content"], path + "/content");
+      }
   }
   return null;
 }
@@ -1137,7 +1437,9 @@ var astSchema = {
         { $ref: "#/$defs/IfNode" },
         { $ref: "#/$defs/EachNode" },
         { $ref: "#/$defs/ComponentNode" },
-        { $ref: "#/$defs/SlotNode" }
+        { $ref: "#/$defs/SlotNode" },
+        { $ref: "#/$defs/MarkdownNode" },
+        { $ref: "#/$defs/CodeNode" }
       ]
     },
     ElementNode: {
@@ -1220,6 +1522,25 @@ var astSchema = {
         kind: { type: "string", const: "slot" }
       }
     },
+    MarkdownNode: {
+      type: "object",
+      required: ["kind", "content"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "markdown" },
+        content: { $ref: "#/$defs/Expression" }
+      }
+    },
+    CodeNode: {
+      type: "object",
+      required: ["kind", "language", "content"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "code" },
+        language: { $ref: "#/$defs/Expression" },
+        content: { $ref: "#/$defs/Expression" }
+      }
+    },
     // ==================== Component Definition ====================
     ParamDef: {
       type: "object",
@@ -1249,32 +1570,62 @@ var astSchema = {
 };
 export {
   BINARY_OPERATORS,
+  CLIPBOARD_OPERATIONS,
   ConstelaError,
+  DATA_SOURCE_TYPES,
+  DATA_TRANSFORMS,
   HTTP_METHODS,
+  NAVIGATE_TARGETS,
   PARAM_TYPES,
+  STORAGE_OPERATIONS,
+  STORAGE_TYPES,
   UPDATE_OPERATIONS,
   astSchema,
+  createClipboardWriteMissingValueError,
   createComponentCycleError,
   createComponentNotFoundError,
   createComponentPropMissingError,
   createComponentPropTypeError,
   createCondElseRequiredError,
+  createDataNotDefinedError,
   createDuplicateActionError,
+  createDuplicateDefaultSlotError,
+  createDuplicateSlotNameError,
+  createImportsNotDefinedError,
+  createInvalidClipboardOperationError,
+  createInvalidDataSourceError,
+  createInvalidNavigateTargetError,
+  createInvalidSlotNameError,
+  createInvalidStorageOperationError,
+  createInvalidStorageTypeError,
+  createLayoutMissingSlotError,
+  createLayoutNotFoundError,
   createOperationInvalidForTypeError,
   createOperationMissingFieldError,
   createOperationUnknownError,
+  createRouteNotDefinedError,
   createSchemaError,
+  createSlotInLoopError,
+  createStorageSetMissingValueError,
   createUndefinedActionError,
+  createUndefinedDataError,
+  createUndefinedDataSourceError,
+  createUndefinedImportError,
   createUndefinedParamError,
+  createUndefinedRouteParamError,
   createUndefinedStateError,
   createUndefinedVarError,
   createUnsupportedVersionError,
   isActionStep,
   isBinExpr,
   isBooleanField,
+  isClipboardStep,
+  isCodeNode,
   isComponentNode,
   isCondExpr,
   isConstelaError,
+  isDataExpr,
+  isDataSource,
   isEachNode,
   isElementNode,
   isEventHandler,
@@ -1282,16 +1633,26 @@ export {
   isFetchStep,
   isGetExpr,
   isIfNode,
+  isImportExpr,
+  isLayoutProgram,
+  isLifecycleHooks,
   isListField,
   isLitExpr,
+  isMarkdownNode,
+  isNamedSlotNode,
+  isNavigateStep,
   isNotExpr,
   isNumberField,
   isObjectField,
   isParamExpr,
+  isRouteDefinition,
+  isRouteExpr,
   isSetStep,
   isSlotNode,
   isStateExpr,
   isStateField,
+  isStaticPathsDefinition,
+  isStorageStep,
   isStringField,
   isTextNode,
   isUpdateStep,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/core",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "description": "Core types, schema, and validator for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",