@objectstack/spec 2.0.5 → 2.0.7

package/dist/ui/index.js

@@ -24,10 +24,15 @@ __export(ui_exports, {
   ActionParamSchema: () => ActionParamSchema,
   ActionSchema: () => ActionSchema,
   AnimationSchema: () => AnimationSchema,
+  AnimationTriggerSchema: () => AnimationTriggerSchema,
   App: () => App,
   AppBrandingSchema: () => AppBrandingSchema,
   AppSchema: () => AppSchema,
+  AriaPropsSchema: () => AriaPropsSchema,
   BorderRadiusSchema: () => BorderRadiusSchema,
+  BreakpointColumnMapSchema: () => BreakpointColumnMapSchema,
+  BreakpointName: () => BreakpointName,
+  BreakpointOrderMapSchema: () => BreakpointOrderMapSchema,
   BreakpointsSchema: () => BreakpointsSchema,
   CalendarConfigSchema: () => CalendarConfigSchema,
   ChartAnnotationSchema: () => ChartAnnotationSchema,
@@ -37,26 +42,63 @@ __export(ui_exports, {
   ChartSeriesSchema: () => ChartSeriesSchema,
   ChartTypeSchema: () => ChartTypeSchema,
   ColorPaletteSchema: () => ColorPaletteSchema,
+  ColumnSummarySchema: () => ColumnSummarySchema,
+  ComponentAnimationSchema: () => ComponentAnimationSchema,
   ComponentPropsMap: () => ComponentPropsMap,
+  ConflictResolutionSchema: () => ConflictResolutionSchema,
   Dashboard: () => Dashboard,
   DashboardNavItemSchema: () => DashboardNavItemSchema,
   DashboardSchema: () => DashboardSchema,
   DashboardWidgetSchema: () => DashboardWidgetSchema,
+  DateFormatSchema: () => DateFormatSchema,
+  DensityMode: () => DensityMode,
+  DndConfigSchema: () => DndConfigSchema,
+  DragConstraintSchema: () => DragConstraintSchema,
+  DragHandleSchema: () => DragHandleSchema,
+  DragItemSchema: () => DragItemSchema,
+  DropEffectSchema: () => DropEffectSchema,
+  DropZoneSchema: () => DropZoneSchema,
+  EasingFunctionSchema: () => EasingFunctionSchema,
+  EvictionPolicySchema: () => EvictionPolicySchema,
   FieldWidgetPropsSchema: () => FieldWidgetPropsSchema,
+  FocusManagementSchema: () => FocusManagementSchema,
+  FocusTrapConfigSchema: () => FocusTrapConfigSchema,
   FormFieldSchema: () => FormFieldSchema,
   FormSectionSchema: () => FormSectionSchema,
   FormViewSchema: () => FormViewSchema,
+  GalleryConfigSchema: () => GalleryConfigSchema,
   GanttConfigSchema: () => GanttConfigSchema,
+  GestureConfigSchema: () => GestureConfigSchema,
+  GestureTypeSchema: () => GestureTypeSchema,
   GroupNavItemSchema: () => GroupNavItemSchema,
+  GroupingConfigSchema: () => GroupingConfigSchema,
+  GroupingFieldSchema: () => GroupingFieldSchema,
   HttpMethodSchema: () => HttpMethodSchema,
   HttpRequestSchema: () => HttpRequestSchema,
+  I18nLabelSchema: () => I18nLabelSchema,
+  I18nObjectSchema: () => I18nObjectSchema,
   KanbanConfigSchema: () => KanbanConfigSchema,
+  KeyboardNavigationConfigSchema: () => KeyboardNavigationConfigSchema,
+  KeyboardShortcutSchema: () => KeyboardShortcutSchema,
   ListColumnSchema: () => ListColumnSchema,
   ListViewSchema: () => ListViewSchema,
+  LocaleConfigSchema: () => LocaleConfigSchema,
+  LongPressGestureConfigSchema: () => LongPressGestureConfigSchema,
+  MotionConfigSchema: () => MotionConfigSchema,
   NavigationConfigSchema: () => NavigationConfigSchema,
   NavigationItemSchema: () => NavigationItemSchema,
   NavigationModeSchema: () => NavigationModeSchema,
+  NotificationActionSchema: () => NotificationActionSchema,
+  NotificationConfigSchema: () => NotificationConfigSchema,
+  NotificationPositionSchema: () => NotificationPositionSchema,
+  NotificationSchema: () => NotificationSchema,
+  NotificationSeveritySchema: () => NotificationSeveritySchema,
+  NotificationTypeSchema: () => NotificationTypeSchema,
+  NumberFormatSchema: () => NumberFormatSchema,
   ObjectNavItemSchema: () => ObjectNavItemSchema,
+  OfflineCacheConfigSchema: () => OfflineCacheConfigSchema,
+  OfflineConfigSchema: () => OfflineConfigSchema,
+  OfflineStrategySchema: () => OfflineStrategySchema,
   PageCardProps: () => PageCardProps,
   PageComponentSchema: () => PageComponentSchema,
   PageComponentType: () => PageComponentType,
@@ -65,8 +107,13 @@ __export(ui_exports, {
   PageRegionSchema: () => PageRegionSchema,
   PageSchema: () => PageSchema,
   PageTabsProps: () => PageTabsProps,
+  PageTransitionSchema: () => PageTransitionSchema,
   PageVariableSchema: () => PageVariableSchema,
   PaginationConfigSchema: () => PaginationConfigSchema,
+  PerformanceConfigSchema: () => PerformanceConfigSchema,
+  PersistStorageSchema: () => PersistStorageSchema,
+  PinchGestureConfigSchema: () => PinchGestureConfigSchema,
+  PluralRuleSchema: () => PluralRuleSchema,
   RecordDetailsProps: () => RecordDetailsProps,
   RecordHighlightsProps: () => RecordHighlightsProps,
   RecordRelatedListProps: () => RecordRelatedListProps,
@@ -76,15 +123,28 @@ __export(ui_exports, {
   ReportGroupingSchema: () => ReportGroupingSchema,
   ReportSchema: () => ReportSchema,
   ReportType: () => ReportType,
+  ResponsiveConfigSchema: () => ResponsiveConfigSchema,
+  RowColorConfigSchema: () => RowColorConfigSchema,
+  RowHeightSchema: () => RowHeightSchema,
   SelectionConfigSchema: () => SelectionConfigSchema,
   ShadowSchema: () => ShadowSchema,
   SpacingSchema: () => SpacingSchema,
+  SwipeDirectionSchema: () => SwipeDirectionSchema,
+  SwipeGestureConfigSchema: () => SwipeGestureConfigSchema,
+  SyncConfigSchema: () => SyncConfigSchema,
   ThemeMode: () => ThemeMode,
   ThemeSchema: () => ThemeSchema,
+  TimelineConfigSchema: () => TimelineConfigSchema,
+  TouchInteractionSchema: () => TouchInteractionSchema,
+  TouchTargetConfigSchema: () => TouchTargetConfigSchema,
+  TransitionConfigSchema: () => TransitionConfigSchema,
+  TransitionPresetSchema: () => TransitionPresetSchema,
   TypographySchema: () => TypographySchema,
   UrlNavItemSchema: () => UrlNavItemSchema,
   ViewDataSchema: () => ViewDataSchema,
   ViewSchema: () => ViewSchema,
+  ViewSharingSchema: () => ViewSharingSchema,
+  WcagContrastLevel: () => WcagContrastLevel,
   WidgetEventSchema: () => WidgetEventSchema,
   WidgetLifecycleSchema: () => WidgetLifecycleSchema,
   WidgetManifestSchema: () => WidgetManifestSchema,
@@ -95,8 +155,75 @@ __export(ui_exports, {
 module.exports = __toCommonJS(ui_exports);
 
 // src/ui/chart.zod.ts
+var import_zod2 = require("zod");
+
+// src/ui/i18n.zod.ts
 var import_zod = require("zod");
-var ChartTypeSchema = import_zod.z.enum([
+var I18nObjectSchema = import_zod.z.object({
+  /** Translation key (e.g., "views.task_list.label", "apps.crm.description") */
+  key: import_zod.z.string().describe('Translation key (e.g., "views.task_list.label")'),
+  /** Default value when translation is not available */
+  defaultValue: import_zod.z.string().optional().describe("Fallback value when translation key is not found"),
+  /** Interpolation parameters for dynamic translations */
+  params: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional().describe("Interpolation parameters (e.g., { count: 5 })")
+});
+var I18nLabelSchema = import_zod.z.union([
+  import_zod.z.string(),
+  I18nObjectSchema
+]).describe("Display label: plain string or i18n translation object");
+var AriaPropsSchema = import_zod.z.object({
+  /** Accessible label for screen readers */
+  ariaLabel: I18nLabelSchema.optional().describe("Accessible label for screen readers (WAI-ARIA aria-label)"),
+  /** ID of element that describes this component */
+  ariaDescribedBy: import_zod.z.string().optional().describe("ID of element providing additional description (WAI-ARIA aria-describedby)"),
+  /** WAI-ARIA role override */
+  role: import_zod.z.string().optional().describe('WAI-ARIA role attribute (e.g., "dialog", "navigation", "alert")')
+}).describe("ARIA accessibility attributes");
+var PluralRuleSchema = import_zod.z.object({
+  /** Translation key for the plural form */
+  key: import_zod.z.string().describe("Translation key"),
+  /** Form for zero quantity */
+  zero: import_zod.z.string().optional().describe('Zero form (e.g., "No items")'),
+  /** Form for singular (1) */
+  one: import_zod.z.string().optional().describe('Singular form (e.g., "{count} item")'),
+  /** Form for dual (2) — used in Arabic, Welsh, etc. */
+  two: import_zod.z.string().optional().describe('Dual form (e.g., "{count} items" for exactly 2)'),
+  /** Form for few (2-4 in Slavic languages) */
+  few: import_zod.z.string().optional().describe("Few form (e.g., for 2-4 in some languages)"),
+  /** Form for many (5+ in Slavic languages) */
+  many: import_zod.z.string().optional().describe("Many form (e.g., for 5+ in some languages)"),
+  /** Default/fallback form */
+  other: import_zod.z.string().describe('Default plural form (e.g., "{count} items")')
+}).describe("ICU plural rules for a translation key");
+var NumberFormatSchema = import_zod.z.object({
+  style: import_zod.z.enum(["decimal", "currency", "percent", "unit"]).default("decimal").describe("Number formatting style"),
+  currency: import_zod.z.string().optional().describe('ISO 4217 currency code (e.g., "USD", "EUR")'),
+  unit: import_zod.z.string().optional().describe('Unit for unit formatting (e.g., "kilometer", "liter")'),
+  minimumFractionDigits: import_zod.z.number().optional().describe("Minimum number of fraction digits"),
+  maximumFractionDigits: import_zod.z.number().optional().describe("Maximum number of fraction digits"),
+  useGrouping: import_zod.z.boolean().optional().describe("Whether to use grouping separators (e.g., 1,000)")
+}).describe("Number formatting rules");
+var DateFormatSchema = import_zod.z.object({
+  dateStyle: import_zod.z.enum(["full", "long", "medium", "short"]).optional().describe("Date display style"),
+  timeStyle: import_zod.z.enum(["full", "long", "medium", "short"]).optional().describe("Time display style"),
+  timeZone: import_zod.z.string().optional().describe('IANA time zone (e.g., "America/New_York")'),
+  hour12: import_zod.z.boolean().optional().describe("Use 12-hour format")
+}).describe("Date/time formatting rules");
+var LocaleConfigSchema = import_zod.z.object({
+  /** BCP 47 language code (e.g., "en-US", "zh-CN", "ar-SA") */
+  code: import_zod.z.string().describe('BCP 47 language code (e.g., "en-US", "zh-CN")'),
+  /** Ordered fallback chain for missing translations */
+  fallbackChain: import_zod.z.array(import_zod.z.string()).optional().describe('Fallback language codes in priority order (e.g., ["zh-TW", "en"])'),
+  /** Text direction */
+  direction: import_zod.z.enum(["ltr", "rtl"]).default("ltr").describe("Text direction: left-to-right or right-to-left"),
+  /** Default number formatting */
+  numberFormat: NumberFormatSchema.optional().describe("Default number formatting rules"),
+  /** Default date formatting */
+  dateFormat: DateFormatSchema.optional().describe("Default date/time formatting rules")
+}).describe("Locale configuration");
+
+// src/ui/chart.zod.ts
+var ChartTypeSchema = import_zod2.z.enum([
   // Comparison
   "bar",
   "horizontal-bar",
@@ -145,260 +272,382 @@ var ChartTypeSchema = import_zod.z.enum([
   "table",
   "pivot"
 ]);
-var ChartAxisSchema = import_zod.z.object({
+var ChartAxisSchema = import_zod2.z.object({
   /** Data field to map to this axis */
-  field: import_zod.z.string().describe("Data field key"),
+  field: import_zod2.z.string().describe("Data field key"),
   /** Axis title */
-  title: import_zod.z.string().optional().describe("Axis display title"),
+  title: I18nLabelSchema.optional().describe("Axis display title"),
   /** Value formatting (d3-format or similar) */
-  format: import_zod.z.string().optional().describe('Value format string (e.g., "$0,0.00")'),
+  format: import_zod2.z.string().optional().describe('Value format string (e.g., "$0,0.00")'),
   /** Axis scale settings */
-  min: import_zod.z.number().optional().describe("Minimum value"),
-  max: import_zod.z.number().optional().describe("Maximum value"),
-  stepSize: import_zod.z.number().optional().describe("Step size for ticks"),
+  min: import_zod2.z.number().optional().describe("Minimum value"),
+  max: import_zod2.z.number().optional().describe("Maximum value"),
+  stepSize: import_zod2.z.number().optional().describe("Step size for ticks"),
   /** Appearance */
-  showGridLines: import_zod.z.boolean().default(true),
-  position: import_zod.z.enum(["left", "right", "top", "bottom"]).optional().describe("Axis position"),
+  showGridLines: import_zod2.z.boolean().default(true),
+  position: import_zod2.z.enum(["left", "right", "top", "bottom"]).optional().describe("Axis position"),
   /** Logarithmic scale */
-  logarithmic: import_zod.z.boolean().default(false)
+  logarithmic: import_zod2.z.boolean().default(false)
 });
-var ChartSeriesSchema = import_zod.z.object({
+var ChartSeriesSchema = import_zod2.z.object({
   /** Field name for values */
-  name: import_zod.z.string().describe("Field name or series identifier"),
+  name: import_zod2.z.string().describe("Field name or series identifier"),
   /** Display label */
-  label: import_zod.z.string().optional().describe("Series display label"),
+  label: I18nLabelSchema.optional().describe("Series display label"),
   /** Series type override (combo charts) */
   type: ChartTypeSchema.optional().describe("Override chart type for this series"),
   /** Specific color */
-  color: import_zod.z.string().optional().describe("Series color (hex/rgb/token)"),
+  color: import_zod2.z.string().optional().describe("Series color (hex/rgb/token)"),
   /** Stacking group */
-  stack: import_zod.z.string().optional().describe("Stack identifier to group series"),
+  stack: import_zod2.z.string().optional().describe("Stack identifier to group series"),
   /** Axis binding */
-  yAxis: import_zod.z.enum(["left", "right"]).default("left").describe("Bind to specific Y-Axis")
-});
-var ChartAnnotationSchema = import_zod.z.object({
-  type: import_zod.z.enum(["line", "region"]).default("line"),
-  axis: import_zod.z.enum(["x", "y"]).default("y"),
-  value: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).describe("Start value"),
-  endValue: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]).optional().describe("End value for regions"),
-  color: import_zod.z.string().optional(),
-  label: import_zod.z.string().optional(),
-  style: import_zod.z.enum(["solid", "dashed", "dotted"]).default("dashed")
-});
-var ChartInteractionSchema = import_zod.z.object({
-  tooltips: import_zod.z.boolean().default(true),
-  zoom: import_zod.z.boolean().default(false),
-  brush: import_zod.z.boolean().default(false),
-  clickAction: import_zod.z.string().optional().describe("Action ID to trigger on click")
-});
-var ChartConfigSchema = import_zod.z.object({
+  yAxis: import_zod2.z.enum(["left", "right"]).default("left").describe("Bind to specific Y-Axis")
+});
+var ChartAnnotationSchema = import_zod2.z.object({
+  type: import_zod2.z.enum(["line", "region"]).default("line"),
+  axis: import_zod2.z.enum(["x", "y"]).default("y"),
+  value: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.string()]).describe("Start value"),
+  endValue: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.string()]).optional().describe("End value for regions"),
+  color: import_zod2.z.string().optional(),
+  label: I18nLabelSchema.optional(),
+  style: import_zod2.z.enum(["solid", "dashed", "dotted"]).default("dashed")
+});
+var ChartInteractionSchema = import_zod2.z.object({
+  tooltips: import_zod2.z.boolean().default(true),
+  zoom: import_zod2.z.boolean().default(false),
+  brush: import_zod2.z.boolean().default(false),
+  clickAction: import_zod2.z.string().optional().describe("Action ID to trigger on click")
+});
+var ChartConfigSchema = import_zod2.z.object({
   /** Chart Type */
   type: ChartTypeSchema,
   /** Titles */
-  title: import_zod.z.string().optional().describe("Chart title"),
-  subtitle: import_zod.z.string().optional().describe("Chart subtitle"),
-  description: import_zod.z.string().optional().describe("Accessibility description"),
+  title: I18nLabelSchema.optional().describe("Chart title"),
+  subtitle: I18nLabelSchema.optional().describe("Chart subtitle"),
+  description: I18nLabelSchema.optional().describe("Accessibility description"),
   /** Axes Mapping */
   xAxis: ChartAxisSchema.optional().describe("X-Axis configuration"),
-  yAxis: import_zod.z.array(ChartAxisSchema).optional().describe("Y-Axis configuration (support dual axis)"),
+  yAxis: import_zod2.z.array(ChartAxisSchema).optional().describe("Y-Axis configuration (support dual axis)"),
   /** Series Configuration */
-  series: import_zod.z.array(ChartSeriesSchema).optional().describe("Defined series configuration"),
+  series: import_zod2.z.array(ChartSeriesSchema).optional().describe("Defined series configuration"),
   /** Appearance */
-  colors: import_zod.z.array(import_zod.z.string()).optional().describe("Color palette"),
-  height: import_zod.z.number().optional().describe("Fixed height in pixels"),
+  colors: import_zod2.z.array(import_zod2.z.string()).optional().describe("Color palette"),
+  height: import_zod2.z.number().optional().describe("Fixed height in pixels"),
   /** Components */
-  showLegend: import_zod.z.boolean().default(true).describe("Display legend"),
-  showDataLabels: import_zod.z.boolean().default(false).describe("Display data labels"),
+  showLegend: import_zod2.z.boolean().default(true).describe("Display legend"),
+  showDataLabels: import_zod2.z.boolean().default(false).describe("Display data labels"),
   /** Annotations & Reference Lines */
-  annotations: import_zod.z.array(ChartAnnotationSchema).optional(),
+  annotations: import_zod2.z.array(ChartAnnotationSchema).optional(),
   /** Interactions */
-  interaction: ChartInteractionSchema.optional()
+  interaction: ChartInteractionSchema.optional(),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
 });
 
-// src/ui/app.zod.ts
+// src/ui/responsive.zod.ts
 var import_zod3 = require("zod");
+var BreakpointName = import_zod3.z.enum(["xs", "sm", "md", "lg", "xl", "2xl"]);
+var BreakpointColumnMapSchema = import_zod3.z.object({
+  xs: import_zod3.z.number().min(1).max(12).optional(),
+  sm: import_zod3.z.number().min(1).max(12).optional(),
+  md: import_zod3.z.number().min(1).max(12).optional(),
+  lg: import_zod3.z.number().min(1).max(12).optional(),
+  xl: import_zod3.z.number().min(1).max(12).optional(),
+  "2xl": import_zod3.z.number().min(1).max(12).optional()
+}).describe("Grid columns per breakpoint (1-12)");
+var BreakpointOrderMapSchema = import_zod3.z.object({
+  xs: import_zod3.z.number().optional(),
+  sm: import_zod3.z.number().optional(),
+  md: import_zod3.z.number().optional(),
+  lg: import_zod3.z.number().optional(),
+  xl: import_zod3.z.number().optional(),
+  "2xl": import_zod3.z.number().optional()
+}).describe("Display order per breakpoint");
+var ResponsiveConfigSchema = import_zod3.z.object({
+  /** Minimum breakpoint for visibility */
+  breakpoint: BreakpointName.optional().describe("Minimum breakpoint for visibility"),
+  /** Hide on specific breakpoints */
+  hiddenOn: import_zod3.z.array(BreakpointName).optional().describe("Hide on these breakpoints"),
+  /** Grid columns per breakpoint (1-12 column grid) */
+  columns: BreakpointColumnMapSchema.optional().describe("Grid columns per breakpoint"),
+  /** Display order per breakpoint */
+  order: BreakpointOrderMapSchema.optional().describe("Display order per breakpoint")
+}).describe("Responsive layout configuration");
+var PerformanceConfigSchema = import_zod3.z.object({
+  /** Enable lazy loading for this component */
+  lazyLoad: import_zod3.z.boolean().optional().describe("Enable lazy loading (defer rendering until visible)"),
+  /** Virtual scrolling configuration for large datasets */
+  virtualScroll: import_zod3.z.object({
+    enabled: import_zod3.z.boolean().default(false).describe("Enable virtual scrolling"),
+    itemHeight: import_zod3.z.number().optional().describe("Fixed item height in pixels (for estimation)"),
+    overscan: import_zod3.z.number().optional().describe("Number of extra items to render outside viewport")
+  }).optional().describe("Virtual scrolling configuration"),
+  /** Client-side caching strategy */
+  cacheStrategy: import_zod3.z.enum([
+    "none",
+    "cache-first",
+    "network-first",
+    "stale-while-revalidate"
+  ]).optional().describe("Client-side data caching strategy"),
+  /** Enable data prefetching */
+  prefetch: import_zod3.z.boolean().optional().describe("Prefetch data before component is visible"),
+  /** Maximum number of items to render before pagination */
+  pageSize: import_zod3.z.number().optional().describe("Number of items per page for pagination"),
+  /** Debounce interval for user interactions (ms) */
+  debounceMs: import_zod3.z.number().optional().describe("Debounce interval for user interactions in milliseconds")
+}).describe("Performance optimization configuration");
+
+// src/ui/app.zod.ts
+var import_zod5 = require("zod");
 
 // src/shared/identifiers.zod.ts
-var import_zod2 = require("zod");
-var SystemIdentifierSchema = import_zod2.z.string().min(2, { message: "System identifier must be at least 2 characters" }).regex(/^[a-z][a-z0-9_.]*$/, {
+var import_zod4 = require("zod");
+var SystemIdentifierSchema = import_zod4.z.string().min(2, { message: "System identifier must be at least 2 characters" }).regex(/^[a-z][a-z0-9_.]*$/, {
   message: 'System identifier must be lowercase, starting with a letter, and may contain letters, numbers, underscores, or dots (e.g., "user_profile" or "order.created")'
 }).describe("System identifier (lowercase with underscores or dots)");
-var SnakeCaseIdentifierSchema = import_zod2.z.string().min(2, { message: "Identifier must be at least 2 characters" }).regex(/^[a-z][a-z0-9_]*$/, {
+var SnakeCaseIdentifierSchema = import_zod4.z.string().min(2, { message: "Identifier must be at least 2 characters" }).regex(/^[a-z][a-z0-9_]*$/, {
   message: 'Identifier must be lowercase snake_case, starting with a letter, and may contain only letters, numbers, and underscores (e.g., "user_profile")'
 }).describe("Snake case identifier (lowercase with underscores only)");
-var EventNameSchema = import_zod2.z.string().min(3, { message: "Event name must be at least 3 characters" }).regex(/^[a-z][a-z0-9_.]*$/, {
+var EventNameSchema = import_zod4.z.string().min(3, { message: "Event name must be at least 3 characters" }).regex(/^[a-z][a-z0-9_.]*$/, {
   message: 'Event name must be lowercase with dots for namespacing (e.g., "user.created", "order.paid")'
 }).describe("Event name (lowercase with dot notation for namespacing)");
 
 // src/ui/app.zod.ts
-var BaseNavItemSchema = import_zod3.z.object({
+var BaseNavItemSchema = import_zod5.z.object({
   /** Unique identifier for the item */
   id: SnakeCaseIdentifierSchema.describe("Unique identifier for this navigation item (lowercase snake_case)"),
   /** Display label */
-  label: import_zod3.z.string().describe("Display proper label"),
+  label: I18nLabelSchema.describe("Display proper label"),
   /** Icon name (Lucide) */
-  icon: import_zod3.z.string().optional().describe("Icon name"),
+  icon: import_zod5.z.string().optional().describe("Icon name"),
   /** 
    * Visibility condition. 
    * Formula expression returning boolean. 
    * e.g. "user.is_admin || user.department == 'sales'"
    */
-  visible: import_zod3.z.string().optional().describe("Visibility formula condition")
+  visible: import_zod5.z.string().optional().describe("Visibility formula condition")
 });
 var ObjectNavItemSchema = BaseNavItemSchema.extend({
-  type: import_zod3.z.literal("object"),
-  objectName: import_zod3.z.string().describe("Target object name"),
-  viewName: import_zod3.z.string().optional().describe('Default list view to open. Defaults to "all"')
+  type: import_zod5.z.literal("object"),
+  objectName: import_zod5.z.string().describe("Target object name"),
+  viewName: import_zod5.z.string().optional().describe('Default list view to open. Defaults to "all"')
 });
 var DashboardNavItemSchema = BaseNavItemSchema.extend({
-  type: import_zod3.z.literal("dashboard"),
-  dashboardName: import_zod3.z.string().describe("Target dashboard name")
+  type: import_zod5.z.literal("dashboard"),
+  dashboardName: import_zod5.z.string().describe("Target dashboard name")
 });
 var PageNavItemSchema = BaseNavItemSchema.extend({
-  type: import_zod3.z.literal("page"),
-  pageName: import_zod3.z.string().describe("Target custom page component name"),
-  params: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional().describe("Parameters passed to the page context")
+  type: import_zod5.z.literal("page"),
+  pageName: import_zod5.z.string().describe("Target custom page component name"),
+  params: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional().describe("Parameters passed to the page context")
 });
 var UrlNavItemSchema = BaseNavItemSchema.extend({
-  type: import_zod3.z.literal("url"),
-  url: import_zod3.z.string().describe("Target external URL"),
-  target: import_zod3.z.enum(["_self", "_blank"]).default("_self").describe("Link target window")
+  type: import_zod5.z.literal("url"),
+  url: import_zod5.z.string().describe("Target external URL"),
+  target: import_zod5.z.enum(["_self", "_blank"]).default("_self").describe("Link target window")
 });
 var GroupNavItemSchema = BaseNavItemSchema.extend({
-  type: import_zod3.z.literal("group"),
-  expanded: import_zod3.z.boolean().default(false).describe("Default expansion state in sidebar")
+  type: import_zod5.z.literal("group"),
+  expanded: import_zod5.z.boolean().default(false).describe("Default expansion state in sidebar")
   // children property is added in the recursive definition below
 });
-var NavigationItemSchema = import_zod3.z.lazy(
-  () => import_zod3.z.union([
+var NavigationItemSchema = import_zod5.z.lazy(
+  () => import_zod5.z.union([
     // Object Item can now have children (Airtable style: Object -> Views)
     ObjectNavItemSchema.extend({
-      children: import_zod3.z.array(NavigationItemSchema).optional().describe("Child navigation items (e.g. specific views)")
+      children: import_zod5.z.array(NavigationItemSchema).optional().describe("Child navigation items (e.g. specific views)")
     }),
     DashboardNavItemSchema,
     PageNavItemSchema,
     UrlNavItemSchema,
     GroupNavItemSchema.extend({
-      children: import_zod3.z.array(NavigationItemSchema).describe("Child navigation items")
+      children: import_zod5.z.array(NavigationItemSchema).describe("Child navigation items")
     })
   ])
 );
-var AppBrandingSchema = import_zod3.z.object({
-  primaryColor: import_zod3.z.string().optional().describe("Primary theme color hex code"),
-  logo: import_zod3.z.string().optional().describe("Custom logo URL for this app"),
-  favicon: import_zod3.z.string().optional().describe("Custom favicon URL for this app")
+var AppBrandingSchema = import_zod5.z.object({
+  primaryColor: import_zod5.z.string().optional().describe("Primary theme color hex code"),
+  logo: import_zod5.z.string().optional().describe("Custom logo URL for this app"),
+  favicon: import_zod5.z.string().optional().describe("Custom favicon URL for this app")
 });
-var AppSchema = import_zod3.z.object({
+var AppSchema = import_zod5.z.object({
   /** Machine name (id) */
   name: SnakeCaseIdentifierSchema.describe("App unique machine name (lowercase snake_case)"),
   /** Display label */
-  label: import_zod3.z.string().describe("App display label"),
+  label: I18nLabelSchema.describe("App display label"),
   /** App version */
-  version: import_zod3.z.string().optional().describe("App version"),
+  version: import_zod5.z.string().optional().describe("App version"),
   /** Description */
-  description: import_zod3.z.string().optional().describe("App description"),
+  description: I18nLabelSchema.optional().describe("App description"),
   /** Icon name (Lucide) */
-  icon: import_zod3.z.string().optional().describe("App icon used in the App Launcher"),
+  icon: import_zod5.z.string().optional().describe("App icon used in the App Launcher"),
   /** Branding/Theming Configuration */
   branding: AppBrandingSchema.optional().describe("App-specific branding"),
   /** Application status */
-  active: import_zod3.z.boolean().optional().default(true).describe("Whether the app is enabled"),
+  active: import_zod5.z.boolean().optional().default(true).describe("Whether the app is enabled"),
   /** Is this the default app for new users? */
-  isDefault: import_zod3.z.boolean().optional().default(false).describe("Is default app"),
+  isDefault: import_zod5.z.boolean().optional().default(false).describe("Is default app"),
   /** 
    * Navigation Tree Structure.
    * Replaces the old flat 'tabs' list with a structured menu.
    */
-  navigation: import_zod3.z.array(NavigationItemSchema).optional().describe("Structured navigation menu tree"),
+  navigation: import_zod5.z.array(NavigationItemSchema).optional().describe("Structured navigation menu tree"),
   /** 
    * App-level Home Page Override
    * ID of the navigation item to act as the landing page.
    * If not set, usually defaults to the first navigation item.
    */
-  homePageId: import_zod3.z.string().optional().describe("ID of the navigation item to serve as landing page"),
+  homePageId: import_zod5.z.string().optional().describe("ID of the navigation item to serve as landing page"),
   /** 
    * Access Control
    * List of permissions required to access this app.
    * Modern replacement for role/profile based assignment.
    * Example: ["app.access.crm"]
    */
-  requiredPermissions: import_zod3.z.array(import_zod3.z.string()).optional().describe("Permissions required to access this app"),
+  requiredPermissions: import_zod5.z.array(import_zod5.z.string()).optional().describe("Permissions required to access this app"),
   /** 
    * Package Components (For config file convenience)
    * In a real monorepo these might be auto-discovered, but here we allow explicit registration.
    */
-  objects: import_zod3.z.array(import_zod3.z.unknown()).optional().describe("Objects belonging to this app"),
-  apis: import_zod3.z.array(import_zod3.z.unknown()).optional().describe("Custom APIs belonging to this app")
+  objects: import_zod5.z.array(import_zod5.z.unknown()).optional().describe("Objects belonging to this app"),
+  apis: import_zod5.z.array(import_zod5.z.unknown()).optional().describe("Custom APIs belonging to this app"),
+  /** Mobile navigation mode */
+  mobileNavigation: import_zod5.z.object({
+    mode: import_zod5.z.enum(["drawer", "bottom_nav", "hamburger"]).default("drawer").describe("Mobile navigation mode: drawer sidebar, bottom navigation bar, or hamburger menu"),
+    bottomNavItems: import_zod5.z.array(import_zod5.z.string()).optional().describe("Navigation item IDs to show in bottom nav (max 5)")
+  }).optional().describe("Mobile-specific navigation configuration"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes for the application")
 });
 var App = {
   create: (config) => AppSchema.parse(config)
 };
 
 // src/ui/view.zod.ts
-var import_zod4 = require("zod");
-var HttpMethodSchema = import_zod4.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-var HttpRequestSchema = import_zod4.z.object({
-  url: import_zod4.z.string().describe("API endpoint URL"),
+var import_zod6 = require("zod");
+var HttpMethodSchema = import_zod6.z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+var HttpRequestSchema = import_zod6.z.object({
+  url: import_zod6.z.string().describe("API endpoint URL"),
   method: HttpMethodSchema.optional().default("GET").describe("HTTP method"),
-  headers: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional().describe("Custom HTTP headers"),
-  params: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional().describe("Query parameters"),
-  body: import_zod4.z.unknown().optional().describe("Request body for POST/PUT/PATCH")
-});
-var ViewDataSchema = import_zod4.z.discriminatedUnion("provider", [
-  import_zod4.z.object({
-    provider: import_zod4.z.literal("object"),
-    object: import_zod4.z.string().describe("Target object name")
+  headers: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe("Custom HTTP headers"),
+  params: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional().describe("Query parameters"),
+  body: import_zod6.z.unknown().optional().describe("Request body for POST/PUT/PATCH")
+});
+var ViewDataSchema = import_zod6.z.discriminatedUnion("provider", [
+  import_zod6.z.object({
+    provider: import_zod6.z.literal("object"),
+    object: import_zod6.z.string().describe("Target object name")
   }),
-  import_zod4.z.object({
-    provider: import_zod4.z.literal("api"),
+  import_zod6.z.object({
+    provider: import_zod6.z.literal("api"),
     read: HttpRequestSchema.optional().describe("Configuration for fetching data"),
     write: HttpRequestSchema.optional().describe("Configuration for submitting data (for forms/editable tables)")
   }),
-  import_zod4.z.object({
-    provider: import_zod4.z.literal("value"),
-    items: import_zod4.z.array(import_zod4.z.unknown()).describe("Static data array")
+  import_zod6.z.object({
+    provider: import_zod6.z.literal("value"),
+    items: import_zod6.z.array(import_zod6.z.unknown()).describe("Static data array")
   })
 ]);
-var ListColumnSchema = import_zod4.z.object({
-  field: import_zod4.z.string().describe("Field name (snake_case)"),
-  label: import_zod4.z.string().optional().describe("Display label override"),
-  width: import_zod4.z.number().positive().optional().describe("Column width in pixels"),
-  align: import_zod4.z.enum(["left", "center", "right"]).optional().describe("Text alignment"),
-  hidden: import_zod4.z.boolean().optional().describe("Hide column by default"),
-  sortable: import_zod4.z.boolean().optional().describe("Allow sorting by this column"),
-  resizable: import_zod4.z.boolean().optional().describe("Allow resizing this column"),
-  wrap: import_zod4.z.boolean().optional().describe("Allow text wrapping"),
-  type: import_zod4.z.string().optional().describe('Renderer type override (e.g., "currency", "date")'),
+var ColumnSummarySchema = import_zod6.z.enum([
+  "none",
+  "count",
+  "count_empty",
+  "count_filled",
+  "count_unique",
+  "percent_empty",
+  "percent_filled",
+  "sum",
+  "avg",
+  "min",
+  "max"
+]).describe("Aggregation function for column footer summary");
+var ListColumnSchema = import_zod6.z.object({
+  field: import_zod6.z.string().describe("Field name (snake_case)"),
+  label: I18nLabelSchema.optional().describe("Display label override"),
+  width: import_zod6.z.number().positive().optional().describe("Column width in pixels"),
+  align: import_zod6.z.enum(["left", "center", "right"]).optional().describe("Text alignment"),
+  hidden: import_zod6.z.boolean().optional().describe("Hide column by default"),
+  sortable: import_zod6.z.boolean().optional().describe("Allow sorting by this column"),
+  resizable: import_zod6.z.boolean().optional().describe("Allow resizing this column"),
+  wrap: import_zod6.z.boolean().optional().describe("Allow text wrapping"),
+  type: import_zod6.z.string().optional().describe('Renderer type override (e.g., "currency", "date")'),
+  /** Pinning (Airtable-style frozen columns) */
+  pinned: import_zod6.z.enum(["left", "right"]).optional().describe("Pin/freeze column to left or right side"),
+  /** Column Footer Summary (Airtable-style aggregation) */
+  summary: ColumnSummarySchema.optional().describe("Footer aggregation function for this column"),
   /** Interaction */
-  link: import_zod4.z.boolean().optional().describe("Functions as the primary navigation link (triggers View navigation)"),
-  action: import_zod4.z.string().optional().describe("Registered Action ID to execute when clicked")
-});
-var SelectionConfigSchema = import_zod4.z.object({
-  type: import_zod4.z.enum(["none", "single", "multiple"]).default("none").describe("Selection mode")
-});
-var PaginationConfigSchema = import_zod4.z.object({
-  pageSize: import_zod4.z.number().int().positive().default(25).describe("Number of records per page"),
-  pageSizeOptions: import_zod4.z.array(import_zod4.z.number().int().positive()).optional().describe("Available page size options")
-});
-var KanbanConfigSchema = import_zod4.z.object({
-  groupByField: import_zod4.z.string().describe("Field to group columns by (usually status/select)"),
-  summarizeField: import_zod4.z.string().optional().describe("Field to sum at top of column (e.g. amount)"),
-  columns: import_zod4.z.array(import_zod4.z.string()).describe("Fields to show on cards")
-});
-var CalendarConfigSchema = import_zod4.z.object({
-  startDateField: import_zod4.z.string(),
-  endDateField: import_zod4.z.string().optional(),
-  titleField: import_zod4.z.string(),
-  colorField: import_zod4.z.string().optional()
-});
-var GanttConfigSchema = import_zod4.z.object({
-  startDateField: import_zod4.z.string(),
-  endDateField: import_zod4.z.string(),
-  titleField: import_zod4.z.string(),
-  progressField: import_zod4.z.string().optional(),
-  dependenciesField: import_zod4.z.string().optional()
-});
-var NavigationModeSchema = import_zod4.z.enum([
+  link: import_zod6.z.boolean().optional().describe("Functions as the primary navigation link (triggers View navigation)"),
+  action: import_zod6.z.string().optional().describe("Registered Action ID to execute when clicked")
+});
+var SelectionConfigSchema = import_zod6.z.object({
+  type: import_zod6.z.enum(["none", "single", "multiple"]).default("none").describe("Selection mode")
+});
+var PaginationConfigSchema = import_zod6.z.object({
+  pageSize: import_zod6.z.number().int().positive().default(25).describe("Number of records per page"),
+  pageSizeOptions: import_zod6.z.array(import_zod6.z.number().int().positive()).optional().describe("Available page size options")
+});
+var RowHeightSchema = import_zod6.z.enum([
+  "compact",
+  // Minimal padding, single line
+  "short",
+  // Reduced padding
+  "medium",
+  // Default padding
+  "tall",
+  // Extra padding, multi-line preview
+  "extra_tall"
+  // Maximum padding, rich content preview
+]).describe("Row height / density setting for list view");
+var GroupingFieldSchema = import_zod6.z.object({
+  field: import_zod6.z.string().describe("Field name to group by"),
+  order: import_zod6.z.enum(["asc", "desc"]).default("asc").describe("Group sort order"),
+  collapsed: import_zod6.z.boolean().default(false).describe("Collapse groups by default")
+});
+var GroupingConfigSchema = import_zod6.z.object({
+  fields: import_zod6.z.array(GroupingFieldSchema).min(1).describe("Fields to group by (supports up to 3 levels)")
+}).describe("Record grouping configuration");
+var GalleryConfigSchema = import_zod6.z.object({
+  coverField: import_zod6.z.string().optional().describe("Attachment/image field to display as card cover"),
+  coverFit: import_zod6.z.enum(["cover", "contain"]).default("cover").describe("Image fit mode for card cover"),
+  cardSize: import_zod6.z.enum(["small", "medium", "large"]).default("medium").describe("Card size in gallery view"),
+  titleField: import_zod6.z.string().optional().describe("Field to display as card title"),
+  visibleFields: import_zod6.z.array(import_zod6.z.string()).optional().describe("Fields to display on card body")
+}).describe("Gallery/card view configuration");
+var TimelineConfigSchema = import_zod6.z.object({
+  startDateField: import_zod6.z.string().describe("Field for timeline item start date"),
+  endDateField: import_zod6.z.string().optional().describe("Field for timeline item end date"),
+  titleField: import_zod6.z.string().describe("Field to display as timeline item title"),
+  groupByField: import_zod6.z.string().optional().describe("Field to group timeline rows"),
+  colorField: import_zod6.z.string().optional().describe("Field to determine item color"),
+  scale: import_zod6.z.enum(["hour", "day", "week", "month", "quarter", "year"]).default("week").describe("Default timeline scale")
+}).describe("Timeline view configuration");
+var ViewSharingSchema = import_zod6.z.object({
+  type: import_zod6.z.enum(["personal", "collaborative"]).default("collaborative").describe("View ownership type"),
+  lockedBy: import_zod6.z.string().optional().describe("User who locked the view configuration")
+}).describe("View sharing and access configuration");
+var RowColorConfigSchema = import_zod6.z.object({
+  field: import_zod6.z.string().describe("Field to derive color from (typically a select/status field)"),
+  colors: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional().describe("Map of field value to color (hex/token)")
+}).describe("Row color configuration based on field values");
+var KanbanConfigSchema = import_zod6.z.object({
+  groupByField: import_zod6.z.string().describe("Field to group columns by (usually status/select)"),
+  summarizeField: import_zod6.z.string().optional().describe("Field to sum at top of column (e.g. amount)"),
+  columns: import_zod6.z.array(import_zod6.z.string()).describe("Fields to show on cards")
+});
+var CalendarConfigSchema = import_zod6.z.object({
+  startDateField: import_zod6.z.string(),
+  endDateField: import_zod6.z.string().optional(),
+  titleField: import_zod6.z.string(),
+  colorField: import_zod6.z.string().optional()
+});
+var GanttConfigSchema = import_zod6.z.object({
+  startDateField: import_zod6.z.string(),
+  endDateField: import_zod6.z.string(),
+  titleField: import_zod6.z.string(),
+  progressField: import_zod6.z.string().optional(),
+  dependenciesField: import_zod6.z.string().optional()
+});
+var NavigationModeSchema = import_zod6.z.enum([
   "page",
   // Navigate to a new route (default)
   "drawer",
@@ -414,21 +663,21 @@ var NavigationModeSchema = import_zod4.z.enum([
   "none"
   // No navigation (read-only list)
 ]);
-var NavigationConfigSchema = import_zod4.z.object({
+var NavigationConfigSchema = import_zod6.z.object({
   mode: NavigationModeSchema.default("page"),
   /** Target View Config */
-  view: import_zod4.z.string().optional().describe('Name of the form view to use for details (e.g. "summary_view", "edit_form")'),
+  view: import_zod6.z.string().optional().describe('Name of the form view to use for details (e.g. "summary_view", "edit_form")'),
   /** Interaction Triggers */
-  preventNavigation: import_zod4.z.boolean().default(false).describe("Disable standard navigation entirely"),
-  openNewTab: import_zod4.z.boolean().default(false).describe("Force open in new tab (applies to page mode)"),
+  preventNavigation: import_zod6.z.boolean().default(false).describe("Disable standard navigation entirely"),
+  openNewTab: import_zod6.z.boolean().default(false).describe("Force open in new tab (applies to page mode)"),
   /** Dimensions (for modal/drawer) */
-  width: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional().describe('Width of the drawer/modal (e.g. "600px", "50%")')
+  width: import_zod6.z.union([import_zod6.z.string(), import_zod6.z.number()]).optional().describe('Width of the drawer/modal (e.g. "600px", "50%")')
 });
-var ListViewSchema = import_zod4.z.object({
+var ListViewSchema = import_zod6.z.object({
   name: SnakeCaseIdentifierSchema.optional().describe("Internal view name (lowercase snake_case)"),
-  label: import_zod4.z.string().optional(),
-  // Display label override
-  type: import_zod4.z.enum([
+  label: I18nLabelSchema.optional(),
+  // Display label override (supports i18n)
+  type: import_zod6.z.enum([
     "grid",
     // Standard Data Table
     "kanban",
@@ -447,28 +696,28 @@ var ListViewSchema = import_zod4.z.object({
   /** Data Source Configuration */
   data: ViewDataSchema.optional().describe('Data source configuration (defaults to "object" provider)'),
   /** Shared Query Config */
-  columns: import_zod4.z.union([
-    import_zod4.z.array(import_zod4.z.string()),
+  columns: import_zod6.z.union([
+    import_zod6.z.array(import_zod6.z.string()),
     // Legacy: simple field names
-    import_zod4.z.array(ListColumnSchema)
+    import_zod6.z.array(ListColumnSchema)
     // Enhanced: detailed column config
   ]).describe("Fields to display as columns"),
-  filter: import_zod4.z.array(import_zod4.z.unknown()).optional().describe("Filter criteria (JSON Rules)"),
-  sort: import_zod4.z.union([
-    import_zod4.z.string(),
+  filter: import_zod6.z.array(import_zod6.z.unknown()).optional().describe("Filter criteria (JSON Rules)"),
+  sort: import_zod6.z.union([
+    import_zod6.z.string(),
     //Legacy "field desc"
-    import_zod4.z.array(import_zod4.z.object({
-      field: import_zod4.z.string(),
-      order: import_zod4.z.enum(["asc", "desc"])
+    import_zod6.z.array(import_zod6.z.object({
+      field: import_zod6.z.string(),
+      order: import_zod6.z.enum(["asc", "desc"])
     }))
   ]).optional(),
   /** Search & Filter */
-  searchableFields: import_zod4.z.array(import_zod4.z.string()).optional().describe("Fields enabled for search"),
-  filterableFields: import_zod4.z.array(import_zod4.z.string()).optional().describe("Fields enabled for end-user filtering in the top bar"),
+  searchableFields: import_zod6.z.array(import_zod6.z.string()).optional().describe("Fields enabled for search"),
+  filterableFields: import_zod6.z.array(import_zod6.z.string()).optional().describe("Fields enabled for end-user filtering in the top bar"),
   /** Grid Features */
-  resizable: import_zod4.z.boolean().optional().describe("Enable column resizing"),
-  striped: import_zod4.z.boolean().optional().describe("Striped row styling"),
-  bordered: import_zod4.z.boolean().optional().describe("Show borders"),
+  resizable: import_zod6.z.boolean().optional().describe("Enable column resizing"),
+  striped: import_zod6.z.boolean().optional().describe("Striped row styling"),
+  bordered: import_zod6.z.boolean().optional().describe("Show borders"),
   /** Selection */
   selection: SelectionConfigSchema.optional().describe("Row selection configuration"),
   /** Navigation / Interaction */
@@ -479,54 +728,70 @@ var ListViewSchema = import_zod4.z.object({
   kanban: KanbanConfigSchema.optional(),
   calendar: CalendarConfigSchema.optional(),
   gantt: GanttConfigSchema.optional(),
+  gallery: GalleryConfigSchema.optional(),
+  timeline: TimelineConfigSchema.optional(),
+  /** View Metadata (Airtable-style view management) */
+  description: I18nLabelSchema.optional().describe("View description for documentation/tooltips"),
+  sharing: ViewSharingSchema.optional().describe("View sharing and access configuration"),
+  /** Row Height / Density (Airtable-style) */
+  rowHeight: RowHeightSchema.optional().describe("Row height / density setting"),
+  /** Record Grouping (Airtable-style) */
+  grouping: GroupingConfigSchema.optional().describe("Group records by one or more fields"),
+  /** Row Color (Airtable-style) */
+  rowColor: RowColorConfigSchema.optional().describe("Color rows based on field value"),
+  /** Field Visibility & Ordering per View (Airtable-style) */
+  hiddenFields: import_zod6.z.array(import_zod6.z.string()).optional().describe("Fields to hide in this specific view"),
+  fieldOrder: import_zod6.z.array(import_zod6.z.string()).optional().describe("Explicit field display order for this view"),
   /** Row & Bulk Actions */
-  rowActions: import_zod4.z.array(import_zod4.z.string()).optional().describe("Actions available for individual row items"),
-  bulkActions: import_zod4.z.array(import_zod4.z.string()).optional().describe("Actions available when multiple rows are selected"),
+  rowActions: import_zod6.z.array(import_zod6.z.string()).optional().describe("Actions available for individual row items"),
+  bulkActions: import_zod6.z.array(import_zod6.z.string()).optional().describe("Actions available when multiple rows are selected"),
   /** Performance */
-  virtualScroll: import_zod4.z.boolean().optional().describe("Enable virtual scrolling for large datasets"),
+  virtualScroll: import_zod6.z.boolean().optional().describe("Enable virtual scrolling for large datasets"),
   /** Conditional Formatting */
-  conditionalFormatting: import_zod4.z.array(import_zod4.z.object({
-    condition: import_zod4.z.string().describe("Condition expression to evaluate"),
-    style: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).describe("CSS styles to apply when condition is true")
+  conditionalFormatting: import_zod6.z.array(import_zod6.z.object({
+    condition: import_zod6.z.string().describe("Condition expression to evaluate"),
+    style: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).describe("CSS styles to apply when condition is true")
   })).optional().describe("Conditional formatting rules for list rows"),
   /** Inline Edit */
-  inlineEdit: import_zod4.z.boolean().optional().describe("Allow inline editing of records directly in the list view"),
+  inlineEdit: import_zod6.z.boolean().optional().describe("Allow inline editing of records directly in the list view"),
   /** Export */
-  exportOptions: import_zod4.z.array(import_zod4.z.enum(["csv", "xlsx", "pdf", "json"])).optional().describe("Available export format options"),
+  exportOptions: import_zod6.z.array(import_zod6.z.enum(["csv", "xlsx", "pdf", "json"])).optional().describe("Available export format options"),
   /** Empty State */
-  emptyState: import_zod4.z.object({
-    title: import_zod4.z.string().optional(),
-    message: import_zod4.z.string().optional(),
-    icon: import_zod4.z.string().optional()
-  }).optional().describe("Empty state configuration when no records found")
-});
-var FormFieldSchema = import_zod4.z.object({
-  field: import_zod4.z.string().describe("Field name (snake_case)"),
-  label: import_zod4.z.string().optional().describe("Display label override"),
-  placeholder: import_zod4.z.string().optional().describe("Placeholder text"),
-  helpText: import_zod4.z.string().optional().describe("Help/hint text"),
-  readonly: import_zod4.z.boolean().optional().describe("Read-only override"),
-  required: import_zod4.z.boolean().optional().describe("Required override"),
-  hidden: import_zod4.z.boolean().optional().describe("Hidden override"),
-  colSpan: import_zod4.z.number().int().min(1).max(4).optional().describe("Column span in grid layout (1-4)"),
-  widget: import_zod4.z.string().optional().describe("Custom widget/component name"),
-  dependsOn: import_zod4.z.string().optional().describe("Parent field name for cascading"),
-  visibleOn: import_zod4.z.string().optional().describe("Visibility condition expression")
-});
-var FormSectionSchema = import_zod4.z.object({
-  label: import_zod4.z.string().optional(),
-  collapsible: import_zod4.z.boolean().default(false),
-  collapsed: import_zod4.z.boolean().default(false),
-  columns: import_zod4.z.enum(["1", "2", "3", "4"]).default("2").transform((val) => parseInt(val)),
-  fields: import_zod4.z.array(import_zod4.z.union([
-    import_zod4.z.string(),
+  emptyState: import_zod6.z.object({
+    title: I18nLabelSchema.optional(),
+    message: I18nLabelSchema.optional(),
+    icon: import_zod6.z.string().optional()
+  }).optional().describe("Empty state configuration when no records found"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes for the list view")
+});
+var FormFieldSchema = import_zod6.z.object({
+  field: import_zod6.z.string().describe("Field name (snake_case)"),
+  label: I18nLabelSchema.optional().describe("Display label override"),
+  placeholder: I18nLabelSchema.optional().describe("Placeholder text"),
+  helpText: I18nLabelSchema.optional().describe("Help/hint text"),
+  readonly: import_zod6.z.boolean().optional().describe("Read-only override"),
+  required: import_zod6.z.boolean().optional().describe("Required override"),
+  hidden: import_zod6.z.boolean().optional().describe("Hidden override"),
+  colSpan: import_zod6.z.number().int().min(1).max(4).optional().describe("Column span in grid layout (1-4)"),
+  widget: import_zod6.z.string().optional().describe("Custom widget/component name"),
+  dependsOn: import_zod6.z.string().optional().describe("Parent field name for cascading"),
+  visibleOn: import_zod6.z.string().optional().describe("Visibility condition expression")
+});
+var FormSectionSchema = import_zod6.z.object({
+  label: I18nLabelSchema.optional(),
+  collapsible: import_zod6.z.boolean().default(false),
+  collapsed: import_zod6.z.boolean().default(false),
+  columns: import_zod6.z.enum(["1", "2", "3", "4"]).default("2").transform((val) => parseInt(val)),
+  fields: import_zod6.z.array(import_zod6.z.union([
+    import_zod6.z.string(),
     // Legacy: simple field name
     FormFieldSchema
     // Enhanced: detailed field config
   ]))
 });
-var FormViewSchema = import_zod4.z.object({
-  type: import_zod4.z.enum([
+var FormViewSchema = import_zod6.z.object({
+  type: import_zod6.z.enum([
     "simple",
     // Single column or sections
     "tabbed",
@@ -542,125 +807,127 @@ var FormViewSchema = import_zod4.z.object({
   ]).default("simple"),
   /** Data Source Configuration */
   data: ViewDataSchema.optional().describe('Data source configuration (defaults to "object" provider)'),
-  sections: import_zod4.z.array(FormSectionSchema).optional(),
+  sections: import_zod6.z.array(FormSectionSchema).optional(),
   // For simple layout
-  groups: import_zod4.z.array(FormSectionSchema).optional()
+  groups: import_zod6.z.array(FormSectionSchema).optional(),
   // Legacy support -> alias to sections
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes for the form view")
 });
-var ViewSchema = import_zod4.z.object({
+var ViewSchema = import_zod6.z.object({
   list: ListViewSchema.optional(),
   // Default list view
   form: FormViewSchema.optional(),
   // Default form view
-  listViews: import_zod4.z.record(import_zod4.z.string(), ListViewSchema).optional().describe("Additional named list views"),
-  formViews: import_zod4.z.record(import_zod4.z.string(), FormViewSchema).optional().describe("Additional named form views")
+  listViews: import_zod6.z.record(import_zod6.z.string(), ListViewSchema).optional().describe("Additional named list views"),
+  formViews: import_zod6.z.record(import_zod6.z.string(), FormViewSchema).optional().describe("Additional named form views")
 });
 
 // src/ui/dashboard.zod.ts
-var import_zod6 = require("zod");
+var import_zod8 = require("zod");
 
 // src/data/filter.zod.ts
-var import_zod5 = require("zod");
-var FieldReferenceSchema = import_zod5.z.object({
-  $field: import_zod5.z.string().describe("Field Reference/Column Name")
+var import_zod7 = require("zod");
+var FieldReferenceSchema = import_zod7.z.object({
+  $field: import_zod7.z.string().describe("Field Reference/Column Name")
 });
-var EqualityOperatorSchema = import_zod5.z.object({
+var EqualityOperatorSchema = import_zod7.z.object({
   /** Equal to (default) - SQL: = | MongoDB: $eq */
-  $eq: import_zod5.z.any().optional(),
+  $eq: import_zod7.z.any().optional(),
   /** Not equal to - SQL: <> or != | MongoDB: $ne */
-  $ne: import_zod5.z.any().optional()
+  $ne: import_zod7.z.any().optional()
 });
-var ComparisonOperatorSchema = import_zod5.z.object({
+var ComparisonOperatorSchema = import_zod7.z.object({
   /** Greater than - SQL: > | MongoDB: $gt */
-  $gt: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
+  $gt: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
   /** Greater than or equal to - SQL: >= | MongoDB: $gte */
-  $gte: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
+  $gte: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
   /** Less than - SQL: < | MongoDB: $lt */
-  $lt: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
+  $lt: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
   /** Less than or equal to - SQL: <= | MongoDB: $lte */
-  $lte: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional()
+  $lte: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional()
 });
-var SetOperatorSchema = import_zod5.z.object({
+var SetOperatorSchema = import_zod7.z.object({
   /** In list - SQL: IN (?, ?, ?) | MongoDB: $in */
-  $in: import_zod5.z.array(import_zod5.z.any()).optional(),
+  $in: import_zod7.z.array(import_zod7.z.any()).optional(),
   /** Not in list - SQL: NOT IN (...) | MongoDB: $nin */
-  $nin: import_zod5.z.array(import_zod5.z.any()).optional()
+  $nin: import_zod7.z.array(import_zod7.z.any()).optional()
 });
-var RangeOperatorSchema = import_zod5.z.object({
+var RangeOperatorSchema = import_zod7.z.object({
   /** Between (inclusive) - takes [min, max] array */
-  $between: import_zod5.z.tuple([
-    import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]),
-    import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema])
+  $between: import_zod7.z.tuple([
+    import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]),
+    import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema])
   ]).optional()
 });
-var StringOperatorSchema = import_zod5.z.object({
+var StringOperatorSchema = import_zod7.z.object({
   /** Contains substring - SQL: LIKE %?% | MongoDB: $regex */
-  $contains: import_zod5.z.string().optional(),
+  $contains: import_zod7.z.string().optional(),
   /** Starts with prefix - SQL: LIKE ?% | MongoDB: $regex */
-  $startsWith: import_zod5.z.string().optional(),
+  $startsWith: import_zod7.z.string().optional(),
   /** Ends with suffix - SQL: LIKE %? | MongoDB: $regex */
-  $endsWith: import_zod5.z.string().optional()
+  $endsWith: import_zod7.z.string().optional()
 });
-var SpecialOperatorSchema = import_zod5.z.object({
+var SpecialOperatorSchema = import_zod7.z.object({
   /** Is null check - SQL: IS NULL (true) / IS NOT NULL (false) | MongoDB: field: null */
-  $null: import_zod5.z.boolean().optional(),
+  $null: import_zod7.z.boolean().optional(),
   /** Field exists check (primarily for NoSQL) - MongoDB: $exists */
-  $exists: import_zod5.z.boolean().optional()
+  $exists: import_zod7.z.boolean().optional()
 });
-var FieldOperatorsSchema = import_zod5.z.object({
+var FieldOperatorsSchema = import_zod7.z.object({
   // Equality
-  $eq: import_zod5.z.any().optional(),
-  $ne: import_zod5.z.any().optional(),
+  $eq: import_zod7.z.any().optional(),
+  $ne: import_zod7.z.any().optional(),
   // Comparison (numeric/date)
-  $gt: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
-  $gte: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
-  $lt: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
-  $lte: import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]).optional(),
+  $gt: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
+  $gte: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
+  $lt: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
+  $lte: import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]).optional(),
   // Set & Range
-  $in: import_zod5.z.array(import_zod5.z.any()).optional(),
-  $nin: import_zod5.z.array(import_zod5.z.any()).optional(),
-  $between: import_zod5.z.tuple([
-    import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema]),
-    import_zod5.z.union([import_zod5.z.number(), import_zod5.z.date(), FieldReferenceSchema])
+  $in: import_zod7.z.array(import_zod7.z.any()).optional(),
+  $nin: import_zod7.z.array(import_zod7.z.any()).optional(),
+  $between: import_zod7.z.tuple([
+    import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema]),
+    import_zod7.z.union([import_zod7.z.number(), import_zod7.z.date(), FieldReferenceSchema])
   ]).optional(),
   // String-specific
-  $contains: import_zod5.z.string().optional(),
-  $startsWith: import_zod5.z.string().optional(),
-  $endsWith: import_zod5.z.string().optional(),
+  $contains: import_zod7.z.string().optional(),
+  $startsWith: import_zod7.z.string().optional(),
+  $endsWith: import_zod7.z.string().optional(),
   // Special
-  $null: import_zod5.z.boolean().optional(),
-  $exists: import_zod5.z.boolean().optional()
-});
-var FilterConditionSchema = import_zod5.z.lazy(
-  () => import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).and(
-    import_zod5.z.object({
-      $and: import_zod5.z.array(FilterConditionSchema).optional(),
-      $or: import_zod5.z.array(FilterConditionSchema).optional(),
+  $null: import_zod7.z.boolean().optional(),
+  $exists: import_zod7.z.boolean().optional()
+});
+var FilterConditionSchema = import_zod7.z.lazy(
+  () => import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).and(
+    import_zod7.z.object({
+      $and: import_zod7.z.array(FilterConditionSchema).optional(),
+      $or: import_zod7.z.array(FilterConditionSchema).optional(),
       $not: FilterConditionSchema.optional()
     })
   )
 );
-var QueryFilterSchema = import_zod5.z.object({
+var QueryFilterSchema = import_zod7.z.object({
   where: FilterConditionSchema.optional()
 });
-var NormalizedFilterSchema = import_zod5.z.lazy(
-  () => import_zod5.z.object({
-    $and: import_zod5.z.array(
-      import_zod5.z.union([
+var NormalizedFilterSchema = import_zod7.z.lazy(
+  () => import_zod7.z.object({
+    $and: import_zod7.z.array(
+      import_zod7.z.union([
         // Field condition: { field: { $op: value } }
-        import_zod5.z.record(import_zod5.z.string(), FieldOperatorsSchema),
+        import_zod7.z.record(import_zod7.z.string(), FieldOperatorsSchema),
         // Nested logical group
         NormalizedFilterSchema
       ])
     ).optional(),
-    $or: import_zod5.z.array(
-      import_zod5.z.union([
-        import_zod5.z.record(import_zod5.z.string(), FieldOperatorsSchema),
+    $or: import_zod7.z.array(
+      import_zod7.z.union([
+        import_zod7.z.record(import_zod7.z.string(), FieldOperatorsSchema),
         NormalizedFilterSchema
       ])
     ).optional(),
-    $not: import_zod5.z.union([
-      import_zod5.z.record(import_zod5.z.string(), FieldOperatorsSchema),
+    $not: import_zod7.z.union([
+      import_zod7.z.record(import_zod7.z.string(), FieldOperatorsSchema),
       NormalizedFilterSchema
     ]).optional()
   })
@@ -690,23 +957,23 @@ var LOGICAL_OPERATORS = ["$and", "$or", "$not"];
 var ALL_OPERATORS = [...FILTER_OPERATORS, ...LOGICAL_OPERATORS];
 
 // src/ui/dashboard.zod.ts
-var DashboardWidgetSchema = import_zod6.z.object({
+var DashboardWidgetSchema = import_zod8.z.object({
   /** Widget Title */
-  title: import_zod6.z.string().optional().describe("Widget title"),
+  title: I18nLabelSchema.optional().describe("Widget title"),
   /** Visualization Type */
   type: ChartTypeSchema.default("metric").describe("Visualization type"),
   /** Chart Configuration */
   chartConfig: ChartConfigSchema.optional().describe("Chart visualization configuration"),
   /** Data Source Object */
-  object: import_zod6.z.string().optional().describe("Data source object name"),
+  object: import_zod8.z.string().optional().describe("Data source object name"),
   /** Data Filter (MongoDB-style FilterCondition) */
   filter: FilterConditionSchema.optional().describe("Data filter criteria"),
   /** Category Field (X-Axis / Group By) */
-  categoryField: import_zod6.z.string().optional().describe("Field for grouping (X-Axis)"),
+  categoryField: import_zod8.z.string().optional().describe("Field for grouping (X-Axis)"),
   /** Value Field (Y-Axis) */
-  valueField: import_zod6.z.string().optional().describe("Field for values (Y-Axis)"),
+  valueField: import_zod8.z.string().optional().describe("Field for values (Y-Axis)"),
   /** Aggregate operation */
-  aggregate: import_zod6.z.enum(["count", "sum", "avg", "min", "max"]).optional().default("count").describe("Aggregate function"),
+  aggregate: import_zod8.z.enum(["count", "sum", "avg", "min", "max"]).optional().default("count").describe("Aggregate function"),
   /** 
    * Layout Position (React-Grid-Layout style)
    * x: column (0-11)
@@ -714,40 +981,48 @@ var DashboardWidgetSchema = import_zod6.z.object({
    * w: width (1-12)
    * h: height
    */
-  layout: import_zod6.z.object({
-    x: import_zod6.z.number(),
-    y: import_zod6.z.number(),
-    w: import_zod6.z.number(),
-    h: import_zod6.z.number()
+  layout: import_zod8.z.object({
+    x: import_zod8.z.number(),
+    y: import_zod8.z.number(),
+    w: import_zod8.z.number(),
+    h: import_zod8.z.number()
   }).describe("Grid layout position"),
   /** Widget specific options (colors, legend, etc.) */
-  options: import_zod6.z.unknown().optional().describe("Widget specific configuration")
+  options: import_zod8.z.unknown().optional().describe("Widget specific configuration"),
+  /** Responsive layout overrides per breakpoint */
+  responsive: ResponsiveConfigSchema.optional().describe("Responsive layout configuration"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
 });
-var DashboardSchema = import_zod6.z.object({
+var DashboardSchema = import_zod8.z.object({
   /** Machine name */
   name: SnakeCaseIdentifierSchema.describe("Dashboard unique name"),
   /** Display label */
-  label: import_zod6.z.string().describe("Dashboard label"),
+  label: I18nLabelSchema.describe("Dashboard label"),
   /** Description */
-  description: import_zod6.z.string().optional().describe("Dashboard description"),
+  description: I18nLabelSchema.optional().describe("Dashboard description"),
   /** Collection of widgets */
-  widgets: import_zod6.z.array(DashboardWidgetSchema).describe("Widgets to display"),
+  widgets: import_zod8.z.array(DashboardWidgetSchema).describe("Widgets to display"),
   /** Auto-refresh */
-  refreshInterval: import_zod6.z.number().optional().describe("Auto-refresh interval in seconds"),
+  refreshInterval: import_zod8.z.number().optional().describe("Auto-refresh interval in seconds"),
   /** Global Filters */
-  globalFilters: import_zod6.z.array(import_zod6.z.object({
-    field: import_zod6.z.string().describe("Field name to filter on"),
-    label: import_zod6.z.string().optional().describe("Display label for the filter"),
-    type: import_zod6.z.enum(["text", "select", "date", "number"]).optional().describe("Filter input type")
-  })).optional().describe("Global filters that apply to all widgets in the dashboard")
+  globalFilters: import_zod8.z.array(import_zod8.z.object({
+    field: import_zod8.z.string().describe("Field name to filter on"),
+    label: I18nLabelSchema.optional().describe("Display label for the filter"),
+    type: import_zod8.z.enum(["text", "select", "date", "number"]).optional().describe("Filter input type")
+  })).optional().describe("Global filters that apply to all widgets in the dashboard"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes"),
+  /** Performance optimization settings */
+  performance: PerformanceConfigSchema.optional().describe("Performance optimization settings")
 });
 var Dashboard = {
   create: (config) => DashboardSchema.parse(config)
 };
 
 // src/ui/report.zod.ts
-var import_zod7 = require("zod");
-var ReportType = import_zod7.z.enum([
+var import_zod9 = require("zod");
+var ReportType = import_zod9.z.enum([
   "tabular",
   // Simple list
   "summary",
@@ -757,91 +1032,97 @@ var ReportType = import_zod7.z.enum([
   "joined"
   // Joined multiple blocks
 ]);
-var ReportColumnSchema = import_zod7.z.object({
-  field: import_zod7.z.string().describe("Field name"),
-  label: import_zod7.z.string().optional().describe("Override label"),
-  aggregate: import_zod7.z.enum(["sum", "avg", "max", "min", "count", "unique"]).optional().describe("Aggregation function")
-});
-var ReportGroupingSchema = import_zod7.z.object({
-  field: import_zod7.z.string().describe("Field to group by"),
-  sortOrder: import_zod7.z.enum(["asc", "desc"]).default("asc"),
-  dateGranularity: import_zod7.z.enum(["day", "week", "month", "quarter", "year"]).optional().describe("For date fields")
+var ReportColumnSchema = import_zod9.z.object({
+  field: import_zod9.z.string().describe("Field name"),
+  label: I18nLabelSchema.optional().describe("Override label"),
+  aggregate: import_zod9.z.enum(["sum", "avg", "max", "min", "count", "unique"]).optional().describe("Aggregation function"),
+  /** Responsive visibility/priority per breakpoint */
+  responsive: ResponsiveConfigSchema.optional().describe("Responsive visibility for this column")
+});
+var ReportGroupingSchema = import_zod9.z.object({
+  field: import_zod9.z.string().describe("Field to group by"),
+  sortOrder: import_zod9.z.enum(["asc", "desc"]).default("asc"),
+  dateGranularity: import_zod9.z.enum(["day", "week", "month", "quarter", "year"]).optional().describe("For date fields")
 });
 var ReportChartSchema = ChartConfigSchema.extend({
   /** Report-specific chart configuration */
-  xAxis: import_zod7.z.string().describe("Grouping field for X-Axis"),
-  yAxis: import_zod7.z.string().describe("Summary field for Y-Axis"),
-  groupBy: import_zod7.z.string().optional().describe("Additional grouping field")
+  xAxis: import_zod9.z.string().describe("Grouping field for X-Axis"),
+  yAxis: import_zod9.z.string().describe("Summary field for Y-Axis"),
+  groupBy: import_zod9.z.string().optional().describe("Additional grouping field")
 });
-var ReportSchema = import_zod7.z.object({
+var ReportSchema = import_zod9.z.object({
   /** Identity */
   name: SnakeCaseIdentifierSchema.describe("Report unique name"),
-  label: import_zod7.z.string().describe("Report label"),
-  description: import_zod7.z.string().optional(),
+  label: I18nLabelSchema.describe("Report label"),
+  description: I18nLabelSchema.optional(),
   /** Data Source */
-  objectName: import_zod7.z.string().describe("Primary object"),
+  objectName: import_zod9.z.string().describe("Primary object"),
   /** Report Configuration */
   type: ReportType.default("tabular").describe("Report format type"),
-  columns: import_zod7.z.array(ReportColumnSchema).describe("Columns to display"),
+  columns: import_zod9.z.array(ReportColumnSchema).describe("Columns to display"),
   /** Grouping (for Summary/Matrix) */
-  groupingsDown: import_zod7.z.array(ReportGroupingSchema).optional().describe("Row groupings"),
-  groupingsAcross: import_zod7.z.array(ReportGroupingSchema).optional().describe("Column groupings (Matrix only)"),
+  groupingsDown: import_zod9.z.array(ReportGroupingSchema).optional().describe("Row groupings"),
+  groupingsAcross: import_zod9.z.array(ReportGroupingSchema).optional().describe("Column groupings (Matrix only)"),
   /** Filtering (MongoDB-style FilterCondition) */
   filter: FilterConditionSchema.optional().describe("Filter criteria"),
   /** Visualization */
-  chart: ReportChartSchema.optional().describe("Embedded chart configuration")
+  chart: ReportChartSchema.optional().describe("Embedded chart configuration"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes"),
+  /** Performance optimization settings */
+  performance: PerformanceConfigSchema.optional().describe("Performance optimization settings")
 });
 var Report = {
   create: (config) => ReportSchema.parse(config)
 };
 
 // src/ui/action.zod.ts
-var import_zod11 = require("zod");
+var import_zod13 = require("zod");
 
 // src/data/field.zod.ts
-var import_zod10 = require("zod");
+var import_zod12 = require("zod");
 
 // src/system/encryption.zod.ts
-var import_zod8 = require("zod");
-var EncryptionAlgorithmSchema = import_zod8.z.enum([
+var import_zod10 = require("zod");
+var EncryptionAlgorithmSchema = import_zod10.z.enum([
   "aes-256-gcm",
   "aes-256-cbc",
   "chacha20-poly1305"
 ]).describe("Supported encryption algorithm");
-var KeyManagementProviderSchema = import_zod8.z.enum([
+var KeyManagementProviderSchema = import_zod10.z.enum([
   "local",
   "aws-kms",
   "azure-key-vault",
   "gcp-kms",
   "hashicorp-vault"
 ]).describe("Key management service provider");
-var KeyRotationPolicySchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().default(false).describe("Enable automatic key rotation"),
-  frequencyDays: import_zod8.z.number().min(1).default(90).describe("Rotation frequency in days"),
-  retainOldVersions: import_zod8.z.number().default(3).describe("Number of old key versions to retain"),
-  autoRotate: import_zod8.z.boolean().default(true).describe("Automatically rotate without manual approval")
+var KeyRotationPolicySchema = import_zod10.z.object({
+  enabled: import_zod10.z.boolean().default(false).describe("Enable automatic key rotation"),
+  frequencyDays: import_zod10.z.number().min(1).default(90).describe("Rotation frequency in days"),
+  retainOldVersions: import_zod10.z.number().default(3).describe("Number of old key versions to retain"),
+  autoRotate: import_zod10.z.boolean().default(true).describe("Automatically rotate without manual approval")
 }).describe("Policy for automatic encryption key rotation");
-var EncryptionConfigSchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().default(false).describe("Enable field-level encryption"),
+var EncryptionConfigSchema = import_zod10.z.object({
+  enabled: import_zod10.z.boolean().default(false).describe("Enable field-level encryption"),
   algorithm: EncryptionAlgorithmSchema.default("aes-256-gcm").describe("Encryption algorithm"),
-  keyManagement: import_zod8.z.object({
+  keyManagement: import_zod10.z.object({
     provider: KeyManagementProviderSchema.describe("Key management service provider"),
-    keyId: import_zod8.z.string().optional().describe("Key identifier in the provider"),
+    keyId: import_zod10.z.string().optional().describe("Key identifier in the provider"),
     rotationPolicy: KeyRotationPolicySchema.optional().describe("Key rotation policy")
   }).describe("Key management configuration"),
-  scope: import_zod8.z.enum(["field", "record", "table", "database"]).describe("Encryption scope level"),
-  deterministicEncryption: import_zod8.z.boolean().default(false).describe("Allows equality queries on encrypted data"),
-  searchableEncryption: import_zod8.z.boolean().default(false).describe("Allows search on encrypted data")
+  scope: import_zod10.z.enum(["field", "record", "table", "database"]).describe("Encryption scope level"),
+  deterministicEncryption: import_zod10.z.boolean().default(false).describe("Allows equality queries on encrypted data"),
+  searchableEncryption: import_zod10.z.boolean().default(false).describe("Allows search on encrypted data")
 }).describe("Field-level encryption configuration");
-var FieldEncryptionSchema = import_zod8.z.object({
-  fieldName: import_zod8.z.string().describe("Name of the field to encrypt"),
+var FieldEncryptionSchema = import_zod10.z.object({
+  fieldName: import_zod10.z.string().describe("Name of the field to encrypt"),
   encryptionConfig: EncryptionConfigSchema.describe("Encryption settings for this field"),
-  indexable: import_zod8.z.boolean().default(false).describe("Allow indexing on encrypted field")
+  indexable: import_zod10.z.boolean().default(false).describe("Allow indexing on encrypted field")
 }).describe("Per-field encryption assignment");
 
 // src/system/masking.zod.ts
-var import_zod9 = require("zod");
-var MaskingStrategySchema = import_zod9.z.enum([
+var import_zod11 = require("zod");
+var MaskingStrategySchema = import_zod11.z.enum([
   "redact",
   // Complete redaction: ****
   "partial",
@@ -857,23 +1138,23 @@ var MaskingStrategySchema = import_zod9.z.enum([
   "substitute"
   // Substitute with dummy data
 ]).describe("Data masking strategy for PII protection");
-var MaskingRuleSchema = import_zod9.z.object({
-  field: import_zod9.z.string().describe("Field name to apply masking to"),
+var MaskingRuleSchema = import_zod11.z.object({
+  field: import_zod11.z.string().describe("Field name to apply masking to"),
   strategy: MaskingStrategySchema.describe("Masking strategy to use"),
-  pattern: import_zod9.z.string().optional().describe("Regex pattern for partial masking"),
-  preserveFormat: import_zod9.z.boolean().default(true).describe("Keep the original data format after masking"),
-  preserveLength: import_zod9.z.boolean().default(true).describe("Keep the original data length after masking"),
-  roles: import_zod9.z.array(import_zod9.z.string()).optional().describe("Roles that see masked data"),
-  exemptRoles: import_zod9.z.array(import_zod9.z.string()).optional().describe("Roles that see unmasked data")
+  pattern: import_zod11.z.string().optional().describe("Regex pattern for partial masking"),
+  preserveFormat: import_zod11.z.boolean().default(true).describe("Keep the original data format after masking"),
+  preserveLength: import_zod11.z.boolean().default(true).describe("Keep the original data length after masking"),
+  roles: import_zod11.z.array(import_zod11.z.string()).optional().describe("Roles that see masked data"),
+  exemptRoles: import_zod11.z.array(import_zod11.z.string()).optional().describe("Roles that see unmasked data")
 }).describe("Masking rule for a single field");
-var MaskingConfigSchema = import_zod9.z.object({
-  enabled: import_zod9.z.boolean().default(false).describe("Enable data masking"),
-  rules: import_zod9.z.array(MaskingRuleSchema).describe("List of field-level masking rules"),
-  auditUnmasking: import_zod9.z.boolean().default(true).describe("Log when masked data is accessed unmasked")
+var MaskingConfigSchema = import_zod11.z.object({
+  enabled: import_zod11.z.boolean().default(false).describe("Enable data masking"),
+  rules: import_zod11.z.array(MaskingRuleSchema).describe("List of field-level masking rules"),
+  auditUnmasking: import_zod11.z.boolean().default(true).describe("Log when masked data is accessed unmasked")
 }).describe("Top-level data masking configuration for PII protection");
 
 // src/data/field.zod.ts
-var FieldType = import_zod10.z.enum([
+var FieldType = import_zod12.z.enum([
   // Core Text
   "text",
   "textarea",
@@ -949,92 +1230,92 @@ var FieldType = import_zod10.z.enum([
   "vector"
   // Vector embeddings for AI/ML (semantic search, RAG)
 ]);
-var SelectOptionSchema = import_zod10.z.object({
-  label: import_zod10.z.string().describe("Display label (human-readable, any case allowed)"),
+var SelectOptionSchema = import_zod12.z.object({
+  label: import_zod12.z.string().describe("Display label (human-readable, any case allowed)"),
   value: SystemIdentifierSchema.describe("Stored value (lowercase machine identifier)"),
-  color: import_zod10.z.string().optional().describe("Color code for badges/charts"),
-  default: import_zod10.z.boolean().optional().describe("Is default option")
-});
-var LocationCoordinatesSchema = import_zod10.z.object({
-  latitude: import_zod10.z.number().min(-90).max(90).describe("Latitude coordinate"),
-  longitude: import_zod10.z.number().min(-180).max(180).describe("Longitude coordinate"),
-  altitude: import_zod10.z.number().optional().describe("Altitude in meters"),
-  accuracy: import_zod10.z.number().optional().describe("Accuracy in meters")
-});
-var CurrencyConfigSchema = import_zod10.z.object({
-  precision: import_zod10.z.number().int().min(0).max(10).default(2).describe("Decimal precision (default: 2)"),
-  currencyMode: import_zod10.z.enum(["dynamic", "fixed"]).default("dynamic").describe("Currency mode: dynamic (user selectable) or fixed (single currency)"),
-  defaultCurrency: import_zod10.z.string().length(3).default("CNY").describe("Default or fixed currency code (ISO 4217, e.g., USD, CNY, EUR)")
-});
-var CurrencyValueSchema = import_zod10.z.object({
-  value: import_zod10.z.number().describe("Monetary amount"),
-  currency: import_zod10.z.string().length(3).describe("Currency code (ISO 4217)")
-});
-var AddressSchema = import_zod10.z.object({
-  street: import_zod10.z.string().optional().describe("Street address"),
-  city: import_zod10.z.string().optional().describe("City name"),
-  state: import_zod10.z.string().optional().describe("State/Province"),
-  postalCode: import_zod10.z.string().optional().describe("Postal/ZIP code"),
-  country: import_zod10.z.string().optional().describe("Country name or code"),
-  countryCode: import_zod10.z.string().optional().describe("ISO country code (e.g., US, GB)"),
-  formatted: import_zod10.z.string().optional().describe("Formatted address string")
-});
-var VectorConfigSchema = import_zod10.z.object({
-  dimensions: import_zod10.z.number().int().min(1).max(1e4).describe("Vector dimensionality (e.g., 1536 for OpenAI embeddings)"),
-  distanceMetric: import_zod10.z.enum(["cosine", "euclidean", "dotProduct", "manhattan"]).default("cosine").describe("Distance/similarity metric for vector search"),
-  normalized: import_zod10.z.boolean().default(false).describe("Whether vectors are normalized (unit length)"),
-  indexed: import_zod10.z.boolean().default(true).describe("Whether to create a vector index for fast similarity search"),
-  indexType: import_zod10.z.enum(["hnsw", "ivfflat", "flat"]).optional().describe("Vector index algorithm (HNSW for high accuracy, IVFFlat for large datasets)")
-});
-var FileAttachmentConfigSchema = import_zod10.z.object({
+  color: import_zod12.z.string().optional().describe("Color code for badges/charts"),
+  default: import_zod12.z.boolean().optional().describe("Is default option")
+});
+var LocationCoordinatesSchema = import_zod12.z.object({
+  latitude: import_zod12.z.number().min(-90).max(90).describe("Latitude coordinate"),
+  longitude: import_zod12.z.number().min(-180).max(180).describe("Longitude coordinate"),
+  altitude: import_zod12.z.number().optional().describe("Altitude in meters"),
+  accuracy: import_zod12.z.number().optional().describe("Accuracy in meters")
+});
+var CurrencyConfigSchema = import_zod12.z.object({
+  precision: import_zod12.z.number().int().min(0).max(10).default(2).describe("Decimal precision (default: 2)"),
+  currencyMode: import_zod12.z.enum(["dynamic", "fixed"]).default("dynamic").describe("Currency mode: dynamic (user selectable) or fixed (single currency)"),
+  defaultCurrency: import_zod12.z.string().length(3).default("CNY").describe("Default or fixed currency code (ISO 4217, e.g., USD, CNY, EUR)")
+});
+var CurrencyValueSchema = import_zod12.z.object({
+  value: import_zod12.z.number().describe("Monetary amount"),
+  currency: import_zod12.z.string().length(3).describe("Currency code (ISO 4217)")
+});
+var AddressSchema = import_zod12.z.object({
+  street: import_zod12.z.string().optional().describe("Street address"),
+  city: import_zod12.z.string().optional().describe("City name"),
+  state: import_zod12.z.string().optional().describe("State/Province"),
+  postalCode: import_zod12.z.string().optional().describe("Postal/ZIP code"),
+  country: import_zod12.z.string().optional().describe("Country name or code"),
+  countryCode: import_zod12.z.string().optional().describe("ISO country code (e.g., US, GB)"),
+  formatted: import_zod12.z.string().optional().describe("Formatted address string")
+});
+var VectorConfigSchema = import_zod12.z.object({
+  dimensions: import_zod12.z.number().int().min(1).max(1e4).describe("Vector dimensionality (e.g., 1536 for OpenAI embeddings)"),
+  distanceMetric: import_zod12.z.enum(["cosine", "euclidean", "dotProduct", "manhattan"]).default("cosine").describe("Distance/similarity metric for vector search"),
+  normalized: import_zod12.z.boolean().default(false).describe("Whether vectors are normalized (unit length)"),
+  indexed: import_zod12.z.boolean().default(true).describe("Whether to create a vector index for fast similarity search"),
+  indexType: import_zod12.z.enum(["hnsw", "ivfflat", "flat"]).optional().describe("Vector index algorithm (HNSW for high accuracy, IVFFlat for large datasets)")
+});
+var FileAttachmentConfigSchema = import_zod12.z.object({
   /** File Size Limits */
-  minSize: import_zod10.z.number().min(0).optional().describe("Minimum file size in bytes"),
-  maxSize: import_zod10.z.number().min(1).optional().describe("Maximum file size in bytes (e.g., 10485760 = 10MB)"),
+  minSize: import_zod12.z.number().min(0).optional().describe("Minimum file size in bytes"),
+  maxSize: import_zod12.z.number().min(1).optional().describe("Maximum file size in bytes (e.g., 10485760 = 10MB)"),
   /** File Type Restrictions */
-  allowedTypes: import_zod10.z.array(import_zod10.z.string()).optional().describe('Allowed file extensions (e.g., [".pdf", ".docx", ".jpg"])'),
-  blockedTypes: import_zod10.z.array(import_zod10.z.string()).optional().describe('Blocked file extensions (e.g., [".exe", ".bat", ".sh"])'),
-  allowedMimeTypes: import_zod10.z.array(import_zod10.z.string()).optional().describe('Allowed MIME types (e.g., ["image/jpeg", "application/pdf"])'),
-  blockedMimeTypes: import_zod10.z.array(import_zod10.z.string()).optional().describe("Blocked MIME types"),
+  allowedTypes: import_zod12.z.array(import_zod12.z.string()).optional().describe('Allowed file extensions (e.g., [".pdf", ".docx", ".jpg"])'),
+  blockedTypes: import_zod12.z.array(import_zod12.z.string()).optional().describe('Blocked file extensions (e.g., [".exe", ".bat", ".sh"])'),
+  allowedMimeTypes: import_zod12.z.array(import_zod12.z.string()).optional().describe('Allowed MIME types (e.g., ["image/jpeg", "application/pdf"])'),
+  blockedMimeTypes: import_zod12.z.array(import_zod12.z.string()).optional().describe("Blocked MIME types"),
   /** Virus Scanning */
-  virusScan: import_zod10.z.boolean().default(false).describe("Enable virus scanning for uploaded files"),
-  virusScanProvider: import_zod10.z.enum(["clamav", "virustotal", "metadefender", "custom"]).optional().describe("Virus scanning service provider"),
-  virusScanOnUpload: import_zod10.z.boolean().default(true).describe("Scan files immediately on upload"),
-  quarantineOnThreat: import_zod10.z.boolean().default(true).describe("Quarantine files if threat detected"),
+  virusScan: import_zod12.z.boolean().default(false).describe("Enable virus scanning for uploaded files"),
+  virusScanProvider: import_zod12.z.enum(["clamav", "virustotal", "metadefender", "custom"]).optional().describe("Virus scanning service provider"),
+  virusScanOnUpload: import_zod12.z.boolean().default(true).describe("Scan files immediately on upload"),
+  quarantineOnThreat: import_zod12.z.boolean().default(true).describe("Quarantine files if threat detected"),
   /** Storage Configuration */
-  storageProvider: import_zod10.z.string().optional().describe("Object storage provider name (references ObjectStorageConfig)"),
-  storageBucket: import_zod10.z.string().optional().describe("Target bucket name"),
-  storagePrefix: import_zod10.z.string().optional().describe('Storage path prefix (e.g., "uploads/documents/")'),
+  storageProvider: import_zod12.z.string().optional().describe("Object storage provider name (references ObjectStorageConfig)"),
+  storageBucket: import_zod12.z.string().optional().describe("Target bucket name"),
+  storagePrefix: import_zod12.z.string().optional().describe('Storage path prefix (e.g., "uploads/documents/")'),
   /** Image-Specific Validation */
-  imageValidation: import_zod10.z.object({
-    minWidth: import_zod10.z.number().min(1).optional().describe("Minimum image width in pixels"),
-    maxWidth: import_zod10.z.number().min(1).optional().describe("Maximum image width in pixels"),
-    minHeight: import_zod10.z.number().min(1).optional().describe("Minimum image height in pixels"),
-    maxHeight: import_zod10.z.number().min(1).optional().describe("Maximum image height in pixels"),
-    aspectRatio: import_zod10.z.string().optional().describe('Required aspect ratio (e.g., "16:9", "1:1")'),
-    generateThumbnails: import_zod10.z.boolean().default(false).describe("Auto-generate thumbnails"),
-    thumbnailSizes: import_zod10.z.array(import_zod10.z.object({
-      name: import_zod10.z.string().describe('Thumbnail variant name (e.g., "small", "medium", "large")'),
-      width: import_zod10.z.number().min(1).describe("Thumbnail width in pixels"),
-      height: import_zod10.z.number().min(1).describe("Thumbnail height in pixels"),
-      crop: import_zod10.z.boolean().default(false).describe("Crop to exact dimensions")
+  imageValidation: import_zod12.z.object({
+    minWidth: import_zod12.z.number().min(1).optional().describe("Minimum image width in pixels"),
+    maxWidth: import_zod12.z.number().min(1).optional().describe("Maximum image width in pixels"),
+    minHeight: import_zod12.z.number().min(1).optional().describe("Minimum image height in pixels"),
+    maxHeight: import_zod12.z.number().min(1).optional().describe("Maximum image height in pixels"),
+    aspectRatio: import_zod12.z.string().optional().describe('Required aspect ratio (e.g., "16:9", "1:1")'),
+    generateThumbnails: import_zod12.z.boolean().default(false).describe("Auto-generate thumbnails"),
+    thumbnailSizes: import_zod12.z.array(import_zod12.z.object({
+      name: import_zod12.z.string().describe('Thumbnail variant name (e.g., "small", "medium", "large")'),
+      width: import_zod12.z.number().min(1).describe("Thumbnail width in pixels"),
+      height: import_zod12.z.number().min(1).describe("Thumbnail height in pixels"),
+      crop: import_zod12.z.boolean().default(false).describe("Crop to exact dimensions")
     })).optional().describe("Thumbnail size configurations"),
-    preserveMetadata: import_zod10.z.boolean().default(false).describe("Preserve EXIF metadata"),
-    autoRotate: import_zod10.z.boolean().default(true).describe("Auto-rotate based on EXIF orientation")
+    preserveMetadata: import_zod12.z.boolean().default(false).describe("Preserve EXIF metadata"),
+    autoRotate: import_zod12.z.boolean().default(true).describe("Auto-rotate based on EXIF orientation")
   }).optional().describe("Image-specific validation rules"),
   /** Upload Behavior */
-  allowMultiple: import_zod10.z.boolean().default(false).describe("Allow multiple file uploads (overrides field.multiple)"),
-  allowReplace: import_zod10.z.boolean().default(true).describe("Allow replacing existing files"),
-  allowDelete: import_zod10.z.boolean().default(true).describe("Allow deleting uploaded files"),
-  requireUpload: import_zod10.z.boolean().default(false).describe("Require at least one file when field is required"),
+  allowMultiple: import_zod12.z.boolean().default(false).describe("Allow multiple file uploads (overrides field.multiple)"),
+  allowReplace: import_zod12.z.boolean().default(true).describe("Allow replacing existing files"),
+  allowDelete: import_zod12.z.boolean().default(true).describe("Allow deleting uploaded files"),
+  requireUpload: import_zod12.z.boolean().default(false).describe("Require at least one file when field is required"),
   /** Metadata Extraction */
-  extractMetadata: import_zod10.z.boolean().default(true).describe("Extract file metadata (name, size, type, etc.)"),
-  extractText: import_zod10.z.boolean().default(false).describe("Extract text content from documents (OCR/parsing)"),
+  extractMetadata: import_zod12.z.boolean().default(true).describe("Extract file metadata (name, size, type, etc.)"),
+  extractText: import_zod12.z.boolean().default(false).describe("Extract text content from documents (OCR/parsing)"),
   /** Versioning */
-  versioningEnabled: import_zod10.z.boolean().default(false).describe("Keep previous versions of replaced files"),
-  maxVersions: import_zod10.z.number().min(1).optional().describe("Maximum number of versions to retain"),
+  versioningEnabled: import_zod12.z.boolean().default(false).describe("Keep previous versions of replaced files"),
+  maxVersions: import_zod12.z.number().min(1).optional().describe("Maximum number of versions to retain"),
   /** Access Control */
-  publicRead: import_zod10.z.boolean().default(false).describe("Allow public read access to uploaded files"),
-  presignedUrlExpiry: import_zod10.z.number().min(60).max(604800).default(3600).describe("Presigned URL expiration in seconds (default: 1 hour)")
+  publicRead: import_zod12.z.boolean().default(false).describe("Allow public read access to uploaded files"),
+  presignedUrlExpiry: import_zod12.z.number().min(60).max(604800).default(3600).describe("Presigned URL expiration in seconds (default: 1 hour)")
 }).refine((data) => {
   if (data.minSize !== void 0 && data.maxSize !== void 0 && data.minSize > data.maxSize) {
     return false;
@@ -1050,88 +1331,88 @@ var FileAttachmentConfigSchema = import_zod10.z.object({
 }, {
   message: "virusScanProvider requires virusScan to be enabled"
 });
-var DataQualityRulesSchema = import_zod10.z.object({
+var DataQualityRulesSchema = import_zod12.z.object({
   /** Enforce uniqueness constraint */
-  uniqueness: import_zod10.z.boolean().default(false).describe("Enforce unique values across all records"),
+  uniqueness: import_zod12.z.boolean().default(false).describe("Enforce unique values across all records"),
   /** Completeness ratio (0-1) indicating minimum percentage of non-null values */
-  completeness: import_zod10.z.number().min(0).max(1).default(0).describe("Minimum ratio of non-null values (0-1, default: 0 = no requirement)"),
+  completeness: import_zod12.z.number().min(0).max(1).default(0).describe("Minimum ratio of non-null values (0-1, default: 0 = no requirement)"),
   /** Accuracy validation against authoritative source */
-  accuracy: import_zod10.z.object({
-    source: import_zod10.z.string().describe('Reference data source for validation (e.g., "api.verify.com", "master_data")'),
-    threshold: import_zod10.z.number().min(0).max(1).describe("Minimum accuracy threshold (0-1, e.g., 0.95 = 95% match required)")
+  accuracy: import_zod12.z.object({
+    source: import_zod12.z.string().describe('Reference data source for validation (e.g., "api.verify.com", "master_data")'),
+    threshold: import_zod12.z.number().min(0).max(1).describe("Minimum accuracy threshold (0-1, e.g., 0.95 = 95% match required)")
   }).optional().describe("Accuracy validation configuration")
 });
-var ComputedFieldCacheSchema = import_zod10.z.object({
+var ComputedFieldCacheSchema = import_zod12.z.object({
   /** Enable caching for this computed field */
-  enabled: import_zod10.z.boolean().describe("Enable caching for computed field results"),
+  enabled: import_zod12.z.boolean().describe("Enable caching for computed field results"),
   /** Time-to-live in seconds */
-  ttl: import_zod10.z.number().min(0).describe("Cache TTL in seconds (0 = no expiration)"),
+  ttl: import_zod12.z.number().min(0).describe("Cache TTL in seconds (0 = no expiration)"),
   /** Array of field paths that trigger cache invalidation when changed */
-  invalidateOn: import_zod10.z.array(import_zod10.z.string()).describe('Field paths that invalidate cache (e.g., ["inventory.quantity", "pricing.base_price"])')
+  invalidateOn: import_zod12.z.array(import_zod12.z.string()).describe('Field paths that invalidate cache (e.g., ["inventory.quantity", "pricing.base_price"])')
 });
-var FieldSchema = import_zod10.z.object({
+var FieldSchema = import_zod12.z.object({
   /** Identity */
-  name: import_zod10.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine name (snake_case)").optional(),
-  label: import_zod10.z.string().optional().describe("Human readable label"),
+  name: import_zod12.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine name (snake_case)").optional(),
+  label: import_zod12.z.string().optional().describe("Human readable label"),
   type: FieldType.describe("Field Data Type"),
-  description: import_zod10.z.string().optional().describe("Tooltip/Help text"),
-  format: import_zod10.z.string().optional().describe("Format string (e.g. email, phone)"),
+  description: import_zod12.z.string().optional().describe("Tooltip/Help text"),
+  format: import_zod12.z.string().optional().describe("Format string (e.g. email, phone)"),
   /** Database Constraints */
-  required: import_zod10.z.boolean().default(false).describe("Is required"),
-  searchable: import_zod10.z.boolean().default(false).describe("Is searchable"),
-  multiple: import_zod10.z.boolean().default(false).describe("Allow multiple values (Stores as Array/JSON). Applicable for select, lookup, file, image."),
-  unique: import_zod10.z.boolean().default(false).describe("Is unique constraint"),
-  defaultValue: import_zod10.z.unknown().optional().describe("Default value"),
+  required: import_zod12.z.boolean().default(false).describe("Is required"),
+  searchable: import_zod12.z.boolean().default(false).describe("Is searchable"),
+  multiple: import_zod12.z.boolean().default(false).describe("Allow multiple values (Stores as Array/JSON). Applicable for select, lookup, file, image."),
+  unique: import_zod12.z.boolean().default(false).describe("Is unique constraint"),
+  defaultValue: import_zod12.z.unknown().optional().describe("Default value"),
   /** Text/String Constraints */
-  maxLength: import_zod10.z.number().optional().describe("Max character length"),
-  minLength: import_zod10.z.number().optional().describe("Min character length"),
+  maxLength: import_zod12.z.number().optional().describe("Max character length"),
+  minLength: import_zod12.z.number().optional().describe("Min character length"),
   /** Number Constraints */
-  precision: import_zod10.z.number().optional().describe("Total digits"),
-  scale: import_zod10.z.number().optional().describe("Decimal places"),
-  min: import_zod10.z.number().optional().describe("Minimum value"),
-  max: import_zod10.z.number().optional().describe("Maximum value"),
+  precision: import_zod12.z.number().optional().describe("Total digits"),
+  scale: import_zod12.z.number().optional().describe("Decimal places"),
+  min: import_zod12.z.number().optional().describe("Minimum value"),
+  max: import_zod12.z.number().optional().describe("Maximum value"),
   /** Selection Options */
-  options: import_zod10.z.array(SelectOptionSchema).optional().describe("Static options for select/multiselect"),
+  options: import_zod12.z.array(SelectOptionSchema).optional().describe("Static options for select/multiselect"),
   /** Relationship Config */
-  reference: import_zod10.z.string().optional().describe("Target Object Name"),
-  referenceFilters: import_zod10.z.array(import_zod10.z.string()).optional().describe('Filters applied to lookup dialogs (e.g. "active = true")'),
-  writeRequiresMasterRead: import_zod10.z.boolean().optional().describe("If true, user needs read access to master record to edit this field"),
-  deleteBehavior: import_zod10.z.enum(["set_null", "cascade", "restrict"]).optional().default("set_null").describe("What happens if referenced record is deleted"),
+  reference: import_zod12.z.string().optional().describe("Target Object Name"),
+  referenceFilters: import_zod12.z.array(import_zod12.z.string()).optional().describe('Filters applied to lookup dialogs (e.g. "active = true")'),
+  writeRequiresMasterRead: import_zod12.z.boolean().optional().describe("If true, user needs read access to master record to edit this field"),
+  deleteBehavior: import_zod12.z.enum(["set_null", "cascade", "restrict"]).optional().default("set_null").describe("What happens if referenced record is deleted"),
   /** Calculation */
-  expression: import_zod10.z.string().optional().describe("Formula expression"),
-  summaryOperations: import_zod10.z.object({
-    object: import_zod10.z.string(),
-    field: import_zod10.z.string(),
-    function: import_zod10.z.enum(["count", "sum", "min", "max", "avg"])
+  expression: import_zod12.z.string().optional().describe("Formula expression"),
+  summaryOperations: import_zod12.z.object({
+    object: import_zod12.z.string(),
+    field: import_zod12.z.string(),
+    function: import_zod12.z.enum(["count", "sum", "min", "max", "avg"])
   }).optional().describe("Roll-up summary definition"),
   /** Enhanced Field Type Configurations */
   // Code field config
-  language: import_zod10.z.string().optional().describe("Programming language for syntax highlighting (e.g., javascript, python, sql)"),
-  theme: import_zod10.z.string().optional().describe("Code editor theme (e.g., dark, light, monokai)"),
-  lineNumbers: import_zod10.z.boolean().optional().describe("Show line numbers in code editor"),
+  language: import_zod12.z.string().optional().describe("Programming language for syntax highlighting (e.g., javascript, python, sql)"),
+  theme: import_zod12.z.string().optional().describe("Code editor theme (e.g., dark, light, monokai)"),
+  lineNumbers: import_zod12.z.boolean().optional().describe("Show line numbers in code editor"),
   // Rating field config
-  maxRating: import_zod10.z.number().optional().describe("Maximum rating value (default: 5)"),
-  allowHalf: import_zod10.z.boolean().optional().describe("Allow half-star ratings"),
+  maxRating: import_zod12.z.number().optional().describe("Maximum rating value (default: 5)"),
+  allowHalf: import_zod12.z.boolean().optional().describe("Allow half-star ratings"),
   // Location field config
-  displayMap: import_zod10.z.boolean().optional().describe("Display map widget for location field"),
-  allowGeocoding: import_zod10.z.boolean().optional().describe("Allow address-to-coordinate conversion"),
+  displayMap: import_zod12.z.boolean().optional().describe("Display map widget for location field"),
+  allowGeocoding: import_zod12.z.boolean().optional().describe("Allow address-to-coordinate conversion"),
   // Address field config
-  addressFormat: import_zod10.z.enum(["us", "uk", "international"]).optional().describe("Address format template"),
+  addressFormat: import_zod12.z.enum(["us", "uk", "international"]).optional().describe("Address format template"),
   // Color field config
-  colorFormat: import_zod10.z.enum(["hex", "rgb", "rgba", "hsl"]).optional().describe("Color value format"),
-  allowAlpha: import_zod10.z.boolean().optional().describe("Allow transparency/alpha channel"),
-  presetColors: import_zod10.z.array(import_zod10.z.string()).optional().describe("Preset color options"),
+  colorFormat: import_zod12.z.enum(["hex", "rgb", "rgba", "hsl"]).optional().describe("Color value format"),
+  allowAlpha: import_zod12.z.boolean().optional().describe("Allow transparency/alpha channel"),
+  presetColors: import_zod12.z.array(import_zod12.z.string()).optional().describe("Preset color options"),
   // Slider field config
-  step: import_zod10.z.number().optional().describe("Step increment for slider (default: 1)"),
-  showValue: import_zod10.z.boolean().optional().describe("Display current value on slider"),
-  marks: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.string()).optional().describe('Custom marks/labels at specific values (e.g., {0: "Low", 50: "Medium", 100: "High"})'),
+  step: import_zod12.z.number().optional().describe("Step increment for slider (default: 1)"),
+  showValue: import_zod12.z.boolean().optional().describe("Display current value on slider"),
+  marks: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string()).optional().describe('Custom marks/labels at specific values (e.g., {0: "Low", 50: "Medium", 100: "High"})'),
   // QR Code / Barcode field config
   // Note: qrErrorCorrection is only applicable when barcodeFormat='qr'
   // Runtime validation should enforce this constraint
-  barcodeFormat: import_zod10.z.enum(["qr", "ean13", "ean8", "code128", "code39", "upca", "upce"]).optional().describe("Barcode format type"),
-  qrErrorCorrection: import_zod10.z.enum(["L", "M", "Q", "H"]).optional().describe('QR code error correction level (L=7%, M=15%, Q=25%, H=30%). Only applicable when barcodeFormat is "qr"'),
-  displayValue: import_zod10.z.boolean().optional().describe("Display human-readable value below barcode/QR code"),
-  allowScanning: import_zod10.z.boolean().optional().describe("Enable camera scanning for barcode/QR code input"),
+  barcodeFormat: import_zod12.z.enum(["qr", "ean13", "ean8", "code128", "code39", "upca", "upce"]).optional().describe("Barcode format type"),
+  qrErrorCorrection: import_zod12.z.enum(["L", "M", "Q", "H"]).optional().describe('QR code error correction level (L=7%, M=15%, Q=25%, H=30%). Only applicable when barcodeFormat is "qr"'),
+  displayValue: import_zod12.z.boolean().optional().describe("Display human-readable value below barcode/QR code"),
+  allowScanning: import_zod12.z.boolean().optional().describe("Enable camera scanning for barcode/QR code input"),
   // Currency field config
   currencyConfig: CurrencyConfigSchema.optional().describe("Configuration for currency field type"),
   // Vector field config
@@ -1144,10 +1425,10 @@ var FieldSchema = import_zod10.z.object({
   // Data masking rules
   maskingRule: MaskingRuleSchema.optional().describe("Data masking rules for PII protection"),
   // Audit trail
-  auditTrail: import_zod10.z.boolean().default(false).describe("Enable detailed audit trail for this field (tracks all changes with user and timestamp)"),
+  auditTrail: import_zod12.z.boolean().default(false).describe("Enable detailed audit trail for this field (tracks all changes with user and timestamp)"),
   /** Field Dependencies & Relationships */
   // Field dependencies
-  dependencies: import_zod10.z.array(import_zod10.z.string()).optional().describe("Array of field names that this field depends on (for formulas, visibility rules, etc.)"),
+  dependencies: import_zod12.z.array(import_zod12.z.string()).optional().describe("Array of field names that this field depends on (for formulas, visibility rules, etc.)"),
   /** Computed Field Optimization */
   // Computed field caching
   cached: ComputedFieldCacheSchema.optional().describe("Caching configuration for computed/formula fields"),
@@ -1155,35 +1436,35 @@ var FieldSchema = import_zod10.z.object({
   // Data quality rules
   dataQuality: DataQualityRulesSchema.optional().describe("Data quality validation and monitoring rules"),
   /** Security & Visibility */
-  hidden: import_zod10.z.boolean().default(false).describe("Hidden from default UI"),
-  readonly: import_zod10.z.boolean().default(false).describe("Read-only in UI"),
-  sortable: import_zod10.z.boolean().optional().default(true).describe("Whether field is sortable in list views"),
-  inlineHelpText: import_zod10.z.string().optional().describe("Help text displayed below the field in forms"),
-  trackFeedHistory: import_zod10.z.boolean().optional().describe("Track field changes in Chatter/activity feed (Salesforce pattern)"),
-  caseSensitive: import_zod10.z.boolean().optional().describe("Whether text comparisons are case-sensitive"),
-  autonumberFormat: import_zod10.z.string().optional().describe('Auto-number display format pattern (e.g., "CASE-{0000}")'),
+  hidden: import_zod12.z.boolean().default(false).describe("Hidden from default UI"),
+  readonly: import_zod12.z.boolean().default(false).describe("Read-only in UI"),
+  sortable: import_zod12.z.boolean().optional().default(true).describe("Whether field is sortable in list views"),
+  inlineHelpText: import_zod12.z.string().optional().describe("Help text displayed below the field in forms"),
+  trackFeedHistory: import_zod12.z.boolean().optional().describe("Track field changes in Chatter/activity feed (Salesforce pattern)"),
+  caseSensitive: import_zod12.z.boolean().optional().describe("Whether text comparisons are case-sensitive"),
+  autonumberFormat: import_zod12.z.string().optional().describe('Auto-number display format pattern (e.g., "CASE-{0000}")'),
   /** Indexing */
-  index: import_zod10.z.boolean().default(false).describe("Create standard database index"),
-  externalId: import_zod10.z.boolean().default(false).describe("Is external ID for upsert operations")
+  index: import_zod12.z.boolean().default(false).describe("Create standard database index"),
+  externalId: import_zod12.z.boolean().default(false).describe("Is external ID for upsert operations")
 });
 
 // src/ui/action.zod.ts
-var ActionParamSchema = import_zod11.z.object({
-  name: import_zod11.z.string(),
-  label: import_zod11.z.string(),
+var ActionParamSchema = import_zod13.z.object({
+  name: import_zod13.z.string(),
+  label: I18nLabelSchema,
   type: FieldType,
-  required: import_zod11.z.boolean().default(false),
-  options: import_zod11.z.array(import_zod11.z.object({ label: import_zod11.z.string(), value: import_zod11.z.string() })).optional()
+  required: import_zod13.z.boolean().default(false),
+  options: import_zod13.z.array(import_zod13.z.object({ label: I18nLabelSchema, value: import_zod13.z.string() })).optional()
 });
-var ActionSchema = import_zod11.z.object({
+var ActionSchema = import_zod13.z.object({
   /** Machine name of the action */
   name: SnakeCaseIdentifierSchema.describe("Machine name (lowercase snake_case)"),
   /** Display label */
-  label: import_zod11.z.string().describe("Display label"),
+  label: I18nLabelSchema.describe("Display label"),
   /** Icon name (Lucide) */
-  icon: import_zod11.z.string().optional().describe("Icon name"),
+  icon: import_zod13.z.string().optional().describe("Icon name"),
   /** Where does this action appear? */
-  locations: import_zod11.z.array(import_zod11.z.enum([
+  locations: import_zod13.z.array(import_zod13.z.enum([
     "list_toolbar",
     "list_item",
     "record_header",
@@ -1196,7 +1477,7 @@ var ActionSchema = import_zod11.z.object({
    * Defaults to 'button' or 'menu_item' based on location,
    * but can be overridden.
    */
-  component: import_zod11.z.enum([
+  component: import_zod13.z.enum([
     "action:button",
     // Standard Button
     "action:icon",
@@ -1207,41 +1488,43 @@ var ActionSchema = import_zod11.z.object({
     // Button Group
   ]).optional().describe("Visual component override"),
   /** @deprecated Use `locations` instead. Will be removed in v2.0.0 */
-  location: import_zod11.z.unknown().optional().describe("DEPRECATED: Use `locations` field instead. Scheduled for removal in v2.0.0"),
+  location: import_zod13.z.unknown().optional().describe("DEPRECATED: Use `locations` field instead. Scheduled for removal in v2.0.0"),
   /** What type of interaction? */
-  type: import_zod11.z.enum(["script", "url", "modal", "flow", "api"]).default("script").describe("Action functionality type"),
+  type: import_zod13.z.enum(["script", "url", "modal", "flow", "api"]).default("script").describe("Action functionality type"),
   /** Payload / Target */
-  target: import_zod11.z.string().optional().describe("URL, Script Name, Flow ID, or API Endpoint"),
+  target: import_zod13.z.string().optional().describe("URL, Script Name, Flow ID, or API Endpoint"),
   // For URL/Flow types
-  execute: import_zod11.z.string().optional().describe("Legacy execution logic"),
+  execute: import_zod13.z.string().optional().describe("Legacy execution logic"),
   /** User Input Requirements */
-  params: import_zod11.z.array(ActionParamSchema).optional().describe("Input parameters required from user"),
+  params: import_zod13.z.array(ActionParamSchema).optional().describe("Input parameters required from user"),
   /** UX Behavior */
-  confirmText: import_zod11.z.string().optional().describe("Confirmation message before execution"),
-  successMessage: import_zod11.z.string().optional().describe("Success message to show after execution"),
-  refreshAfter: import_zod11.z.boolean().default(false).describe("Refresh view after execution"),
+  confirmText: I18nLabelSchema.optional().describe("Confirmation message before execution"),
+  successMessage: I18nLabelSchema.optional().describe("Success message to show after execution"),
+  refreshAfter: import_zod13.z.boolean().default(false).describe("Refresh view after execution"),
   /** Access */
-  visible: import_zod11.z.string().optional().describe("Formula returning boolean"),
-  disabled: import_zod11.z.union([import_zod11.z.boolean(), import_zod11.z.string()]).optional().describe("Whether the action is disabled, or a condition expression string"),
+  visible: import_zod13.z.string().optional().describe("Formula returning boolean"),
+  disabled: import_zod13.z.union([import_zod13.z.boolean(), import_zod13.z.string()]).optional().describe("Whether the action is disabled, or a condition expression string"),
   /** Keyboard Shortcut */
-  shortcut: import_zod11.z.string().optional().describe('Keyboard shortcut to trigger this action (e.g., "Ctrl+S")'),
+  shortcut: import_zod13.z.string().optional().describe('Keyboard shortcut to trigger this action (e.g., "Ctrl+S")'),
   /** Bulk Operations */
-  bulkEnabled: import_zod11.z.boolean().optional().describe("Whether this action can be applied to multiple selected records"),
+  bulkEnabled: import_zod13.z.boolean().optional().describe("Whether this action can be applied to multiple selected records"),
   /** Execution */
-  timeout: import_zod11.z.number().optional().describe("Maximum execution time in milliseconds for the action")
+  timeout: import_zod13.z.number().optional().describe("Maximum execution time in milliseconds for the action"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
 });
 var Action = {
   create: (config) => ActionSchema.parse(config)
 };
 
 // src/ui/page.zod.ts
-var import_zod12 = require("zod");
-var PageRegionSchema = import_zod12.z.object({
-  name: import_zod12.z.string().describe('Region name (e.g. "sidebar", "main", "header")'),
-  width: import_zod12.z.enum(["small", "medium", "large", "full"]).optional(),
-  components: import_zod12.z.array(import_zod12.z.lazy(() => PageComponentSchema)).describe("Components in this region")
+var import_zod14 = require("zod");
+var PageRegionSchema = import_zod14.z.object({
+  name: import_zod14.z.string().describe('Region name (e.g. "sidebar", "main", "header")'),
+  width: import_zod14.z.enum(["small", "medium", "large", "full"]).optional(),
+  components: import_zod14.z.array(import_zod14.z.lazy(() => PageComponentSchema)).describe("Components in this region")
 });
-var PageComponentType = import_zod12.z.enum([
+var PageComponentType = import_zod14.z.enum([
   // Structure
   "page:header",
   "page:footer",
@@ -1269,201 +1552,207 @@ var PageComponentType = import_zod12.z.enum([
   "ai:chat_window",
   "ai:suggestion"
 ]);
-var PageComponentSchema = import_zod12.z.object({
+var PageComponentSchema = import_zod14.z.object({
   /** Definition */
-  type: import_zod12.z.union([
+  type: import_zod14.z.union([
     PageComponentType,
-    import_zod12.z.string()
+    import_zod14.z.string()
   ]).describe("Component Type (Standard enum or custom string)"),
-  id: import_zod12.z.string().optional().describe("Unique instance ID"),
+  id: import_zod14.z.string().optional().describe("Unique instance ID"),
   /** Configuration */
-  label: import_zod12.z.string().optional(),
-  properties: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).describe("Component props passed to the widget. See component.zod.ts for schemas."),
+  label: I18nLabelSchema.optional(),
+  properties: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()).describe("Component props passed to the widget. See component.zod.ts for schemas."),
   /** 
    * Event Handlers 
    * Map event names to Action expressions.
    * "onClick": "set_variable('userId', $event.id)"
    * "onRowSelect": "navigate_to('page_detail', { id: $event.id })"
    */
-  events: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string()).optional().describe("Event handlers map"),
+  events: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).optional().describe("Event handlers map"),
   /** Appearance */
-  style: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string()).optional().describe("Inline styles or utility classes"),
-  className: import_zod12.z.string().optional().describe("CSS class names"),
+  style: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.string()).optional().describe("Inline styles or utility classes"),
+  className: import_zod14.z.string().optional().describe("CSS class names"),
   /** Visibility Rule */
-  visibility: import_zod12.z.string().optional().describe("Visibility filter/formula")
-});
-var PageVariableSchema = import_zod12.z.object({
-  name: import_zod12.z.string().describe("Variable name"),
-  type: import_zod12.z.enum(["string", "number", "boolean", "object", "array"]).default("string"),
-  defaultValue: import_zod12.z.unknown().optional()
-});
-var PageSchema = import_zod12.z.object({
+  visibility: import_zod14.z.string().optional().describe("Visibility filter/formula"),
+  /** Responsive layout overrides per breakpoint */
+  responsive: ResponsiveConfigSchema.optional().describe("Responsive layout configuration"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
+});
+var PageVariableSchema = import_zod14.z.object({
+  name: import_zod14.z.string().describe("Variable name"),
+  type: import_zod14.z.enum(["string", "number", "boolean", "object", "array"]).default("string"),
+  defaultValue: import_zod14.z.unknown().optional()
+});
+var PageSchema = import_zod14.z.object({
   name: SnakeCaseIdentifierSchema.describe("Page unique name (lowercase snake_case)"),
-  label: import_zod12.z.string(),
-  description: import_zod12.z.string().optional(),
+  label: I18nLabelSchema,
+  description: I18nLabelSchema.optional(),
   /** Page Type */
-  type: import_zod12.z.enum(["record", "home", "app", "utility"]).default("record"),
+  type: import_zod14.z.enum(["record", "home", "app", "utility"]).default("record"),
   /** Page State Definitions */
-  variables: import_zod12.z.array(PageVariableSchema).optional().describe("Local page state variables"),
+  variables: import_zod14.z.array(PageVariableSchema).optional().describe("Local page state variables"),
   /** Context */
-  object: import_zod12.z.string().optional().describe("Bound object (for Record pages)"),
+  object: import_zod14.z.string().optional().describe("Bound object (for Record pages)"),
   /** Layout Template */
-  template: import_zod12.z.string().default("default").describe('Layout template name (e.g. "header-sidebar-main")'),
+  template: import_zod14.z.string().default("default").describe('Layout template name (e.g. "header-sidebar-main")'),
   /** Regions & Content */
-  regions: import_zod12.z.array(PageRegionSchema).describe("Defined regions with components"),
+  regions: import_zod14.z.array(PageRegionSchema).describe("Defined regions with components"),
   /** Activation */
-  isDefault: import_zod12.z.boolean().default(false),
-  assignedProfiles: import_zod12.z.array(import_zod12.z.string()).optional()
+  isDefault: import_zod14.z.boolean().default(false),
+  assignedProfiles: import_zod14.z.array(import_zod14.z.string()).optional(),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
 });
 
 // src/ui/widget.zod.ts
-var import_zod13 = require("zod");
-var WidgetLifecycleSchema = import_zod13.z.object({
+var import_zod15 = require("zod");
+var WidgetLifecycleSchema = import_zod15.z.object({
   /**
    * Called when widget is mounted/rendered for the first time
    * Use for initialization, setting up event listeners, loading data, etc.
    * 
    * @example "initializeDatePicker(); loadOptions();"
    */
-  onMount: import_zod13.z.string().optional().describe("Initialization code when widget mounts"),
+  onMount: import_zod15.z.string().optional().describe("Initialization code when widget mounts"),
   /**
    * Called when widget props change
    * Receives previous props for comparison
    * 
    * @example "if (prevProps.value !== props.value) { updateDisplay() }"
    */
-  onUpdate: import_zod13.z.string().optional().describe("Code to run when props change"),
+  onUpdate: import_zod15.z.string().optional().describe("Code to run when props change"),
   /**
    * Called when widget is about to be removed from DOM
    * Use for cleanup, removing event listeners, canceling timers, etc.
    * 
    * @example "destroyDatePicker(); cancelPendingRequests();"
    */
-  onUnmount: import_zod13.z.string().optional().describe("Cleanup code when widget unmounts"),
+  onUnmount: import_zod15.z.string().optional().describe("Cleanup code when widget unmounts"),
   /**
    * Custom validation logic for this widget
    * Should return error message string if invalid, null/undefined if valid
    * 
    * @example "return value && value.length >= 10 ? null : 'Minimum 10 characters'"
    */
-  onValidate: import_zod13.z.string().optional().describe("Custom validation logic"),
+  onValidate: import_zod15.z.string().optional().describe("Custom validation logic"),
   /**
    * Called when widget receives focus
    * 
    * @example "highlightField(); logFocusEvent();"
    */
-  onFocus: import_zod13.z.string().optional().describe("Code to run on focus"),
+  onFocus: import_zod15.z.string().optional().describe("Code to run on focus"),
   /**
    * Called when widget loses focus
    * 
    * @example "validateField(); saveFieldState();"
    */
-  onBlur: import_zod13.z.string().optional().describe("Code to run on blur"),
+  onBlur: import_zod15.z.string().optional().describe("Code to run on blur"),
   /**
    * Called on any error in the widget
    * 
    * @example "logError(error); showErrorNotification();"
    */
-  onError: import_zod13.z.string().optional().describe("Error handling code")
+  onError: import_zod15.z.string().optional().describe("Error handling code")
 });
-var WidgetEventSchema = import_zod13.z.object({
+var WidgetEventSchema = import_zod15.z.object({
   /**
    * Event name
    * Should be lowercase, dash-separated for consistency
    * 
    * @example "value-change", "item-selected", "search-complete"
    */
-  name: import_zod13.z.string().describe("Event name"),
+  name: import_zod15.z.string().describe("Event name"),
   /**
    * Event label for documentation
    */
-  label: import_zod13.z.string().optional().describe("Human-readable event label"),
+  label: I18nLabelSchema.optional().describe("Human-readable event label"),
   /**
    * Event description
    */
-  description: import_zod13.z.string().optional().describe("Event description and usage"),
+  description: I18nLabelSchema.optional().describe("Event description and usage"),
   /**
    * Whether event bubbles up through the DOM hierarchy
    * 
    * @default false
    */
-  bubbles: import_zod13.z.boolean().default(false).describe("Whether event bubbles"),
+  bubbles: import_zod15.z.boolean().default(false).describe("Whether event bubbles"),
   /**
    * Whether event can be cancelled
    * 
    * @default false
    */
-  cancelable: import_zod13.z.boolean().default(false).describe("Whether event is cancelable"),
+  cancelable: import_zod15.z.boolean().default(false).describe("Whether event is cancelable"),
   /**
    * Event payload schema
    * Defines the data structure sent with the event
    * 
    * @example { userId: 'string', timestamp: 'number' }
    */
-  payload: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional().describe("Event payload schema")
+  payload: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional().describe("Event payload schema")
 });
-var WidgetPropertySchema = import_zod13.z.object({
+var WidgetPropertySchema = import_zod15.z.object({
   /**
    * Property name
    * Should be camelCase following ObjectStack conventions
    */
-  name: import_zod13.z.string().describe("Property name (camelCase)"),
+  name: import_zod15.z.string().describe("Property name (camelCase)"),
   /**
    * Property label for UI
    */
-  label: import_zod13.z.string().optional().describe("Human-readable label"),
+  label: I18nLabelSchema.optional().describe("Human-readable label"),
   /**
    * Property data type
    * 
    * @example "string", "number", "boolean", "array", "object", "function"
    */
-  type: import_zod13.z.enum(["string", "number", "boolean", "array", "object", "function", "any"]).describe("TypeScript type"),
+  type: import_zod15.z.enum(["string", "number", "boolean", "array", "object", "function", "any"]).describe("TypeScript type"),
   /**
    * Whether property is required
    * 
    * @default false
    */
-  required: import_zod13.z.boolean().default(false).describe("Whether property is required"),
+  required: import_zod15.z.boolean().default(false).describe("Whether property is required"),
   /**
    * Default value for the property
    */
-  default: import_zod13.z.unknown().optional().describe("Default value"),
+  default: import_zod15.z.unknown().optional().describe("Default value"),
   /**
    * Property description
    */
-  description: import_zod13.z.string().optional().describe("Property description"),
+  description: I18nLabelSchema.optional().describe("Property description"),
   /**
    * Property validation schema
    * Can include min/max, regex, enum values, etc.
    */
-  validation: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional().describe("Validation rules"),
+  validation: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional().describe("Validation rules"),
   /**
    * Property category for grouping in UI
    */
-  category: import_zod13.z.string().optional().describe("Property category")
+  category: import_zod15.z.string().optional().describe("Property category")
 });
-var WidgetSourceSchema = import_zod13.z.discriminatedUnion("type", [
+var WidgetSourceSchema = import_zod15.z.discriminatedUnion("type", [
   // NPM Registry (standard)
-  import_zod13.z.object({
-    type: import_zod13.z.literal("npm"),
-    packageName: import_zod13.z.string().describe("NPM package name"),
-    version: import_zod13.z.string().default("latest"),
-    exportName: import_zod13.z.string().optional().describe("Named export (default: default)")
+  import_zod15.z.object({
+    type: import_zod15.z.literal("npm"),
+    packageName: import_zod15.z.string().describe("NPM package name"),
+    version: import_zod15.z.string().default("latest"),
+    exportName: import_zod15.z.string().optional().describe("Named export (default: default)")
   }),
   // Module Federation (Remote)
-  import_zod13.z.object({
-    type: import_zod13.z.literal("remote"),
-    url: import_zod13.z.string().url().describe("Remote entry URL (.js)"),
-    moduleName: import_zod13.z.string().describe("Exposed module name"),
-    scope: import_zod13.z.string().describe("Remote scope name")
+  import_zod15.z.object({
+    type: import_zod15.z.literal("remote"),
+    url: import_zod15.z.string().url().describe("Remote entry URL (.js)"),
+    moduleName: import_zod15.z.string().describe("Exposed module name"),
+    scope: import_zod15.z.string().describe("Remote scope name")
   }),
   // Inline Code (Simple scripts)
-  import_zod13.z.object({
-    type: import_zod13.z.literal("inline"),
-    code: import_zod13.z.string().describe("JavaScript code body")
+  import_zod15.z.object({
+    type: import_zod15.z.literal("inline"),
+    code: import_zod15.z.string().describe("JavaScript code body")
   })
 ]);
-var WidgetManifestSchema = import_zod13.z.object({
+var WidgetManifestSchema = import_zod15.z.object({
   /**
    * Widget identifier (snake_case)
    */
@@ -1471,33 +1760,33 @@ var WidgetManifestSchema = import_zod13.z.object({
   /**
    * Human-readable widget name
    */
-  label: import_zod13.z.string().describe("Widget display name"),
+  label: I18nLabelSchema.describe("Widget display name"),
   /**
    * Widget description
    */
-  description: import_zod13.z.string().optional().describe("Widget description"),
+  description: I18nLabelSchema.optional().describe("Widget description"),
   /**
    * Widget version (semver)
    */
-  version: import_zod13.z.string().optional().describe("Widget version (semver)"),
+  version: import_zod15.z.string().optional().describe("Widget version (semver)"),
   /**
    * Widget author/organization
    */
-  author: import_zod13.z.string().optional().describe("Widget author"),
+  author: import_zod15.z.string().optional().describe("Widget author"),
   /**
    * Icon name or URL
    */
-  icon: import_zod13.z.string().optional().describe("Widget icon"),
+  icon: import_zod15.z.string().optional().describe("Widget icon"),
   /**
    * Field types this widget supports
    * 
    * @example ["text", "email", "url"]
    */
-  fieldTypes: import_zod13.z.array(import_zod13.z.string()).optional().describe("Supported field types"),
+  fieldTypes: import_zod15.z.array(import_zod15.z.string()).optional().describe("Supported field types"),
   /**
    * Widget category for organization
    */
-  category: import_zod13.z.enum(["input", "display", "picker", "editor", "custom"]).default("custom").describe("Widget category"),
+  category: import_zod15.z.enum(["input", "display", "picker", "editor", "custom"]).default("custom").describe("Widget category"),
   /**
    * Widget lifecycle hooks
    */
@@ -1505,11 +1794,11 @@ var WidgetManifestSchema = import_zod13.z.object({
   /**
    * Custom events this widget emits
    */
-  events: import_zod13.z.array(WidgetEventSchema).optional().describe("Custom events"),
+  events: import_zod15.z.array(WidgetEventSchema).optional().describe("Custom events"),
   /**
    * Widget configuration properties
    */
-  properties: import_zod13.z.array(WidgetPropertySchema).optional().describe("Configuration properties"),
+  properties: import_zod15.z.array(WidgetPropertySchema).optional().describe("Configuration properties"),
   /**
    * Widget implementation
    * Defines how to load the widget code
@@ -1519,56 +1808,60 @@ var WidgetManifestSchema = import_zod13.z.object({
    * Widget dependencies
    * External libraries or scripts needed
    */
-  dependencies: import_zod13.z.array(import_zod13.z.object({
-    name: import_zod13.z.string(),
-    version: import_zod13.z.string().optional(),
-    url: import_zod13.z.string().url().optional()
+  dependencies: import_zod15.z.array(import_zod15.z.object({
+    name: import_zod15.z.string(),
+    version: import_zod15.z.string().optional(),
+    url: import_zod15.z.string().url().optional()
   })).optional().describe("Widget dependencies"),
   /**
    * Widget screenshots for showcase
    */
-  screenshots: import_zod13.z.array(import_zod13.z.string().url()).optional().describe("Screenshot URLs"),
+  screenshots: import_zod15.z.array(import_zod15.z.string().url()).optional().describe("Screenshot URLs"),
   /**
    * Widget documentation URL
    */
-  documentation: import_zod13.z.string().url().optional().describe("Documentation URL"),
+  documentation: import_zod15.z.string().url().optional().describe("Documentation URL"),
   /**
    * License information
    */
-  license: import_zod13.z.string().optional().describe("License (SPDX identifier)"),
+  license: import_zod15.z.string().optional().describe("License (SPDX identifier)"),
   /**
    * Tags for discovery
    */
-  tags: import_zod13.z.array(import_zod13.z.string()).optional().describe("Tags for categorization")
+  tags: import_zod15.z.array(import_zod15.z.string()).optional().describe("Tags for categorization"),
+  /** ARIA accessibility attributes */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes"),
+  /** Performance optimization settings */
+  performance: PerformanceConfigSchema.optional().describe("Performance optimization settings")
 });
-var FieldWidgetPropsSchema = import_zod13.z.object({
+var FieldWidgetPropsSchema = import_zod15.z.object({
   /**
    * Current field value.
    * Type depends on the field type (string, number, boolean, array, object, etc.)
    */
-  value: import_zod13.z.unknown().describe("Current field value"),
+  value: import_zod15.z.unknown().describe("Current field value"),
   /**
    * Callback function to update the field value.
    * Should be called when user interaction changes the value.
    * 
    * @param newValue - The new value to set
    */
-  onChange: import_zod13.z.function().input(import_zod13.z.tuple([import_zod13.z.unknown()])).output(import_zod13.z.void()).describe("Callback to update field value"),
+  onChange: import_zod15.z.function().input(import_zod15.z.tuple([import_zod15.z.unknown()])).output(import_zod15.z.void()).describe("Callback to update field value"),
   /**
    * Whether the field is in read-only mode.
    * When true, the widget should display the value but not allow editing.
    */
-  readonly: import_zod13.z.boolean().default(false).describe("Read-only mode flag"),
+  readonly: import_zod15.z.boolean().default(false).describe("Read-only mode flag"),
   /**
    * Whether the field is required.
    * Widget should indicate required state visually and validate accordingly.
    */
-  required: import_zod13.z.boolean().default(false).describe("Required field flag"),
+  required: import_zod15.z.boolean().default(false).describe("Required field flag"),
   /**
    * Validation error message to display.
    * When present, widget should display the error in its UI.
    */
-  error: import_zod13.z.string().optional().describe("Validation error message"),
+  error: import_zod15.z.string().optional().describe("Validation error message"),
   /**
    * Complete field definition from the schema.
    * Contains metadata like type, constraints, options, etc.
@@ -1578,57 +1871,63 @@ var FieldWidgetPropsSchema = import_zod13.z.object({
    * The complete record/document being edited.
    * Useful for conditional logic and cross-field dependencies.
    */
-  record: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional().describe("Complete record data"),
+  record: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional().describe("Complete record data"),
   /**
    * Custom options passed to the widget.
    * Can contain widget-specific configuration like themes, behaviors, etc.
    */
-  options: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional().describe("Custom widget options")
+  options: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.unknown()).optional().describe("Custom widget options")
 });
 
 // src/ui/component.zod.ts
-var import_zod14 = require("zod");
-var EmptyProps = import_zod14.z.object({});
-var PageHeaderProps = import_zod14.z.object({
-  title: import_zod14.z.string().describe("Page title"),
-  subtitle: import_zod14.z.string().optional().describe("Page subtitle"),
-  icon: import_zod14.z.string().optional().describe("Icon name"),
-  breadcrumb: import_zod14.z.boolean().default(true).describe("Show breadcrumb"),
-  actions: import_zod14.z.array(import_zod14.z.string()).optional().describe("Action IDs to show in header")
-});
-var PageTabsProps = import_zod14.z.object({
-  type: import_zod14.z.enum(["line", "card", "pill"]).default("line"),
-  position: import_zod14.z.enum(["top", "left"]).default("top"),
-  items: import_zod14.z.array(import_zod14.z.object({
-    label: import_zod14.z.string(),
-    icon: import_zod14.z.string().optional(),
-    children: import_zod14.z.array(import_zod14.z.unknown()).describe("Child components")
-  }))
-});
-var PageCardProps = import_zod14.z.object({
-  title: import_zod14.z.string().optional(),
-  bordered: import_zod14.z.boolean().default(true),
-  actions: import_zod14.z.array(import_zod14.z.string()).optional(),
+var import_zod16 = require("zod");
+var EmptyProps = import_zod16.z.object({});
+var PageHeaderProps = import_zod16.z.object({
+  title: I18nLabelSchema.describe("Page title"),
+  subtitle: I18nLabelSchema.optional().describe("Page subtitle"),
+  icon: import_zod16.z.string().optional().describe("Icon name"),
+  breadcrumb: import_zod16.z.boolean().default(true).describe("Show breadcrumb"),
+  actions: import_zod16.z.array(import_zod16.z.string()).optional().describe("Action IDs to show in header"),
+  /** ARIA accessibility */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
+});
+var PageTabsProps = import_zod16.z.object({
+  type: import_zod16.z.enum(["line", "card", "pill"]).default("line"),
+  position: import_zod16.z.enum(["top", "left"]).default("top"),
+  items: import_zod16.z.array(import_zod16.z.object({
+    label: I18nLabelSchema,
+    icon: import_zod16.z.string().optional(),
+    children: import_zod16.z.array(import_zod16.z.unknown()).describe("Child components")
+  })),
+  /** ARIA accessibility */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
+});
+var PageCardProps = import_zod16.z.object({
+  title: I18nLabelSchema.optional(),
+  bordered: import_zod16.z.boolean().default(true),
+  actions: import_zod16.z.array(import_zod16.z.string()).optional(),
   /** Slot for nested content in the Card body */
-  body: import_zod14.z.array(import_zod14.z.unknown()).optional().describe("Card content components (slot)"),
+  body: import_zod16.z.array(import_zod16.z.unknown()).optional().describe("Card content components (slot)"),
   /** Slot for footer content */
-  footer: import_zod14.z.array(import_zod14.z.unknown()).optional().describe("Card footer components (slot)")
+  footer: import_zod16.z.array(import_zod16.z.unknown()).optional().describe("Card footer components (slot)"),
+  /** ARIA accessibility */
+  aria: AriaPropsSchema.optional().describe("ARIA accessibility attributes")
 });
-var RecordDetailsProps = import_zod14.z.object({
-  columns: import_zod14.z.enum(["1", "2", "3", "4"]).default("2"),
-  layout: import_zod14.z.enum(["auto", "custom"]).default("auto"),
+var RecordDetailsProps = import_zod16.z.object({
+  columns: import_zod16.z.enum(["1", "2", "3", "4"]).default("2"),
+  layout: import_zod16.z.enum(["auto", "custom"]).default("auto"),
   // If custom layout
-  sections: import_zod14.z.array(import_zod14.z.string()).optional().describe("Section IDs to show")
+  sections: import_zod16.z.array(import_zod16.z.string()).optional().describe("Section IDs to show")
 });
-var RecordRelatedListProps = import_zod14.z.object({
-  objectName: import_zod14.z.string().describe("Related object name"),
-  relationshipField: import_zod14.z.string().describe("Field on related object that points to this record"),
-  columns: import_zod14.z.array(import_zod14.z.string()).describe("Fields to display"),
-  sort: import_zod14.z.string().optional(),
-  limit: import_zod14.z.number().default(5)
+var RecordRelatedListProps = import_zod16.z.object({
+  objectName: import_zod16.z.string().describe("Related object name"),
+  relationshipField: import_zod16.z.string().describe("Field on related object that points to this record"),
+  columns: import_zod16.z.array(import_zod16.z.string()).describe("Fields to display"),
+  sort: import_zod16.z.string().optional(),
+  limit: import_zod16.z.number().default(5)
 });
-var RecordHighlightsProps = import_zod14.z.object({
-  fields: import_zod14.z.array(import_zod14.z.string()).min(1).max(7).describe("Key fields to highlights (max 7)")
+var RecordHighlightsProps = import_zod16.z.object({
+  fields: import_zod16.z.array(import_zod16.z.string()).min(1).max(7).describe("Key fields to highlights (max 7)")
 });
 var ComponentPropsMap = {
   // Structure
@@ -1655,142 +1954,223 @@ var ComponentPropsMap = {
   "global:notifications": EmptyProps,
   "user:profile": EmptyProps,
   // AI
-  "ai:chat_window": import_zod14.z.object({ mode: import_zod14.z.enum(["float", "sidebar", "inline"]).default("float") }),
-  "ai:suggestion": import_zod14.z.object({ context: import_zod14.z.string().optional() })
+  "ai:chat_window": import_zod16.z.object({ mode: import_zod16.z.enum(["float", "sidebar", "inline"]).default("float") }),
+  "ai:suggestion": import_zod16.z.object({ context: import_zod16.z.string().optional() })
 };
 
 // src/ui/theme.zod.ts
-var import_zod15 = require("zod");
-var ColorPaletteSchema = import_zod15.z.object({
-  primary: import_zod15.z.string().describe("Primary brand color (hex, rgb, or hsl)"),
-  secondary: import_zod15.z.string().optional().describe("Secondary brand color"),
-  accent: import_zod15.z.string().optional().describe("Accent color for highlights"),
-  success: import_zod15.z.string().optional().describe("Success state color (default: green)"),
-  warning: import_zod15.z.string().optional().describe("Warning state color (default: yellow)"),
-  error: import_zod15.z.string().optional().describe("Error state color (default: red)"),
-  info: import_zod15.z.string().optional().describe("Info state color (default: blue)"),
+var import_zod19 = require("zod");
+
+// src/ui/touch.zod.ts
+var import_zod17 = require("zod");
+var TouchTargetConfigSchema = import_zod17.z.object({
+  minWidth: import_zod17.z.number().default(44).describe("Minimum touch target width in pixels (WCAG 2.5.5: 44px)"),
+  minHeight: import_zod17.z.number().default(44).describe("Minimum touch target height in pixels (WCAG 2.5.5: 44px)"),
+  padding: import_zod17.z.number().optional().describe("Additional padding around touch target in pixels"),
+  hitSlop: import_zod17.z.object({
+    top: import_zod17.z.number().optional().describe("Extra hit area above the element"),
+    right: import_zod17.z.number().optional().describe("Extra hit area to the right of the element"),
+    bottom: import_zod17.z.number().optional().describe("Extra hit area below the element"),
+    left: import_zod17.z.number().optional().describe("Extra hit area to the left of the element")
+  }).optional().describe("Invisible hit area extension beyond the visible bounds")
+}).describe("Touch target sizing configuration (WCAG accessible)");
+var GestureTypeSchema = import_zod17.z.enum([
+  "swipe",
+  "pinch",
+  "long_press",
+  "double_tap",
+  "drag",
+  "rotate",
+  "pan"
+]).describe("Touch gesture type");
+var SwipeDirectionSchema = import_zod17.z.enum(["up", "down", "left", "right"]);
+var SwipeGestureConfigSchema = import_zod17.z.object({
+  direction: import_zod17.z.array(SwipeDirectionSchema).describe("Allowed swipe directions"),
+  threshold: import_zod17.z.number().optional().describe("Minimum distance in pixels to recognize swipe"),
+  velocity: import_zod17.z.number().optional().describe("Minimum velocity (px/ms) to trigger swipe")
+}).describe("Swipe gesture recognition settings");
+var PinchGestureConfigSchema = import_zod17.z.object({
+  minScale: import_zod17.z.number().optional().describe("Minimum scale factor (e.g., 0.5 for 50%)"),
+  maxScale: import_zod17.z.number().optional().describe("Maximum scale factor (e.g., 3.0 for 300%)")
+}).describe("Pinch/zoom gesture recognition settings");
+var LongPressGestureConfigSchema = import_zod17.z.object({
+  duration: import_zod17.z.number().default(500).describe("Hold duration in milliseconds to trigger long press"),
+  moveTolerance: import_zod17.z.number().optional().describe("Max movement in pixels allowed during press")
+}).describe("Long press gesture recognition settings");
+var GestureConfigSchema = import_zod17.z.object({
+  type: GestureTypeSchema.describe("Gesture type to configure"),
+  label: I18nLabelSchema.optional().describe("Descriptive label for the gesture action"),
+  enabled: import_zod17.z.boolean().default(true).describe("Whether this gesture is active"),
+  swipe: SwipeGestureConfigSchema.optional().describe("Swipe gesture settings (when type is swipe)"),
+  pinch: PinchGestureConfigSchema.optional().describe("Pinch gesture settings (when type is pinch)"),
+  longPress: LongPressGestureConfigSchema.optional().describe("Long press settings (when type is long_press)")
+}).describe("Per-gesture configuration");
+var TouchInteractionSchema = import_zod17.z.object({
+  gestures: import_zod17.z.array(GestureConfigSchema).optional().describe("Configured gesture recognizers"),
+  touchTarget: TouchTargetConfigSchema.optional().describe("Touch target sizing and hit area"),
+  hapticFeedback: import_zod17.z.boolean().optional().describe("Enable haptic feedback on touch interactions")
+}).merge(AriaPropsSchema.partial()).describe("Touch and gesture interaction configuration");
+
+// src/ui/keyboard.zod.ts
+var import_zod18 = require("zod");
+var FocusTrapConfigSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean().default(false).describe("Enable focus trapping within this container"),
+  initialFocus: import_zod18.z.string().optional().describe("CSS selector for the element to focus on activation"),
+  returnFocus: import_zod18.z.boolean().default(true).describe("Return focus to trigger element on deactivation"),
+  escapeDeactivates: import_zod18.z.boolean().default(true).describe("Allow Escape key to deactivate the focus trap")
+}).describe("Focus trap configuration for modal-like containers");
+var KeyboardShortcutSchema = import_zod18.z.object({
+  key: import_zod18.z.string().describe('Key combination (e.g., "Ctrl+S", "Alt+N", "Escape")'),
+  action: import_zod18.z.string().describe("Action identifier to invoke when shortcut is triggered"),
+  description: I18nLabelSchema.optional().describe("Human-readable description of what the shortcut does"),
+  scope: import_zod18.z.enum(["global", "view", "form", "modal", "list"]).default("global").describe("Scope in which this shortcut is active")
+}).describe("Keyboard shortcut binding");
+var FocusManagementSchema = import_zod18.z.object({
+  tabOrder: import_zod18.z.enum(["auto", "manual"]).default("auto").describe("Tab order strategy: auto (DOM order) or manual (explicit tabIndex)"),
+  skipLinks: import_zod18.z.boolean().default(false).describe("Provide skip-to-content navigation links"),
+  focusVisible: import_zod18.z.boolean().default(true).describe("Show visible focus indicators for keyboard users"),
+  focusTrap: FocusTrapConfigSchema.optional().describe("Focus trap settings"),
+  arrowNavigation: import_zod18.z.boolean().default(false).describe("Enable arrow key navigation between focusable items")
+}).describe("Focus and tab navigation management");
+var KeyboardNavigationConfigSchema = import_zod18.z.object({
+  shortcuts: import_zod18.z.array(KeyboardShortcutSchema).optional().describe("Registered keyboard shortcuts"),
+  focusManagement: FocusManagementSchema.optional().describe("Focus and tab order management"),
+  rovingTabindex: import_zod18.z.boolean().default(false).describe("Enable roving tabindex pattern for composite widgets")
+}).merge(AriaPropsSchema.partial()).describe("Keyboard navigation and shortcut configuration");
+
+// src/ui/theme.zod.ts
+var ColorPaletteSchema = import_zod19.z.object({
+  primary: import_zod19.z.string().describe("Primary brand color (hex, rgb, or hsl)"),
+  secondary: import_zod19.z.string().optional().describe("Secondary brand color"),
+  accent: import_zod19.z.string().optional().describe("Accent color for highlights"),
+  success: import_zod19.z.string().optional().describe("Success state color (default: green)"),
+  warning: import_zod19.z.string().optional().describe("Warning state color (default: yellow)"),
+  error: import_zod19.z.string().optional().describe("Error state color (default: red)"),
+  info: import_zod19.z.string().optional().describe("Info state color (default: blue)"),
   // Neutral colors
-  background: import_zod15.z.string().optional().describe("Background color"),
-  surface: import_zod15.z.string().optional().describe("Surface/card background color"),
-  text: import_zod15.z.string().optional().describe("Primary text color"),
-  textSecondary: import_zod15.z.string().optional().describe("Secondary text color"),
-  border: import_zod15.z.string().optional().describe("Border color"),
-  disabled: import_zod15.z.string().optional().describe("Disabled state color"),
+  background: import_zod19.z.string().optional().describe("Background color"),
+  surface: import_zod19.z.string().optional().describe("Surface/card background color"),
+  text: import_zod19.z.string().optional().describe("Primary text color"),
+  textSecondary: import_zod19.z.string().optional().describe("Secondary text color"),
+  border: import_zod19.z.string().optional().describe("Border color"),
+  disabled: import_zod19.z.string().optional().describe("Disabled state color"),
   // Color variants (shades)
-  primaryLight: import_zod15.z.string().optional().describe("Lighter shade of primary"),
-  primaryDark: import_zod15.z.string().optional().describe("Darker shade of primary"),
-  secondaryLight: import_zod15.z.string().optional().describe("Lighter shade of secondary"),
-  secondaryDark: import_zod15.z.string().optional().describe("Darker shade of secondary")
-});
-var TypographySchema = import_zod15.z.object({
-  fontFamily: import_zod15.z.object({
-    base: import_zod15.z.string().optional().describe("Base font family (default: system fonts)"),
-    heading: import_zod15.z.string().optional().describe("Heading font family"),
-    mono: import_zod15.z.string().optional().describe("Monospace font family for code")
+  primaryLight: import_zod19.z.string().optional().describe("Lighter shade of primary"),
+  primaryDark: import_zod19.z.string().optional().describe("Darker shade of primary"),
+  secondaryLight: import_zod19.z.string().optional().describe("Lighter shade of secondary"),
+  secondaryDark: import_zod19.z.string().optional().describe("Darker shade of secondary")
+});
+var TypographySchema = import_zod19.z.object({
+  fontFamily: import_zod19.z.object({
+    base: import_zod19.z.string().optional().describe("Base font family (default: system fonts)"),
+    heading: import_zod19.z.string().optional().describe("Heading font family"),
+    mono: import_zod19.z.string().optional().describe("Monospace font family for code")
   }).optional(),
-  fontSize: import_zod15.z.object({
-    xs: import_zod15.z.string().optional().describe("Extra small font size (e.g., 0.75rem)"),
-    sm: import_zod15.z.string().optional().describe("Small font size (e.g., 0.875rem)"),
-    base: import_zod15.z.string().optional().describe("Base font size (e.g., 1rem)"),
-    lg: import_zod15.z.string().optional().describe("Large font size (e.g., 1.125rem)"),
-    xl: import_zod15.z.string().optional().describe("Extra large font size (e.g., 1.25rem)"),
-    "2xl": import_zod15.z.string().optional().describe("2X large font size (e.g., 1.5rem)"),
-    "3xl": import_zod15.z.string().optional().describe("3X large font size (e.g., 1.875rem)"),
-    "4xl": import_zod15.z.string().optional().describe("4X large font size (e.g., 2.25rem)")
+  fontSize: import_zod19.z.object({
+    xs: import_zod19.z.string().optional().describe("Extra small font size (e.g., 0.75rem)"),
+    sm: import_zod19.z.string().optional().describe("Small font size (e.g., 0.875rem)"),
+    base: import_zod19.z.string().optional().describe("Base font size (e.g., 1rem)"),
+    lg: import_zod19.z.string().optional().describe("Large font size (e.g., 1.125rem)"),
+    xl: import_zod19.z.string().optional().describe("Extra large font size (e.g., 1.25rem)"),
+    "2xl": import_zod19.z.string().optional().describe("2X large font size (e.g., 1.5rem)"),
+    "3xl": import_zod19.z.string().optional().describe("3X large font size (e.g., 1.875rem)"),
+    "4xl": import_zod19.z.string().optional().describe("4X large font size (e.g., 2.25rem)")
   }).optional(),
-  fontWeight: import_zod15.z.object({
-    light: import_zod15.z.number().optional().describe("Light weight (default: 300)"),
-    normal: import_zod15.z.number().optional().describe("Normal weight (default: 400)"),
-    medium: import_zod15.z.number().optional().describe("Medium weight (default: 500)"),
-    semibold: import_zod15.z.number().optional().describe("Semibold weight (default: 600)"),
-    bold: import_zod15.z.number().optional().describe("Bold weight (default: 700)")
+  fontWeight: import_zod19.z.object({
+    light: import_zod19.z.number().optional().describe("Light weight (default: 300)"),
+    normal: import_zod19.z.number().optional().describe("Normal weight (default: 400)"),
+    medium: import_zod19.z.number().optional().describe("Medium weight (default: 500)"),
+    semibold: import_zod19.z.number().optional().describe("Semibold weight (default: 600)"),
+    bold: import_zod19.z.number().optional().describe("Bold weight (default: 700)")
   }).optional(),
-  lineHeight: import_zod15.z.object({
-    tight: import_zod15.z.string().optional().describe("Tight line height (e.g., 1.25)"),
-    normal: import_zod15.z.string().optional().describe("Normal line height (e.g., 1.5)"),
-    relaxed: import_zod15.z.string().optional().describe("Relaxed line height (e.g., 1.75)"),
-    loose: import_zod15.z.string().optional().describe("Loose line height (e.g., 2)")
+  lineHeight: import_zod19.z.object({
+    tight: import_zod19.z.string().optional().describe("Tight line height (e.g., 1.25)"),
+    normal: import_zod19.z.string().optional().describe("Normal line height (e.g., 1.5)"),
+    relaxed: import_zod19.z.string().optional().describe("Relaxed line height (e.g., 1.75)"),
+    loose: import_zod19.z.string().optional().describe("Loose line height (e.g., 2)")
   }).optional(),
-  letterSpacing: import_zod15.z.object({
-    tighter: import_zod15.z.string().optional().describe("Tighter letter spacing (e.g., -0.05em)"),
-    tight: import_zod15.z.string().optional().describe("Tight letter spacing (e.g., -0.025em)"),
-    normal: import_zod15.z.string().optional().describe("Normal letter spacing (e.g., 0)"),
-    wide: import_zod15.z.string().optional().describe("Wide letter spacing (e.g., 0.025em)"),
-    wider: import_zod15.z.string().optional().describe("Wider letter spacing (e.g., 0.05em)")
+  letterSpacing: import_zod19.z.object({
+    tighter: import_zod19.z.string().optional().describe("Tighter letter spacing (e.g., -0.05em)"),
+    tight: import_zod19.z.string().optional().describe("Tight letter spacing (e.g., -0.025em)"),
+    normal: import_zod19.z.string().optional().describe("Normal letter spacing (e.g., 0)"),
+    wide: import_zod19.z.string().optional().describe("Wide letter spacing (e.g., 0.025em)"),
+    wider: import_zod19.z.string().optional().describe("Wider letter spacing (e.g., 0.05em)")
   }).optional()
 });
-var SpacingSchema = import_zod15.z.object({
-  "0": import_zod15.z.string().optional().describe("0 spacing (0)"),
-  "1": import_zod15.z.string().optional().describe("Spacing unit 1 (e.g., 0.25rem)"),
-  "2": import_zod15.z.string().optional().describe("Spacing unit 2 (e.g., 0.5rem)"),
-  "3": import_zod15.z.string().optional().describe("Spacing unit 3 (e.g., 0.75rem)"),
-  "4": import_zod15.z.string().optional().describe("Spacing unit 4 (e.g., 1rem)"),
-  "5": import_zod15.z.string().optional().describe("Spacing unit 5 (e.g., 1.25rem)"),
-  "6": import_zod15.z.string().optional().describe("Spacing unit 6 (e.g., 1.5rem)"),
-  "8": import_zod15.z.string().optional().describe("Spacing unit 8 (e.g., 2rem)"),
-  "10": import_zod15.z.string().optional().describe("Spacing unit 10 (e.g., 2.5rem)"),
-  "12": import_zod15.z.string().optional().describe("Spacing unit 12 (e.g., 3rem)"),
-  "16": import_zod15.z.string().optional().describe("Spacing unit 16 (e.g., 4rem)"),
-  "20": import_zod15.z.string().optional().describe("Spacing unit 20 (e.g., 5rem)"),
-  "24": import_zod15.z.string().optional().describe("Spacing unit 24 (e.g., 6rem)")
-});
-var BorderRadiusSchema = import_zod15.z.object({
-  none: import_zod15.z.string().optional().describe("No border radius (0)"),
-  sm: import_zod15.z.string().optional().describe("Small border radius (e.g., 0.125rem)"),
-  base: import_zod15.z.string().optional().describe("Base border radius (e.g., 0.25rem)"),
-  md: import_zod15.z.string().optional().describe("Medium border radius (e.g., 0.375rem)"),
-  lg: import_zod15.z.string().optional().describe("Large border radius (e.g., 0.5rem)"),
-  xl: import_zod15.z.string().optional().describe("Extra large border radius (e.g., 0.75rem)"),
-  "2xl": import_zod15.z.string().optional().describe("2X large border radius (e.g., 1rem)"),
-  full: import_zod15.z.string().optional().describe("Full border radius (50%)")
-});
-var ShadowSchema = import_zod15.z.object({
-  none: import_zod15.z.string().optional().describe("No shadow"),
-  sm: import_zod15.z.string().optional().describe("Small shadow"),
-  base: import_zod15.z.string().optional().describe("Base shadow"),
-  md: import_zod15.z.string().optional().describe("Medium shadow"),
-  lg: import_zod15.z.string().optional().describe("Large shadow"),
-  xl: import_zod15.z.string().optional().describe("Extra large shadow"),
-  "2xl": import_zod15.z.string().optional().describe("2X large shadow"),
-  inner: import_zod15.z.string().optional().describe("Inner shadow (inset)")
-});
-var BreakpointsSchema = import_zod15.z.object({
-  xs: import_zod15.z.string().optional().describe("Extra small breakpoint (e.g., 480px)"),
-  sm: import_zod15.z.string().optional().describe("Small breakpoint (e.g., 640px)"),
-  md: import_zod15.z.string().optional().describe("Medium breakpoint (e.g., 768px)"),
-  lg: import_zod15.z.string().optional().describe("Large breakpoint (e.g., 1024px)"),
-  xl: import_zod15.z.string().optional().describe("Extra large breakpoint (e.g., 1280px)"),
-  "2xl": import_zod15.z.string().optional().describe("2X large breakpoint (e.g., 1536px)")
-});
-var AnimationSchema = import_zod15.z.object({
-  duration: import_zod15.z.object({
-    fast: import_zod15.z.string().optional().describe("Fast animation (e.g., 150ms)"),
-    base: import_zod15.z.string().optional().describe("Base animation (e.g., 300ms)"),
-    slow: import_zod15.z.string().optional().describe("Slow animation (e.g., 500ms)")
+var SpacingSchema = import_zod19.z.object({
+  "0": import_zod19.z.string().optional().describe("0 spacing (0)"),
+  "1": import_zod19.z.string().optional().describe("Spacing unit 1 (e.g., 0.25rem)"),
+  "2": import_zod19.z.string().optional().describe("Spacing unit 2 (e.g., 0.5rem)"),
+  "3": import_zod19.z.string().optional().describe("Spacing unit 3 (e.g., 0.75rem)"),
+  "4": import_zod19.z.string().optional().describe("Spacing unit 4 (e.g., 1rem)"),
+  "5": import_zod19.z.string().optional().describe("Spacing unit 5 (e.g., 1.25rem)"),
+  "6": import_zod19.z.string().optional().describe("Spacing unit 6 (e.g., 1.5rem)"),
+  "8": import_zod19.z.string().optional().describe("Spacing unit 8 (e.g., 2rem)"),
+  "10": import_zod19.z.string().optional().describe("Spacing unit 10 (e.g., 2.5rem)"),
+  "12": import_zod19.z.string().optional().describe("Spacing unit 12 (e.g., 3rem)"),
+  "16": import_zod19.z.string().optional().describe("Spacing unit 16 (e.g., 4rem)"),
+  "20": import_zod19.z.string().optional().describe("Spacing unit 20 (e.g., 5rem)"),
+  "24": import_zod19.z.string().optional().describe("Spacing unit 24 (e.g., 6rem)")
+});
+var BorderRadiusSchema = import_zod19.z.object({
+  none: import_zod19.z.string().optional().describe("No border radius (0)"),
+  sm: import_zod19.z.string().optional().describe("Small border radius (e.g., 0.125rem)"),
+  base: import_zod19.z.string().optional().describe("Base border radius (e.g., 0.25rem)"),
+  md: import_zod19.z.string().optional().describe("Medium border radius (e.g., 0.375rem)"),
+  lg: import_zod19.z.string().optional().describe("Large border radius (e.g., 0.5rem)"),
+  xl: import_zod19.z.string().optional().describe("Extra large border radius (e.g., 0.75rem)"),
+  "2xl": import_zod19.z.string().optional().describe("2X large border radius (e.g., 1rem)"),
+  full: import_zod19.z.string().optional().describe("Full border radius (50%)")
+});
+var ShadowSchema = import_zod19.z.object({
+  none: import_zod19.z.string().optional().describe("No shadow"),
+  sm: import_zod19.z.string().optional().describe("Small shadow"),
+  base: import_zod19.z.string().optional().describe("Base shadow"),
+  md: import_zod19.z.string().optional().describe("Medium shadow"),
+  lg: import_zod19.z.string().optional().describe("Large shadow"),
+  xl: import_zod19.z.string().optional().describe("Extra large shadow"),
+  "2xl": import_zod19.z.string().optional().describe("2X large shadow"),
+  inner: import_zod19.z.string().optional().describe("Inner shadow (inset)")
+});
+var BreakpointsSchema = import_zod19.z.object({
+  xs: import_zod19.z.string().optional().describe("Extra small breakpoint (e.g., 480px)"),
+  sm: import_zod19.z.string().optional().describe("Small breakpoint (e.g., 640px)"),
+  md: import_zod19.z.string().optional().describe("Medium breakpoint (e.g., 768px)"),
+  lg: import_zod19.z.string().optional().describe("Large breakpoint (e.g., 1024px)"),
+  xl: import_zod19.z.string().optional().describe("Extra large breakpoint (e.g., 1280px)"),
+  "2xl": import_zod19.z.string().optional().describe("2X large breakpoint (e.g., 1536px)")
+});
+var AnimationSchema = import_zod19.z.object({
+  duration: import_zod19.z.object({
+    fast: import_zod19.z.string().optional().describe("Fast animation (e.g., 150ms)"),
+    base: import_zod19.z.string().optional().describe("Base animation (e.g., 300ms)"),
+    slow: import_zod19.z.string().optional().describe("Slow animation (e.g., 500ms)")
   }).optional(),
-  timing: import_zod15.z.object({
-    linear: import_zod15.z.string().optional().describe("Linear timing function"),
-    ease: import_zod15.z.string().optional().describe("Ease timing function"),
-    easeIn: import_zod15.z.string().optional().describe("Ease-in timing function"),
-    easeOut: import_zod15.z.string().optional().describe("Ease-out timing function"),
-    easeInOut: import_zod15.z.string().optional().describe("Ease-in-out timing function")
+  timing: import_zod19.z.object({
+    linear: import_zod19.z.string().optional().describe("Linear timing function"),
+    ease: import_zod19.z.string().optional().describe("Ease timing function"),
+    easeIn: import_zod19.z.string().optional().describe("Ease-in timing function"),
+    easeOut: import_zod19.z.string().optional().describe("Ease-out timing function"),
+    easeInOut: import_zod19.z.string().optional().describe("Ease-in-out timing function")
   }).optional()
 });
-var ZIndexSchema = import_zod15.z.object({
-  base: import_zod15.z.number().optional().describe("Base z-index (e.g., 0)"),
-  dropdown: import_zod15.z.number().optional().describe("Dropdown z-index (e.g., 1000)"),
-  sticky: import_zod15.z.number().optional().describe("Sticky z-index (e.g., 1020)"),
-  fixed: import_zod15.z.number().optional().describe("Fixed z-index (e.g., 1030)"),
-  modalBackdrop: import_zod15.z.number().optional().describe("Modal backdrop z-index (e.g., 1040)"),
-  modal: import_zod15.z.number().optional().describe("Modal z-index (e.g., 1050)"),
-  popover: import_zod15.z.number().optional().describe("Popover z-index (e.g., 1060)"),
-  tooltip: import_zod15.z.number().optional().describe("Tooltip z-index (e.g., 1070)")
-});
-var ThemeMode = import_zod15.z.enum(["light", "dark", "auto"]);
-var ThemeSchema = import_zod15.z.object({
+var ZIndexSchema = import_zod19.z.object({
+  base: import_zod19.z.number().optional().describe("Base z-index (e.g., 0)"),
+  dropdown: import_zod19.z.number().optional().describe("Dropdown z-index (e.g., 1000)"),
+  sticky: import_zod19.z.number().optional().describe("Sticky z-index (e.g., 1020)"),
+  fixed: import_zod19.z.number().optional().describe("Fixed z-index (e.g., 1030)"),
+  modalBackdrop: import_zod19.z.number().optional().describe("Modal backdrop z-index (e.g., 1040)"),
+  modal: import_zod19.z.number().optional().describe("Modal z-index (e.g., 1050)"),
+  popover: import_zod19.z.number().optional().describe("Popover z-index (e.g., 1060)"),
+  tooltip: import_zod19.z.number().optional().describe("Tooltip z-index (e.g., 1070)")
+});
+var ThemeMode = import_zod19.z.enum(["light", "dark", "auto"]);
+var DensityMode = import_zod19.z.enum(["compact", "regular", "spacious"]);
+var WcagContrastLevel = import_zod19.z.enum(["AA", "AAA"]);
+var ThemeSchema = import_zod19.z.object({
   name: SnakeCaseIdentifierSchema.describe("Unique theme identifier (snake_case)"),
-  label: import_zod15.z.string().describe("Human-readable theme name"),
-  description: import_zod15.z.string().optional().describe("Theme description"),
+  label: import_zod19.z.string().describe("Human-readable theme name"),
+  description: import_zod19.z.string().optional().describe("Theme description"),
   /** Theme mode */
   mode: ThemeMode.default("light").describe("Theme mode (light, dark, or auto)"),
   /** Color system */
@@ -1810,26 +2190,238 @@ var ThemeSchema = import_zod15.z.object({
   /** Z-Index */
   zIndex: ZIndexSchema.optional().describe("Z-index scale for layering"),
   /** Custom CSS variables */
-  customVars: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string()).optional().describe("Custom CSS variables (key-value pairs)"),
+  customVars: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.string()).optional().describe("Custom CSS variables (key-value pairs)"),
   /** Logo */
-  logo: import_zod15.z.object({
-    light: import_zod15.z.string().optional().describe("Logo URL for light mode"),
-    dark: import_zod15.z.string().optional().describe("Logo URL for dark mode"),
-    favicon: import_zod15.z.string().optional().describe("Favicon URL")
+  logo: import_zod19.z.object({
+    light: import_zod19.z.string().optional().describe("Logo URL for light mode"),
+    dark: import_zod19.z.string().optional().describe("Logo URL for dark mode"),
+    favicon: import_zod19.z.string().optional().describe("Favicon URL")
   }).optional().describe("Logo assets"),
   /** Extends another theme */
-  extends: import_zod15.z.string().optional().describe("Base theme to extend from")
+  extends: import_zod19.z.string().optional().describe("Base theme to extend from"),
+  /** Display density mode */
+  density: DensityMode.optional().describe("Display density: compact, regular, or spacious"),
+  /** WCAG contrast level requirement */
+  wcagContrast: WcagContrastLevel.optional().describe("WCAG color contrast level (AA or AAA)"),
+  /** Right-to-left language support */
+  rtl: import_zod19.z.boolean().optional().describe("Enable right-to-left layout direction"),
+  /** Touch target accessibility configuration */
+  touchTarget: TouchTargetConfigSchema.optional().describe("Touch target sizing defaults"),
+  /** Keyboard navigation and focus management */
+  keyboardNavigation: FocusManagementSchema.optional().describe("Keyboard focus management settings")
 });
+
+// src/ui/offline.zod.ts
+var import_zod20 = require("zod");
+var OfflineStrategySchema = import_zod20.z.enum([
+  "cache_first",
+  "network_first",
+  "stale_while_revalidate",
+  "network_only",
+  "cache_only"
+]).describe("Data fetching strategy for offline/online transitions");
+var ConflictResolutionSchema = import_zod20.z.enum([
+  "client_wins",
+  "server_wins",
+  "manual",
+  "last_write_wins"
+]).describe("How to resolve conflicts when syncing offline changes");
+var SyncConfigSchema = import_zod20.z.object({
+  strategy: OfflineStrategySchema.default("network_first").describe("Sync fetch strategy"),
+  conflictResolution: ConflictResolutionSchema.default("last_write_wins").describe("Conflict resolution policy"),
+  retryInterval: import_zod20.z.number().optional().describe("Retry interval in milliseconds between sync attempts"),
+  maxRetries: import_zod20.z.number().optional().describe("Maximum number of sync retry attempts"),
+  batchSize: import_zod20.z.number().optional().describe("Number of mutations to sync per batch")
+}).describe("Offline-to-online synchronization configuration");
+var PersistStorageSchema = import_zod20.z.enum([
+  "indexeddb",
+  "localstorage",
+  "sqlite"
+]).describe("Client-side storage backend for offline cache");
+var EvictionPolicySchema = import_zod20.z.enum([
+  "lru",
+  "lfu",
+  "fifo"
+]).describe("Cache eviction policy");
+var OfflineCacheConfigSchema = import_zod20.z.object({
+  maxSize: import_zod20.z.number().optional().describe("Maximum cache size in bytes"),
+  ttl: import_zod20.z.number().optional().describe("Time-to-live for cached entries in milliseconds"),
+  persistStorage: PersistStorageSchema.default("indexeddb").describe("Storage backend"),
+  evictionPolicy: EvictionPolicySchema.default("lru").describe("Cache eviction policy when full")
+}).describe("Client-side offline cache configuration");
+var OfflineConfigSchema = import_zod20.z.object({
+  enabled: import_zod20.z.boolean().default(false).describe("Enable offline support"),
+  strategy: OfflineStrategySchema.default("network_first").describe("Default offline fetch strategy"),
+  cache: OfflineCacheConfigSchema.optional().describe("Cache settings for offline data"),
+  sync: SyncConfigSchema.optional().describe("Sync settings for offline mutations"),
+  offlineIndicator: import_zod20.z.boolean().default(true).describe("Show a visual indicator when offline"),
+  offlineMessage: I18nLabelSchema.optional().describe("Customizable offline status message shown to users"),
+  queueMaxSize: import_zod20.z.number().optional().describe("Maximum number of queued offline mutations")
+}).describe("Offline support configuration");
+
+// src/ui/animation.zod.ts
+var import_zod21 = require("zod");
+var TransitionPresetSchema = import_zod21.z.enum([
+  "fade",
+  "slide_up",
+  "slide_down",
+  "slide_left",
+  "slide_right",
+  "scale",
+  "rotate",
+  "flip",
+  "none"
+]).describe("Transition preset type");
+var EasingFunctionSchema = import_zod21.z.enum([
+  "linear",
+  "ease",
+  "ease_in",
+  "ease_out",
+  "ease_in_out",
+  "spring"
+]).describe("Animation easing function");
+var TransitionConfigSchema = import_zod21.z.object({
+  preset: TransitionPresetSchema.optional().describe("Transition preset to apply"),
+  duration: import_zod21.z.number().optional().describe("Transition duration in milliseconds"),
+  easing: EasingFunctionSchema.optional().describe("Easing function for the transition"),
+  delay: import_zod21.z.number().optional().describe("Delay before transition starts in milliseconds"),
+  customKeyframes: import_zod21.z.string().optional().describe("CSS @keyframes name for custom animations")
+}).describe("Animation transition configuration");
+var AnimationTriggerSchema = import_zod21.z.enum([
+  "on_mount",
+  "on_unmount",
+  "on_hover",
+  "on_focus",
+  "on_click",
+  "on_scroll",
+  "on_visible"
+]).describe("Event that triggers the animation");
+var ComponentAnimationSchema = import_zod21.z.object({
+  label: I18nLabelSchema.optional().describe("Descriptive label for this animation configuration"),
+  enter: TransitionConfigSchema.optional().describe("Enter/mount animation"),
+  exit: TransitionConfigSchema.optional().describe("Exit/unmount animation"),
+  hover: TransitionConfigSchema.optional().describe("Hover state animation"),
+  trigger: AnimationTriggerSchema.optional().describe("When to trigger the animation"),
+  reducedMotion: import_zod21.z.enum(["respect", "disable", "alternative"]).default("respect").describe("Accessibility: how to handle prefers-reduced-motion")
+}).merge(AriaPropsSchema.partial()).describe("Component-level animation configuration");
+var PageTransitionSchema = import_zod21.z.object({
+  type: TransitionPresetSchema.default("fade").describe("Page transition type"),
+  duration: import_zod21.z.number().default(300).describe("Transition duration in milliseconds"),
+  easing: EasingFunctionSchema.default("ease_in_out").describe("Easing function for the transition"),
+  crossFade: import_zod21.z.boolean().default(false).describe("Whether to cross-fade between pages")
+}).describe("Page-level transition configuration");
+var MotionConfigSchema = import_zod21.z.object({
+  label: I18nLabelSchema.optional().describe("Descriptive label for the motion configuration"),
+  defaultTransition: TransitionConfigSchema.optional().describe("Default transition applied to all animations"),
+  pageTransitions: PageTransitionSchema.optional().describe("Page navigation transition settings"),
+  componentAnimations: import_zod21.z.record(import_zod21.z.string(), ComponentAnimationSchema).optional().describe("Component name to animation configuration mapping"),
+  reducedMotion: import_zod21.z.boolean().default(false).describe("When true, respect prefers-reduced-motion and suppress animations globally"),
+  enabled: import_zod21.z.boolean().default(true).describe("Enable or disable all animations globally")
+}).describe("Top-level motion and animation design configuration");
+
+// src/ui/notification.zod.ts
+var import_zod22 = require("zod");
+var NotificationTypeSchema = import_zod22.z.enum([
+  "toast",
+  "snackbar",
+  "banner",
+  "alert",
+  "inline"
+]).describe("Notification presentation style");
+var NotificationSeveritySchema = import_zod22.z.enum([
+  "info",
+  "success",
+  "warning",
+  "error"
+]).describe("Notification severity level");
+var NotificationPositionSchema = import_zod22.z.enum([
+  "top_left",
+  "top_center",
+  "top_right",
+  "bottom_left",
+  "bottom_center",
+  "bottom_right"
+]).describe("Screen position for notification placement");
+var NotificationActionSchema = import_zod22.z.object({
+  label: I18nLabelSchema.describe("Action button label"),
+  action: import_zod22.z.string().describe("Action identifier to execute"),
+  variant: import_zod22.z.enum(["primary", "secondary", "link"]).default("primary").describe("Button variant style")
+}).describe("Notification action button");
+var NotificationSchema = import_zod22.z.object({
+  type: NotificationTypeSchema.default("toast").describe("Notification presentation style"),
+  severity: NotificationSeveritySchema.default("info").describe("Notification severity level"),
+  title: I18nLabelSchema.optional().describe("Notification title"),
+  message: I18nLabelSchema.describe("Notification message body"),
+  icon: import_zod22.z.string().optional().describe("Icon name override"),
+  duration: import_zod22.z.number().optional().describe("Auto-dismiss duration in ms, omit for persistent"),
+  dismissible: import_zod22.z.boolean().default(true).describe("Allow user to dismiss the notification"),
+  actions: import_zod22.z.array(NotificationActionSchema).optional().describe("Action buttons"),
+  position: NotificationPositionSchema.optional().describe("Override default position")
+}).merge(AriaPropsSchema.partial()).describe("Notification instance definition");
+var NotificationConfigSchema = import_zod22.z.object({
+  defaultPosition: NotificationPositionSchema.default("top_right").describe("Default screen position for notifications"),
+  defaultDuration: import_zod22.z.number().default(5e3).describe("Default auto-dismiss duration in ms"),
+  maxVisible: import_zod22.z.number().default(5).describe("Maximum number of notifications visible at once"),
+  stackDirection: import_zod22.z.enum(["up", "down"]).default("down").describe("Stack direction for multiple notifications"),
+  pauseOnHover: import_zod22.z.boolean().default(true).describe("Pause auto-dismiss timer on hover")
+}).describe("Global notification system configuration");
+
+// src/ui/dnd.zod.ts
+var import_zod23 = require("zod");
+var DragHandleSchema = import_zod23.z.enum([
+  "element",
+  "handle",
+  "grip_icon"
+]).describe("Drag initiation method");
+var DropEffectSchema = import_zod23.z.enum([
+  "move",
+  "copy",
+  "link",
+  "none"
+]).describe("Drop operation effect");
+var DragConstraintSchema = import_zod23.z.object({
+  axis: import_zod23.z.enum(["x", "y", "both"]).default("both").describe("Constrain drag axis"),
+  bounds: import_zod23.z.enum(["parent", "viewport", "none"]).default("none").describe("Constrain within bounds"),
+  grid: import_zod23.z.tuple([import_zod23.z.number(), import_zod23.z.number()]).optional().describe("Snap to grid [x, y] in pixels")
+}).describe("Drag movement constraints");
+var DropZoneSchema = import_zod23.z.object({
+  label: I18nLabelSchema.optional().describe("Accessible label for the drop zone"),
+  accept: import_zod23.z.array(import_zod23.z.string()).describe("Accepted drag item types"),
+  maxItems: import_zod23.z.number().optional().describe("Maximum items allowed in drop zone"),
+  highlightOnDragOver: import_zod23.z.boolean().default(true).describe("Highlight drop zone when dragging over"),
+  dropEffect: DropEffectSchema.default("move").describe("Visual effect on drop")
+}).merge(AriaPropsSchema.partial()).describe("Drop zone configuration");
+var DragItemSchema = import_zod23.z.object({
+  type: import_zod23.z.string().describe("Drag item type identifier for matching with drop zones"),
+  label: I18nLabelSchema.optional().describe("Accessible label describing the draggable item"),
+  handle: DragHandleSchema.default("element").describe("How to initiate drag"),
+  constraint: DragConstraintSchema.optional().describe("Drag movement constraints"),
+  preview: import_zod23.z.enum(["element", "custom", "none"]).default("element").describe("Drag preview type"),
+  disabled: import_zod23.z.boolean().default(false).describe("Disable dragging")
+}).merge(AriaPropsSchema.partial()).describe("Draggable item configuration");
+var DndConfigSchema = import_zod23.z.object({
+  enabled: import_zod23.z.boolean().default(false).describe("Enable drag and drop"),
+  dragItem: DragItemSchema.optional().describe("Configuration for draggable item"),
+  dropZone: DropZoneSchema.optional().describe("Configuration for drop target"),
+  sortable: import_zod23.z.boolean().default(false).describe("Enable sortable list behavior"),
+  autoScroll: import_zod23.z.boolean().default(true).describe("Auto-scroll during drag near edges"),
+  touchDelay: import_zod23.z.number().default(200).describe("Delay in ms before drag starts on touch devices")
+}).describe("Drag and drop interaction configuration");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Action,
   ActionParamSchema,
   ActionSchema,
   AnimationSchema,
+  AnimationTriggerSchema,
   App,
   AppBrandingSchema,
   AppSchema,
+  AriaPropsSchema,
   BorderRadiusSchema,
+  BreakpointColumnMapSchema,
+  BreakpointName,
+  BreakpointOrderMapSchema,
   BreakpointsSchema,
   CalendarConfigSchema,
   ChartAnnotationSchema,
@@ -1839,26 +2431,63 @@ var ThemeSchema = import_zod15.z.object({
   ChartSeriesSchema,
   ChartTypeSchema,
   ColorPaletteSchema,
+  ColumnSummarySchema,
+  ComponentAnimationSchema,
   ComponentPropsMap,
+  ConflictResolutionSchema,
   Dashboard,
   DashboardNavItemSchema,
   DashboardSchema,
   DashboardWidgetSchema,
+  DateFormatSchema,
+  DensityMode,
+  DndConfigSchema,
+  DragConstraintSchema,
+  DragHandleSchema,
+  DragItemSchema,
+  DropEffectSchema,
+  DropZoneSchema,
+  EasingFunctionSchema,
+  EvictionPolicySchema,
   FieldWidgetPropsSchema,
+  FocusManagementSchema,
+  FocusTrapConfigSchema,
   FormFieldSchema,
   FormSectionSchema,
   FormViewSchema,
+  GalleryConfigSchema,
   GanttConfigSchema,
+  GestureConfigSchema,
+  GestureTypeSchema,
   GroupNavItemSchema,
+  GroupingConfigSchema,
+  GroupingFieldSchema,
   HttpMethodSchema,
   HttpRequestSchema,
+  I18nLabelSchema,
+  I18nObjectSchema,
   KanbanConfigSchema,
+  KeyboardNavigationConfigSchema,
+  KeyboardShortcutSchema,
   ListColumnSchema,
   ListViewSchema,
+  LocaleConfigSchema,
+  LongPressGestureConfigSchema,
+  MotionConfigSchema,
   NavigationConfigSchema,
   NavigationItemSchema,
   NavigationModeSchema,
+  NotificationActionSchema,
+  NotificationConfigSchema,
+  NotificationPositionSchema,
+  NotificationSchema,
+  NotificationSeveritySchema,
+  NotificationTypeSchema,
+  NumberFormatSchema,
   ObjectNavItemSchema,
+  OfflineCacheConfigSchema,
+  OfflineConfigSchema,
+  OfflineStrategySchema,
   PageCardProps,
   PageComponentSchema,
   PageComponentType,
@@ -1867,8 +2496,13 @@ var ThemeSchema = import_zod15.z.object({
   PageRegionSchema,
   PageSchema,
   PageTabsProps,
+  PageTransitionSchema,
   PageVariableSchema,
   PaginationConfigSchema,
+  PerformanceConfigSchema,
+  PersistStorageSchema,
+  PinchGestureConfigSchema,
+  PluralRuleSchema,
   RecordDetailsProps,
   RecordHighlightsProps,
   RecordRelatedListProps,
@@ -1878,15 +2512,28 @@ var ThemeSchema = import_zod15.z.object({
   ReportGroupingSchema,
   ReportSchema,
   ReportType,
+  ResponsiveConfigSchema,
+  RowColorConfigSchema,
+  RowHeightSchema,
   SelectionConfigSchema,
   ShadowSchema,
   SpacingSchema,
+  SwipeDirectionSchema,
+  SwipeGestureConfigSchema,
+  SyncConfigSchema,
   ThemeMode,
   ThemeSchema,
+  TimelineConfigSchema,
+  TouchInteractionSchema,
+  TouchTargetConfigSchema,
+  TransitionConfigSchema,
+  TransitionPresetSchema,
   TypographySchema,
   UrlNavItemSchema,
   ViewDataSchema,
   ViewSchema,
+  ViewSharingSchema,
+  WcagContrastLevel,
   WidgetEventSchema,
   WidgetLifecycleSchema,
   WidgetManifestSchema,