@objectstack/spec 1.0.11 → 1.1.0

package/dist/system/index.js

@@ -3433,7 +3433,7 @@ var ChangeRequestSchema = import_zod12.z.object({
 });
 
 // src/system/migration.zod.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/data/field.zod.ts
 var import_zod15 = require("zod");
@@ -3802,7 +3802,7 @@ var FieldSchema = import_zod15.z.object({
 });
 
 // src/data/object.zod.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // src/data/validation.zod.ts
 var import_zod16 = require("zod");
@@ -3887,8 +3887,77 @@ var ConditionalValidationSchema = BaseValidationSchema.extend({
   otherwise: ValidationRuleSchema.optional().describe("Validation rule to apply when condition is false")
 });
 
+// src/automation/state-machine.zod.ts
+var import_zod17 = require("zod");
+var ActionRefSchema = import_zod17.z.union([
+  import_zod17.z.string().describe("Action Name"),
+  import_zod17.z.object({
+    type: import_zod17.z.string(),
+    // e.g., 'xstate.assign', 'log', 'email'
+    params: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).optional()
+  })
+]);
+var GuardRefSchema = import_zod17.z.union([
+  import_zod17.z.string().describe('Guard Name (e.g., "isManager", "amountGT1000")'),
+  import_zod17.z.object({
+    type: import_zod17.z.string(),
+    params: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).optional()
+  })
+]);
+var TransitionSchema = import_zod17.z.object({
+  target: import_zod17.z.string().optional().describe("Target State ID"),
+  cond: GuardRefSchema.optional().describe("Condition (Guard) required to take this path"),
+  actions: import_zod17.z.array(ActionRefSchema).optional().describe("Actions to execute during transition"),
+  description: import_zod17.z.string().optional().describe("Human readable description of this rule")
+});
+var EventSchema = import_zod17.z.object({
+  type: import_zod17.z.string().describe('Event Type (e.g. "APPROVE", "REJECT", "Submit")'),
+  // Payload validation schema could go here if we want deep validation
+  schema: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).optional().describe("Expected event payload structure")
+});
+var StateNodeSchema = import_zod17.z.lazy(() => import_zod17.z.object({
+  /** Type of state */
+  type: import_zod17.z.enum(["atomic", "compound", "parallel", "final", "history"]).default("atomic"),
+  /** Entry/Exit Actions */
+  entry: import_zod17.z.array(ActionRefSchema).optional().describe("Actions to run when entering this state"),
+  exit: import_zod17.z.array(ActionRefSchema).optional().describe("Actions to run when leaving this state"),
+  /** Transitions (Events) */
+  on: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.union([
+    import_zod17.z.string(),
+    // Shorthand target
+    TransitionSchema,
+    import_zod17.z.array(TransitionSchema)
+  ])).optional().describe("Map of Event Type -> Transition Definition"),
+  /** Always Transitions (Eventless) */
+  always: import_zod17.z.array(TransitionSchema).optional(),
+  /** Nesting (Hierarchical States) */
+  initial: import_zod17.z.string().optional().describe("Initial child state (if compound)"),
+  states: import_zod17.z.record(import_zod17.z.string(), StateNodeSchema).optional(),
+  /** Metadata for UI/AI */
+  meta: import_zod17.z.object({
+    label: import_zod17.z.string().optional(),
+    description: import_zod17.z.string().optional(),
+    color: import_zod17.z.string().optional(),
+    // For UI diagrams
+    // Instructions for AI Agent when in this state
+    aiInstructions: import_zod17.z.string().optional().describe("Specific instructions for AI when in this state")
+  }).optional()
+}));
+var StateMachineSchema = import_zod17.z.object({
+  id: SnakeCaseIdentifierSchema.describe("Unique Machine ID"),
+  description: import_zod17.z.string().optional(),
+  /** Context (Memory) Schema */
+  contextSchema: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).optional().describe("Zod Schema for the machine context/memory"),
+  /** Initial State */
+  initial: import_zod17.z.string().describe("Initial State ID"),
+  /** State Definitions */
+  states: import_zod17.z.record(import_zod17.z.string(), StateNodeSchema).describe("State Nodes"),
+  /** Global Listeners */
+  on: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.union([import_zod17.z.string(), TransitionSchema, import_zod17.z.array(TransitionSchema)])).optional()
+});
+
 // src/data/object.zod.ts
-var ApiMethod = import_zod17.z.enum([
+var ApiMethod = import_zod18.z.enum([
   "get",
   "list",
   // Read
@@ -3913,65 +3982,65 @@ var ApiMethod = import_zod17.z.enum([
   "export"
   // Data portability
 ]);
-var ObjectCapabilities = import_zod17.z.object({
+var ObjectCapabilities = import_zod18.z.object({
   /** Enable history tracking (Audit Trail) */
-  trackHistory: import_zod17.z.boolean().default(false).describe("Enable field history tracking for audit compliance"),
+  trackHistory: import_zod18.z.boolean().default(false).describe("Enable field history tracking for audit compliance"),
   /** Enable global search indexing */
-  searchable: import_zod17.z.boolean().default(true).describe("Index records for global search"),
+  searchable: import_zod18.z.boolean().default(true).describe("Index records for global search"),
   /** Enable REST/GraphQL API access */
-  apiEnabled: import_zod17.z.boolean().default(true).describe("Expose object via automatic APIs"),
+  apiEnabled: import_zod18.z.boolean().default(true).describe("Expose object via automatic APIs"),
   /** 
    * API Supported Operations
    * Granular control over API exposure.
    */
-  apiMethods: import_zod17.z.array(ApiMethod).optional().describe("Whitelist of allowed API operations"),
+  apiMethods: import_zod18.z.array(ApiMethod).optional().describe("Whitelist of allowed API operations"),
   /** Enable standard attachments/files engine */
-  files: import_zod17.z.boolean().default(false).describe("Enable file attachments and document management"),
+  files: import_zod18.z.boolean().default(false).describe("Enable file attachments and document management"),
   /** Enable social collaboration (Comments, Mentions, Feeds) */
-  feeds: import_zod17.z.boolean().default(false).describe("Enable social feed, comments, and mentions (Chatter-like)"),
+  feeds: import_zod18.z.boolean().default(false).describe("Enable social feed, comments, and mentions (Chatter-like)"),
   /** Enable standard Activity suite (Tasks, Calendars, Events) */
-  activities: import_zod17.z.boolean().default(false).describe("Enable standard tasks and events tracking"),
+  activities: import_zod18.z.boolean().default(false).describe("Enable standard tasks and events tracking"),
   /** Enable Recycle Bin / Soft Delete */
-  trash: import_zod17.z.boolean().default(true).describe("Enable soft-delete with restore capability"),
+  trash: import_zod18.z.boolean().default(true).describe("Enable soft-delete with restore capability"),
   /** Enable "Recently Viewed" tracking */
-  mru: import_zod17.z.boolean().default(true).describe("Track Most Recently Used (MRU) list for users"),
+  mru: import_zod18.z.boolean().default(true).describe("Track Most Recently Used (MRU) list for users"),
   /** Allow cloning records */
-  clone: import_zod17.z.boolean().default(true).describe("Allow record deep cloning")
-});
-var IndexSchema = import_zod17.z.object({
-  name: import_zod17.z.string().optional().describe("Index name (auto-generated if not provided)"),
-  fields: import_zod17.z.array(import_zod17.z.string()).describe("Fields included in the index"),
-  type: import_zod17.z.enum(["btree", "hash", "gin", "gist", "fulltext"]).optional().default("btree").describe("Index algorithm type"),
-  unique: import_zod17.z.boolean().optional().default(false).describe("Whether the index enforces uniqueness"),
-  partial: import_zod17.z.string().optional().describe("Partial index condition (SQL WHERE clause for conditional indexes)")
-});
-var SearchConfigSchema2 = import_zod17.z.object({
-  fields: import_zod17.z.array(import_zod17.z.string()).describe("Fields to index for full-text search weighting"),
-  displayFields: import_zod17.z.array(import_zod17.z.string()).optional().describe("Fields to display in search result cards"),
-  filters: import_zod17.z.array(import_zod17.z.string()).optional().describe("Default filters for search results")
-});
-var TenancyConfigSchema = import_zod17.z.object({
-  enabled: import_zod17.z.boolean().describe("Enable multi-tenancy for this object"),
-  strategy: import_zod17.z.enum(["shared", "isolated", "hybrid"]).describe("Tenant isolation strategy: shared (single DB, row-level), isolated (separate DB per tenant), hybrid (mix)"),
-  tenantField: import_zod17.z.string().default("tenant_id").describe("Field name for tenant identifier"),
-  crossTenantAccess: import_zod17.z.boolean().default(false).describe("Allow cross-tenant data access (with explicit permission)")
-});
-var SoftDeleteConfigSchema = import_zod17.z.object({
-  enabled: import_zod17.z.boolean().describe("Enable soft delete (trash/recycle bin)"),
-  field: import_zod17.z.string().default("deleted_at").describe("Field name for soft delete timestamp"),
-  cascadeDelete: import_zod17.z.boolean().default(false).describe("Cascade soft delete to related records")
-});
-var VersioningConfigSchema = import_zod17.z.object({
-  enabled: import_zod17.z.boolean().describe("Enable record versioning"),
-  strategy: import_zod17.z.enum(["snapshot", "delta", "event-sourcing"]).describe("Versioning strategy: snapshot (full copy), delta (changes only), event-sourcing (event log)"),
-  retentionDays: import_zod17.z.number().min(1).optional().describe("Number of days to retain old versions (undefined = infinite)"),
-  versionField: import_zod17.z.string().default("version").describe("Field name for version number/timestamp")
-});
-var PartitioningConfigSchema = import_zod17.z.object({
-  enabled: import_zod17.z.boolean().describe("Enable table partitioning"),
-  strategy: import_zod17.z.enum(["range", "hash", "list"]).describe("Partitioning strategy: range (date ranges), hash (consistent hashing), list (predefined values)"),
-  key: import_zod17.z.string().describe("Field name to partition by"),
-  interval: import_zod17.z.string().optional().describe('Partition interval for range strategy (e.g., "1 month", "1 year")')
+  clone: import_zod18.z.boolean().default(true).describe("Allow record deep cloning")
+});
+var IndexSchema = import_zod18.z.object({
+  name: import_zod18.z.string().optional().describe("Index name (auto-generated if not provided)"),
+  fields: import_zod18.z.array(import_zod18.z.string()).describe("Fields included in the index"),
+  type: import_zod18.z.enum(["btree", "hash", "gin", "gist", "fulltext"]).optional().default("btree").describe("Index algorithm type"),
+  unique: import_zod18.z.boolean().optional().default(false).describe("Whether the index enforces uniqueness"),
+  partial: import_zod18.z.string().optional().describe("Partial index condition (SQL WHERE clause for conditional indexes)")
+});
+var SearchConfigSchema2 = import_zod18.z.object({
+  fields: import_zod18.z.array(import_zod18.z.string()).describe("Fields to index for full-text search weighting"),
+  displayFields: import_zod18.z.array(import_zod18.z.string()).optional().describe("Fields to display in search result cards"),
+  filters: import_zod18.z.array(import_zod18.z.string()).optional().describe("Default filters for search results")
+});
+var TenancyConfigSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean().describe("Enable multi-tenancy for this object"),
+  strategy: import_zod18.z.enum(["shared", "isolated", "hybrid"]).describe("Tenant isolation strategy: shared (single DB, row-level), isolated (separate DB per tenant), hybrid (mix)"),
+  tenantField: import_zod18.z.string().default("tenant_id").describe("Field name for tenant identifier"),
+  crossTenantAccess: import_zod18.z.boolean().default(false).describe("Allow cross-tenant data access (with explicit permission)")
+});
+var SoftDeleteConfigSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean().describe("Enable soft delete (trash/recycle bin)"),
+  field: import_zod18.z.string().default("deleted_at").describe("Field name for soft delete timestamp"),
+  cascadeDelete: import_zod18.z.boolean().default(false).describe("Cascade soft delete to related records")
+});
+var VersioningConfigSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean().describe("Enable record versioning"),
+  strategy: import_zod18.z.enum(["snapshot", "delta", "event-sourcing"]).describe("Versioning strategy: snapshot (full copy), delta (changes only), event-sourcing (event log)"),
+  retentionDays: import_zod18.z.number().min(1).optional().describe("Number of days to retain old versions (undefined = infinite)"),
+  versionField: import_zod18.z.string().default("version").describe("Field name for version number/timestamp")
+});
+var PartitioningConfigSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean().describe("Enable table partitioning"),
+  strategy: import_zod18.z.enum(["range", "hash", "list"]).describe("Partitioning strategy: range (date ranges), hash (consistent hashing), list (predefined values)"),
+  key: import_zod18.z.string().describe("Field name to partition by"),
+  interval: import_zod18.z.string().optional().describe('Partition interval for range strategy (e.g., "1 month", "1 year")')
 }).refine((data) => {
   if (data.strategy === "range" && !data.interval) {
     return false;
@@ -3980,39 +4049,39 @@ var PartitioningConfigSchema = import_zod17.z.object({
 }, {
   message: 'interval is required when strategy is "range"'
 });
-var CDCConfigSchema = import_zod17.z.object({
-  enabled: import_zod17.z.boolean().describe("Enable Change Data Capture"),
-  events: import_zod17.z.array(import_zod17.z.enum(["insert", "update", "delete"])).describe("Event types to capture"),
-  destination: import_zod17.z.string().describe('Destination endpoint (e.g., "kafka://topic", "webhook://url")')
+var CDCConfigSchema = import_zod18.z.object({
+  enabled: import_zod18.z.boolean().describe("Enable Change Data Capture"),
+  events: import_zod18.z.array(import_zod18.z.enum(["insert", "update", "delete"])).describe("Event types to capture"),
+  destination: import_zod18.z.string().describe('Destination endpoint (e.g., "kafka://topic", "webhook://url")')
 });
-var ObjectSchemaBase = import_zod17.z.object({
+var ObjectSchemaBase = import_zod18.z.object({
   /** 
    * Identity & Metadata 
    */
-  name: import_zod17.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine unique key (snake_case). Immutable."),
-  label: import_zod17.z.string().optional().describe('Human readable singular label (e.g. "Account")'),
-  pluralLabel: import_zod17.z.string().optional().describe('Human readable plural label (e.g. "Accounts")'),
-  description: import_zod17.z.string().optional().describe("Developer documentation / description"),
-  icon: import_zod17.z.string().optional().describe("Icon name (Lucide/Material) for UI representation"),
+  name: import_zod18.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine unique key (snake_case). Immutable."),
+  label: import_zod18.z.string().optional().describe('Human readable singular label (e.g. "Account")'),
+  pluralLabel: import_zod18.z.string().optional().describe('Human readable plural label (e.g. "Accounts")'),
+  description: import_zod18.z.string().optional().describe("Developer documentation / description"),
+  icon: import_zod18.z.string().optional().describe("Icon name (Lucide/Material) for UI representation"),
   /**
    * Taxonomy & Organization
    */
-  tags: import_zod17.z.array(import_zod17.z.string()).optional().describe('Categorization tags (e.g. "sales", "system", "reference")'),
-  active: import_zod17.z.boolean().optional().default(true).describe("Is the object active and usable"),
-  isSystem: import_zod17.z.boolean().optional().default(false).describe("Is system object (protected from deletion)"),
-  abstract: import_zod17.z.boolean().optional().default(false).describe("Is abstract base object (cannot be instantiated)"),
+  tags: import_zod18.z.array(import_zod18.z.string()).optional().describe('Categorization tags (e.g. "sales", "system", "reference")'),
+  active: import_zod18.z.boolean().optional().default(true).describe("Is the object active and usable"),
+  isSystem: import_zod18.z.boolean().optional().default(false).describe("Is system object (protected from deletion)"),
+  abstract: import_zod18.z.boolean().optional().default(false).describe("Is abstract base object (cannot be instantiated)"),
   /** 
    * Storage & Virtualization 
    */
-  datasource: import_zod17.z.string().optional().default("default").describe('Target Datasource ID. "default" is the primary DB.'),
-  tableName: import_zod17.z.string().optional().describe("Physical table/collection name in the target datasource"),
+  datasource: import_zod18.z.string().optional().default("default").describe('Target Datasource ID. "default" is the primary DB.'),
+  tableName: import_zod18.z.string().optional().describe("Physical table/collection name in the target datasource"),
   /** 
    * Data Model 
    */
-  fields: import_zod17.z.record(import_zod17.z.string().regex(/^[a-z_][a-z0-9_]*$/, {
+  fields: import_zod18.z.record(import_zod18.z.string().regex(/^[a-z_][a-z0-9_]*$/, {
     message: 'Field names must be lowercase snake_case (e.g., "first_name", "company", "annual_revenue")'
   }), FieldSchema).describe("Field definitions map. Keys must be snake_case identifiers."),
-  indexes: import_zod17.z.array(IndexSchema).optional().describe("Database performance indexes"),
+  indexes: import_zod18.z.array(IndexSchema).optional().describe("Database performance indexes"),
   /**
    * Advanced Data Management
    */
@@ -4030,12 +4099,22 @@ var ObjectSchemaBase = import_zod17.z.object({
    * Logic & Validation (Co-located)
    * Best Practice: Define rules close to data.
    */
-  validations: import_zod17.z.array(ValidationRuleSchema).optional().describe("Object-level validation rules"),
+  validations: import_zod18.z.array(ValidationRuleSchema).optional().describe("Object-level validation rules"),
+  /**
+   * State Machine(s)
+   * Supports a single machine (legacy) or a named record of machines.
+   * Multiple machines allow parallel lifecycles (e.g., status + payment_status + approval_status).
+   * 
+   * @example Single: stateMachine: { id: 'lifecycle', initial: 'draft', states: {...} }
+   * @example Multiple: stateMachines: { lifecycle: {...}, payment: {...}, approval: {...} }
+   */
+  stateMachine: StateMachineSchema.optional().describe("Single state machine for record lifecycle (shorthand)"),
+  stateMachines: import_zod18.z.record(import_zod18.z.string(), StateMachineSchema).optional().describe("Named state machines for parallel lifecycles (e.g., status, payment, approval)"),
   /** 
    * Display & UI Hints (Data-Layer)
    */
-  titleFormat: import_zod17.z.string().optional().describe('Title expression (e.g. "{name} - {code}"). Overrides nameField.'),
-  compactLayout: import_zod17.z.array(import_zod17.z.string()).optional().describe("Primary fields for hover/cards/lookups"),
+  titleFormat: import_zod18.z.string().optional().describe('Title expression (e.g. "{name} - {code}"). Overrides nameField.'),
+  compactLayout: import_zod18.z.array(import_zod18.z.string()).optional().describe("Primary fields for hover/cards/lookups"),
   /** 
    * Search Engine Config 
    */
@@ -4048,45 +4127,64 @@ var ObjectSchemaBase = import_zod17.z.object({
 var ObjectSchema = Object.assign(ObjectSchemaBase, {
   create: (config) => config
 });
+var ObjectOwnershipEnum = import_zod18.z.enum(["own", "extend"]);
+var ObjectExtensionSchema = import_zod18.z.object({
+  /** The target object name (FQN) to extend */
+  extend: import_zod18.z.string().describe("Target object name (FQN) to extend"),
+  /** Fields to merge into the target object (additive) */
+  fields: import_zod18.z.record(import_zod18.z.string(), FieldSchema).optional().describe("Fields to add/override"),
+  /** Override label */
+  label: import_zod18.z.string().optional(),
+  /** Override plural label */
+  pluralLabel: import_zod18.z.string().optional(),
+  /** Override description */
+  description: import_zod18.z.string().optional(),
+  /** Additional validation rules to add */
+  validations: import_zod18.z.array(ValidationRuleSchema).optional(),
+  /** Additional indexes to add */
+  indexes: import_zod18.z.array(IndexSchema).optional(),
+  /** Merge priority. Higher number applied later (wins on conflict). Default: 200 */
+  priority: import_zod18.z.number().int().min(0).max(999).default(200).describe("Merge priority (higher = applied later)")
+});
 
 // src/system/migration.zod.ts
-var AddFieldOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("add_field"),
-  objectName: import_zod18.z.string(),
-  fieldName: import_zod18.z.string(),
+var AddFieldOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("add_field"),
+  objectName: import_zod19.z.string(),
+  fieldName: import_zod19.z.string(),
   field: FieldSchema
 });
-var ModifyFieldOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("modify_field"),
-  objectName: import_zod18.z.string(),
-  fieldName: import_zod18.z.string(),
-  changes: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown())
+var ModifyFieldOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("modify_field"),
+  objectName: import_zod19.z.string(),
+  fieldName: import_zod19.z.string(),
+  changes: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown())
   // Partial field definition updates
 });
-var RemoveFieldOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("remove_field"),
-  objectName: import_zod18.z.string(),
-  fieldName: import_zod18.z.string()
+var RemoveFieldOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("remove_field"),
+  objectName: import_zod19.z.string(),
+  fieldName: import_zod19.z.string()
 });
-var CreateObjectOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("create_object"),
+var CreateObjectOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("create_object"),
   object: ObjectSchema
 });
-var RenameObjectOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("rename_object"),
-  oldName: import_zod18.z.string(),
-  newName: import_zod18.z.string()
+var RenameObjectOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("rename_object"),
+  oldName: import_zod19.z.string(),
+  newName: import_zod19.z.string()
 });
-var DeleteObjectOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("delete_object"),
-  objectName: import_zod18.z.string()
+var DeleteObjectOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("delete_object"),
+  objectName: import_zod19.z.string()
 });
-var ExecuteSqlOperation = import_zod18.z.object({
-  type: import_zod18.z.literal("execute_sql"),
-  sql: import_zod18.z.string(),
-  description: import_zod18.z.string().optional()
+var ExecuteSqlOperation = import_zod19.z.object({
+  type: import_zod19.z.literal("execute_sql"),
+  sql: import_zod19.z.string(),
+  description: import_zod19.z.string().optional()
 });
-var MigrationOperationSchema = import_zod18.z.discriminatedUnion("type", [
+var MigrationOperationSchema = import_zod19.z.discriminatedUnion("type", [
   AddFieldOperation,
   ModifyFieldOperation,
   RemoveFieldOperation,
@@ -4095,65 +4193,65 @@ var MigrationOperationSchema = import_zod18.z.discriminatedUnion("type", [
   DeleteObjectOperation,
   ExecuteSqlOperation
 ]);
-var MigrationDependencySchema = import_zod18.z.object({
-  migrationId: import_zod18.z.string(),
-  package: import_zod18.z.string().optional()
-});
-var ChangeSetSchema = import_zod18.z.object({
-  id: import_zod18.z.string().uuid().describe("Unique identifier for this change set"),
-  name: import_zod18.z.string().describe("Human readable name for the migration"),
-  description: import_zod18.z.string().optional(),
-  author: import_zod18.z.string().optional(),
-  createdAt: import_zod18.z.string().datetime().optional(),
+var MigrationDependencySchema = import_zod19.z.object({
+  migrationId: import_zod19.z.string(),
+  package: import_zod19.z.string().optional()
+});
+var ChangeSetSchema = import_zod19.z.object({
+  id: import_zod19.z.string().uuid().describe("Unique identifier for this change set"),
+  name: import_zod19.z.string().describe("Human readable name for the migration"),
+  description: import_zod19.z.string().optional(),
+  author: import_zod19.z.string().optional(),
+  createdAt: import_zod19.z.string().datetime().optional(),
   // Dependencies ensure migrations run in order
-  dependencies: import_zod18.z.array(MigrationDependencySchema).optional(),
+  dependencies: import_zod19.z.array(MigrationDependencySchema).optional(),
   // The actual atomic operations
-  operations: import_zod18.z.array(MigrationOperationSchema),
+  operations: import_zod19.z.array(MigrationOperationSchema),
   // Rollback operations (AI should generate these too)
-  rollback: import_zod18.z.array(MigrationOperationSchema).optional()
+  rollback: import_zod19.z.array(MigrationOperationSchema).optional()
 });
 
 // src/system/auth-config.zod.ts
-var import_zod19 = require("zod");
-var AuthProviderConfigSchema = import_zod19.z.object({
-  id: import_zod19.z.string().describe("Provider ID (github, google)"),
-  clientId: import_zod19.z.string().describe("OAuth Client ID"),
-  clientSecret: import_zod19.z.string().describe("OAuth Client Secret"),
-  scope: import_zod19.z.array(import_zod19.z.string()).optional().describe("Requested permissions")
-});
-var AuthPluginConfigSchema = import_zod19.z.object({
-  organization: import_zod19.z.boolean().default(false).describe("Enable Organization/Teams support"),
-  twoFactor: import_zod19.z.boolean().default(false).describe("Enable 2FA"),
-  passkeys: import_zod19.z.boolean().default(false).describe("Enable Passkey support"),
-  magicLink: import_zod19.z.boolean().default(false).describe("Enable Magic Link login")
-});
-var AuthConfigSchema = import_zod19.z.object({
-  secret: import_zod19.z.string().optional().describe("Encryption secret"),
-  baseUrl: import_zod19.z.string().optional().describe("Base URL for auth routes"),
-  databaseUrl: import_zod19.z.string().optional().describe("Database connection string"),
-  providers: import_zod19.z.array(AuthProviderConfigSchema).optional(),
+var import_zod20 = require("zod");
+var AuthProviderConfigSchema = import_zod20.z.object({
+  id: import_zod20.z.string().describe("Provider ID (github, google)"),
+  clientId: import_zod20.z.string().describe("OAuth Client ID"),
+  clientSecret: import_zod20.z.string().describe("OAuth Client Secret"),
+  scope: import_zod20.z.array(import_zod20.z.string()).optional().describe("Requested permissions")
+});
+var AuthPluginConfigSchema = import_zod20.z.object({
+  organization: import_zod20.z.boolean().default(false).describe("Enable Organization/Teams support"),
+  twoFactor: import_zod20.z.boolean().default(false).describe("Enable 2FA"),
+  passkeys: import_zod20.z.boolean().default(false).describe("Enable Passkey support"),
+  magicLink: import_zod20.z.boolean().default(false).describe("Enable Magic Link login")
+});
+var AuthConfigSchema = import_zod20.z.object({
+  secret: import_zod20.z.string().optional().describe("Encryption secret"),
+  baseUrl: import_zod20.z.string().optional().describe("Base URL for auth routes"),
+  databaseUrl: import_zod20.z.string().optional().describe("Database connection string"),
+  providers: import_zod20.z.array(AuthProviderConfigSchema).optional(),
   plugins: AuthPluginConfigSchema.optional(),
-  session: import_zod19.z.object({
-    expiresIn: import_zod19.z.number().default(60 * 60 * 24 * 7).describe("Session duration in seconds"),
-    updateAge: import_zod19.z.number().default(60 * 60 * 24).describe("Session update frequency")
+  session: import_zod20.z.object({
+    expiresIn: import_zod20.z.number().default(60 * 60 * 24 * 7).describe("Session duration in seconds"),
+    updateAge: import_zod20.z.number().default(60 * 60 * 24).describe("Session update frequency")
   }).optional(),
   // Custom auth properties
-  [import_zod19.z.string().regex(/^[^A-Z]+$/).toString()]: import_zod19.z.any().optional()
+  [import_zod20.z.string().regex(/^[^A-Z]+$/).toString()]: import_zod20.z.any().optional()
 });
 
 // src/system/compliance.zod.ts
-var import_zod20 = require("zod");
-var GDPRConfigSchema = import_zod20.z.object({
-  enabled: import_zod20.z.boolean(),
-  dataSubjectRights: import_zod20.z.object({
-    rightToAccess: import_zod20.z.boolean().default(true),
-    rightToRectification: import_zod20.z.boolean().default(true),
-    rightToErasure: import_zod20.z.boolean().default(true),
-    rightToRestriction: import_zod20.z.boolean().default(true),
-    rightToPortability: import_zod20.z.boolean().default(true),
-    rightToObjection: import_zod20.z.boolean().default(true)
+var import_zod21 = require("zod");
+var GDPRConfigSchema = import_zod21.z.object({
+  enabled: import_zod21.z.boolean(),
+  dataSubjectRights: import_zod21.z.object({
+    rightToAccess: import_zod21.z.boolean().default(true),
+    rightToRectification: import_zod21.z.boolean().default(true),
+    rightToErasure: import_zod21.z.boolean().default(true),
+    rightToRestriction: import_zod21.z.boolean().default(true),
+    rightToPortability: import_zod21.z.boolean().default(true),
+    rightToObjection: import_zod21.z.boolean().default(true)
   }),
-  legalBasis: import_zod20.z.enum([
+  legalBasis: import_zod21.z.enum([
     "consent",
     "contract",
     "legal-obligation",
@@ -4161,34 +4259,34 @@ var GDPRConfigSchema = import_zod20.z.object({
     "public-task",
     "legitimate-interests"
   ]),
-  consentTracking: import_zod20.z.boolean().default(true),
-  dataRetentionDays: import_zod20.z.number().optional(),
-  dataProcessingAgreement: import_zod20.z.string().optional()
-});
-var HIPAAConfigSchema = import_zod20.z.object({
-  enabled: import_zod20.z.boolean(),
-  phi: import_zod20.z.object({
-    encryption: import_zod20.z.boolean().default(true),
-    accessControl: import_zod20.z.boolean().default(true),
-    auditTrail: import_zod20.z.boolean().default(true),
-    backupAndRecovery: import_zod20.z.boolean().default(true)
+  consentTracking: import_zod21.z.boolean().default(true),
+  dataRetentionDays: import_zod21.z.number().optional(),
+  dataProcessingAgreement: import_zod21.z.string().optional()
+});
+var HIPAAConfigSchema = import_zod21.z.object({
+  enabled: import_zod21.z.boolean(),
+  phi: import_zod21.z.object({
+    encryption: import_zod21.z.boolean().default(true),
+    accessControl: import_zod21.z.boolean().default(true),
+    auditTrail: import_zod21.z.boolean().default(true),
+    backupAndRecovery: import_zod21.z.boolean().default(true)
   }),
-  businessAssociateAgreement: import_zod20.z.boolean().default(false)
-});
-var PCIDSSConfigSchema = import_zod20.z.object({
-  enabled: import_zod20.z.boolean(),
-  level: import_zod20.z.enum(["1", "2", "3", "4"]),
-  cardDataFields: import_zod20.z.array(import_zod20.z.string()),
-  tokenization: import_zod20.z.boolean().default(true),
-  encryptionInTransit: import_zod20.z.boolean().default(true),
-  encryptionAtRest: import_zod20.z.boolean().default(true)
-});
-var AuditLogConfigSchema = import_zod20.z.object({
-  enabled: import_zod20.z.boolean().default(true),
-  retentionDays: import_zod20.z.number().default(365),
-  immutable: import_zod20.z.boolean().default(true),
-  signLogs: import_zod20.z.boolean().default(false),
-  events: import_zod20.z.array(import_zod20.z.enum([
+  businessAssociateAgreement: import_zod21.z.boolean().default(false)
+});
+var PCIDSSConfigSchema = import_zod21.z.object({
+  enabled: import_zod21.z.boolean(),
+  level: import_zod21.z.enum(["1", "2", "3", "4"]),
+  cardDataFields: import_zod21.z.array(import_zod21.z.string()),
+  tokenization: import_zod21.z.boolean().default(true),
+  encryptionInTransit: import_zod21.z.boolean().default(true),
+  encryptionAtRest: import_zod21.z.boolean().default(true)
+});
+var AuditLogConfigSchema = import_zod21.z.object({
+  enabled: import_zod21.z.boolean().default(true),
+  retentionDays: import_zod21.z.number().default(365),
+  immutable: import_zod21.z.boolean().default(true),
+  signLogs: import_zod21.z.boolean().default(false),
+  events: import_zod21.z.array(import_zod21.z.enum([
     "create",
     "read",
     "update",
@@ -4200,7 +4298,7 @@ var AuditLogConfigSchema = import_zod20.z.object({
     "failed-login"
   ]))
 });
-var ComplianceConfigSchema = import_zod20.z.object({
+var ComplianceConfigSchema = import_zod21.z.object({
   gdpr: GDPRConfigSchema.optional(),
   hipaa: HIPAAConfigSchema.optional(),
   pciDss: PCIDSSConfigSchema.optional(),
@@ -4208,57 +4306,57 @@ var ComplianceConfigSchema = import_zod20.z.object({
 });
 
 // src/system/job.zod.ts
-var import_zod21 = require("zod");
-var CronScheduleSchema = import_zod21.z.object({
-  type: import_zod21.z.literal("cron"),
-  expression: import_zod21.z.string().describe('Cron expression (e.g., "0 0 * * *" for daily at midnight)'),
-  timezone: import_zod21.z.string().optional().default("UTC").describe('Timezone for cron execution (e.g., "America/New_York")')
+var import_zod22 = require("zod");
+var CronScheduleSchema = import_zod22.z.object({
+  type: import_zod22.z.literal("cron"),
+  expression: import_zod22.z.string().describe('Cron expression (e.g., "0 0 * * *" for daily at midnight)'),
+  timezone: import_zod22.z.string().optional().default("UTC").describe('Timezone for cron execution (e.g., "America/New_York")')
 });
-var IntervalScheduleSchema = import_zod21.z.object({
-  type: import_zod21.z.literal("interval"),
-  intervalMs: import_zod21.z.number().int().positive().describe("Interval in milliseconds")
+var IntervalScheduleSchema = import_zod22.z.object({
+  type: import_zod22.z.literal("interval"),
+  intervalMs: import_zod22.z.number().int().positive().describe("Interval in milliseconds")
 });
-var OnceScheduleSchema = import_zod21.z.object({
-  type: import_zod21.z.literal("once"),
-  at: import_zod21.z.string().datetime().describe("ISO 8601 datetime when to execute")
+var OnceScheduleSchema = import_zod22.z.object({
+  type: import_zod22.z.literal("once"),
+  at: import_zod22.z.string().datetime().describe("ISO 8601 datetime when to execute")
 });
-var ScheduleSchema = import_zod21.z.discriminatedUnion("type", [
+var ScheduleSchema = import_zod22.z.discriminatedUnion("type", [
   CronScheduleSchema,
   IntervalScheduleSchema,
   OnceScheduleSchema
 ]);
-var RetryPolicySchema = import_zod21.z.object({
-  maxRetries: import_zod21.z.number().int().min(0).default(3).describe("Maximum number of retry attempts"),
-  backoffMs: import_zod21.z.number().int().positive().default(1e3).describe("Initial backoff delay in milliseconds"),
-  backoffMultiplier: import_zod21.z.number().positive().default(2).describe("Multiplier for exponential backoff")
-});
-var JobSchema = import_zod21.z.object({
-  id: import_zod21.z.string().describe("Unique job identifier"),
-  name: import_zod21.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Job name (snake_case)"),
+var RetryPolicySchema = import_zod22.z.object({
+  maxRetries: import_zod22.z.number().int().min(0).default(3).describe("Maximum number of retry attempts"),
+  backoffMs: import_zod22.z.number().int().positive().default(1e3).describe("Initial backoff delay in milliseconds"),
+  backoffMultiplier: import_zod22.z.number().positive().default(2).describe("Multiplier for exponential backoff")
+});
+var JobSchema = import_zod22.z.object({
+  id: import_zod22.z.string().describe("Unique job identifier"),
+  name: import_zod22.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Job name (snake_case)"),
   schedule: ScheduleSchema.describe("Job schedule configuration"),
-  handler: import_zod21.z.string().describe('Handler path (e.g. "path/to/file:functionName") or script ID'),
+  handler: import_zod22.z.string().describe('Handler path (e.g. "path/to/file:functionName") or script ID'),
   retryPolicy: RetryPolicySchema.optional().describe("Retry policy configuration"),
-  timeout: import_zod21.z.number().int().positive().optional().describe("Timeout in milliseconds"),
-  enabled: import_zod21.z.boolean().default(true).describe("Whether the job is enabled")
+  timeout: import_zod22.z.number().int().positive().optional().describe("Timeout in milliseconds"),
+  enabled: import_zod22.z.boolean().default(true).describe("Whether the job is enabled")
 });
-var JobExecutionStatus = import_zod21.z.enum([
+var JobExecutionStatus = import_zod22.z.enum([
   "running",
   "success",
   "failed",
   "timeout"
 ]);
-var JobExecutionSchema = import_zod21.z.object({
-  jobId: import_zod21.z.string().describe("Job identifier"),
-  startedAt: import_zod21.z.string().datetime().describe("ISO 8601 datetime when execution started"),
-  completedAt: import_zod21.z.string().datetime().optional().describe("ISO 8601 datetime when execution completed"),
+var JobExecutionSchema = import_zod22.z.object({
+  jobId: import_zod22.z.string().describe("Job identifier"),
+  startedAt: import_zod22.z.string().datetime().describe("ISO 8601 datetime when execution started"),
+  completedAt: import_zod22.z.string().datetime().optional().describe("ISO 8601 datetime when execution completed"),
   status: JobExecutionStatus.describe("Execution status"),
-  error: import_zod21.z.string().optional().describe("Error message if failed"),
-  duration: import_zod21.z.number().int().optional().describe("Execution duration in milliseconds")
+  error: import_zod22.z.string().optional().describe("Error message if failed"),
+  duration: import_zod22.z.number().int().optional().describe("Execution duration in milliseconds")
 });
 
 // src/system/worker.zod.ts
-var import_zod22 = require("zod");
-var TaskPriority = import_zod22.z.enum([
+var import_zod23 = require("zod");
+var TaskPriority = import_zod23.z.enum([
   "critical",
   // 0 - Must execute immediately
   "high",
@@ -4277,7 +4375,7 @@ var TASK_PRIORITY_VALUES = {
   low: 3,
   background: 4
 };
-var TaskStatus = import_zod22.z.enum([
+var TaskStatus = import_zod23.z.enum([
   "pending",
   // Waiting to be processed
   "queued",
@@ -4295,30 +4393,30 @@ var TaskStatus = import_zod22.z.enum([
   "dead"
   // Moved to dead letter queue
 ]);
-var TaskRetryPolicySchema = import_zod22.z.object({
-  maxRetries: import_zod22.z.number().int().min(0).default(3).describe("Maximum retry attempts"),
-  backoffStrategy: import_zod22.z.enum(["fixed", "linear", "exponential"]).default("exponential").describe("Backoff strategy between retries"),
-  initialDelayMs: import_zod22.z.number().int().positive().default(1e3).describe("Initial retry delay in milliseconds"),
-  maxDelayMs: import_zod22.z.number().int().positive().default(6e4).describe("Maximum retry delay in milliseconds"),
-  backoffMultiplier: import_zod22.z.number().positive().default(2).describe("Multiplier for exponential backoff")
+var TaskRetryPolicySchema = import_zod23.z.object({
+  maxRetries: import_zod23.z.number().int().min(0).default(3).describe("Maximum retry attempts"),
+  backoffStrategy: import_zod23.z.enum(["fixed", "linear", "exponential"]).default("exponential").describe("Backoff strategy between retries"),
+  initialDelayMs: import_zod23.z.number().int().positive().default(1e3).describe("Initial retry delay in milliseconds"),
+  maxDelayMs: import_zod23.z.number().int().positive().default(6e4).describe("Maximum retry delay in milliseconds"),
+  backoffMultiplier: import_zod23.z.number().positive().default(2).describe("Multiplier for exponential backoff")
 });
-var TaskSchema = import_zod22.z.object({
+var TaskSchema = import_zod23.z.object({
   /**
    * Unique task identifier
    */
-  id: import_zod22.z.string().describe("Unique task identifier"),
+  id: import_zod23.z.string().describe("Unique task identifier"),
   /**
    * Task type (handler identifier)
    */
-  type: import_zod22.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Task type (snake_case)"),
+  type: import_zod23.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Task type (snake_case)"),
   /**
    * Task payload data
    */
-  payload: import_zod22.z.any().describe("Task payload data"),
+  payload: import_zod23.z.any().describe("Task payload data"),
   /**
    * Queue name
    */
-  queue: import_zod22.z.string().default("default").describe("Queue name"),
+  queue: import_zod23.z.string().default("default").describe("Queue name"),
   /**
    * Task priority
    */
@@ -4330,15 +4428,15 @@ var TaskSchema = import_zod22.z.object({
   /**
    * Execution timeout in milliseconds
    */
-  timeoutMs: import_zod22.z.number().int().positive().optional().describe("Task timeout in milliseconds"),
+  timeoutMs: import_zod23.z.number().int().positive().optional().describe("Task timeout in milliseconds"),
   /**
    * Scheduled execution time
    */
-  scheduledAt: import_zod22.z.string().datetime().optional().describe("ISO 8601 datetime to execute task"),
+  scheduledAt: import_zod23.z.string().datetime().optional().describe("ISO 8601 datetime to execute task"),
   /**
    * Maximum execution attempts
    */
-  attempts: import_zod22.z.number().int().min(0).default(0).describe("Number of execution attempts"),
+  attempts: import_zod23.z.number().int().min(0).default(0).describe("Number of execution attempts"),
   /**
    * Task status
    */
@@ -4346,18 +4444,18 @@ var TaskSchema = import_zod22.z.object({
   /**
    * Task metadata
    */
-  metadata: import_zod22.z.object({
-    createdAt: import_zod22.z.string().datetime().optional().describe("When task was created"),
-    updatedAt: import_zod22.z.string().datetime().optional().describe("Last update time"),
-    createdBy: import_zod22.z.string().optional().describe("User who created task"),
-    tags: import_zod22.z.array(import_zod22.z.string()).optional().describe("Task tags for filtering")
+  metadata: import_zod23.z.object({
+    createdAt: import_zod23.z.string().datetime().optional().describe("When task was created"),
+    updatedAt: import_zod23.z.string().datetime().optional().describe("Last update time"),
+    createdBy: import_zod23.z.string().optional().describe("User who created task"),
+    tags: import_zod23.z.array(import_zod23.z.string()).optional().describe("Task tags for filtering")
   }).optional().describe("Task metadata")
 });
-var TaskExecutionResultSchema = import_zod22.z.object({
+var TaskExecutionResultSchema = import_zod23.z.object({
   /**
    * Task identifier
    */
-  taskId: import_zod22.z.string().describe("Task identifier"),
+  taskId: import_zod23.z.string().describe("Task identifier"),
   /**
    * Execution status
    */
@@ -4365,45 +4463,45 @@ var TaskExecutionResultSchema = import_zod22.z.object({
   /**
    * Execution result data
    */
-  result: import_zod22.z.any().optional().describe("Execution result data"),
+  result: import_zod23.z.any().optional().describe("Execution result data"),
   /**
    * Error information
    */
-  error: import_zod22.z.object({
-    message: import_zod22.z.string().describe("Error message"),
-    stack: import_zod22.z.string().optional().describe("Error stack trace"),
-    code: import_zod22.z.string().optional().describe("Error code")
+  error: import_zod23.z.object({
+    message: import_zod23.z.string().describe("Error message"),
+    stack: import_zod23.z.string().optional().describe("Error stack trace"),
+    code: import_zod23.z.string().optional().describe("Error code")
   }).optional().describe("Error details if failed"),
   /**
    * Execution duration
    */
-  durationMs: import_zod22.z.number().int().optional().describe("Execution duration in milliseconds"),
+  durationMs: import_zod23.z.number().int().optional().describe("Execution duration in milliseconds"),
   /**
    * Execution timestamps
    */
-  startedAt: import_zod22.z.string().datetime().describe("When execution started"),
-  completedAt: import_zod22.z.string().datetime().optional().describe("When execution completed"),
+  startedAt: import_zod23.z.string().datetime().describe("When execution started"),
+  completedAt: import_zod23.z.string().datetime().optional().describe("When execution completed"),
   /**
    * Retry information
    */
-  attempt: import_zod22.z.number().int().min(1).describe("Attempt number (1-indexed)"),
-  willRetry: import_zod22.z.boolean().describe("Whether task will be retried")
+  attempt: import_zod23.z.number().int().min(1).describe("Attempt number (1-indexed)"),
+  willRetry: import_zod23.z.boolean().describe("Whether task will be retried")
 });
-var QueueConfigSchema = import_zod22.z.object({
+var QueueConfigSchema = import_zod23.z.object({
   /**
    * Queue name
    */
-  name: import_zod22.z.string().describe("Queue name (snake_case)"),
+  name: import_zod23.z.string().describe("Queue name (snake_case)"),
   /**
    * Maximum concurrent workers
    */
-  concurrency: import_zod22.z.number().int().min(1).default(5).describe("Max concurrent task executions"),
+  concurrency: import_zod23.z.number().int().min(1).default(5).describe("Max concurrent task executions"),
   /**
    * Rate limiting
    */
-  rateLimit: import_zod22.z.object({
-    max: import_zod22.z.number().int().positive().describe("Maximum tasks per duration"),
-    duration: import_zod22.z.number().int().positive().describe("Duration in milliseconds")
+  rateLimit: import_zod23.z.object({
+    max: import_zod23.z.number().int().positive().describe("Maximum tasks per duration"),
+    duration: import_zod23.z.number().int().positive().describe("Duration in milliseconds")
   }).optional().describe("Rate limit configuration"),
   /**
    * Default retry policy
@@ -4412,43 +4510,43 @@ var QueueConfigSchema = import_zod22.z.object({
   /**
    * Dead letter queue
    */
-  deadLetterQueue: import_zod22.z.string().optional().describe("Dead letter queue name"),
+  deadLetterQueue: import_zod23.z.string().optional().describe("Dead letter queue name"),
   /**
    * Queue priority
    */
-  priority: import_zod22.z.number().int().min(0).default(0).describe("Queue priority (lower = higher priority)"),
+  priority: import_zod23.z.number().int().min(0).default(0).describe("Queue priority (lower = higher priority)"),
   /**
    * Auto-scaling configuration
    */
-  autoScale: import_zod22.z.object({
-    enabled: import_zod22.z.boolean().default(false).describe("Enable auto-scaling"),
-    minWorkers: import_zod22.z.number().int().min(1).default(1).describe("Minimum workers"),
-    maxWorkers: import_zod22.z.number().int().min(1).default(10).describe("Maximum workers"),
-    scaleUpThreshold: import_zod22.z.number().int().positive().default(100).describe("Queue size to scale up"),
-    scaleDownThreshold: import_zod22.z.number().int().min(0).default(10).describe("Queue size to scale down")
+  autoScale: import_zod23.z.object({
+    enabled: import_zod23.z.boolean().default(false).describe("Enable auto-scaling"),
+    minWorkers: import_zod23.z.number().int().min(1).default(1).describe("Minimum workers"),
+    maxWorkers: import_zod23.z.number().int().min(1).default(10).describe("Maximum workers"),
+    scaleUpThreshold: import_zod23.z.number().int().positive().default(100).describe("Queue size to scale up"),
+    scaleDownThreshold: import_zod23.z.number().int().min(0).default(10).describe("Queue size to scale down")
   }).optional().describe("Auto-scaling configuration")
 });
-var BatchTaskSchema = import_zod22.z.object({
+var BatchTaskSchema = import_zod23.z.object({
   /**
    * Batch job identifier
    */
-  id: import_zod22.z.string().describe("Unique batch job identifier"),
+  id: import_zod23.z.string().describe("Unique batch job identifier"),
   /**
    * Task type for processing each item
    */
-  type: import_zod22.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Task type (snake_case)"),
+  type: import_zod23.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Task type (snake_case)"),
   /**
    * Items to process
    */
-  items: import_zod22.z.array(import_zod22.z.any()).describe("Array of items to process"),
+  items: import_zod23.z.array(import_zod23.z.any()).describe("Array of items to process"),
   /**
    * Batch size (items per task)
    */
-  batchSize: import_zod22.z.number().int().min(1).default(100).describe("Number of items per batch"),
+  batchSize: import_zod23.z.number().int().min(1).default(100).describe("Number of items per batch"),
   /**
    * Queue name
    */
-  queue: import_zod22.z.string().default("batch").describe("Queue for batch tasks"),
+  queue: import_zod23.z.string().default("batch").describe("Queue for batch tasks"),
   /**
    * Priority
    */
@@ -4456,11 +4554,11 @@ var BatchTaskSchema = import_zod22.z.object({
   /**
    * Parallel processing
    */
-  parallel: import_zod22.z.boolean().default(true).describe("Process batches in parallel"),
+  parallel: import_zod23.z.boolean().default(true).describe("Process batches in parallel"),
   /**
    * Stop on error
    */
-  stopOnError: import_zod22.z.boolean().default(false).describe("Stop batch if any item fails"),
+  stopOnError: import_zod23.z.boolean().default(false).describe("Stop batch if any item fails"),
   /**
    * Progress callback
    * 
@@ -4470,118 +4568,118 @@ var BatchTaskSchema = import_zod22.z.object({
    * 
    * @param progress - Object containing processed count, total count, and failed count
    */
-  onProgress: import_zod22.z.function().args(import_zod22.z.object({
-    processed: import_zod22.z.number(),
-    total: import_zod22.z.number(),
-    failed: import_zod22.z.number()
-  })).returns(import_zod22.z.void()).optional().describe("Progress callback function (called after each batch)")
+  onProgress: import_zod23.z.function().args(import_zod23.z.object({
+    processed: import_zod23.z.number(),
+    total: import_zod23.z.number(),
+    failed: import_zod23.z.number()
+  })).returns(import_zod23.z.void()).optional().describe("Progress callback function (called after each batch)")
 });
-var BatchProgressSchema = import_zod22.z.object({
+var BatchProgressSchema = import_zod23.z.object({
   /**
    * Batch job identifier
    */
-  batchId: import_zod22.z.string().describe("Batch job identifier"),
+  batchId: import_zod23.z.string().describe("Batch job identifier"),
   /**
    * Total items
    */
-  total: import_zod22.z.number().int().min(0).describe("Total number of items"),
+  total: import_zod23.z.number().int().min(0).describe("Total number of items"),
   /**
    * Processed items
    */
-  processed: import_zod22.z.number().int().min(0).default(0).describe("Items processed"),
+  processed: import_zod23.z.number().int().min(0).default(0).describe("Items processed"),
   /**
    * Successful items
    */
-  succeeded: import_zod22.z.number().int().min(0).default(0).describe("Items succeeded"),
+  succeeded: import_zod23.z.number().int().min(0).default(0).describe("Items succeeded"),
   /**
    * Failed items
    */
-  failed: import_zod22.z.number().int().min(0).default(0).describe("Items failed"),
+  failed: import_zod23.z.number().int().min(0).default(0).describe("Items failed"),
   /**
    * Progress percentage
    */
-  percentage: import_zod22.z.number().min(0).max(100).describe("Progress percentage"),
+  percentage: import_zod23.z.number().min(0).max(100).describe("Progress percentage"),
   /**
    * Status
    */
-  status: import_zod22.z.enum(["pending", "running", "completed", "failed", "cancelled"]).describe("Batch status"),
+  status: import_zod23.z.enum(["pending", "running", "completed", "failed", "cancelled"]).describe("Batch status"),
   /**
    * Timestamps
    */
-  startedAt: import_zod22.z.string().datetime().optional().describe("When batch started"),
-  completedAt: import_zod22.z.string().datetime().optional().describe("When batch completed")
+  startedAt: import_zod23.z.string().datetime().optional().describe("When batch started"),
+  completedAt: import_zod23.z.string().datetime().optional().describe("When batch completed")
 });
-var WorkerConfigSchema = import_zod22.z.object({
+var WorkerConfigSchema = import_zod23.z.object({
   /**
    * Worker name
    */
-  name: import_zod22.z.string().describe("Worker name"),
+  name: import_zod23.z.string().describe("Worker name"),
   /**
    * Queues to process
    */
-  queues: import_zod22.z.array(import_zod22.z.string()).min(1).describe("Queue names to process"),
+  queues: import_zod23.z.array(import_zod23.z.string()).min(1).describe("Queue names to process"),
   /**
    * Queue configurations
    */
-  queueConfigs: import_zod22.z.array(QueueConfigSchema).optional().describe("Queue configurations"),
+  queueConfigs: import_zod23.z.array(QueueConfigSchema).optional().describe("Queue configurations"),
   /**
    * Polling interval
    */
-  pollIntervalMs: import_zod22.z.number().int().positive().default(1e3).describe("Queue polling interval in milliseconds"),
+  pollIntervalMs: import_zod23.z.number().int().positive().default(1e3).describe("Queue polling interval in milliseconds"),
   /**
    * Visibility timeout
    */
-  visibilityTimeoutMs: import_zod22.z.number().int().positive().default(3e4).describe("How long a task is invisible after being claimed"),
+  visibilityTimeoutMs: import_zod23.z.number().int().positive().default(3e4).describe("How long a task is invisible after being claimed"),
   /**
    * Task timeout
    */
-  defaultTimeoutMs: import_zod22.z.number().int().positive().default(3e5).describe("Default task timeout in milliseconds"),
+  defaultTimeoutMs: import_zod23.z.number().int().positive().default(3e5).describe("Default task timeout in milliseconds"),
   /**
    * Graceful shutdown timeout
    */
-  shutdownTimeoutMs: import_zod22.z.number().int().positive().default(3e4).describe("Graceful shutdown timeout in milliseconds"),
+  shutdownTimeoutMs: import_zod23.z.number().int().positive().default(3e4).describe("Graceful shutdown timeout in milliseconds"),
   /**
    * Task handlers
    */
-  handlers: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.function()).optional().describe("Task type handlers")
+  handlers: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.function()).optional().describe("Task type handlers")
 });
-var WorkerStatsSchema = import_zod22.z.object({
+var WorkerStatsSchema = import_zod23.z.object({
   /**
    * Worker name
    */
-  workerName: import_zod22.z.string().describe("Worker name"),
+  workerName: import_zod23.z.string().describe("Worker name"),
   /**
    * Total tasks processed
    */
-  totalProcessed: import_zod22.z.number().int().min(0).describe("Total tasks processed"),
+  totalProcessed: import_zod23.z.number().int().min(0).describe("Total tasks processed"),
   /**
    * Successful tasks
    */
-  succeeded: import_zod22.z.number().int().min(0).describe("Successful tasks"),
+  succeeded: import_zod23.z.number().int().min(0).describe("Successful tasks"),
   /**
    * Failed tasks
    */
-  failed: import_zod22.z.number().int().min(0).describe("Failed tasks"),
+  failed: import_zod23.z.number().int().min(0).describe("Failed tasks"),
   /**
    * Active tasks
    */
-  active: import_zod22.z.number().int().min(0).describe("Currently active tasks"),
+  active: import_zod23.z.number().int().min(0).describe("Currently active tasks"),
   /**
    * Average execution time
    */
-  avgExecutionMs: import_zod22.z.number().min(0).optional().describe("Average execution time in milliseconds"),
+  avgExecutionMs: import_zod23.z.number().min(0).optional().describe("Average execution time in milliseconds"),
   /**
    * Uptime
    */
-  uptimeMs: import_zod22.z.number().int().min(0).describe("Worker uptime in milliseconds"),
+  uptimeMs: import_zod23.z.number().int().min(0).describe("Worker uptime in milliseconds"),
   /**
    * Queue stats
    */
-  queues: import_zod22.z.record(import_zod22.z.string(), import_zod22.z.object({
-    pending: import_zod22.z.number().int().min(0).describe("Pending tasks"),
-    active: import_zod22.z.number().int().min(0).describe("Active tasks"),
-    completed: import_zod22.z.number().int().min(0).describe("Completed tasks"),
-    failed: import_zod22.z.number().int().min(0).describe("Failed tasks")
+  queues: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.object({
+    pending: import_zod23.z.number().int().min(0).describe("Pending tasks"),
+    active: import_zod23.z.number().int().min(0).describe("Active tasks"),
+    completed: import_zod23.z.number().int().min(0).describe("Completed tasks"),
+    failed: import_zod23.z.number().int().min(0).describe("Failed tasks")
   })).optional().describe("Per-queue statistics")
 });
 var Task = Object.assign(TaskSchema, {
@@ -4598,113 +4696,113 @@ var BatchTask = Object.assign(BatchTaskSchema, {
 });
 
 // src/system/notification.zod.ts
-var import_zod23 = require("zod");
-var EmailTemplateSchema = import_zod23.z.object({
+var import_zod24 = require("zod");
+var EmailTemplateSchema = import_zod24.z.object({
   /**
    * Unique identifier for the email template
    */
-  id: import_zod23.z.string().describe("Template identifier"),
+  id: import_zod24.z.string().describe("Template identifier"),
   /**
    * Email subject line (supports variable interpolation)
    */
-  subject: import_zod23.z.string().describe("Email subject"),
+  subject: import_zod24.z.string().describe("Email subject"),
   /**
    * Email body content
    */
-  body: import_zod23.z.string().describe("Email body content"),
+  body: import_zod24.z.string().describe("Email body content"),
   /**
    * Content type of the email body
    * @default 'html'
    */
-  bodyType: import_zod23.z.enum(["text", "html", "markdown"]).optional().default("html").describe("Body content type"),
+  bodyType: import_zod24.z.enum(["text", "html", "markdown"]).optional().default("html").describe("Body content type"),
   /**
    * List of template variables for dynamic content
    */
-  variables: import_zod23.z.array(import_zod23.z.string()).optional().describe("Template variables"),
+  variables: import_zod24.z.array(import_zod24.z.string()).optional().describe("Template variables"),
   /**
    * File attachments to include with the email
    */
-  attachments: import_zod23.z.array(import_zod23.z.object({
-    name: import_zod23.z.string().describe("Attachment filename"),
-    url: import_zod23.z.string().url().describe("Attachment URL")
+  attachments: import_zod24.z.array(import_zod24.z.object({
+    name: import_zod24.z.string().describe("Attachment filename"),
+    url: import_zod24.z.string().url().describe("Attachment URL")
   })).optional().describe("Email attachments")
 });
-var SMSTemplateSchema = import_zod23.z.object({
+var SMSTemplateSchema = import_zod24.z.object({
   /**
    * Unique identifier for the SMS template
    */
-  id: import_zod23.z.string().describe("Template identifier"),
+  id: import_zod24.z.string().describe("Template identifier"),
   /**
    * SMS message content (supports variable interpolation)
    */
-  message: import_zod23.z.string().describe("SMS message content"),
+  message: import_zod24.z.string().describe("SMS message content"),
   /**
    * Maximum character length for the SMS
    * @default 160
    */
-  maxLength: import_zod23.z.number().optional().default(160).describe("Maximum message length"),
+  maxLength: import_zod24.z.number().optional().default(160).describe("Maximum message length"),
   /**
    * List of template variables for dynamic content
    */
-  variables: import_zod23.z.array(import_zod23.z.string()).optional().describe("Template variables")
+  variables: import_zod24.z.array(import_zod24.z.string()).optional().describe("Template variables")
 });
-var PushNotificationSchema = import_zod23.z.object({
+var PushNotificationSchema = import_zod24.z.object({
   /**
    * Notification title
    */
-  title: import_zod23.z.string().describe("Notification title"),
+  title: import_zod24.z.string().describe("Notification title"),
   /**
    * Notification body text
    */
-  body: import_zod23.z.string().describe("Notification body"),
+  body: import_zod24.z.string().describe("Notification body"),
   /**
    * Icon URL to display with notification
    */
-  icon: import_zod23.z.string().url().optional().describe("Notification icon URL"),
+  icon: import_zod24.z.string().url().optional().describe("Notification icon URL"),
   /**
    * Badge count to display on app icon
    */
-  badge: import_zod23.z.number().optional().describe("Badge count"),
+  badge: import_zod24.z.number().optional().describe("Badge count"),
   /**
    * Custom data payload
    */
-  data: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.any()).optional().describe("Custom data"),
+  data: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any()).optional().describe("Custom data"),
   /**
    * Action buttons for the notification
    */
-  actions: import_zod23.z.array(import_zod23.z.object({
-    action: import_zod23.z.string().describe("Action identifier"),
-    title: import_zod23.z.string().describe("Action button title")
+  actions: import_zod24.z.array(import_zod24.z.object({
+    action: import_zod24.z.string().describe("Action identifier"),
+    title: import_zod24.z.string().describe("Action button title")
   })).optional().describe("Notification actions")
 });
-var InAppNotificationSchema = import_zod23.z.object({
+var InAppNotificationSchema = import_zod24.z.object({
   /**
    * Notification title
    */
-  title: import_zod23.z.string().describe("Notification title"),
+  title: import_zod24.z.string().describe("Notification title"),
   /**
    * Notification message content
    */
-  message: import_zod23.z.string().describe("Notification message"),
+  message: import_zod24.z.string().describe("Notification message"),
   /**
    * Notification severity type
    */
-  type: import_zod23.z.enum(["info", "success", "warning", "error"]).describe("Notification type"),
+  type: import_zod24.z.enum(["info", "success", "warning", "error"]).describe("Notification type"),
   /**
    * Optional URL to navigate to when clicked
    */
-  actionUrl: import_zod23.z.string().optional().describe("Action URL"),
+  actionUrl: import_zod24.z.string().optional().describe("Action URL"),
   /**
    * Whether the notification can be dismissed by the user
    * @default true
    */
-  dismissible: import_zod23.z.boolean().optional().default(true).describe("User dismissible"),
+  dismissible: import_zod24.z.boolean().optional().default(true).describe("User dismissible"),
   /**
    * Timestamp when notification expires (Unix milliseconds)
    */
-  expiresAt: import_zod23.z.number().optional().describe("Expiration timestamp")
+  expiresAt: import_zod24.z.number().optional().describe("Expiration timestamp")
 });
-var NotificationChannelSchema = import_zod23.z.enum([
+var NotificationChannelSchema = import_zod24.z.enum([
   "email",
   "sms",
   "push",
@@ -4713,15 +4811,15 @@ var NotificationChannelSchema = import_zod23.z.enum([
   "teams",
   "webhook"
 ]);
-var NotificationConfigSchema = import_zod23.z.object({
+var NotificationConfigSchema = import_zod24.z.object({
   /**
    * Unique identifier for this notification configuration
    */
-  id: import_zod23.z.string().describe("Notification ID"),
+  id: import_zod24.z.string().describe("Notification ID"),
   /**
    * Human-readable name for this notification
    */
-  name: import_zod23.z.string().describe("Notification name"),
+  name: import_zod24.z.string().describe("Notification name"),
   /**
    * Delivery channel for the notification
    */
@@ -4729,7 +4827,7 @@ var NotificationConfigSchema = import_zod23.z.object({
   /**
    * Notification template based on channel type
    */
-  template: import_zod23.z.union([
+  template: import_zod24.z.union([
     EmailTemplateSchema,
     SMSTemplateSchema,
     PushNotificationSchema,
@@ -4738,106 +4836,106 @@ var NotificationConfigSchema = import_zod23.z.object({
   /**
    * Recipient configuration
    */
-  recipients: import_zod23.z.object({
+  recipients: import_zod24.z.object({
     /**
      * Primary recipients
      */
-    to: import_zod23.z.array(import_zod23.z.string()).describe("Primary recipients"),
+    to: import_zod24.z.array(import_zod24.z.string()).describe("Primary recipients"),
     /**
      * CC recipients (email only)
      */
-    cc: import_zod23.z.array(import_zod23.z.string()).optional().describe("CC recipients"),
+    cc: import_zod24.z.array(import_zod24.z.string()).optional().describe("CC recipients"),
     /**
      * BCC recipients (email only)
      */
-    bcc: import_zod23.z.array(import_zod23.z.string()).optional().describe("BCC recipients")
+    bcc: import_zod24.z.array(import_zod24.z.string()).optional().describe("BCC recipients")
   }).describe("Recipients"),
   /**
    * Scheduling configuration
    */
-  schedule: import_zod23.z.object({
+  schedule: import_zod24.z.object({
     /**
      * Scheduling type
      */
-    type: import_zod23.z.enum(["immediate", "delayed", "scheduled"]).describe("Schedule type"),
+    type: import_zod24.z.enum(["immediate", "delayed", "scheduled"]).describe("Schedule type"),
     /**
      * Delay in milliseconds (for delayed type)
      */
-    delay: import_zod23.z.number().optional().describe("Delay in milliseconds"),
+    delay: import_zod24.z.number().optional().describe("Delay in milliseconds"),
     /**
      * Scheduled send time (Unix timestamp in milliseconds)
      */
-    scheduledAt: import_zod23.z.number().optional().describe("Scheduled timestamp")
+    scheduledAt: import_zod24.z.number().optional().describe("Scheduled timestamp")
   }).optional().describe("Scheduling"),
   /**
    * Retry policy for failed deliveries
    */
-  retryPolicy: import_zod23.z.object({
+  retryPolicy: import_zod24.z.object({
     /**
      * Enable automatic retries
      * @default true
      */
-    enabled: import_zod23.z.boolean().optional().default(true).describe("Enable retries"),
+    enabled: import_zod24.z.boolean().optional().default(true).describe("Enable retries"),
     /**
      * Maximum number of retry attempts
      * @default 3
      */
-    maxRetries: import_zod23.z.number().optional().default(3).describe("Max retry attempts"),
+    maxRetries: import_zod24.z.number().optional().default(3).describe("Max retry attempts"),
     /**
      * Backoff strategy for retries
      */
-    backoffStrategy: import_zod23.z.enum(["exponential", "linear", "fixed"]).describe("Backoff strategy")
+    backoffStrategy: import_zod24.z.enum(["exponential", "linear", "fixed"]).describe("Backoff strategy")
   }).optional().describe("Retry policy"),
   /**
    * Delivery tracking configuration
    */
-  tracking: import_zod23.z.object({
+  tracking: import_zod24.z.object({
     /**
      * Track when emails are opened
      * @default false
      */
-    trackOpens: import_zod23.z.boolean().optional().default(false).describe("Track opens"),
+    trackOpens: import_zod24.z.boolean().optional().default(false).describe("Track opens"),
     /**
      * Track when links are clicked
      * @default false
      */
-    trackClicks: import_zod23.z.boolean().optional().default(false).describe("Track clicks"),
+    trackClicks: import_zod24.z.boolean().optional().default(false).describe("Track clicks"),
     /**
      * Track delivery status
      * @default true
      */
-    trackDelivery: import_zod23.z.boolean().optional().default(true).describe("Track delivery")
+    trackDelivery: import_zod24.z.boolean().optional().default(true).describe("Track delivery")
   }).optional().describe("Tracking configuration")
 });
 
 // src/system/translation.zod.ts
-var import_zod24 = require("zod");
-var TranslationDataSchema = import_zod24.z.object({
+var import_zod25 = require("zod");
+var TranslationDataSchema = import_zod25.z.object({
   /** Object translations */
-  objects: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.object({
-    label: import_zod24.z.string(),
-    pluralLabel: import_zod24.z.string().optional(),
-    fields: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.object({
-      label: import_zod24.z.string().optional(),
-      help: import_zod24.z.string().optional(),
-      options: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional()
+  objects: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.object({
+    label: import_zod25.z.string(),
+    pluralLabel: import_zod25.z.string().optional(),
+    fields: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.object({
+      label: import_zod25.z.string().optional(),
+      help: import_zod25.z.string().optional(),
+      options: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.string()).optional()
       // Option value -> Label map
     })).optional()
   })).optional(),
   /** App/Menu translations */
-  apps: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.object({
-    label: import_zod24.z.string(),
-    description: import_zod24.z.string().optional()
+  apps: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.object({
+    label: import_zod25.z.string(),
+    description: import_zod25.z.string().optional()
   })).optional(),
   /** UI Messages */
-  messages: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.string()).optional()
+  messages: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.string()).optional()
 });
-var LocaleSchema = import_zod24.z.string().describe("BCP-47 Language Tag (e.g. en-US, zh-CN)");
-var TranslationBundleSchema = import_zod24.z.record(LocaleSchema, TranslationDataSchema);
+var LocaleSchema = import_zod25.z.string().describe("BCP-47 Language Tag (e.g. en-US, zh-CN)");
+var TranslationBundleSchema = import_zod25.z.record(LocaleSchema, TranslationDataSchema);
 
 // src/system/collaboration.zod.ts
-var import_zod25 = require("zod");
-var OTOperationType = import_zod25.z.enum([
+var import_zod26 = require("zod");
+var OTOperationType = import_zod26.z.enum([
   "insert",
   // Insert characters at position
   "delete",
@@ -4845,38 +4943,38 @@ var OTOperationType = import_zod25.z.enum([
   "retain"
   // Keep characters (used for composing operations)
 ]);
-var OTComponentSchema = import_zod25.z.discriminatedUnion("type", [
-  import_zod25.z.object({
-    type: import_zod25.z.literal("insert"),
-    text: import_zod25.z.string().describe("Text to insert"),
-    attributes: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Text formatting attributes (e.g., bold, italic)")
+var OTComponentSchema = import_zod26.z.discriminatedUnion("type", [
+  import_zod26.z.object({
+    type: import_zod26.z.literal("insert"),
+    text: import_zod26.z.string().describe("Text to insert"),
+    attributes: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Text formatting attributes (e.g., bold, italic)")
   }),
-  import_zod25.z.object({
-    type: import_zod25.z.literal("delete"),
-    count: import_zod25.z.number().int().positive().describe("Number of characters to delete")
+  import_zod26.z.object({
+    type: import_zod26.z.literal("delete"),
+    count: import_zod26.z.number().int().positive().describe("Number of characters to delete")
   }),
-  import_zod25.z.object({
-    type: import_zod25.z.literal("retain"),
-    count: import_zod25.z.number().int().positive().describe("Number of characters to retain"),
-    attributes: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Attribute changes to apply")
+  import_zod26.z.object({
+    type: import_zod26.z.literal("retain"),
+    count: import_zod26.z.number().int().positive().describe("Number of characters to retain"),
+    attributes: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Attribute changes to apply")
   })
 ]);
-var OTOperationSchema = import_zod25.z.object({
-  operationId: import_zod25.z.string().uuid().describe("Unique operation identifier"),
-  documentId: import_zod25.z.string().describe("Document identifier"),
-  userId: import_zod25.z.string().describe("User who created the operation"),
-  sessionId: import_zod25.z.string().uuid().describe("Session identifier"),
-  components: import_zod25.z.array(OTComponentSchema).describe("Operation components"),
-  baseVersion: import_zod25.z.number().int().nonnegative().describe("Document version this operation is based on"),
-  timestamp: import_zod25.z.string().datetime().describe("ISO 8601 datetime when operation was created"),
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Additional operation metadata")
-});
-var OTTransformResultSchema = import_zod25.z.object({
+var OTOperationSchema = import_zod26.z.object({
+  operationId: import_zod26.z.string().uuid().describe("Unique operation identifier"),
+  documentId: import_zod26.z.string().describe("Document identifier"),
+  userId: import_zod26.z.string().describe("User who created the operation"),
+  sessionId: import_zod26.z.string().uuid().describe("Session identifier"),
+  components: import_zod26.z.array(OTComponentSchema).describe("Operation components"),
+  baseVersion: import_zod26.z.number().int().nonnegative().describe("Document version this operation is based on"),
+  timestamp: import_zod26.z.string().datetime().describe("ISO 8601 datetime when operation was created"),
+  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Additional operation metadata")
+});
+var OTTransformResultSchema = import_zod26.z.object({
   operation: OTOperationSchema.describe("Transformed operation"),
-  transformed: import_zod25.z.boolean().describe("Whether transformation was applied"),
-  conflicts: import_zod25.z.array(import_zod25.z.string()).optional().describe("Conflict descriptions if any")
+  transformed: import_zod26.z.boolean().describe("Whether transformation was applied"),
+  conflicts: import_zod26.z.array(import_zod26.z.string()).optional().describe("Conflict descriptions if any")
 });
-var CRDTType = import_zod25.z.enum([
+var CRDTType = import_zod26.z.enum([
   "lww-register",
   // Last-Write-Wins Register
   "g-counter",
@@ -4896,74 +4994,74 @@ var CRDTType = import_zod25.z.enum([
   "json"
   // CRDT-based JSON (e.g., Automerge)
 ]);
-var VectorClockSchema = import_zod25.z.object({
-  clock: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.number().int().nonnegative()).describe("Map of replica ID to logical timestamp")
-});
-var LWWRegisterSchema = import_zod25.z.object({
-  type: import_zod25.z.literal("lww-register"),
-  value: import_zod25.z.any().describe("Current register value"),
-  timestamp: import_zod25.z.string().datetime().describe("ISO 8601 datetime of last write"),
-  replicaId: import_zod25.z.string().describe("ID of replica that performed last write"),
+var VectorClockSchema = import_zod26.z.object({
+  clock: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.number().int().nonnegative()).describe("Map of replica ID to logical timestamp")
+});
+var LWWRegisterSchema = import_zod26.z.object({
+  type: import_zod26.z.literal("lww-register"),
+  value: import_zod26.z.any().describe("Current register value"),
+  timestamp: import_zod26.z.string().datetime().describe("ISO 8601 datetime of last write"),
+  replicaId: import_zod26.z.string().describe("ID of replica that performed last write"),
   vectorClock: VectorClockSchema.optional().describe("Optional vector clock for causality tracking")
 });
-var CounterOperationSchema = import_zod25.z.object({
-  replicaId: import_zod25.z.string().describe("Replica identifier"),
-  delta: import_zod25.z.number().int().describe("Change amount (positive for increment, negative for decrement)"),
-  timestamp: import_zod25.z.string().datetime().describe("ISO 8601 datetime of operation")
-});
-var GCounterSchema = import_zod25.z.object({
-  type: import_zod25.z.literal("g-counter"),
-  counts: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.number().int().nonnegative()).describe("Map of replica ID to count")
-});
-var PNCounterSchema = import_zod25.z.object({
-  type: import_zod25.z.literal("pn-counter"),
-  positive: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.number().int().nonnegative()).describe("Positive increments per replica"),
-  negative: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.number().int().nonnegative()).describe("Negative increments per replica")
-});
-var ORSetElementSchema = import_zod25.z.object({
-  value: import_zod25.z.any().describe("Element value"),
-  timestamp: import_zod25.z.string().datetime().describe("Addition timestamp"),
-  replicaId: import_zod25.z.string().describe("Replica that added the element"),
-  uid: import_zod25.z.string().uuid().describe("Unique identifier for this addition"),
-  removed: import_zod25.z.boolean().optional().default(false).describe("Whether element has been removed")
-});
-var ORSetSchema = import_zod25.z.object({
-  type: import_zod25.z.literal("or-set"),
-  elements: import_zod25.z.array(ORSetElementSchema).describe("Set elements with metadata")
-});
-var TextCRDTOperationSchema = import_zod25.z.object({
-  operationId: import_zod25.z.string().uuid().describe("Unique operation identifier"),
-  replicaId: import_zod25.z.string().describe("Replica identifier"),
-  position: import_zod25.z.number().int().nonnegative().describe("Position in document"),
-  insert: import_zod25.z.string().optional().describe("Text to insert"),
-  delete: import_zod25.z.number().int().positive().optional().describe("Number of characters to delete"),
-  timestamp: import_zod25.z.string().datetime().describe("ISO 8601 datetime of operation"),
-  lamportTimestamp: import_zod25.z.number().int().nonnegative().describe("Lamport timestamp for ordering")
-});
-var TextCRDTStateSchema = import_zod25.z.object({
-  type: import_zod25.z.literal("text"),
-  documentId: import_zod25.z.string().describe("Document identifier"),
-  content: import_zod25.z.string().describe("Current text content"),
-  operations: import_zod25.z.array(TextCRDTOperationSchema).describe("History of operations"),
-  lamportClock: import_zod25.z.number().int().nonnegative().describe("Current Lamport clock value"),
+var CounterOperationSchema = import_zod26.z.object({
+  replicaId: import_zod26.z.string().describe("Replica identifier"),
+  delta: import_zod26.z.number().int().describe("Change amount (positive for increment, negative for decrement)"),
+  timestamp: import_zod26.z.string().datetime().describe("ISO 8601 datetime of operation")
+});
+var GCounterSchema = import_zod26.z.object({
+  type: import_zod26.z.literal("g-counter"),
+  counts: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.number().int().nonnegative()).describe("Map of replica ID to count")
+});
+var PNCounterSchema = import_zod26.z.object({
+  type: import_zod26.z.literal("pn-counter"),
+  positive: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.number().int().nonnegative()).describe("Positive increments per replica"),
+  negative: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.number().int().nonnegative()).describe("Negative increments per replica")
+});
+var ORSetElementSchema = import_zod26.z.object({
+  value: import_zod26.z.any().describe("Element value"),
+  timestamp: import_zod26.z.string().datetime().describe("Addition timestamp"),
+  replicaId: import_zod26.z.string().describe("Replica that added the element"),
+  uid: import_zod26.z.string().uuid().describe("Unique identifier for this addition"),
+  removed: import_zod26.z.boolean().optional().default(false).describe("Whether element has been removed")
+});
+var ORSetSchema = import_zod26.z.object({
+  type: import_zod26.z.literal("or-set"),
+  elements: import_zod26.z.array(ORSetElementSchema).describe("Set elements with metadata")
+});
+var TextCRDTOperationSchema = import_zod26.z.object({
+  operationId: import_zod26.z.string().uuid().describe("Unique operation identifier"),
+  replicaId: import_zod26.z.string().describe("Replica identifier"),
+  position: import_zod26.z.number().int().nonnegative().describe("Position in document"),
+  insert: import_zod26.z.string().optional().describe("Text to insert"),
+  delete: import_zod26.z.number().int().positive().optional().describe("Number of characters to delete"),
+  timestamp: import_zod26.z.string().datetime().describe("ISO 8601 datetime of operation"),
+  lamportTimestamp: import_zod26.z.number().int().nonnegative().describe("Lamport timestamp for ordering")
+});
+var TextCRDTStateSchema = import_zod26.z.object({
+  type: import_zod26.z.literal("text"),
+  documentId: import_zod26.z.string().describe("Document identifier"),
+  content: import_zod26.z.string().describe("Current text content"),
+  operations: import_zod26.z.array(TextCRDTOperationSchema).describe("History of operations"),
+  lamportClock: import_zod26.z.number().int().nonnegative().describe("Current Lamport clock value"),
   vectorClock: VectorClockSchema.describe("Vector clock for causality")
 });
-var CRDTStateSchema = import_zod25.z.discriminatedUnion("type", [
+var CRDTStateSchema = import_zod26.z.discriminatedUnion("type", [
   LWWRegisterSchema,
   GCounterSchema,
   PNCounterSchema,
   ORSetSchema,
   TextCRDTStateSchema
 ]);
-var CRDTMergeResultSchema = import_zod25.z.object({
+var CRDTMergeResultSchema = import_zod26.z.object({
   state: CRDTStateSchema.describe("Merged CRDT state"),
-  conflicts: import_zod25.z.array(import_zod25.z.object({
-    type: import_zod25.z.string().describe("Conflict type"),
-    description: import_zod25.z.string().describe("Conflict description"),
-    resolved: import_zod25.z.boolean().describe("Whether conflict was automatically resolved")
+  conflicts: import_zod26.z.array(import_zod26.z.object({
+    type: import_zod26.z.string().describe("Conflict type"),
+    description: import_zod26.z.string().describe("Conflict description"),
+    resolved: import_zod26.z.boolean().describe("Whether conflict was automatically resolved")
   })).optional().describe("Conflicts encountered during merge")
 });
-var CursorColorPreset = import_zod25.z.enum([
+var CursorColorPreset = import_zod26.z.enum([
   "blue",
   "green",
   "red",
@@ -4975,49 +5073,49 @@ var CursorColorPreset = import_zod25.z.enum([
   "indigo",
   "cyan"
 ]);
-var CursorStyleSchema = import_zod25.z.object({
-  color: import_zod25.z.union([CursorColorPreset, import_zod25.z.string()]).describe("Cursor color (preset or custom hex)"),
-  opacity: import_zod25.z.number().min(0).max(1).optional().default(1).describe("Cursor opacity (0-1)"),
-  label: import_zod25.z.string().optional().describe("Label to display with cursor (usually username)"),
-  showLabel: import_zod25.z.boolean().optional().default(true).describe("Whether to show label"),
-  pulseOnUpdate: import_zod25.z.boolean().optional().default(true).describe("Whether to pulse when cursor moves")
-});
-var CursorSelectionSchema = import_zod25.z.object({
-  anchor: import_zod25.z.object({
-    line: import_zod25.z.number().int().nonnegative().describe("Anchor line number"),
-    column: import_zod25.z.number().int().nonnegative().describe("Anchor column number")
+var CursorStyleSchema = import_zod26.z.object({
+  color: import_zod26.z.union([CursorColorPreset, import_zod26.z.string()]).describe("Cursor color (preset or custom hex)"),
+  opacity: import_zod26.z.number().min(0).max(1).optional().default(1).describe("Cursor opacity (0-1)"),
+  label: import_zod26.z.string().optional().describe("Label to display with cursor (usually username)"),
+  showLabel: import_zod26.z.boolean().optional().default(true).describe("Whether to show label"),
+  pulseOnUpdate: import_zod26.z.boolean().optional().default(true).describe("Whether to pulse when cursor moves")
+});
+var CursorSelectionSchema = import_zod26.z.object({
+  anchor: import_zod26.z.object({
+    line: import_zod26.z.number().int().nonnegative().describe("Anchor line number"),
+    column: import_zod26.z.number().int().nonnegative().describe("Anchor column number")
   }).describe("Selection anchor (start point)"),
-  focus: import_zod25.z.object({
-    line: import_zod25.z.number().int().nonnegative().describe("Focus line number"),
-    column: import_zod25.z.number().int().nonnegative().describe("Focus column number")
+  focus: import_zod26.z.object({
+    line: import_zod26.z.number().int().nonnegative().describe("Focus line number"),
+    column: import_zod26.z.number().int().nonnegative().describe("Focus column number")
   }).describe("Selection focus (end point)"),
-  direction: import_zod25.z.enum(["forward", "backward"]).optional().describe("Selection direction")
-});
-var CollaborativeCursorSchema = import_zod25.z.object({
-  userId: import_zod25.z.string().describe("User identifier"),
-  sessionId: import_zod25.z.string().uuid().describe("Session identifier"),
-  documentId: import_zod25.z.string().describe("Document identifier"),
-  userName: import_zod25.z.string().describe("Display name of user"),
-  position: import_zod25.z.object({
-    line: import_zod25.z.number().int().nonnegative().describe("Cursor line number (0-indexed)"),
-    column: import_zod25.z.number().int().nonnegative().describe("Cursor column number (0-indexed)")
+  direction: import_zod26.z.enum(["forward", "backward"]).optional().describe("Selection direction")
+});
+var CollaborativeCursorSchema = import_zod26.z.object({
+  userId: import_zod26.z.string().describe("User identifier"),
+  sessionId: import_zod26.z.string().uuid().describe("Session identifier"),
+  documentId: import_zod26.z.string().describe("Document identifier"),
+  userName: import_zod26.z.string().describe("Display name of user"),
+  position: import_zod26.z.object({
+    line: import_zod26.z.number().int().nonnegative().describe("Cursor line number (0-indexed)"),
+    column: import_zod26.z.number().int().nonnegative().describe("Cursor column number (0-indexed)")
   }).describe("Current cursor position"),
   selection: CursorSelectionSchema.optional().describe("Current text selection"),
   style: CursorStyleSchema.describe("Visual style for this cursor"),
-  isTyping: import_zod25.z.boolean().optional().default(false).describe("Whether user is currently typing"),
-  lastUpdate: import_zod25.z.string().datetime().describe("ISO 8601 datetime of last cursor update"),
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Additional cursor metadata")
-});
-var CursorUpdateSchema = import_zod25.z.object({
-  position: import_zod25.z.object({
-    line: import_zod25.z.number().int().nonnegative(),
-    column: import_zod25.z.number().int().nonnegative()
+  isTyping: import_zod26.z.boolean().optional().default(false).describe("Whether user is currently typing"),
+  lastUpdate: import_zod26.z.string().datetime().describe("ISO 8601 datetime of last cursor update"),
+  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Additional cursor metadata")
+});
+var CursorUpdateSchema = import_zod26.z.object({
+  position: import_zod26.z.object({
+    line: import_zod26.z.number().int().nonnegative(),
+    column: import_zod26.z.number().int().nonnegative()
   }).optional().describe("Updated cursor position"),
   selection: CursorSelectionSchema.optional().describe("Updated selection"),
-  isTyping: import_zod25.z.boolean().optional().describe("Updated typing state"),
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Updated metadata")
+  isTyping: import_zod26.z.boolean().optional().describe("Updated typing state"),
+  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Updated metadata")
 });
-var UserActivityStatus = import_zod25.z.enum([
+var UserActivityStatus = import_zod26.z.enum([
   "active",
   // User is actively editing
   "idle",
@@ -5027,48 +5125,48 @@ var UserActivityStatus = import_zod25.z.enum([
   "disconnected"
   // User is disconnected
 ]);
-var AwarenessUserStateSchema = import_zod25.z.object({
-  userId: import_zod25.z.string().describe("User identifier"),
-  sessionId: import_zod25.z.string().uuid().describe("Session identifier"),
-  userName: import_zod25.z.string().describe("Display name"),
-  userAvatar: import_zod25.z.string().optional().describe("User avatar URL"),
+var AwarenessUserStateSchema = import_zod26.z.object({
+  userId: import_zod26.z.string().describe("User identifier"),
+  sessionId: import_zod26.z.string().uuid().describe("Session identifier"),
+  userName: import_zod26.z.string().describe("Display name"),
+  userAvatar: import_zod26.z.string().optional().describe("User avatar URL"),
   status: UserActivityStatus.describe("Current activity status"),
-  currentDocument: import_zod25.z.string().optional().describe("Document ID user is currently editing"),
-  currentView: import_zod25.z.string().optional().describe("Current view/page user is on"),
-  lastActivity: import_zod25.z.string().datetime().describe("ISO 8601 datetime of last activity"),
-  joinedAt: import_zod25.z.string().datetime().describe("ISO 8601 datetime when user joined session"),
-  permissions: import_zod25.z.array(import_zod25.z.string()).optional().describe("User permissions in this session"),
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Additional user state metadata")
-});
-var AwarenessSessionSchema = import_zod25.z.object({
-  sessionId: import_zod25.z.string().uuid().describe("Session identifier"),
-  documentId: import_zod25.z.string().optional().describe("Document ID this session is for"),
-  users: import_zod25.z.array(AwarenessUserStateSchema).describe("Active users in session"),
-  startedAt: import_zod25.z.string().datetime().describe("ISO 8601 datetime when session started"),
-  lastUpdate: import_zod25.z.string().datetime().describe("ISO 8601 datetime of last update"),
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Session metadata")
-});
-var AwarenessUpdateSchema = import_zod25.z.object({
+  currentDocument: import_zod26.z.string().optional().describe("Document ID user is currently editing"),
+  currentView: import_zod26.z.string().optional().describe("Current view/page user is on"),
+  lastActivity: import_zod26.z.string().datetime().describe("ISO 8601 datetime of last activity"),
+  joinedAt: import_zod26.z.string().datetime().describe("ISO 8601 datetime when user joined session"),
+  permissions: import_zod26.z.array(import_zod26.z.string()).optional().describe("User permissions in this session"),
+  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Additional user state metadata")
+});
+var AwarenessSessionSchema = import_zod26.z.object({
+  sessionId: import_zod26.z.string().uuid().describe("Session identifier"),
+  documentId: import_zod26.z.string().optional().describe("Document ID this session is for"),
+  users: import_zod26.z.array(AwarenessUserStateSchema).describe("Active users in session"),
+  startedAt: import_zod26.z.string().datetime().describe("ISO 8601 datetime when session started"),
+  lastUpdate: import_zod26.z.string().datetime().describe("ISO 8601 datetime of last update"),
+  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Session metadata")
+});
+var AwarenessUpdateSchema = import_zod26.z.object({
   status: UserActivityStatus.optional().describe("Updated status"),
-  currentDocument: import_zod25.z.string().optional().describe("Updated current document"),
-  currentView: import_zod25.z.string().optional().describe("Updated current view"),
-  metadata: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).optional().describe("Updated metadata")
-});
-var AwarenessEventSchema = import_zod25.z.object({
-  eventId: import_zod25.z.string().uuid().describe("Event identifier"),
-  sessionId: import_zod25.z.string().uuid().describe("Session identifier"),
-  eventType: import_zod25.z.enum([
+  currentDocument: import_zod26.z.string().optional().describe("Updated current document"),
+  currentView: import_zod26.z.string().optional().describe("Updated current view"),
+  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).optional().describe("Updated metadata")
+});
+var AwarenessEventSchema = import_zod26.z.object({
+  eventId: import_zod26.z.string().uuid().describe("Event identifier"),
+  sessionId: import_zod26.z.string().uuid().describe("Session identifier"),
+  eventType: import_zod26.z.enum([
     "user.joined",
     "user.left",
     "user.updated",
     "session.created",
     "session.ended"
   ]).describe("Type of awareness event"),
-  userId: import_zod25.z.string().optional().describe("User involved in event"),
-  timestamp: import_zod25.z.string().datetime().describe("ISO 8601 datetime of event"),
-  payload: import_zod25.z.any().describe("Event payload")
+  userId: import_zod26.z.string().optional().describe("User involved in event"),
+  timestamp: import_zod26.z.string().datetime().describe("ISO 8601 datetime of event"),
+  payload: import_zod26.z.any().describe("Event payload")
 });
-var CollaborationMode = import_zod25.z.enum([
+var CollaborationMode = import_zod26.z.enum([
   "ot",
   // Operational Transformation
   "crdt",
@@ -5078,36 +5176,36 @@ var CollaborationMode = import_zod25.z.enum([
   "hybrid"
   // Hybrid approach
 ]);
-var CollaborationSessionConfigSchema = import_zod25.z.object({
+var CollaborationSessionConfigSchema = import_zod26.z.object({
   mode: CollaborationMode.describe("Collaboration mode to use"),
-  enableCursorSharing: import_zod25.z.boolean().optional().default(true).describe("Enable cursor sharing"),
-  enablePresence: import_zod25.z.boolean().optional().default(true).describe("Enable presence tracking"),
-  enableAwareness: import_zod25.z.boolean().optional().default(true).describe("Enable awareness state"),
-  maxUsers: import_zod25.z.number().int().positive().optional().describe("Maximum concurrent users"),
-  idleTimeout: import_zod25.z.number().int().positive().optional().default(3e5).describe("Idle timeout in milliseconds"),
-  conflictResolution: import_zod25.z.enum(["ot", "crdt", "manual"]).optional().default("ot").describe("Conflict resolution strategy"),
-  persistence: import_zod25.z.boolean().optional().default(true).describe("Enable operation persistence"),
-  snapshot: import_zod25.z.object({
-    enabled: import_zod25.z.boolean().describe("Enable periodic snapshots"),
-    interval: import_zod25.z.number().int().positive().describe("Snapshot interval in milliseconds")
+  enableCursorSharing: import_zod26.z.boolean().optional().default(true).describe("Enable cursor sharing"),
+  enablePresence: import_zod26.z.boolean().optional().default(true).describe("Enable presence tracking"),
+  enableAwareness: import_zod26.z.boolean().optional().default(true).describe("Enable awareness state"),
+  maxUsers: import_zod26.z.number().int().positive().optional().describe("Maximum concurrent users"),
+  idleTimeout: import_zod26.z.number().int().positive().optional().default(3e5).describe("Idle timeout in milliseconds"),
+  conflictResolution: import_zod26.z.enum(["ot", "crdt", "manual"]).optional().default("ot").describe("Conflict resolution strategy"),
+  persistence: import_zod26.z.boolean().optional().default(true).describe("Enable operation persistence"),
+  snapshot: import_zod26.z.object({
+    enabled: import_zod26.z.boolean().describe("Enable periodic snapshots"),
+    interval: import_zod26.z.number().int().positive().describe("Snapshot interval in milliseconds")
   }).optional().describe("Snapshot configuration")
 });
-var CollaborationSessionSchema = import_zod25.z.object({
-  sessionId: import_zod25.z.string().uuid().describe("Session identifier"),
-  documentId: import_zod25.z.string().describe("Document identifier"),
+var CollaborationSessionSchema = import_zod26.z.object({
+  sessionId: import_zod26.z.string().uuid().describe("Session identifier"),
+  documentId: import_zod26.z.string().describe("Document identifier"),
   config: CollaborationSessionConfigSchema.describe("Session configuration"),
-  users: import_zod25.z.array(AwarenessUserStateSchema).describe("Active users"),
-  cursors: import_zod25.z.array(CollaborativeCursorSchema).describe("Active cursors"),
-  version: import_zod25.z.number().int().nonnegative().describe("Current document version"),
-  operations: import_zod25.z.array(import_zod25.z.union([OTOperationSchema, TextCRDTOperationSchema])).optional().describe("Recent operations"),
-  createdAt: import_zod25.z.string().datetime().describe("ISO 8601 datetime when session was created"),
-  lastActivity: import_zod25.z.string().datetime().describe("ISO 8601 datetime of last activity"),
-  status: import_zod25.z.enum(["active", "idle", "ended"]).describe("Session status")
+  users: import_zod26.z.array(AwarenessUserStateSchema).describe("Active users"),
+  cursors: import_zod26.z.array(CollaborativeCursorSchema).describe("Active cursors"),
+  version: import_zod26.z.number().int().nonnegative().describe("Current document version"),
+  operations: import_zod26.z.array(import_zod26.z.union([OTOperationSchema, TextCRDTOperationSchema])).optional().describe("Recent operations"),
+  createdAt: import_zod26.z.string().datetime().describe("ISO 8601 datetime when session was created"),
+  lastActivity: import_zod26.z.string().datetime().describe("ISO 8601 datetime of last activity"),
+  status: import_zod26.z.enum(["active", "idle", "ended"]).describe("Session status")
 });
 
 // src/system/metadata-persistence.zod.ts
-var import_zod26 = require("zod");
-var MetadataScopeSchema = import_zod26.z.enum([
+var import_zod27 = require("zod");
+var MetadataScopeSchema = import_zod27.z.enum([
   "system",
   // Defined in Code (Files). Read-only at runtime. Upgraded via deployment.
   "platform",
@@ -5115,7 +5213,7 @@ var MetadataScopeSchema = import_zod26.z.enum([
   "user"
   // Defined in DB (Personal). User-configured. Overrides platform/system.
 ]);
-var MetadataStateSchema = import_zod26.z.enum([
+var MetadataStateSchema = import_zod27.z.enum([
   "draft",
   // Work in progress, not active
   "active",
@@ -5125,24 +5223,24 @@ var MetadataStateSchema = import_zod26.z.enum([
   "deprecated"
   // Running but flagged for removal
 ]);
-var MetadataRecordSchema = import_zod26.z.object({
+var MetadataRecordSchema = import_zod27.z.object({
   /** Primary Key (UUID) */
-  _id: import_zod26.z.string(),
+  _id: import_zod27.z.string(),
   /** 
    * Machine Name 
    * The unique identifier used in code references (e.g. "account_list_view").
    */
-  name: import_zod26.z.string(),
+  name: import_zod27.z.string(),
   /**
    * Metadata Type
    * e.g. "object", "view", "permission_set", "flow"
    */
-  type: import_zod26.z.string(),
+  type: import_zod27.z.string(),
   /**
    * Namespace / Module
    * Groups metadata into packages (e.g. "crm", "finance", "core").
    */
-  namespace: import_zod26.z.string().default("default"),
+  namespace: import_zod27.z.string().default("default"),
   /**
    * Ownership differentiation
    */
@@ -5152,24 +5250,24 @@ var MetadataRecordSchema = import_zod26.z.object({
    * Stores the actual configuration JSON.
    * This field holds the value of `ViewSchema`, `ObjectSchema`, etc.
    */
-  metadata: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()),
+  metadata: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.any()),
   /**
    * Extension / Merge Strategy
    * If this record overrides a system record, how should it be applied?
    */
-  extends: import_zod26.z.string().optional().describe("Name of the parent metadata to extend/override"),
-  strategy: import_zod26.z.enum(["merge", "replace"]).default("merge"),
+  extends: import_zod27.z.string().optional().describe("Name of the parent metadata to extend/override"),
+  strategy: import_zod27.z.enum(["merge", "replace"]).default("merge"),
   /** Owner (for user-scope items) */
-  owner: import_zod26.z.string().optional(),
+  owner: import_zod27.z.string().optional(),
   /** State */
   state: MetadataStateSchema.default("active"),
   /** Audit */
-  created_by: import_zod26.z.string().optional(),
-  created_at: import_zod26.z.date().optional(),
-  updated_by: import_zod26.z.string().optional(),
-  updated_at: import_zod26.z.date().optional()
+  created_by: import_zod27.z.string().optional(),
+  created_at: import_zod27.z.date().optional(),
+  updated_by: import_zod27.z.string().optional(),
+  updated_at: import_zod27.z.date().optional()
 });
-var MetadataFormatSchema = import_zod26.z.enum([
+var MetadataFormatSchema = import_zod27.z.enum([
   "json",
   "yaml",
   "yml",
@@ -5179,120 +5277,120 @@ var MetadataFormatSchema = import_zod26.z.enum([
   "javascript"
   // Aliases
 ]);
-var MetadataStatsSchema = import_zod26.z.object({
-  path: import_zod26.z.string().optional(),
-  size: import_zod26.z.number().optional(),
-  mtime: import_zod26.z.date().optional(),
-  hash: import_zod26.z.string().optional(),
-  etag: import_zod26.z.string().optional(),
+var MetadataStatsSchema = import_zod27.z.object({
+  path: import_zod27.z.string().optional(),
+  size: import_zod27.z.number().optional(),
+  mtime: import_zod27.z.date().optional(),
+  hash: import_zod27.z.string().optional(),
+  etag: import_zod27.z.string().optional(),
   // Required by local cache
-  modifiedAt: import_zod26.z.date().optional(),
+  modifiedAt: import_zod27.z.date().optional(),
   // Alias for mtime
   format: MetadataFormatSchema.optional()
   // Required for serialization
 });
-var MetadataLoaderContractSchema = import_zod26.z.object({
-  name: import_zod26.z.string(),
-  protocol: import_zod26.z.string(),
+var MetadataLoaderContractSchema = import_zod27.z.object({
+  name: import_zod27.z.string(),
+  protocol: import_zod27.z.string(),
   // e.g. 'file:', 'http:', 's3:'
-  description: import_zod26.z.string().optional(),
-  supportedFormats: import_zod26.z.array(import_zod26.z.string()).optional(),
-  supportsWatch: import_zod26.z.boolean().optional(),
-  supportsWrite: import_zod26.z.boolean().optional(),
-  supportsCache: import_zod26.z.boolean().optional(),
-  capabilities: import_zod26.z.object({
-    read: import_zod26.z.boolean().default(true),
-    write: import_zod26.z.boolean().default(false),
-    watch: import_zod26.z.boolean().default(false),
-    list: import_zod26.z.boolean().default(true)
+  description: import_zod27.z.string().optional(),
+  supportedFormats: import_zod27.z.array(import_zod27.z.string()).optional(),
+  supportsWatch: import_zod27.z.boolean().optional(),
+  supportsWrite: import_zod27.z.boolean().optional(),
+  supportsCache: import_zod27.z.boolean().optional(),
+  capabilities: import_zod27.z.object({
+    read: import_zod27.z.boolean().default(true),
+    write: import_zod27.z.boolean().default(false),
+    watch: import_zod27.z.boolean().default(false),
+    list: import_zod27.z.boolean().default(true)
   })
 });
-var MetadataLoadOptionsSchema = import_zod26.z.object({
+var MetadataLoadOptionsSchema = import_zod27.z.object({
   scope: MetadataScopeSchema.optional(),
-  namespace: import_zod26.z.string().optional(),
-  raw: import_zod26.z.boolean().optional().describe("Return raw file content instead of parsed JSON"),
-  cache: import_zod26.z.boolean().optional(),
-  useCache: import_zod26.z.boolean().optional(),
+  namespace: import_zod27.z.string().optional(),
+  raw: import_zod27.z.boolean().optional().describe("Return raw file content instead of parsed JSON"),
+  cache: import_zod27.z.boolean().optional(),
+  useCache: import_zod27.z.boolean().optional(),
   // Alias for cache
-  validate: import_zod26.z.boolean().optional(),
-  ifNoneMatch: import_zod26.z.string().optional(),
+  validate: import_zod27.z.boolean().optional(),
+  ifNoneMatch: import_zod27.z.string().optional(),
   // For caching
-  recursive: import_zod26.z.boolean().optional(),
-  limit: import_zod26.z.number().optional(),
-  patterns: import_zod26.z.array(import_zod26.z.string()).optional(),
-  loader: import_zod26.z.string().optional().describe("Specific loader to use (e.g. filesystem, database)")
+  recursive: import_zod27.z.boolean().optional(),
+  limit: import_zod27.z.number().optional(),
+  patterns: import_zod27.z.array(import_zod27.z.string()).optional(),
+  loader: import_zod27.z.string().optional().describe("Specific loader to use (e.g. filesystem, database)")
 });
-var MetadataLoadResultSchema = import_zod26.z.object({
-  data: import_zod26.z.any(),
+var MetadataLoadResultSchema = import_zod27.z.object({
+  data: import_zod27.z.any(),
   stats: MetadataStatsSchema.optional(),
   format: MetadataFormatSchema.optional(),
-  source: import_zod26.z.string().optional(),
+  source: import_zod27.z.string().optional(),
   // File path or URL
-  fromCache: import_zod26.z.boolean().optional(),
-  etag: import_zod26.z.string().optional(),
-  notModified: import_zod26.z.boolean().optional(),
-  loadTime: import_zod26.z.number().optional()
+  fromCache: import_zod27.z.boolean().optional(),
+  etag: import_zod27.z.string().optional(),
+  notModified: import_zod27.z.boolean().optional(),
+  loadTime: import_zod27.z.number().optional()
 });
-var MetadataSaveOptionsSchema = import_zod26.z.object({
+var MetadataSaveOptionsSchema = import_zod27.z.object({
   format: MetadataFormatSchema.optional(),
-  create: import_zod26.z.boolean().default(true),
-  overwrite: import_zod26.z.boolean().default(true),
-  path: import_zod26.z.string().optional(),
-  prettify: import_zod26.z.boolean().optional(),
-  indent: import_zod26.z.number().optional(),
-  sortKeys: import_zod26.z.boolean().optional(),
-  backup: import_zod26.z.boolean().optional(),
-  atomic: import_zod26.z.boolean().optional(),
-  loader: import_zod26.z.string().optional().describe("Specific loader to use (e.g. filesystem, database)")
-});
-var MetadataSaveResultSchema = import_zod26.z.object({
-  success: import_zod26.z.boolean(),
-  path: import_zod26.z.string().optional(),
+  create: import_zod27.z.boolean().default(true),
+  overwrite: import_zod27.z.boolean().default(true),
+  path: import_zod27.z.string().optional(),
+  prettify: import_zod27.z.boolean().optional(),
+  indent: import_zod27.z.number().optional(),
+  sortKeys: import_zod27.z.boolean().optional(),
+  backup: import_zod27.z.boolean().optional(),
+  atomic: import_zod27.z.boolean().optional(),
+  loader: import_zod27.z.string().optional().describe("Specific loader to use (e.g. filesystem, database)")
+});
+var MetadataSaveResultSchema = import_zod27.z.object({
+  success: import_zod27.z.boolean(),
+  path: import_zod27.z.string().optional(),
   stats: MetadataStatsSchema.optional(),
-  etag: import_zod26.z.string().optional(),
-  size: import_zod26.z.number().optional(),
-  saveTime: import_zod26.z.number().optional(),
-  backupPath: import_zod26.z.string().optional()
-});
-var MetadataWatchEventSchema = import_zod26.z.object({
-  type: import_zod26.z.enum(["add", "change", "unlink", "added", "changed", "deleted"]),
-  path: import_zod26.z.string(),
-  name: import_zod26.z.string().optional(),
+  etag: import_zod27.z.string().optional(),
+  size: import_zod27.z.number().optional(),
+  saveTime: import_zod27.z.number().optional(),
+  backupPath: import_zod27.z.string().optional()
+});
+var MetadataWatchEventSchema = import_zod27.z.object({
+  type: import_zod27.z.enum(["add", "change", "unlink", "added", "changed", "deleted"]),
+  path: import_zod27.z.string(),
+  name: import_zod27.z.string().optional(),
   stats: MetadataStatsSchema.optional(),
-  metadataType: import_zod26.z.string().optional(),
-  data: import_zod26.z.any().optional(),
-  timestamp: import_zod26.z.date().optional()
-});
-var MetadataCollectionInfoSchema = import_zod26.z.object({
-  type: import_zod26.z.string(),
-  count: import_zod26.z.number(),
-  namespaces: import_zod26.z.array(import_zod26.z.string())
-});
-var MetadataExportOptionsSchema = import_zod26.z.object({
-  types: import_zod26.z.array(import_zod26.z.string()).optional(),
-  namespaces: import_zod26.z.array(import_zod26.z.string()).optional(),
-  output: import_zod26.z.string().describe("Output directory or file"),
+  metadataType: import_zod27.z.string().optional(),
+  data: import_zod27.z.any().optional(),
+  timestamp: import_zod27.z.date().optional()
+});
+var MetadataCollectionInfoSchema = import_zod27.z.object({
+  type: import_zod27.z.string(),
+  count: import_zod27.z.number(),
+  namespaces: import_zod27.z.array(import_zod27.z.string())
+});
+var MetadataExportOptionsSchema = import_zod27.z.object({
+  types: import_zod27.z.array(import_zod27.z.string()).optional(),
+  namespaces: import_zod27.z.array(import_zod27.z.string()).optional(),
+  output: import_zod27.z.string().describe("Output directory or file"),
   format: MetadataFormatSchema.default("json")
 });
-var MetadataImportOptionsSchema = import_zod26.z.object({
-  source: import_zod26.z.string().describe("Input directory or file"),
-  strategy: import_zod26.z.enum(["merge", "replace", "skip"]).default("merge"),
-  validate: import_zod26.z.boolean().default(true)
-});
-var MetadataManagerConfigSchema = import_zod26.z.object({
-  loaders: import_zod26.z.array(import_zod26.z.any()).optional(),
-  watch: import_zod26.z.boolean().optional(),
-  cache: import_zod26.z.boolean().optional(),
-  basePath: import_zod26.z.string().optional(),
-  rootDir: import_zod26.z.string().optional(),
-  formats: import_zod26.z.array(MetadataFormatSchema).optional(),
-  watchOptions: import_zod26.z.any().optional()
+var MetadataImportOptionsSchema = import_zod27.z.object({
+  source: import_zod27.z.string().describe("Input directory or file"),
+  strategy: import_zod27.z.enum(["merge", "replace", "skip"]).default("merge"),
+  validate: import_zod27.z.boolean().default(true)
+});
+var MetadataManagerConfigSchema = import_zod27.z.object({
+  loaders: import_zod27.z.array(import_zod27.z.any()).optional(),
+  watch: import_zod27.z.boolean().optional(),
+  cache: import_zod27.z.boolean().optional(),
+  basePath: import_zod27.z.string().optional(),
+  rootDir: import_zod27.z.string().optional(),
+  formats: import_zod27.z.array(MetadataFormatSchema).optional(),
+  watchOptions: import_zod27.z.any().optional()
   // Chokidar options
 });
 
 // src/system/service-registry.zod.ts
-var import_zod27 = require("zod");
-var CoreServiceName = import_zod27.z.enum([
+var import_zod28 = require("zod");
+var CoreServiceName = import_zod28.z.enum([
   // Core Data & Metadata
   "metadata",
   // Object/Field Definitions
@@ -5325,7 +5423,7 @@ var CoreServiceName = import_zod27.z.enum([
   "notification"
   // Email/Push/SMS
 ]);
-var ServiceCriticalitySchema = import_zod27.z.enum([
+var ServiceCriticalitySchema = import_zod28.z.enum([
   "required",
   // System fails to start if missing (Exit Code 1)
   "core",
@@ -5352,22 +5450,22 @@ var ServiceRequirementDef = {
   realtime: "optional",
   notification: "optional"
 };
-var ServiceStatusSchema = import_zod27.z.object({
+var ServiceStatusSchema = import_zod28.z.object({
   name: CoreServiceName,
-  enabled: import_zod27.z.boolean(),
-  status: import_zod27.z.enum(["running", "stopped", "degraded", "initializing"]),
-  version: import_zod27.z.string().optional(),
-  provider: import_zod27.z.string().optional().describe('Implementation provider (e.g. "s3" for storage)'),
-  features: import_zod27.z.array(import_zod27.z.string()).optional().describe("List of supported sub-features")
+  enabled: import_zod28.z.boolean(),
+  status: import_zod28.z.enum(["running", "stopped", "degraded", "initializing"]),
+  version: import_zod28.z.string().optional(),
+  provider: import_zod28.z.string().optional().describe('Implementation provider (e.g. "s3" for storage)'),
+  features: import_zod28.z.array(import_zod28.z.string()).optional().describe("List of supported sub-features")
 });
-var KernelServiceMapSchema = import_zod27.z.record(
+var KernelServiceMapSchema = import_zod28.z.record(
   CoreServiceName,
-  import_zod27.z.any().describe("Service Instance implementing the protocol interface")
+  import_zod28.z.any().describe("Service Instance implementing the protocol interface")
 );
-var ServiceConfigSchema = import_zod27.z.object({
-  id: import_zod27.z.string(),
+var ServiceConfigSchema = import_zod28.z.object({
+  id: import_zod28.z.string(),
   name: CoreServiceName,
-  options: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.any()).optional()
+  options: import_zod28.z.record(import_zod28.z.string(), import_zod28.z.any()).optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {