@objectstack/spec 1.0.10 → 1.0.12

package/dist/data/index.js

@@ -118,6 +118,8 @@ __export(data_exports, {
   NoSQLTransactionOptionsSchema: () => NoSQLTransactionOptionsSchema,
   NormalizedFilterSchema: () => NormalizedFilterSchema,
   ObjectCapabilities: () => ObjectCapabilities,
+  ObjectExtensionSchema: () => ObjectExtensionSchema,
+  ObjectOwnershipEnum: () => ObjectOwnershipEnum,
   ObjectSchema: () => ObjectSchema,
   PartitioningConfigSchema: () => PartitioningConfigSchema,
   PoolConfigSchema: () => PoolConfigSchema,
@@ -405,7 +407,7 @@ var QuerySchema = BaseQuerySchema.extend({
 });
 
 // src/data/object.zod.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/data/field.zod.ts
 var import_zod6 = require("zod");
@@ -988,8 +990,77 @@ var ConditionalValidationSchema = BaseValidationSchema.extend({
   otherwise: ValidationRuleSchema.optional().describe("Validation rule to apply when condition is false")
 });
 
+// src/automation/state-machine.zod.ts
+var import_zod8 = require("zod");
+var ActionRefSchema = import_zod8.z.union([
+  import_zod8.z.string().describe("Action Name"),
+  import_zod8.z.object({
+    type: import_zod8.z.string(),
+    // e.g., 'xstate.assign', 'log', 'email'
+    params: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any()).optional()
+  })
+]);
+var GuardRefSchema = import_zod8.z.union([
+  import_zod8.z.string().describe('Guard Name (e.g., "isManager", "amountGT1000")'),
+  import_zod8.z.object({
+    type: import_zod8.z.string(),
+    params: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any()).optional()
+  })
+]);
+var TransitionSchema = import_zod8.z.object({
+  target: import_zod8.z.string().optional().describe("Target State ID"),
+  cond: GuardRefSchema.optional().describe("Condition (Guard) required to take this path"),
+  actions: import_zod8.z.array(ActionRefSchema).optional().describe("Actions to execute during transition"),
+  description: import_zod8.z.string().optional().describe("Human readable description of this rule")
+});
+var EventSchema = import_zod8.z.object({
+  type: import_zod8.z.string().describe('Event Type (e.g. "APPROVE", "REJECT", "Submit")'),
+  // Payload validation schema could go here if we want deep validation
+  schema: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any()).optional().describe("Expected event payload structure")
+});
+var StateNodeSchema = import_zod8.z.lazy(() => import_zod8.z.object({
+  /** Type of state */
+  type: import_zod8.z.enum(["atomic", "compound", "parallel", "final", "history"]).default("atomic"),
+  /** Entry/Exit Actions */
+  entry: import_zod8.z.array(ActionRefSchema).optional().describe("Actions to run when entering this state"),
+  exit: import_zod8.z.array(ActionRefSchema).optional().describe("Actions to run when leaving this state"),
+  /** Transitions (Events) */
+  on: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.union([
+    import_zod8.z.string(),
+    // Shorthand target
+    TransitionSchema,
+    import_zod8.z.array(TransitionSchema)
+  ])).optional().describe("Map of Event Type -> Transition Definition"),
+  /** Always Transitions (Eventless) */
+  always: import_zod8.z.array(TransitionSchema).optional(),
+  /** Nesting (Hierarchical States) */
+  initial: import_zod8.z.string().optional().describe("Initial child state (if compound)"),
+  states: import_zod8.z.record(import_zod8.z.string(), StateNodeSchema).optional(),
+  /** Metadata for UI/AI */
+  meta: import_zod8.z.object({
+    label: import_zod8.z.string().optional(),
+    description: import_zod8.z.string().optional(),
+    color: import_zod8.z.string().optional(),
+    // For UI diagrams
+    // Instructions for AI Agent when in this state
+    aiInstructions: import_zod8.z.string().optional().describe("Specific instructions for AI when in this state")
+  }).optional()
+}));
+var StateMachineSchema = import_zod8.z.object({
+  id: SnakeCaseIdentifierSchema.describe("Unique Machine ID"),
+  description: import_zod8.z.string().optional(),
+  /** Context (Memory) Schema */
+  contextSchema: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any()).optional().describe("Zod Schema for the machine context/memory"),
+  /** Initial State */
+  initial: import_zod8.z.string().describe("Initial State ID"),
+  /** State Definitions */
+  states: import_zod8.z.record(import_zod8.z.string(), StateNodeSchema).describe("State Nodes"),
+  /** Global Listeners */
+  on: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.union([import_zod8.z.string(), TransitionSchema, import_zod8.z.array(TransitionSchema)])).optional()
+});
+
 // src/data/object.zod.ts
-var ApiMethod = import_zod8.z.enum([
+var ApiMethod = import_zod9.z.enum([
   "get",
   "list",
   // Read
@@ -1014,65 +1085,65 @@ var ApiMethod = import_zod8.z.enum([
   "export"
   // Data portability
 ]);
-var ObjectCapabilities = import_zod8.z.object({
+var ObjectCapabilities = import_zod9.z.object({
   /** Enable history tracking (Audit Trail) */
-  trackHistory: import_zod8.z.boolean().default(false).describe("Enable field history tracking for audit compliance"),
+  trackHistory: import_zod9.z.boolean().default(false).describe("Enable field history tracking for audit compliance"),
   /** Enable global search indexing */
-  searchable: import_zod8.z.boolean().default(true).describe("Index records for global search"),
+  searchable: import_zod9.z.boolean().default(true).describe("Index records for global search"),
   /** Enable REST/GraphQL API access */
-  apiEnabled: import_zod8.z.boolean().default(true).describe("Expose object via automatic APIs"),
+  apiEnabled: import_zod9.z.boolean().default(true).describe("Expose object via automatic APIs"),
   /** 
    * API Supported Operations
    * Granular control over API exposure.
    */
-  apiMethods: import_zod8.z.array(ApiMethod).optional().describe("Whitelist of allowed API operations"),
+  apiMethods: import_zod9.z.array(ApiMethod).optional().describe("Whitelist of allowed API operations"),
   /** Enable standard attachments/files engine */
-  files: import_zod8.z.boolean().default(false).describe("Enable file attachments and document management"),
+  files: import_zod9.z.boolean().default(false).describe("Enable file attachments and document management"),
   /** Enable social collaboration (Comments, Mentions, Feeds) */
-  feeds: import_zod8.z.boolean().default(false).describe("Enable social feed, comments, and mentions (Chatter-like)"),
+  feeds: import_zod9.z.boolean().default(false).describe("Enable social feed, comments, and mentions (Chatter-like)"),
   /** Enable standard Activity suite (Tasks, Calendars, Events) */
-  activities: import_zod8.z.boolean().default(false).describe("Enable standard tasks and events tracking"),
+  activities: import_zod9.z.boolean().default(false).describe("Enable standard tasks and events tracking"),
   /** Enable Recycle Bin / Soft Delete */
-  trash: import_zod8.z.boolean().default(true).describe("Enable soft-delete with restore capability"),
+  trash: import_zod9.z.boolean().default(true).describe("Enable soft-delete with restore capability"),
   /** Enable "Recently Viewed" tracking */
-  mru: import_zod8.z.boolean().default(true).describe("Track Most Recently Used (MRU) list for users"),
+  mru: import_zod9.z.boolean().default(true).describe("Track Most Recently Used (MRU) list for users"),
   /** Allow cloning records */
-  clone: import_zod8.z.boolean().default(true).describe("Allow record deep cloning")
-});
-var IndexSchema = import_zod8.z.object({
-  name: import_zod8.z.string().optional().describe("Index name (auto-generated if not provided)"),
-  fields: import_zod8.z.array(import_zod8.z.string()).describe("Fields included in the index"),
-  type: import_zod8.z.enum(["btree", "hash", "gin", "gist", "fulltext"]).optional().default("btree").describe("Index algorithm type"),
-  unique: import_zod8.z.boolean().optional().default(false).describe("Whether the index enforces uniqueness"),
-  partial: import_zod8.z.string().optional().describe("Partial index condition (SQL WHERE clause for conditional indexes)")
-});
-var SearchConfigSchema = import_zod8.z.object({
-  fields: import_zod8.z.array(import_zod8.z.string()).describe("Fields to index for full-text search weighting"),
-  displayFields: import_zod8.z.array(import_zod8.z.string()).optional().describe("Fields to display in search result cards"),
-  filters: import_zod8.z.array(import_zod8.z.string()).optional().describe("Default filters for search results")
-});
-var TenancyConfigSchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().describe("Enable multi-tenancy for this object"),
-  strategy: import_zod8.z.enum(["shared", "isolated", "hybrid"]).describe("Tenant isolation strategy: shared (single DB, row-level), isolated (separate DB per tenant), hybrid (mix)"),
-  tenantField: import_zod8.z.string().default("tenant_id").describe("Field name for tenant identifier"),
-  crossTenantAccess: import_zod8.z.boolean().default(false).describe("Allow cross-tenant data access (with explicit permission)")
-});
-var SoftDeleteConfigSchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().describe("Enable soft delete (trash/recycle bin)"),
-  field: import_zod8.z.string().default("deleted_at").describe("Field name for soft delete timestamp"),
-  cascadeDelete: import_zod8.z.boolean().default(false).describe("Cascade soft delete to related records")
-});
-var VersioningConfigSchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().describe("Enable record versioning"),
-  strategy: import_zod8.z.enum(["snapshot", "delta", "event-sourcing"]).describe("Versioning strategy: snapshot (full copy), delta (changes only), event-sourcing (event log)"),
-  retentionDays: import_zod8.z.number().min(1).optional().describe("Number of days to retain old versions (undefined = infinite)"),
-  versionField: import_zod8.z.string().default("version").describe("Field name for version number/timestamp")
-});
-var PartitioningConfigSchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().describe("Enable table partitioning"),
-  strategy: import_zod8.z.enum(["range", "hash", "list"]).describe("Partitioning strategy: range (date ranges), hash (consistent hashing), list (predefined values)"),
-  key: import_zod8.z.string().describe("Field name to partition by"),
-  interval: import_zod8.z.string().optional().describe('Partition interval for range strategy (e.g., "1 month", "1 year")')
+  clone: import_zod9.z.boolean().default(true).describe("Allow record deep cloning")
+});
+var IndexSchema = import_zod9.z.object({
+  name: import_zod9.z.string().optional().describe("Index name (auto-generated if not provided)"),
+  fields: import_zod9.z.array(import_zod9.z.string()).describe("Fields included in the index"),
+  type: import_zod9.z.enum(["btree", "hash", "gin", "gist", "fulltext"]).optional().default("btree").describe("Index algorithm type"),
+  unique: import_zod9.z.boolean().optional().default(false).describe("Whether the index enforces uniqueness"),
+  partial: import_zod9.z.string().optional().describe("Partial index condition (SQL WHERE clause for conditional indexes)")
+});
+var SearchConfigSchema = import_zod9.z.object({
+  fields: import_zod9.z.array(import_zod9.z.string()).describe("Fields to index for full-text search weighting"),
+  displayFields: import_zod9.z.array(import_zod9.z.string()).optional().describe("Fields to display in search result cards"),
+  filters: import_zod9.z.array(import_zod9.z.string()).optional().describe("Default filters for search results")
+});
+var TenancyConfigSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean().describe("Enable multi-tenancy for this object"),
+  strategy: import_zod9.z.enum(["shared", "isolated", "hybrid"]).describe("Tenant isolation strategy: shared (single DB, row-level), isolated (separate DB per tenant), hybrid (mix)"),
+  tenantField: import_zod9.z.string().default("tenant_id").describe("Field name for tenant identifier"),
+  crossTenantAccess: import_zod9.z.boolean().default(false).describe("Allow cross-tenant data access (with explicit permission)")
+});
+var SoftDeleteConfigSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean().describe("Enable soft delete (trash/recycle bin)"),
+  field: import_zod9.z.string().default("deleted_at").describe("Field name for soft delete timestamp"),
+  cascadeDelete: import_zod9.z.boolean().default(false).describe("Cascade soft delete to related records")
+});
+var VersioningConfigSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean().describe("Enable record versioning"),
+  strategy: import_zod9.z.enum(["snapshot", "delta", "event-sourcing"]).describe("Versioning strategy: snapshot (full copy), delta (changes only), event-sourcing (event log)"),
+  retentionDays: import_zod9.z.number().min(1).optional().describe("Number of days to retain old versions (undefined = infinite)"),
+  versionField: import_zod9.z.string().default("version").describe("Field name for version number/timestamp")
+});
+var PartitioningConfigSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean().describe("Enable table partitioning"),
+  strategy: import_zod9.z.enum(["range", "hash", "list"]).describe("Partitioning strategy: range (date ranges), hash (consistent hashing), list (predefined values)"),
+  key: import_zod9.z.string().describe("Field name to partition by"),
+  interval: import_zod9.z.string().optional().describe('Partition interval for range strategy (e.g., "1 month", "1 year")')
 }).refine((data) => {
   if (data.strategy === "range" && !data.interval) {
     return false;
@@ -1081,39 +1152,39 @@ var PartitioningConfigSchema = import_zod8.z.object({
 }, {
   message: 'interval is required when strategy is "range"'
 });
-var CDCConfigSchema = import_zod8.z.object({
-  enabled: import_zod8.z.boolean().describe("Enable Change Data Capture"),
-  events: import_zod8.z.array(import_zod8.z.enum(["insert", "update", "delete"])).describe("Event types to capture"),
-  destination: import_zod8.z.string().describe('Destination endpoint (e.g., "kafka://topic", "webhook://url")')
+var CDCConfigSchema = import_zod9.z.object({
+  enabled: import_zod9.z.boolean().describe("Enable Change Data Capture"),
+  events: import_zod9.z.array(import_zod9.z.enum(["insert", "update", "delete"])).describe("Event types to capture"),
+  destination: import_zod9.z.string().describe('Destination endpoint (e.g., "kafka://topic", "webhook://url")')
 });
-var ObjectSchemaBase = import_zod8.z.object({
+var ObjectSchemaBase = import_zod9.z.object({
   /** 
    * Identity & Metadata 
    */
-  name: import_zod8.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine unique key (snake_case). Immutable."),
-  label: import_zod8.z.string().optional().describe('Human readable singular label (e.g. "Account")'),
-  pluralLabel: import_zod8.z.string().optional().describe('Human readable plural label (e.g. "Accounts")'),
-  description: import_zod8.z.string().optional().describe("Developer documentation / description"),
-  icon: import_zod8.z.string().optional().describe("Icon name (Lucide/Material) for UI representation"),
+  name: import_zod9.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Machine unique key (snake_case). Immutable."),
+  label: import_zod9.z.string().optional().describe('Human readable singular label (e.g. "Account")'),
+  pluralLabel: import_zod9.z.string().optional().describe('Human readable plural label (e.g. "Accounts")'),
+  description: import_zod9.z.string().optional().describe("Developer documentation / description"),
+  icon: import_zod9.z.string().optional().describe("Icon name (Lucide/Material) for UI representation"),
   /**
    * Taxonomy & Organization
    */
-  tags: import_zod8.z.array(import_zod8.z.string()).optional().describe('Categorization tags (e.g. "sales", "system", "reference")'),
-  active: import_zod8.z.boolean().optional().default(true).describe("Is the object active and usable"),
-  isSystem: import_zod8.z.boolean().optional().default(false).describe("Is system object (protected from deletion)"),
-  abstract: import_zod8.z.boolean().optional().default(false).describe("Is abstract base object (cannot be instantiated)"),
+  tags: import_zod9.z.array(import_zod9.z.string()).optional().describe('Categorization tags (e.g. "sales", "system", "reference")'),
+  active: import_zod9.z.boolean().optional().default(true).describe("Is the object active and usable"),
+  isSystem: import_zod9.z.boolean().optional().default(false).describe("Is system object (protected from deletion)"),
+  abstract: import_zod9.z.boolean().optional().default(false).describe("Is abstract base object (cannot be instantiated)"),
   /** 
    * Storage & Virtualization 
    */
-  datasource: import_zod8.z.string().optional().default("default").describe('Target Datasource ID. "default" is the primary DB.'),
-  tableName: import_zod8.z.string().optional().describe("Physical table/collection name in the target datasource"),
+  datasource: import_zod9.z.string().optional().default("default").describe('Target Datasource ID. "default" is the primary DB.'),
+  tableName: import_zod9.z.string().optional().describe("Physical table/collection name in the target datasource"),
   /** 
    * Data Model 
    */
-  fields: import_zod8.z.record(import_zod8.z.string().regex(/^[a-z_][a-z0-9_]*$/, {
+  fields: import_zod9.z.record(import_zod9.z.string().regex(/^[a-z_][a-z0-9_]*$/, {
     message: 'Field names must be lowercase snake_case (e.g., "first_name", "company", "annual_revenue")'
   }), FieldSchema).describe("Field definitions map. Keys must be snake_case identifiers."),
-  indexes: import_zod8.z.array(IndexSchema).optional().describe("Database performance indexes"),
+  indexes: import_zod9.z.array(IndexSchema).optional().describe("Database performance indexes"),
   /**
    * Advanced Data Management
    */
@@ -1131,12 +1202,22 @@ var ObjectSchemaBase = import_zod8.z.object({
    * Logic & Validation (Co-located)
    * Best Practice: Define rules close to data.
    */
-  validations: import_zod8.z.array(ValidationRuleSchema).optional().describe("Object-level validation rules"),
+  validations: import_zod9.z.array(ValidationRuleSchema).optional().describe("Object-level validation rules"),
+  /**
+   * State Machine(s)
+   * Supports a single machine (legacy) or a named record of machines.
+   * Multiple machines allow parallel lifecycles (e.g., status + payment_status + approval_status).
+   * 
+   * @example Single: stateMachine: { id: 'lifecycle', initial: 'draft', states: {...} }
+   * @example Multiple: stateMachines: { lifecycle: {...}, payment: {...}, approval: {...} }
+   */
+  stateMachine: StateMachineSchema.optional().describe("Single state machine for record lifecycle (shorthand)"),
+  stateMachines: import_zod9.z.record(import_zod9.z.string(), StateMachineSchema).optional().describe("Named state machines for parallel lifecycles (e.g., status, payment, approval)"),
   /** 
    * Display & UI Hints (Data-Layer)
    */
-  titleFormat: import_zod8.z.string().optional().describe('Title expression (e.g. "{name} - {code}"). Overrides nameField.'),
-  compactLayout: import_zod8.z.array(import_zod8.z.string()).optional().describe("Primary fields for hover/cards/lookups"),
+  titleFormat: import_zod9.z.string().optional().describe('Title expression (e.g. "{name} - {code}"). Overrides nameField.'),
+  compactLayout: import_zod9.z.array(import_zod9.z.string()).optional().describe("Primary fields for hover/cards/lookups"),
   /** 
    * Search Engine Config 
    */
@@ -1149,10 +1230,29 @@ var ObjectSchemaBase = import_zod8.z.object({
 var ObjectSchema = Object.assign(ObjectSchemaBase, {
   create: (config) => config
 });
+var ObjectOwnershipEnum = import_zod9.z.enum(["own", "extend"]);
+var ObjectExtensionSchema = import_zod9.z.object({
+  /** The target object name (FQN) to extend */
+  extend: import_zod9.z.string().describe("Target object name (FQN) to extend"),
+  /** Fields to merge into the target object (additive) */
+  fields: import_zod9.z.record(import_zod9.z.string(), FieldSchema).optional().describe("Fields to add/override"),
+  /** Override label */
+  label: import_zod9.z.string().optional(),
+  /** Override plural label */
+  pluralLabel: import_zod9.z.string().optional(),
+  /** Override description */
+  description: import_zod9.z.string().optional(),
+  /** Additional validation rules to add */
+  validations: import_zod9.z.array(ValidationRuleSchema).optional(),
+  /** Additional indexes to add */
+  indexes: import_zod9.z.array(IndexSchema).optional(),
+  /** Merge priority. Higher number applied later (wins on conflict). Default: 200 */
+  priority: import_zod9.z.number().int().min(0).max(999).default(200).describe("Merge priority (higher = applied later)")
+});
 
 // src/data/hook.zod.ts
-var import_zod9 = require("zod");
-var HookEvent = import_zod9.z.enum([
+var import_zod10 = require("zod");
+var HookEvent = import_zod10.z.enum([
   // Read Operations
   "beforeFind",
   "afterFind",
@@ -1175,16 +1275,16 @@ var HookEvent = import_zod9.z.enum([
   "beforeDeleteMany",
   "afterDeleteMany"
 ]);
-var HookSchema = import_zod9.z.object({
+var HookSchema = import_zod10.z.object({
   /**
    * Unique identifier for the hook
    * Required for debugging and overriding.
    */
-  name: import_zod9.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Hook unique name (snake_case)"),
+  name: import_zod10.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Hook unique name (snake_case)"),
   /**
    * Human readable label
    */
-  label: import_zod9.z.string().optional().describe("Description of what this hook does"),
+  label: import_zod10.z.string().optional().describe("Description of what this hook does"),
   /**
    * Target Object(s)
    * can be:
@@ -1192,17 +1292,17 @@ var HookSchema = import_zod9.z.object({
    * - List of objects: ["account", "contact"]
    * - Wildcard: "*" (All objects)
    */
-  object: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())]).describe("Target object(s)"),
+  object: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).describe("Target object(s)"),
   /**
    * Events to subscribe to
    * Combinations of timing (before/after) and action (find/insert/update/delete/etc)
    */
-  events: import_zod9.z.array(HookEvent).describe("Lifecycle events"),
+  events: import_zod10.z.array(HookEvent).describe("Lifecycle events"),
   /**
    * Handler Logic
    * Reference to a registered function in the plugin system OR a direct function (runtime only).
    */
-  handler: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.any()]).optional().describe("Function handler name or direct function"),
+  handler: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.any()]).optional().describe("Function handler name or direct function"),
   /**
    * Execution Order
    * Lower numbers run first.
@@ -1210,27 +1310,27 @@ var HookSchema = import_zod9.z.object({
    * - App Hooks: 100-999
    * - User Hooks: 1000+
    */
-  priority: import_zod9.z.number().default(100).describe("Execution priority"),
+  priority: import_zod10.z.number().default(100).describe("Execution priority"),
   /**
    * Async / Background Execution
    * If true, the hook runs in the background and does not block the transaction.
    * Only applicable for 'after*' events.
    * Default: false (Blocking)
    */
-  async: import_zod9.z.boolean().default(false).describe("Run specifically as fire-and-forget"),
+  async: import_zod10.z.boolean().default(false).describe("Run specifically as fire-and-forget"),
   /**
    * Error Policy
    * What to do if the hook throws an exception?
    * - abort: Rollback transaction (if blocking)
    * - log: Log error and continue
    */
-  onError: import_zod9.z.enum(["abort", "log"]).default("abort").describe("Error handling strategy")
+  onError: import_zod10.z.enum(["abort", "log"]).default("abort").describe("Error handling strategy")
 });
-var HookContextSchema = import_zod9.z.object({
+var HookContextSchema = import_zod10.z.object({
   /** Tracing ID */
-  id: import_zod9.z.string().optional().describe("Unique execution ID for tracing"),
+  id: import_zod10.z.string().optional().describe("Unique execution ID for tracing"),
   /** Target Object Name */
-  object: import_zod9.z.string(),
+  object: import_zod10.z.string(),
   /** Current Lifecycle Event */
   event: HookEvent,
   /** 
@@ -1244,42 +1344,42 @@ var HookContextSchema = import_zod9.z.object({
    * - updateMany: { query: QueryAST, doc: Record, options: DriverOptions }
    * - deleteMany: { query: QueryAST, options: DriverOptions }
    */
-  input: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()).describe("Mutable input parameters"),
+  input: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).describe("Mutable input parameters"),
   /** 
    * Operation Result (Mutable)
    * Available in 'after*' events. Modify this to transform the output.
    */
-  result: import_zod9.z.any().optional().describe("Operation result (After hooks only)"),
+  result: import_zod10.z.any().optional().describe("Operation result (After hooks only)"),
   /**
    * Data Snapshot
    * The state of the record BEFORE the operation (for update/delete).
    */
-  previous: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()).optional().describe("Record state before operation"),
+  previous: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).optional().describe("Record state before operation"),
   /**
    * Execution Session
    * Contains authentication and tenancy information.
    */
-  session: import_zod9.z.object({
-    userId: import_zod9.z.string().optional(),
-    tenantId: import_zod9.z.string().optional(),
-    roles: import_zod9.z.array(import_zod9.z.string()).optional(),
-    accessToken: import_zod9.z.string().optional()
+  session: import_zod10.z.object({
+    userId: import_zod10.z.string().optional(),
+    tenantId: import_zod10.z.string().optional(),
+    roles: import_zod10.z.array(import_zod10.z.string()).optional(),
+    accessToken: import_zod10.z.string().optional()
   }).optional().describe("Current session context"),
   /**
    * Transaction Handle
    * If the operation is part of a transaction, use this handle for side-effects.
    */
-  transaction: import_zod9.z.any().optional().describe("Database transaction handle"),
+  transaction: import_zod10.z.any().optional().describe("Database transaction handle"),
   /**
    * Engine Access
    * Reference to the ObjectQL engine for performing side effects.
    */
-  ql: import_zod9.z.any().describe("ObjectQL Engine Reference")
+  ql: import_zod10.z.any().describe("ObjectQL Engine Reference")
 });
 
 // src/data/mapping.zod.ts
-var import_zod10 = require("zod");
-var TransformType = import_zod10.z.enum([
+var import_zod11 = require("zod");
+var TransformType = import_zod11.z.enum([
   "none",
   // Direct copy
   "constant",
@@ -1295,114 +1395,114 @@ var TransformType = import_zod10.z.enum([
   "map"
   // Value mapping (e.g. "Active" -> "active")
 ]);
-var FieldMappingSchema = import_zod10.z.object({
+var FieldMappingSchema = import_zod11.z.object({
   /** Source Column */
-  source: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).describe("Source column header(s)"),
+  source: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())]).describe("Source column header(s)"),
   /** Target Field */
-  target: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.array(import_zod10.z.string())]).describe("Target object field(s)"),
+  target: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.array(import_zod11.z.string())]).describe("Target object field(s)"),
   /** Transformation */
   transform: TransformType.default("none"),
   /** Configuration for transform */
-  params: import_zod10.z.object({
+  params: import_zod11.z.object({
     // Constant
-    value: import_zod10.z.any().optional(),
+    value: import_zod11.z.any().optional(),
     // Lookup
-    object: import_zod10.z.string().optional(),
+    object: import_zod11.z.string().optional(),
     // Lookup Object
-    fromField: import_zod10.z.string().optional(),
+    fromField: import_zod11.z.string().optional(),
     // Match on (e.g. "name")
-    toField: import_zod10.z.string().optional(),
+    toField: import_zod11.z.string().optional(),
     // Value to take (e.g. "_id")
-    autoCreate: import_zod10.z.boolean().optional(),
+    autoCreate: import_zod11.z.boolean().optional(),
     // Create if missing
     // Map
-    valueMap: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).optional(),
+    valueMap: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional(),
     // { "Open": "draft" }
     // Split/Join
-    separator: import_zod10.z.string().optional()
+    separator: import_zod11.z.string().optional()
   }).optional()
 });
-var MappingSchema = import_zod10.z.object({
+var MappingSchema = import_zod11.z.object({
   /** Identity */
   name: SnakeCaseIdentifierSchema.describe("Mapping unique name (lowercase snake_case)"),
-  label: import_zod10.z.string().optional(),
+  label: import_zod11.z.string().optional(),
   /** Scope */
-  sourceFormat: import_zod10.z.enum(["csv", "json", "xml", "sql"]).default("csv"),
-  targetObject: import_zod10.z.string().describe("Target Object Name"),
+  sourceFormat: import_zod11.z.enum(["csv", "json", "xml", "sql"]).default("csv"),
+  targetObject: import_zod11.z.string().describe("Target Object Name"),
   /** Column Mappings */
-  fieldMapping: import_zod10.z.array(FieldMappingSchema),
+  fieldMapping: import_zod11.z.array(FieldMappingSchema),
   /** Upsert Logic */
-  mode: import_zod10.z.enum(["insert", "update", "upsert"]).default("insert"),
-  upsertKey: import_zod10.z.array(import_zod10.z.string()).optional().describe("Fields to match for upsert (e.g. email)"),
+  mode: import_zod11.z.enum(["insert", "update", "upsert"]).default("insert"),
+  upsertKey: import_zod11.z.array(import_zod11.z.string()).optional().describe("Fields to match for upsert (e.g. email)"),
   /** Extract Logic (For Export) */
   extractQuery: QuerySchema.optional().describe("Query to run for export only"),
   /** Error Handling */
-  errorPolicy: import_zod10.z.enum(["skip", "abort", "retry"]).default("skip"),
-  batchSize: import_zod10.z.number().default(1e3)
+  errorPolicy: import_zod11.z.enum(["skip", "abort", "retry"]).default("skip"),
+  batchSize: import_zod11.z.number().default(1e3)
 });
 
 // src/data/data-engine.zod.ts
-var import_zod11 = require("zod");
-var DataEngineFilterSchema = import_zod11.z.union([
-  import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()),
+var import_zod12 = require("zod");
+var DataEngineFilterSchema = import_zod12.z.union([
+  import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()),
   FilterConditionSchema
 ]).describe("Data Engine query filter conditions");
-var DataEngineSortSchema = import_zod11.z.union([
-  import_zod11.z.record(import_zod11.z.string(), import_zod11.z.enum(["asc", "desc"])),
-  import_zod11.z.record(import_zod11.z.string(), import_zod11.z.union([import_zod11.z.literal(1), import_zod11.z.literal(-1)])),
-  import_zod11.z.array(SortNodeSchema)
+var DataEngineSortSchema = import_zod12.z.union([
+  import_zod12.z.record(import_zod12.z.string(), import_zod12.z.enum(["asc", "desc"])),
+  import_zod12.z.record(import_zod12.z.string(), import_zod12.z.union([import_zod12.z.literal(1), import_zod12.z.literal(-1)])),
+  import_zod12.z.array(SortNodeSchema)
 ]).describe("Sort order definition");
-var DataEngineQueryOptionsSchema = import_zod11.z.object({
+var DataEngineQueryOptionsSchema = import_zod12.z.object({
   /** Filter conditions (WHERE) */
   filter: DataEngineFilterSchema.optional(),
   /** Fields to select (SELECT) */
-  select: import_zod11.z.array(import_zod11.z.string()).optional(),
+  select: import_zod12.z.array(import_zod12.z.string()).optional(),
   /** Sort order (ORDER BY) */
   sort: DataEngineSortSchema.optional(),
   /** Limit number of results (LIMIT) */
-  limit: import_zod11.z.number().int().min(1).optional(),
+  limit: import_zod12.z.number().int().min(1).optional(),
   /** Skip number of results (OFFSET) */
-  skip: import_zod11.z.number().int().min(0).optional(),
+  skip: import_zod12.z.number().int().min(0).optional(),
   /** 
    * Maximum number of results (OData style)
    * Takes precedence over limit if both specified
    */
-  top: import_zod11.z.number().int().min(1).optional(),
+  top: import_zod12.z.number().int().min(1).optional(),
   /**
    * Include related records (JOIN/Populate)
    * List of relationship field names to expand
    */
-  populate: import_zod11.z.array(import_zod11.z.string()).optional()
+  populate: import_zod12.z.array(import_zod12.z.string()).optional()
 }).describe("Query options for IDataEngine.find() operations");
-var DataEngineInsertOptionsSchema = import_zod11.z.object({
+var DataEngineInsertOptionsSchema = import_zod12.z.object({
   /** 
    * Return the inserted record(s)? 
    * Some drivers support RETURNING clause for efficiency.
    * Default: true
    */
-  returning: import_zod11.z.boolean().default(true).optional()
+  returning: import_zod12.z.boolean().default(true).optional()
 }).describe("Options for DataEngine.insert operations");
-var DataEngineUpdateOptionsSchema = import_zod11.z.object({
+var DataEngineUpdateOptionsSchema = import_zod12.z.object({
   /** Filter conditions to identify records to update */
   filter: DataEngineFilterSchema.optional(),
   /** 
    * Perform an upsert? 
    * If true, insert if not found.
    */
-  upsert: import_zod11.z.boolean().default(false).optional(),
+  upsert: import_zod12.z.boolean().default(false).optional(),
   /**
    * Update multiple records?
    * If false, only the first match is updated.
    * Default: false
    */
-  multi: import_zod11.z.boolean().default(false).optional(),
+  multi: import_zod12.z.boolean().default(false).optional(),
   /** 
    * Return the updated record(s)? 
    * Default: false (returns update count/status)
    */
-  returning: import_zod11.z.boolean().default(false).optional()
+  returning: import_zod12.z.boolean().default(false).optional()
 }).describe("Options for DataEngine.update operations");
-var DataEngineDeleteOptionsSchema = import_zod11.z.object({
+var DataEngineDeleteOptionsSchema = import_zod12.z.object({
   /** Filter conditions to identify records to delete */
   filter: DataEngineFilterSchema.optional(),
   /**
@@ -1410,99 +1510,99 @@ var DataEngineDeleteOptionsSchema = import_zod11.z.object({
    * If false, only the first match is deleted.
    * Default: false
    */
-  multi: import_zod11.z.boolean().default(false).optional()
+  multi: import_zod12.z.boolean().default(false).optional()
 }).describe("Options for DataEngine.delete operations");
-var DataEngineAggregateOptionsSchema = import_zod11.z.object({
+var DataEngineAggregateOptionsSchema = import_zod12.z.object({
   /** Filter conditions (WHERE) */
   filter: DataEngineFilterSchema.optional(),
   /** Group By fields */
-  groupBy: import_zod11.z.array(import_zod11.z.string()).optional(),
+  groupBy: import_zod12.z.array(import_zod12.z.string()).optional(),
   /** 
    * Aggregation definitions 
    * e.g. [{ field: 'amount', method: 'sum', alias: 'total' }]
    */
-  aggregations: import_zod11.z.array(import_zod11.z.object({
-    field: import_zod11.z.string(),
-    method: import_zod11.z.enum(["count", "sum", "avg", "min", "max", "count_distinct"]),
-    alias: import_zod11.z.string().optional()
+  aggregations: import_zod12.z.array(import_zod12.z.object({
+    field: import_zod12.z.string(),
+    method: import_zod12.z.enum(["count", "sum", "avg", "min", "max", "count_distinct"]),
+    alias: import_zod12.z.string().optional()
   })).optional()
 }).describe("Options for DataEngine.aggregate operations");
-var DataEngineCountOptionsSchema = import_zod11.z.object({
+var DataEngineCountOptionsSchema = import_zod12.z.object({
   /** Filter conditions */
   filter: DataEngineFilterSchema.optional()
 }).describe("Options for DataEngine.count operations");
-var DataEngineContractSchema = import_zod11.z.object({
-  find: import_zod11.z.function().args(import_zod11.z.string(), DataEngineQueryOptionsSchema.optional()).returns(import_zod11.z.promise(import_zod11.z.array(import_zod11.z.any()))),
-  findOne: import_zod11.z.function().args(import_zod11.z.string(), DataEngineQueryOptionsSchema.optional()).returns(import_zod11.z.promise(import_zod11.z.any())),
-  insert: import_zod11.z.function().args(import_zod11.z.string(), import_zod11.z.union([import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()), import_zod11.z.array(import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()))]), DataEngineInsertOptionsSchema.optional()).returns(import_zod11.z.promise(import_zod11.z.any())),
-  update: import_zod11.z.function().args(import_zod11.z.string(), import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()), DataEngineUpdateOptionsSchema.optional()).returns(import_zod11.z.promise(import_zod11.z.any())),
-  delete: import_zod11.z.function().args(import_zod11.z.string(), DataEngineDeleteOptionsSchema.optional()).returns(import_zod11.z.promise(import_zod11.z.any())),
-  count: import_zod11.z.function().args(import_zod11.z.string(), DataEngineCountOptionsSchema.optional()).returns(import_zod11.z.promise(import_zod11.z.number())),
-  aggregate: import_zod11.z.function().args(import_zod11.z.string(), DataEngineAggregateOptionsSchema).returns(import_zod11.z.promise(import_zod11.z.array(import_zod11.z.any())))
+var DataEngineContractSchema = import_zod12.z.object({
+  find: import_zod12.z.function().args(import_zod12.z.string(), DataEngineQueryOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.array(import_zod12.z.any()))),
+  findOne: import_zod12.z.function().args(import_zod12.z.string(), DataEngineQueryOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.any())),
+  insert: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.union([import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), import_zod12.z.array(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()))]), DataEngineInsertOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.any())),
+  update: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), DataEngineUpdateOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.any())),
+  delete: import_zod12.z.function().args(import_zod12.z.string(), DataEngineDeleteOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.any())),
+  count: import_zod12.z.function().args(import_zod12.z.string(), DataEngineCountOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.number())),
+  aggregate: import_zod12.z.function().args(import_zod12.z.string(), DataEngineAggregateOptionsSchema).returns(import_zod12.z.promise(import_zod12.z.array(import_zod12.z.any())))
 }).describe("Standard Data Engine Contract");
-var DataEngineFindRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("find"),
-  object: import_zod11.z.string(),
+var DataEngineFindRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("find"),
+  object: import_zod12.z.string(),
   query: DataEngineQueryOptionsSchema.optional()
 });
-var DataEngineFindOneRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("findOne"),
-  object: import_zod11.z.string(),
+var DataEngineFindOneRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("findOne"),
+  object: import_zod12.z.string(),
   query: DataEngineQueryOptionsSchema.optional()
 });
-var DataEngineInsertRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("insert"),
-  object: import_zod11.z.string(),
-  data: import_zod11.z.union([import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()), import_zod11.z.array(import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()))]),
+var DataEngineInsertRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("insert"),
+  object: import_zod12.z.string(),
+  data: import_zod12.z.union([import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), import_zod12.z.array(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()))]),
   options: DataEngineInsertOptionsSchema.optional()
 });
-var DataEngineUpdateRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("update"),
-  object: import_zod11.z.string(),
-  data: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()),
-  id: import_zod11.z.any().optional().describe("ID for single update, or use filter in options"),
+var DataEngineUpdateRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("update"),
+  object: import_zod12.z.string(),
+  data: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()),
+  id: import_zod12.z.any().optional().describe("ID for single update, or use filter in options"),
   options: DataEngineUpdateOptionsSchema.optional()
 });
-var DataEngineDeleteRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("delete"),
-  object: import_zod11.z.string(),
-  id: import_zod11.z.any().optional().describe("ID for single delete, or use filter in options"),
+var DataEngineDeleteRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("delete"),
+  object: import_zod12.z.string(),
+  id: import_zod12.z.any().optional().describe("ID for single delete, or use filter in options"),
   options: DataEngineDeleteOptionsSchema.optional()
 });
-var DataEngineCountRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("count"),
-  object: import_zod11.z.string(),
+var DataEngineCountRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("count"),
+  object: import_zod12.z.string(),
   query: DataEngineCountOptionsSchema.optional()
 });
-var DataEngineAggregateRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("aggregate"),
-  object: import_zod11.z.string(),
+var DataEngineAggregateRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("aggregate"),
+  object: import_zod12.z.string(),
   query: DataEngineAggregateOptionsSchema
 });
-var DataEngineExecuteRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("execute"),
+var DataEngineExecuteRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("execute"),
   /** The abstract command (string SQL, or JSON object) */
-  command: import_zod11.z.any(),
+  command: import_zod12.z.any(),
   /** Optional options */
-  options: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional()
+  options: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()).optional()
 });
-var DataEngineVectorFindRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("vectorFind"),
-  object: import_zod11.z.string(),
+var DataEngineVectorFindRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("vectorFind"),
+  object: import_zod12.z.string(),
   /** The vector embedding to search for */
-  vector: import_zod11.z.array(import_zod11.z.number()),
+  vector: import_zod12.z.array(import_zod12.z.number()),
   /** Optional pre-filter (Metadata filtering) */
   filter: DataEngineFilterSchema.optional(),
   /** Fields to select */
-  select: import_zod11.z.array(import_zod11.z.string()).optional(),
+  select: import_zod12.z.array(import_zod12.z.string()).optional(),
   /** Number of results */
-  limit: import_zod11.z.number().int().default(5).optional(),
+  limit: import_zod12.z.number().int().default(5).optional(),
   /** Minimum similarity score (0-1) or distance threshold */
-  threshold: import_zod11.z.number().optional()
+  threshold: import_zod12.z.number().optional()
 });
-var DataEngineBatchRequestSchema = import_zod11.z.object({
-  method: import_zod11.z.literal("batch"),
-  requests: import_zod11.z.array(import_zod11.z.discriminatedUnion("method", [
+var DataEngineBatchRequestSchema = import_zod12.z.object({
+  method: import_zod12.z.literal("batch"),
+  requests: import_zod12.z.array(import_zod12.z.discriminatedUnion("method", [
     DataEngineFindRequestSchema,
     DataEngineFindOneRequestSchema,
     DataEngineInsertRequestSchema,
@@ -1518,9 +1618,9 @@ var DataEngineBatchRequestSchema = import_zod11.z.object({
    * - true: All or nothing (Atomic)
    * - false: Best effort, continue on error
    */
-  transaction: import_zod11.z.boolean().default(true).optional()
+  transaction: import_zod12.z.boolean().default(true).optional()
 });
-var DataEngineRequestSchema = import_zod11.z.discriminatedUnion("method", [
+var DataEngineRequestSchema = import_zod12.z.discriminatedUnion("method", [
   DataEngineFindRequestSchema,
   DataEngineFindOneRequestSchema,
   DataEngineInsertRequestSchema,
@@ -1534,67 +1634,67 @@ var DataEngineRequestSchema = import_zod11.z.discriminatedUnion("method", [
 ]).describe("Virtual ObjectQL Request Protocol");
 
 // src/data/driver.zod.ts
-var import_zod12 = require("zod");
-var DriverOptionsSchema = import_zod12.z.object({
+var import_zod13 = require("zod");
+var DriverOptionsSchema = import_zod13.z.object({
   /**
    * Transaction handle/identifier.
    * If provided, the operation must run within this transaction.
    */
-  transaction: import_zod12.z.any().optional().describe("Transaction handle"),
+  transaction: import_zod13.z.any().optional().describe("Transaction handle"),
   /**
    * Operation timeout in milliseconds.
    */
-  timeout: import_zod12.z.number().optional().describe("Timeout in ms"),
+  timeout: import_zod13.z.number().optional().describe("Timeout in ms"),
   /**
    * Whether to bypass cache and force a fresh read.
    */
-  skipCache: import_zod12.z.boolean().optional().describe("Bypass cache"),
+  skipCache: import_zod13.z.boolean().optional().describe("Bypass cache"),
   /**
    * Distributed Tracing Context.
    * Used for passing OpenTelemetry span context or request IDs for observability.
    */
-  traceContext: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string()).optional().describe("OpenTelemetry context or request ID"),
+  traceContext: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.string()).optional().describe("OpenTelemetry context or request ID"),
   /**
    * Tenant Identifier.
    * For multi-tenant databases (row-level security or schema-per-tenant).
    */
-  tenantId: import_zod12.z.string().optional().describe("Tenant Isolation identifier")
+  tenantId: import_zod13.z.string().optional().describe("Tenant Isolation identifier")
 });
-var DriverCapabilitiesSchema = import_zod12.z.object({
+var DriverCapabilitiesSchema = import_zod13.z.object({
   // ============================================================================
   // Basic CRUD Operations
   // ============================================================================
   /**
    * Whether the driver supports create operations.
    */
-  create: import_zod12.z.boolean().default(true).describe("Supports CREATE operations"),
+  create: import_zod13.z.boolean().default(true).describe("Supports CREATE operations"),
   /**
    * Whether the driver supports read operations.
    */
-  read: import_zod12.z.boolean().default(true).describe("Supports READ operations"),
+  read: import_zod13.z.boolean().default(true).describe("Supports READ operations"),
   /**
    * Whether the driver supports update operations.
    */
-  update: import_zod12.z.boolean().default(true).describe("Supports UPDATE operations"),
+  update: import_zod13.z.boolean().default(true).describe("Supports UPDATE operations"),
   /**
    * Whether the driver supports delete operations.
    */
-  delete: import_zod12.z.boolean().default(true).describe("Supports DELETE operations"),
+  delete: import_zod13.z.boolean().default(true).describe("Supports DELETE operations"),
   // ============================================================================
   // Bulk Operations
   // ============================================================================
   /**
    * Whether the driver supports bulk create operations.
    */
-  bulkCreate: import_zod12.z.boolean().default(false).describe("Supports bulk CREATE operations"),
+  bulkCreate: import_zod13.z.boolean().default(false).describe("Supports bulk CREATE operations"),
   /**
    * Whether the driver supports bulk update operations.
    */
-  bulkUpdate: import_zod12.z.boolean().default(false).describe("Supports bulk UPDATE operations"),
+  bulkUpdate: import_zod13.z.boolean().default(false).describe("Supports bulk UPDATE operations"),
   /**
    * Whether the driver supports bulk delete operations.
    */
-  bulkDelete: import_zod12.z.boolean().default(false).describe("Supports bulk DELETE operations"),
+  bulkDelete: import_zod13.z.boolean().default(false).describe("Supports bulk DELETE operations"),
   // ============================================================================
   // Transaction & Connection Management
   // ============================================================================
@@ -1602,15 +1702,15 @@ var DriverCapabilitiesSchema = import_zod12.z.object({
    * Whether the driver supports database transactions.
    * If true, beginTransaction, commit, and rollback must be implemented.
    */
-  transactions: import_zod12.z.boolean().default(false).describe("Supports ACID transactions"),
+  transactions: import_zod13.z.boolean().default(false).describe("Supports ACID transactions"),
   /**
    * Whether the driver supports savepoints within transactions.
    */
-  savepoints: import_zod12.z.boolean().default(false).describe("Supports transaction savepoints"),
+  savepoints: import_zod13.z.boolean().default(false).describe("Supports transaction savepoints"),
   /**
    * Supported transaction isolation levels.
    */
-  isolationLevels: import_zod12.z.array(import_zod12.z.enum([
+  isolationLevels: import_zod13.z.array(import_zod13.z.enum([
     "read-uncommitted",
     "read-committed",
     "repeatable-read",
@@ -1625,41 +1725,41 @@ var DriverCapabilitiesSchema = import_zod12.z.object({
    * 
    * Example: Memory driver might not support complex filter conditions.
    */
-  queryFilters: import_zod12.z.boolean().default(true).describe("Supports WHERE clause filtering"),
+  queryFilters: import_zod13.z.boolean().default(true).describe("Supports WHERE clause filtering"),
   /**
    * Whether the driver supports aggregation functions (COUNT, SUM, AVG, etc.).
    * If false, ObjectQL will compute aggregations in memory.
    */
-  queryAggregations: import_zod12.z.boolean().default(false).describe("Supports GROUP BY and aggregation functions"),
+  queryAggregations: import_zod13.z.boolean().default(false).describe("Supports GROUP BY and aggregation functions"),
   /**
    * Whether the driver supports ORDER BY sorting.
    * If false, ObjectQL will sort results in memory.
    */
-  querySorting: import_zod12.z.boolean().default(true).describe("Supports ORDER BY sorting"),
+  querySorting: import_zod13.z.boolean().default(true).describe("Supports ORDER BY sorting"),
   /**
    * Whether the driver supports LIMIT/OFFSET pagination.
    * If false, ObjectQL will fetch all records and paginate in memory.
    */
-  queryPagination: import_zod12.z.boolean().default(true).describe("Supports LIMIT/OFFSET pagination"),
+  queryPagination: import_zod13.z.boolean().default(true).describe("Supports LIMIT/OFFSET pagination"),
   /**
    * Whether the driver supports window functions (ROW_NUMBER, RANK, LAG, LEAD, etc.).
    * If false, ObjectQL will compute window functions in memory.
    */
-  queryWindowFunctions: import_zod12.z.boolean().default(false).describe("Supports window functions with OVER clause"),
+  queryWindowFunctions: import_zod13.z.boolean().default(false).describe("Supports window functions with OVER clause"),
   /**
    * Whether the driver supports subqueries (nested SELECT statements).
    * If false, ObjectQL will execute queries separately and combine results.
    */
-  querySubqueries: import_zod12.z.boolean().default(false).describe("Supports subqueries"),
+  querySubqueries: import_zod13.z.boolean().default(false).describe("Supports subqueries"),
   /**
    * Whether the driver supports Common Table Expressions (WITH clause).
    */
-  queryCTE: import_zod12.z.boolean().default(false).describe("Supports Common Table Expressions (WITH clause)"),
+  queryCTE: import_zod13.z.boolean().default(false).describe("Supports Common Table Expressions (WITH clause)"),
   /**
    * Whether the driver supports SQL-style joins.
    * If false, ObjectQL will fetch related data separately and join in memory.
    */
-  joins: import_zod12.z.boolean().default(false).describe("Supports SQL joins"),
+  joins: import_zod13.z.boolean().default(false).describe("Supports SQL joins"),
   // ============================================================================
   // Advanced Features
   // ============================================================================
@@ -1667,69 +1767,69 @@ var DriverCapabilitiesSchema = import_zod12.z.object({
    * Whether the driver supports full-text search.
    * If true, text search queries can be pushed to the database.
    */
-  fullTextSearch: import_zod12.z.boolean().default(false).describe("Supports full-text search"),
+  fullTextSearch: import_zod13.z.boolean().default(false).describe("Supports full-text search"),
   /**
    * Whether the driver supports JSON querying capabilities.
    */
-  jsonQuery: import_zod12.z.boolean().default(false).describe("Supports JSON field querying"),
+  jsonQuery: import_zod13.z.boolean().default(false).describe("Supports JSON field querying"),
   /**
    * Whether the driver supports geospatial queries.
    */
-  geospatialQuery: import_zod12.z.boolean().default(false).describe("Supports geospatial queries"),
+  geospatialQuery: import_zod13.z.boolean().default(false).describe("Supports geospatial queries"),
   /**
    * Whether the driver supports streaming large result sets.
    */
-  streaming: import_zod12.z.boolean().default(false).describe("Supports result streaming (cursors/iterators)"),
+  streaming: import_zod13.z.boolean().default(false).describe("Supports result streaming (cursors/iterators)"),
   /**
    * Whether the driver supports JSON field types.
    * If false, JSON data will be serialized as strings.
    */
-  jsonFields: import_zod12.z.boolean().default(false).describe("Supports JSON field types"),
+  jsonFields: import_zod13.z.boolean().default(false).describe("Supports JSON field types"),
   /**
    * Whether the driver supports array field types.
    * If false, arrays will be stored as JSON strings or in separate tables.
    */
-  arrayFields: import_zod12.z.boolean().default(false).describe("Supports array field types"),
+  arrayFields: import_zod13.z.boolean().default(false).describe("Supports array field types"),
   /**
    * Whether the driver supports vector embeddings and similarity search.
    * Required for RAG (Retrieval-Augmented Generation) and AI features.
    */
-  vectorSearch: import_zod12.z.boolean().default(false).describe("Supports vector embeddings and similarity search"),
+  vectorSearch: import_zod13.z.boolean().default(false).describe("Supports vector embeddings and similarity search"),
   /**
    * Whether the driver supports geospatial queries.
    * @deprecated Use geospatialQuery instead
    */
-  geoSpatial: import_zod12.z.boolean().default(false).describe("Supports geospatial queries (deprecated: use geospatialQuery)"),
+  geoSpatial: import_zod13.z.boolean().default(false).describe("Supports geospatial queries (deprecated: use geospatialQuery)"),
   // ============================================================================
   // Schema Management
   // ============================================================================
   /**
    * Whether the driver supports automatic schema synchronization.
    */
-  schemaSync: import_zod12.z.boolean().default(false).describe("Supports automatic schema synchronization"),
+  schemaSync: import_zod13.z.boolean().default(false).describe("Supports automatic schema synchronization"),
   /**
    * Whether the driver supports database migrations.
    */
-  migrations: import_zod12.z.boolean().default(false).describe("Supports database migrations"),
+  migrations: import_zod13.z.boolean().default(false).describe("Supports database migrations"),
   /**
    * Whether the driver supports index management.
    */
-  indexes: import_zod12.z.boolean().default(false).describe("Supports index creation and management"),
+  indexes: import_zod13.z.boolean().default(false).describe("Supports index creation and management"),
   // ============================================================================
   // Performance & Optimization
   // ============================================================================
   /**
    * Whether the driver supports connection pooling.
    */
-  connectionPooling: import_zod12.z.boolean().default(false).describe("Supports connection pooling"),
+  connectionPooling: import_zod13.z.boolean().default(false).describe("Supports connection pooling"),
   /**
    * Whether the driver supports prepared statements.
    */
-  preparedStatements: import_zod12.z.boolean().default(false).describe("Supports prepared statements (SQL injection prevention)"),
+  preparedStatements: import_zod13.z.boolean().default(false).describe("Supports prepared statements (SQL injection prevention)"),
   /**
    * Whether the driver supports query result caching.
    */
-  queryCache: import_zod12.z.boolean().default(false).describe("Supports query result caching")
+  queryCache: import_zod13.z.boolean().default(false).describe("Supports query result caching")
 }).refine((data) => {
   if (data.geoSpatial !== void 0 && data.geospatialQuery !== void 0 && data.geoSpatial !== data.geospatialQuery) {
     return false;
@@ -1738,15 +1838,15 @@ var DriverCapabilitiesSchema = import_zod12.z.object({
 }, {
   message: "Deprecated geoSpatial and geospatialQuery must have the same value if both are provided"
 });
-var DriverInterfaceSchema = import_zod12.z.object({
+var DriverInterfaceSchema = import_zod13.z.object({
   /**
    * Driver name (e.g., 'postgresql', 'mongodb', 'rest_api').
    */
-  name: import_zod12.z.string().describe("Driver unique name"),
+  name: import_zod13.z.string().describe("Driver unique name"),
   /**
    * Driver version.
    */
-  version: import_zod12.z.string().describe("Driver version"),
+  version: import_zod13.z.string().describe("Driver version"),
   /**
    * Capabilities descriptor.
    */
@@ -1757,25 +1857,25 @@ var DriverInterfaceSchema = import_zod12.z.object({
   /**
    * Initialize connection pool or authenticate.
    */
-  connect: import_zod12.z.function().args().returns(import_zod12.z.promise(import_zod12.z.void())).describe("Establish connection"),
+  connect: import_zod13.z.function().args().returns(import_zod13.z.promise(import_zod13.z.void())).describe("Establish connection"),
   /**
    * Close connections and cleanup resources.
    */
-  disconnect: import_zod12.z.function().args().returns(import_zod12.z.promise(import_zod12.z.void())).describe("Close connection"),
+  disconnect: import_zod13.z.function().args().returns(import_zod13.z.promise(import_zod13.z.void())).describe("Close connection"),
   /**
    * Check connection health.
    * @returns true if healthy, false otherwise.
    */
-  checkHealth: import_zod12.z.function().args().returns(import_zod12.z.promise(import_zod12.z.boolean())).describe("Health check"),
+  checkHealth: import_zod13.z.function().args().returns(import_zod13.z.promise(import_zod13.z.boolean())).describe("Health check"),
   /**
    * Get Connection Pool Statistics.
    * Useful for monitoring database load.
    */
-  getPoolStats: import_zod12.z.function().args().returns(import_zod12.z.object({
-    total: import_zod12.z.number(),
-    idle: import_zod12.z.number(),
-    active: import_zod12.z.number(),
-    waiting: import_zod12.z.number()
+  getPoolStats: import_zod13.z.function().args().returns(import_zod13.z.object({
+    total: import_zod13.z.number(),
+    idle: import_zod13.z.number(),
+    active: import_zod13.z.number(),
+    waiting: import_zod13.z.number()
   }).optional()).optional().describe("Get connection pool statistics"),
   // ============================================================================
   // Raw Execution (Escape Hatch)
@@ -1796,7 +1896,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * // Mongo Driver
    * await driver.execute({ aggregate: 'orders', pipeline: [...] });
    */
-  execute: import_zod12.z.function().args(import_zod12.z.any(), import_zod12.z.array(import_zod12.z.any()).optional(), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.any())).describe("Execute raw command"),
+  execute: import_zod13.z.function().args(import_zod13.z.any(), import_zod13.z.array(import_zod13.z.any()).optional(), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.any())).describe("Execute raw command"),
   // ============================================================================
   // CRUD Operations
   // ============================================================================
@@ -1818,7 +1918,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @returns Array of records.
    *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
    */
-  find: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.array(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())))).describe("Find records"),
+  find: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.array(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any())))).describe("Find records"),
   /**
    * Stream records matching the structured query.
    * Optimized for large datasets to avoid memory overflow.
@@ -1828,7 +1928,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param options - Driver options.
    * @returns AsyncIterable/ReadableStream of records.
    */
-  findStream: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod12.z.any()).describe("Stream records (AsyncIterable)"),
+  findStream: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod13.z.any()).describe("Stream records (AsyncIterable)"),
   /**
    * Find a single record by query.
    * Similar to find(), but returns only the first match or null.
@@ -1839,7 +1939,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @returns The record or null.
    *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
    */
-  findOne: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()).nullable())).describe("Find one record"),
+  findOne: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()).nullable())).describe("Find one record"),
   /**
    * Create a new record.
    * 
@@ -1849,7 +1949,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @returns The created record, including server-generated fields (id, created_at, etc.).
    *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
    */
-  create: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()))).describe("Create record"),
+  create: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()))).describe("Create record"),
   /**
    * Update an existing record by ID.
    * 
@@ -1860,7 +1960,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @returns The updated record.
    *          MUST return `id` as string. MUST NOT return implementation details like `_id`.
    */
-  update: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.string().or(import_zod12.z.number()), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()))).describe("Update record"),
+  update: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.string().or(import_zod13.z.number()), import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()))).describe("Update record"),
   /**
    * Upsert (Update or Insert) a record.
    * 
@@ -1870,7 +1970,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param options - Driver options.
    * @returns The created or updated record.
    */
-  upsert: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), import_zod12.z.array(import_zod12.z.string()).optional(), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()))).describe("Upsert record"),
+  upsert: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()), import_zod13.z.array(import_zod13.z.string()).optional(), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()))).describe("Upsert record"),
   /**
    * Delete a record by ID.
    * 
@@ -1879,7 +1979,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param options - Driver options.
    * @returns True if deleted, false if not found.
    */
-  delete: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.string().or(import_zod12.z.number()), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.boolean())).describe("Delete record"),
+  delete: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.string().or(import_zod13.z.number()), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.boolean())).describe("Delete record"),
   /**
    * Count records matching a query.
    * 
@@ -1888,7 +1988,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param options - Driver options.
    * @returns Total count.
    */
-  count: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema.optional(), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.number())).describe("Count records"),
+  count: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema.optional(), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.number())).describe("Count records"),
   // ============================================================================
   // Bulk Operations
   // ============================================================================
@@ -1900,7 +2000,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param dataArray - Array of record data.
    * @returns Array of created records.
    */
-  bulkCreate: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.array(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())))),
+  bulkCreate: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.array(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any())), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.array(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any())))),
   /**
    * Update multiple records in a single batch.
    * 
@@ -1908,14 +2008,14 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param updates - Array of objects containing {id, data}.
    * @returns Array of updated records.
    */
-  bulkUpdate: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.object({ id: import_zod12.z.string().or(import_zod12.z.number()), data: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()) })), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.array(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())))),
+  bulkUpdate: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.array(import_zod13.z.object({ id: import_zod13.z.string().or(import_zod13.z.number()), data: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()) })), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.array(import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any())))),
   /**
    * Delete multiple records in a single batch.
    * 
    * @param object - The object name.
    * @param ids - Array of record IDs.
    */
-  bulkDelete: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.string().or(import_zod12.z.number())), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.void())),
+  bulkDelete: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.array(import_zod13.z.string().or(import_zod13.z.number())), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.void())),
   /**
    * Update multiple records matching a query.
    * Direct database push-down. DOES NOT trigger per-record hooks.
@@ -1925,7 +2025,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param data - The data to update.
    * @returns Count of modified records.
    */
-  updateMany: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema, import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.number())).optional(),
+  updateMany: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema, import_zod13.z.record(import_zod13.z.string(), import_zod13.z.any()), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.number())).optional(),
   /**
    * Delete multiple records matching a query.
    * Direct database push-down. DOES NOT trigger per-record hooks.
@@ -1934,7 +2034,7 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param query - The filtering criteria.
    * @returns Count of deleted records.
    */
-  deleteMany: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.number())).optional(),
+  deleteMany: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.number())).optional(),
   // ============================================================================
   // Transaction Management
   // ============================================================================
@@ -1943,19 +2043,19 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param options - Isolation level and other settings.
    * @returns A transaction handle to be passed to subsequent operations via `options.transaction`.
    */
-  beginTransaction: import_zod12.z.function().args(import_zod12.z.object({
-    isolationLevel: import_zod12.z.enum(["READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SERIALIZABLE", "SNAPSHOT"]).optional()
-  }).optional()).returns(import_zod12.z.promise(import_zod12.z.any())).describe("Start transaction"),
+  beginTransaction: import_zod13.z.function().args(import_zod13.z.object({
+    isolationLevel: import_zod13.z.enum(["READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SERIALIZABLE", "SNAPSHOT"]).optional()
+  }).optional()).returns(import_zod13.z.promise(import_zod13.z.any())).describe("Start transaction"),
   /**
    * Commit the transaction.
    * @param transaction - The transaction handle.
    */
-  commit: import_zod12.z.function().args(import_zod12.z.any()).returns(import_zod12.z.promise(import_zod12.z.void())).describe("Commit transaction"),
+  commit: import_zod13.z.function().args(import_zod13.z.any()).returns(import_zod13.z.promise(import_zod13.z.void())).describe("Commit transaction"),
   /**
    * Rollback the transaction.
    * @param transaction - The transaction handle.
    */
-  rollback: import_zod12.z.function().args(import_zod12.z.any()).returns(import_zod12.z.promise(import_zod12.z.void())).describe("Rollback transaction"),
+  rollback: import_zod13.z.function().args(import_zod13.z.any()).returns(import_zod13.z.promise(import_zod13.z.void())).describe("Rollback transaction"),
   // ============================================================================
   // Schema Management
   // ============================================================================
@@ -1968,14 +2068,14 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param schema - The full Object Schema (fields, indexes, etc).
    * @param options - Driver options.
    */
-  syncSchema: import_zod12.z.function().args(import_zod12.z.string(), import_zod12.z.any(), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.void())).describe("Sync object schema to DB"),
+  syncSchema: import_zod13.z.function().args(import_zod13.z.string(), import_zod13.z.any(), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.void())).describe("Sync object schema to DB"),
   /**
    * Drop the underlying table or collection for an object.
    * WARNING: Destructive operation.
    * 
    * @param object - The object name.
    */
-  dropTable: import_zod12.z.function().args(import_zod12.z.string(), DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.void())),
+  dropTable: import_zod13.z.function().args(import_zod13.z.string(), DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.void())),
   /**
    * Analyze query performance.
    * Returns execution plan without executing the query (where possible).
@@ -1984,25 +2084,25 @@ var DriverInterfaceSchema = import_zod12.z.object({
    * @param query - The query to explain.
    * @returns The execution plan details.
    */
-  explain: import_zod12.z.function().args(import_zod12.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod12.z.promise(import_zod12.z.any())).optional()
+  explain: import_zod13.z.function().args(import_zod13.z.string(), QuerySchema, DriverOptionsSchema.optional()).returns(import_zod13.z.promise(import_zod13.z.any())).optional()
 });
-var PoolConfigSchema = import_zod12.z.object({
-  min: import_zod12.z.number().min(0).default(2).describe("Minimum number of connections in pool"),
-  max: import_zod12.z.number().min(1).default(10).describe("Maximum number of connections in pool"),
-  idleTimeoutMillis: import_zod12.z.number().min(0).default(3e4).describe("Time in ms before idle connection is closed"),
-  connectionTimeoutMillis: import_zod12.z.number().min(0).default(5e3).describe("Time in ms to wait for available connection")
+var PoolConfigSchema = import_zod13.z.object({
+  min: import_zod13.z.number().min(0).default(2).describe("Minimum number of connections in pool"),
+  max: import_zod13.z.number().min(1).default(10).describe("Maximum number of connections in pool"),
+  idleTimeoutMillis: import_zod13.z.number().min(0).default(3e4).describe("Time in ms before idle connection is closed"),
+  connectionTimeoutMillis: import_zod13.z.number().min(0).default(5e3).describe("Time in ms to wait for available connection")
 });
-var DriverConfigSchema = import_zod12.z.object({
-  name: import_zod12.z.string().describe("Driver instance name"),
-  type: import_zod12.z.enum(["sql", "nosql", "cache", "search", "graph", "timeseries"]).describe("Driver type category"),
+var DriverConfigSchema = import_zod13.z.object({
+  name: import_zod13.z.string().describe("Driver instance name"),
+  type: import_zod13.z.enum(["sql", "nosql", "cache", "search", "graph", "timeseries"]).describe("Driver type category"),
   capabilities: DriverCapabilitiesSchema.describe("Driver capability flags"),
-  connectionString: import_zod12.z.string().optional().describe("Database connection string (driver-specific format)"),
+  connectionString: import_zod13.z.string().optional().describe("Database connection string (driver-specific format)"),
   poolConfig: PoolConfigSchema.optional().describe("Connection pool configuration")
 });
 
 // src/data/driver-sql.zod.ts
-var import_zod13 = require("zod");
-var SQLDialectSchema = import_zod13.z.enum([
+var import_zod14 = require("zod");
+var SQLDialectSchema = import_zod14.z.enum([
   "postgresql",
   "mysql",
   "sqlite",
@@ -2010,21 +2110,21 @@ var SQLDialectSchema = import_zod13.z.enum([
   "oracle",
   "mariadb"
 ]);
-var DataTypeMappingSchema = import_zod13.z.object({
-  text: import_zod13.z.string().describe("SQL type for text fields (e.g., VARCHAR, TEXT)"),
-  number: import_zod13.z.string().describe("SQL type for number fields (e.g., NUMERIC, DECIMAL, INT)"),
-  boolean: import_zod13.z.string().describe("SQL type for boolean fields (e.g., BOOLEAN, BIT)"),
-  date: import_zod13.z.string().describe("SQL type for date fields (e.g., DATE)"),
-  datetime: import_zod13.z.string().describe("SQL type for datetime fields (e.g., TIMESTAMP, DATETIME)"),
-  json: import_zod13.z.string().optional().describe("SQL type for JSON fields (e.g., JSON, JSONB)"),
-  uuid: import_zod13.z.string().optional().describe("SQL type for UUID fields (e.g., UUID, CHAR(36))"),
-  binary: import_zod13.z.string().optional().describe("SQL type for binary fields (e.g., BLOB, BYTEA)")
-});
-var SSLConfigSchema = import_zod13.z.object({
-  rejectUnauthorized: import_zod13.z.boolean().default(true).describe("Reject connections with invalid certificates"),
-  ca: import_zod13.z.string().optional().describe("CA certificate file path or content"),
-  cert: import_zod13.z.string().optional().describe("Client certificate file path or content"),
-  key: import_zod13.z.string().optional().describe("Client private key file path or content")
+var DataTypeMappingSchema = import_zod14.z.object({
+  text: import_zod14.z.string().describe("SQL type for text fields (e.g., VARCHAR, TEXT)"),
+  number: import_zod14.z.string().describe("SQL type for number fields (e.g., NUMERIC, DECIMAL, INT)"),
+  boolean: import_zod14.z.string().describe("SQL type for boolean fields (e.g., BOOLEAN, BIT)"),
+  date: import_zod14.z.string().describe("SQL type for date fields (e.g., DATE)"),
+  datetime: import_zod14.z.string().describe("SQL type for datetime fields (e.g., TIMESTAMP, DATETIME)"),
+  json: import_zod14.z.string().optional().describe("SQL type for JSON fields (e.g., JSON, JSONB)"),
+  uuid: import_zod14.z.string().optional().describe("SQL type for UUID fields (e.g., UUID, CHAR(36))"),
+  binary: import_zod14.z.string().optional().describe("SQL type for binary fields (e.g., BLOB, BYTEA)")
+});
+var SSLConfigSchema = import_zod14.z.object({
+  rejectUnauthorized: import_zod14.z.boolean().default(true).describe("Reject connections with invalid certificates"),
+  ca: import_zod14.z.string().optional().describe("CA certificate file path or content"),
+  cert: import_zod14.z.string().optional().describe("Client certificate file path or content"),
+  key: import_zod14.z.string().optional().describe("Client private key file path or content")
 }).refine((data) => {
   const hasCert = data.cert !== void 0;
   const hasKey = data.key !== void 0;
@@ -2033,10 +2133,10 @@ var SSLConfigSchema = import_zod13.z.object({
   message: "Client certificate (cert) and private key (key) must be provided together"
 });
 var SQLDriverConfigSchema = DriverConfigSchema.extend({
-  type: import_zod13.z.literal("sql").describe('Driver type must be "sql"'),
+  type: import_zod14.z.literal("sql").describe('Driver type must be "sql"'),
   dialect: SQLDialectSchema.describe("SQL database dialect"),
   dataTypeMapping: DataTypeMappingSchema.describe("SQL data type mapping configuration"),
-  ssl: import_zod13.z.boolean().default(false).describe("Enable SSL/TLS connection"),
+  ssl: import_zod14.z.boolean().default(false).describe("Enable SSL/TLS connection"),
   sslConfig: SSLConfigSchema.optional().describe("SSL/TLS configuration (required when ssl is true)")
 }).refine((data) => {
   if (data.ssl && !data.sslConfig) {
@@ -2048,8 +2148,8 @@ var SQLDriverConfigSchema = DriverConfigSchema.extend({
 });
 
 // src/data/driver-nosql.zod.ts
-var import_zod14 = require("zod");
-var NoSQLDatabaseTypeSchema = import_zod14.z.enum([
+var import_zod15 = require("zod");
+var NoSQLDatabaseTypeSchema = import_zod15.z.enum([
   "mongodb",
   "couchdb",
   "dynamodb",
@@ -2059,7 +2159,7 @@ var NoSQLDatabaseTypeSchema = import_zod14.z.enum([
   "neo4j",
   "orientdb"
 ]);
-var NoSQLOperationTypeSchema = import_zod14.z.enum([
+var NoSQLOperationTypeSchema = import_zod15.z.enum([
   "find",
   // Query documents/records
   "findOne",
@@ -2083,7 +2183,7 @@ var NoSQLOperationTypeSchema = import_zod14.z.enum([
   "dropIndex"
   // Drop index
 ]);
-var ConsistencyLevelSchema = import_zod14.z.enum([
+var ConsistencyLevelSchema = import_zod15.z.enum([
   "all",
   "quorum",
   "one",
@@ -2091,7 +2191,7 @@ var ConsistencyLevelSchema = import_zod14.z.enum([
   "each_quorum",
   "eventual"
 ]);
-var NoSQLIndexTypeSchema = import_zod14.z.enum([
+var NoSQLIndexTypeSchema = import_zod15.z.enum([
   "single",
   // Single field index
   "compound",
@@ -2109,40 +2209,40 @@ var NoSQLIndexTypeSchema = import_zod14.z.enum([
   "sparse"
   // Sparse index (only indexed documents with field)
 ]);
-var ShardingConfigSchema = import_zod14.z.object({
-  enabled: import_zod14.z.boolean().default(false).describe("Enable sharding"),
-  shardKey: import_zod14.z.string().optional().describe("Field to use as shard key"),
-  shardingStrategy: import_zod14.z.enum(["hash", "range", "zone"]).optional().describe("Sharding strategy"),
-  numShards: import_zod14.z.number().int().positive().optional().describe("Number of shards")
-});
-var ReplicationConfigSchema = import_zod14.z.object({
-  enabled: import_zod14.z.boolean().default(false).describe("Enable replication"),
-  replicaSetName: import_zod14.z.string().optional().describe("Replica set name"),
-  replicas: import_zod14.z.number().int().positive().optional().describe("Number of replicas"),
-  readPreference: import_zod14.z.enum(["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]).optional().describe("Read preference for replica set"),
-  writeConcern: import_zod14.z.enum(["majority", "acknowledged", "unacknowledged"]).optional().describe("Write concern level")
-});
-var DocumentSchemaValidationSchema = import_zod14.z.object({
-  enabled: import_zod14.z.boolean().default(false).describe("Enable schema validation"),
-  validationLevel: import_zod14.z.enum(["strict", "moderate", "off"]).optional().describe("Validation strictness"),
-  validationAction: import_zod14.z.enum(["error", "warn"]).optional().describe("Action on validation failure"),
-  jsonSchema: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.any()).optional().describe("JSON Schema for validation")
-});
-var NoSQLDataTypeMappingSchema = import_zod14.z.object({
-  text: import_zod14.z.string().describe("NoSQL type for text fields"),
-  number: import_zod14.z.string().describe("NoSQL type for number fields"),
-  boolean: import_zod14.z.string().describe("NoSQL type for boolean fields"),
-  date: import_zod14.z.string().describe("NoSQL type for date fields"),
-  datetime: import_zod14.z.string().describe("NoSQL type for datetime fields"),
-  json: import_zod14.z.string().optional().describe("NoSQL type for JSON/object fields"),
-  uuid: import_zod14.z.string().optional().describe("NoSQL type for UUID fields"),
-  binary: import_zod14.z.string().optional().describe("NoSQL type for binary fields"),
-  array: import_zod14.z.string().optional().describe("NoSQL type for array fields"),
-  objectId: import_zod14.z.string().optional().describe("NoSQL type for ObjectID fields (MongoDB)"),
-  geopoint: import_zod14.z.string().optional().describe("NoSQL type for geospatial point fields")
+var ShardingConfigSchema = import_zod15.z.object({
+  enabled: import_zod15.z.boolean().default(false).describe("Enable sharding"),
+  shardKey: import_zod15.z.string().optional().describe("Field to use as shard key"),
+  shardingStrategy: import_zod15.z.enum(["hash", "range", "zone"]).optional().describe("Sharding strategy"),
+  numShards: import_zod15.z.number().int().positive().optional().describe("Number of shards")
+});
+var ReplicationConfigSchema = import_zod15.z.object({
+  enabled: import_zod15.z.boolean().default(false).describe("Enable replication"),
+  replicaSetName: import_zod15.z.string().optional().describe("Replica set name"),
+  replicas: import_zod15.z.number().int().positive().optional().describe("Number of replicas"),
+  readPreference: import_zod15.z.enum(["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]).optional().describe("Read preference for replica set"),
+  writeConcern: import_zod15.z.enum(["majority", "acknowledged", "unacknowledged"]).optional().describe("Write concern level")
+});
+var DocumentSchemaValidationSchema = import_zod15.z.object({
+  enabled: import_zod15.z.boolean().default(false).describe("Enable schema validation"),
+  validationLevel: import_zod15.z.enum(["strict", "moderate", "off"]).optional().describe("Validation strictness"),
+  validationAction: import_zod15.z.enum(["error", "warn"]).optional().describe("Action on validation failure"),
+  jsonSchema: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).optional().describe("JSON Schema for validation")
+});
+var NoSQLDataTypeMappingSchema = import_zod15.z.object({
+  text: import_zod15.z.string().describe("NoSQL type for text fields"),
+  number: import_zod15.z.string().describe("NoSQL type for number fields"),
+  boolean: import_zod15.z.string().describe("NoSQL type for boolean fields"),
+  date: import_zod15.z.string().describe("NoSQL type for date fields"),
+  datetime: import_zod15.z.string().describe("NoSQL type for datetime fields"),
+  json: import_zod15.z.string().optional().describe("NoSQL type for JSON/object fields"),
+  uuid: import_zod15.z.string().optional().describe("NoSQL type for UUID fields"),
+  binary: import_zod15.z.string().optional().describe("NoSQL type for binary fields"),
+  array: import_zod15.z.string().optional().describe("NoSQL type for array fields"),
+  objectId: import_zod15.z.string().optional().describe("NoSQL type for ObjectID fields (MongoDB)"),
+  geopoint: import_zod15.z.string().optional().describe("NoSQL type for geospatial point fields")
 });
 var NoSQLDriverConfigSchema = DriverConfigSchema.extend({
-  type: import_zod14.z.literal("nosql").describe('Driver type must be "nosql"'),
+  type: import_zod15.z.literal("nosql").describe('Driver type must be "nosql"'),
   databaseType: NoSQLDatabaseTypeSchema.describe("Specific NoSQL database type"),
   dataTypeMapping: NoSQLDataTypeMappingSchema.describe("NoSQL data type mapping configuration"),
   /**
@@ -2164,31 +2264,31 @@ var NoSQLDriverConfigSchema = DriverConfigSchema.extend({
   /**
    * AWS Region (for DynamoDB, DocumentDB, etc.)
    */
-  region: import_zod14.z.string().optional().describe("AWS region (for managed NoSQL services)"),
+  region: import_zod15.z.string().optional().describe("AWS region (for managed NoSQL services)"),
   /**
    * AWS Access Key ID (for DynamoDB, DocumentDB, etc.)
    */
-  accessKeyId: import_zod14.z.string().optional().describe("AWS access key ID"),
+  accessKeyId: import_zod15.z.string().optional().describe("AWS access key ID"),
   /**
    * AWS Secret Access Key (for DynamoDB, DocumentDB, etc.)
    */
-  secretAccessKey: import_zod14.z.string().optional().describe("AWS secret access key"),
+  secretAccessKey: import_zod15.z.string().optional().describe("AWS secret access key"),
   /**
    * Time-to-live (TTL) field name
    * Automatically delete documents after a specified time
    */
-  ttlField: import_zod14.z.string().optional().describe("Field name for TTL (auto-deletion)"),
+  ttlField: import_zod15.z.string().optional().describe("Field name for TTL (auto-deletion)"),
   /**
    * Maximum document size in bytes
    */
-  maxDocumentSize: import_zod14.z.number().int().positive().optional().describe("Maximum document size in bytes"),
+  maxDocumentSize: import_zod15.z.number().int().positive().optional().describe("Maximum document size in bytes"),
   /**
    * Collection/Table name prefix
    * Useful for multi-tenancy or environment isolation
    */
-  collectionPrefix: import_zod14.z.string().optional().describe("Prefix for collection/table names")
+  collectionPrefix: import_zod15.z.string().optional().describe("Prefix for collection/table names")
 });
-var NoSQLQueryOptionsSchema = import_zod14.z.object({
+var NoSQLQueryOptionsSchema = import_zod15.z.object({
   /**
    * Consistency level for this query
    */
@@ -2196,61 +2296,61 @@ var NoSQLQueryOptionsSchema = import_zod14.z.object({
   /**
    * Read from secondary replicas
    */
-  readFromSecondary: import_zod14.z.boolean().optional().describe("Allow reading from secondary replicas"),
+  readFromSecondary: import_zod15.z.boolean().optional().describe("Allow reading from secondary replicas"),
   /**
    * Projection (fields to include/exclude)
    */
-  projection: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.union([import_zod14.z.literal(0), import_zod14.z.literal(1)])).optional().describe("Field projection"),
+  projection: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.union([import_zod15.z.literal(0), import_zod15.z.literal(1)])).optional().describe("Field projection"),
   /**
    * Query timeout in milliseconds
    */
-  timeout: import_zod14.z.number().int().positive().optional().describe("Query timeout (ms)"),
+  timeout: import_zod15.z.number().int().positive().optional().describe("Query timeout (ms)"),
   /**
    * Use cursor for large result sets
    */
-  useCursor: import_zod14.z.boolean().optional().describe("Use cursor instead of loading all results"),
+  useCursor: import_zod15.z.boolean().optional().describe("Use cursor instead of loading all results"),
   /**
    * Batch size for cursor iteration
    */
-  batchSize: import_zod14.z.number().int().positive().optional().describe("Cursor batch size"),
+  batchSize: import_zod15.z.number().int().positive().optional().describe("Cursor batch size"),
   /**
    * Enable query profiling
    */
-  profile: import_zod14.z.boolean().optional().describe("Enable query profiling"),
+  profile: import_zod15.z.boolean().optional().describe("Enable query profiling"),
   /**
    * Use hinted index
    */
-  hint: import_zod14.z.string().optional().describe("Index hint for query optimization")
+  hint: import_zod15.z.string().optional().describe("Index hint for query optimization")
 });
-var AggregationStageSchema = import_zod14.z.object({
+var AggregationStageSchema = import_zod15.z.object({
   /**
    * Stage operator (e.g., $match, $group, $sort, $project)
    */
-  operator: import_zod14.z.string().describe("Aggregation operator (e.g., $match, $group, $sort)"),
+  operator: import_zod15.z.string().describe("Aggregation operator (e.g., $match, $group, $sort)"),
   /**
    * Stage parameters/options
    */
-  options: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.any()).describe("Stage-specific options")
+  options: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).describe("Stage-specific options")
 });
-var AggregationPipelineSchema = import_zod14.z.object({
+var AggregationPipelineSchema = import_zod15.z.object({
   /**
    * Collection/Table to aggregate
    */
-  collection: import_zod14.z.string().describe("Collection/table name"),
+  collection: import_zod15.z.string().describe("Collection/table name"),
   /**
    * Pipeline stages
    */
-  stages: import_zod14.z.array(AggregationStageSchema).describe("Aggregation pipeline stages"),
+  stages: import_zod15.z.array(AggregationStageSchema).describe("Aggregation pipeline stages"),
   /**
    * Additional options
    */
   options: NoSQLQueryOptionsSchema.optional().describe("Query options")
 });
-var NoSQLIndexSchema = import_zod14.z.object({
+var NoSQLIndexSchema = import_zod15.z.object({
   /**
    * Index name
    */
-  name: import_zod14.z.string().describe("Index name"),
+  name: import_zod15.z.string().describe("Index name"),
   /**
    * Index type
    */
@@ -2259,53 +2359,53 @@ var NoSQLIndexSchema = import_zod14.z.object({
    * Fields to index
    * For compound indexes, order matters
    */
-  fields: import_zod14.z.array(import_zod14.z.object({
-    field: import_zod14.z.string().describe("Field name"),
-    order: import_zod14.z.enum(["asc", "desc", "text", "2dsphere"]).optional().describe("Index order or type")
+  fields: import_zod15.z.array(import_zod15.z.object({
+    field: import_zod15.z.string().describe("Field name"),
+    order: import_zod15.z.enum(["asc", "desc", "text", "2dsphere"]).optional().describe("Index order or type")
   })).describe("Fields to index"),
   /**
    * Unique constraint
    */
-  unique: import_zod14.z.boolean().default(false).describe("Enforce uniqueness"),
+  unique: import_zod15.z.boolean().default(false).describe("Enforce uniqueness"),
   /**
    * Sparse index (only index documents with the field)
    */
-  sparse: import_zod14.z.boolean().default(false).describe("Sparse index"),
+  sparse: import_zod15.z.boolean().default(false).describe("Sparse index"),
   /**
    * TTL in seconds (for TTL indexes)
    */
-  expireAfterSeconds: import_zod14.z.number().int().positive().optional().describe("TTL in seconds"),
+  expireAfterSeconds: import_zod15.z.number().int().positive().optional().describe("TTL in seconds"),
   /**
    * Partial index filter
    */
-  partialFilterExpression: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.any()).optional().describe("Partial index filter"),
+  partialFilterExpression: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).optional().describe("Partial index filter"),
   /**
    * Background index creation
    */
-  background: import_zod14.z.boolean().default(false).describe("Create index in background")
+  background: import_zod15.z.boolean().default(false).describe("Create index in background")
 });
-var NoSQLTransactionOptionsSchema = import_zod14.z.object({
+var NoSQLTransactionOptionsSchema = import_zod15.z.object({
   /**
    * Read concern level
    */
-  readConcern: import_zod14.z.enum(["local", "majority", "linearizable", "snapshot"]).optional().describe("Read concern level"),
+  readConcern: import_zod15.z.enum(["local", "majority", "linearizable", "snapshot"]).optional().describe("Read concern level"),
   /**
    * Write concern level
    */
-  writeConcern: import_zod14.z.enum(["majority", "acknowledged", "unacknowledged"]).optional().describe("Write concern level"),
+  writeConcern: import_zod15.z.enum(["majority", "acknowledged", "unacknowledged"]).optional().describe("Write concern level"),
   /**
    * Read preference
    */
-  readPreference: import_zod14.z.enum(["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]).optional().describe("Read preference"),
+  readPreference: import_zod15.z.enum(["primary", "primaryPreferred", "secondary", "secondaryPreferred", "nearest"]).optional().describe("Read preference"),
   /**
    * Transaction timeout in milliseconds
    */
-  maxCommitTimeMS: import_zod14.z.number().int().positive().optional().describe("Transaction commit timeout (ms)")
+  maxCommitTimeMS: import_zod15.z.number().int().positive().optional().describe("Transaction commit timeout (ms)")
 });
 
 // src/data/dataset.zod.ts
-var import_zod15 = require("zod");
-var DatasetMode = import_zod15.z.enum([
+var import_zod16 = require("zod");
+var DatasetMode = import_zod16.z.enum([
   "insert",
   // Try to insert, fail on duplicate
   "update",
@@ -2317,19 +2417,19 @@ var DatasetMode = import_zod15.z.enum([
   "ignore"
   // Try to insert, silently skip duplicates
 ]);
-var DatasetSchema = import_zod15.z.object({
+var DatasetSchema = import_zod16.z.object({
   /** 
    * Target Object 
    * The machine name of the object to populate.
    */
-  object: import_zod15.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Target Object Name"),
+  object: import_zod16.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Target Object Name"),
   /** 
    * Idempotency Key (The "Upsert" Key)
    * The field used to check if a record already exists.
    * Best Practice: Use a natural key like 'code', 'slug', 'username' or 'external_id'.
    * Standard: '_id' (internal ID) is rarely used for portable seed data.
    */
-  externalId: import_zod15.z.string().default("name").describe("Field match for uniqueness check"),
+  externalId: import_zod16.z.string().default("name").describe("Field match for uniqueness check"),
   /** 
    * Import Strategy
    */
@@ -2340,182 +2440,182 @@ var DatasetSchema = import_zod15.z.object({
    * - 'dev': Only for development/demo
    * - 'test': Only for CI/CD tests
    */
-  env: import_zod15.z.array(import_zod15.z.enum(["prod", "dev", "test"])).default(["prod", "dev", "test"]).describe("Applicable environments"),
+  env: import_zod16.z.array(import_zod16.z.enum(["prod", "dev", "test"])).default(["prod", "dev", "test"]).describe("Applicable environments"),
   /** 
    * The Payload
    * Array of raw JSON objects matching the Object Schema.
    */
-  records: import_zod15.z.array(import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any())).describe("Data records")
+  records: import_zod16.z.array(import_zod16.z.record(import_zod16.z.string(), import_zod16.z.any())).describe("Data records")
 });
 
 // src/data/document.zod.ts
-var import_zod16 = require("zod");
-var DocumentVersionSchema = import_zod16.z.object({
+var import_zod17 = require("zod");
+var DocumentVersionSchema = import_zod17.z.object({
   /**
    * Sequential version number (increments with each new version)
    */
-  versionNumber: import_zod16.z.number().describe("Version number"),
+  versionNumber: import_zod17.z.number().describe("Version number"),
   /**
    * Timestamp when this version was created (Unix milliseconds)
    */
-  createdAt: import_zod16.z.number().describe("Creation timestamp"),
+  createdAt: import_zod17.z.number().describe("Creation timestamp"),
   /**
    * User ID who created this version
    */
-  createdBy: import_zod16.z.string().describe("Creator user ID"),
+  createdBy: import_zod17.z.string().describe("Creator user ID"),
   /**
    * File size in bytes
    */
-  size: import_zod16.z.number().describe("File size in bytes"),
+  size: import_zod17.z.number().describe("File size in bytes"),
   /**
    * Checksum/hash of the file content (for integrity verification)
    */
-  checksum: import_zod16.z.string().describe("File checksum"),
+  checksum: import_zod17.z.string().describe("File checksum"),
   /**
    * URL to download this specific version
    */
-  downloadUrl: import_zod16.z.string().url().describe("Download URL"),
+  downloadUrl: import_zod17.z.string().url().describe("Download URL"),
   /**
    * Whether this is the latest version
    * @default false
    */
-  isLatest: import_zod16.z.boolean().optional().default(false).describe("Is latest version")
+  isLatest: import_zod17.z.boolean().optional().default(false).describe("Is latest version")
 });
-var DocumentTemplateSchema = import_zod16.z.object({
+var DocumentTemplateSchema = import_zod17.z.object({
   /**
    * Unique identifier for the template
    */
-  id: import_zod16.z.string().describe("Template ID"),
+  id: import_zod17.z.string().describe("Template ID"),
   /**
    * Human-readable name of the template
    */
-  name: import_zod16.z.string().describe("Template name"),
+  name: import_zod17.z.string().describe("Template name"),
   /**
    * Optional description of the template's purpose
    */
-  description: import_zod16.z.string().optional().describe("Template description"),
+  description: import_zod17.z.string().optional().describe("Template description"),
   /**
    * URL to the template file
    */
-  fileUrl: import_zod16.z.string().url().describe("Template file URL"),
+  fileUrl: import_zod17.z.string().url().describe("Template file URL"),
   /**
    * MIME type of the template file
    */
-  fileType: import_zod16.z.string().describe("File MIME type"),
+  fileType: import_zod17.z.string().describe("File MIME type"),
   /**
    * List of dynamic placeholders in the template
    */
-  placeholders: import_zod16.z.array(import_zod16.z.object({
+  placeholders: import_zod17.z.array(import_zod17.z.object({
     /**
      * Placeholder identifier (used in template)
      */
-    key: import_zod16.z.string().describe("Placeholder key"),
+    key: import_zod17.z.string().describe("Placeholder key"),
     /**
      * Human-readable label for the placeholder
      */
-    label: import_zod16.z.string().describe("Placeholder label"),
+    label: import_zod17.z.string().describe("Placeholder label"),
     /**
      * Data type of the placeholder value
      */
-    type: import_zod16.z.enum(["text", "number", "date", "image"]).describe("Placeholder type"),
+    type: import_zod17.z.enum(["text", "number", "date", "image"]).describe("Placeholder type"),
     /**
      * Whether this placeholder must be filled
      * @default false
      */
-    required: import_zod16.z.boolean().optional().default(false).describe("Is required")
+    required: import_zod17.z.boolean().optional().default(false).describe("Is required")
   })).describe("Template placeholders")
 });
-var ESignatureConfigSchema = import_zod16.z.object({
+var ESignatureConfigSchema = import_zod17.z.object({
   /**
    * E-signature service provider
    */
-  provider: import_zod16.z.enum(["docusign", "adobe-sign", "hellosign", "custom"]).describe("E-signature provider"),
+  provider: import_zod17.z.enum(["docusign", "adobe-sign", "hellosign", "custom"]).describe("E-signature provider"),
   /**
    * Whether e-signature is enabled for this document
    * @default false
    */
-  enabled: import_zod16.z.boolean().optional().default(false).describe("E-signature enabled"),
+  enabled: import_zod17.z.boolean().optional().default(false).describe("E-signature enabled"),
   /**
    * List of signers in signing order
    */
-  signers: import_zod16.z.array(import_zod16.z.object({
+  signers: import_zod17.z.array(import_zod17.z.object({
     /**
      * Signer's email address
      */
-    email: import_zod16.z.string().email().describe("Signer email"),
+    email: import_zod17.z.string().email().describe("Signer email"),
     /**
      * Signer's full name
      */
-    name: import_zod16.z.string().describe("Signer name"),
+    name: import_zod17.z.string().describe("Signer name"),
     /**
      * Signer's role in the document
      */
-    role: import_zod16.z.string().describe("Signer role"),
+    role: import_zod17.z.string().describe("Signer role"),
     /**
      * Signing order (lower numbers sign first)
      */
-    order: import_zod16.z.number().describe("Signing order")
+    order: import_zod17.z.number().describe("Signing order")
   })).describe("Document signers"),
   /**
    * Days until signature request expires
    * @default 30
    */
-  expirationDays: import_zod16.z.number().optional().default(30).describe("Expiration days"),
+  expirationDays: import_zod17.z.number().optional().default(30).describe("Expiration days"),
   /**
    * Days between reminder emails
    * @default 7
    */
-  reminderDays: import_zod16.z.number().optional().default(7).describe("Reminder interval days")
+  reminderDays: import_zod17.z.number().optional().default(7).describe("Reminder interval days")
 });
-var DocumentSchema = import_zod16.z.object({
+var DocumentSchema = import_zod17.z.object({
   /**
    * Unique document identifier
    */
-  id: import_zod16.z.string().describe("Document ID"),
+  id: import_zod17.z.string().describe("Document ID"),
   /**
    * Document name
    */
-  name: import_zod16.z.string().describe("Document name"),
+  name: import_zod17.z.string().describe("Document name"),
   /**
    * Optional document description
    */
-  description: import_zod16.z.string().optional().describe("Document description"),
+  description: import_zod17.z.string().optional().describe("Document description"),
   /**
    * MIME type of the document
    */
-  fileType: import_zod16.z.string().describe("File MIME type"),
+  fileType: import_zod17.z.string().describe("File MIME type"),
   /**
    * File size in bytes
    */
-  fileSize: import_zod16.z.number().describe("File size in bytes"),
+  fileSize: import_zod17.z.number().describe("File size in bytes"),
   /**
    * Document category for organization
    */
-  category: import_zod16.z.string().optional().describe("Document category"),
+  category: import_zod17.z.string().optional().describe("Document category"),
   /**
    * Tags for searchability and organization
    */
-  tags: import_zod16.z.array(import_zod16.z.string()).optional().describe("Document tags"),
+  tags: import_zod17.z.array(import_zod17.z.string()).optional().describe("Document tags"),
   /**
    * Version control configuration
    */
-  versioning: import_zod16.z.object({
+  versioning: import_zod17.z.object({
     /**
      * Whether versioning is enabled
      */
-    enabled: import_zod16.z.boolean().describe("Versioning enabled"),
+    enabled: import_zod17.z.boolean().describe("Versioning enabled"),
     /**
      * List of all document versions
      */
-    versions: import_zod16.z.array(DocumentVersionSchema).describe("Version history"),
+    versions: import_zod17.z.array(DocumentVersionSchema).describe("Version history"),
     /**
      * Current major version number
      */
-    majorVersion: import_zod16.z.number().describe("Major version"),
+    majorVersion: import_zod17.z.number().describe("Major version"),
     /**
      * Current minor version number
      */
-    minorVersion: import_zod16.z.number().describe("Minor version")
+    minorVersion: import_zod17.z.number().describe("Minor version")
   }).optional().describe("Version control"),
   /**
    * Template configuration (if document is generated from template)
@@ -2528,65 +2628,65 @@ var DocumentSchema = import_zod16.z.object({
   /**
    * Access control settings
    */
-  access: import_zod16.z.object({
+  access: import_zod17.z.object({
     /**
      * Whether document is publicly accessible
      * @default false
      */
-    isPublic: import_zod16.z.boolean().optional().default(false).describe("Public access"),
+    isPublic: import_zod17.z.boolean().optional().default(false).describe("Public access"),
     /**
      * List of user/team IDs with access
      */
-    sharedWith: import_zod16.z.array(import_zod16.z.string()).optional().describe("Shared with"),
+    sharedWith: import_zod17.z.array(import_zod17.z.string()).optional().describe("Shared with"),
     /**
      * Timestamp when access expires (Unix milliseconds)
      */
-    expiresAt: import_zod16.z.number().optional().describe("Access expiration")
+    expiresAt: import_zod17.z.number().optional().describe("Access expiration")
   }).optional().describe("Access control"),
   /**
    * Custom metadata fields
    */
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.any()).optional().describe("Custom metadata")
+  metadata: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).optional().describe("Custom metadata")
 });
 
 // src/data/external-lookup.zod.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/shared/mapping.zod.ts
-var import_zod17 = require("zod");
-var TransformTypeSchema = import_zod17.z.discriminatedUnion("type", [
-  import_zod17.z.object({
-    type: import_zod17.z.literal("constant"),
-    value: import_zod17.z.any().describe("Constant value to use")
+var import_zod18 = require("zod");
+var TransformTypeSchema = import_zod18.z.discriminatedUnion("type", [
+  import_zod18.z.object({
+    type: import_zod18.z.literal("constant"),
+    value: import_zod18.z.any().describe("Constant value to use")
   }).describe("Set a constant value"),
-  import_zod17.z.object({
-    type: import_zod17.z.literal("cast"),
-    targetType: import_zod17.z.enum(["string", "number", "boolean", "date"]).describe("Target data type")
+  import_zod18.z.object({
+    type: import_zod18.z.literal("cast"),
+    targetType: import_zod18.z.enum(["string", "number", "boolean", "date"]).describe("Target data type")
   }).describe("Cast to a specific data type"),
-  import_zod17.z.object({
-    type: import_zod17.z.literal("lookup"),
-    table: import_zod17.z.string().describe("Lookup table name"),
-    keyField: import_zod17.z.string().describe("Field to match on"),
-    valueField: import_zod17.z.string().describe("Field to retrieve")
+  import_zod18.z.object({
+    type: import_zod18.z.literal("lookup"),
+    table: import_zod18.z.string().describe("Lookup table name"),
+    keyField: import_zod18.z.string().describe("Field to match on"),
+    valueField: import_zod18.z.string().describe("Field to retrieve")
   }).describe("Lookup value from another table"),
-  import_zod17.z.object({
-    type: import_zod17.z.literal("javascript"),
-    expression: import_zod17.z.string().describe('JavaScript expression (e.g., "value.toUpperCase()")')
+  import_zod18.z.object({
+    type: import_zod18.z.literal("javascript"),
+    expression: import_zod18.z.string().describe('JavaScript expression (e.g., "value.toUpperCase()")')
   }).describe("Custom JavaScript transformation"),
-  import_zod17.z.object({
-    type: import_zod17.z.literal("map"),
-    mappings: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).describe('Value mappings (e.g., {"Active": "active"})')
+  import_zod18.z.object({
+    type: import_zod18.z.literal("map"),
+    mappings: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).describe('Value mappings (e.g., {"Active": "active"})')
   }).describe("Map values using a dictionary")
 ]);
-var FieldMappingSchema2 = import_zod17.z.object({
+var FieldMappingSchema2 = import_zod18.z.object({
   /**
    * Source field name
    */
-  source: import_zod17.z.string().describe("Source field name"),
+  source: import_zod18.z.string().describe("Source field name"),
   /**
    * Target field name (should be snake_case for ObjectStack)
    */
-  target: import_zod17.z.string().describe("Target field name"),
+  target: import_zod18.z.string().describe("Target field name"),
   /**
    * Transformation to apply
    */
@@ -2594,58 +2694,58 @@ var FieldMappingSchema2 = import_zod17.z.object({
   /**
    * Default value if source is null/undefined
    */
-  defaultValue: import_zod17.z.any().optional().describe("Default if source is null/undefined")
+  defaultValue: import_zod18.z.any().optional().describe("Default if source is null/undefined")
 });
 
 // src/data/external-lookup.zod.ts
-var ExternalDataSourceSchema = import_zod18.z.object({
+var ExternalDataSourceSchema = import_zod19.z.object({
   /**
    * Unique identifier for the external data source
    */
-  id: import_zod18.z.string().describe("Data source ID"),
+  id: import_zod19.z.string().describe("Data source ID"),
   /**
    * Human-readable name of the data source
    */
-  name: import_zod18.z.string().describe("Data source name"),
+  name: import_zod19.z.string().describe("Data source name"),
   /**
    * Protocol type for connecting to the data source
    */
-  type: import_zod18.z.enum(["odata", "rest-api", "graphql", "custom"]).describe("Protocol type"),
+  type: import_zod19.z.enum(["odata", "rest-api", "graphql", "custom"]).describe("Protocol type"),
   /**
    * Base URL endpoint for the external system
    */
-  endpoint: import_zod18.z.string().url().describe("API endpoint URL"),
+  endpoint: import_zod19.z.string().url().describe("API endpoint URL"),
   /**
    * Authentication configuration
    */
-  authentication: import_zod18.z.object({
+  authentication: import_zod19.z.object({
     /**
      * Authentication method
      */
-    type: import_zod18.z.enum(["oauth2", "api-key", "basic", "none"]).describe("Auth type"),
+    type: import_zod19.z.enum(["oauth2", "api-key", "basic", "none"]).describe("Auth type"),
     /**
      * Authentication-specific configuration
      * Structure varies based on auth type
      */
-    config: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).describe("Auth configuration")
+    config: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.any()).describe("Auth configuration")
   }).describe("Authentication")
 });
 var ExternalFieldMappingSchema = FieldMappingSchema2.extend({
   /**
    * Field data type
    */
-  type: import_zod18.z.string().optional().describe("Field type"),
+  type: import_zod19.z.string().optional().describe("Field type"),
   /**
    * Whether the field is read-only
    * @default true
    */
-  readonly: import_zod18.z.boolean().optional().default(true).describe("Read-only field")
+  readonly: import_zod19.z.boolean().optional().default(true).describe("Read-only field")
 });
-var ExternalLookupSchema = import_zod18.z.object({
+var ExternalLookupSchema = import_zod19.z.object({
   /**
    * Name of the field that uses external lookup
    */
-  fieldName: import_zod18.z.string().describe("Field name"),
+  fieldName: import_zod19.z.string().describe("Field name"),
   /**
    * External data source configuration
    */
@@ -2653,137 +2753,137 @@ var ExternalLookupSchema = import_zod18.z.object({
   /**
    * Query configuration for fetching external data
    */
-  query: import_zod18.z.object({
+  query: import_zod19.z.object({
     /**
      * API endpoint path (relative to base endpoint)
      */
-    endpoint: import_zod18.z.string().describe("Query endpoint path"),
+    endpoint: import_zod19.z.string().describe("Query endpoint path"),
     /**
      * HTTP method for the query
      * @default 'GET'
      */
-    method: import_zod18.z.enum(["GET", "POST"]).optional().default("GET").describe("HTTP method"),
+    method: import_zod19.z.enum(["GET", "POST"]).optional().default("GET").describe("HTTP method"),
     /**
      * Query parameters or request body
      */
-    parameters: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).optional().describe("Query parameters")
+    parameters: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.any()).optional().describe("Query parameters")
   }).describe("Query configuration"),
   /**
    * Mapping between external and local fields
    */
-  fieldMappings: import_zod18.z.array(ExternalFieldMappingSchema).describe("Field mappings"),
+  fieldMappings: import_zod19.z.array(ExternalFieldMappingSchema).describe("Field mappings"),
   /**
    * Cache configuration for external data
    */
-  caching: import_zod18.z.object({
+  caching: import_zod19.z.object({
     /**
      * Whether caching is enabled
      * @default true
      */
-    enabled: import_zod18.z.boolean().optional().default(true).describe("Cache enabled"),
+    enabled: import_zod19.z.boolean().optional().default(true).describe("Cache enabled"),
     /**
      * Time-to-live in seconds
      * @default 300
      */
-    ttl: import_zod18.z.number().optional().default(300).describe("Cache TTL (seconds)"),
+    ttl: import_zod19.z.number().optional().default(300).describe("Cache TTL (seconds)"),
     /**
      * Cache eviction strategy
      * @default 'ttl'
      */
-    strategy: import_zod18.z.enum(["lru", "lfu", "ttl"]).optional().default("ttl").describe("Cache strategy")
+    strategy: import_zod19.z.enum(["lru", "lfu", "ttl"]).optional().default("ttl").describe("Cache strategy")
   }).optional().describe("Caching configuration"),
   /**
    * Fallback behavior when external system is unavailable
    */
-  fallback: import_zod18.z.object({
+  fallback: import_zod19.z.object({
     /**
      * Whether fallback is enabled
      * @default true
      */
-    enabled: import_zod18.z.boolean().optional().default(true).describe("Fallback enabled"),
+    enabled: import_zod19.z.boolean().optional().default(true).describe("Fallback enabled"),
     /**
      * Default value to use when external system fails
      */
-    defaultValue: import_zod18.z.any().optional().describe("Default fallback value"),
+    defaultValue: import_zod19.z.any().optional().describe("Default fallback value"),
     /**
      * Whether to show error message to user
      * @default true
      */
-    showError: import_zod18.z.boolean().optional().default(true).describe("Show error to user")
+    showError: import_zod19.z.boolean().optional().default(true).describe("Show error to user")
   }).optional().describe("Fallback configuration"),
   /**
    * Rate limiting to prevent overwhelming external system
    */
-  rateLimit: import_zod18.z.object({
+  rateLimit: import_zod19.z.object({
     /**
      * Maximum requests per second
      */
-    requestsPerSecond: import_zod18.z.number().describe("Requests per second limit"),
+    requestsPerSecond: import_zod19.z.number().describe("Requests per second limit"),
     /**
      * Burst size for handling spikes
      */
-    burstSize: import_zod18.z.number().optional().describe("Burst size")
+    burstSize: import_zod19.z.number().optional().describe("Burst size")
   }).optional().describe("Rate limiting")
 });
 
 // src/data/datasource.zod.ts
-var import_zod19 = require("zod");
-var DriverType = import_zod19.z.string().describe("Underlying driver identifier");
-var DriverDefinitionSchema = import_zod19.z.object({
-  id: import_zod19.z.string().describe('Unique driver identifier (e.g. "postgres")'),
-  label: import_zod19.z.string().describe('Display label (e.g. "PostgreSQL")'),
-  description: import_zod19.z.string().optional(),
-  icon: import_zod19.z.string().optional(),
+var import_zod20 = require("zod");
+var DriverType = import_zod20.z.string().describe("Underlying driver identifier");
+var DriverDefinitionSchema = import_zod20.z.object({
+  id: import_zod20.z.string().describe('Unique driver identifier (e.g. "postgres")'),
+  label: import_zod20.z.string().describe('Display label (e.g. "PostgreSQL")'),
+  description: import_zod20.z.string().optional(),
+  icon: import_zod20.z.string().optional(),
   /**
    * Configuration Schema (JSON Schema)
    * Describes the structure of the `config` object needed for this driver.
    * Used by the UI to generate the connection form.
    */
-  configSchema: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.any()).describe("JSON Schema for connection configuration"),
+  configSchema: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.any()).describe("JSON Schema for connection configuration"),
   /**
    * Default Capabilities
    * What this driver supports out-of-the-box.
    */
-  capabilities: import_zod19.z.lazy(() => DatasourceCapabilities).optional()
+  capabilities: import_zod20.z.lazy(() => DatasourceCapabilities).optional()
 });
-var DatasourceCapabilities = import_zod19.z.object({
+var DatasourceCapabilities = import_zod20.z.object({
   // ============================================================================
   // Transaction & Connection Management
   // ============================================================================
   /** Can handle ACID transactions? */
-  transactions: import_zod19.z.boolean().default(false),
+  transactions: import_zod20.z.boolean().default(false),
   // ============================================================================
   // Query Operations
   // ============================================================================
   /** Can execute WHERE clause filters natively? */
-  queryFilters: import_zod19.z.boolean().default(false),
+  queryFilters: import_zod20.z.boolean().default(false),
   /** Can perform aggregation (group by, sum, avg)? */
-  queryAggregations: import_zod19.z.boolean().default(false),
+  queryAggregations: import_zod20.z.boolean().default(false),
   /** Can perform ORDER BY sorting? */
-  querySorting: import_zod19.z.boolean().default(false),
+  querySorting: import_zod20.z.boolean().default(false),
   /** Can perform LIMIT/OFFSET pagination? */
-  queryPagination: import_zod19.z.boolean().default(false),
+  queryPagination: import_zod20.z.boolean().default(false),
   /** Can perform window functions? */
-  queryWindowFunctions: import_zod19.z.boolean().default(false),
+  queryWindowFunctions: import_zod20.z.boolean().default(false),
   /** Can perform subqueries? */
-  querySubqueries: import_zod19.z.boolean().default(false),
+  querySubqueries: import_zod20.z.boolean().default(false),
   /** Can execute SQL-like joins natively? */
-  joins: import_zod19.z.boolean().default(false),
+  joins: import_zod20.z.boolean().default(false),
   // ============================================================================
   // Advanced Features
   // ============================================================================
   /** Can perform full-text search? */
-  fullTextSearch: import_zod19.z.boolean().default(false),
+  fullTextSearch: import_zod20.z.boolean().default(false),
   /** Is read-only? */
-  readOnly: import_zod19.z.boolean().default(false),
+  readOnly: import_zod20.z.boolean().default(false),
   /** Is scheme-less (needs schema inference)? */
-  dynamicSchema: import_zod19.z.boolean().default(false)
+  dynamicSchema: import_zod20.z.boolean().default(false)
 });
-var DatasourceSchema = import_zod19.z.object({
+var DatasourceSchema = import_zod20.z.object({
   /** Machine Name */
-  name: import_zod19.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique datasource identifier"),
+  name: import_zod20.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique datasource identifier"),
   /** Human Label */
-  label: import_zod19.z.string().optional().describe("Display label"),
+  label: import_zod20.z.string().optional().describe("Display label"),
   /** Driver */
   driver: DriverType.describe("Underlying driver type"),
   /** 
@@ -2791,37 +2891,37 @@ var DatasourceSchema = import_zod19.z.object({
    * Specific to the driver (e.g., host, port, user, password, bucket, etc.)
    * Stored securely (passwords usually interpolated from ENV).
    */
-  config: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.any()).describe("Driver specific configuration"),
+  config: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.any()).describe("Driver specific configuration"),
   /**
    * Connection Pool Configuration
    * Standard connection pooling settings.
    */
-  pool: import_zod19.z.object({
-    min: import_zod19.z.number().default(0).describe("Minimum connections"),
-    max: import_zod19.z.number().default(10).describe("Maximum connections"),
-    idleTimeoutMillis: import_zod19.z.number().default(3e4).describe("Idle timeout"),
-    connectionTimeoutMillis: import_zod19.z.number().default(3e3).describe("Connection establishment timeout")
+  pool: import_zod20.z.object({
+    min: import_zod20.z.number().default(0).describe("Minimum connections"),
+    max: import_zod20.z.number().default(10).describe("Maximum connections"),
+    idleTimeoutMillis: import_zod20.z.number().default(3e4).describe("Idle timeout"),
+    connectionTimeoutMillis: import_zod20.z.number().default(3e3).describe("Connection establishment timeout")
   }).optional().describe("Connection pool settings"),
   /**
    * Read Replicas
    * Optional list of duplicate configurations for read-only operations.
    * Useful for scaling read throughput.
    */
-  readReplicas: import_zod19.z.array(import_zod19.z.record(import_zod19.z.string(), import_zod19.z.any())).optional().describe("Read-only replica configurations"),
+  readReplicas: import_zod20.z.array(import_zod20.z.record(import_zod20.z.string(), import_zod20.z.any())).optional().describe("Read-only replica configurations"),
   /**
    * Capability Overrides
    * Manually override what the driver claims to support.
    */
   capabilities: DatasourceCapabilities.optional().describe("Capability overrides"),
   /** Description */
-  description: import_zod19.z.string().optional().describe("Internal description"),
+  description: import_zod20.z.string().optional().describe("Internal description"),
   /** Is enabled? */
-  active: import_zod19.z.boolean().default(true).describe("Is datasource enabled")
+  active: import_zod20.z.boolean().default(true).describe("Is datasource enabled")
 });
 
 // src/data/analytics.zod.ts
-var import_zod20 = require("zod");
-var MetricType = import_zod20.z.enum([
+var import_zod21 = require("zod");
+var MetricType = import_zod21.z.enum([
   "count",
   "sum",
   "avg",
@@ -2835,14 +2935,14 @@ var MetricType = import_zod20.z.enum([
   "boolean"
   // Custom SQL expression returning a boolean
 ]);
-var DimensionType = import_zod20.z.enum([
+var DimensionType = import_zod21.z.enum([
   "string",
   "number",
   "boolean",
   "time",
   "geo"
 ]);
-var TimeUpdateInterval = import_zod20.z.enum([
+var TimeUpdateInterval = import_zod21.z.enum([
   "second",
   "minute",
   "hour",
@@ -2852,78 +2952,78 @@ var TimeUpdateInterval = import_zod20.z.enum([
   "quarter",
   "year"
 ]);
-var MetricSchema = import_zod20.z.object({
-  name: import_zod20.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique metric ID"),
-  label: import_zod20.z.string().describe("Human readable label"),
-  description: import_zod20.z.string().optional(),
+var MetricSchema = import_zod21.z.object({
+  name: import_zod21.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique metric ID"),
+  label: import_zod21.z.string().describe("Human readable label"),
+  description: import_zod21.z.string().optional(),
   type: MetricType,
   /** Source Calculation */
-  sql: import_zod20.z.string().describe("SQL expression or field reference"),
+  sql: import_zod21.z.string().describe("SQL expression or field reference"),
   /** Filtering for this specific metric (e.g. "Revenue from Premium Users") */
-  filters: import_zod20.z.array(import_zod20.z.object({
-    sql: import_zod20.z.string()
+  filters: import_zod21.z.array(import_zod21.z.object({
+    sql: import_zod21.z.string()
   })).optional(),
   /** Format for display (e.g. "currency", "percent") */
-  format: import_zod20.z.string().optional()
+  format: import_zod21.z.string().optional()
 });
-var DimensionSchema = import_zod20.z.object({
-  name: import_zod20.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique dimension ID"),
-  label: import_zod20.z.string().describe("Human readable label"),
-  description: import_zod20.z.string().optional(),
+var DimensionSchema = import_zod21.z.object({
+  name: import_zod21.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Unique dimension ID"),
+  label: import_zod21.z.string().describe("Human readable label"),
+  description: import_zod21.z.string().optional(),
   type: DimensionType,
   /** Source Column */
-  sql: import_zod20.z.string().describe("SQL expression or column reference"),
+  sql: import_zod21.z.string().describe("SQL expression or column reference"),
   /** For Time Dimensions: Supported Granularities */
-  granularities: import_zod20.z.array(TimeUpdateInterval).optional()
+  granularities: import_zod21.z.array(TimeUpdateInterval).optional()
 });
-var CubeJoinSchema = import_zod20.z.object({
-  name: import_zod20.z.string().describe("Target cube name"),
-  relationship: import_zod20.z.enum(["one_to_one", "one_to_many", "many_to_one"]).default("many_to_one"),
-  sql: import_zod20.z.string().describe("Join condition (ON clause)")
+var CubeJoinSchema = import_zod21.z.object({
+  name: import_zod21.z.string().describe("Target cube name"),
+  relationship: import_zod21.z.enum(["one_to_one", "one_to_many", "many_to_one"]).default("many_to_one"),
+  sql: import_zod21.z.string().describe("Join condition (ON clause)")
 });
-var CubeSchema = import_zod20.z.object({
-  name: import_zod20.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Cube name (snake_case)"),
-  title: import_zod20.z.string().optional(),
-  description: import_zod20.z.string().optional(),
+var CubeSchema = import_zod21.z.object({
+  name: import_zod21.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Cube name (snake_case)"),
+  title: import_zod21.z.string().optional(),
+  description: import_zod21.z.string().optional(),
   /** Physical Data Source */
-  sql: import_zod20.z.string().describe("Base SQL statement or Table Name"),
+  sql: import_zod21.z.string().describe("Base SQL statement or Table Name"),
   /** Semantic Definitions */
-  measures: import_zod20.z.record(import_zod20.z.string(), MetricSchema).describe("Quantitative metrics"),
-  dimensions: import_zod20.z.record(import_zod20.z.string(), DimensionSchema).describe("Qualitative attributes"),
+  measures: import_zod21.z.record(import_zod21.z.string(), MetricSchema).describe("Quantitative metrics"),
+  dimensions: import_zod21.z.record(import_zod21.z.string(), DimensionSchema).describe("Qualitative attributes"),
   /** Relationships */
-  joins: import_zod20.z.record(import_zod20.z.string(), CubeJoinSchema).optional(),
+  joins: import_zod21.z.record(import_zod21.z.string(), CubeJoinSchema).optional(),
   /** Pre-aggregations / Caching */
-  refreshKey: import_zod20.z.object({
-    every: import_zod20.z.string().optional(),
+  refreshKey: import_zod21.z.object({
+    every: import_zod21.z.string().optional(),
     // e.g. "1 hour"
-    sql: import_zod20.z.string().optional()
+    sql: import_zod21.z.string().optional()
     // SQL to check for data changes
   }).optional(),
   /** Access Control */
-  public: import_zod20.z.boolean().default(false)
-});
-var AnalyticsQuerySchema = import_zod20.z.object({
-  measures: import_zod20.z.array(import_zod20.z.string()).describe("List of metrics to calculate"),
-  dimensions: import_zod20.z.array(import_zod20.z.string()).optional().describe("List of dimensions to group by"),
-  filters: import_zod20.z.array(import_zod20.z.object({
-    member: import_zod20.z.string().describe("Dimension or Measure"),
-    operator: import_zod20.z.enum(["equals", "notEquals", "contains", "notContains", "gt", "gte", "lt", "lte", "set", "notSet", "inDateRange"]),
-    values: import_zod20.z.array(import_zod20.z.string()).optional()
+  public: import_zod21.z.boolean().default(false)
+});
+var AnalyticsQuerySchema = import_zod21.z.object({
+  measures: import_zod21.z.array(import_zod21.z.string()).describe("List of metrics to calculate"),
+  dimensions: import_zod21.z.array(import_zod21.z.string()).optional().describe("List of dimensions to group by"),
+  filters: import_zod21.z.array(import_zod21.z.object({
+    member: import_zod21.z.string().describe("Dimension or Measure"),
+    operator: import_zod21.z.enum(["equals", "notEquals", "contains", "notContains", "gt", "gte", "lt", "lte", "set", "notSet", "inDateRange"]),
+    values: import_zod21.z.array(import_zod21.z.string()).optional()
   })).optional(),
-  timeDimensions: import_zod20.z.array(import_zod20.z.object({
-    dimension: import_zod20.z.string(),
+  timeDimensions: import_zod21.z.array(import_zod21.z.object({
+    dimension: import_zod21.z.string(),
     granularity: TimeUpdateInterval.optional(),
-    dateRange: import_zod20.z.union([
-      import_zod20.z.string(),
+    dateRange: import_zod21.z.union([
+      import_zod21.z.string(),
       // "Last 7 days"
-      import_zod20.z.array(import_zod20.z.string())
+      import_zod21.z.array(import_zod21.z.string())
       // ["2023-01-01", "2023-01-31"]
     ]).optional()
   })).optional(),
-  order: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.enum(["asc", "desc"])).optional(),
-  limit: import_zod20.z.number().optional(),
-  offset: import_zod20.z.number().optional(),
-  timezone: import_zod20.z.string().default("UTC")
+  order: import_zod21.z.record(import_zod21.z.string(), import_zod21.z.enum(["asc", "desc"])).optional(),
+  limit: import_zod21.z.number().optional(),
+  offset: import_zod21.z.number().optional(),
+  timezone: import_zod21.z.string().default("UTC")
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -3025,6 +3125,8 @@ var AnalyticsQuerySchema = import_zod20.z.object({
   NoSQLTransactionOptionsSchema,
   NormalizedFilterSchema,
   ObjectCapabilities,
+  ObjectExtensionSchema,
+  ObjectOwnershipEnum,
   ObjectSchema,
   PartitioningConfigSchema,
   PoolConfigSchema,