@objectstack/spec 1.0.11 → 1.1.0

package/dist/system/index.mjs

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